def eliminar_justificacion(jid, token):
prof = warden.has_one_profile(token, ['assistance-super-admin','assistance-admin'])
if not prof or prof['profile'] == False:
return ('no tiene los permisos suficientes', 403)
with obtener_session() as session:
AssistanceModel.eliminarJustificacion(session, jid)
session.commit()
def obtener_acceso_modulos(token=None):
config = AssistanceModel._config()
perfiles = config['api']['perfiles']
for perfil in perfiles:
p = perfil['perfil']
response = warden.has_all_profiles(token, [p])
if 'profile' in response and response['profile']:
return perfil['funciones']
"""
se chequea el modelo para controlar si es necesario asignarle ciertas funciones
"""
autorizador_id = token['sub']
funciones = AssistanceModel.obtener_acceso_modulos(autorizador_id)
if funciones:
return funciones
"""
si no matcheo anteriorment entonces retorno las funciones por defecto.
"""
pgen = (p for p in perfiles if p['perfil'] == 'default')
pdefault = next(pgen)
if not pdefault or pdefault['perfil'] != 'default':
raise Exception('no se encuentra perfil por defecto')
return pdefault['funciones']
def actualizar_justificacion(jid, token):
prof = warden.has_one_profile(token, ['assistance-super-admin', 'assistance-admin'])
if not prof or prof['profile'] == False:
return ('no tiene los permisos suficientes', 403)
datos = request.get_json()
with obtener_session() as session:
AssistanceModel.actualizar_justificacion(session, jid, datos)
session.commit()
def usuarios_search(search, token=None):
prof = warden.has_one_profile(token, ['assistance-super-admin','assistance-admin','assistance-operator', 'assistance-user'])
if prof and prof['profile']:
usuarios = AssistanceModel.usuarios_search(search)
return usuarios
autorizador_id = token['sub']
usuarios = AssistanceModel.sub_usuarios_search(autorizador_id, search)
return usuarios
def crear_horario(token):
prof = warden.has_one_profile(token, ['assistance-super-admin','assistance-admin'])
if not prof or prof['profile'] == False:
return ('no tiene los permisos suficientes', 403)
horarios = request.get_json()
logging.debug(horarios)
with obtener_session() as session:
AssistanceModel.crearHorario(session, horarios)
session.commit()
return True
def justificaciones(uid, token):
prof = warden.has_one_profile(token, ['assistance-super-admin','assistance-admin','assistance-operator'])
if prof and prof['profile'] == True:
with obtener_session() as session:
return AssistanceModel.justificaciones(session)
autorizador_id = token['sub']
if AssistanceModel.chequear_acceso(autorizador_id, uid):
with obtener_session() as session:
return AssistanceModel.justificacionesParaUsuario(session, uid)
return ('no tiene los permisos suficientes', 403)
def lugares(token=None):
uid = token['sub']
search = request.args.get('q')
if not search:
search = ''
prof = warden.has_one_profile(token, ['assistance-super-admin','assistance-admin','assistance-operator', 'assistance-user'])
if prof and prof['profile'] == True:
config = AssistanceModel._config()
lid = config['api']['lugar_raiz']
return AssistanceModel.sublugares_por_lugar_id(lugar_id=lid, search=search)
return AssistanceModel.lugares(session=None, autorizador_id=uid, search=search)
def horario(uid,token):
fecha_str = request.args.get('fecha', None)
fecha = parser.parse(fecha_str).date() if fecha_str else None
prof = warden.has_one_profile(token, ['assistance-super-admin','assistance-admin','assistance-operator','assistance-user'])
if prof and prof['profile'] == True:
with obtener_session() as session:
return AssistanceModel.horario(session, uid, fecha)
usuario_logueado = token['sub']
if AssistanceModel.chequear_acceso(usuario_logueado, uid):
with obtener_session() as session:
return AssistanceModel.horario(session, uid, fecha)
return ('no tiene los permisos suficientes', 403)
def reloj_usuario(rid, ruid, token):
prof = warden.has_one_profile(token, ['assistance-super-admin','assistance-admin'])
if not prof or prof['profile'] == False:
return ('no tiene los permisos suficientes', 403)
assert rid is not None
assert ruid is not None
with obtener_session() as session:
u = AssistanceModel.usuario_por_reloj(session, rid, ruid)
t = AssistanceModel.templates_por_usuario_por_reloj(session, rid, ruid)
r = {
'usuario': u,
'huellas': t
}
return r
def relojes(token):
prof = warden.has_one_profile(token, ['assistance-super-admin','assistance-admin'])
if not prof or prof['profile'] == False:
return ('no tiene los permisos suficientes', 403)
with obtener_session() as session:
return AssistanceModel.relojes(session)
def reporte_justificaciones_realizadas(cantidad=10):
#prof = warden.has_one_profile(token, ['assistance-super-admin','assistance-admin','assistance-operator'])
#if prof and prof['profile'] == True:
cantidad = int(cantidad)
with obtener_session() as session:
return AssistanceModel.reporte_justificaciones_realizadas(session, cantidad)
def usuarios(uid=None, token=None):
prof = warden.has_one_profile(token, ['assistance-super-admin','assistance-admin','assistance-operator', 'assistance-user'])
if prof and prof['profile'] == True:
with obtener_session() as session:
return AssistanceModel.usuario(session, uid, retornarClave=False)
autorizador_id = token['sub']
if AssistanceModel.chequear_acceso(autorizador_id, uid):
with obtener_session() as session:
return AssistanceModel.usuario(session, uid, retornarClave=False)
''' como no soy admin, ni tengo cargo, entonces chequea que se este consultando a si mismo '''
if autorizador_id == uid:
with obtener_session() as session:
return AssistanceModel.usuario(session, autorizador_id, retornarClave=False)
return ('no tiene los permisos suficientes', 403)
def usuarios(uid):
start_str = request.args.get('sdate', None)
start = parser.parse(start_str) if start_str else None
end_str = request.args.get('edate', None)
end = parser.parse(end_str) if end_str else datetime.date.today()
return AssistanceModel.obtenerLAO(uid, start, end)
def reporte_general(token):
datos = request.get_json()
fecha = parser.parse(datos["fecha"]).date() if 'fecha' in datos else None
lugares = datos["lugares"]
usuario_logueado = token['sub']
prof = warden.has_one_profile(token, ['assistance-super-admin','assistance-admin','assistance-operator','assistance-user'])
if prof and prof['profile'] == True:
with obtener_session() as session:
return AssistanceModel.reporteGeneralAdmin(session, lugares, fecha)
if AssistanceModel.chequear_acceso_lugares(usuario_logueado, lugares):
with obtener_session() as session:
return AssistanceModel.reporteGeneral(session, usuario_logueado, lugares, fecha)
return ('no tiene los permisos suficientes', 403)
def reporte_justificaciones(uid, token):
fecha_str = request.args.get('inicio', None)
inicio = parser.parse(fecha_str).date() if fecha_str else None
fecha_str = request.args.get('fin', None)
fin = parser.parse(fecha_str).date() if fecha_str else None
prof = warden.has_one_profile(token, ['assistance-super-admin', 'assistance-admin','assistance-operator','assistance-user'])
if prof and prof['profile']:
with obtener_session() as session:
return AssistanceModel.reporteJustificaciones(session, uid, inicio, fin)
usuario_logueado = token['sub']
if AssistanceModel.chequear_acceso(usuario_logueado, uid):
with obtener_session() as session:
return AssistanceModel.reporteJustificaciones(session, uid, inicio, fin)
return ('no tiene los permisos suficientes', 403)
def reloj_eliminar_usuarios(rid, token):
prof = warden.has_one_profile(token, 'assistance-super-admin')
if not prof or prof['profile'] == False:
return ('no tiene los permisos suficientes', 403)
assert rid is not None
with obtener_session() as session:
r = AssistanceModel.eliminar_usuarios_reloj(session, rid)
return r
def crear_log_por_usuario(uid, token=None):
prof = warden.has_one_profile(token, ['assistance-super-admin', 'assistance-admin'])
if not prof or prof['profile'] == False:
return ('no tiene los permisos suficientes', 403)
with obtener_session() as session:
r = AssistanceModel.crear_log_por_usuario(session, uid)
session.commit()
return r
def obtenerReporte(uid):
inicio_str = request.args.get('sdate', None)
inicio = parser.parse(inicio_str) if inicio_str else None
fin_str = request.args.get('edate', None)
fin = parser.parse(fin_str) if fin_str else datetime.datetime.now()
reporte = AssistanceModel.generarReporte(inicio, fin, uid)
return reporte
def perfil(uid, token):
fecha_str = request.args.get('fecha', None)
fecha = parser.parse(fecha_str).date() if fecha_str else None
if not fecha:
return ('fecha, parametro no encontrado',400)
prof = warden.has_one_profile(token, ['assistance-super-admin', 'assistance-admin'])
if prof and prof['profile']:
with obtener_session() as session:
return AssistanceModel.perfil(session, uid, fecha)
usuario_logueado = token['sub']
with obtener_session() as session:
#if AssistanceModel.chequear_acceso_reporte(session, usuario_logueado, uid):
if usuario_logueado == uid:
return AssistanceModel.perfil(session, uid, fecha)
else:
return ('no tiene los permisos suficientes', 403)
def reloj(rid,token):
assert rid is not None
prof = warden.has_one_profile(token, ['assistance-super-admin','assistance-admin'])
if not prof or prof['profile'] == False:
return ('no tiene los permisos suficientes', 403)
with obtener_session() as session:
r = AssistanceModel.reloj(session, rid)
return r
def compensatorios(uid, token):
assert uid is not None
prof = warden.has_one_profile(token, ['assistance-super-admin'])
if not prof or prof['profile'] == False:
''' Como no es admin compruebo si es una autoconsulta '''
if uid != token['sub']:
return ('no tiene los permisos suficientes', 403)
with obtener_session() as session:
return AssistanceModel.compensatorios(session, uid)
def eliminar_fecha_justificada(uid, jid, token):
autorizador_id = token['sub']
prof = warden.has_one_profile(token, ['assistance-super-admin', 'assistance-admin'])
if prof or prof['profile'] == True:
with obtener_session() as session:
jid = AssistanceModel.eliminarFechaJustificada(session, jid, autorizador_id)
session.commit()
return jid
if autorizador_id == uid:
return ('no tiene los permisos suficientes', 403)
if AssistanceModel.chequear_acceso(autorizador_id, uid):
with obtener_session() as session:
id = AssistanceModel.eliminarFechaJustificadaJefe(session, jid, autorizador_id, uid)
session.commit()
return id
return ('no tiene los permisos suficientes', 403)
def crear_justificacion(token):
prof = warden.has_one_profile(token, ['assistance-super-admin','assistance-admin'])
if not prof or prof['profile'] == False:
return ('no tiene los permisos suficientes', 403)
justificacion = request.get_json()
logging.debug(justificacion)
with obtener_session() as session:
jid = AssistanceModel.crear_justificacion(session, justificacion)
session.commit()
return jid
def crear_compensatorio(token):
prof = warden.has_one_profile(token, ['assistance-super-admin'])
if not prof or prof['profile'] == False:
return ('no tiene los permisos suficientes', 403)
id_creador_compensatorio = token['sub']
compensatorio = request.get_json()
logging.debug(compensatorio)
with obtener_session() as session:
cid = AssistanceModel.crear_compensatorio(session, compensatorio, id_creador_compensatorio)
session.commit()
return cid
def justificar(token):
fechaJustificada = request.get_json()
prof = warden.has_one_profile(token, ['assistance-super-admin', 'assistance-admin','assistance-operator'])
if prof and prof['profile'] == True:
with obtener_session() as session:
autorizador_id = token['sub']
id = AssistanceModel.justificar(session, fechaJustificada, autorizador_id)
session.commit()
return id
autorizador_id = token['sub']
uid = fechaJustificada['usuario_id']
if autorizador_id == uid:
return ('no tiene los permisos suficientes', 403)
if AssistanceModel.chequear_acceso(autorizador_id, uid):
with obtener_session() as session:
id = AssistanceModel.justificar(session, fechaJustificada, autorizador_id)
session.commit()
return id
return ('no tiene los permisos suficientes', 403)
def logs_por_usuario(uid,token):
prof = warden.has_one_profile(token, ['assistance-super-admin', 'assistance-admin', 'assistance-operator'])
if not prof or prof['profile'] == False:
return ('no tiene los permisos suficientes', 403)
inicio = datetime.datetime.now()
fin = inicio + datetime.timedelta(days=1)
marcaciones = []
with obtener_session() as session:
reporte = AssistanceModel.reporte(session, uid=uid, inicio=inicio, fin=fin)
for r in reporte.reportes:
marcaciones.extend(r.marcaciones)
marcaciones.extend(r.duplicadas)
return marcaciones
def historial_horarios(uid, token):
prof = warden.has_one_profile(token, ['assistance-super-admin','assistance-admin'])
if not prof or prof['profile'] == False:
''' como no soy admin, entonces chequea que se este consultando a si mismo '''
if not uid or uid != token['sub']:
return ('no tiene los permisos suficientes', 403)
fecha_str = request.args.get('fecha_inicio', None)
inicio = parser.parse(fecha_str).date() if fecha_str else None
fecha_str = request.args.get('fecha_fin', None)
fin = parser.parse(fecha_str).date() if fecha_str else None
timezone = request.args.get('timezone', 'America/Argentina/Buenos_Aires')
with obtener_session() as session:
ret = AssistanceModel.historial_horarios(session, uid, inicio, fin, timezone)
return ret
def eliminar_horarios(uid, hid, token):
prof = warden.has_one_profile(token, ['assistance-super-admin','assistance-admin'])
if not prof or prof['profile'] == False:
''' como no soy admin, entonces chequea que se este consultando a si mismo '''
if not uid or uid != token['sub']:
return ('no tiene los permisos suficientes', 403)
fecha_str = request.args.get('fecha_inicio', None)
inicio = parser.parse(fecha_str).date() if fecha_str else None
fecha_str = request.args.get('fecha_fin', None)
fin = parser.parse(fecha_str).date() if fecha_str else None
with obtener_session() as session:
h = AssistanceModel.eliminar_horario(session, uid, hid)
session.commit()
return {'status':'ok', 'horario':h}
def _acceso_modulos_modelo(uid):
return AssistanceModel.obtener_acceso_modulos(uid)
def retornar_config_ui():
config = AssistanceModel._config()
return config['ui']