def init(self):
origin = "Comprobante.init()"
try:
recovering_parser = etree.XMLParser(recover=True)
if os.path.isfile(self.get_Abspath()):
document = etree.parse(self.get_Abspath(),
parser=recovering_parser)
self.raiz = document.getroot()
self.name_spaces = {
'xsi': 'http://www.w3.org/2001/XMLSchema-instance',
'cfdi': 'http://www.sat.gob.mx/cfd/3',
'tfd': 'http://www.sat.gob.mx/TimbreFiscalDigital',
'nomina': 'http://www.sat.gob.mx/nomina',
'nomina12': 'http://www.sat.gob.mx/nomina12'
}
except Exception, error:
if type(error).__name__ == "XMLSyntaxError":
raise Error("validacion", origin, "xml corrupto", str(error))
else:
raise Error(type(error).__name__, origin, "", str(error))
def update_Comprobacion(self, _comprobante):
origin = "ModeloComprobanteEmpleado.update_Comprobacion()"
try:
connection.close()
comprobante = ComprobanteEmpleado.objects.get(
uuid=_comprobante.uuid)
comprobante.comprobacion = _comprobante.comprobacion
file_name = _comprobante.nombre.replace('xml', 'pdf').replace(
'XML', 'PDF')
file_abspath = _comprobante.get_Abspath().replace('xml',
'pdf').replace(
'XML', 'PDF')
comprobante.archivo_pdf.save(file_name,
File(open(file_abspath, 'r')))
# comprobante.save()
print "Se actualizo el comprobante: {}".format(_comprobante.uuid)
except Exception as error:
raise Error(type(error).__name__, origin, "", str(error))
def read_Emisor_DomicilioFiscal_Node(self):
origin = "Comprobante.read_Emisor_DomicilioFiscal_Node()"
try:
# obtener nodo
nodo = self.raiz.find('cfdi:Emisor', self.name_spaces).find(
'cfdi:DomicilioFiscal', self.name_spaces)
# obtener datos
self.emisor_calle = self.get_Value_Nodo(nodo, ['calle'], "char")
self.emisor_noExterior = self.get_Value_Nodo(
nodo, ['noExterior'], "char")
self.emisor_noInterior = self.get_Value_Nodo(
nodo, ['noInterior'], "char")
self.emisor_colonia = self.get_Value_Nodo(nodo, ['colonia'],
"char")
self.emisor_localidad = self.get_Value_Nodo(
nodo, ['localidad'], "char")
self.emisor_municipio = self.get_Value_Nodo(
nodo, ['municipio'], "char")
self.emisor_estado = self.get_Value_Nodo(nodo, ['estado'], "char")
self.emisor_pais = self.get_Value_Nodo(nodo, ['pais'], "char")
self.emisor_codigoPostal = self.get_Value_Nodo(
nodo, ['codigoPostal'], "int")
return True
except Exception, error:
raise Error(type(error).__name__, origin, "", str(error))
def read_Nomina12_Deducciones_Node(self):
origin = "Comprobante.read_Nomina12_Deducciones_Node()"
try:
nodos = self.raiz.find('cfdi:Complemento', self.name_spaces).find(
'nomina12:Nomina',
self.name_spaces).find('nomina12:Deducciones',
self.name_spaces)
self.deducciones_totalOtrasDeducciones = self.get_Value_Nodo(
nodos, ['TotalOtrasDeducciones'], "float")
self.deducciones_totalImpuestosRetenidos = self.get_Value_Nodo(
nodos, ['TotalImpuestosRetenidos'], "float")
for nodo in nodos:
item = {
'TipoDeduccion':
self.get_Value_Nodo(nodo, ['TipoDeduccion'], "char"),
'Clave':
self.get_Value_Nodo(nodo, ['Clave'], "char"),
'Concepto':
self.get_Value_Nodo(nodo, ['Concepto'], "char"),
'Importe':
self.get_Value_Nodo(nodo, ['Importe'], "char"),
}
self.deducciones.append(item)
return True
except Exception, error:
raise Error(type(error).__name__, origin, "", str(error))
def read_Conceptos_Node(self):
origin = "Comprobante.read_Impuestos_Retenciones()"
try:
nodos = self.raiz.find('cfdi:Conceptos', self.name_spaces)
for nodo in nodos:
item = {
"cantidad":
self.get_Value_Nodo(nodo, ['cantidad'], "char"),
"unidad":
self.get_Value_Nodo(nodo, ['unidad'], "char"),
"noIdentificacion":
self.get_Value_Nodo(nodo, ['noIdentificacion'], "char"),
"descripcion":
self.get_Value_Nodo(nodo, ['descripcion'], "char"),
"valorUnitario":
self.get_Value_Nodo(nodo, ['valorUnitario'], "char"),
"importe":
self.get_Value_Nodo(nodo, ['importe'], "char")
}
self.conceptos.append(item)
return True
except Exception, error:
raise Error(type(error).__name__, origin, "", str(error))
def read_Emisor_ExpedidoEn_Node(self):
origin = "Comprobante.read_Emisor_ExpedidoEn_Node()"
try:
# obtener nodo
nodo = self.raiz.find('cfdi:Emisor', self.name_spaces).find(
'cfdi:ExpedidoEn', self.name_spaces)
# obtener datos
self.emisor_expedidoEn_calle = self.get_Value_Nodo(
nodo, ['calle'], "char")
self.emisor_expedidoEn_noExterior = self.get_Value_Nodo(
nodo, ['noExterior'], "char")
self.emisor_expedidoEn_noInterior = self.get_Value_Nodo(
nodo, ['noInterior'], "char")
self.emisor_expedidoEn_colonia = self.get_Value_Nodo(
nodo, ['colonia'], "char")
self.emisor_expedidoEn_municipio = self.get_Value_Nodo(
nodo, ['municipio'], "char")
self.emisor_expedidoEn_estado = self.get_Value_Nodo(
nodo, ['estado'], "char")
self.emisor_expedidoEn_pais = self.get_Value_Nodo(
nodo, ['pais'], "char")
return True
except Exception, error:
raise Error(type(error).__name__, origin, "", str(error))
def read_Receptor_Domicilio_Node(self):
origin = "Comprobante.read_Receptor_Domicilio_Node()"
try:
nodo = self.raiz.find('cfdi:Receptor', self.name_spaces).find(
'cfdi:Domicilio', self.name_spaces)
self.receptor_calle = self.get_Value_Nodo(nodo, ['calle'], "char")
self.receptor_noExterior = self.get_Value_Nodo(
nodo, ['noExterior'], "char")
self.receptor_noInterior = self.get_Value_Nodo(
nodo, ['noInterior'], "char")
self.receptor_colonia = self.get_Value_Nodo(
nodo, ['colonia'], "char")
self.receptor_localidad = self.get_Value_Nodo(
nodo, ['localidad'], "char")
self.receptor_municipio = self.get_Value_Nodo(
nodo, ['municipio'], "char")
self.receptor_estado = self.get_Value_Nodo(nodo, ['estado'],
"char")
self.receptor_pais = self.get_Value_Nodo(nodo, ['pais'], "char")
self.receptor_codigoPostal = self.get_Value_Nodo(
nodo, ['codigoPostal'], "char")
except Exception, error:
raise Error(type(error).__name__, origin, "", str(error))
def save_InSmart(self, _file):
origin = "Sentinel.save_InSmart()"
try:
ModeloComprobanteEmpleado.add(_file)
self.log.line("Guardar en SmartCFDI.......OK")
except Exception as error:
if error.control == "registro ya existe":
self.log.line("Guardar en SmartCFDI.......Ya existe en BD")
else:
self.log.line(
"Guardar en SmartCFDI (SentinelNomina).......%s" %
(error.mensaje))
self.log.line(
"(SentinelNomina)No se pudo guardar en SmartCFDI por lo cual se movera a NO_PROCESADAS"
)
self.move_To_NoProcesadas(_file, _with_pdf=False)
raise Error("validacion", origin, "error al guardar in smart",
str(error))
def get_Estado(self, emisor_rfc, receptor_rfc, total, uuid):
""" Posibles valores de retorno:
Vigente
Cancelado
Desconocido
"""
origin = "WebServiceSAT.get_Estado()"
datos = self.mensajeSoap.format(emisor_rfc, receptor_rfc, total,
uuid).encode('utf-8')
cabecera = {
'SOAPAction': '"http://tempuri.org/IConsultaCFDIService/Consulta"',
'Content-length': len(datos),
'Content-type': 'text/xml; charset="UTF-8"'
}
sesion_ = Session()
request_ = Request('POST',
self.webservice,
data=datos,
headers=cabecera)
prepped = request_.prepare()
try:
response = sesion_.send(prepped, timeout=5)
tree = ElementTree.fromstring(response.text.encode('utf-8'))
estado = tree[0][0][0][1].text
return estado
except Exception, error:
raise Error(type(error).__name__, origin, "", str(error))
def read_Nomina_Percepciones_Node(self):
origin = "Comprobante.read_Nomina_Percepciones_Node()"
try:
nodos = self.raiz.find('cfdi:Complemento', self.name_spaces).find(
'nomina:Nomina',
self.name_spaces).find('nomina:Percepciones', self.name_spaces)
self.percepciones_totalGravado = self.get_Value_Nodo(
nodos, ['TotalGravado'], "float")
self.percepciones_totalExento = self.get_Value_Nodo(
nodos, ['TotalExento'], "float")
for nodo in nodos:
item = {
'TipoPercepcion':
self.get_Value_Nodo(nodo, ['TipoPercepcion'], "char"),
'Clave':
self.get_Value_Nodo(nodo, ['Clave'], "char"),
'Concepto':
self.get_Value_Nodo(nodo, ['Concepto'], "char"),
'ImporteGravado':
self.get_Value_Nodo(nodo, ['ImporteGravado'], "char"),
'ImporteExento':
self.get_Value_Nodo(nodo, ['ImporteExento'], "char")
}
self.percepciones.append(item)
return True
except Exception, error:
raise Error(type(error).__name__, origin, "", str(error))
def validate_Estado_InSat(self, _file):
origin = "Sentinel.validate_Estado_InSat()"
try:
webservice = WebServiceSAT()
estado_sat = webservice.get_Estado(_file.emisor_rfc,
_file.receptor_rfc, _file.total,
_file.uuid)
_file.estadoSat = estado_sat.encode('utf-8')
_file.fecha_validacion = datetime.now().date()
self.log.line("Estado en SAT ......%s" %
(estado_sat.encode('utf-8')))
except Exception as error:
self.log.line("Validar estado en SAT.......%s" % (str(error)))
self.log.line(
"No se pudo validar el estado en el portal SAT, por lo cual se movera a NO_ENCONTRADAS_SAT"
)
self.move_To_NoEncontradasSAT(_file, _with_pdf=True)
raise Error("validacion", origin, "error al obtener estado sat",
str(error))
def read_Nomina_HorasExtras(self):
origin = "Comprobante.read_Nomina_HorasExtras()"
try:
nodos = self.raiz.find('cfdi:Complemento', self.name_spaces).find(
'nomina:Nomina',
self.name_spaces).find('nomina:HorasExtras', self.name_spaces)
for nodo in nodos:
item = {
'Dias':
self.get_Value_Nodo(nodo, ['Dias'], "char"),
'TipoHoras':
self.get_Value_Nodo(nodo, ['TipoHoras'], "char"),
'ImportePagado':
self.get_Value_Nodo(nodo, ['ImportePagado'], "char")
}
self.horasExtras.append(item)
return True
except Exception, error:
raise Error(type(error).__name__, origin, "", str(error))
def read_Nomina12_Node(self):
origin = "Comprobante.read_Nomina12_Node()"
try:
nodo = self.raiz.find('cfdi:Complemento', self.name_spaces).find(
'nomina12:Nomina', self.name_spaces)
#1.2
self.tipoNomina = self.get_Value_Nodo(nodo, ['TipoNomina'], "char")
self.totalDeducciones = self.get_Value_Nodo(
nodo, ['TotalDeducciones'], "float")
self.totalPercepciones = self.get_Value_Nodo(
nodo, ['TotalPercepciones'], "float")
self.version = self.get_Value_Nodo(nodo, ['Version'], "char")
#/1.2
self.fechaInicialPago = self.get_Value_Nodo(
nodo, ['FechaInicialPago'], "date")
self.fechaFinalPago = self.get_Value_Nodo(nodo, ['FechaFinalPago'],
"date")
self.numDiasPagados = self.get_Value_Nodo(nodo, ['NumDiasPagados'],
"float")
self.fechaPago = self.get_Value_Nodo(nodo, ['FechaPago'], "date")
return True
except Exception, error:
raise Error(type(error).__name__, origin, "", str(error))
def get_ByClave(self, _clave):
origin = "ModeloEmailAccount.get_ByClave()"
try:
connection.close()
registro = EmailAccount.objects.get(clave=_clave)
return registro
except Exception as error:
if type(error).__name__ == 'DoesNotExist':
raise Error("validacion", origin, "no proveedor",
"No se encontro cuenta %s" % (_clave))
else:
raise Error(type(error).__name__, origin, "", str(error))
def get_ByRfc(self, _rfc):
origin = "ModeloEmpresa.get_ByRfc()"
try:
connection.close()
empresa = Empresa.objects.get(rfc=_rfc, activa=True)
return empresa
except Exception as error:
if type(error).__name__ == 'DoesNotExist':
raise Error("validacion", origin, "no empresa",
"No se encontro empresa")
else:
raise Error(type(error).__name__, origin, "", str(error))
def get_ByRfc(self, _rfc):
origin = "ModeloF0101.get()"
try:
connection.close()
registro = F0101.objects.using('jde_p').get(rfc__contains=_rfc,
tipo__contains="V")
return registro
except Exception as error:
if type(error).__name__ == 'DoesNotExist':
raise Error("validacion", origin, "no proveedor",
"No se encontro proveedor %s" % (_rfc))
else:
raise Error(type(error).__name__, origin, "", str(error))
def get(self, _uuid):
origin = "ModeloComprobanteEmpleado.get()"
try:
connection.close()
factura = ComprobanteEmpleado.objects.get(uuid=_uuid)
return factura
except Exception as error:
raise Error(type(error).__name__, origin, "", str(error))
def add(self, _comprobante):
origin = "ModeloF5903000.add()"
try:
connection.close()
registro = F5903000(
ftgenkey=_comprobante.uuid,
fttax=_comprobante.emisor_rfc,
fttaxs=_comprobante.receptor_rfc,
ftbrtpo="CXP",
ftcrcd=_comprobante.moneda[0:3],
ftcrr=Validator.convert_ToFloat(_comprobante.tipoCambio),
ftamrt1=Validator.convert_ToFloat(_comprobante.total) * 10000,
ftamrt2=Validator.convert_ToFloat(_comprobante.subTotal) *
10000,
ftamrt3=Validator.convert_ToFloat(_comprobante.total) * 10000,
fturcd=0,
ftupmj=Validator.convert_ToJulianJDE(datetime.now().date()),
ftlo01='5',
ftuser='******',
ftpid='SYNFAC',
ftjobn='ENDTOEND',
ftivd=Validator.convert_ToJulianJDE(_comprobante.fecha),
ftan8=_comprobante.emisor_jde_clave)
# ftan8 = _comprobante.getClaveProveedorJDE()
registro.save(using="jde_p")
return "Se guardo el comprobante: {}".format(_comprobante.uuid)
except Exception as error:
if type(error).__name__ == "IntegrityError":
raise Error("validacion", origin, "registro ya existe",
str(error))
else:
raise Error(type(error).__name__, origin, "", str(error))
def read_Emisor_RegimenFiscal_Node(self):
origin = "Comprobante.read_Emisor_RegimenFiscal_Node()"
try:
nodo = self.raiz.find('cfdi:Emisor', self.name_spaces).find(
'cfdi:RegimenFiscal', self.name_spaces)
self.emisor_regimen = self.get_Value_Nodo(nodo, ['Regimen'],
"char")
return True
except Exception, error:
raise Error(type(error).__name__, origin, "", str(error))
def validate_Extension(self, _file):
origin = "Sentinel.validate_Extension()"
if _file.extension == ".xml" or _file.extension == ".XML":
self.log.line("Extension del archivo.......XML")
elif _file.extension == ".pdf" or _file.extension == ".PDF":
self.log.line(
"Extension del archivo.......PDF (Se movera junto con el archivo XML)"
)
raise Error("validacion", origin, "Extension PDF",
"La extension es PDF")
else:
self.log.line(
"Archivo con extension no esperada.......%s. (Se movera a no procesados)"
% (_file.extension))
self.move_To_NoProcesadas(_file, _with_pdf=False)
raise Error("validacion", origin, "extension desconocida",
"La extension es Desconocida")
def update_SatStatus(self, _comprobante):
origin = "ModeloComprobanteEmpleado.update_SatStatus()"
try:
connection.close()
comprobante = ComprobanteEmpleado.objects.get(
uuid=_comprobante.uuid)
comprobante.estadoSat = _comprobante.estadoSat
comprobante.fecha_validacion = _comprobante.fecha_validacion
comprobante.save()
print "Se actualizo el comprobante: {}".format(_comprobante.uuid)
except Exception as error:
raise Error(type(error).__name__, origin, "", str(error))
def read_Impuestos_Node(self):
origin = "Comprobante.read_Impuestos_Node()"
try:
nodo = self.raiz.find('cfdi:Impuestos', self.name_spaces)
self.totalImpuestosTrasladados = self.get_Value_Nodo(
nodo, ['totalImpuestosTrasladados'], "float")
self.totalImpuestosRetenidos = self.get_Value_Nodo(
nodo, ['totalImpuestosRetenidos'], "float")
return True
except Exception, error:
raise Error(type(error).__name__, origin, "", str(error))
def read_Nomina12_Emisor_Node(self):
origin = "Comprobante.read_Nomina12_Emisor_Node()"
try:
nodo = self.raiz.find('cfdi:Complemento', self.name_spaces).find(
'nomina12:Nomina',
self.name_spaces).find('nomina12:Emisor', self.name_spaces)
#1.2
self.registroPatronal = self.get_Value_Nodo(
nodo, ['TipoNomina'], "char")
#/1.2
return True
except Exception, error:
raise Error(type(error).__name__, origin, "", str(error))
def read_File(self, _file):
origin = "Sentinel.read_File()"
_file.read()
if _file.uuid != "":
self.log.line(_file)
else:
self.log.line(
"No se encontro UUID en el archivo XML, por lo cual se movera a NO_PROCESADAS"
)
self.move_To_NoProcesadas(_file, _with_pdf=True)
raise Error("validacion", origin, "no uuid",
"El archivo no contiene UUID")
def read_Receptor_Node(self):
origin = "Comprobante.read_Receptor_Node()"
try:
nodo = self.raiz.find('cfdi:Receptor', self.name_spaces)
self.receptor_rfc = self.get_Value_Nodo(nodo, ['rfc', 'Rfc'],
"char")
self.receptor_nombre = self.get_Value_Nodo(nodo,
['nombre', 'Nombre'],
"char")
return True
except Exception, error:
raise Error(type(error).__name__, origin, "", str(error))
def read_Nomina_Node(self):
origin = "Comprobante.read_Nomina_Node()"
try:
nodo = self.raiz.find('cfdi:Complemento', self.name_spaces).find(
'nomina:Nomina', self.name_spaces)
self.registroPatronal = self.get_Value_Nodo(
nodo, ['RegistroPatronal'], "char")
self.numEmpleado = self.get_Value_Nodo(nodo, ['NumEmpleado'],
"char")
self.curp = self.get_Value_Nodo(nodo, ['CURP'], "char")
self.tipoRegimen = self.get_Value_Nodo(nodo, ['TipoRegimen'],
"char")
self.numSeguridadSocial = self.get_Value_Nodo(
nodo, ['NumSeguridadSocial'], "char")
self.fechaPago = self.get_Value_Nodo(nodo, ['FechaPago'], "date")
self.fechaInicialPago = self.get_Value_Nodo(
nodo, ['FechaInicialPago'], "date")
self.fechaFinalPago = self.get_Value_Nodo(nodo, ['FechaFinalPago'],
"date")
self.numDiasPagados = self.get_Value_Nodo(nodo, ['NumDiasPagados'],
"int")
self.clabe = self.get_Value_Nodo(nodo, ['CLABE'], "char")
self.banco = self.get_Value_Nodo(nodo, ['Banco'], "char")
self.fechaInicioRelLaboral = self.get_Value_Nodo(
nodo, ['FechaInicioRelLaboral'], "date")
self.antiguedad = self.get_Value_Nodo(nodo, ['Antiguedad'], "int")
self.puesto = self.get_Value_Nodo(nodo, ['Puesto'], "char")
self.tipoJornada = self.get_Value_Nodo(nodo, ['TipoJornada'],
"char")
self.periodicidadPago = self.get_Value_Nodo(
nodo, ['PeriodicidadPago'], "char")
self.riesgoPuesto = self.get_Value_Nodo(nodo, ['RiesgoPuesto'],
"char")
self.salarioDiarioIntegrado = self.get_Value_Nodo(
nodo, ['SalarioDiarioIntegrado'], "float")
return True
except Exception, error:
raise Error(type(error).__name__, origin, "", str(error))
def read_Nomina12_Receptor_Node(self):
origin = "Comprobante.read_Nomina12_Recepror_Node()"
try:
nodo = self.raiz.find('cfdi:Complemento', self.name_spaces).find(
'nomina12:Nomina',
self.name_spaces).find('nomina12:Receptor', self.name_spaces)
#1.2
self.tipoContrato = self.get_Value_Nodo(nodo, ['TipoContrato'],
"char")
self.salarioBaseCotApor = self.get_Value_Nodo(
nodo, ['SalarioBaseCotApor'], "float")
self.cveEntidadFederativa = self.get_Value_Nodo(
nodo, ['ClaveEntFed'], "char")
self.cuentaBancaria = self.get_Value_Nodo(nodo, ['CuentaBancaria'],
"char")
self.departamento = self.get_Value_Nodo(nodo, ['Departamento'],
"char")
#/1.2
self.curp = self.get_Value_Nodo(nodo, ['CURP', 'Curp'], "char")
self.numSeguridadSocial = self.get_Value_Nodo(
nodo, ['NumSeguridadSocial'], "char")
self.fechaInicioRelLaboral = self.get_Value_Nodo(
nodo, ['FechaInicioRelLaboral'], "date")
#self.antiguedad = self.get_Value_Nodo(nodo, ['Antigüedad'], "char")
self.tipoJornada = self.get_Value_Nodo(nodo, ['TipoJornada'],
"char")
self.tipoRegimen = self.get_Value_Nodo(nodo, ['TipoRegimen'],
"char")
self.numEmpleado = self.get_Value_Nodo(nodo, ['NumEmpleado'],
"char")
self.puesto = self.get_Value_Nodo(nodo, ['Puesto'], "char")
self.riesgoPuesto = self.get_Value_Nodo(nodo, ['RiesgoPuesto'],
"char")
self.periodicidadPago = self.get_Value_Nodo(
nodo, ['PeriodicidadPago'], "char")
self.salarioDiarioIntegrado = self.get_Value_Nodo(
nodo, ['SalarioDiarioIntegrado'], "float")
return True
except Exception, error:
raise Error(type(error).__name__, origin, "", str(error))
def create_Folder_NoValidas(self, _file):
origin = "Sentinel.create_Folder_NoValidas()"
new_folders = [
"procesadas", _file.empresa_clave,
_file.fecha.strftime('%Y'),
_file.fecha.strftime('%m'), "no_validas", _file.emisor_rfc
]
abspath_novalidas = os.path.join(self.folder.abspath, *new_folders)
folder_novalidas = Carpeta(abspath_novalidas)
try:
self.folder.add_Folders(new_folders)
folder_novalidas.exist(origin)
self.log.line("Creacion de folder NO_VALIDAS (CXP).......OK")
return folder_novalidas
except Exception as error:
if error.control == "carpeta ya existe":
self.log.line(
"Creacion de folder NO_VALIDAS (CXP).......Carpeta ya existe"
)
return folder_novalidas
else:
self.log.line("Creacion de folder NO_VALIDAS (CXP).......%s" %
(str(error)))
self.log.line(
"No se logro crear el folder de NO_VALIDAS(CXP), por lo que se movera a NO_PROCESADAS"
)
self.move_To_NoProcesadas(_file, _with_pdf=True)
raise Error("validacion", origin,
"error al crear carpeta no_validas", str(error))
def read_Complemento_Node(self):
origin = "Comprobante.read_Complemento_Node()"
try:
nodo = self.raiz.find('cfdi:Complemento', self.name_spaces).find(
'tfd:TimbreFiscalDigital', self.name_spaces)
self.uuid = self.get_Value_Nodo(nodo, ['UUID'], "char").upper()
self.fechaTimbrado = self.get_Value_Nodo(nodo, ['FechaTimbrado'],
"date")
self.noCertificadoSAT = self.get_Value_Nodo(
nodo, ['noCertificadoSAT', 'NoCertificadoSAT'], "char")
self.selloSAT = self.get_Value_Nodo(nodo, ['selloSAT', 'SelloSAT'],
"char")
return True
except Exception, error:
raise Error(type(error).__name__, origin, "", str(error))
def read_Emisor_Node(self):
origin = "Comprobante.read_Emisor_Node()"
try:
# Obtener nodo
nodo = self.raiz.find('cfdi:Emisor', self.name_spaces)
self.emisor_rfc = self.get_Value_Nodo(nodo, ['rfc', 'Rfc'],
"char").upper()
self.emisor_nombre = self.get_Value_Nodo(nodo,
['nombre', 'Nombre'],
"char").upper()
self.emisor_regimen = self.get_Value_Nodo(nodo, ['RegimenFiscal'],
"char")
return True
except Exception, error:
raise Error(type(error).__name__, origin, "", str(error))
