From 8ec45fc51ed01094108d395976c83406417970b1 Mon Sep 17 00:00:00 2001
From: "noe.izquierdo" <noe.izquierdo@openpyme.mx>
Date: Tue, 26 Mar 2024 10:44:11 -0600
Subject: [PATCH 01/19] =?UTF-8?q?feat(account.payment):=20se=20corrigen=20?=
=?UTF-8?q?errores=20para=20la=20validaci=C3=B3n=20de=20pagos?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
l10n_mx_facturae/models/account_payment.py | 19 +++++--------------
1 file changed, 5 insertions(+), 14 deletions(-)
diff --git a/l10n_mx_facturae/models/account_payment.py b/l10n_mx_facturae/models/account_payment.py
index 9c6646fd93..d43314d24f 100644
--- a/l10n_mx_facturae/models/account_payment.py
+++ b/l10n_mx_facturae/models/account_payment.py
@@ -154,18 +154,9 @@ class AccountPayment(models.Model):
or will use the default behavior"""
self.ensure_one()
# We need to give the date in the context to get proper rate
- voucher_currency = self.journal_id.currency or self.company_id.currency_id
+ voucher_currency = self.journal_id.currency_id or self.company_id.currency_id
voucher_currency = voucher_currency.with_context(date=self.date)
- voucher_currency = voucher_currency.with_context(
- special_currency_rate=(
- voucher_currency.rate * self.payment_rate
- ),
- special_currency=(
- self.payment_rate_currency_id
- and self.payment_rate_currency_id.id
- or False
- ),
- )
+
res = float_round(
voucher_currency.compute(1.0, self.company_id.currency_id, round=False),
precision_digits=6,
@@ -300,12 +291,12 @@ class AccountPayment(models.Model):
if invoice.currency_id == company_currency:
# When invoice is in company currency we are going to use payment rate
voucher_currency = voucher_currency.with_context(
- special_currency_rate=(1 / self.payment_rate),
+ special_currency_rate=(1 / voucher_currency.rate),
special_currency=voucher_currency.id,
)
else:
voucher_currency = voucher_currency.with_context(
- special_currency_rate=(1 / invoice.currency_rate),
+ special_currency_rate=(1 / invoice.currency_id.rate),
special_currency=invoice.currency_id.id,
)
@@ -404,7 +395,7 @@ class AccountPayment(models.Model):
special_currency=voucher_currency.id,
)
tax_base = invoice_currency.compute(
- tax_move.tax_base, voucher_currency, round=False,
+ tax_move.tax_base_amount, voucher_currency, round=False,
)
# Force rounding 6 decimals to use as many decimal as possible and
# avoid rounding errors when validating XML
--
GitLab
From b992efa470dcd9d29ccdae5cb09a1896ef537b45 Mon Sep 17 00:00:00 2001
From: "noe.izquierdo" <noe.izquierdo@openpyme.mx>
Date: Tue, 26 Mar 2024 16:09:48 -0600
Subject: [PATCH 02/19] =?UTF-8?q?feat(account.move):=20se=20mejora=20la=20?=
=?UTF-8?q?precisi=C3=B3n=20decimal=20y=20se=20generaliza=20en=20parser=20?=
=?UTF-8?q?funci=C3=B3n=20format=5Ffloat?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
l10n_mx_facturae/data/account_move.xml | 4 +--
l10n_mx_facturae/data/account_payment.xml | 4 +--
.../data/ir_attachment_facturae_config.xml | 4 +--
l10n_mx_facturae/report/__init__.py | 1 +
l10n_mx_facturae/report/account_move.py | 22 ++++++++++++
l10n_mx_facturae/report/account_payment.py | 34 +++++++++----------
l10n_mx_facturae/templates/account_move.xml | 8 ++---
.../templates/account_payment.xml | 4 +--
8 files changed, 51 insertions(+), 30 deletions(-)
create mode 100644 l10n_mx_facturae/report/account_move.py
diff --git a/l10n_mx_facturae/data/account_move.xml b/l10n_mx_facturae/data/account_move.xml
index 47fabd6217..4b2fd495bf 100644
--- a/l10n_mx_facturae/data/account_move.xml
+++ b/l10n_mx_facturae/data/account_move.xml
@@ -6,7 +6,7 @@
<field name="name">Account Move CFDI XML</field>
<field name="model">account.move</field>
<field name="report_type">qweb-xml</field>
- <field name="report_name">l10n_mx_facturae.account_move_template_cfdi_xml</field>
+ <field name="report_name">l10n_mx_facturae.account_move</field>
<field name="xml_declaration">true</field>
<field name="xsd_schema"><?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:cfdi="http://www.sat.gob.mx/cfd/4" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:catCFDI="http://www.sat.gob.mx/sitio_internet/cfd/catalogos" xmlns:tdCFDI="http://www.sat.gob.mx/sitio_internet/cfd/tipoDatos/tdCFDI" targetNamespace="http://www.sat.gob.mx/cfd/4" elementFormDefault="qualified" attributeFormDefault="unqualified">
	<xs:import namespace="http://www.sat.gob.mx/sitio_internet/cfd/catalogos" schemaLocation="http://www.sat.gob.mx/sitio_internet/cfd/catalogos/catCFDI.xsd"/>
	<xs:import namespace="http://www.sat.gob.mx/sitio_internet/cfd/tipoDatos/tdCFDI" schemaLocation="http://www.sat.gob.mx/sitio_internet/cfd/tipoDatos/tdCFDI/tdCFDI.xsd"/>
	<xs:element name="Comprobante">
		<xs:annotation>
			<xs:documentation>Estándar de Comprobante Fiscal Digital por Internet.</xs:documentation>
		</xs:annotation>
		<xs:complexType>
			<xs:sequence>
				<xs:element name="InformacionGlobal" minOccurs="0">
					<xs:annotation>
						<xs:documentation>Nodo condicional para precisar la información relacionada con el comprobante global.</xs:documentation>
					</xs:annotation>
					<xs:complexType>
						<xs:attribute name="Periodicidad" type="catCFDI:c_Periodicidad" use="required">
							<xs:annotation>
								<xs:documentation>Atributo requerido para expresar el período al que corresponde la información del comprobante global.</xs:documentation>
							</xs:annotation>
						</xs:attribute>
						<xs:attribute name="Meses" type="catCFDI:c_Meses" use="required">
							<xs:annotation>
								<xs:documentation>Atributo requerido para expresar el mes o los meses al que corresponde la información del comprobante global.</xs:documentation>
							</xs:annotation>
						</xs:attribute>
						<xs:attribute name="Año" use="required">
							<xs:annotation>
								<xs:documentation>Atributo requerido para expresar el año al que corresponde la información del comprobante global.</xs:documentation>
							</xs:annotation>
							<xs:simpleType>
								<xs:restriction base="xs:short">
									<xs:minInclusive value="2021"/>
									<xs:whiteSpace value="collapse"/>
								</xs:restriction>
							</xs:simpleType>
						</xs:attribute>
					</xs:complexType>
				</xs:element>
				<xs:element name="CfdiRelacionados" minOccurs="0" maxOccurs="unbounded">
					<xs:annotation>
						<xs:documentation>Nodo opcional para precisar la información de los comprobantes relacionados.</xs:documentation>
					</xs:annotation>
					<xs:complexType>
						<xs:sequence>
							<xs:element name="CfdiRelacionado" maxOccurs="unbounded">
								<xs:annotation>
									<xs:documentation>Nodo requerido para precisar la información de los comprobantes relacionados.</xs:documentation>
								</xs:annotation>
								<xs:complexType>
									<xs:attribute name="UUID" use="required">
										<xs:annotation>
											<xs:documentation>Atributo requerido para registrar el folio fiscal (UUID) de un CFDI relacionado con el presente comprobante, por ejemplo: Si el CFDI relacionado es un comprobante de traslado que sirve para registrar el movimiento de la mercancía. Si este comprobante se usa como nota de crédito o nota de débito del comprobante relacionado. Si este comprobante es una devolución sobre el comprobante relacionado. Si éste sustituye a una factura cancelada.</xs:documentation>
										</xs:annotation>
										<xs:simpleType>
											<xs:restriction base="xs:string">
												<xs:length value="36"/>
												<xs:whiteSpace value="collapse"/>
												<xs:pattern value="[a-f0-9A-F]{8}-[a-f0-9A-F]{4}-[a-f0-9A-F]{4}-[a-f0-9A-F]{4}-[a-f0-9A-F]{12}"/>
											</xs:restriction>
										</xs:simpleType>
									</xs:attribute>
								</xs:complexType>
							</xs:element>
						</xs:sequence>
						<xs:attribute name="TipoRelacion" type="catCFDI:c_TipoRelacion" use="required">
							<xs:annotation>
								<xs:documentation>Atributo requerido para indicar la clave de la relación que existe entre éste que se está generando y el o los CFDI previos.</xs:documentation>
							</xs:annotation>
						</xs:attribute>
					</xs:complexType>
				</xs:element>
				<xs:element name="Emisor">
					<xs:annotation>
						<xs:documentation>Nodo requerido para expresar la información del contribuyente emisor del comprobante.</xs:documentation>
					</xs:annotation>
					<xs:complexType>
						<xs:attribute name="Rfc" type="tdCFDI:t_RFC" use="required">
							<xs:annotation>
								<xs:documentation>Atributo requerido para registrar la Clave del Registro Federal de Contribuyentes correspondiente al contribuyente emisor del comprobante.</xs:documentation>
							</xs:annotation>
						</xs:attribute>
						<xs:attribute name="Nombre" use="required">
							<xs:annotation>
								<xs:documentation>Atributo requerido para registrar el nombre, denominación o razón social del contribuyente inscrito en el RFC, del emisor del comprobante.</xs:documentation>
							</xs:annotation>
							<xs:simpleType>
								<xs:restriction base="xs:string">
									<xs:minLength value="1"/>
									<xs:maxLength value="300"/>
									<xs:whiteSpace value="collapse"/>
									<xs:pattern value="[^|]{1,300}"/>
								</xs:restriction>
							</xs:simpleType>
						</xs:attribute>
						<xs:attribute name="RegimenFiscal" type="catCFDI:c_RegimenFiscal" use="required">
							<xs:annotation>
								<xs:documentation>Atributo requerido para incorporar la clave del régimen del contribuyente emisor al que aplicará el efecto fiscal de este comprobante.</xs:documentation>
							</xs:annotation>
						</xs:attribute>
						<xs:attribute name="FacAtrAdquirente" use="optional">
							<xs:annotation>
								<xs:documentation>Atributo condicional para expresar el número de operación proporcionado por el SAT cuando se trate de un comprobante a través de un PCECFDI o un PCGCFDISP.</xs:documentation>
							</xs:annotation>
							<xs:simpleType>
								<xs:restriction base="xs:string">
									<xs:whiteSpace value="collapse"/>
									<xs:length value="10"/>
									<xs:pattern value="[0-9]{10}"/>
								</xs:restriction>
							</xs:simpleType>
						</xs:attribute>
					</xs:complexType>
				</xs:element>
				<xs:element name="Receptor">
					<xs:annotation>
						<xs:documentation>Nodo requerido para precisar la información del contribuyente receptor del comprobante.</xs:documentation>
					</xs:annotation>
					<xs:complexType>
						<xs:attribute name="Rfc" type="tdCFDI:t_RFC" use="required">
							<xs:annotation>
								<xs:documentation>Atributo requerido para registrar la Clave del Registro Federal de Contribuyentes correspondiente al contribuyente receptor del comprobante.</xs:documentation>
							</xs:annotation>
						</xs:attribute>
						<xs:attribute name="Nombre" use="required">
							<xs:annotation>
								<xs:documentation>Atributo requerido para registrar el nombre(s), primer apellido, segundo apellido, según corresponda, denominación o razón social del contribuyente, inscrito en el RFC, del receptor del comprobante.</xs:documentation>
							</xs:annotation>
							<xs:simpleType>
								<xs:restriction base="xs:string">
									<xs:minLength value="1"/>
									<xs:maxLength value="300"/>
									<xs:whiteSpace value="collapse"/>
									<xs:pattern value="[^|]{1,300}"/>
								</xs:restriction>
							</xs:simpleType>
						</xs:attribute>
						<xs:attribute name="DomicilioFiscalReceptor" use="required">
							<xs:annotation>
								<xs:documentation>Atributo requerido para registrar el código postal del domicilio fiscal del receptor del comprobante.</xs:documentation>
							</xs:annotation>
							<xs:simpleType>
								<xs:restriction base="xs:string">
									<xs:length value="5"/>
									<xs:whiteSpace value="collapse"/>
									<xs:pattern value="[0-9]{5}"/>
								</xs:restriction>
							</xs:simpleType>
						</xs:attribute>
						<xs:attribute name="ResidenciaFiscal" type="catCFDI:c_Pais" use="optional">
							<xs:annotation>
								<xs:documentation>Atributo condicional para registrar la clave del país de residencia para efectos fiscales del receptor del comprobante, cuando se trate de un extranjero, y que es conforme con la especificación ISO 3166-1 alpha-3. Es requerido cuando se incluya el complemento de comercio exterior o se registre el atributo NumRegIdTrib.</xs:documentation>
							</xs:annotation>
						</xs:attribute>
						<xs:attribute name="NumRegIdTrib" use="optional">
							<xs:annotation>
								<xs:documentation>Atributo condicional para expresar el número de registro de identidad fiscal del receptor cuando sea residente en el extranjero. Es requerido cuando se incluya el complemento de comercio exterior.</xs:documentation>
							</xs:annotation>
							<xs:simpleType>
								<xs:restriction base="xs:string">
									<xs:minLength value="1"/>
									<xs:maxLength value="40"/>
									<xs:whiteSpace value="collapse"/>
								</xs:restriction>
							</xs:simpleType>
						</xs:attribute>
						<xs:attribute name="RegimenFiscalReceptor" type="catCFDI:c_RegimenFiscal" use="required">
							<xs:annotation>
								<xs:documentation>Atributo requerido para incorporar la clave del régimen fiscal del contribuyente receptor al que aplicará el efecto fiscal de este comprobante.</xs:documentation>
							</xs:annotation>
						</xs:attribute>
						<xs:attribute name="UsoCFDI" type="catCFDI:c_UsoCFDI" use="required">
							<xs:annotation>
								<xs:documentation>Atributo requerido para expresar la clave del uso que dará a esta factura el receptor del CFDI.</xs:documentation>
							</xs:annotation>
						</xs:attribute>
					</xs:complexType>
				</xs:element>
				<xs:element name="Conceptos">
					<xs:annotation>
						<xs:documentation>Nodo requerido para listar los conceptos cubiertos por el comprobante.</xs:documentation>
					</xs:annotation>
					<xs:complexType>
						<xs:sequence>
							<xs:element name="Concepto" maxOccurs="unbounded">
								<xs:annotation>
									<xs:documentation>Nodo requerido para registrar la información detallada de un bien o servicio amparado en el comprobante.</xs:documentation>
								</xs:annotation>
								<xs:complexType>
									<xs:sequence>
										<xs:element name="Impuestos" minOccurs="0">
											<xs:annotation>
												<xs:documentation>Nodo condicional para capturar los impuestos aplicables al presente concepto.</xs:documentation>
											</xs:annotation>
											<xs:complexType>
												<xs:sequence>
													<xs:element name="Traslados" minOccurs="0">
														<xs:annotation>
															<xs:documentation>Nodo opcional para asentar los impuestos trasladados aplicables al presente concepto.</xs:documentation>
														</xs:annotation>
														<xs:complexType>
															<xs:sequence>
																<xs:element name="Traslado" maxOccurs="unbounded">
																	<xs:annotation>
																		<xs:documentation>Nodo requerido para asentar la información detallada de un traslado de impuestos aplicable al presente concepto.</xs:documentation>
																	</xs:annotation>
																	<xs:complexType>
																		<xs:attribute name="Base" use="required">
																			<xs:annotation>
																				<xs:documentation>Atributo requerido para señalar la base para el cálculo del impuesto, la determinación de la base se realiza de acuerdo con las disposiciones fiscales vigentes. No se permiten valores negativos.</xs:documentation>
																			</xs:annotation>
																			<xs:simpleType>
																				<xs:restriction base="xs:decimal">
																					<xs:fractionDigits value="6"/>
																					<xs:minInclusive value="0.000001"/>
																					<xs:whiteSpace value="collapse"/>
																				</xs:restriction>
																			</xs:simpleType>
																		</xs:attribute>
																		<xs:attribute name="Impuesto" type="catCFDI:c_Impuesto" use="required">
																			<xs:annotation>
																				<xs:documentation>Atributo requerido para señalar la clave del tipo de impuesto trasladado aplicable al concepto.</xs:documentation>
																			</xs:annotation>
																		</xs:attribute>
																		<xs:attribute name="TipoFactor" type="catCFDI:c_TipoFactor" use="required">
																			<xs:annotation>
																				<xs:documentation>Atributo requerido para señalar la clave del tipo de factor que se aplica a la base del impuesto.</xs:documentation>
																			</xs:annotation>
																		</xs:attribute>
																		<xs:attribute name="TasaOCuota" use="optional">
																			<xs:annotation>
																				<xs:documentation>Atributo condicional para señalar el valor de la tasa o cuota del impuesto que se traslada para el presente concepto. Es requerido cuando el atributo TipoFactor tenga una clave que corresponda a Tasa o Cuota.</xs:documentation>
																			</xs:annotation>
																			<xs:simpleType>
																				<xs:restriction base="xs:decimal">
																					<xs:fractionDigits value="6"/>
																					<xs:minInclusive value="0.000000"/>
																					<xs:whiteSpace value="collapse"/>
																				</xs:restriction>
																			</xs:simpleType>
																		</xs:attribute>
																		<xs:attribute name="Importe" type="tdCFDI:t_Importe" use="optional">
																			<xs:annotation>
																				<xs:documentation>Atributo condicional para señalar el importe del impuesto trasladado que aplica al concepto. No se permiten valores negativos. Es requerido cuando TipoFactor sea Tasa o Cuota.</xs:documentation>
																			</xs:annotation>
																		</xs:attribute>
																	</xs:complexType>
																</xs:element>
															</xs:sequence>
														</xs:complexType>
													</xs:element>
													<xs:element name="Retenciones" minOccurs="0">
														<xs:annotation>
															<xs:documentation>Nodo opcional para asentar los impuestos retenidos aplicables al presente concepto.</xs:documentation>
														</xs:annotation>
														<xs:complexType>
															<xs:sequence>
																<xs:element name="Retencion" maxOccurs="unbounded">
																	<xs:annotation>
																		<xs:documentation>Nodo requerido para asentar la información detallada de una retención de impuestos aplicable al presente concepto.</xs:documentation>
																	</xs:annotation>
																	<xs:complexType>
																		<xs:attribute name="Base" use="required">
																			<xs:annotation>
																				<xs:documentation>Atributo requerido para señalar la base para el cálculo de la retención, la determinación de la base se realiza de acuerdo con las disposiciones fiscales vigentes. No se permiten valores negativos.</xs:documentation>
																			</xs:annotation>
																			<xs:simpleType>
																				<xs:restriction base="xs:decimal">
																					<xs:fractionDigits value="6"/>
																					<xs:minInclusive value="0.000001"/>
																					<xs:whiteSpace value="collapse"/>
																				</xs:restriction>
																			</xs:simpleType>
																		</xs:attribute>
																		<xs:attribute name="Impuesto" type="catCFDI:c_Impuesto" use="required">
																			<xs:annotation>
																				<xs:documentation>Atributo requerido para señalar la clave del tipo de impuesto retenido aplicable al concepto.</xs:documentation>
																			</xs:annotation>
																		</xs:attribute>
																		<xs:attribute name="TipoFactor" type="catCFDI:c_TipoFactor" use="required">
																			<xs:annotation>
																				<xs:documentation>Atributo requerido para señalar la clave del tipo de factor que se aplica a la base del impuesto.</xs:documentation>
																			</xs:annotation>
																		</xs:attribute>
																		<xs:attribute name="TasaOCuota" use="required">
																			<xs:annotation>
																				<xs:documentation>Atributo requerido para señalar la tasa o cuota del impuesto que se retiene para el presente concepto.</xs:documentation>
																			</xs:annotation>
																			<xs:simpleType>
																				<xs:restriction base="xs:decimal">
																					<xs:whiteSpace value="collapse"/>
																					<xs:minInclusive value="0.000000"/>
																					<xs:fractionDigits value="6"/>
																				</xs:restriction>
																			</xs:simpleType>
																		</xs:attribute>
																		<xs:attribute name="Importe" type="tdCFDI:t_Importe" use="required">
																			<xs:annotation>
																				<xs:documentation>Atributo requerido para señalar el importe del impuesto retenido que aplica al concepto. No se permiten valores negativos.</xs:documentation>
																			</xs:annotation>
																		</xs:attribute>
																	</xs:complexType>
																</xs:element>
															</xs:sequence>
														</xs:complexType>
													</xs:element>
												</xs:sequence>
											</xs:complexType>
										</xs:element>
										<xs:element name="ACuentaTerceros" minOccurs="0">
											<xs:annotation>
												<xs:documentation>Nodo opcional para registrar información del contribuyente Tercero, a cuenta del que se realiza la operación.</xs:documentation>
											</xs:annotation>
											<xs:complexType>
												<xs:attribute name="RfcACuentaTerceros" type="tdCFDI:t_RFC" use="required">
													<xs:annotation>
														<xs:documentation>Atributo requerido para registrar la Clave del Registro Federal de Contribuyentes del contribuyente Tercero, a cuenta del que se realiza la operación.</xs:documentation>
													</xs:annotation>
												</xs:attribute>
												<xs:attribute name="NombreACuentaTerceros" use="required">
													<xs:annotation>
														<xs:documentation>Atributo requerido para registrar el nombre, denominación o razón social del contribuyente Tercero correspondiente con el Rfc, a cuenta del que se realiza la operación.</xs:documentation>
													</xs:annotation>
													<xs:simpleType>
														<xs:restriction base="xs:string">
															<xs:minLength value="1"/>
															<xs:maxLength value="300"/>
															<xs:whiteSpace value="collapse"/>
															<xs:pattern value="[^|]{1,300}"/>
														</xs:restriction>
													</xs:simpleType>
												</xs:attribute>
												<xs:attribute name="RegimenFiscalACuentaTerceros" type="catCFDI:c_RegimenFiscal" use="required">
													<xs:annotation>
														<xs:documentation>Atributo requerido para incorporar la clave del régimen del contribuyente Tercero, a cuenta del que se realiza la operación.</xs:documentation>
													</xs:annotation>
												</xs:attribute>
												<xs:attribute name="DomicilioFiscalACuentaTerceros" use="required">
													<xs:annotation>
														<xs:documentation>Atributo requerido para incorporar el código postal del domicilio fiscal del Tercero, a cuenta del que se realiza la operación.</xs:documentation>
													</xs:annotation>
													<xs:simpleType>
														<xs:restriction base="xs:string">
															<xs:length value="5"/>
															<xs:whiteSpace value="collapse"/>
															<xs:pattern value="[0-9]{5}"/>
														</xs:restriction>
													</xs:simpleType>
												</xs:attribute>
											</xs:complexType>
										</xs:element>
										<xs:element name="InformacionAduanera" minOccurs="0" maxOccurs="unbounded">
											<xs:annotation>
												<xs:documentation>Nodo opcional para introducir la información aduanera aplicable cuando se trate de ventas de primera mano de mercancías importadas o se trate de operaciones de comercio exterior con bienes o servicios.</xs:documentation>
											</xs:annotation>
											<xs:complexType>
												<xs:attribute name="NumeroPedimento" use="required">
													<xs:annotation>
														<xs:documentation>Atributo requerido para expresar el número del pedimento que ampara la importación del bien que se expresa en el siguiente formato: últimos 2 dígitos del año de validación seguidos por dos espacios, 2 dígitos de la aduana de despacho seguidos por dos espacios, 4 dígitos del número de la patente seguidos por dos espacios, 1 dígito que corresponde al último dígito del año en curso, salvo que se trate de un pedimento consolidado iniciado en el año inmediato anterior o del pedimento original de una rectificación, seguido de 6 dígitos de la numeración progresiva por aduana.</xs:documentation>
													</xs:annotation>
													<xs:simpleType>
														<xs:restriction base="xs:string">
															<xs:length value="21"/>
															<xs:pattern value="[0-9]{2}  [0-9]{2}  [0-9]{4}  [0-9]{7}"/>
														</xs:restriction>
													</xs:simpleType>
												</xs:attribute>
											</xs:complexType>
										</xs:element>
										<xs:element name="CuentaPredial" minOccurs="0" maxOccurs="unbounded">
											<xs:annotation>
												<xs:documentation>Nodo opcional para asentar el número de cuenta predial con el que fue registrado el inmueble, en el sistema catastral de la entidad federativa de que trate, o bien para incorporar los datos de identificación del certificado de participación inmobiliaria no amortizable.</xs:documentation>
											</xs:annotation>
											<xs:complexType>
												<xs:attribute name="Numero" use="required">
													<xs:annotation>
														<xs:documentation>Atributo requerido para precisar el número de la cuenta predial del inmueble cubierto por el presente concepto, o bien para incorporar los datos de identificación del certificado de participación inmobiliaria no amortizable, tratándose de arrendamiento.</xs:documentation>
													</xs:annotation>
													<xs:simpleType>
														<xs:restriction base="xs:string">
															<xs:minLength value="1"/>
															<xs:maxLength value="150"/>
															<xs:whiteSpace value="collapse"/>
															<xs:pattern value="[0-9a-zA-Z]{1,150}"/>
														</xs:restriction>
													</xs:simpleType>
												</xs:attribute>
											</xs:complexType>
										</xs:element>
										<xs:element name="ComplementoConcepto" minOccurs="0">
											<xs:annotation>
												<xs:documentation>Nodo opcional donde se incluyen los nodos complementarios de extensión al concepto definidos por el SAT, de acuerdo con las disposiciones particulares para un sector o actividad específica.</xs:documentation>
											</xs:annotation>
											<xs:complexType>
												<xs:sequence>
													<xs:any maxOccurs="unbounded"/>
												</xs:sequence>
											</xs:complexType>
										</xs:element>
										<xs:element name="Parte" minOccurs="0" maxOccurs="unbounded">
											<xs:annotation>
												<xs:documentation>Nodo opcional para expresar las partes o componentes que integran la totalidad del concepto expresado en el comprobante fiscal digital por Internet.</xs:documentation>
											</xs:annotation>
											<xs:complexType>
												<xs:sequence>
													<xs:element name="InformacionAduanera" minOccurs="0" maxOccurs="unbounded">
														<xs:annotation>
															<xs:documentation>Nodo opcional para introducir la información aduanera aplicable cuando se trate de ventas de primera mano de mercancías importadas o se trate de operaciones de comercio exterior con bienes o servicios.</xs:documentation>
														</xs:annotation>
														<xs:complexType>
															<xs:attribute name="NumeroPedimento" use="required">
																<xs:annotation>
																	<xs:documentation>Atributo requerido para expresar el número del pedimento que ampara la importación del bien que se expresa en el siguiente formato: últimos 2 dígitos del año de validación seguidos por dos espacios, 2 dígitos de la aduana de despacho seguidos por dos espacios, 4 dígitos del número de la patente seguidos por dos espacios, 1 dígito que corresponde al último dígito del año en curso, salvo que se trate de un pedimento consolidado iniciado en el año inmediato anterior o del pedimento original de una rectificación, seguido de 6 dígitos de la numeración progresiva por aduana.</xs:documentation>
																</xs:annotation>
																<xs:simpleType>
																	<xs:restriction base="xs:string">
																		<xs:length value="21"/>
																		<xs:pattern value="[0-9]{2}  [0-9]{2}  [0-9]{4}  [0-9]{7}"/>
																	</xs:restriction>
																</xs:simpleType>
															</xs:attribute>
														</xs:complexType>
													</xs:element>
												</xs:sequence>
												<xs:attribute name="ClaveProdServ" type="catCFDI:c_ClaveProdServ" use="required">
													<xs:annotation>
														<xs:documentation>Atributo requerido para expresar la clave del producto o del servicio amparado por la presente parte. Es requerido y deben utilizar las claves del catálogo de productos y servicios, cuando los conceptos que registren por sus actividades correspondan con dichos conceptos.</xs:documentation>
													</xs:annotation>
												</xs:attribute>
												<xs:attribute name="NoIdentificacion" use="optional">
													<xs:annotation>
														<xs:documentation>Atributo opcional para expresar el número de serie, número de parte del bien o identificador del producto o del servicio amparado por la presente parte. Opcionalmente se puede utilizar claves del estándar GTIN.</xs:documentation>
													</xs:annotation>
													<xs:simpleType>
														<xs:restriction base="xs:string">
															<xs:minLength value="1"/>
															<xs:maxLength value="100"/>
															<xs:whiteSpace value="collapse"/>
															<xs:pattern value="[^|]{1,100}"/>
														</xs:restriction>
													</xs:simpleType>
												</xs:attribute>
												<xs:attribute name="Cantidad" use="required">
													<xs:annotation>
														<xs:documentation>Atributo requerido para precisar la cantidad de bienes o servicios del tipo particular definido por la presente parte.</xs:documentation>
													</xs:annotation>
													<xs:simpleType>
														<xs:restriction base="xs:decimal">
															<xs:fractionDigits value="6"/>
															<xs:minInclusive value="0.000001"/>
															<xs:whiteSpace value="collapse"/>
														</xs:restriction>
													</xs:simpleType>
												</xs:attribute>
												<xs:attribute name="Unidad" use="optional">
													<xs:annotation>
														<xs:documentation>Atributo opcional para precisar la unidad de medida propia de la operación del emisor, aplicable para la cantidad expresada en la parte. La unidad debe corresponder con la descripción de la parte. </xs:documentation>
													</xs:annotation>
													<xs:simpleType>
														<xs:restriction base="xs:string">
															<xs:minLength value="1"/>
															<xs:maxLength value="20"/>
															<xs:whiteSpace value="collapse"/>
															<xs:pattern value="[^|]{1,20}"/>
														</xs:restriction>
													</xs:simpleType>
												</xs:attribute>
												<xs:attribute name="Descripcion" use="required">
													<xs:annotation>
														<xs:documentation>Atributo requerido para precisar la descripción del bien o servicio cubierto por la presente parte.</xs:documentation>
													</xs:annotation>
													<xs:simpleType>
														<xs:restriction base="xs:string">
															<xs:minLength value="1"/>
															<xs:maxLength value="1000"/>
															<xs:whiteSpace value="collapse"/>
															<xs:pattern value="[^|]{1,1000}"/>
														</xs:restriction>
													</xs:simpleType>
												</xs:attribute>
												<xs:attribute name="ValorUnitario" type="tdCFDI:t_Importe" use="optional">
													<xs:annotation>
														<xs:documentation>Atributo opcional para precisar el valor o precio unitario del bien o servicio cubierto por la presente parte. No se permiten valores negativos.</xs:documentation>
													</xs:annotation>
												</xs:attribute>
												<xs:attribute name="Importe" type="tdCFDI:t_Importe" use="optional">
													<xs:annotation>
														<xs:documentation>Atributo opcional para precisar el importe total de los bienes o servicios de la presente parte. Debe ser equivalente al resultado de multiplicar la cantidad por el valor unitario expresado en la parte. No se permiten valores negativos.</xs:documentation>
													</xs:annotation>
												</xs:attribute>
											</xs:complexType>
										</xs:element>
									</xs:sequence>
									<xs:attribute name="ClaveProdServ" type="catCFDI:c_ClaveProdServ" use="required">
										<xs:annotation>
											<xs:documentation>Atributo requerido para expresar la clave del producto o del servicio amparado por el presente concepto. Es requerido y deben utilizar las claves del catálogo de productos y servicios, cuando los conceptos que registren por sus actividades correspondan con dichos conceptos.</xs:documentation>
										</xs:annotation>
									</xs:attribute>
									<xs:attribute name="NoIdentificacion" use="optional">
										<xs:annotation>
											<xs:documentation>Atributo opcional para expresar el número de parte, identificador del producto o del servicio, la clave de producto o servicio, SKU o equivalente, propia de la operación del emisor, amparado por el presente concepto. Opcionalmente se puede utilizar claves del estándar GTIN.</xs:documentation>
										</xs:annotation>
										<xs:simpleType>
											<xs:restriction base="xs:string">
												<xs:whiteSpace value="collapse"/>
												<xs:minLength value="1"/>
												<xs:maxLength value="100"/>
												<xs:pattern value="[^|]{1,100}"/>
											</xs:restriction>
										</xs:simpleType>
									</xs:attribute>
									<xs:attribute name="Cantidad" use="required">
										<xs:annotation>
											<xs:documentation>Atributo requerido para precisar la cantidad de bienes o servicios del tipo particular definido por el presente concepto.</xs:documentation>
										</xs:annotation>
										<xs:simpleType>
											<xs:restriction base="xs:decimal">
												<xs:fractionDigits value="6"/>
												<xs:minInclusive value="0.000001"/>
												<xs:whiteSpace value="collapse"/>
											</xs:restriction>
										</xs:simpleType>
									</xs:attribute>
									<xs:attribute name="ClaveUnidad" type="catCFDI:c_ClaveUnidad" use="required">
										<xs:annotation>
											<xs:documentation>Atributo requerido para precisar la clave de unidad de medida estandarizada aplicable para la cantidad expresada en el concepto. La unidad debe corresponder con la descripción del concepto.</xs:documentation>
										</xs:annotation>
									</xs:attribute>
									<xs:attribute name="Unidad" use="optional">
										<xs:annotation>
											<xs:documentation>Atributo opcional para precisar la unidad de medida propia de la operación del emisor, aplicable para la cantidad expresada en el concepto. La unidad debe corresponder con la descripción del concepto.</xs:documentation>
										</xs:annotation>
										<xs:simpleType>
											<xs:restriction base="xs:string">
												<xs:minLength value="1"/>
												<xs:maxLength value="20"/>
												<xs:whiteSpace value="collapse"/>
												<xs:pattern value="[^|]{1,20}"/>
											</xs:restriction>
										</xs:simpleType>
									</xs:attribute>
									<xs:attribute name="Descripcion" use="required">
										<xs:annotation>
											<xs:documentation>Atributo requerido para precisar la descripción del bien o servicio cubierto por el presente concepto.</xs:documentation>
										</xs:annotation>
										<xs:simpleType>
											<xs:restriction base="xs:string">
												<xs:minLength value="1"/>
												<xs:maxLength value="1000"/>
												<xs:whiteSpace value="collapse"/>
												<xs:pattern value="[^|]{1,1000}"/>
											</xs:restriction>
										</xs:simpleType>
									</xs:attribute>
									<xs:attribute name="ValorUnitario" type="tdCFDI:t_Importe" use="required">
										<xs:annotation>
											<xs:documentation>Atributo requerido para precisar el valor o precio unitario del bien o servicio cubierto por el presente concepto.</xs:documentation>
										</xs:annotation>
									</xs:attribute>
									<xs:attribute name="Importe" type="tdCFDI:t_Importe" use="required">
										<xs:annotation>
											<xs:documentation>Atributo requerido para precisar el importe total de los bienes o servicios del presente concepto. Debe ser equivalente al resultado de multiplicar la cantidad por el valor unitario expresado en el concepto. No se permiten valores negativos. </xs:documentation>
										</xs:annotation>
									</xs:attribute>
									<xs:attribute name="Descuento" type="tdCFDI:t_Importe" use="optional">
										<xs:annotation>
											<xs:documentation>Atributo opcional para representar el importe de los descuentos aplicables al concepto. No se permiten valores negativos.</xs:documentation>
										</xs:annotation>
									</xs:attribute>
									<xs:attribute name="ObjetoImp" type="catCFDI:c_ObjetoImp" use="required">
										<xs:annotation>
											<xs:documentation>Atributo requerido para expresar si la operación comercial es objeto o no de impuesto.</xs:documentation>
										</xs:annotation>
									</xs:attribute>
								</xs:complexType>
							</xs:element>
						</xs:sequence>
					</xs:complexType>
				</xs:element>
				<xs:element name="Impuestos" minOccurs="0">
					<xs:annotation>
						<xs:documentation>Nodo condicional para expresar el resumen de los impuestos aplicables.</xs:documentation>
					</xs:annotation>
					<xs:complexType>
						<xs:sequence>
							<xs:element name="Retenciones" minOccurs="0">
								<xs:annotation>
									<xs:documentation>Nodo condicional para capturar los impuestos retenidos aplicables. Es requerido cuando en los conceptos se registre algún impuesto retenido.</xs:documentation>
								</xs:annotation>
								<xs:complexType>
									<xs:sequence>
										<xs:element name="Retencion" maxOccurs="unbounded">
											<xs:annotation>
												<xs:documentation>Nodo requerido para la información detallada de una retención de impuesto específico.</xs:documentation>
											</xs:annotation>
											<xs:complexType>
												<xs:attribute name="Impuesto" type="catCFDI:c_Impuesto" use="required">
													<xs:annotation>
														<xs:documentation>Atributo requerido para señalar la clave del tipo de impuesto retenido.</xs:documentation>
													</xs:annotation>
												</xs:attribute>
												<xs:attribute name="Importe" type="tdCFDI:t_Importe" use="required">
													<xs:annotation>
														<xs:documentation>Atributo requerido para señalar el monto del impuesto retenido. No se permiten valores negativos.</xs:documentation>
													</xs:annotation>
												</xs:attribute>
											</xs:complexType>
										</xs:element>
									</xs:sequence>
								</xs:complexType>
							</xs:element>
							<xs:element name="Traslados" minOccurs="0">
								<xs:annotation>
									<xs:documentation>Nodo condicional para capturar los impuestos trasladados aplicables. Es requerido cuando en los conceptos se registre un impuesto trasladado.</xs:documentation>
								</xs:annotation>
								<xs:complexType>
									<xs:sequence>
										<xs:element name="Traslado" maxOccurs="unbounded">
											<xs:annotation>
												<xs:documentation>Nodo requerido para la información detallada de un traslado de impuesto específico.</xs:documentation>
											</xs:annotation>
											<xs:complexType>
												<xs:attribute name="Base" type="tdCFDI:t_Importe" use="required">
													<xs:annotation>
														<xs:documentation>Atributo requerido para señalar la suma de los atributos Base de los conceptos del impuesto trasladado. No se permiten valores negativos.</xs:documentation>
													</xs:annotation>
												</xs:attribute>
												<xs:attribute name="Impuesto" type="catCFDI:c_Impuesto" use="required">
													<xs:annotation>
														<xs:documentation>Atributo requerido para señalar la clave del tipo de impuesto trasladado.</xs:documentation>
													</xs:annotation>
												</xs:attribute>
												<xs:attribute name="TipoFactor" type="catCFDI:c_TipoFactor" use="required">
													<xs:annotation>
														<xs:documentation>Atributo requerido para señalar la clave del tipo de factor que se aplica a la base del impuesto.</xs:documentation>
													</xs:annotation>
												</xs:attribute>
												<xs:attribute name="TasaOCuota" use="optional">
													<xs:annotation>
														<xs:documentation>Atributo condicional para señalar el valor de la tasa o cuota del impuesto que se traslada por los conceptos amparados en el comprobante.</xs:documentation>
													</xs:annotation>
													<xs:simpleType>
														<xs:restriction base="xs:decimal">
															<xs:whiteSpace value="collapse"/>
															<xs:minInclusive value="0.000000"/>
															<xs:fractionDigits value="6"/>
														</xs:restriction>
													</xs:simpleType>
												</xs:attribute>
												<xs:attribute name="Importe" type="tdCFDI:t_Importe" use="optional">
													<xs:annotation>
														<xs:documentation>Atributo condicional para señalar la suma del importe del impuesto trasladado, agrupado por impuesto, TipoFactor y TasaOCuota. No se permiten valores negativos.</xs:documentation>
													</xs:annotation>
												</xs:attribute>
											</xs:complexType>
										</xs:element>
									</xs:sequence>
								</xs:complexType>
							</xs:element>
						</xs:sequence>
						<xs:attribute name="TotalImpuestosRetenidos" type="tdCFDI:t_Importe" use="optional">
							<xs:annotation>
								<xs:documentation>Atributo condicional para expresar el total de los impuestos retenidos que se desprenden de los conceptos expresados en el comprobante fiscal digital por Internet. No se permiten valores negativos. Es requerido cuando en los conceptos se registren impuestos retenidos.</xs:documentation>
							</xs:annotation>
						</xs:attribute>
						<xs:attribute name="TotalImpuestosTrasladados" type="tdCFDI:t_Importe" use="optional">
							<xs:annotation>
								<xs:documentation>Atributo condicional para expresar el total de los impuestos trasladados que se desprenden de los conceptos expresados en el comprobante fiscal digital por Internet. No se permiten valores negativos. Es requerido cuando en los conceptos se registren impuestos trasladados.</xs:documentation>
							</xs:annotation>
						</xs:attribute>
					</xs:complexType>
				</xs:element>
				<xs:element name="Complemento" minOccurs="0">
					<xs:annotation>
						<xs:documentation>Nodo opcional donde se incluye el complemento Timbre Fiscal Digital de manera obligatoria y los nodos complementarios determinados por el SAT, de acuerdo con las disposiciones particulares para un sector o actividad específica.</xs:documentation>
					</xs:annotation>
					<xs:complexType>
						<xs:sequence>
							<xs:any minOccurs="0" maxOccurs="unbounded"/>
						</xs:sequence>
					</xs:complexType>
				</xs:element>
				<xs:element name="Addenda" minOccurs="0">
					<xs:annotation>
						<xs:documentation>Nodo opcional para recibir las extensiones al presente formato que sean de utilidad al contribuyente. Para las reglas de uso del mismo, referirse al formato origen.</xs:documentation>
					</xs:annotation>
					<xs:complexType>
						<xs:sequence>
							<xs:any maxOccurs="unbounded"/>
						</xs:sequence>
					</xs:complexType>
				</xs:element>
			</xs:sequence>
			<xs:attribute name="Version" use="required" fixed="4.0">
				<xs:annotation>
					<xs:documentation>Atributo requerido con valor prefijado a 4.0 que indica la versión del estándar bajo el que se encuentra expresado el comprobante.</xs:documentation>
				</xs:annotation>
				<xs:simpleType>
					<xs:restriction base="xs:string">
						<xs:whiteSpace value="collapse"/>
					</xs:restriction>
				</xs:simpleType>
			</xs:attribute>
			<xs:attribute name="Serie" use="optional">
				<xs:annotation>
					<xs:documentation>Atributo opcional para precisar la serie para control interno del contribuyente. Este atributo acepta una cadena de caracteres.</xs:documentation>
				</xs:annotation>
				<xs:simpleType>
					<xs:restriction base="xs:string">
						<xs:minLength value="1"/>
						<xs:maxLength value="25"/>
						<xs:whiteSpace value="collapse"/>
						<xs:pattern value="[^|]{1,25}"/>
					</xs:restriction>
				</xs:simpleType>
			</xs:attribute>
			<xs:attribute name="Folio" use="optional">
				<xs:annotation>
					<xs:documentation>Atributo opcional para control interno del contribuyente que expresa el folio del comprobante, acepta una cadena de caracteres.</xs:documentation>
				</xs:annotation>
				<xs:simpleType>
					<xs:restriction base="xs:string">
						<xs:minLength value="1"/>
						<xs:maxLength value="40"/>
						<xs:whiteSpace value="collapse"/>
						<xs:pattern value="[^|]{1,40}"/>
					</xs:restriction>
				</xs:simpleType>
			</xs:attribute>
			<xs:attribute name="Fecha" type="tdCFDI:t_FechaH" use="required">
				<xs:annotation>
					<xs:documentation>Atributo requerido para la expresión de la fecha y hora de expedición del Comprobante Fiscal Digital por Internet. Se expresa en la forma AAAA-MM-DDThh:mm:ss y debe corresponder con la hora local donde se expide el comprobante.</xs:documentation>
				</xs:annotation>
			</xs:attribute>
			<xs:attribute name="Sello" use="required">
				<xs:annotation>
					<xs:documentation>Atributo requerido para contener el sello digital del comprobante fiscal, al que hacen referencia las reglas de resolución miscelánea vigente. El sello debe ser expresado como una cadena de texto en formato Base 64.</xs:documentation>
				</xs:annotation>
				<xs:simpleType>
					<xs:restriction base="xs:string">
						<xs:whiteSpace value="collapse"/>
					</xs:restriction>
				</xs:simpleType>
			</xs:attribute>
			<xs:attribute name="FormaPago" type="catCFDI:c_FormaPago" use="optional">
				<xs:annotation>
					<xs:documentation>Atributo condicional para expresar la clave de la forma de pago de los bienes o servicios amparados por el comprobante.</xs:documentation>
				</xs:annotation>
			</xs:attribute>
			<xs:attribute name="NoCertificado" use="required">
				<xs:annotation>
					<xs:documentation>Atributo requerido para expresar el número de serie del certificado de sello digital que ampara al comprobante, de acuerdo con el acuse correspondiente a 20 posiciones otorgado por el sistema del SAT.</xs:documentation>
				</xs:annotation>
				<xs:simpleType>
					<xs:restriction base="xs:string">
						<xs:whiteSpace value="collapse"/>
					</xs:restriction>
				</xs:simpleType>
			</xs:attribute>
			<xs:attribute name="Certificado" use="required">
				<xs:annotation>
					<xs:documentation>Atributo requerido que sirve para incorporar el certificado de sello digital que ampara al comprobante, como texto en formato base 64.</xs:documentation>
				</xs:annotation>
				<xs:simpleType>
					<xs:restriction base="xs:string">
						<xs:whiteSpace value="collapse"/>
					</xs:restriction>
				</xs:simpleType>
			</xs:attribute>
			<xs:attribute name="CondicionesDePago" use="optional">
				<xs:annotation>
					<xs:documentation>Atributo condicional para expresar las condiciones comerciales aplicables para el pago del comprobante fiscal digital por Internet. Este atributo puede ser condicionado mediante atributos o complementos.</xs:documentation>
				</xs:annotation>
				<xs:simpleType>
					<xs:restriction base="xs:string">
						<xs:whiteSpace value="collapse"/>
						<xs:minLength value="1"/>
						<xs:maxLength value="1000"/>
						<xs:pattern value="[^|]{1,1000}"/>
					</xs:restriction>
				</xs:simpleType>
			</xs:attribute>
			<xs:attribute name="SubTotal" type="tdCFDI:t_Importe" use="required">
				<xs:annotation>
					<xs:documentation>Atributo requerido para representar la suma de los importes de los conceptos antes de descuentos e impuesto. No se permiten valores negativos.</xs:documentation>
				</xs:annotation>
			</xs:attribute>
			<xs:attribute name="Descuento" type="tdCFDI:t_Importe" use="optional">
				<xs:annotation>
					<xs:documentation>Atributo condicional para representar el importe total de los descuentos aplicables antes de impuestos. No se permiten valores negativos. Se debe registrar cuando existan conceptos con descuento.</xs:documentation>
				</xs:annotation>
			</xs:attribute>
			<xs:attribute name="Moneda" type="catCFDI:c_Moneda" use="required">
				<xs:annotation>
					<xs:documentation>Atributo requerido para identificar la clave de la moneda utilizada para expresar los montos, cuando se usa moneda nacional se registra MXN. Conforme con la especificación ISO 4217.</xs:documentation>
				</xs:annotation>
			</xs:attribute>
			<xs:attribute name="TipoCambio" use="optional">
				<xs:annotation>
					<xs:documentation>Atributo condicional para representar el tipo de cambio FIX conforme con la moneda usada. Es requerido cuando la clave de moneda es distinta de MXN y de XXX. El valor debe reflejar el número de pesos mexicanos que equivalen a una unidad de la divisa señalada en el atributo moneda. Si el valor está fuera del porcentaje aplicable a la moneda tomado del catálogo c_Moneda, el emisor debe obtener del PAC que vaya a timbrar el CFDI, de manera no automática, una clave de confirmación para ratificar que el valor es correcto e integrar dicha clave en el atributo Confirmacion.</xs:documentation>
				</xs:annotation>
				<xs:simpleType>
					<xs:restriction base="xs:decimal">
						<xs:fractionDigits value="6"/>
						<xs:minInclusive value="0.000001"/>
						<xs:whiteSpace value="collapse"/>
					</xs:restriction>
				</xs:simpleType>
			</xs:attribute>
			<xs:attribute name="Total" type="tdCFDI:t_Importe" use="required">
				<xs:annotation>
					<xs:documentation>Atributo requerido para representar la suma del subtotal, menos los descuentos aplicables, más las contribuciones recibidas (impuestos trasladados - federales y/o locales, derechos, productos, aprovechamientos, aportaciones de seguridad social, contribuciones de mejoras) menos los impuestos retenidos federales y/o locales. Si el valor es superior al límite que establezca el SAT en la Resolución Miscelánea Fiscal vigente, el emisor debe obtener del PAC que vaya a timbrar el CFDI, de manera no automática, una clave de confirmación para ratificar que el valor es correcto e integrar dicha clave en el atributo Confirmacion. No se permiten valores negativos. </xs:documentation>
				</xs:annotation>
			</xs:attribute>
			<xs:attribute name="TipoDeComprobante" type="catCFDI:c_TipoDeComprobante" use="required">
				<xs:annotation>
					<xs:documentation>Atributo requerido para expresar la clave del efecto del comprobante fiscal para el contribuyente emisor.</xs:documentation>
				</xs:annotation>
			</xs:attribute>
			<xs:attribute name="Exportacion" type="catCFDI:c_Exportacion" use="required">
				<xs:annotation>
					<xs:documentation>Atributo requerido para expresar si el comprobante ampara una operación de exportación.</xs:documentation>
				</xs:annotation>
			</xs:attribute>
			<xs:attribute name="MetodoPago" type="catCFDI:c_MetodoPago" use="optional">
				<xs:annotation>
					<xs:documentation>Atributo condicional para precisar la clave del método de pago que aplica para este comprobante fiscal digital por Internet, conforme al Artículo 29-A fracción VII incisos a y b del CFF.</xs:documentation>
				</xs:annotation>
			</xs:attribute>
			<xs:attribute name="LugarExpedicion" type="catCFDI:c_CodigoPostal" use="required">
				<xs:annotation>
					<xs:documentation>Atributo requerido para incorporar el código postal del lugar de expedición del comprobante (domicilio de la matriz o de la sucursal).</xs:documentation>
				</xs:annotation>
			</xs:attribute>
			<xs:attribute name="Confirmacion" use="optional">
				<xs:annotation>
					<xs:documentation>Atributo condicional para registrar la clave de confirmación que entregue el PAC para expedir el comprobante con importes grandes, con un tipo de cambio fuera del rango establecido o con ambos casos. Es requerido cuando se registra un tipo de cambio o un total fuera del rango establecido.</xs:documentation>
				</xs:annotation>
				<xs:simpleType>
					<xs:restriction base="xs:string">
						<xs:whiteSpace value="collapse"/>
						<xs:length value="5"/>
						<xs:pattern value="[0-9a-zA-Z]{5}"/>
					</xs:restriction>
				</xs:simpleType>
			</xs:attribute>
		</xs:complexType>
	</xs:element>
</xs:schema>
</field>
</record>
@@ -21,7 +21,7 @@
<field name="report_file">l10n_mx_facturae/report/account_move.odt</field>
<field name="in_format">oo-odt</field>
<field name="out_format" ref="report_aeroo.report_mimetypes_pdf_odt"/>
- <field name="parser_model">report.l10n_mx_qr</field>
+ <field name="parser_model">report.l10n_mx_facturae.account_move</field>
<field name="styles_mode">default</field>
<field name="preload_mode">static</field>
<field name="deferred">off</field>
diff --git a/l10n_mx_facturae/data/account_payment.xml b/l10n_mx_facturae/data/account_payment.xml
index 83fecf0d4a..f2d4733197 100644
--- a/l10n_mx_facturae/data/account_payment.xml
+++ b/l10n_mx_facturae/data/account_payment.xml
@@ -6,7 +6,7 @@
<field name="name">Account Payment CFDI XML</field>
<field name="model">account.payment</field>
<field name="report_type">qweb-xml</field>
- <field name="report_name">l10n_mx_facturae.account_payment_template_cfdi_xml</field>
+ <field name="report_name">l10n_mx_facturae.account_payment</field>
<field name="xml_declaration">true</field>
<field name="xsd_schema"></field>
</record>
@@ -21,7 +21,7 @@
<field name="report_file">l10n_mx_facturae/report/account_payment.odt</field>
<field name="in_format">oo-odt</field>
<field name="out_format" ref="report_aeroo.report_mimetypes_pdf_odt"/>
- <field name="parser_model">report.l10n_mx_facturae.account_payment_template_cfdi_xml</field>
+ <field name="parser_model">report.l10n_mx_facturae.account_payment</field>
<field name="styles_mode">default</field>
<field name="preload_mode">static</field>
<field name="deferred">off</field>
diff --git a/l10n_mx_facturae/data/ir_attachment_facturae_config.xml b/l10n_mx_facturae/data/ir_attachment_facturae_config.xml
index db90752145..4539748303 100644
--- a/l10n_mx_facturae/data/ir_attachment_facturae_config.xml
+++ b/l10n_mx_facturae/data/ir_attachment_facturae_config.xml
@@ -5,7 +5,7 @@
model="ir.attachment.facturae.mx.config">
<field name="model">account.move</field>
<field name="version">4.0</field>
- <field name="template_xml_sign">l10n_mx_facturae.account_move_template_cfdi_xml</field>
+ <field name="template_xml_sign">l10n_mx_facturae.account_move</field>
<field name="template_xml_cancel">Aun.no.hay.uno</field>
<field name="template_pdf_sign">l10n_mx_facturae.account_move_template_cfdi_pdf</field>
<field name="template_pdf_cancel">l10n_mx_facturae.account_move_template_cfdi_pdf</field>
@@ -16,7 +16,7 @@
model="ir.attachment.facturae.mx.config">
<field name="model">account.payment</field>
<field name="version">4.0</field>
- <field name="template_xml_sign">l10n_mx_facturae.account_payment_template_cfdi_xml</field>
+ <field name="template_xml_sign">l10n_mx_facturae.account_payment</field>
<field name="template_xml_cancel">Aun.no.hay.uno</field>
<field name="template_pdf_sign">l10n_mx_facturae.account_payment_template_cfdi_pdf</field>
<field name="template_pdf_cancel"><!--l10n_mx_facturae.account_payment_template_cfdi_pdf--></field>
diff --git a/l10n_mx_facturae/report/__init__.py b/l10n_mx_facturae/report/__init__.py
index d564ba5da1..dd3fb58358 100644
--- a/l10n_mx_facturae/report/__init__.py
+++ b/l10n_mx_facturae/report/__init__.py
@@ -1,3 +1,4 @@
# -*- coding: utf-8 -*-
+from . import account_move
from . import account_payment
diff --git a/l10n_mx_facturae/report/account_move.py b/l10n_mx_facturae/report/account_move.py
new file mode 100644
index 0000000000..91e1bf36d5
--- /dev/null
+++ b/l10n_mx_facturae/report/account_move.py
@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+
+from odoo import api, models
+
+
+class Parser(models.AbstractModel):
+ _inherit = "report.l10n_mx_cfdi"
+ _description = "report.l10n_mx_facturae.account_move"
+ _name = "report.l10n_mx_facturae.account_move"
+
+ def _get_report_values(self, docids, data=None):
+ res = super()._get_report_values(docids, data=data)
+ docs = self.env["account.move"].browse(docids)
+ # return a custom rendering context
+ res.update(
+ {
+ "doc_ids": docids,
+ "doc_model": "account.move",
+ "docs": docs,
+ }
+ )
+ return res
diff --git a/l10n_mx_facturae/report/account_payment.py b/l10n_mx_facturae/report/account_payment.py
index 325f895f30..1cd16ae961 100644
--- a/l10n_mx_facturae/report/account_payment.py
+++ b/l10n_mx_facturae/report/account_payment.py
@@ -4,34 +4,32 @@ from odoo import api, models
class Parser(models.AbstractModel):
- _inherit = ["report.report_xml.abstract", "report.l10n_mx_qr", "report.report_aeroo.abstract"]
- _description = "report.l10n_mx_facturae.account_payment_template_cfdi_xml"
- _name = "report.l10n_mx_facturae.account_payment_template_cfdi_xml"
+ _inherit = "report.l10n_mx_cfdi"
+ _description = "report.l10n_mx_facturae.account_payment"
+ _name = "report.l10n_mx_facturae.account_payment"
@api.model
def aeroo_report(self, docids, data):
self = self.with_context(
- format_float = self._format_float,
- format_impuesto = self._format_impuesto,
- format_tasaocuota = self._format_tasaocuota,
+ format_impuesto=self._format_impuesto,
+ format_tasaocuota=self._format_tasaocuota,
)
return super(Parser, self).aeroo_report(docids, data)
def _get_report_values(self, docids, data=None):
+ res = super()._get_report_values(docids, data=data)
docs = self.env["account.payment"].browse(docids)
# return a custom rendering context
- return {
- "doc_ids": docids,
- "doc_model": "account.payment",
- "docs": docs,
- "format_float": self._format_float,
- "format_impuesto": self._format_impuesto,
- "format_tasaocuota": self._format_tasaocuota,
- }
-
- def _format_float(self, amount, decimals):
- """Format any amount to a given number of decimals"""
- return "{:.{}f}".format(amount, decimals)
+ res.update(
+ {
+ "doc_ids": docids,
+ "doc_model": "account.payment",
+ "docs": docs,
+ "format_impuesto": self._format_impuesto,
+ "format_tasaocuota": self._format_tasaocuota,
+ }
+ )
+ return res
def _format_impuesto(self, tax):
tax_types = {
diff --git a/l10n_mx_facturae/templates/account_move.xml b/l10n_mx_facturae/templates/account_move.xml
index 2202441201..b0a4a8b7c2 100644
--- a/l10n_mx_facturae/templates/account_move.xml
+++ b/l10n_mx_facturae/templates/account_move.xml
@@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8" ?>
<odoo>
- <template id="account_move_template_cfdi_xml">
+ <template id="account_move">
<t t-set="move" t-value="docs[0]" />
<t t-set="taxes" t-value="move.impuestos" />
<t t-set="total_traslados" t-value="move.l10n_mx_facturae_compute_total_traslados(taxes)" />
@@ -68,7 +68,7 @@
<cfdi:Traslados t-if="line.impuestos['traslados']">
<t t-set="impuestos" t-value="line.impuestos"/>
<cfdi:Traslado t-foreach="impuestos['traslados']" t-as="tax"
- t-attf-Base="{{ tax.base }}"
+ t-att-Base="format_float(tax.base, o.currency_id.decimal_places)"
t-attf-Impuesto="{{ tax.xml_name }}"
t-attf-TipoFactor="{{ tax.type }}"
t-attf-TasaOCuota="{{ tax.TasaOCuota }}"
@@ -76,7 +76,7 @@
</cfdi:Traslados>
<cfdi:Retenciones t-if="impuestos['retenciones']">
<cfdi:Retencion t-foreach="impuestos['retenciones']" t-as="tax"
- t-attf-Base="{{ tax.base }}"
+ t-att-Base="format_float(tax.base, o.currency_id.decimal_places)"
t-attf-Impuesto="{{ tax.xml_name }}"
t-attf-TipoFactor="{{ tax.type }}"
t-attf-TasaOCuota="{{ tax.TasaOCuota }}"
@@ -101,7 +101,7 @@
</cfdi:Retenciones>
<cfdi:Traslados t-if="taxes['traslados']">
<cfdi:Traslado t-foreach="taxes['traslados']" t-as="tax"
- t-attf-Base="{{ tax.base }}"
+ t-att-Base="format_float(tax.base, o.currency_id.decimal_places)"
t-attf-Impuesto="{{ tax.xml_name }}"
t-attf-TipoFactor="{{ tax.type }}"
t-attf-TasaOCuota="{{ tax.TasaOCuota }}"
diff --git a/l10n_mx_facturae/templates/account_payment.xml b/l10n_mx_facturae/templates/account_payment.xml
index 4203c948b3..3b9dfe6de3 100644
--- a/l10n_mx_facturae/templates/account_payment.xml
+++ b/l10n_mx_facturae/templates/account_payment.xml
@@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8" ?>
<odoo>
- <template id="account_payment_template_cfdi_xml">
+ <template id="account_payment">
<t t-set="payment" t-value="docs[0]" />
<t t-set="residenciaFiscal" t-value="payment.l10n_mx_facturae_payment_compute_residencia_fiscal()"/>
<t t-set="regimenTrib" t-value="payment.l10n_mx_facturae_payment_compute_regimen_tributario()"/>
@@ -54,7 +54,7 @@
<pago20:Totales
t-attf-MontoTotalPagos="{{ o.l10n_mx_facturae_payment_montototalpagos() }}"
t-att-TotalTrasladosBaseIVAExento="traslados.get('baseIVAExento', False)"
- t-att-TotalTrasladosBaseIVA16="traslados.get('baseIVA16.0', False)"
+ t-att-TotalTrasladosBaseIVA16="format_float(traslados.get('baseIVA16.0', False), o.currency_id.decimal_places)"
t-att-TotalTrasladosImpuestoIVA16="traslados.get('importeIVA16.0', False)"
t-att-TotalTrasladosBaseIVA8="traslados.get('baseIVA8.0', False)"
t-att-TotalTrasladosImpuestoIVA8="traslados.get('importeIVA8.0', False)"
--
GitLab
From 7b012259c4e83893888ab5b4463f17eec7ba921d Mon Sep 17 00:00:00 2001
From: "noe.izquierdo" <noe.izquierdo@openpyme.mx>
Date: Wed, 10 Apr 2024 10:02:50 -0600
Subject: [PATCH 03/19] feat(account.payment): se agregan correcciones para los
totales traslados y retenciones
---
l10n_mx_facturae/models/account_move.py | 24 +++++++++++++++++++
.../templates/account_payment.xml | 8 +++----
2 files changed, 28 insertions(+), 4 deletions(-)
diff --git a/l10n_mx_facturae/models/account_move.py b/l10n_mx_facturae/models/account_move.py
index 063bb5549b..19599d4bfa 100644
--- a/l10n_mx_facturae/models/account_move.py
+++ b/l10n_mx_facturae/models/account_move.py
@@ -541,6 +541,18 @@ class AccountMoveLine(models.Model):
"N° Pediment",
)
+ l10n_mx_tax_base_dr = fields.Monetary(
+ compute="_compute_l10n_mx_tax_base_dr"
+ )
+
+ l10n_mx_tax_importe_dr = fields.Monetary(
+ compute="_compute_l10n_mx_tax_importe_dr"
+ )
+
+ l10n_mx_tax_currency_dr = fields.Monetary(
+ compute="_compue_l10n_mx_tax_currency_dr"
+ )
+
@api.constrains("cfdi_cuentapredial")
def _constraint_cfdi_cuentapredial(self):
for record in self:
@@ -761,3 +773,15 @@ class AccountMoveLine(models.Model):
def l10n_mx_facturae_importe(self):
return "{0:.2f}".format(self.importe)
+
+ def _compute_l10n_mx_tax_base_dr(self):
+ for record in self:
+ return
+
+ def _compute_l10n_mx_tax_importe_dr(self):
+ for record in self:
+ return
+
+ def _compue_l10n_mx_tax_currency_dr(self):
+ for record in self:
+ return
diff --git a/l10n_mx_facturae/templates/account_payment.xml b/l10n_mx_facturae/templates/account_payment.xml
index 3b9dfe6de3..9305f84f16 100644
--- a/l10n_mx_facturae/templates/account_payment.xml
+++ b/l10n_mx_facturae/templates/account_payment.xml
@@ -54,10 +54,10 @@
<pago20:Totales
t-attf-MontoTotalPagos="{{ o.l10n_mx_facturae_payment_montototalpagos() }}"
t-att-TotalTrasladosBaseIVAExento="traslados.get('baseIVAExento', False)"
- t-att-TotalTrasladosBaseIVA16="format_float(traslados.get('baseIVA16.0', False), o.currency_id.decimal_places)"
- t-att-TotalTrasladosImpuestoIVA16="traslados.get('importeIVA16.0', False)"
- t-att-TotalTrasladosBaseIVA8="traslados.get('baseIVA8.0', False)"
- t-att-TotalTrasladosImpuestoIVA8="traslados.get('importeIVA8.0', False)"
+ t-att-TotalTrasladosBaseIVA16="format_float(traslados.get('baseIVA16.0'), o.currency_id.decimal_places) if traslados.get('baseIVA16.0', False) else False"
+ t-att-TotalTrasladosImpuestoIVA16="format_float(traslados.get('importeIVA16.0'), o.currency_id.decimal_places) if traslados.get('importeIVA16.0', False) else False"
+ t-att-TotalTrasladosBaseIVA8="format_float(traslados.get('baseIVA8.0'), o.currency_id.decimal_places) if traslados.get('baseIVA8.0', False) else False"
+ t-att-TotalTrasladosImpuestoIVA8="format_float(traslados.get('importeIVA8.0'), o.currency_id.decimal_places) if traslados.get('importeIVA8.0', False) else False"
t-att-TotalTrasladosBaseIVA0="traslados.get('baseIVA0.0', False)"
t-att-TotalTrasladosImpuestoIVA0="traslados.get('importeIVA0.0', False)"
t-att-TotalRetencionesIVA="retenciones.get('importeIVA', False)"
--
GitLab
From 91537a6ac06590c24948dea7a33a3f27f54b4a24 Mon Sep 17 00:00:00 2001
From: "noe.izquierdo" <noe.izquierdo@openpyme.mx>
Date: Thu, 11 Apr 2024 18:01:09 -0600
Subject: [PATCH 04/19] fix(account.payment): se agregan funciones para
calcular la basedr e impuestodr en la moneda del dr
---
l10n_mx_facturae/models/account_move.py | 24 -------
l10n_mx_facturae/models/account_payment.py | 70 ++++++++-----------
.../templates/account_payment.xml | 8 +--
3 files changed, 33 insertions(+), 69 deletions(-)
diff --git a/l10n_mx_facturae/models/account_move.py b/l10n_mx_facturae/models/account_move.py
index 19599d4bfa..063bb5549b 100644
--- a/l10n_mx_facturae/models/account_move.py
+++ b/l10n_mx_facturae/models/account_move.py
@@ -541,18 +541,6 @@ class AccountMoveLine(models.Model):
"N° Pediment",
)
- l10n_mx_tax_base_dr = fields.Monetary(
- compute="_compute_l10n_mx_tax_base_dr"
- )
-
- l10n_mx_tax_importe_dr = fields.Monetary(
- compute="_compute_l10n_mx_tax_importe_dr"
- )
-
- l10n_mx_tax_currency_dr = fields.Monetary(
- compute="_compue_l10n_mx_tax_currency_dr"
- )
-
@api.constrains("cfdi_cuentapredial")
def _constraint_cfdi_cuentapredial(self):
for record in self:
@@ -773,15 +761,3 @@ class AccountMoveLine(models.Model):
def l10n_mx_facturae_importe(self):
return "{0:.2f}".format(self.importe)
-
- def _compute_l10n_mx_tax_base_dr(self):
- for record in self:
- return
-
- def _compute_l10n_mx_tax_importe_dr(self):
- for record in self:
- return
-
- def _compue_l10n_mx_tax_currency_dr(self):
- for record in self:
- return
diff --git a/l10n_mx_facturae/models/account_payment.py b/l10n_mx_facturae/models/account_payment.py
index d43314d24f..5acacfaa41 100644
--- a/l10n_mx_facturae/models/account_payment.py
+++ b/l10n_mx_facturae/models/account_payment.py
@@ -345,20 +345,8 @@ class AccountPayment(models.Model):
tax_group = tax_rep_lines.mapped("tag_ids")
key = tax_group.name + str(line["tax_id"].amount)
- if company_currency != voucher_currency:
- company_currency = company_currency.with_context(
- special_currency_rate=self.currency_rate(),
- special_currency=voucher_currency.id,
- )
- tax_totals["importe" + key] = company_currency.compute(
- line["importe"], voucher_currency,
- )
- tax_totals["base" + key] = company_currency.compute(
- line["tax_base"], voucher_currency,
- )
- else:
- tax_totals["importe" + key] = line["importe"]
- tax_totals["base" + key] = line["tax_base"]
+ tax_totals["importe" + key] = line["importe"]
+ tax_totals["base" + key] = line["tax_base"]
return tax_totals
@@ -378,35 +366,11 @@ class AccountPayment(models.Model):
importe=0.0,
)
- if tax_move.currency_id != voucher_currency:
- invoice_currency = (
- tax_move.currency_id
- if tax_move.currency_id else company_currency
- )
- invoice_currency = invoice_currency.with_context(date=self.date)
- if invoice_currency != company_currency:
- invoice_currency = invoice_currency.with_context(
- special_currency_rate=self.tipocambiodr(invoice),
- special_currency=invoice_currency.id,
- )
- else:
- invoice_currency = invoice_currency.with_context(
- special_currency_rate=(1 / self.tipocambiodr(invoice)),
- special_currency=voucher_currency.id,
- )
- tax_base = invoice_currency.compute(
- tax_move.tax_base_amount, voucher_currency, round=False,
- )
- # Force rounding 6 decimals to use as many decimal as possible and
- # avoid rounding errors when validating XML
- tax_base = float_round(
- tax_base, precision_digits=2, rounding_method="DOWN",
- )
- else:
- tax_base = tax_move.tax_base_amount
+ tax_base = self._l10n_mx_tax_base_dr(invoice, tax_move)
+ importe = self._l10n_mx_tax_importe_dr(invoice, tax_move)
tax_totals[tax_move.tax_line_id.id]["tax_base"] += tax_base
- tax_totals[tax_move.tax_line_id.id]["importe"] += abs(tax_move.balance)
+ tax_totals[tax_move.tax_line_id.id]["importe"] += importe
return [line for line in tax_totals.values()]
@@ -429,3 +393,27 @@ class AccountPayment(models.Model):
domain.append(("tax_line_id.amount_type", "=", "percent"))
return domain
+
+ def _l10n_mx_tax_base_dr(self, invoice, tax_move):
+ amount = tax_move.tax_base_amount
+
+ if invoice.currency_id != self.company_id.currency_id:
+ account = (
+ tax_move.company_id.account_cash_basis_base_account_id or
+ tax_move.account_id
+ )
+ base_line = tax_move.move_id.line_ids.filtered(
+ lambda l:
+ l.id != tax_move.id and l.account_id == account and l.tax_ids
+ )
+ amount = -1 * base_line.amount_currency
+
+ return amount
+
+ def _l10n_mx_tax_importe_dr(self, invoice, tax_move):
+ amount = tax_move.balance
+
+ if invoice.currency_id != self.company_id.currency_id:
+ amount = tax_move.amount_currency
+
+ return -1 * amount
diff --git a/l10n_mx_facturae/templates/account_payment.xml b/l10n_mx_facturae/templates/account_payment.xml
index 9305f84f16..eeec6bff47 100644
--- a/l10n_mx_facturae/templates/account_payment.xml
+++ b/l10n_mx_facturae/templates/account_payment.xml
@@ -58,8 +58,8 @@
t-att-TotalTrasladosImpuestoIVA16="format_float(traslados.get('importeIVA16.0'), o.currency_id.decimal_places) if traslados.get('importeIVA16.0', False) else False"
t-att-TotalTrasladosBaseIVA8="format_float(traslados.get('baseIVA8.0'), o.currency_id.decimal_places) if traslados.get('baseIVA8.0', False) else False"
t-att-TotalTrasladosImpuestoIVA8="format_float(traslados.get('importeIVA8.0'), o.currency_id.decimal_places) if traslados.get('importeIVA8.0', False) else False"
- t-att-TotalTrasladosBaseIVA0="traslados.get('baseIVA0.0', False)"
- t-att-TotalTrasladosImpuestoIVA0="traslados.get('importeIVA0.0', False)"
+ t-att-TotalTrasladosBaseIVA0="format_float(traslados.get('baseIVA0.0'), o.currency_id.decimal_places) if traslados.get('baseIVA0.0', False) else False"
+ t-att-TotalTrasladosImpuestoIVA0="format_float(traslados.get('importeIVA0.0'), o.currency_id.decimal_places) if traslados.get('importeIVA0.0', False) else False"
t-att-TotalRetencionesIVA="retenciones.get('importeIVA', False)"
t-att-TotalRetencionesISR="retenciones.get('importeISR', False)"
t-att-TotalRetencionesIEPS="retenciones.get('importeIEPS', False)" />
@@ -92,9 +92,9 @@
</pago20:RetencionesDR>
<pago20:TrasladosDR>
<pago20:TrasladoDR t-foreach="o.impuestos_dr(invoice)" t-as="tax_move"
- t-att-BaseDR="format_float(tax_move.tax_base_amount, invoice.currency_id.decimal_places)"
+ t-att-BaseDR="format_float(o._l10n_mx_tax_base_dr(invoice, tax_move), invoice.currency_id.decimal_places)"
t-att-ImpuestoDR="format_impuesto(tax_move.tax_line_id)"
- t-att-ImporteDR="format_float(abs(tax_move.balance), invoice.currency_id.decimal_places)"
+ t-att-ImporteDR="format_float(abs(o._l10n_mx_tax_importe_dr(invoice, tax_move)), invoice.currency_id.decimal_places)"
t-att-TasaOCuotaDR="format_tasaocuota(tax_move.tax_line_id)"
t-att-TipoFactorDR="tax_move.tax_line_id.l10n_mx_tax_type" />
</pago20:TrasladosDR>
--
GitLab
From 41499162050314a5c911ac69dd4bd83777db1e1d Mon Sep 17 00:00:00 2001
From: "ricardo.mendoza" <ricardo.mendoza@openpyme.mx>
Date: Thu, 18 Apr 2024 10:34:11 -0600
Subject: [PATCH 05/19] =?UTF-8?q?feat(cancelaci=C3=B3n=20de=20facturas):?=
=?UTF-8?q?=20se=20creo=20un=20campo=20boolean=20en=20el=20objeto=20accoun?=
=?UTF-8?q?t.move,=20y=20un=20campo=20al=20xml?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
l10n_mx_facturae/models/account_move.py | 3 +++
l10n_mx_facturae/views/account_move.xml | 1 +
2 files changed, 4 insertions(+)
diff --git a/l10n_mx_facturae/models/account_move.py b/l10n_mx_facturae/models/account_move.py
index 063bb5549b..9ab48f3f88 100644
--- a/l10n_mx_facturae/models/account_move.py
+++ b/l10n_mx_facturae/models/account_move.py
@@ -17,6 +17,9 @@ class AccountMove(models.Model):
_name = "account.move"
_inherit = ["account.move", "base.cfdi"]
+ is_cancelable = fields.Boolean(
+ "Candidate is canceled"
+ )
@property
def formapago(self):
"""Return payment type for display on CFDI"""
diff --git a/l10n_mx_facturae/views/account_move.xml b/l10n_mx_facturae/views/account_move.xml
index f7d429a9fe..fefbbf1c4c 100644
--- a/l10n_mx_facturae/views/account_move.xml
+++ b/l10n_mx_facturae/views/account_move.xml
@@ -32,6 +32,7 @@
<field name="arch" type="xml">
<button name="button_cancel" position="before">
<field name="is_cfdi_candidate" invisible="1" />
+ <field name="is_cancelable" invisible="1" />
</button>
<xpath expr="//header" position="after">
<div
--
GitLab
From f1c15630f6b1365005db534c4bea0eb5ff1284c6 Mon Sep 17 00:00:00 2001
From: "ricardo.mendoza" <ricardo.mendoza@openpyme.mx>
Date: Thu, 18 Apr 2024 18:10:12 -0600
Subject: [PATCH 06/19] =?UTF-8?q?Se=20agrego=20el=20boton=20Cancelar=20CFD?=
=?UTF-8?q?I=20al=20header,=20se=20uso=20una=20funci=C3=B3n=20de=20ejemplo?=
=?UTF-8?q?=20que=20imprime=20el=20hola=20mundo=20para=20que=20nos=20permi?=
=?UTF-8?q?tiara=20crear=20el=20boton=20ya=20que=20la=20funci=C3=B3n=20es?=
=?UTF-8?q?=20obligatoria=20y=20por=20ultimo=20se=20agregaron=20la=20condi?=
=?UTF-8?q?ciones=20al=20attrs=20del=20boton=20creado=20para=20indicarlo?=
=?UTF-8?q?=20cuando=20debe=20de=20estar=20visible?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
l10n_mx_facturae/models/account_move.py | 4 ++++
l10n_mx_facturae/views/account_move.xml | 1 +
2 files changed, 5 insertions(+)
diff --git a/l10n_mx_facturae/models/account_move.py b/l10n_mx_facturae/models/account_move.py
index 9ab48f3f88..cfef523c5d 100644
--- a/l10n_mx_facturae/models/account_move.py
+++ b/l10n_mx_facturae/models/account_move.py
@@ -20,6 +20,10 @@ class AccountMove(models.Model):
is_cancelable = fields.Boolean(
"Candidate is canceled"
)
+ def l10n_mx_action_cancel(self):
+ print("Hola Mundo")
+
+
@property
def formapago(self):
"""Return payment type for display on CFDI"""
diff --git a/l10n_mx_facturae/views/account_move.xml b/l10n_mx_facturae/views/account_move.xml
index fefbbf1c4c..59c291ca18 100644
--- a/l10n_mx_facturae/views/account_move.xml
+++ b/l10n_mx_facturae/views/account_move.xml
@@ -31,6 +31,7 @@
<field name="inherit_id" ref="account.view_move_form"/>
<field name="arch" type="xml">
<button name="button_cancel" position="before">
+ <button name="l10n_mx_action_cancel" string="Cancelar CFDI" type="object" class="btn-primary" attrs="{'invisible': [('state', '!=', 'posted'), ('cfdi_state', '!=', 'done')]}"/>
<field name="is_cfdi_candidate" invisible="1" />
<field name="is_cancelable" invisible="1" />
</button>
--
GitLab
From baebf299fc65eb16edbfeeae23acafc4409788dc Mon Sep 17 00:00:00 2001
From: "ricardo.mendoza" <ricardo.mendoza@openpyme.mx>
Date: Fri, 19 Apr 2024 16:13:22 -0600
Subject: [PATCH 07/19] =?UTF-8?q?Se=20coloca=20el=20campo=20is=5Fcancelabl?=
=?UTF-8?q?e=20despues=20de=20l10n=5Fmx=5Fexport,=20y=20se=20ajusta=20la?=
=?UTF-8?q?=20identaci=C3=B3n=20en=20el=20modelo=20de=20vista?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
l10n_mx_facturae/models/account_move.py | 8 ++++----
l10n_mx_facturae/views/account_move.xml | 13 ++++++++++++-
2 files changed, 16 insertions(+), 5 deletions(-)
diff --git a/l10n_mx_facturae/models/account_move.py b/l10n_mx_facturae/models/account_move.py
index cfef523c5d..a170c923ce 100644
--- a/l10n_mx_facturae/models/account_move.py
+++ b/l10n_mx_facturae/models/account_move.py
@@ -17,13 +17,9 @@ class AccountMove(models.Model):
_name = "account.move"
_inherit = ["account.move", "base.cfdi"]
- is_cancelable = fields.Boolean(
- "Candidate is canceled"
- )
def l10n_mx_action_cancel(self):
print("Hola Mundo")
-
@property
def formapago(self):
"""Return payment type for display on CFDI"""
@@ -161,6 +157,10 @@ class AccountMove(models.Model):
string="Merchandise export",
)
+ is_cancelable = fields.Boolean(
+ "Candidate is canceled"
+ )
+
def button_validate(self):
"""
Extend `AccountMove.button_validate`: prevents to manipulate the
diff --git a/l10n_mx_facturae/views/account_move.xml b/l10n_mx_facturae/views/account_move.xml
index 59c291ca18..d5144b7db1 100644
--- a/l10n_mx_facturae/views/account_move.xml
+++ b/l10n_mx_facturae/views/account_move.xml
@@ -31,7 +31,18 @@
<field name="inherit_id" ref="account.view_move_form"/>
<field name="arch" type="xml">
<button name="button_cancel" position="before">
- <button name="l10n_mx_action_cancel" string="Cancelar CFDI" type="object" class="btn-primary" attrs="{'invisible': [('state', '!=', 'posted'), ('cfdi_state', '!=', 'done')]}"/>
+ <button name="l10n_mx_action_cancel"
+ string="Cancel CFDI"
+ type="object"
+ class="btn-primary"
+ attrs="{'invisible': [
+ ('state', '!=', 'posted'),
+ (
+ 'cfdi_state',
+ '!=',
+ 'done'
+ )
+ ]}"/>
<field name="is_cfdi_candidate" invisible="1" />
<field name="is_cancelable" invisible="1" />
</button>
--
GitLab
From fff622ff98efe9b35dcc0cf1646a7493fa460208 Mon Sep 17 00:00:00 2001
From: "ricardo.mendoza" <ricardo.mendoza@openpyme.mx>
Date: Mon, 22 Apr 2024 13:26:55 -0600
Subject: [PATCH 08/19] =?UTF-8?q?Se=20coloca=20la=20funci=C3=B3n=20l10n=5F?=
=?UTF-8?q?mx=5Faction=5Fcancel=20al=20final=20de=20las=20funciones=20de?=
=?UTF-8?q?=20la=20clase=20account?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
l10n_mx_facturae/models/account_move.py | 5 ++---
1 file changed, 2 insertions(+), 3 deletions(-)
diff --git a/l10n_mx_facturae/models/account_move.py b/l10n_mx_facturae/models/account_move.py
index a170c923ce..81bb604051 100644
--- a/l10n_mx_facturae/models/account_move.py
+++ b/l10n_mx_facturae/models/account_move.py
@@ -17,9 +17,6 @@ class AccountMove(models.Model):
_name = "account.move"
_inherit = ["account.move", "base.cfdi"]
- def l10n_mx_action_cancel(self):
- print("Hola Mundo")
-
@property
def formapago(self):
"""Return payment type for display on CFDI"""
@@ -527,6 +524,8 @@ class AccountMove(models.Model):
return res
+ def l10n_mx_action_cancel(self):
+ print("Hola Mundo")
class AccountMoveLine(models.Model):
_inherit = "account.move.line"
--
GitLab
From 364bce9b8aef4aca0a4388a181c0fe4bd526a899 Mon Sep 17 00:00:00 2001
From: "ricardo.mendoza" <ricardo.mendoza@openpyme.mx>
Date: Mon, 22 Apr 2024 13:44:28 -0600
Subject: [PATCH 09/19] =?UTF-8?q?Se=20corrige=20la=20identaci=C3=B3n=20del?=
=?UTF-8?q?=20bot=C3=B3n=20Cancel=20CFDI?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
l10n_mx_facturae/views/account_move.xml | 8 ++------
1 file changed, 2 insertions(+), 6 deletions(-)
diff --git a/l10n_mx_facturae/views/account_move.xml b/l10n_mx_facturae/views/account_move.xml
index d5144b7db1..90f997368a 100644
--- a/l10n_mx_facturae/views/account_move.xml
+++ b/l10n_mx_facturae/views/account_move.xml
@@ -36,12 +36,8 @@
type="object"
class="btn-primary"
attrs="{'invisible': [
- ('state', '!=', 'posted'),
- (
- 'cfdi_state',
- '!=',
- 'done'
- )
+ ('state', '!=', 'posted'),
+ ('cfdi_state', '!=', 'done')
]}"/>
<field name="is_cfdi_candidate" invisible="1" />
<field name="is_cancelable" invisible="1" />
--
GitLab
From f9f81b8de3c2bdaf8e29a57376f60d870d41d198 Mon Sep 17 00:00:00 2001
From: "ricardo.mendoza" <ricardo.mendoza@openpyme.mx>
Date: Mon, 22 Apr 2024 14:04:11 -0600
Subject: [PATCH 10/19] =?UTF-8?q?Se=20corrige=20la=20identaci=C3=B3n=20del?=
=?UTF-8?q?=20boton=20tal=20cual=20esta=20mostrada=20en=20el=20ejemplo=20g?=
=?UTF-8?q?it=20lab=20con=204=20espacios=20a=20su=20izquierda?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
l10n_mx_facturae/views/account_move.xml | 16 ++++++++--------
1 file changed, 8 insertions(+), 8 deletions(-)
diff --git a/l10n_mx_facturae/views/account_move.xml b/l10n_mx_facturae/views/account_move.xml
index 90f997368a..9bfd892623 100644
--- a/l10n_mx_facturae/views/account_move.xml
+++ b/l10n_mx_facturae/views/account_move.xml
@@ -32,15 +32,15 @@
<field name="arch" type="xml">
<button name="button_cancel" position="before">
<button name="l10n_mx_action_cancel"
- string="Cancel CFDI"
- type="object"
- class="btn-primary"
- attrs="{'invisible': [
- ('state', '!=', 'posted'),
- ('cfdi_state', '!=', 'done')
- ]}"/>
+ string="Cancel CFDI"
+ type="object"
+ class="btn-primary"
+ attrs="{'invisible': [
+ ('state', '!=', 'posted'),
+ ('cfdi_state', '!=', 'done')
+ ]}"/>
<field name="is_cfdi_candidate" invisible="1" />
- <field name="is_cancelable" invisible="1" />
+ <field name="is_cancelable" invisible="0" />
</button>
<xpath expr="//header" position="after">
<div
--
GitLab
From 7ec35c6afad7c5dea853dae8852f9f41394b19c2 Mon Sep 17 00:00:00 2001
From: "ricardo.mendoza" <ricardo.mendoza@openpyme.mx>
Date: Mon, 22 Apr 2024 18:06:59 -0600
Subject: [PATCH 11/19] =?UTF-8?q?Se=20agrego=20la=20funci=C3=B3n=20que=20c?=
=?UTF-8?q?ambia=20el=20estado=20de=20la=20celda=20is=5Fcancelable=20a=20T?=
=?UTF-8?q?rue=20cuando=20se=20presiona=20el=20boton=20Cancel=20CFDI?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
l10n_mx_facturae/models/account_move.py | 3 ++-
l10n_mx_facturae/views/account_move.xml | 2 +-
2 files changed, 3 insertions(+), 2 deletions(-)
diff --git a/l10n_mx_facturae/models/account_move.py b/l10n_mx_facturae/models/account_move.py
index 81bb604051..04ab01abd9 100644
--- a/l10n_mx_facturae/models/account_move.py
+++ b/l10n_mx_facturae/models/account_move.py
@@ -525,7 +525,8 @@ class AccountMove(models.Model):
return res
def l10n_mx_action_cancel(self):
- print("Hola Mundo")
+ # Call write() to update the is_cancelable field
+ self.write({'is_cancelable': True})
class AccountMoveLine(models.Model):
_inherit = "account.move.line"
diff --git a/l10n_mx_facturae/views/account_move.xml b/l10n_mx_facturae/views/account_move.xml
index 9bfd892623..2cde0e337c 100644
--- a/l10n_mx_facturae/views/account_move.xml
+++ b/l10n_mx_facturae/views/account_move.xml
@@ -40,7 +40,7 @@
('cfdi_state', '!=', 'done')
]}"/>
<field name="is_cfdi_candidate" invisible="1" />
- <field name="is_cancelable" invisible="0" />
+ <field name="is_cancelable" invisible="1" />
</button>
<xpath expr="//header" position="after">
<div
--
GitLab
From 88c0fd93497fbf7e55decd42f8afcd2846622592 Mon Sep 17 00:00:00 2001
From: "ricardo.mendoza" <ricardo.mendoza@openpyme.mx>
Date: Tue, 23 Apr 2024 11:23:19 -0600
Subject: [PATCH 12/19] Se agrega el ciclo que filtra a las facturas por
atributos
---
l10n_mx_facturae/models/account_move.py | 11 +++++++++++
1 file changed, 11 insertions(+)
diff --git a/l10n_mx_facturae/models/account_move.py b/l10n_mx_facturae/models/account_move.py
index 04ab01abd9..325d97e325 100644
--- a/l10n_mx_facturae/models/account_move.py
+++ b/l10n_mx_facturae/models/account_move.py
@@ -527,6 +527,17 @@ class AccountMove(models.Model):
def l10n_mx_action_cancel(self):
# Call write() to update the is_cancelable field
self.write({'is_cancelable': True})
+ # Get only invoices with related cfdi to cancel cfdi before cancel invoice
+ """Extend `AccountInvoice.action_cancel()`; Cancels the CFDI related to the
+ invoice
+ """
+ # Get only invoices with related cfdi to cancel cfdi before cancel invoice
+ cfdis = self.filtered(
+ lambda i:
+ i.journal_id.sign_sat
+ and i.cfdi_id
+ and i.cfdi_id.state not in ["draft", "cancel"]
+ )
class AccountMoveLine(models.Model):
_inherit = "account.move.line"
--
GitLab
From 85a3e046503f2c92988c84464ce16b3782cf3735 Mon Sep 17 00:00:00 2001
From: "ricardo.mendoza" <ricardo.mendoza@openpyme.mx>
Date: Tue, 23 Apr 2024 13:10:11 -0600
Subject: [PATCH 13/19] Se agrega el ciclo for y dentro de este manda el
mensaje al chatter siempre que el for se ejecute
---
l10n_mx_facturae/models/account_move.py | 12 ++++++++++++
1 file changed, 12 insertions(+)
diff --git a/l10n_mx_facturae/models/account_move.py b/l10n_mx_facturae/models/account_move.py
index 325d97e325..2a995c376a 100644
--- a/l10n_mx_facturae/models/account_move.py
+++ b/l10n_mx_facturae/models/account_move.py
@@ -538,6 +538,18 @@ class AccountMove(models.Model):
and i.cfdi_id
and i.cfdi_id.state not in ["draft", "cancel"]
)
+ for invoice in cfdis:
+ # Ensure we can cancel this invoice
+ invoice.check_if_can_cancel()
+ # If l10n_mx_edi_original_invoice is set save uuid to send info to PAC
+ # while cancel invoice
+ invoice.cfdi_id.substitute_cfdi_uuid = (
+ invoice.l10n_mx_edi_original_invoice.cfdi_id.uuid
+ )
+ invoice.message_post(
+ body=_("Cancellation request sent")
+ )
+ cancelacion = invoice.cancel_cfdi()[0]
class AccountMoveLine(models.Model):
_inherit = "account.move.line"
--
GitLab
From 990b2d682067fc446e16112adb9a3f65cb90b44d Mon Sep 17 00:00:00 2001
From: "ricardo.mendoza" <ricardo.mendoza@openpyme.mx>
Date: Tue, 23 Apr 2024 13:17:46 -0600
Subject: [PATCH 14/19] Se agregaron codiciones
---
l10n_mx_facturae/models/account_move.py | 13 +++++++++++++
1 file changed, 13 insertions(+)
diff --git a/l10n_mx_facturae/models/account_move.py b/l10n_mx_facturae/models/account_move.py
index 2a995c376a..1d29077802 100644
--- a/l10n_mx_facturae/models/account_move.py
+++ b/l10n_mx_facturae/models/account_move.py
@@ -550,6 +550,19 @@ class AccountMove(models.Model):
body=_("Cancellation request sent")
)
cancelacion = invoice.cancel_cfdi()[0]
+ if cancelacion:
+ # CFDI cancelled (cancelacion == True) must cancel invoice too
+ invoice.button_draft()
+ invoice.button_cancel()
+ elif cancelacion is None:
+ # CFDI set to approval (cancelacion == None) must set invoice
+ # to waiting too
+ invoice.write({"state": "waiting"})
+ elif cancelacion is False:
+ # CFDI cancel denied (cancelacion == False) must get back invoice
+ # to open state
+ self.undo_waiting_state()
+
class AccountMoveLine(models.Model):
_inherit = "account.move.line"
--
GitLab
From 5ef61504f349f89380285ea758fa1436ba7b29f1 Mon Sep 17 00:00:00 2001
From: "ricardo.mendoza" <ricardo.mendoza@openpyme.mx>
Date: Tue, 23 Apr 2024 18:19:30 -0600
Subject: [PATCH 15/19] =?UTF-8?q?Problema=20con=20la=20variable=20cancelac?=
=?UTF-8?q?i=C3=B3n=20dentro=20del=20ciclo=20for=20en=20la=20funcion=20l10?=
=?UTF-8?q?n=5Fmx=5Faction=5Fcancel?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
l10n_mx_facturae/models/account_move.py | 65 ++-----------------------
l10n_mx_facturae/views/account_move.xml | 1 +
2 files changed, 6 insertions(+), 60 deletions(-)
diff --git a/l10n_mx_facturae/models/account_move.py b/l10n_mx_facturae/models/account_move.py
index 1d29077802..312a8c1041 100644
--- a/l10n_mx_facturae/models/account_move.py
+++ b/l10n_mx_facturae/models/account_move.py
@@ -320,42 +320,6 @@ class AccountMove(models.Model):
# Create new CFDI object for this invoice
account_invoice.create_cfdi()
- def action_cancel(self):
- """Extend `AccountMove.action_cancel()`; Cancels the CFDI related to the
- invoice
- """
- # Get only invoices with related cfdi to cancel cfdi before cancel invoice
- cfdis = self.filtered(
- lambda i:
- i.journal_id.sign_sat
- and i.cfdi_id
- and i.cfdi_id.state not in ["draft", "cancel"]
- )
- for invoice in cfdis:
- # Ensure we can cancel this invoice
- invoice.check_if_can_cancel()
- # If l10n_mx_edi_original_invoice is set save uuid to send info to PAC
- # while cancel invoice
- invoice.cfdi_id.substitute_cfdi_uuid = (
- invoice.l10n_mx_edi_original_invoice.cfdi_id.uuid
- )
- cancelacion = invoice.cancel_cfdi()[0]
- if cancelacion:
- # CFDI cancelled (cancelacion == True) must cancel invoice too
- super(AccountMove, invoice).action_cancel()
- elif cancelacion is None:
- # CFDI set to approval (cancelacion == None) must set invoice
- # to waiting too
- invoice.write({"state": "waiting"})
- elif cancelacion is False:
- # CFDI cancel denied (cancelacion == False) must get back invoice
- # to open state
- self.undo_waiting_state()
-
- # Call super only with invoices without CFDI
- invoices = self - cfdis
- return super(AccountMove, invoices).action_cancel()
-
def undo_waiting_state(self):
"""When cancel is negate revert invoice to open and post account_move"""
for record in self:
@@ -525,12 +489,11 @@ class AccountMove(models.Model):
return res
def l10n_mx_action_cancel(self):
+ """Cancels the CFDI related to the invoice"""
+
# Call write() to update the is_cancelable field
- self.write({'is_cancelable': True})
- # Get only invoices with related cfdi to cancel cfdi before cancel invoice
- """Extend `AccountInvoice.action_cancel()`; Cancels the CFDI related to the
- invoice
- """
+ self.write({"is_cancelable": True})
+
# Get only invoices with related cfdi to cancel cfdi before cancel invoice
cfdis = self.filtered(
lambda i:
@@ -538,30 +501,12 @@ class AccountMove(models.Model):
and i.cfdi_id
and i.cfdi_id.state not in ["draft", "cancel"]
)
+
for invoice in cfdis:
- # Ensure we can cancel this invoice
- invoice.check_if_can_cancel()
- # If l10n_mx_edi_original_invoice is set save uuid to send info to PAC
- # while cancel invoice
- invoice.cfdi_id.substitute_cfdi_uuid = (
- invoice.l10n_mx_edi_original_invoice.cfdi_id.uuid
- )
invoice.message_post(
body=_("Cancellation request sent")
)
cancelacion = invoice.cancel_cfdi()[0]
- if cancelacion:
- # CFDI cancelled (cancelacion == True) must cancel invoice too
- invoice.button_draft()
- invoice.button_cancel()
- elif cancelacion is None:
- # CFDI set to approval (cancelacion == None) must set invoice
- # to waiting too
- invoice.write({"state": "waiting"})
- elif cancelacion is False:
- # CFDI cancel denied (cancelacion == False) must get back invoice
- # to open state
- self.undo_waiting_state()
class AccountMoveLine(models.Model):
diff --git a/l10n_mx_facturae/views/account_move.xml b/l10n_mx_facturae/views/account_move.xml
index 2cde0e337c..bd0ec404a5 100644
--- a/l10n_mx_facturae/views/account_move.xml
+++ b/l10n_mx_facturae/views/account_move.xml
@@ -36,6 +36,7 @@
type="object"
class="btn-primary"
attrs="{'invisible': [
+ '&',
('state', '!=', 'posted'),
('cfdi_state', '!=', 'done')
]}"/>
--
GitLab
From c6a747f3c993f3b1b2611bc951c2669943a2af3e Mon Sep 17 00:00:00 2001
From: "ricardo.mendoza" <ricardo.mendoza@openpyme.mx>
Date: Fri, 26 Apr 2024 12:26:20 -0600
Subject: [PATCH 16/19] Mensaje al chatter dentro del ciclo for y condiciones
agregadas funcionando correctamente al cancelar la factura
---
l10n_mx_facturae/models/account_move.py | 14 +++++++++++++-
1 file changed, 13 insertions(+), 1 deletion(-)
diff --git a/l10n_mx_facturae/models/account_move.py b/l10n_mx_facturae/models/account_move.py
index 312a8c1041..0f652b4d51 100644
--- a/l10n_mx_facturae/models/account_move.py
+++ b/l10n_mx_facturae/models/account_move.py
@@ -506,7 +506,19 @@ class AccountMove(models.Model):
invoice.message_post(
body=_("Cancellation request sent")
)
- cancelacion = invoice.cancel_cfdi()[0]
+ cancelacion = invoice.cancel_cfdi()
+ if cancelacion:
+ # CFDI cancelled (cancelacion == True) must cancel invoice too
+ invoice.button_draft()
+ invoice.button_cancel()
+ elif cancelacion is None:
+ # CFDI set to approval (cancelacion == None) must set invoice
+ # to waiting too
+ invoice.write({"state": "waiting"})
+ elif cancelacion is False:
+ # CFDI cancel denied (cancelacion == False) must get back invoice
+ # to open state
+ self.undo_waiting_state()
class AccountMoveLine(models.Model):
--
GitLab
From 818e5ef7997a80b21e14d09318e11c0087a3f636 Mon Sep 17 00:00:00 2001
From: "ricardo.mendoza" <ricardo.mendoza@openpyme.mx>
Date: Mon, 29 Apr 2024 12:37:16 -0600
Subject: [PATCH 17/19] Se hicieron las correcciones indicadas en los ultimos
comentarios agregados al merge
---
l10n_mx_facturae/models/account_move.py | 84 +++++++++++++------------
l10n_mx_facturae/views/account_move.xml | 1 -
2 files changed, 45 insertions(+), 40 deletions(-)
diff --git a/l10n_mx_facturae/models/account_move.py b/l10n_mx_facturae/models/account_move.py
index 0f652b4d51..2fb66e826a 100644
--- a/l10n_mx_facturae/models/account_move.py
+++ b/l10n_mx_facturae/models/account_move.py
@@ -154,10 +154,6 @@ class AccountMove(models.Model):
string="Merchandise export",
)
- is_cancelable = fields.Boolean(
- "Candidate is canceled"
- )
-
def button_validate(self):
"""
Extend `AccountMove.button_validate`: prevents to manipulate the
@@ -320,13 +316,56 @@ class AccountMove(models.Model):
# Create new CFDI object for this invoice
account_invoice.create_cfdi()
+ def l10n_mx_action_cancel(self):
+ """Cancels the CFDI related to the invoice"""
+
+ # Get only invoices with related cfdi to cancel cfdi before cancel invoice
+ cfdis = self.filtered(
+ lambda i:
+ i.journal_id.sign_sat
+ and i.cfdi_id
+ and i.cfdi_id.state not in ["draft", "cancel"]
+ )
+
+ for invoice in cfdis:
+ invoice.message_post(
+ body=_("Cancellation request sent")
+ )
+ cancelacion = invoice.cancel_cfdi()
+ if cancelacion:
+ # CFDI cancelled (cancelacion == True) must cancel invoice too
+ invoice.button_draft()
+ invoice.button_cancel()
+ elif cancelacion is None:
+ # CFDI set to approval (cancelacion == None) must set invoice
+ # to waiting too
+ invoice.write({"state": "posted"})
+ invoice.message_post(
+ body=_("Awaiting cancellation")
+ )
+ elif cancelacion is False:
+ # CFDI cancel denied (cancelacion == False) must get back invoice
+ # to open state
+ self.undo_waiting_state()
+ invoice.message_post(
+ body=_("Denied cancellation")
+ )
+
def undo_waiting_state(self):
"""When cancel is negate revert invoice to open and post account_move"""
for record in self:
- to_update = record.filtered(lambda i: i.state == "waiting")
- to_update.write({"state": "open"})
+ to_update = record.filtered(lambda i: i.cfdi_state == "waiting")
+ to_update.write({"state": "posted"})
to_update.mapped("move_id").post()
+ @api.depends("state", "cfdi_state")
+ def _compute_show_reset_to_draft_button(self):
+ super()._compute_show_reset_to_draft_button()
+
+ for move in self:
+ if move.state in ("posted", "cancel") and move.cfdi_state in ("signed", "done", "waiting", "cancel"):
+ move.show_reset_to_draft_button = False
+
def action_consult_cancellation_status(self):
"""Verify cancellation status"""
# TODO: Is this really needed? Maybe we can reuse the action_cancel
@@ -488,39 +527,6 @@ class AccountMove(models.Model):
return res
- def l10n_mx_action_cancel(self):
- """Cancels the CFDI related to the invoice"""
-
- # Call write() to update the is_cancelable field
- self.write({"is_cancelable": True})
-
- # Get only invoices with related cfdi to cancel cfdi before cancel invoice
- cfdis = self.filtered(
- lambda i:
- i.journal_id.sign_sat
- and i.cfdi_id
- and i.cfdi_id.state not in ["draft", "cancel"]
- )
-
- for invoice in cfdis:
- invoice.message_post(
- body=_("Cancellation request sent")
- )
- cancelacion = invoice.cancel_cfdi()
- if cancelacion:
- # CFDI cancelled (cancelacion == True) must cancel invoice too
- invoice.button_draft()
- invoice.button_cancel()
- elif cancelacion is None:
- # CFDI set to approval (cancelacion == None) must set invoice
- # to waiting too
- invoice.write({"state": "waiting"})
- elif cancelacion is False:
- # CFDI cancel denied (cancelacion == False) must get back invoice
- # to open state
- self.undo_waiting_state()
-
-
class AccountMoveLine(models.Model):
_inherit = "account.move.line"
diff --git a/l10n_mx_facturae/views/account_move.xml b/l10n_mx_facturae/views/account_move.xml
index bd0ec404a5..fd28448063 100644
--- a/l10n_mx_facturae/views/account_move.xml
+++ b/l10n_mx_facturae/views/account_move.xml
@@ -41,7 +41,6 @@
('cfdi_state', '!=', 'done')
]}"/>
<field name="is_cfdi_candidate" invisible="1" />
- <field name="is_cancelable" invisible="1" />
</button>
<xpath expr="//header" position="after">
<div
--
GitLab
From f4647afabe0adbcc4b97c0eec06156f958f64e2d Mon Sep 17 00:00:00 2001
From: "ricardo.mendoza" <ricardo.mendoza@openpyme.mx>
Date: Mon, 29 Apr 2024 15:56:41 -0600
Subject: [PATCH 18/19] Se elimina el campo state
---
l10n_mx_facturae/models/account_move.py | 4 ----
1 file changed, 4 deletions(-)
diff --git a/l10n_mx_facturae/models/account_move.py b/l10n_mx_facturae/models/account_move.py
index 2fb66e826a..3bdc1422f9 100644
--- a/l10n_mx_facturae/models/account_move.py
+++ b/l10n_mx_facturae/models/account_move.py
@@ -124,10 +124,6 @@ class AccountMove(models.Model):
"cfdi.use", "CFDI use", readonly=True, states={"draft": [("readonly", False)]}
)
cfdi_relation_type = fields.Many2one("cfdi.relation.type", "CFDI Relation type")
- state = fields.Selection(
- selection_add=[("waiting", _("To cancel"))],
- ondelete={'waiting': 'cascade'}
- )
l10n_mx_edi_to_cancel = fields.Char(
#compute="_compute_l10n_mx_edi_to_cancel",
#search="_search_l10n_mx_edi_to_cancel",
--
GitLab
From 9d464eb016b107084843d50a3553ced5bea4343a Mon Sep 17 00:00:00 2001
From: "jesus.lomas" <jesus.lomas@openpyme.mx>
Date: Mon, 29 Apr 2024 13:28:40 -0600
Subject: [PATCH 19/19] =?UTF-8?q?feat(res.company):=20a=20la=20compa=C3=B1?=
=?UTF-8?q?ia=20fronteriza=20se=20le=20agreg=C3=B3=20el=20regimen=20fiscal?=
=?UTF-8?q?=20y=20el=20uso=20del=20cfdi?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
a la compañia fronteriza se le agregó el regimen fiscal y el uso del cfdi, ademas se creo el parther
de Maria Olivia
---
l10n_mx_facturae/demo/demo_res_partner.xml | 27 ++++++++++++++++++++++
1 file changed, 27 insertions(+)
diff --git a/l10n_mx_facturae/demo/demo_res_partner.xml b/l10n_mx_facturae/demo/demo_res_partner.xml
index 941161b955..2ec790f9f7 100644
--- a/l10n_mx_facturae/demo/demo_res_partner.xml
+++ b/l10n_mx_facturae/demo/demo_res_partner.xml
@@ -25,4 +25,31 @@
<field name="payment_method_id" ref="l10n_mx_base.cfdi_payment_method_1"/>
</record>
+ <record id="l10n_mx_ir_attachment_facturae.demo_partner_company_mx_frontier" model="res.partner">
+ <field name="cfdi_fiscal_regime_id" ref="l10n_mx_base.regime_fiscal_601"/>
+ <field name="cfdi_use_id" ref="l10n_mx_base.cfdi_use_S01"/>
+ </record>
+
+ <record id="l10n_mx_ir_attachment_facturae.res_company_mx_frontier" model="res.company">
+ <field name="cfdi_fiscal_regime_id" ref="l10n_mx_base.regime_fiscal_601"/>
+ <field name="cfdi_use_id" ref="l10n_mx_base.cfdi_use_S01"/>
+ </record>
+
+ <record id="res_partner_2024" model="res.partner">
+ <field name="name">Maria Olivia Martinez Sagaz</field>
+ <field name="is_company">1</field>
+ <field name="street">45 10 oriente</field>
+ <field name="city">Culiacán</field>
+ <field name="state_id" ref="base.state_mx_sin"/>
+ <field name="zip">80290</field>
+ <field name="vat">MXMASO451221PM4</field>
+ <field name="phone">(870)-931-0505</field>
+ <field name="country_id" ref="base.mx"/>
+ <field name="email">maria.martinez@example.com</field>
+ <field name="company_id" ref="l10n_mx_ir_attachment_facturae.res_company_mx_frontier"/>
+ <field name="cfdi_fiscal_regime_id" ref="l10n_mx_base.regime_fiscal_616"/>
+ <field name="cfdi_use_id" ref="l10n_mx_base.cfdi_use_S01"/>
+ <field name="payment_method_id" ref="l10n_mx_base.cfdi_payment_method_1"/>
+ </record>
+
</odoo>
--
GitLab