def creaviaje():
datos=request.form
token=datos["token"]
if checkToken(token):
id_usuario=getIdFromToken(token)
dia=datos["dia"]
hora=datos["hora"]
minutos=datos["minutos"]
horaLlegada=datos["horaLlegada"]
minutosLlegada=datos["minutosLlegada"]
plazas=datos["plazas"]
precio=datos["precio"]
detalles=datos["detalles"]
destino=datos["destino"]
esdevuelta=datos["esdevuelta"]
consultaInsertarViaje="INSERT INTO `viajes` (`id_viaje`, `salida`, `llegada`, `detalles`, `id_usuario`, `plazas`, `precio`, `destino`,`EsDeVuelta`) \
VALUES (NULL, '2016-01-"+str(dia)+" "+str(hora)+":"+str(minutos)+":00', '2016-01-"+str(dia)+" "+str(horaLlegada)+":"+str(minutosLlegada)+":00',\
'"+str(detalles)+"', '"+str(id_usuario)+"', '"+str(plazas)+"', '"+str(precio)+"', '"+str(destino)+"',"+esdevuelta+")"
conexionCreaViaje=conexion.conectar()
cursorCreaViaje=conexionCreaViaje.cursor()
cursorCreaViaje.execute(consultaInsertarViaje)
conexionCreaViaje.commit()
conexionCreaViaje.close()
return {"exito":True}
return{"Error":"Token inválido"}
def viajesFiltrados():
datos=request.form
dia=datos["dia"]
hora=datos["hora"]
minutos=datos["minutos"]
destino=datos["destino"]
origen=getIdPueblo(datos["origen"])#Numero indicando el id del pueblo
margen=datos["margen"]
vuelta=datos["EsDeVuelta"]
consultaInsertarViaje="SELECT viajes.*,usuarios.pueblo_origen,usuarios.telefono FROM viajes INNER JOIN usuarios on viajes.id_usuario=usuarios.id_usuario where salida >= date_sub('2016-01-"+str (dia)+" "+str(hora)+":"+str(minutos)+":00',\
INTERVAL "+margen+" MINUTE) AND salida <= date_add('2016-01-"+str (dia)+" "+str(hora)+":"+str(minutos)+":00',\
INTERVAL "+margen+" MINUTE) AND pueblo_origen="+origen+" AND destino="+destino+" AND EsDeVuelta="+vuelta
#print (consultaInsertarViaje)
conexionCreaViaje=conexion.conectar()
cursorCreaViaje=conexionCreaViaje.cursor()
cursorCreaViaje.execute(consultaInsertarViaje)
conexionCreaViaje.close()
res=dict()
for id_viaje,salida,llegada,detalles,id_usuario,plazas,precio,destino,EsDeVuelta,pueblo_origen,telefono in cursorCreaViaje:
#salida_fecha= datetime.datetime.strptime(str(salida),"%Y-%M-%D %H:%M:%S").datetime()
salida_fecha=salida
salida_dia=salida_fecha.day
salida_hora=salida_fecha.hour
salida_minuto=salida_fecha.minute
res[id_viaje]={"dia":salida_dia,"hora":salida_hora,"minutos":salida_minuto,"detalles":detalles,"id_usuario":id_usuario,"plazas":plazas,"precio":str(precio),"telefono":str(telefono),"EsDeVuelta":str(EsDeVuelta)}
return res
def checkToken(token):
consultaToken='SELECT token FROM `usuarios` WHERE `token` LIKE \''+token+'\''
conexionToken=conexion.conectar()
cursorToken=conexionToken.cursor()
cursorToken.execute(consultaToken)
conexionToken.close()
for tok in cursorToken:
return True
return False
def registro():
datos = request.form
nombre = datos["nombre"]
apellidos = datos["apellidos"]
telefono = datos["telefono"]
pueblo = datos["pueblo"]
correo = datos["correo"]
passwd = generate_password_hash(
datos["password"]) # check_password_hash(pw_hash, password)
#verificar datos aqui:
#el pueblo existe
errores = list()
if (len(datos["password"]) < 6):
errores.append("Contraseña demasiado corta")
if (getIdPueblo(pueblo) == "ERROR"):
errores.append("error: pueblo no existente: " + pueblo)
#el correo es valido
if not validate_email(
correo): #paranoya: verify=True revisar que el correo existe
errores.append("error: correo no valido: " + correo)
#el telefono es valido
regexpTelefono = re.compile("^[9|6|7][0-9]{8}$")
if not regexpTelefono.match(telefono):
errores.append("error: telefono no valido: " + telefono)
#verificar que el usuario no está registrado:
consultaCorreoUnico = 'SELECT correo FROM `usuarios` WHERE `correo` LIKE \'' + correo + '\''
conexionRegistro = conexion.conectar()
cursorRegistro = conexionRegistro.cursor()
cursorRegistro.execute(consultaCorreoUnico)
for mail in cursorRegistro:
errores.append("Ya existe un usuario con este correo")
#En caso de error devolver una lista con los errores
if (len(errores) > 0):
return errores
#No hace falta else: hacemos un return
#Generar token para el usuario en caso de exito
token = generate_password_hash("TOKEN++" + passwd + datos["password"] +
correo)
#insertar datos en la base de datos
insertarUsuario="INSERT INTO `usuarios` (`id_usuario`, `nombre`, `apellidos`, `telefono`, `pueblo_origen`, `pass`, `correo`, `token`) VALUES (NULL, \'" +\
nombre+"\',\'"+apellidos+"\',\'"+telefono+"\',"+getIdPueblo(pueblo)+",\'"+passwd+"\',\'"+correo+"\',\'"+token+"\');"
#print(insertarUsuario)
cursorRegistro.execute(insertarUsuario)
conexionRegistro.commit()
conexionRegistro.close()
#devolver {"token":token}
return {"exito": True, "token": token}
def isBanned(user_name):
conn = conectar()
cur = conn.cursor()
cur.callproc('jugadorToxico', [user_name])
result = cur.fetchone()
cur.close()
conn.close()
return result[0]
def actualizar_nivel(userName):
conn = conectar()
cur = conn.cursor()
cur.callproc('update_nivel', [
userName,
])
cur.close()
conn.commit()
conn.close()
def getIdFromToken(token):
consultaToken='SELECT id_usuario FROM `usuarios` WHERE `token` LIKE \''+token+'\''
conexionToken=conexion.conectar()
#print(consultaToken)
cursorToken=conexionToken.cursor()
cursorToken.execute(consultaToken)
conexionToken.close()
res="ERROR"
for tok in cursorToken:
return tok[0]
#print("TOKEN INVALIDO")
return res
def getIdFromToken(token):
consultaToken = 'SELECT id_usuario FROM `usuarios` WHERE `token` LIKE \'' + token + '\''
conexionToken = conexion.conectar()
#print(consultaToken)
cursorToken = conexionToken.cursor()
cursorToken.execute(consultaToken)
conexionToken.close()
res = "ERROR"
for tok in cursorToken:
return tok[0]
#print("TOKEN INVALIDO")
return res
def RegistrarUsuario(datosDeRegistro):
data = datosDeRegistro
conn = conectar()
cur = conn.cursor()
cur.execute(
"""
INSERT into Jugador (nick,nombres,apellidoP,apellidoM,correo,contraseña,pais,cantReportes,ban_S_N,ultimoLogin,peleasDisponibles)
VALUES (%s, %s, %s, %s, %s, %s, %s,0,False,current_date,5);""",
(data[0], data[1], data[2], data[3], data[4], data[5], data[6]))
cur.close()
conn.commit()
conn.close()
def registro():
datos=request.form
nombre=datos["nombre"]
apellidos=datos["apellidos"]
telefono=datos["telefono"]
pueblo=datos["pueblo"]
correo=datos["correo"]
passwd= generate_password_hash(datos["password"])# check_password_hash(pw_hash, password)
#verificar datos aqui:
#el pueblo existe
errores=list()
if(len(datos["password"])<6):
errores.append("Contraseña demasiado corta")
if(getIdPueblo(pueblo)=="ERROR"):
errores.append("error: pueblo no existente: "+pueblo)
#el correo es valido
if not validate_email(correo):#paranoya: verify=True revisar que el correo existe
errores.append("error: correo no valido: "+correo)
#el telefono es valido
regexpTelefono = re.compile("^[9|6|7][0-9]{8}$")
if not regexpTelefono.match(telefono):
errores.append("error: telefono no valido: "+telefono)
#verificar que el usuario no está registrado:
consultaCorreoUnico='SELECT correo FROM `usuarios` WHERE `correo` LIKE \''+correo+'\''
conexionRegistro=conexion.conectar()
cursorRegistro=conexionRegistro.cursor()
cursorRegistro.execute(consultaCorreoUnico)
for mail in cursorRegistro:
errores.append("Ya existe un usuario con este correo")
#En caso de error devolver una lista con los errores
if(len(errores)>0):
return errores
#No hace falta else: hacemos un return
#Generar token para el usuario en caso de exito
token=generate_password_hash("TOKEN++"+passwd+datos["password"]+correo)
#insertar datos en la base de datos
insertarUsuario="INSERT INTO `usuarios` (`id_usuario`, `nombre`, `apellidos`, `telefono`, `pueblo_origen`, `pass`, `correo`, `token`) VALUES (NULL, \'" +\
nombre+"\',\'"+apellidos+"\',\'"+telefono+"\',"+getIdPueblo(pueblo)+",\'"+passwd+"\',\'"+correo+"\',\'"+token+"\');"
#print(insertarUsuario)
cursorRegistro.execute(insertarUsuario)
conexionRegistro.commit()
conexionRegistro.close()
#devolver {"token":token}
return {"exito":True,"token":token}
def banPlayer(nick):
if (nickExiste(nick)):
conn = conectar()
cur = conn.cursor()
cur.execute("UPDATE jugador SET ban_S_N = True WHERE nick = (%s) ",
(nick, ))
conn.commit()
cur.close()
conn.close()
return True
else:
cur.close()
conn.close()
return False
def login():
datos=request.form
correo=datos["correo"]
passwd=datos["password"]
consultaLogin='******''+correo+'\''
conexionLogin=conexion.conectar()
cursorLogin=conexionLogin.cursor()
cursorLogin.execute(consultaLogin)
for token,password in cursorLogin:
conexionLogin.close()
if check_password_hash(password, passwd):
return {"token":token}
conexionLogin.close()
return{"Error":"Usuario o contraseña inválido"}
def top3():
conn = conectar()
cur = conn.cursor()
top = []
cur.callproc('topNiveles', [])
result = cur.fetchall()
for jug in result:
top.append([jug[0], jug[1]])
cur.close()
conn.close()
return top
def login():
datos = request.form
correo = datos["correo"]
passwd = datos["password"]
consultaLogin = '******'' + correo + '\''
conexionLogin = conexion.conectar()
cursorLogin = conexionLogin.cursor()
cursorLogin.execute(consultaLogin)
for token, password in cursorLogin:
conexionLogin.close()
if check_password_hash(password, passwd):
return {"token": token}
conexionLogin.close()
return {"Error": "Usuario o contraseña inválido"}
def getAvatar(nick):
conn = conectar()
cur = conn.cursor()
cur.execute("select * from avatar")
found = False
for avatar in cur:
if (avatar[0] == nick):
found = True
atributes = [
avatar[0], avatar[1], avatar[2], avatar[3], avatar[4],
avatar[5]
]
return atributes
if (found == False):
print("No se encontro al avatar")
def __init__(self, configuracion):
"""
Se encarga de retornar un objeto SamDB, lista a usar en la operación que querramos
"""
self.claves = configuracion['claves']
self.borrables = configuracion['borrables']
self.traduccion = configuracion['traduccion']
self.lp = parametros()
self.sesion = conectar(self.lp)
if (self.sesion):
self.conexion = SamDB(session_info=self.sesion, lp=self.lp)
else:
raise AutenticacionException('No estás autenticado')
def subirStats(nick, stats):
conn = conectar()
cur = conn.cursor()
if (stats == "velocidad"):
cur.execute(
"UPDATE avatar SET velocidad = velocidad+3 WHERE nick=(%s) ",
(nick, ))
elif stats == "ataque":
cur.execute("UPDATE avatar SET ataque = ataque+1 WHERE nick=(%s) ",
(nick, ))
else:
cur.execute("UPDATE avatar SET vida = vida+3 WHERE nick=(%s) ",
(nick, ))
conn.commit()
cur.close()
conn.close()
def nickExiste(nick):
conn = conectar()
cur = conn.cursor()
cur.execute("SELECT nick FROM administrador ")
existe = False
# recorremos el cursor en la tabla de administrador
for administrador in cur:
if (administrador[0] == nick):
existe = True
#si no se encuentra ningun administrador con el nick correspondiente,
#recorremos a los jugadores
if (existe == False):
cur.execute("SELECT nick FROM jugador ")
for jugador in cur:
if (jugador[0] == nick):
existe = True
return existe
def report(nick):
conn = conectar()
cur = conn.cursor()
cur.execute('SELECT nick FROM jugador')
found = False
for jugador in cur:
if (jugador[0] == nick):
found = True
if found == True:
cur.execute(
'UPDATE jugador SET cantreportes = cantreportes+1 WHERE nick = (%s);',
(nick, ))
cur.close()
conn.commit()
conn.close()
return True
else:
cur.close()
conn.commit()
conn.close()
return False
def viajesFiltrados():
datos = request.form
dia = datos["dia"]
hora = datos["hora"]
minutos = datos["minutos"]
destino = datos["destino"]
origen = getIdPueblo(datos["origen"]) #Numero indicando el id del pueblo
margen = datos["margen"]
vuelta = datos["EsDeVuelta"]
consultaInsertarViaje = "SELECT viajes.*,usuarios.pueblo_origen,usuarios.telefono FROM viajes INNER JOIN usuarios on viajes.id_usuario=usuarios.id_usuario where salida >= date_sub('2016-01-" + str(
dia) + " " + str(hora) + ":" + str(minutos) + ":00',\
INTERVAL " + margen + " MINUTE) AND salida <= date_add('2016-01-" + str(
dia) + " " + str(hora) + ":" + str(minutos) + ":00',\
INTERVAL " + margen + " MINUTE) AND pueblo_origen=" + origen + " AND destino=" + destino + " AND EsDeVuelta=" + vuelta
#print (consultaInsertarViaje)
conexionCreaViaje = conexion.conectar()
cursorCreaViaje = conexionCreaViaje.cursor()
cursorCreaViaje.execute(consultaInsertarViaje)
conexionCreaViaje.close()
res = dict()
for id_viaje, salida, llegada, detalles, id_usuario, plazas, precio, destino, EsDeVuelta, pueblo_origen, telefono in cursorCreaViaje:
#salida_fecha= datetime.datetime.strptime(str(salida),"%Y-%M-%D %H:%M:%S").datetime()
salida_fecha = salida
salida_dia = salida_fecha.day
salida_hora = salida_fecha.hour
salida_minuto = salida_fecha.minute
res[id_viaje] = {
"dia": salida_dia,
"hora": salida_hora,
"minutos": salida_minuto,
"detalles": detalles,
"id_usuario": id_usuario,
"plazas": plazas,
"precio": str(precio),
"telefono": str(telefono),
"EsDeVuelta": str(EsDeVuelta)
}
return res
def generarAvatar(nick):
listaDatos = []
ataque = random.randint(1, 3)
vida = random.randint(10, 20)
velocidad = random.randint(1, 10)
listaDatos.append(nick)
listaDatos.append(ataque)
listaDatos.append(velocidad)
listaDatos.append(vida)
listaDatos.append(0)
conn = conectar()
cur = conn.cursor()
cur.execute(
"""
INSERT INTO avatar (nick, ataque, velocidad, vida,ptosexp,nivel)
VALUES (%s,%s,%s,%s,%s,1);""",
(listaDatos[0], listaDatos[1], listaDatos[2], listaDatos[3],
listaDatos[4]))
cur.close()
conn.commit()
conn.close()
def enviar_admin():
args = [0]
cursor.callproc('GenerarAdministradorSucursal', args)
cursor.execute("SELECT @_GenerarAdministradorSucursal_0;")
res_json = '{"opcode":0, "dato":' + cursor.fetchall()[0][0] + '}'
conexion.conectar(res_json.encode())
def enviar_promocion():
args = [0]
cursor.callproc('GenerarPuestoEmpleado', args)
cursor.execute("SELECT @_GenerarPuestoEmpleado_0;")
res_json = '{"opcode":4, "dato":' + cursor.fetchall()[0][0] + '}'
conexion.conectar(res_json.encode())
import conexion
import datetime
import hashlib
cnc = conexion.conectar()
database = cnc[0]
cursor = cnc[1]
class Usuario:
def __init__(self, nombre, apellido, email, contrasena):
self.nombre = nombre
self.apellido = apellido
self.email = email
self.contrasena = contrasena
def cifrar(self):
cifrado = hashlib.sha256()
cifrado.update(self.contrasena.encode("utf8"))
return cifrado.hexdigest()
def registrar(self):
sql = f"SELECT * FROM usuarios WHERE email = '{self.email}'"
cursor.execute(sql)
if cursor.rowcount > 1:
print(f"el email {self.email} ya esta registrado")
return [0, self]
fecha = datetime.datetime.now()
sql = "INSERT INTO usuarios VALUES(null, %s, %s, %s, %s, %s)"
usuario = (self.nombre, self.apellido, self.email, self.cifrar(), fecha)
try:
from flask import request, url_for
from flask.ext.api import FlaskAPI, status, exceptions
from werkzeug.security import generate_password_hash, check_password_hash
from validate_email import validate_email
import re
import conexion
import datetime
app = FlaskAPI(__name__)
cnx = conexion.conectar()
cursor = cnx.cursor()
#inicializando:
pueblos=dict()
destinos=dict()
query = ("SELECT * FROM pueblos "
#"WHERE hire_date BETWEEN %s AND %s"
)
cursor.execute(query)
#cursor.execute(query, (hire_start, hire_end))
for (id_pueblo, nombre_pueblo, id_provincia) in cursor:
pueblos[id_pueblo]=nombre_pueblo
#pueblos[id_pueblo]=(nombre_pueblo,id_provincia)
query = ("SELECT * FROM destinos"
#"WHERE hire_date BETWEEN %s AND %s"
)
#import usuarios.conexion as conexion
import conexion
conex = conexion.conectar()
database = conex[0]
cursor = conex[1]
class Nota:
def __init__(self, usuario_id, titulo='', descripcion=''):
self.usuario_id = usuario_id
self.titulo = titulo
self.descripcion = descripcion
def guardar(self):
sql = "INSERT INTO notas VALUES(null, %s, %s, %s, NOW(), 1)"
nota = (self.usuario_id, self.titulo, self.descripcion)
cursor.execute(sql, nota)
database.commit()
return [cursor.rowcount, self]
def listar(self):
sql = f'SELECT * FROM notas WHERE usuario_id = {self.usuario_id} AND estado=1'
cursor.execute(sql)
response = cursor.fetchall()
def enviar_cliente():
args = [0]
cursor.callproc('GenerarCliente', args)
cursor.execute("SELECT @_GenerarCliente_0;")
res_json = '{"opcode":1, "dato":' + cursor.fetchall()[0][0] + '}'
conexion.conectar(res_json.encode())
import conexion
connect = conexion.conectar()
database = connect[0]
cursor = connect[1]
class Nota:
def __init__(self, usuario_id, titulo="", descripcion="", realizada=""):
self.usuario_id = usuario_id
self.titulo = titulo
self.descripcion = descripcion
self.realizada = str(realizada)
def guardar(self):
sql = f"SELECT * FROM notas WHERE usuarios_id = {self.usuario_id} AND titulo LIKE '{self.titulo}'"
cursor.execute(sql)
if cursor.rowcount > 0:
print(f"la nota {self.titulo} ya esta registrada")
return [0, self]
sql = "INSERT INTO notas VALUES(null, %s, %s, %s, NOW(), %s)"
nota = (self.usuario_id, self.titulo, self.descripcion, self.realizada)
cursor.execute(sql, nota)
database.commit()
return [cursor.rowcount, self]
def listar(self):
sql = f"SELECT * FROM notas WHERE usuarios_id = {self.usuario_id} ORDER BY `realizada` ASC"
cursor.execute(sql)
result = cursor.fetchall()
return result
from src.extras import clean, convert_float, pause
from conexion import conectar
import pymysql as mysql
import json
import time
import random
import sys
encontradas_en_db = 0
donde = []
iguales = 0
encontradas = 0
no_encontradas = 0
conexion = conectar()
cur = conexion.cursor()
determinantes_no_encontradas = {}
""" try:
clean()
print('Iniciando...')
with open('determinantes.json', 'r') as f:
diccionario_de_determinantes = json.load(f)
clean()
except:
diccionario_de_determinantes = {} """
def contar_caracteres(cadena, caracter):
contador = 0
for i in range(len(cadena)):
if cadena[i] == caracter:
contador += 1
import mysql.connector
from datetime import datetime
from conexion import conectar
database, cursor = conectar()
class Usuario:
nombre: str
apellido: str
email: str
passwd: str
def __init__(self, nombre, apellido, email, passwd):
self.nombre = nombre
self.apellido = apellido
self.email = email
self.passwd = passwd
def crear_usuario(self):
try:
sql_request = f"INSERT INTO usuarios VALUES (null, '{self.nombre}', '{self.apellido}', '{self.email}', '{self.passwd}', '{datetime.now()}')"
cursor.execute(sql_request)
database.commit()
return True
except Exception as err:
print("Error al crear el usuario. " + str(type(err).__name__) +
": " + str(err))
def buscar_usuario(self):
