464 lines
14 KiB
Python
464 lines
14 KiB
Python
#!/usr/bin/env python3
|
|
|
|
import datetime
|
|
import getpass
|
|
import json
|
|
import logging
|
|
import os
|
|
import re
|
|
from io import BytesIO
|
|
from pathlib import Path
|
|
|
|
import lxml.etree as ET
|
|
|
|
from finkok import PACFinkok
|
|
from comercio import PACComercioDigital
|
|
from pycert import SATCertificate
|
|
|
|
|
|
LOG_FORMAT = '%(asctime)s - %(levelname)s - %(message)s'
|
|
LOG_DATE = '%d/%m/%Y %H:%M:%S'
|
|
logging.addLevelName(logging.ERROR, '\033[1;41mERROR\033[1;0m')
|
|
logging.addLevelName(logging.DEBUG, '\x1b[33mDEBUG\033[1;0m')
|
|
logging.addLevelName(logging.INFO, '\x1b[32mINFO\033[1;0m')
|
|
logging.basicConfig(level=logging.DEBUG, format=LOG_FORMAT, datefmt=LOG_DATE)
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
PACs = {
|
|
'finkok': PACFinkok,
|
|
'comercio': PACComercioDigital,
|
|
}
|
|
NS_CFDI = {
|
|
'cfdi': 'http://www.sat.gob.mx/cfd/3',
|
|
}
|
|
|
|
|
|
def _exists(path):
|
|
if not path:
|
|
return False
|
|
return Path(path).exists()
|
|
|
|
|
|
def _join(*paths):
|
|
return str(Path(paths[0]).joinpath(*paths[1:]))
|
|
|
|
|
|
class CFDI(object):
|
|
_version = '3.3'
|
|
_prefix = 'cfdi'
|
|
_xmlns = 'http://www.sat.gob.mx/cfd/3'
|
|
schema = f'{_xmlns} http://www.sat.gob.mx/sitio_internet/cfd/3/cfdv33.xsd'
|
|
_pagos = 'http://www.sat.gob.mx/Pagos'
|
|
PAGOS = {
|
|
'version': '1.0',
|
|
'prefix': _pagos,
|
|
'ns': {'pago10': _pagos},
|
|
'schema': f' {_pagos} http://www.sat.gob.mx/sitio_internet/cfd/Pagos/Pagos10.xsd',
|
|
}
|
|
_nomina = 'http://www.sat.gob.mx/nomina12'
|
|
NOMINA = {
|
|
'version': '1.2',
|
|
'prefix': _nomina,
|
|
'ns': {'nomina12': _nomina},
|
|
'schema': f' {_nomina} http://www.sat.gob.mx/sitio_internet/cfd/nomina/nomina12.xsd',
|
|
}
|
|
|
|
def __init__(self, data):
|
|
self.error = ''
|
|
self._root = None
|
|
self._cfdi = self._make_cfdi(data)
|
|
|
|
@property
|
|
def xml(self):
|
|
return self._cfdi
|
|
|
|
def save(self, path):
|
|
doc = ET.ElementTree(self._root)
|
|
doc.write(path, pretty_print=True, encoding='utf-8',
|
|
doctype='<?xml version="1.0" encoding="utf-8"?>')
|
|
return
|
|
|
|
def _make_cfdi(self, data):
|
|
self._validate_data(data)
|
|
self._comprobante(data['comprobante'])
|
|
self._relacionados(data.get('relacionados', {}))
|
|
self._emisor(data['emisor'])
|
|
self._receptor(data['receptor'])
|
|
self._conceptos(data['conceptos'])
|
|
self._impuestos(data.get('impuestos', {}))
|
|
self._complementos(data)
|
|
|
|
xml = ET.tostring(self._root,
|
|
pretty_print=True, xml_declaration=True, encoding='utf-8')
|
|
return xml.decode()
|
|
|
|
def _validate_data(self, data):
|
|
self._schema = self.schema
|
|
self._exists_pagos = 'pagos' in data
|
|
self._exists_nomina = 'nomina' in data
|
|
self._node_complement = False
|
|
|
|
if self._exists_pagos:
|
|
self._node_complement = True
|
|
self._schema += self.PAGOS['schema']
|
|
if self._exists_nomina:
|
|
self._node_complement = True
|
|
self._schema += self.NOMINA['schema']
|
|
return
|
|
|
|
def _comprobante(self, attr):
|
|
NSMAP = {
|
|
self._prefix: self._xmlns,
|
|
'xsi': 'http://www.w3.org/2001/XMLSchema-instance',
|
|
}
|
|
if self._exists_pagos:
|
|
NSMAP.update(self.PAGOS['ns'])
|
|
if self._exists_nomina:
|
|
NSMAP.update(self.NOMINA['ns'])
|
|
|
|
attr_qname = ET.QName(
|
|
'http://www.w3.org/2001/XMLSchema-instance', 'schemaLocation')
|
|
schema = {attr_qname: self._schema}
|
|
|
|
if not 'Version' in attr:
|
|
attr['Version'] = self._version
|
|
|
|
node_name = f'{{{self._xmlns}}}Comprobante'
|
|
self._root = ET.Element(node_name, schema, **attr, nsmap=NSMAP)
|
|
return
|
|
|
|
def _relacionados(self, attr):
|
|
|
|
return
|
|
|
|
def _emisor(self, attr):
|
|
node_name = f'{{{self._xmlns}}}Emisor'
|
|
emisor = ET.SubElement(self._root, node_name, attr)
|
|
return
|
|
|
|
def _receptor(self, attr):
|
|
node_name = f'{{{self._xmlns}}}Receptor'
|
|
emisor = ET.SubElement(self._root, node_name, attr)
|
|
return
|
|
|
|
def _conceptos(self, data):
|
|
node_name = f'{{{self._xmlns}}}Conceptos'
|
|
conceptos = ET.SubElement(self._root, node_name)
|
|
for row in data:
|
|
complemento = row.pop('complemento', {})
|
|
taxes = row.pop('impuestos', {})
|
|
|
|
node_name = f'{{{self._xmlns}}}Concepto'
|
|
concepto = ET.SubElement(conceptos, node_name, row)
|
|
|
|
if not taxes:
|
|
continue
|
|
|
|
if taxes['traslados'] or taxes['retenciones']:
|
|
node_name = f'{{{self._xmlns}}}Impuestos'
|
|
impuestos = ET.SubElement(concepto, node_name)
|
|
if 'traslados' in taxes and taxes['traslados']:
|
|
node_name = f'{{{self._xmlns}}}Traslados'
|
|
traslados = ET.SubElement(impuestos, node_name)
|
|
node_name = f'{{{self._xmlns}}}Traslado'
|
|
for traslado in taxes['traslados']:
|
|
ET.SubElement(traslados, node_name, traslado)
|
|
if 'retenciones' in taxes and taxes['retenciones']:
|
|
node_name = f'{{{self._xmlns}}}Retenciones'
|
|
retenciones = ET.SubElement(impuestos, node_name)
|
|
node_name = f'{{{self._xmlns}}}Retencion'
|
|
for retencion in taxes['retenciones']:
|
|
ET.SubElement(retenciones, node_name, retencion)
|
|
return
|
|
|
|
def _impuestos(self, data):
|
|
if not data:
|
|
return
|
|
|
|
node_name = f'{{{self._xmlns}}}Impuestos'
|
|
# ~ ET.SubElement(self._root, node_name)
|
|
|
|
retenciones = data.pop('retenciones', ())
|
|
traslados = data.pop('traslados', ())
|
|
taxes = ET.SubElement(self._root, node_name, data)
|
|
|
|
if retenciones:
|
|
node_name = f'{{{self._xmlns}}}Retenciones'
|
|
subnode = ET.SubElement(taxes, node_name)
|
|
node_name = f'{{{self._xmlns}}}Retencion'
|
|
for row in retenciones:
|
|
ET.SubElement(subnode, node_name, row)
|
|
|
|
if traslados:
|
|
node_name = f'{{{self._xmlns}}}Traslados'
|
|
subnode = ET.SubElement(taxes, node_name)
|
|
node_name = f'{{{self._xmlns}}}Traslado'
|
|
for row in traslados:
|
|
ET.SubElement(subnode, node_name, row)
|
|
|
|
return
|
|
|
|
def _complementos(self, data):
|
|
if not self._node_complement:
|
|
return
|
|
|
|
node_name = f'{{{self._xmlns}}}Complemento'
|
|
complemento = ET.SubElement(self._root, node_name)
|
|
|
|
if self._exists_pagos:
|
|
self._pagos(complemento, data['pagos'])
|
|
|
|
if self._exists_nomina:
|
|
self._nomina(complemento, data['nomina'])
|
|
return
|
|
|
|
def _pagos(self, complemento, data):
|
|
node_name = f"{{{self.PAGOS['prefix']}}}Pagos"
|
|
attr = {'Version': self.PAGOS['version']}
|
|
node_pagos = ET.SubElement(complemento, node_name, attr)
|
|
for pago in data:
|
|
documentos = pago.pop('documentos')
|
|
node_name = f"{{{self.PAGOS['prefix']}}}Pago"
|
|
node_pago = ET.SubElement(node_pagos, node_name, pago)
|
|
node_name = f"{{{self.PAGOS['prefix']}}}DoctoRelacionado"
|
|
for doc in documentos:
|
|
ET.SubElement(node_pago, node_name, doc)
|
|
return
|
|
|
|
def _nomina(self, complemento, data):
|
|
emisor = data.pop('emisor')
|
|
receptor = data.pop('receptor')
|
|
percepciones = data.pop('percepciones', {})
|
|
deducciones = data.pop('deducciones', {})
|
|
otros = data.pop('otros', ())
|
|
|
|
if not 'Version' in data:
|
|
data['Version'] = self.NOMINA['version']
|
|
|
|
node_name = f"{{{self.NOMINA['prefix']}}}Nomina"
|
|
node_nomina = ET.SubElement(complemento, node_name, data)
|
|
node_name = f"{{{self.NOMINA['prefix']}}}Emisor"
|
|
ET.SubElement(node_nomina, node_name, emisor)
|
|
node_name = f"{{{self.NOMINA['prefix']}}}Receptor"
|
|
ET.SubElement(node_nomina, node_name, receptor)
|
|
|
|
if percepciones:
|
|
attr = percepciones
|
|
percepciones = attr.pop('percepciones')
|
|
node_name = f"{{{self.NOMINA['prefix']}}}Percepciones"
|
|
node = ET.SubElement(node_nomina, node_name, attr)
|
|
node_name = f"{{{self.NOMINA['prefix']}}}Percepcion"
|
|
for percepcion in percepciones:
|
|
ET.SubElement(node, node_name, percepcion)
|
|
|
|
if deducciones:
|
|
attr = deducciones
|
|
deducciones = attr.pop('deducciones')
|
|
node_name = f"{{{self.NOMINA['prefix']}}}Deducciones"
|
|
node = ET.SubElement(node_nomina, node_name, attr)
|
|
node_name = f"{{{self.NOMINA['prefix']}}}Deduccion"
|
|
for deduccion in deducciones:
|
|
ET.SubElement(node, node_name, deduccion)
|
|
|
|
if otros:
|
|
node_name = f"{{{self.NOMINA['prefix']}}}OtrosPagos"
|
|
node = ET.SubElement(node_nomina, node_name)
|
|
node_name = f"{{{self.NOMINA['prefix']}}}OtroPago"
|
|
for otro in otros:
|
|
subsidio = otro.pop('subsidio', {})
|
|
sub_node = ET.SubElement(node, node_name, otro)
|
|
if subsidio:
|
|
sub_name = f"{{{self.NOMINA['prefix']}}}SubsidioAlEmpleo"
|
|
ET.SubElement(sub_node, sub_name, subsidio)
|
|
return
|
|
|
|
|
|
def _validate_args_validar_cert(args):
|
|
data = {}
|
|
path_cert = args.dir_cert
|
|
name = args.nombre
|
|
|
|
if not _exists(path_cert):
|
|
msg = 'La ruta con los certificados es requerida'
|
|
log.error(msg)
|
|
return False, data
|
|
|
|
path_cer = _join(path_cert, f'{name}.cer')
|
|
path_key = _join(path_cert, f'{name}.key')
|
|
path_enc = _join(path_cert, f'{name}.enc')
|
|
|
|
if not _exists(path_cer):
|
|
msg = f'No se encontró el archivo CER en: {path_cer}'
|
|
log.error(msg)
|
|
return False, data
|
|
|
|
if not _exists(path_key):
|
|
msg = f'No se encontró el archivo KEY en: {path_key}'
|
|
log.error(msg)
|
|
return False, data
|
|
|
|
password = getpass.getpass('Introduce tu clave del archivo KEY: ')
|
|
if not password.strip():
|
|
msg = 'La clave es requerida'
|
|
log.error(msg)
|
|
return False, data
|
|
|
|
data['cer'] = path_cer
|
|
data['key'] = path_key
|
|
data['pass'] = password
|
|
data['enc'] = path_enc
|
|
|
|
return True, data
|
|
|
|
|
|
|
|
def validar_cert(args):
|
|
result, data = _validate_args_validar_cert(args)
|
|
if not result:
|
|
return
|
|
|
|
cer = open(data['cer'], 'rb').read()
|
|
key = open(data['key'], 'rb').read()
|
|
cert = SATCertificate(cer, key, password=data['pass'])
|
|
|
|
if cert.error:
|
|
log.error(cert.error)
|
|
return
|
|
|
|
if cert.is_fiel:
|
|
msg = 'El certificado es FIEL, no podrás timbrar.'
|
|
log.error(msg)
|
|
return
|
|
|
|
Path(data['enc']).write_bytes(cert.key_enc)
|
|
|
|
msg = 'Los datos del certificado son:'
|
|
log.info(msg)
|
|
log.info(f'\n{cert}')
|
|
msg = 'Puedes timbrar con estos certificados'
|
|
log.info(msg)
|
|
return
|
|
|
|
|
|
def _make(path, target):
|
|
with open(path, 'r', encoding='utf-8') as f:
|
|
data = json.loads(f.read())
|
|
|
|
cfdi = CFDI(data)
|
|
p = Path(path)
|
|
new_path = f'{target}/{p.stem}.xml'
|
|
cfdi.save(new_path)
|
|
log.info(f'\tGenerado: {new_path}')
|
|
return
|
|
|
|
|
|
def make(source, target):
|
|
docs = get_files(source, 'json')
|
|
for doc in docs:
|
|
log.info(f'Generando: {doc}')
|
|
_make(doc, target)
|
|
return
|
|
|
|
|
|
def _stamp(path, target):
|
|
current_path = os.path.dirname(__file__)
|
|
path_cer = join(current_path, 'certificados')
|
|
path_xslt = join(current_path, 'xslt', 'cadena.xslt')
|
|
doc = ET.parse(path)
|
|
|
|
for pac in PACs.keys():
|
|
xslt = open(path_xslt, 'rb')
|
|
cer = read_file(join(path_cer, f'{pac}.cer'))
|
|
key = read_file(join(path_cer, f'{pac}.enc'))
|
|
cert = SATCertificate(cer, key)
|
|
# ~ print(cert)
|
|
|
|
root = doc.getroot()
|
|
root.attrib['Fecha'] = datetime.datetime.now().isoformat()[:19]
|
|
root.attrib['NoCertificado'] = cert.serial_number
|
|
root.attrib['Certificado'] = cert.cer_txt
|
|
emisor = root.xpath('//cfdi:Emisor', namespaces=NS_CFDI)[0]
|
|
emisor.attrib['Rfc'] = cert.rfc
|
|
emisor.attrib['RegimenFiscal'] = '601'
|
|
|
|
transfor = ET.XSLT(ET.parse(xslt))
|
|
cadena = str(transfor(doc)).encode()
|
|
stamp = cert.sign(cadena)
|
|
root.attrib['Sello'] = stamp
|
|
xslt.close()
|
|
|
|
p = Path(path)
|
|
new_path = f'{target}/{p.stem}_{pac}.xml'
|
|
doc.write(new_path, pretty_print=True, encoding='utf-8',
|
|
doctype='<?xml version="1.0" encoding="utf-8"?>')
|
|
log.info(f'\tSellado: {new_path}')
|
|
|
|
return
|
|
|
|
|
|
def stamp(source, target):
|
|
docs = get_files(source)
|
|
for doc in docs:
|
|
log.info(f'Sellando: {doc}')
|
|
_stamp(doc, target)
|
|
return
|
|
|
|
|
|
def _stamp_pac(path, target):
|
|
pac = None
|
|
for key in PACs.keys():
|
|
if key in path:
|
|
pac = PACs[key]()
|
|
break
|
|
|
|
if pac is None:
|
|
msg = 'Diferente PAC en documento'
|
|
log.debug(msg)
|
|
return
|
|
|
|
data = open(path, 'rb').read()
|
|
xml = pac.stamp(data)
|
|
|
|
if pac.error:
|
|
log.error(pac.error)
|
|
return
|
|
|
|
p = Path(path)
|
|
new_path = f'{target}/{p.stem}_timbrada.xml'
|
|
|
|
with open(new_path, 'w') as f:
|
|
f.write(xml)
|
|
log.info(f'\tTimbrada: {new_path}')
|
|
return
|
|
|
|
|
|
def stamp_pac(source, target):
|
|
docs = get_files(source)
|
|
for doc in docs:
|
|
log.info(f'Enviando: {doc}')
|
|
_stamp_pac(doc, target)
|
|
return
|
|
|
|
|
|
def read_file(path):
|
|
with open(path, 'rb') as f:
|
|
data = f.read()
|
|
return data
|
|
|
|
|
|
|
|
|
|
def get_files(path, ext='xml'):
|
|
docs = []
|
|
for folder, _, files in os.walk(path):
|
|
pattern = re.compile('\.{}'.format(ext), re.IGNORECASE)
|
|
docs += [join(folder,f) for f in files if pattern.search(f)]
|
|
return tuple(docs)
|
|
|
|
|
|
|
|
|
|
def _replace_ext(path, ext):
|
|
return str(Path(path).with_suffix(ext))
|