def get(ini_date: str = "yyyy-mm-dd H:M:S",
end_date: str = "yyyy-mm-dd H:M:S"):
""" Obtiene el estado del cálculo de los reportes de disponibilidad existentes en el periodo especificado
Nota: Este servicio es válido solamente al momento de consultar el estado de un cálculo en proceso
en otro contexto, este servicio no garantiza un comportamiento correcto
Fecha inicial formato: <b>yyyy-mm-dd H:M:S</b>
Fecha final formato: <b>yyyy-mm-dd H:M:S</b>
"""
success1, ini_date = u.check_date_yyyy_mm_dd_hh_mm_ss(ini_date)
success2, end_date = u.check_date_yyyy_mm_dd_hh_mm_ss(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
# check the existing nodes:
all_nodes = SRNode.objects()
all_nodes = [n for n in all_nodes if n.activado]
if len(all_nodes) == 0:
msg = f"No se encuentran nodos que procesar"
return dict(success=False, msg=msg), 404
# scan reports within this date range:
to_send = list()
for node in all_nodes:
if u.isTemporal(ini_date, end_date):
v_report = SRNodeDetailsTemporal(nodo=node,
nombre=node.nombre,
tipo=node.tipo,
fecha_inicio=ini_date,
fecha_final=end_date)
else:
v_report = SRNodeDetailsPermanente(nodo=node,
nombre=node.nombre,
tipo=node.tipo,
fecha_inicio=ini_date,
fecha_final=end_date)
tmp_report = TemporalProcessingStateReport.objects(
id_report=v_report.id_report).first()
if tmp_report is None:
for i in range(20):
tmp_report = TemporalProcessingStateReport.objects(
id_report=v_report.id_report).first()
if tmp_report is not None:
break
else:
time.sleep(2)
to_send.append(tmp_report.to_summary())
if len(all_nodes) == len(to_send):
return dict(success=True, status=to_send), 200
else:
return dict(success=False, status=None), 409
def run_all_nodes(report_ini_date: dt.datetime,
report_end_date: dt.datetime,
save_in_db=False,
force=False):
# corre todos los nodos que se encuentran activos:
global start_time_script
start_time_script = dt.datetime.now()
mongo_config = init.MONGOCLIENT_SETTINGS
try:
connect(**mongo_config)
except Exception as e:
pass
""" Buscando los nodos con los que se va a trabajar """
all_nodes = SRNode.objects()
all_nodes = [n for n in all_nodes if n.activado]
if len(all_nodes) == 0:
msg = f"No hay nodos a procesar en db:[{mongo_config['db']}]"
return False, [], msg
name_list = [n.nombre for n in all_nodes]
for sR_node in all_nodes:
report_node = SRNodeDetailsBase(nodo=sR_node,
nombre=sR_node.nombre,
tipo=sR_node.tipo,
fecha_inicio=report_ini_date,
fecha_final=report_end_date)
status_node = TemporalProcessingStateReport.objects(
id_report=report_node.id_report).first()
if status_node is not None:
status_node.delete()
return run_node_list(name_list, report_ini_date, report_end_date,
save_in_db, force)
def delete(ini_date: str = "yyyy-mm-dd H:M:S",
end_date: str = "yyyy-mm-dd H:M:S"):
""" Elimina si existe la disponibilidad de los nodos especificados en la lista
Fecha inicial formato: <b>yyyy-mm-dd H:M:S</b>
Fecha final formato: <b>yyyy-mm-dd H:M:S</b>
"""
success1, ini_date = u.check_date_yyyy_mm_dd_hh_mm_ss(ini_date)
success2, end_date = u.check_date_yyyy_mm_dd_hh_mm_ss(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
node_list_name = request.json["nodos"]
not_found = list()
deleted = list()
for node in node_list_name:
sR_node = SRNode.objects(nombre=node).first()
if sR_node is None:
not_found.append(node)
continue
report_v = SRNodeDetailsBase(nodo=sR_node,
nombre=sR_node.nombre,
tipo=sR_node.tipo,
fecha_inicio=ini_date,
fecha_final=end_date)
# delete status report if exists
status_report = TemporalProcessingStateReport.objects(
id_report=report_v.id_report).first()
if status_report is not None:
status_report.delete()
if u.isTemporal(ini_date, end_date):
report = SRNodeDetailsTemporal.objects(
id_report=report_v.id_report).first()
else:
report_v = SRNodeDetailsPermanente(nodo=sR_node,
nombre=sR_node.nombre,
tipo=sR_node.tipo,
fecha_inicio=ini_date,
fecha_final=end_date)
report = SRNodeDetailsPermanente.objects(
id_report=report_v.id_report).first()
if report is None:
not_found.append(node)
continue
report.delete()
deleted.append(node)
if len(deleted) == 0:
return dict(success=False, deleted=deleted,
not_found=not_found), 404
success, _, msg = run_summary(ini_date,
end_date,
save_in_db=True,
force=True)
if not success:
return dict(success=False, deleted=[], not_found=not_found), 400
return dict(success=True, deleted=deleted, not_found=not_found), 200
def save(self, msg=None):
info = dict(trigger=dict(seconds=self.trigger.seconds, days=self.trigger.days), mail_config=self.mail_config,
parameters=self.parameters)
state = TemporalProcessingStateReport.objects(id_report=self.name).first()
if state is None:
state = TemporalProcessingStateReport(id_report=self.name, info=info, msg=msg)
state.save()
else:
state.update(info=info, created=dt.datetime.now(), msg=msg)
def put(self, id_report):
""" Configuración para la ejecución del reporte """
request_data = dict(request.json)
state_report = TemporalProcessingStateReport.objects(id_report=id_report).first()
if state_report is not None:
state_report.update(info=request_data)
else:
state_report = TemporalProcessingStateReport(id_report=id_report, info=request_data, msg="Rutina configurada")
state_report.save()
return dict(success=True, msg="Parámetros configurados de manera correcta"), 200
def post(self, id_report):
""" Corre de manera rutinaria el reporte con el id """
th = get_thread_by_name(id_report)
if th is None:
if id_report == 'rutina_de_reporte_diario':
state = TemporalProcessingStateReport.objects(id_report=id_report).first()
if state is None:
return dict(success=False, msg="La rutina aún no ha sido configurada"), 404
trigger = dt.timedelta(**state.info["trigger"])
th_v = StoppableThreadDailyReport(trigger=trigger, name=id_report)
th_v.start()
return dict(success=True, msg="La rutina ha sido inicializada"), 200
if id_report == 'rutina_correo_electronico':
state = TemporalProcessingStateReport.objects(id_report=id_report).first()
if state is None:
return dict(success=False, msg="La rutina aún no ha sido configurada"), 404
trigger = dt.timedelta(**state.info["trigger"])
mail_config = state.info["mail_config"]
parameters = state.info["parameters"]
th_v = StoppableThreadMailReport(name=id_report, trigger=trigger, mail_config=mail_config,
parameters=parameters)
th_v.start()
return dict(success=True, msg="La rutina ha sido inicializada"), 200
return dict(success=False, msg="La rutina ya se encuentra en ejecución"), 409
def test():
mongo_config = init.MONGOCLIENT_SETTINGS
connect(**mongo_config)
rutine_name = "rutina_de_reporte_diario"
trigger = dict(hours=7, minutes=29, seconds=0)
th_v = StoppableThreadDailyReport(trigger=dt.timedelta(**trigger),
name=rutine_name)
th_v.save(msg="Configuración guardada")
state = TemporalProcessingStateReport.objects(
id_report=rutine_name).first()
trigger = dt.timedelta(**state.info["trigger"])
th = get_thread_by_name(rutine_name)
if th is None:
th = StoppableThreadDailyReport(trigger=trigger, name=rutine_name)
th.start()
else:
th.stop()
def test():
mongo_config = init.MONGOCLIENT_SETTINGS
connect(**mongo_config)
rutine_name = "rutina_correo_electronico"
trigger = dict(hours=7, minutes=40, seconds=0)
mail_config = dict(from_email="*****@*****.**", users=["*****@*****.**"],
admin=["*****@*****.**"])
parameters = dict(disp_utr_umbral=0.9, disp_tag_umbral=0.9)
ini_date, end_date = get_dates_by_default()
ini_date, end_date = dt.datetime(year=2021, month=3, day=1), dt.datetime(year=2021, month=3, day=30)
th_v = StoppableThreadMailReport(trigger=dt.timedelta(**trigger), name=rutine_name, mail_config=mail_config,
parameters=parameters, ini_date=ini_date, end_date=end_date)
th_v.save(msg="Configuración guardada")
state = TemporalProcessingStateReport.objects(id_report=rutine_name).first()
trigger = dt.timedelta(**state.info["trigger"])
mail_config = state.info["mail_config"]
th = get_thread_by_name(rutine_name)
if th is None:
th = StoppableThreadMailReport(name=rutine_name, trigger=trigger, mail_config=mail_config, parameters=parameters,
ini_date=ini_date, end_date=end_date)
th.start()
else:
th.stop()
def update_from_db(self):
state = TemporalProcessingStateReport.objects(
id_report=self.name).first()
if state is not None:
self.trigger = dt.timedelta(**state.info["trigger"])
def update_from_db(self):
state = TemporalProcessingStateReport.objects(id_report=self.name).first()
if state is not None:
self.trigger = dt.timedelta(**state.info["trigger"])
self.mail_config = state.info["mail_config"]
self.parameters = state.info["parameters"]