def __evaluar_archivo_tipo_jsonline(self, origen, archivo):
l = 0
js = []
# abrir el archivo json descargado del origen
with open(archivo, "r", encoding="utf8") as archivojson:
for line in archivojson:
js.append(json.loads(line))
# archivo destino para cargar los json al king fisher
outfile_name = self.__obtener_directorio_kingfisher(origen) + origen + "_" + str(uuid.uuid4()) + ".json"
# archivo hash para agregar los nuevos hash
archivo_hash = open(pb.Publicadores.publicador_archivo_hash(origen), "a")
# ciclo para analizar cada linea json
for p in js:
hs = self.__obtener_hash(json.dumps(p)) # convertir el json string a un hash md5
# buscar el hash en el archivo hash
if not self.__buscar_hash(origen, hs): # de no existir el hash
if l == 0:
outfile = open(outfile_name, "w")
l = l + 1
# guardar el nuevo hash
archivo_hash.writelines(hs + "\n")
# pasar el json string al nuevo archivo para cargarlo al king fisher
outfile.writelines(str(json.dumps(p)) + "\n")
log.registrar_log_info(__name__, err.EdcaErrores.INFO_ARMAR_ARCHIVOS_GENERICO, self.__event_log,
"Release a Procesar en KingFisher= " + str(l))
archivo_hash.close() # cerrar archivo de hash
outfile.close() # cerrar archivo de json para el king fisher
archivojson.close() # cerrar archivo json origen
def __mover_archivos_historico(self, origen, directorio):
# obtener la carpeta historica del origen o sistema
__directorio_historico = self.__obtener_directorio_historico(origen)
# Copiar los archivos a la carpeta historica
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_CARGAR_ARCHIVOS_GENERICO,
self.__event_log, "Copiando JSON de " + directorio + " --> " +
__directorio_historico)
util.EdcaUtil.move_file_to(
"*", directorio, __directorio_historico
) # utilitario para mover los archivos json al una carpeta destino
# Comprimir todos los archivos json en la carpeta historico
#if os.listdir(__directorio_historico) != 0:
if util.EdcaUtil.existen_archivos_json(__directorio_historico):
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_CARGAR_ARCHIVOS_GENERICO,
self.__event_log, "Comprimiendo los JSON historicos a ZIP")
for archivo in self.__obtener_archivos(
__directorio_historico
): # obtener todos los json file del historico
# comprimir archivo
zp.ZipTools.comprimir(archivo, __directorio_historico)
# borrar todos los archviso JSon dejando exclusivo los ZIP
util.EdcaUtil.borrar_archivo(archivo)
def guardar_datos(self, query):
cur = self.conn.cursor()
try:
cur.execute(query=query)
# log.registrar_log_info(__name__, err.EdcaErrores.INFO_BITACORA_SUCCESS_TXN,
# "BITACORA", msg.EdcaMensajes.obt_mensaje(err.EdcaErrores.INFO_BITACORA_SUCCESS_TXN))
self.__confirmar_transaccion()
return cur
except psycopg2.Error as dbError:
log.registrar_log_exception(__name__,
("Codigo Error: " + str(dbError.pgcode) + " Mensaje: " + dbError.pgerror))
def actualizar_sequencia(self, funcion, tabla, seq_anterior, seq_actual):
cur = self.conn.cursor()
try:
cur.callproc(funcion, (tabla, seq_anterior, seq_actual))
self.__confirmar_transaccion()
# log.registrar_log_info(__name__, err.EdcaErrores.INFO_BITACORA_UPD_SEQ,
# "BITACORA", msg.EdcaMensajes.obt_mensaje(err.EdcaErrores.INFO_BITACORA_UPD_SEQ))
return cur
except psycopg2.Error as dbError:
log.registrar_log_exception(__name__,
("Codigo Error: " + str(dbError.pgcode) + " Mensaje: " + dbError.pgerror))
def validar_directorio(directorio):
if not os.path.exists(directorio):
log.registrar_log_error(
__name__, err.EdcaErrores.ERR_PUBLISHER_DIR_NOT_EXIST,
"VALIDAR PUBLICADOR",
msg.EdcaMensajes.obt_mensaje(
err.EdcaErrores.ERR_PUBLISHER_DIR_NOT_EXIST) % directorio)
os.makedirs(directorio)
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_PUBLISHER_DIR_CREATED,
"VALIDAR PUBLICADOR",
msg.EdcaMensajes.obt_mensaje(
err.EdcaErrores.INFO_PUBLISHER_DIR_CREATED) % directorio)
def descomprimir(archivo, dir_extraer):
try:
zip_ref = zipfile.ZipFile(archivo, 'r')
zip_list = zip_ref.infolist()
for contenido in zip_list:
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_ZIPTOOL_PRINT_DIR,
"EXTRAER ARCHIVO",
msg.EdcaMensajes.obt_mensaje(
err.EdcaErrores.INFO_ZIPTOOL_PRINT_DIR) %
contenido.filename)
zip_ref.extractall(dir_extraer)
zip_ref.close()
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_ZIPTOOL_UNZIP,
"EXTRAER ARCHIVO",
msg.EdcaMensajes.obt_mensaje(
err.EdcaErrores.INFO_ZIPTOOL_UNZIP))
except PermissionError:
log.registrar_log_error(
__name__, err.EdcaErrores.ERR_ZIPTOOL_UNZIP, "EXTRAER ARCHIVO",
msg.EdcaMensajes.obt_mensaje(err.EdcaErrores.ERR_ZIPTOOL_UNZIP)
% PermissionError.filename % PermissionError.strerror)
except IOError:
log.registrar_log_error(
__name__, err.EdcaErrores.ERR_ZIPTOOL_UNZIP, "EXTRAER ARCHIVO",
msg.EdcaMensajes.obt_mensaje(err.EdcaErrores.ERR_ZIPTOOL_UNZIP)
% IOError.filename % IOError.strerror)
def __leer_archivo_json_tipo_release(self, origen, archivo):
print("******* ABRIENDO ARCHIVO JSON DE TIPO RELEASE ********")
# abrir el archivo json descargado del origen
with open(archivo, "r") as archivojson:
data = archivojson.read()
# deserializando del string a json
js = json.loads(data)
# copia del archivo
jx = json.loads(data)
# limpiar el arreglo de releases del archivo para carga king fisher
jx["releases"] = []
# archivo hash para agregar los nuevos hash
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_ARMAR_ARCHIVOS_GENERICO,
"ARMAR JSON RELEASE",
"Cantidad de Releases en el Archivo JSON: " +
str(len(js["releases"])))
lineas = len(js["releases"])
# Se valida si el archivo HASH existe o no
if not util.EdcaUtil.validar_existe_archivo(
pb.Publicadores.publicador_archivo_hash(origen)):
# archivo hash para agregar los nuevos hash
archivo_hash = open(
pb.Publicadores.publicador_archivo_hash(origen),
"w",
encoding='utf-8')
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_ARMAR_ARCHIVOS_GENERICO,
"ARMAR JSON RELEASE", "Archivo HASH: " +
str(archivo_hash) + ", creado exitosamente.")
# contador para saber si hay nuevos releases para cargar
x = 0
# ciclo para analizar el arreglos de json de los releases
for index, p in enumerate(js["releases"]):
print("Releases: " + str(p))
# convertir el json string a un hash md5
hash_datos = self._generar_publicador_hash(json.dumps(p))
print("HASH: " + hash_datos)
print("Index: " + str(index) + " X: " + str(lineas))
if index != (lineas - 1):
archivo_hash.writelines(hash_datos + '\n')
else:
archivo_hash.writelines(hash_datos)
# Acumulador
x = x + 1
archivo_hash.close()
else:
print("ARCHIVO HASH EXISTE")
def __limpiar_carpeta(self, directorio):
log.registrar_log_info(__name__,
err.EdcaErrores.INFO_CARGAR_ARCHIVOS_GENERICO,
self.__event_log,
"Limpiar los archivos JSON de " + directorio)
# Borrar todos los archivos
for archivo in self.__obtener_archivos(
directorio): # obtener todos los json file del historico
# borrar todos los archviso JSon dejando exclusivo los ZIP
try:
util.EdcaUtil.borrar_archivo(archivo)
except Exception as ex:
print(str(ex))
log.registrar_log_info(__name__,
err.EdcaErrores.INFO_CARGAR_ARCHIVOS_GENERICO,
self.__event_log,
"Directorio " + directorio + " limpiado.")
def comprimir(archivo, dir_comprimir):
__archivo_zip = archivo[:archivo.find(".")] + ".zip"
try:
with zipfile.ZipFile(__archivo_zip, 'w',
zipfile.ZIP_DEFLATED) as archivoZip:
archivoZip.write(archivo)
archivoZip.close()
except PermissionError:
log.registrar_log_error(
__name__, err.EdcaErrores.ERR_ZIPTOOL_UNZIP, "EXTRAER ARCHIVO",
msg.EdcaMensajes.obt_mensaje(err.EdcaErrores.ERR_ZIPTOOL_UNZIP)
% PermissionError.filename % PermissionError.strerror)
except IOError:
log.registrar_log_error(
__name__, err.EdcaErrores.ERR_ZIPTOOL_UNZIP, "EXTRAER ARCHIVO",
msg.EdcaMensajes.obt_mensaje(err.EdcaErrores.ERR_ZIPTOOL_UNZIP)
% IOError.filename % IOError.strerror)
def registrar_bitacora(publicador, origen, archivo):
# Se valida si debe almacenar la transaccion en la base de datos
if cfn.bitacora:
db = DaBitacora()
__bitacora = TransaccionesBitacora(
db, publicador, origen, glb.catalogo_download,
zp.ZipTools.obtener_contenido_zip(archivo))
__bitacora.guardar_bitacora()
__txnid = __bitacora.obtener_txn
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_BITACORA_SUCCESS_TXN,
"BITACORA",
msg.EdcaMensajes.obt_mensaje(
err.EdcaErrores.INFO_BITACORA_SUCCESS_TXN).format(__txnid))
else:
log.registrar_log_info(__name__, "BT-0001", "BITACORA",
"Registrar Bitacora esta: DESHABILITADO")
def obtener_contenido_zip(archivo):
global zp
try:
zip_ref = zipfile.ZipFile(archivo, 'r')
zip_list = zip_ref.infolist()
for contenido in zip_list:
zp = contenido.filename
zip_ref.close()
return zp
except PermissionError:
log.registrar_log_error(
__name__, err.EdcaErrores.ERR_ZIPTOOL_UNZIP, "EXTRAER ARCHIVO",
msg.EdcaMensajes.obt_mensaje(err.EdcaErrores.ERR_ZIPTOOL_UNZIP)
% PermissionError.filename % PermissionError.strerror)
except IOError:
log.registrar_log_error(
__name__, err.EdcaErrores.ERR_ZIPTOOL_UNZIP, "EXTRAER ARCHIVO",
msg.EdcaMensajes.obt_mensaje(err.EdcaErrores.ERR_ZIPTOOL_UNZIP)
% IOError.filename % IOError.strerror)
def run(self):
log.registrar_log_info(__name__, err.EdcaErrores.INFO_OCDS_HUNTER_THREAD_START, "THREADS", "Iniciando el Thread: %s" % self.name)
# Se realiza el bloqueo para sincronizar el thread
threadLock.acquire()
log.registrar_log_info(__name__, err.EdcaErrores.INFO_OCDS_HUNTER_THREAD_LOCK, "THREADS", "Thread Adquirio Bloqueo: %s" % self.name)
# Se incia el proceso del publicador
PublicadoresTareas.PublicadoresTareas(self.publicador).ejecutar()
log.registrar_log_info(__name__, err.EdcaErrores.INFO_OCDS_HUNTER_THREAD_FINISH, "THREADS", "Thread Finalizo Tarea: %s" % self.name)
# Se libera el thread
threadLock.release()
log.registrar_log_info(__name__, err.EdcaErrores.INFO_OCDS_HUNTER_THREAD_UNLOCK, "THREADS", "Se libera el Thread: %s" % self.name)
def job_sefin():
print("***************************")
print("* Publicador: SEFIN *")
print("* Programado: 04:00 AM *")
print("* Frecuencia: Semanal *")
print("***************************")
# Se cargan las tareas de los publicadores
try:
threads = []
# Create new threads
thread1 = OcdsHunterThread(2, "Thread-Job-SEFIN", "HN.SEFIN")
# Start new Threads
thread1.start()
# Add threads to thread list
threads.append(thread1)
# Wait for all threads to complete
for t in threads:
t.join()
log.registrar_log_info(__name__, err.EdcaErrores.INFO_OCDS_HUNTER_THREAD_GENERAL, "THREADS", "**** SIN JOBS PARA PROCESAR **** : %s")
except Exception as ex:
print(str(ex))
def ejecutar(self):
try:
log.registrar_log_info(__name__, err.EdcaErrores.INFO_BUILD_FILEFROMKF_BEGIN, self.__event_log,
"======= ETAPA 2 =======")
# ser recorren todos los origenes del publicador
for origen in self.__origenes:
__directorio = self.__obtener_ruta_descarga(origen) # se obtiene el directorio donde estan los archivos
__archivos = self.__obtener_archivos(__directorio) # se obtiene la lista de los archivos json
# se lee la lista de archivos.
for archivo in __archivos:
log.registrar_log_info(__name__, err.EdcaErrores.INFO_ARMAR_ARCHIVOS_GENERICO, self.__event_log,
"Leyendo Archivo: " + archivo)
# se recupera el tipo de archivo json
__tipo = self.__obtener_tipo_archivo_json(origen)
if cfg.tipo_archivo_json_line == __tipo: # funcion para evaluar json line
self.__evaluar_archivo_tipo_jsonline(origen, archivo)
if cfg.tipo_archivo_releasepackage == __tipo: # funcion para evaluar release package
self.__evaluar_archivo_tipo_release(origen, archivo)
log.registrar_log_info(__name__, err.EdcaErrores.INFO_ARMAR_ARCHIVOS_GENERICO, self.__event_log,
"Archivo leido : " + archivo)
except Exception as ex:
log.registrar_log_info(__name__, err.EdcaErrores.INFO_ARMAR_ARCHIVOS_GENERICO, self.__event_log,
str(ex.with_traceback()))
def __evaluar_archivo_tipo_release(self, origen, archivo):
# print("evaluar archivo tipo release")
log.registrar_log_info(__name__, err.EdcaErrores.INFO_ARMAR_ARCHIVOS_GENERICO, self.__event_log,
"evaluar archivo tipo release")
# abrir el archivo json descargado del origen
with open(archivo, "r") as archivojson:
data = archivojson.read()
# deserializando el string a json
js = json.loads(data)
jx = json.loads(data) # copia del archivo.
jx["releases"] = [] # limpiar el arreglo de releases del archivo para carga king fisher
# archivo hash para agregar los nuevos hash
archivo_hash = open(pb.Publicadores.publicador_archivo_hash(origen), "a")
l = 0 # contador para saber si hay nuevos releases para cargar
# ciclo para analizar el arreglos de json de los releases
for p in js["releases"]:
hs = self.__obtener_hash(json.dumps(p)) # convertir el json string a un hash md5
if not self.__buscar_hash(origen, hs):
l = l + 1 # contando cada releases nuevo
archivo_hash.writelines(hs + "\n") # guardar el nuevo hash
jx["releases"].append(p) # agregando el releases nuevo
# Se guarda el valor
self.releases_nuevos = str(l)
log.registrar_log_info(__name__, err.EdcaErrores.INFO_ARMAR_ARCHIVOS_GENERICO, self.__event_log,
"Release a Procesar en KingFisher= " + str(l))
if l != 0: # hay nuevos releases?
# guardar el release package en el archivo destino para cargar al king fisher
outfile_name = self.__obtener_directorio_kingfisher(origen) + origen + "_" + str(uuid.uuid4()) + ".json"
with open(outfile_name, 'w') as outfile:
json.dump(jx, outfile)
# print("Listo para cargar : " + outfile_name)
log.registrar_log_info(__name__, err.EdcaErrores.INFO_ARMAR_ARCHIVOS_GENERICO, self.__event_log,
"Listo para cargar : " + outfile_name)
outfile.close() # cerrar archivo de json para el king fisher
archivo_hash.close() # cerrar archivo de hash
archivojson.close() # cerrar archivo json origen
def ejecutar(self):
# ser recorren todos los origenes del publicador
for origen in self.__origenes:
# Se obtiene el directorio de descarga del archivo JSON del Publicador y Sistema
__directorio = self.__obtener_publicador_directorio_json(origen)
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_ARMAR_ARCHIVOS_GENERICO,
'ARMAR ARCHIVOS',
'Directorio del Archivo JSON: ' + __directorio)
# Se obtiene el archivo JSON del Publicador y Sistema
__archivo_json = self.__obtener_publicador_archivo_json(
__directorio)
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_ARMAR_ARCHIVOS_GENERICO,
'ARMAR ARCHIVOS',
'Archivo JSON a preparar: ' + str(__archivo_json[0]))
# Se obtiene el directorio HASH del Publicador y Sistema
__directorio_hash = self.__obtener_publicador_directorio_hash(
origen)
util.EdcaUtil.validar_directorio(__directorio_hash)
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_ARMAR_ARCHIVOS_GENERICO,
'ARMAR ARCHIVOS',
'Directorio del Archivo HASH: ' + str(__directorio_hash))
# Se procesa la lista de archivos
for archivo in __archivo_json:
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_ARMAR_ARCHIVOS_GENERICO,
'ARMAR ARCHIVOS', 'Iniciando a preparar Archivo JSON: ' +
str(__archivo_json[0]))
# Se obtiene el tipo de JSON del archivo del Publicador
__tipo = self.__obtener_publicador_tipo_archivo_json(origen)
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_ARMAR_ARCHIVOS_GENERICO,
'ARMAR ARCHIVOS', 'El Tipo de Archivo JSON es: ' + __tipo)
# Se evalua el tipo de archivo JSON del Publicador
if 'release-package' == __tipo:
self.__preparar_json_release(origen, archivo)
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_ARMAR_ARCHIVOS_GENERICO,
'ARMAR ARCHIVOS', 'Preparacion de Archivo JSON: ' +
archivo + ', Finalizado.')
def __preparar_json_release(self, origen, archivo):
# Se valida si el archivo HASH existe o no
if not util.EdcaUtil.validar_existe_archivo(
pb.Publicadores.publicador_archivo_hash(origen)):
# archivo hash para agregar los nuevos hash
archivo_hash = open(
pb.Publicadores.publicador_archivo_hash(origen),
"a",
encoding='utf-8')
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_ARMAR_ARCHIVOS_GENERICO,
"ARMAR JSON RELEASE", "Archivo HASH: " + str(archivo_hash) +
", creado exitosamente.")
print("******* ABRIENDO ARCHIVO JSON DE TIPO RELEASE ********")
# abrir el archivo json descargado del origen
with open(archivo, "r") as archivojson:
data = archivojson.read()
# deserializando del string a json
js = json.loads(data)
# copia del archivo
jx = json.loads(data)
# limpiar el arreglo de releases del archivo para carga king fisher
jx["releases"] = []
# archivo hash para agregar los nuevos hash
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_ARMAR_ARCHIVOS_GENERICO,
"ARMAR JSON RELEASE",
"Cantidad de Releases en el Archivo JSON: " +
str(len(js["releases"])))
lineas = len(js["releases"])
# contador para saber si hay nuevos releases para cargar
x = 0
# ciclo para analizar el arreglos de json de los releases
for index, p in enumerate(js["releases"]):
print("Releases: " + str(p))
# convertir el json string a un hash md5
hash_datos = self._generar_publicador_hash(json.dumps(p))
print("HASH: " + hash_datos)
print("Index: " + str(index) + " X: " + str(lineas))
if index != (lineas - 1):
archivo_hash.writelines(hash_datos + '\n')
else:
archivo_hash.writelines(hash_datos)
# Acumulador
x = x + 1
# Se cierra el archivo HASH
archivo_hash.close()
else:
print("***ARCHIVO HASH EXISTE***")
print("INICIANDO COMPARACION DE HASH PARA IDENTIFICAR QUE CAMBIO")
print("******* ABRIENDO ARCHIVO JSON DE TIPO RELEASE ********")
# abrir el archivo json descargado del origen
with open(archivo, "r") as archivojson:
data = archivojson.read()
# deserializando del string a json
js = json.loads(data)
# copia del archivo
jx = json.loads(data)
# limpiar el arreglo de releases del archivo para carga king fisher
jx["releases"] = []
# archivo hash para agregar los nuevos hash
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_ARMAR_ARCHIVOS_GENERICO,
"ARMAR JSON RELEASE",
"Cantidad de Releases en el Archivo JSON: " +
str(len(js["releases"])))
lineas2 = len(js["releases"])
# ciclo para analizar el arreglos de json de los releases
print("******* ABRIENDO ARCHIVO HASH ********")
# abrir el archivo json descargado del origen
with open(pb.Publicadores.publicador_archivo_hash(origen),
"r") as archivohash:
hash_data = archivohash.readline()
# contador para saber si hay nuevos releases para cargar
y = 0
for index, p in enumerate(js["releases"]):
print("Releases: " + str(p))
# convertir el json string a un hash md5
hash_datos = self._generar_publicador_hash(
json.dumps(p))
print("HASH ARCHIVO JSON: " + hash_datos)
# ciclo para analizar el arreglos de json de los releases
#while hash_data:
print("LINEA ARCHIVO HASH {}: {} ".format(
y, hash_data.rstrip()))
if not str(hash_data).rstrip() == str(hash_datos):
print("NO SON IGUALES")
#if index != (lineas2 - 1):
#archivo_hash = open(pb.Publicadores.publicador_archivo_hash(origen), "a", encoding='utf-8')
#archivo_hash.writelines(hash_datos + '\n')
else:
print("RELEASE HASH YA EXISTE, NO TIENE CAMBIOS")
hash_data = archivohash.readline()
# Acumulador
y = y + 1
# Se cierra el archivo HASH
archivohash.close()
def borrar_archivo(archivo):
os.remove(archivo)
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_ZIPTOOL_CLEAN_FILES, "LIMPIAR ZIP",
msg.EdcaMensajes.obt_mensaje(
err.EdcaErrores.INFO_ZIPTOOL_CLEAN_FILES) % archivo)
def ejecutar(self):
try:
log.registrar_log_info(__name__,
err.EdcaErrores.INFO_LOAD_FILEFROMKF_BEGIN,
self.__event_log, "======= ETAPA 3 =======")
# Cursor para recorrer todos los origen o sistemas del publicador,
# el objetivo es por origen cargar los archivos JSon procesados al King Fisher
for origen in self.__origenes:
# se obtiene el directorio de carga king fisher del origen
__directorio_carga = self.__obtener_directorio_kingfisher(
origen)
execKF = True
# Existen archivos en el directorio
if util.EdcaUtil.existen_archivos_json(__directorio_carga):
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_LOAD_FILEFROMKF_BEGIN,
self.__event_log,
"EXISTE ARCHIVOS JSON--> " + str(__directorio_carga))
# Tienen registros los archivos
execKF = False
for archivo in util.EdcaUtil.obtener_lista_solo_archivos(
__directorio_carga, 'json'):
log.registrar_log_info(
__name__,
err.EdcaErrores.INFO_LOAD_FILEFROMKF_BEGIN,
self.__event_log,
"ARCHIVOS JSON--> " + str(archivo))
#Se evalua el archivo
if not util.EdcaUtil.validar_cerobytes_archivo(
archivo):
execKF = True
else:
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_LOAD_FILEFROMKF_BEGIN,
self.__event_log, "NO EXISTEN ARCHIVOS A CARGAR--> " +
str(__directorio_carga))
execKF = False
# se obtiene el formato del archivo json segun el origen o sistema
__tipo_archivo_json = self.__obtener_tipo_archivo_json(origen)
# se obtiene el numero ID Collection del publicador.
__id_collection = self.__obtener_id_collection()
# Log para ver los parametros
log.registrar_log_info(
__name__, err.EdcaErrores.INFO_CARGAR_ARCHIVOS_GENERICO,
self.__event_log,
"ID Collection = " + str(__id_collection) +
", Directorio = " + __directorio_carga +
" Tipo Archivo = " + __tipo_archivo_json)
# Cargar los archivos json al king fisher
if execKF == True:
self.__cargar_kingfisher(__directorio_carga,
__tipo_archivo_json,
__id_collection)
# Mover los archivos a la carpeta de historico
self.__mover_archivos_historico(origen, __directorio_carga)
# Eliminar los archivos JSon de la carpeta de carga
#self.__limpiar_carpeta(__directorio_carga)
# Eliminar los archivos JSon de la carpeta de carga
#self.__limpiar_carpeta_descargas(__directorio_carga)
# Generar el archivo de releases package para descarga masiva
#self.__generar_achivo_masivo()
# log para indicar el inicio del proceso de cargar archivos al king fisher
log.registrar_log_info(__name__, err.EdcaErrores.INFO_FIN_KF,
self.__event_log,
"****** FIN ETAPA 3 ******")
except Exception as ex:
#self.__registrar_bitacora(ex)
raise ex.args
def __registrar_bitacora(code, event, detail):
# print("Code : " + code + " Event : " + event + " Detail : " + detail)
log.registrar_log_info(__name__, code, event, detail)
def obt_conexion(self):
log.registrar_log_info(__name__, err.EdcaErrores.INFO_DATABASE_CONN_OPEN,
"DATABASE", msg.EdcaMensajes.obt_mensaje(err.EdcaErrores.INFO_DATABASE_CONN_OPEN))
return self.conn
def __confirmar_transaccion(self):
log.registrar_log_info(__name__, err.EdcaErrores.INFO_DATABASE_TXN_COMMIT,
"DATABASE", msg.EdcaMensajes.obt_mensaje(err.EdcaErrores.INFO_DATABASE_TXN_COMMIT))
return self.conn.commit()
def __revertir_transaccion(self):
log.registrar_log_info(__name__, err.EdcaErrores.INFO_DATABASE_TXN_ROLLBACK,
"DATABASE", msg.EdcaMensajes.obt_mensaje(err.EdcaErrores.INFO_DATABASE_TXN_ROLLBACK))
return self.conn.rollback()
def cerrar_conexion(self):
if self.conn:
self.conn.close()
log.registrar_log_info(__name__, err.EdcaErrores.INFO_DATABASE_CONN_CLOSE,
"DATABASE", msg.EdcaMensajes.obt_mensaje(err.EdcaErrores.INFO_DATABASE_CONN_CLOSE))