def get(self, formato):
if not formato in init.allowed_formats:
return dict(
success=False,
msg=
f"Formato [{formato}] no permitido. Opciones permitidas: {init.allowed_formats}"
), 404
gcServer = SQLGestionConocimiento()
success, df_trayectoria, msg = gcServer.get_trayectoria_laboral()
if not success:
return dict(success=False, msg=msg), 409
file_name = "trayectoria-laboral.xlsx"
success, resp = send_as(fmt=formato,
df=df_trayectoria,
file_name=file_name)
if success and formato == "json":
return dict(success=True, report=resp), 200
elif success and formato == "excel":
response = send_from_directory(os.path.dirname(resp),
file_name,
as_attachment=True)
return set_max_age_to_response(response, 30)
return dict(
success=False,
msg="No se ha podido generar de manera correcta este reporte"), 409
def get(self):
"""
Permite descargar la última versión en formato Excel de este catálogo
"""
file_name = f"Ambito.xlsx"
file_path = os.path.join(init.TEMP_REPO, file_name)
success, msg = AmbitoAsDataFrame().get_excel_from_db(file_path)
if success:
resp = send_from_directory(os.path.dirname(file_path),
file_name,
as_attachment=True)
return set_max_age_to_response(resp, 30)
else:
return dict(success=False, msg=msg), 500
def get(self, repo="Nombre del repositorio", nombre="Nombre del archivo"):
"""
Descarga un archivo de un repositorio
repo: Nombre del repositorio [s_remoto_excel, s_central_excel]
nombre: Nombre del archivo
"""
names = [n.split("\\")[-1] for n in init.REPOS]
if repo not in names:
return dict(success=False,
msg="No existe el repositorio consultado"), 404
repo = init.FINAL_REPO[names.index(repo)]
files = [
f for f in os.listdir(repo)
if os.path.isfile(os.path.join(repo, f))
]
files = [str(file).lower() for file in files]
if nombre.lower() not in files:
return dict(success=False, msg="No existe el archivo buscado")
resp = send_from_directory(repo, nombre, as_attachment=True)
return set_max_age_to_response(resp, 3)
def get(self, nombre, tipo):
""" Descarga en formato excel la última versión del nodo
"""
node = SRNode.objects(nombre=nombre,
tipo=tipo).as_pymongo().exclude('id')
if node.count() == 0:
return dict(success=False,
msg=f"No existe el nodo en la base de datos"), 404
node_as_dict = node[0]
success, df_main, df_tags, msg = SRDataFramesFromDict(
node_as_dict).convert_to_DataFrames()
if not success:
return dict(success=False, msg=msg), 409
file_name = f"{tipo}{nombre}.xlsx".replace("_", "@")
path = os.path.join(init.TEMP_REPO, file_name)
with pd.ExcelWriter(path) as writer:
df_main.to_excel(writer, sheet_name="main")
df_tags.to_excel(writer, sheet_name="tags")
if os.path.exists(path):
resp = send_from_directory(os.path.dirname(path),
file_name,
as_attachment=False)
return set_max_age_to_response(resp, 5)
def get(formato,
ini_date: str = "yyyy-mm-dd H:M:S",
end_date: str = "yyyy-mm-dd H:M:S"):
""" Entrega el cálculo en formato Excel/JSON realizado por acciones POST/PUT
Si el cálculo no existe entonces <b>código 404</b>
Formato: excel, json
Fecha inicial formato: <b>yyyy-mm-dd, yyyy-mm-dd H:M:S</b>
Fecha final formato: <b>yyyy-mm-dd, yyyy-mm-dd H:M:S</b>
"""
success1, ini_date = u.check_date(ini_date)
success2, end_date = u.check_date(end_date)
if not success1 or not success2:
msg = "No se puede convertir. " + (ini_date
if not success1 else end_date)
return dict(success=False, msg=msg), 400
# Verificando si debe usar el reporte temporal o definitivo:
final_report_v = SRFinalReportBase(fecha_inicio=ini_date,
fecha_final=end_date)
if u.isTemporal(ini_date, end_date):
final_report = SRFinalReportTemporal.objects(
id_report=final_report_v.id_report).first()
else:
final_report = SRFinalReportPermanente.objects(
id_report=final_report_v.id_report).first()
if final_report is None:
return dict(success=False, msg="No existe reporte asociado"), 404
# formato permitido:
permitido = ["excel", "json"]
if not formato in ["excel", "json"]:
msg = f"No se puede presentar el reporte en el formato {formato}, considere las opciones: {permitido}"
return dict(success=False, msg=msg), 400
utrs_dict = final_report.load_nodes_info().create_utrs_list()
success, df_summary, df_details, df_novedades, msg = final_report.to_dataframe(
utrs_dict)
if not success:
return dict(success=False, report=None, msg=msg), 409
# Creating an Excel file:
if formato == "excel":
ini_date_str, end_date_str = ini_date.strftime(
"%Y-%m-%d"), end_date.strftime("%Y-%m-%d")
file_name = f"R_{ini_date_str}@{end_date_str}.xlsx"
path = os.path.join(init.TEMP_REPO, file_name)
with pd.ExcelWriter(path) as writer:
df_summary.to_excel(writer, sheet_name="Resumen")
df_details.to_excel(writer, sheet_name="Detalles")
df_novedades.to_excel(writer, sheet_name="Novedades")
if os.path.exists(path):
resp = send_from_directory(os.path.dirname(path),
file_name,
as_attachment=True)
return set_max_age_to_response(resp, 5)
if formato == "json":
result_dict = dict()
result_dict["Resumen"] = df_summary.to_dict(orient='records')
result_dict["Detalles"] = df_details.to_dict(orient='records')
result_dict["Novedades"] = df_novedades.to_dict(orient='records')
return dict(success=True,
report=result_dict,
msg="Reporte encontrado")
def get(formato, ini_date=None, end_date=None):
""" Entrega el cálculo en formato Excel/JSON realizado de manera diaria a las 00:00
Si el cálculo no existe entonces <b>código 404</b>
Formato: excel, json
Fecha inicial formato: <b>yyyy-mm-dd</b>
Fecha final formato: <b>yyyy-mm-dd</b>
"""
log.info("Starting this report")
if ini_date is None and end_date is None:
ini_date, end_date = u.get_dates_by_default()
else:
success1, ini_date = u.check_date_yyyy_mm_dd(ini_date)
success2, end_date = u.check_date_yyyy_mm_dd(end_date)
if not success1 or not success2:
msg = "No se puede convertir. " + (ini_date if not success1
else end_date)
return dict(success=False, msg=msg), 400
# time range for each consult
date_range = pd.date_range(ini_date,
end_date,
freq=dt.timedelta(days=1))
if len(date_range) == 0:
return dict(success=False,
report=None,
msg="Las fechas de inicio y fin no son correctas.")
n_threads = 0
pool = ThreadPool(8)
results = []
utrs_dict = None
log.info("Going to get each report")
for ini, end in zip(date_range, date_range[1:]):
final_report_v = SRFinalReportTemporal(fecha_inicio=ini,
fecha_final=end)
final_report = SRFinalReportTemporal.objects(
id_report=final_report_v.id_report).first()
log.info(f"thread # {n_threads}")
if utrs_dict is None:
utrs_dict = final_report.load_nodes_info().create_utrs_list()
if final_report is not None:
results.append(
pool.apply_async(final_report.to_dataframe,
kwds={"utrs_dict": utrs_dict}))
n_threads += 1
else:
log.warning(
f"El reporte [{final_report}] no ha sido encontrado ")
log.info(f"Se han desplegado {n_threads} threads")
# la cola permitirá recibir los informes de manera paralela:
df_summary, df_details, df_novedades = pd.DataFrame(), pd.DataFrame(
), pd.DataFrame()
pool.close()
pool.join()
for result in results:
success, _df_summary, _df_details, _df_novedades, msg = result.get(
)
log.info(f"{success}, {msg}")
if success:
df_summary = pd.DataFrame.append(df_summary,
_df_summary,
ignore_index=True)
df_details = pd.DataFrame.append(df_details,
_df_details,
ignore_index=True)
df_novedades = pd.DataFrame.append(df_novedades,
_df_novedades,
ignore_index=True)
n_threads -= 1
log.info(f"threads faltantes: {n_threads}")
# formato permitido:
permitido = ["excel", "json"]
if not formato in ["excel", "json"]:
msg = f"No se puede presentar el reporte en el formato {formato}, considere las opciones: {permitido}"
return dict(success=False, msg=msg), 400
# Creating an Excel file:
if formato == "excel":
ini_date_str, end_date_str = ini_date.strftime(
"%Y-%m-%d"), end_date.strftime("%Y-%m-%d")
file_name = f"R_{ini_date_str}@{end_date_str}.xlsx"
path = os.path.join(init.TEMP_REPO, file_name)
with pd.ExcelWriter(path) as writer:
df_summary.to_excel(writer, sheet_name="Resumen")
df_details.to_excel(writer, sheet_name="Detalles")
df_novedades.to_excel(writer, sheet_name="Novedades")
if os.path.exists(path):
resp = send_from_directory(os.path.dirname(path),
file_name,
as_attachment=True)
return set_max_age_to_response(resp, 2)
if formato == "json":
result_dict = dict()
result_dict["Resumen"] = df_summary.to_dict(orient='records')
result_dict["Detalles"] = df_details.to_dict(orient='records')
result_dict["Novedades"] = df_novedades.to_dict(orient='records')
return dict(success=True,
report=result_dict,
msg="Reporte encontrado")
def get(formato, ini_date: str = None, end_date: str = None, umbral=None):
""" Entrega el listado de tags cuya indisponibilidad sea mayor igual al umbral (por defecto 0)
Si el cálculo no existe entonces <b>código 404</b>
Formato: excel, json
Fecha inicial formato: <b>yyyy-mm-dd, yyyy-mm-dd H:M:S</b>
Fecha final formato: <b>yyyy-mm-dd, yyyy-mm-dd H:M:S</b>
Umbral: <b>float</b>
"""
if ini_date is None or end_date is None:
ini_date, end_date = u.get_last_day()
else:
success1, ini_date = u.check_date(ini_date)
success2, end_date = u.check_date(end_date)
if not success1 or not success2:
msg = "No se puede convertir. " + (ini_date if not success1
else end_date)
return dict(success=False, msg=msg), 400
# definición del umbral
if umbral is None:
umbral = 0
else:
umbral = float(umbral)
# formato permitido:
permitido = ["excel", "json"]
if not formato in ["excel", "json"]:
msg = f"No se puede presentar el reporte en el formato {formato}, considere las opciones: {permitido}"
return dict(success=False, msg=msg), 400
# Verificando si debe usar el reporte temporal o definitivo:
final_report_virtual = SRFinalReportBase(fecha_inicio=ini_date,
fecha_final=end_date)
if u.isTemporal(ini_date, end_date):
# Obtener el reporte final con los detalles de cada reporte por nodo
final_report_db = SRFinalReportTemporal.objects(
id_report=final_report_virtual.id_report).first()
else:
# Obtener el reporte final con los detalles de cada reporte por nodo
final_report_db = SRFinalReportPermanente.objects(
id_report=final_report_virtual.id_report).first()
if final_report_db is None:
return dict(success=False,
msg="El reporte para esta fecha no existe. "
"Considere realizar el cálculo primero"), 404
# variable para guardar el listado de tags con su respectiva indisponibilidad
df_tag = pd.DataFrame(columns=[
lb_fecha_ini, lb_fecha_fin, lb_empresa, lb_unidad_negocio,
lb_utr_id, lb_utr, lb_tag_name, lb_indisponible_minutos
])
for reporte_nodo_resumen in final_report_db.reportes_nodos:
if u.isTemporal(ini_date, end_date):
reporte_nodo_db = SRNodeDetailsTemporal.objects(
id_report=reporte_nodo_resumen.id_report).first()
else:
reporte_nodo_db = SRNodeDetailsPermanente.objects(
id_report=reporte_nodo_resumen.id_report).first()
empresa = reporte_nodo_db.nombre
for reporte_entidad in reporte_nodo_db.reportes_entidades:
unidad_negocio = reporte_entidad.entidad_nombre
for reporte_utr in reporte_entidad.reportes_utrs:
utr_id = reporte_utr.id_utr
utr_nombre = reporte_utr.utr_nombre
if len(reporte_utr.indisponibilidad_detalle) > 0:
df_tag_aux = pd.DataFrame([
t.to_dict()
for t in reporte_utr.indisponibilidad_detalle
])
df_tag_aux[lb_empresa] = empresa
df_tag_aux[lb_unidad_negocio] = unidad_negocio
df_tag_aux[lb_utr_id] = utr_id
df_tag_aux[lb_utr] = utr_nombre
if umbral > 0:
mask = df_tag_aux[lb_indisponible_minutos] >= umbral
df_tag_aux = df_tag_aux[mask]
df_tag = df_tag.append(df_tag_aux, ignore_index=True)
df_tag[lb_fecha_ini] = str(ini_date)
df_tag[lb_fecha_fin] = str(end_date)
if formato == "json":
resp = df_tag.to_dict(orient="records")
return dict(success=True, reporte=resp)
if formato == "excel":
# nombre del archivo
ini_date_str, end_date_str = ini_date.strftime(
"%Y-%m-%d"), end_date.strftime("%Y-%m-%d")
file_name = f"IndispTags_{ini_date_str}@{end_date_str}.xlsx"
path = os.path.join(init.TEMP_REPO, file_name)
# crear en el directorio temporal para envío del archivo
with pd.ExcelWriter(path) as writer:
df_tag.to_excel(writer, sheet_name="Detalles")
if os.path.exists(path):
resp = send_from_directory(os.path.dirname(path),
file_name,
as_attachment=True)
return set_max_age_to_response(resp, 2)
def get(self,
formato=None,
ini_date: str = "yyyy-mm-dd hh:mm:ss",
end_date: str = "yyyy-mm-dd hh:mm:ss"):
""" Obtener las consignaciones existentes en las fechas consultadas
formato de fechas: <b>yyyy-mm-dd hh:mm:ss</b>
formatos disponibles: [json, excel]
"""
success, ini_date, end_date, msg = check_range_yyyy_mm_dd_hh_mm_ss(
ini_date, end_date)
if not success:
return dict(success=False, msg=msg), 400
permitido = ["excel", "json"]
if not formato in ["excel", "json"]:
msg = f"No se puede presentar el reporte en el formato {formato}, considere las opciones: {permitido}"
return dict(success=False, msg=msg), 400
# D*****[***************H
contiene_ini = Q(desde__lte=ini_date) & Q(hasta__gte=ini_date)
# D*****]***************H
contiene_end = Q(desde__lte=end_date) & Q(hasta__gte=end_date)
# [ D********H ]
contenido_en = Q(desde__gte=ini_date) & Q(hasta__lte=end_date)
time_query = contiene_ini | contiene_end | contenido_en
consignaciones = Consignments.objects.filter(time_query)
if len(consignaciones) == 0:
return dict(
success=False,
msg=
f"No se encontraron consignaciones para [{ini_date} @ {end_date}]"
), 404
consignment_result = list()
for c_consignacion in consignaciones:
consignment_dicts = c_consignacion.consignments_in_time_range_w_element(
ini_date, end_date)
consignment_result += consignment_dicts
if len(consignment_result) == 0:
return dict(
success=False,
msg=
f"No se encontraron consignaciones para [{ini_date} @ {end_date}]"
), 404
if formato == 'json':
return dict(success=True, consignaciones=consignment_result), 200
ini_date_str, end_date_str = ini_date.strftime(
"%Y-%m-%d"), end_date.strftime("%Y-%m-%d")
file_name = f"Consignaciones_{ini_date_str}@{end_date_str}.xlsx"
path = os.path.join(init.TEMP_REPO, file_name)
with pd.ExcelWriter(path) as writer:
df_consignment = pd.DataFrame(consignment_result)
df_consignment.to_excel(writer, sheet_name="consignaciones")
if os.path.exists(path):
resp = send_from_directory(os.path.dirname(path),
file_name,
as_attachment=True)
return set_max_age_to_response(resp, 30)
return dict(success=False, consignaciones=consignment_result), 404
def get(self, formato):
if not formato in init.allowed_formats:
return dict(
success=False,
msg=
f"Formato [{formato}] no permitido. Opciones permitidas: {init.allowed_formats}"
), 404
gcServer = SQLGestionConocimiento()
success_1, df_basic_info, msg = gcServer.execute_as_dataframe(
St.info_personal_basica)
success_2, df_direccion_info, msg = gcServer.execute_as_dataframe(
St.funcionarios_direccion)
if not success_1 or not success_2:
msg = "Error al obtener información básica" if not success_1 \
else "Error al obtener información de direcciones"
return dict(success=False, msg=msg), 409
# Estructurando datos de la tabla resultado:
to_remove = [Keys.per_nombres, Keys.per_apellidos]
df_direccion_info.drop(to_remove, axis=1, inplace=True)
df_result = pd.merge(df_basic_info,
df_direccion_info,
on=Keys.fun_numero_documento,
how="left")
# get user information
success, df_users, msg = gcServer.get_users()
to_filter = [
Keys.fun_numero_documento, Keys.telDomicilio, Keys.telCelular,
Keys.telTrabajo, Keys.email, Keys.co_correo
]
df_filter = df_users[to_filter]
df_result = pd.merge(df_result,
df_filter,
on=Keys.fun_numero_documento,
how="left")
success, df_emergency, msg = gcServer.get_emergency_contact()
if not success:
return dict(success=False, msg=msg), 404
df_emergency.drop_duplicates(subset=[Keys.fun_numero_documento],
keep='first',
inplace=True)
df_result = pd.merge(df_result,
df_emergency,
on=Keys.fun_numero_documento,
how="left")
df_result[Keys.fun_fecha_nacimiento] = [
str(f) for f in df_result[Keys.fun_fecha_nacimiento]
]
df_result.sort_values(by=[Keys.fun_numero_documento], inplace=True)
# entregando información:
file_name = "informacion-personal.xlsx"
success, resp = send_as(fmt=formato, df=df_result, file_name=file_name)
if success and formato == "json":
return dict(success=True, report=resp), 200
elif success and formato == "excel":
response = send_from_directory(os.path.dirname(resp),
file_name,
as_attachment=True)
return set_max_age_to_response(response, 30)
return dict(
success=False,
msg="No se ha podido generar de manera correcta este reporte"), 409
def get(self, formato):
if not formato in init.allowed_formats:
return dict(
success=False,
msg=
f"Formato [{formato}] no permitido. Opciones permitidas: {init.allowed_formats}"
), 404
gcServer = SQLGestionConocimiento()
success, df_basic_info, msg = gcServer.execute_as_dataframe(
St.info_personal_basica)
if not success:
return dict(success=False, msg=msg), 409
success, df_direccion_info, msg = gcServer.execute_as_dataframe(
St.funcionarios_direccion)
if not success:
return dict(success=False, msg=msg), 409
success, df_init, msg = gcServer.get_ingreso_institucion()
if not success:
return dict(success=False, msg=msg), 409
success, df_cargo, msg = gcServer.get_cargo_actual()
if not success:
return dict(success=False, msg=msg), 409
# let merge the datasets:
# merge directions:
cols_to_use = [Keys.fun_numero_documento] + list(
df_direccion_info.columns.difference(df_basic_info.columns))
df_result = pd.merge(df_basic_info,
df_direccion_info[cols_to_use],
on=Keys.fun_numero_documento,
how='left')
# merge ingreso institucional
cols_to_use = [Keys.fun_numero_documento] + list(
df_init.columns.difference(df_result.columns))
df_result = pd.merge(df_result,
df_init[cols_to_use],
on=Keys.fun_numero_documento,
how='left')
# merge cargo actual
cols_to_use = [Keys.fun_numero_documento] + list(
df_cargo.columns.difference(df_result.columns))
df_result = pd.merge(df_result,
df_cargo[cols_to_use],
on=Keys.fun_numero_documento,
how='left')
# converting to str some columns:
df_result = columns_as_string(df_result, [
Keys.fun_fecha_nacimiento, Keys.tray_fecha_ingreso,
Keys.tray_fecha_salida
])
# send information in the requested format:
file_name = "servidor-institucion.xlsx"
success, resp = send_as(fmt=formato, df=df_result, file_name=file_name)
if success and formato == "json":
return dict(success=True, report=resp), 200
elif success and formato == "excel":
response = send_from_directory(os.path.dirname(resp),
file_name,
as_attachment=True)
return set_max_age_to_response(response, 30)
return dict(
success=False,
msg="No se ha podido generar de manera correcta este reporte"), 409