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