def reservar_tickets(user, dias, id_log, unit):
""" Reserva tickets de acuerdo a los días pasados como parametros para ese
usuario. """
data = {}
tickets_reservados = []
dias_full = []
for dia in dias:
disponibles = get_tickets_libres(dia)
if disponibles:
data['id_dia'] = get_id_dia(dia)
data['importe'] = get_categoria_importe(user['id_categoria'])
data['unidad'] = unit # terminal o web
data['estado'] = 1 # reservado
fecha = str(int(time()))
data['barcode'] = fecha
update_tickets_dia(data['id_dia']) # tickets_vendidos + 1
id_ticket = db.tickets.insert(**data)
db.commit()
# agregar el ticket y el día como reservado
tickets_reservados.append((id_ticket, data['id_dia']))
insert_ticket_log(id_ticket, id_log)
id_ticket = str(id_ticket)
codigo = fecha + '0' * (10 - len(id_ticket)) + id_ticket
db(db.tickets.id == id_ticket).update(barcode=codigo)
db.commit()
else:
# agregar el día como no disponible
dias_full.append(dia)
data = {}
if len(dias) == (len(tickets_reservados) + len(dias_full)):
return tickets_reservados, dias_full, 1
else:
return tickets_reservados, dias_full, 0
def comprar_tickets(tickets_reservados, id_log):
""" compra los tickets reservados al cambiarles el estado de reservado(1)
a impresos(2) e inserta el log de compra para cada ticket."""
for id_ticket, dia in tickets_reservados:
insert_ticket_log(id_ticket, id_log)
db(db.tickets.id == id_ticket).update(estado=2)
db.commit()
def cancelar_tickets(tickets_reservados):
""" Cancela los tickets pasados como parametro cambiando el estado de
reservado(1) a cancelado (5) y aumenta los tickets disponibles para ese
día."""
for id_ticket, id_dia in tickets_reservados:
db(db.tickets.id == id_ticket).update(estado=5)
db.commit()
update_tickets_dia(id_dia, band=0)
def update_activo(user, valor):
"""
Actualiza el campo activo de un usuario(user) con el valor dado.
valor = 1 -> usuario activo(logueado en el sistema)
valor = 0 -> usuario inactivo(no está logueado en el sistema)
"""
db(db.usuarios.dni == user['dni']).update(activo=valor)
db.commit()
def update_saldo(user, importe, band):
"""
Actualiza el saldo del user de acuerdo al importe del ticket.
Si band = 0 anulación/carga => suma el saldo
Si band = 1 compra => resta el saldo
"""
if band:
db(db.usuarios.dni == user['dni']).update(
saldo=db.usuarios.saldo - importe)
else:
db(db.usuarios.dni == user['dni']).update(
saldo=db.usuarios.saldo + importe)
db.commit()
def get_ticket(user, date):
"""
Retorna la fila de un ticket si hay un ticket activo de ese usuario para
ese día, en caso contrario retorna False."""
tickets = db((db.tickets.id_dia == db.dias.id) &
(db.tickets.id == db.tickets_log_usuarios.id_ticket) &
(db.tickets_log_usuarios.id_log_usuario == db.log_usuarios.id) &
(db.log_usuarios.dni == db.usuarios.dni))
rows = tickets((db.usuarios.dni == user['dni']) &
(db.dias.fecha == date) &
((db.tickets.estado == 2) |
(db.tickets.estado == 1) |
(db.tickets.estado == 3))).select(db.dias.fecha,
db.tickets.importe, db.tickets.estado,
db.tickets.id, db.tickets.barcode)
if rows:
row = rows.first()
fila = {}
fila['fecha'] = row['dias']['fecha']
fila['importe'] = row['tickets']['importe']
fila['estado'] = row['tickets']['estado']
fila['id'] = row['tickets']['id']
fila['barcode'] = row['tickets']['barcode']
return fila
else:
return None
def get_log(unidad, accion, date=datetime.now()):
""" Obtiene el log de cierta accion en cierta maquina el dia de hoy. """
rows = db((db.log_usuarios.id_accion == get_id_accion(accion)) &
(db.log_usuarios.lugar == unidad)).select(db.log_usuarios.ALL)
for row in rows:
if row.fecha.strftime('%Y-%m-%d') == date.strftime('%Y-%m-%d'):
return row
def get_hora_cierre(unidad, date=datetime.now()):
""" Obtiene la hora de cierre de la maquina. """
rows = db((db.log_usuarios.id_accion == get_id_accion('retiro')) &
(db.log_usuarios.lugar == unidad)).select(db.log_usuarios.ALL)
for row in rows:
if row.fecha.strftime('%Y-%m-%d') == date.strftime('%Y-%m-%d'):
return row.fecha.strftime('%H:%M:%S')
def get_dias(user, limit, date=datetime.now()):
"""
Retorna una lista de limit cantidad de dias que tengan tickets
disponibles a partir de la fecha de hoy."""
cantidad = get_count_tickets(user)
weekdays = {0: 'Lu', 1: 'Ma', 2: 'Mi', 3: 'Ju', 4: 'Vi'}
lista_nombres = []
lista_dias = []
if limit > cantidad:
limit -= cantidad
hora = get_hora_compra()
if date.hour >= hora:
date = date + relativedelta(days=1)
rows = db((db.dias.tickets_vendidos < db.dias.tickets_totales) &
(db.dias.fecha >= date.date())).select(db.dias.fecha,
orderby=db.dias.fecha)
for row in rows:
if ((not get_ticket(user, row.fecha)) and
(len(lista_dias) < limit)):
fecha = "%s %s" % (weekdays[row.fecha.weekday()],
row.fecha.strftime('%d/%m/%Y'))
lista_nombres.append(fecha)
lista_dias.append(row.fecha)
return lista_dias, lista_nombres
else:
return lista_dias, lista_nombres
def get_usuario(dni):
"""Retorna una fila de usuario en base a un dni dado"""
rows = db(db.usuarios.dni == dni).select()
if rows:
return rows.first()
else:
return None
def get_estado(id_maquina):
"""Obtiene el estado actual de la maquina dado su id."""
row = db(db.maquinas.id == id_maquina).select().first()
if row:
return row.estado
else:
return None
def get_ubicacion(id_maquina):
""" Obtiene la ubicación de una maquina de acuerdo al número """
row = db(db.maquinas.id == id_maquina).select().first()
if row:
return get_facultad(row.ubicacion)
else:
None
def get_videos():
""" Obtiene la ruta, nombre y título de los videos de ayuda. """
rows = db().select(db.videos.ruta, db.videos.nombre, db.videos.titulo)
diccionario = {}
for row in rows:
diccionario[row['nombre']] = [row['ruta'], row['titulo']]
return diccionario
def get_maquina_ubicacion(id_facultad):
"""Retorna el id de una maquina dado el id de una facultad"""
row = db(db.maquinas.ubicacion == id_facultad).select().first()
if row:
return row.id
else:
return None
def get_tickets_disponibles(date=datetime.now()):
"""Devuelve los tickets disponibles para la semana dado cierto día. Por
defecto para el día de hoy. """
hora_actual = date.hour
hora_compra = get_hora_compra()
anio, sem, dow = date.isocalendar()
dias_hab = {
1: 'Lunes',
2: 'Martes',
3: 'Miercoles',
4: 'Jueves',
5: 'Viernes',
6: 'Sábado',
7: 'Domingo'
}
semana = {}
if hora_compra >= hora_actual:
row = db(db.dias.fecha == date.date()).select(db.dias.ALL).first()
if row:
disponibles = row.tickets_totales - row.tickets_vendidos
disponibles = str(disponibles)
else:
disponibles = '0'
else:
disponibles = '0'
semana['dia1'] = [dias_hab[dow], date.strftime('%d/%m/%Y'), disponibles]
semana['dia2'] = get_next_day(date)
semana['dia3'] = get_next_day(semana['dia2'][3])
semana['dia4'] = get_next_day(semana['dia3'][3])
semana['dia5'] = get_next_day(semana['dia4'][3])
return semana
def update_tickets_dia(id_dia, cantidad=1, band=1):
"""
Actualiza la cantidad de tickets vendidos de acuerdo a band en cant veces.
band = 1 -> compra aumenta la cantidad de tickets vendidos
band = 0 -> anulación disminuye la cantidad de tickets vendidos
"""
if band:
db(db.dias.id == id_dia).update(
tickets_vendidos=db.dias.tickets_vendidos + cantidad
)
else:
db(db.dias.id == id_dia).update(
tickets_vendidos=db.dias.tickets_vendidos - cantidad
)
db.commit()
def get_ticket_grupal_by_id(id_ticket):
""" Retorna la fila de un ticket grupal de acuerdo al id_ticket """
rows = db(
(db.tickets_grupales.id == id_ticket) &
(db.tickets_grupales.id_dia == db.dias.id)).select(
db.dias.fecha,
db.tickets_grupales.importe,
db.tickets_grupales.id,
db.tickets_grupales.cantidad,
db.tickets_grupales.delegacion,
db.tickets_grupales.recibo,
db.tickets_grupales.barcode
)
if rows:
row = rows.first()
fila = {}
fila['fecha'] = row['dias']['fecha']
fila['importe'] = row['tickets_grupales']['importe']
fila['delegacion'] = row['tickets_grupales']['delegacion']
fila['recibo'] = row['tickets_grupales']['recibo']
fila['cantidad'] = row['tickets_grupales']['cantidad']
fila['id'] = row['tickets_grupales']['id']
fila['barcode'] = row['tickets_grupales']['barcode']
return fila
else:
return None
def get_ticket_cierre(id_ticket):
""" Obtiene el ticket de cierre de acuerdo al id. """
row = db(db.tickets_cierre.id == id_ticket).select().first()
if row:
return row
else:
return None
def insert_ticket_cierre(id_log, total, unidad):
""" Registra el ticket de cierre de acuerdo al total de dinero retirado y
la maquina donde se hace. """
data = {}
data['fecha'] = datetime.now()
data['total'] = total
data['id_log_usuario'] = id_log
data['id_maquina'] = unidad
fecha = str(int(time()))
data['barcode'] = fecha
id_ticket = db.tickets_cierre.insert(**data)
db.commit()
id_ticket = str(id_ticket)
codigo = fecha + '0' * (10 - len(id_ticket)) + id_ticket
db(db.tickets_cierre.id == id_ticket).update(barcode=codigo)
db.commit()
return id_ticket
def get_papel_disponible(id_maquina):
""" Obtiene la cantidad de tickets que se pueden imprimir una vez
que tiene poco papel."""
row = db(db.maquinas.id == id_maquina).select().first()
if row:
return row.tickets_disponibles
else:
return None
def get_maquina(ubicacion):
"""Obtiene el número de maquina de acuerdo a su ubicación. """
id_facultad = get_id_facultad(ubicacion)
row = db(db.maquinas.ubicacion == id_facultad).select().first()
if row:
return row.id
else:
return None
def anular_ticket(id_ticket, user, unidad):
"""
Anula el ticket a traves de su id actualizando el estado.
estado = 3 -> consumido
estado = 2 -> impreso
estado = 1 -> activo
estado = 0 -> anulado
Además inserta en el log el ticket anulado, actualiza el saldo
y los tickets vendidos de ese día.
"""
db(db.tickets.id == id_ticket).update(estado=0)
db.commit()
id_log = insert_log(user, 'anular', unidad)
insert_ticket_log(id_ticket, id_log)
importe = get_importe_ticket(id_ticket)
update_saldo(user, importe, 0)
update_tickets_dia(get_dia_ticket(id_ticket), band=0)
def get_all_facultades():
"""Obtiene todas las facultades y devuelve un diccionario:
clave nombre, valor id"""
facultades = {}
rows = db().select(db.facultades.id, db.facultades.nombre)
for row in rows:
facultades[row['nombre']] = row['id']
return facultades
def get_hora_inicio(unidad, date=datetime.now()):
""" Obtiene la hora de inicio de la maquina. """
rows = db((db.log_usuarios.id_accion == get_id_accion('iniciar')) &
(db.log_usuarios.lugar == unidad)).select(db.log_usuarios.ALL)
for row in rows:
if (row.fecha.strftime('%Y-%m-%d') == date.strftime('%Y-%m-%d')
and "1er" in row.descripcion):
return row.fecha.strftime('%H:%M:%S')
def get_alumno(lu, dni):
""" Obtiene el id de un alumno si que es existe el par lu y dni. """
rows = db((db.alumnos.lu == lu) & (db.alumnos.dni == dni)).select()
if rows:
row = rows.first()
return row.id
else:
return None
def get_id_ticket_cierre(unidad, date=datetime.now()):
""" Obtiene el id del ticket de cierre de acuerdo al día
y a la unidad. """
rows = db(db.tickets_cierre.id_maquina == unidad).select()
for row in rows:
if row.fecha.strftime('%Y-%m-%d') == date.strftime('%Y-%m-%d'):
return row.id
return None
def get_all_provincias():
"""Obtiene todas las provincias y devuelve un diccionario:
clave nombre, valor id"""
provincias = {}
rows = db().select(db.provincias.id, db.provincias.nombre)
for row in rows:
provincias[row['nombre']] = row['id']
return provincias
def update_totales_dia(id_dia, cantidad=1, band=1):
"""
Actualiza la cantidad de tickets totales de acuerdo a band en cantidad
de veces:
band = 1 -> aumenta la cantidad de tickets totales
band = 0 -> disminuye la cantidad de tickets totales
"""
if band:
db(db.dias.id == id_dia).update(
tickets_totales=db.dias.tickets_totales + cantidad
)
else:
db(db.dias.id == id_dia).update(
tickets_totales=db.dias.tickets_totales - cantidad
)
db.commit()
def update_ticket_grupal(id_ticket, user, unidad, state):
""" Actualiza el estado del ticket por su id.
estado = 4 -> vencido
estado = 3 -> consumido
estado = 2 -> impreso
estado = 1 -> reservado
estado = 0 -> anulado
"""
db(db.tickets_grupales.id == id_ticket).update(id_estado=state)
db.commit()
if state == 2:
id_log = insert_log(user, 'imprimir_grupal', unidad)
insert_ticket_grupal_log(id_ticket, id_log)
elif state == 0:
id_log = insert_log(user, 'anular_grupal', unidad)
insert_ticket_grupal_log(id_ticket, id_log)
else:
pass
def get_cant_ticket_grupal(id_ticket):
"""
Retorna la cantidad del día del ticket grupal a traves de su id,
en caso de no encontrar ninguno retorna None
"""
row = db(db.tickets_grupales.id == id_ticket).select().first()
if row:
return row.cantidad
else:
return None
