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 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 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 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 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 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 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 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 reloj_huellas(rid, 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
with obtener_session() as session:
r = AssistanceModel.templates_por_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 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_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 eventStream():
while True:
envio = datetime.datetime.now()
eventos = []
with obtener_session() as session:
# obtengo los eventos y los retorno
eventos.extend([
'id: {}\nevent: {}\ndata: {}\n\n'.format(e.id, e.evento, e.mensaje)
for e in session.query(Evento).filter(Evento.enviado == None).all()
]
)
for e in eventos:
yield e
with obtener_session() as session:
for e in session.query(Evento).filter(Evento.enviado == None).all():
e.enviado = envio
session.commit()
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_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 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 obtener_marcaciones_por_uid_por_tiempo(self, uid, dias=2):
"""
Obtiene de la DB las marcaciones hasta 2 dias atras (por defecto) para el usuario_id pasado como parametro
"""
fecha = datetime.datetime.now() - timedelta(days=dias)
marcaciones = []
with obtener_session() as session:
mmarcaciones = session.query(Marcacion).filter(
Marcacion.usuario_id == uid,
Marcacion.marcacion > fecha).order_by(
Marcacion.marcacion).all()
for m in mmarcaciones:
marcaciones.append(m)
return marcaciones
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 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 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
else:
marcacion_tipo = 1
reloj_id = '0a609b5a-5e22-41fc-b9df-17429933ac50'
def _get_marcacion(marcacion):
marc = datetime.datetime.strptime(marcacion, '%d/%m/%Y %H:%M:%S')
marc += datetime.timedelta(hours=3)
marc = pytz.utc.localize(marc)
return marc
with open(archivo) as f:
with obtener_session() as assis:
with open_users_session() as users:
for line in f:
dni, nombres, fecha, algo, t, a = line.split(',')
marcacion = _get_marcacion(fecha)
print(f"DNI: {dni} - marcacion : {marcacion}")
uid = UsersModel.get_uid_person_number(users, dni)
print(f"dni: {dni} -- uid: {uid}")
marcaciones_existentes = assis.query(Marcacion).filter(
Marcacion.user_id == uid,
Marcacion.marcacion == marcacion).all()
for m in marcaciones_existentes:
print(m.marcacion)
print(m.usuario_id)
si no, no se suma nada.
la relacion de las entidades es:
Asiento {
fecha
notas
autorizador_id
registros = [
{
cantidad,
cuenta_id
}
]
}
"""
with obtener_session() as session:
for uid, u in cartera.items():
logging.info('procesando : {}'.format(u['id']))
saldo = CompensatoriosModel.obtenerSaldo(session, u['id'])
fecha = datetime.datetime.now()
reg_a_aplicar = saldo
logging.debug(saldo)
if reg_a_aplicar:
#saldo_a_aplicar = u['stock'] - reg_a_aplicar['saldo']
saldo_a_aplicar = u['stock']
if saldo_a_aplicar > 0:
CompensatoriosModel.cambiarSaldo(
session,
ID_DE_AUTORIZADOR,
u['id'],
def justificacion(jid, token):
with obtener_session() as session:
j = AssistanceModel.justificacion(session, jid)
if not j:
return (404, 'Justificacion No existente')
def relojes_sincronizar():
with obtener_session() as session:
r = AssistanceModel.sincronizar(session)
session.commit()
return r
def generate():
assert rid is not None
with obtener_session() as session:
for r in AssistanceModel.sincronizar_reloj(session, rid):
session.commit()
yield flask.json.dumps(r) + "\n"
def reloj_marcaciones(rid):
assert rid is not None
with obtener_session() as session:
r = AssistanceModel.marcaciones_por_reloj(session, rid)
return r
