def nuevo_usuario(request):
log = '<form action="" method="POST">'
log += 'Nombre de usuario<br><input type="text" name="Usuario"><br>'
log += 'Password<br><input type="password" name="Password">'
log += '<br><input type="submit" value="Registrarme">'
log += '</form>'
inicio = '<a href="/">Inicio</a>'
if request.method == 'POST':
usuario = request.POST['Usuario']
password = request.POST['Password']
lista = User.objects.all()
for fila in lista:
if fila.username == usuario:
error = ""
error += '<span>Error.</span><br>'
error += 'El nombre de usuario ya esta usado. Pruebe otro.'
plantilla = get_template('index.html')
Contexto = Context({'loggin': log, 'inicio': inicio, 'error': error})
renderizado = plantilla.render(Contexto)
return HttpResponse(renderizado)
user = User.objects.create_user(usuario, usuario + '@ejemplo.com', password)
user.save()
user = Usuario(nombre=usuario)
user.save()
return HttpResponseRedirect('/')
plantilla = get_template('index.html')
Contexto = Context({'loggin': log, 'inicio': inicio})
renderizado = plantilla.render(Contexto)
return HttpResponse(renderizado)
def registrar(request):
if request.method == 'POST':
try:
formulario = FormaRegistro(request.POST, request.FILES)
if formulario.is_valid():
nombre = formulario.cleaned_data['nombre']
ap_paterno = formulario.cleaned_data['ap_paterno']
ap_materno = formulario.cleaned_data['ap_materno']
telefono = formulario.cleaned_data['telefono']
imagen = request.FILES['imagen']
usuario_nuevo = Usuario(us_nombre=nombre,
us_ap_paterno=ap_paterno,
us_ap_materno=ap_materno,
us_telefono=telefono,
us_img=imagen)
usuario_nuevo.save(formulario)
else:
print 'Error validando formulario'
print formulario.errors
return HttpResponseRedirect('/appella/registrar/')
except Exception as e:
print 'Error registrando nuevo Usuario: ', e
else:
formulario = FormaRegistro()
return render(request, 'registrar.html', {'form': formulario})
def registrar_usuario():
if request.method == "POST":
json_request = request.get_json(force=True)
logging.info(json_request)
response = {}
# Consultar usuario por identificacion
usuario = Usuario.obtener_usuario_por_id(int(json_request['id']))
if usuario:
response['status'] = '403'
response['message'] = 'El usuario ya se encuentra registrado'
else:
# Registrar usuario en datastore
nuevo_usuario = Usuario.registrar_nuevo_usuario(
identificacion=int(json_request['id']),
nombre=json_request['nombre'],
apellido=json_request['apellido'],
email=json_request['email']
)
response['status'] = '200'
response['message'] = 'El usuario fue registrado satisfactoriamente'
# Retornar respuesta
return json.dumps(response)
return "error"
def user(request):
if request.user.is_authenticated():
(mensaje, admin, logger, request.user.username) = autenticacionUsuario(request)
nombreUsuario = request.user.username
usuario = Usuario.objects.filter(nombre= nombreUsuario)
salida = ""
nameUser = True
Incluido = False
num = 0
for fila in usuario:
if fila.nombre == nombreUsuario:
nameUser = False
if nameUser:
principal = "Pagina de " + request.user.username
comentarioPrincipal = "Introduzca descripcion..."
name = Usuario(titulo= principal, nombre= request.user.username, comentario= comentarioPrincipal)
name.save()
userName = Usuario.objects.get(nombre=nombreUsuario)
listaActividades = userName.actividades.all()
for fila in listaActividades:
salida += "<br/>" + "<br/>"
salida += "Actividad" + "<br/>"
salida += "Titulo: " + fila.titulo + "<br/>"
salida += "Tipo: " + fila.tipo + "<br/>"
salida += "Precio: " + fila.precio + "<br/>"
salida += "Fecha: " + str(fila.fecha) + "<br/>"
salida += "Hora: " + str(fila.hora) + "<br/>"
salida += "Fecha Fin: " + str(fila.fechaFin) + "<br/>"
salida += "Evento Largo: " + str(fila.eventoLargo) + "<br/>"
salida += "<a href="+ fila.informacion + ">" + '+ info' + '</a>' + "<br/>"
member = Membership.objects.get(contenido=fila, usuario=userName)
fechaAct = member.fechaEleccion
salida += "elegida en " + str(fechaAct) + "<br/>"
salida += "<br/>"
num = num + 1
salida +='<form action="" method="POST" accept-charset="UTF-8">' +\
'Titulo: <input type="text" name="titulo">' +\
'Descripcion: <input type="text" name="descripcion">' +\
'<input type="submit" value="Enviar"></form>'
if request.method == "POST":
respuesta = request.POST.get("titulo")
if respuesta:
objeto = Usuario.objects.get(nombre= nombreUsuario)
objeto.titulo = respuesta
objeto.save()
descrip = request.POST.get("descripcion")
if descrip:
objeto = Usuario.objects.get(nombre= nombreUsuario)
objeto.comentario = descrip
objeto.save()
usuario = Usuario.objects.get(nombre = nombreUsuario)
return render_to_response('usuario.html',{'Espacio': "<br/>",'titulo':usuario.titulo,'comentario': usuario.comentario,'lista': salida, 'mensaje':mensaje, 'admin': admin, 'logger': logger}, context_instance=RequestContext(request))
else:
return HttpResponseRedirect("/noRegistrado")
def save(self, commit=True):
if not commit:
raise NotImplementedError("No se puede crear User y Usuario sin guardar en la base de datos")
user = super(UserCreateForm, self).save(commit=True)
user_profile = Usuario(user=user, telefono=self.cleaned_data['telefono'],
direccion=self.cleaned_data['direccion'])
user_profile.save()
return user, user_profile
def post(self):
usuario = Usuario(
nombre = self.request.get("nombre"),
apellido_paterno = self.request.get("apellido_paterno"),
apellido_materno = self.request.get("apellido_materno"),
edad = int(self.request.get("edad"))
)
usuario.put()
self.redirect('/')
def nuevoUSuario(request):
if Usuario.objects.filter(user=request.GET['user']).exists():
return render(request,'crearUsuario.html',{'userValido':True,'pas':False})
else:
if (request.GET['pass1'] == request.GET['pass2']):
nuevoUser = Usuario(nombre=request.GET['nombre'],apellido=request.GET['apellido'],user=request.GET['user'],pas=request.GET['pass1'],fNacimiento = request.GET['fechaNacimiento'],sexo= request.GET['sex'],email= request.GET['eMail'],telefono= request.GET['unTel'])
nuevoUser.save()
return HttpResponse('Usuario creado exitosamente')
else:
return render(request, 'crearUsuario.html',{'userValido':False,'pas':True})
def cogerActividad(request):
actividad = request.POST.get("Identificador", '')
try:
pagina = Usuario.objects.get(nombre = request.user)
except Usuario.DoesNotExist:
pagina = Usuario(nombre = str(request.user), evento = "Pagina de " + str(request.user))
pagina.save()
evento = Actividade.objects.get(id=actividad)
pagina.actividad.add(evento)
return HttpResponseRedirect("/todas")
def prueba(request):
if request.method == 'POST':
form = UploadFileForm(request.POST, request.FILES)
if form.is_valid():
newdoc = Usuario(us_img = request.FILES['file'])
newdoc.save(form)
return HttpResponseRedirect('/appella/')
else:
form = UploadFileForm()
return render(request, 'index.html', {'form': form})
def prueba(request):
if request.method == 'POST':
form = UploadFileForm(request.POST, request.FILES)
if form.is_valid():
newdoc = Usuario(us_img=request.FILES['file'])
newdoc.save(form)
return HttpResponseRedirect('/appella/')
else:
form = UploadFileForm()
return render(request, 'index.html', {'form': form})
def get_usuarios():
usuarios = Usuario.select()
usuarios = [Usuario.to_json() for Usuario in usuarios]
identificador = Usuario.select()
identificador = [Usuario.iden() for Usuario in identificador]
diccionario = {}
for x in range(len(usuarios)):
diccionario[identificador[x]] = usuarios[x]
return jsonify(diccionario)
def save(self, commit=True):
if not commit:
raise NotImplementedError(
"No se puede crear User y Usuario sin guardar en la base de datos"
)
user = super(UserCreateForm, self).save(commit=True)
user_profile = Usuario(user=user,
telefono=self.cleaned_data['telefono'],
direccion=self.cleaned_data['direccion'])
user_profile.save()
return user, user_profile
def register():
nombre = request.forms.get("usuario") #Obtengo los datos del body
password=request.forms.get("password")
tipo=request.forms.get("tipo")
query=Usuario.select().where(Usuario.nombre==nombre).first()
if query:
return ({'register':'False'})
else:
user = Usuario(nombre=nombre,password=password,tipo=tipo)
user.save()
return ({'register':'True'})
def usuario_nuevo():
try:
Usuario.nuevo(rpe=request.form['rpe'],
nombre=request.form['nombre'],
puesto=request.form['puesto'],
departamento=request.form['departamento'],
correo=request.form['correo'],
zona=request.form['zona'])
return "OK!", 200
except:
return "Error!", 404
def get(self):
# Retreive the original url from parameter or Referer header
if 'url' in self.request.params:
original_url = self.request.params['url']
else:
original_url = self.request.headers.get('referer')
if 'agendamlg-api' in original_url:
original_url = '/'
self.response.status_int = 301
if decorator.has_credentials():
# It is already logged in, so, store information about the user in ndb
try:
# Retreive the original url from memcache or from the upper method
come_from = memcache.get('come_from')
original_url = come_from if come_from else original_url
if isinstance(original_url, unicode):
original_url = original_url.encode('utf-8')
memcache.delete('come_from')
# Get user's info
http = decorator.http()
user = service.people().get(userId="me").execute(http=http)
user_id = user[u'id']
# Register or modify the user in ndb
user_or_not = Usuario.query(Usuario.idGoogle == user_id).fetch()
if not user_or_not:
Usuario(
idGoogle=user[u'id'],
tipo=1,
preferencias=[],
extra=to_json(user),
parent=agenda_key()
).put()
newcomer = True
else:
user_or_not[0].extra = to_json(user)
user_or_not[0].put()
newcomer = False
jwt_token = create_jwt_token(user_id)
if original_url:
self.redirect('{}?token={}&newcomer={}'.format(original_url, jwt_token, newcomer))
else:
newcomer = str(newcomer).lower()
self.response.headers['Content-Type'] = 'application/json; charset=utf8'
self.response.write(u'{{"token": "{}", "newcomer": {}}}'.format(jwt_token, newcomer))
except client.AccessTokenRefreshError:
self.redirect(self.request.path_url + '?' + urlencode({'url': original_url}))
else:
# Redirect to Google Authentication page
# TODO Make a better way to store the original_url, that is unique for any login
memcache.set('come_from', original_url) if original_url else None
self.redirect(decorator.authorize_url())
def usuario_nuevo(): try: Usuario.nuevo( rpe=request.form['rpe'], nombre=request.form['nombre'], puesto=request.form['puesto'], departamento=request.form['departamento'], correo=request.form['correo'], zona=request.form['zona']) return "OK!", 200 except: return "Error!", 404
def addusers(): ##esto se ejecuta cada vez que se ejecuta la aplicacion y actualiza los usuarios que hay users = User.objects.all() usrs = Usuario.objects.all() for user in users: add=True for us in usrs: if str(user) == us.user: add=False break if add: userr = Usuario(user=str(user), title="pagina de "+str(user), descripcion="esta es la pagina personal de "+str(user)) userr.save()
def nuevoUSuario(request):
if Usuario.objects.filter(user=request.GET['user']).exists():
return render(request,'crearUsuario.html',{'userValido':True,'pas':False})
else:
if (request.GET['pass1'] == request.GET['pass2']):
unUser = Usuario(nombre=request.GET['nombre'],apellido=request.GET['apellido'],user=request.GET['user'],pas=request.GET['pass1'],fNacimiento = request.GET['fechaNacimiento'],sexo= request.GET['sex'],email= request.GET['eMail'],telefono= request.GET['unTel'])
unUser.save()
request.session['user']= unUser.user
result = list()
result.append(unUser)
return render(request,'index.html',{'result':result,'logueado':True})
else:
return render(request, 'crearUsuario.html',{'userValido':False,'pas':True})
def test_criacao_de_usuario(self):
usuario = Usuario()
usuario.nome = "Usuario Test"
usuario.email = "*****@*****.**"
usuario.senha= "1234"
#pega o contexto da aplicacao
with self.app.app_context():
db.session.add(usuario)
db.session.commit()
#valida se o id foi incrementado pelo banco de dados
self.assertGreater(usuario.id, 0)
def login():
cpf = request.form["CPF"]
senha = request.form["senha"]
busca = Usuario.get_or_none(cpf=cpf, senha=senha)
lista = Usuario.select()
for a in lista:
if a.cpf == cpf:
pessoa = a.nome
if busca != None:
session['usuario'] = pessoa
render_template('inicio.html')
return redirect("/")
def cargar_usuarios():
usuarios = Usuario.objects.all()
if len(usuarios) == 0:
usuarios = User.objects.all()
respuesta = "Cargado en la base de datos!"
for usuario in usuarios:
nombre_usuario = usuario.username
new_user = Usuario(nombre=nombre_usuario)
new_user.save()
else:
respuesta = "Estan cargados usuarios en la base de datos!"
return respuesta
def __init__(self, request, accion="nuevo", profesorid=""):
self.usuario = Usuario()
self.accion = accion
self.request= request
self.profesorid = profesorid
self.obligatorios = ["nombre", "apellidos", "usuarioUJI", "rol"]
self.usuarioForm = UsuarioForm()
if self.accion == "editar" :
self.usuarioForm = UsuarioForm(instance = QueryUser().getUserByUserUJI(profesorid))
if (request.method == "POST" ):
self.usuarioForm = UsuarioForm(request.POST, instance=self.usuario)
def post(self):
nickname = self.request.get('nickname')
comentario = self.request.get('comentario')
user = Usuario(nombreusuario = nickname,
email = users.GetCurrentUser().email())
user.put()
coment = Comentario(usuario = user, comentario = comentario)
coment.put()
webapp2.redirect('/listaComentarios')
return webapp2.redirect('/listaComentarios')
def cargar_usuarios():
usuarios = Usuario.objects.all()
if len(usuarios) == 0:
usuarios = User.objects.all()
respuesta = "Cargado en la base de datos!"
for usuario in usuarios:
nombre_usuario = usuario.username
new_user = Usuario(nombre=nombre_usuario)
new_user.save()
else:
respuesta = "Estan cargados usuarios en la base de datos!"
return respuesta
def logger(request):
if request.user.is_authenticated():
try:
usuario = Usuario.objects.get(Nombre=request.user.username)
print('Usuario "Loggeado"')
except:
usuario = Usuario(Nombre=request.user.username,\
TituloPagina=('Pagina de '+request.user.username),\
Letra=12, ColorFondo='')
usuario.save()
print('Usuario no Encontrado, lo creo... y "Loggeo"')
else:
usuario = 0
return usuario
def mokarCriacaoDeUmUsuario(self):
iEmailUsuario1= '*****@*****.**'
iSenhaUsuario1= 'teste'
iUsername1= '000001'
iTipoUsuario1= Tipo_de_Usuario.objects.filter(id_tipo_usuario= constantes.cntTipoUsuarioFreelancer)[0]
iClasseUsuario1= Classe_de_Usuario.objects.filter(id_classe_usuario= constantes.cntClasseUsuarioPadrao)[0]
iRecebeEmail1= True
iNome= 'Nome'
iSobrenome= 'Sobrenome'
iUsuario1= Usuario(email=iEmailUsuario1, password=iSenhaUsuario1, tipo_usuario= iTipoUsuario1,
receber_email= iRecebeEmail1, first_name= iNome, last_name= iSobrenome,
classe_usuario= iClasseUsuario1)
iUsuario1.save()
self.assertEquals(iUsername1, (Usuario.objects.filter(email= iEmailUsuario1)[0]).username)
def get(self, juegoID):
user = users.get_current_user()
if user:
juego_id = int(juegoID)
juego = Juego.get_by_id(juego_id)
usuario_creador = Usuario.get_by_id(juego.usuario_creador.id())
usuario = Usuario.query(Usuario.id == user.user_id())
usuario = usuario.get()
participa = Participante.query(Participante.usuario == usuario.key,
Participante.juego == juego.key)
if participa.get():
participando = True
else:
participando = False
misTesoros = Tesoro.query(Tesoro.juego == juego.key)
misPistas = []
hallazgos = Hallazgo.query(Hallazgo.juego == juego.key)
for tesoro in misTesoros:
aux = Pista.query(Pista.tesoro == tesoro.key)
misPistas.append(aux.get())
#hallazgos_por_participante = Hallazgo.query(Hallazgo.validado==1,projection=[Hallazgo.usuario, Hallazgo.tesoro],group_by=[Hallazgo.usuario,Hallazgo.tesoro]).fetch();
#print(hallazgos_por_participante)
self.render_template(
'juego.html', {
'juego': juego,
'usuario_creador': usuario_creador,
'misPistas': misPistas,
'participa': participando,
'usuario': usuario,
'hallazgos': hallazgos,
'misTesoros': misTesoros
})
# if juego.estado==1:
# usuario_ganador = Usuario.get_by_id(juego.usuario_ganador.id())
# self.render_template('juego.html', {'juego': juego,'usuario_creador':usuario_creador,'usuario_ganador':usuario_ganador})
# else:
else:
self.redirect(users.create_login_url(self.request.uri))
def cadastro_usuario():
nome = request.form["nome"]
cpf = request.form["CPF"]
telefone = request.form["telefone"]
senha1 = request.form["senha1"]
senha2 = request.form["senha2"]
foto_usuario = request.form["foto"]
if senha1 == senha2:
novo_usuario = Usuario(nome=nome,
cpf=cpf,
senha=senha1,
foto="/static/" + foto_usuario,
telefone=telefone)
novo_usuario.save()
session['usuario'] = nome
return redirect("/")
def delete(self):
ndb.delete_multi(Comentario.query().fetch(keys_only=True))
ndb.delete_multi(MeGusta.query().fetch(keys_only=True))
ndb.delete_multi(Evento.query().fetch(keys_only=True))
ndb.delete_multi(Usuario.query().fetch(keys_only=True))
ndb.delete_multi(Categoria.query().fetch(keys_only=True))
self.response.unicode_body = u'{"True": "👌🏿"}'
def create(id_, name, email, profile_pic):
user = Usuario(google_id=id,
name=name,
email=email,
profile_pic=profile_pic)
session.add(user)
session.commit()
def create_usuario():
name = request.json['name']
email = request.json['email']
phone = request.json['phone']
pais = request.json['pais']
provincia = request.json['provincia']
ciudad = request.json['ciudad']
distrito = request.json['distrito']
direccion = request.json['direccion']
role = request.json['role']
fecha_registro = request.json['fecha_registro']
auth0id = request.json['auth0id']
nuevo_usuario = Usuario(name,email,phone,pais,provincia,ciudad,distrito,direccion,role,fecha_registro,auth0id)
try:
db.session.add(nuevo_usuario)
db.session.commit()
response = {
'code': '0',
'message': 'OK',
'signature': 'Se Agrego el Usuario ' + email
}
return jsonify(message=response)
except exc.SQLAlchemyError as e:
mensaje = (str(e))
response = {
'code': '-1',
'message': 'Error',
'signature': mensaje
}
#return jsonify(message=response)
return jsonify(message=response)
def create_user(username, password):
if already_exists(username):
return None
user = Usuario(usuario=username, password=password)
db.session.add(user)
db.session.commit()
return user
def get(self, juegoID):
user = users.get_current_user()
if user:
juegoID = int(juegoID)
juego = Juego.get_by_id(juegoID)
usuario = Usuario.query(Usuario.id == user.user_id())
usuario = usuario.get()
participa = Participante.query(Participante.usuario == usuario.key,
Participante.juego == juego.key)
if participa.get():
participando = 1
else:
participando = 0
mensajes = Mensaje.query(Mensaje.juego == juego.key)
self.render_template(
'foro_juego.html', {
'juego': juego,
'participa': participando,
'listaMensajes': mensajes,
'usuario': usuario.key
})
else:
self.redirect(users.create_login_url(self.request.uri))
def professor(professor_id):
# Request dos dados do professor no banco
professor = Usuario.buscarProfessorID(professor_id)
bolsas = Bolsa.query.filter_by(prof_id=professor_id).all()
return render_template('paginaProfessor.html',
professor=professor,
bolsas=bolsas)
def post_usuario():
request_usuario = request.get_json()
user1 = Usuario(name=request_usuario["name"])
db.session.add(user1)
db.session.commit()
return jsonify("all good"), 200
def criar_usuario():
novo_usuario = Usuario(request.form['usuario'], request.form['nome'], request.form['sobrenome'],
request.form['senha'], request.form['email'])
criado = usuarioDao.cria_usuario(novo_usuario)
if criado:
flash('Usuário cadastrado com sucesso!')
return redirect(url_for('login'))
def post_usuario():
if not request.json:
abort(400)
usuario = request.json.get('usuario')
contrasena = request.json.get('contrasena')
nombre = request.json.get('nombre')
descripcion = request.json.get('descripcion')
administrador = request.json.get('administrador')
if (administrador.isdigit() == False):
return jsonify(
generate_response(1, error='Administrador tiene que ser numerico'))
#Encripta la contraseña
password = generate_password_hash(str(contrasena))
usuario = Usuario.new(usuario, password, nombre, descripcion,
administrador)
if usuario is None:
abort(422)
if usuario == "error":
abort(406)
return jsonify(usuario.to_json())
def post(self, comentario_id):
iden = int(comentario_id)
nickname = self.request.get('nickname')
comentario = self.request.get('comentario')
user = Usuario(nombreusuario = nickname,
email = users.GetCurrentUser().email())
user.put()
coment = Comentario(usuario = user, comentario = comentario)
coment.put()
comentarioAntiguo = db.get(db.Key.from_path('Comentario', iden))
db.delete(comentarioAntiguo)
return webapp2.redirect('/listaComentarios')
def consultar(self,username,contraseña):
"""
Método encargado de consultar los datos de un usuario a partir de su correo y su contraseña.
Parámetros:
email -- que es el correo del usuario
password -- que es la contraseña del usuario
"""
try:
cnx = super().connectDB()
cursor = cnx.cursor()
sql = "select * from usuarios where username='******' and contraseña=sha('"+contraseña+"');"
cursor.execute(sql)
usuario=None
for row in cursor:
username=row[0]
contraseña=row[1]
usuario=Usuario(username,contraseña)
cursor.close()
cnx.close()
return usuario
except mysql.connector.Error as err:
if err.errno == errorcode.ER_ACCESS_DENIED_ERROR:
print("Something is wrong with your user name or password")
elif err.errno == errorcode.ER_BAD_DB_ERROR:
print("Database does not exist")
return None
def get(self, uid):
usuario = Usuario.query(Usuario.idGoogle == uid).fetch()
if not usuario:
raise AgendamlgNotFoundException.usuario_no_existe(uid)
else:
self.response.write(
usuario_a_json((from_json(usuario[0].extra), usuario[0])))
def post(self):
user = users.get_current_user()
usuario = Usuario.query().filter(Usuario.email == user.email()).get()
seleccion = self.request.get('checks', allow_multiple = True)
listaTags = [];
for nombreTag in seleccion:
tag = Tag.query().filter(Tag.nombre == nombreTag).get()
listaTags.append(tag)
evento = Eventos(nombre=self.request.get('nombre'),
descripcion=self.request.get('descripcion'),
direccion=self.request.get('direccion'),
creador= usuario,
latitud=float(self.request.get('latitud')),
longitud=float(self.request.get('longitud')),
fechaInicio=self.request.get('fechaInicio'),
fechaFin=self.request.get('fechaFin'),
likes = [],
comentarios =[],
tags = listaTags
)
evento.put()
return webapp2.redirect('/')
def entrada(pieza):
forma = FormaEntrada()
muestraObj = db.session.query(Muestra).filter_by(sku=pieza).first()
if forma.validate_on_submit():
usuario = int(forma.empleado.data)
admin = int(forma.encargado.data)
usuarioObj = db.session.query(Usuario).filter_by(
numero=usuario).first()
if not usuarioObj:
usuarioObj = Usuario(numero=usuario)
adminObj = db.session.query(Admin).filter_by(numero=admin).first()
if not adminObj:
adminObj = Admin(numero=admin)
muestraObj.cantidad = 1
ordenEntrega = Orden(muestra=muestraObj,
usuario=usuarioObj,
admin=adminObj,
tipo='Entrada',
timestamp=datetime.now())
db.session.add(ordenEntrega)
db.session.commit()
flash('Se entrego la pieza: {}'.format(muestraObj.sku))
return redirect(url_for('main'))
return render_template('entrada.html', entrada=forma, pieza=muestraObj)
def obtener_resultados_por_grupo(request, SoloJornadaActual):
grupo=Grupo.get_by_id(request.grupoKey)
resultados = ResultadoGrupo()
_match_res=[]
if grupo!=None:
jornadas=[]
if SoloJornadaActual:
jornadas=Jornada.query(Jornada.calendario==grupo.calendario.id(), Jornada.abierto==False).order(Jornada.Numero)
if jornadas.__len__()>0:
jornadas=[jornadas[-1:]] # CREO UNA NUEVA LISTA SOLO CON LA JORNADA ACTUAL (LA ULTIMA CERRADA)
else:
jornadas=Jornada.query(Jornada.calendario==grupo.calendario.id()).order(Jornada.Numero)
for j in jornadas:
partidos=Partido.query(Partido.jornada==j.key)
for usr in grupo.usuarios:
resultado = ResultadoGrupoJornada()
resultado.jornada=str( j.Numero)
resultado.nombre=Usuario.get_by_id(usr.key.id()).Nombre
resultado.usuario=usr.key.id()
for p in partidos:
res = ResultadoQuiniela.query(ResultadoQuiniela.partido == p.key, usuario == usr, ResultadoQuiniela.grupo == grupo.key)
for r in res:
if r.acierto:
resultado.aciertos = resultado.aciertos+1
_match_res.append(resultado)
resultados.nombre=grupo.Nombre
resultados.resultados=_match_res
return resultados
def grabar(request, todos_los_grupos):
grupo=Grupo.get_by_id(request.grupo)
calendario=Calendario.get_by_id(grupo.calendario.id())
respuesta=BooleanMessage()
if calendario!=None:
usuario=Usuario.get_by_id(request.correo)
if usuario!=None:
if todos_los_grupos:
grupos=Grupo.query(Grupo.usuarios == request.correo)
else:
grupos=[]
grupos.append(grupo)
for grupo in grupos:
for match in request.resultados:
partido=Partido.get_by_id(match.partido)
if partido!=None:
_key=partido.Local.id()+"vs"+partido.Visitante.id()+calendario.key.id()
res=ResultadoQuiniela.get_or_insert(_key)
res.usuario=usuario.key
res.partido=partido.key
res.resultado=match.resultado
res.grupo=grupo.key
res.put()
else:
respuesta.error=True
respuesta.mensaje="No esta registrado el grupo "+request.grupo
else:
respuesta.error=True
respuesta.mensaje="No existe el calendario"
return respuesta
def my_view(request):
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
auth.login(request,user)
try:
usu = Usuario.objects.get(nombre = username)
except:
url = "http://127.0.0.1:1234/" + username
rss = url + "/rss"
titulo_p = "Pagina de " + username
mi_usuario = Usuario(nombre = username,url = url,titulo_p = titulo_p,fondo = "css/defult.css",rss = rss)
mi_usuario.save()
return HttpResponseRedirect('/todas')
else:
return HttpResponseRedirect('/')
def post(self):
args = self.reqparse.parse_args()
email = args['email']
password = args['password']
nuevo_usuario = Usuario(email, password)
db.session.add(nuevo_usuario)
db.session.commit()
return formatOutput(1003), 201
def criaUsuarioDoFacebook(self, vUser, vEmail=None):
try:
iUsuario= Usuario()
iUsuario.pk= vUser.id
iUsuario.username= "******" % int(vUser.id)
iUsuario.email= vEmail
iUsuario.tipo_usuario= self.obtemTipoDeUsuario(constantes.cntTipoUsuarioAmbos)
iUsuario.classe_usuario = self.obtemClasseDeUsuario(constantes.cntClasseUsuarioPadrao)
iUsuario.receber_email = True
iUsuario.save()
return True
except Exception, e:
self.getLogger().error('Nao foi possivel obter User: ' + str(e))
return False
def verify_password(usuario_or_token, clave): #print(usuario_or_token) #print(clave) user = Usuario.verify_auth_token(usuario_or_token) if not user: user = Usuario.query.filter_by(vusu_usu=usuario_or_token).first() if not user or not user.login(clave): return False g.user = user return True
def addEve(request):
actividad = request.POST.get("Identificador", '')
try:
pp = Usuario.objects.get(name = request.user)
except Usuario.DoesNotExist:
pp = Usuario(name = str(request.user), event = "pagina de " + str(request.user))
pp.save()
pagaa = Actividade.objects.get(id=actividad)
pp.actividades.add(pagaa)
boolean = comprobar(str(request.user),actividad)
if not boolean:
myusuario = Usuario.objects.get(name = str(request.user))
myact = Actividade.objects.get(id=actividad)
hora = datetime.now()
publicar = FechAdd(fecha = hora, usuario = myusuario, actividad = myact)
publicar.save()
return HttpResponseRedirect("/todas")
def usuario_borrar(rpe): try: usuario = Usuario.select().where(Usuario.rpe == rpe) if usuario is not None: usuario[0].delete() return "OK!", 200 else: return "Error!", 404 except: return "Error!", 404
class ProfesorForm():
def __init__(self, request, accion="nuevo", profesorid=""):
self.usuario = Usuario()
self.accion = accion
self.request= request
self.profesorid = profesorid
self.obligatorios = ["nombre", "apellidos", "usuarioUJI", "rol"]
self.usuarioForm = UsuarioForm()
if self.accion == "editar" :
self.usuarioForm = UsuarioForm(instance = QueryUser().getUserByUserUJI(profesorid))
if (request.method == "POST" ):
self.usuarioForm = UsuarioForm(request.POST, instance=self.usuario)
def is_valid(self):
self.muestraErrorUsuario = True
esValido = self.usuarioForm.is_valid()
if ( not esValido and self.accion == "editar"):
if ( self.usuarioForm.data["usuarioUJI"] == self.profesorid ):
self.muestraErrorUsuario= False
if len(self.usuarioForm.errors)==1:
esValido = True
return esValido
def save(self):
if (self.accion == "nuevo"):
self.creaUsuario()
else:
self.editaUsuario()
def creaUsuario(self):
self.usuario.save()
def editaUsuario(self):
usuarioDB = QueryUser().getUserByUserUJI(self.profesorid)
usuarioDB.nombre = self.usuario.nombre
usuarioDB.apellidos = self.usuario.apellidos
usuarioDB.usuarioUJI = self.usuario.usuarioUJI
usuarioDB.rol = self.usuario.rol
usuarioDB.save()
def login(request):
from datetime import datetime
from pyfb import Pyfb
from NossaCarona.settings import FACEBOOK_APP_ID, FACEBOOK_SECRET_KEY, FACEBOOK_REDIRECT_URL_LOGIN
if request.GET.get('code'): #Login WITH facebook
code = request.GET['code']
facebook = Pyfb(FACEBOOK_APP_ID)
facebook.get_access_token(FACEBOOK_SECRET_KEY, code, redirect_uri=FACEBOOK_REDIRECT_URL_LOGIN)
me = facebook.get_myself()
userdjango = authenticate(fb_id=me.id)
if not userdjango:
userdjango = DjangoUser.objects.create_user(me.email, me.email, None)
userdjango.first_name = me.first_name
userdjango.last_name = me.last_name
userdjango.save()
usuario = Usuario(user=userdjango, sexo=me.gender[0], fb_id=me.id, dt_nascimento=datetime.strptime(me.birthday,'%m/%d/%Y'))
usuario.save()
userlogin(request,userdjango)
else: #login WITHOUT facebook
pass
return HttpResponseRedirect('/')
def modCSS(request):
myname = request.user
myevent = request.POST.get("event", '')
myCfondo = request.POST.get("fondo", '')
myCletra = request.POST.get("letra", '')
try:
info_user = Usuario.objects.get(name = myname)
if myevent != "":
info_user.event = myevent
if myCfondo != "":
info_user.fondo = myCfondo
if myCletra != "":
info_user.letra = myCletra
info_user.save()
except Usuario.DoesNotExist:
info_user = Usuario(name = myname, event = myevent, fondo = myCfondo, letra = myCletra)
info_user.save()
return HttpResponseRedirect("/" + str(request.user))
def registrar(request):
if request.method == 'POST':
try:
formulario = FormaRegistro(request.POST, request.FILES)
if formulario.is_valid():
nombre = formulario.cleaned_data['nombre']
ap_paterno = formulario.cleaned_data['ap_paterno']
ap_materno = formulario.cleaned_data['ap_materno']
telefono = formulario.cleaned_data['telefono']
imagen = request.FILES['imagen']
usuario_nuevo = Usuario(us_nombre=nombre, us_ap_paterno=ap_paterno, us_ap_materno=ap_materno, us_telefono=telefono, us_img=imagen)
usuario_nuevo.save(formulario)
else:
print 'Error validando formulario'
print formulario.errors
return HttpResponseRedirect('/appella/registrar/')
except Exception as e:
print 'Error registrando nuevo Usuario: ', e
else:
formulario = FormaRegistro()
return render(request, 'registrar.html', {'form': formulario})
def usuario_actualizar(rpe): try: usuario = Usuario.update( rpe=request.form['rpe'], nombre=request.form['nombre'], puesto=request.form['puesto'], departamento=request.form['departamento'], correo=request.form['correo'], zona=request.form['zona']).where(Usuario.rpe == rpe) usuario.execute() return "OK!", 200 except: return "Error!", 404
def formulario(request):
if request.method == 'POST':
form = UsuarioForm(request.POST, request.FILES)
if form.is_valid():
nome = form.cleaned_data['nome']
email = form.cleaned_data['email']
senha = form.cleaned_data['senha']
idade = form.cleaned_data['idade']
profissao = form.cleaned_data['profissao']
salario = form.cleaned_data['salario']
tipopessoa = form.cleaned_data['tipopessoa']
cpf_cnpj = form.cleaned_data['cpf_cnpj']
p = Usuario(nome=nome, email=email,senha=senha, idade=idade, profissao=profissao, salario=salario, tipopessoa=tipopessoa, cpf_cnpj=cpf_cnpj)
p.save()
return render_to_response("salvo.html", {"usuario" : nome})
else:
form = UsuarioForm()
return render_to_response("formulario.html", {'form' : form}, context_instance=RequestContext(request))
def buscar(request, usuarios):
partidosJornada = []
jm = JornadaMessage()
grupo=Grupo.get_by_id(int(request.grupokey))
if grupo!=None:
jornada=None
try:
jornada=Jornada.get_by_id(request.jornada)
except:
jornada=None
if jornada==None:
jornada=Jornada.query(Jornada.calendario == grupo.calendario, Jornada.Numero == int(request.jornada))
jornada=jornada.get()
if jornada!=None:
if usuarios==None:
usuarios=[usr.id() for usr in grupo.usuarios]
partidos=Partido.query(Partido.jornada==jornada.key)
if partidos!=None:
for p in partidos:
for usr in usuarios:
partido=PartidoMessage()
partido.Fecha = p.Fecha.strftime('%d/%m/%Y')
partido.Info1 = p.Info1
partido.Info2 = p.Info2
partido.key = p.key.id()
partido.acierto = es_acierto(usr, p, p.GolesLocal, p.GolesVisitante)
partido.resultado = calculoResultado(p.GolesLocal, p.GolesVisitante)
partido.GolesLocal=p.GolesLocal
partido.GolesVisitante=p.GolesVisitante
partido.jornadaAbierta=jornada.abierto
usuario=Usuario.get_by_id(usr)
partido.NombreUsuario=usuario.Nombre
partido.CorreoUsuario=usuario.Correo
local= EquipoMessage()
l=Equipo.get_by_id(p.Local.id())
if l!=None:
local.Nombre=l.Nombre
local.key=l.key.id()
visitante=EquipoMessage()
v=Equipo.get_by_id(p.Visitante.id())
if v!=None:
visitante.Nombre=v.Nombre
visitante.key=v.key.id()
partido.Local = local
partido.Visitante = visitante
partidosJornada.append(partido)
jm.key = jornada.key.id()
jm.Nombre=jornada.Nombre
jm.partidos = partidosJornada
return jm
def buscar_grupos(request):
usr = Usuario.get_by_id(request.grupoKey)
_gpos=[]
if usr != None:
grupos=Grupo.query(Grupo.usuarios == usr.key)
if grupos!=None:
for grupo in grupos:
_gpo = GrupoMessage()
_gpo.Nombre=grupo.Nombre
_gpo.key = str(grupo.key.id())
_gpos.append(_gpo)
respuesta=GrupoMessageCollection(grupos=_gpos)
return respuesta
def es_acierto(usuario,partido, golesLocal, golesVisitante):
usuario=Usuario.get_by_id(usuario)
respuesta=False
_resultado_oficial=calculoResultado(golesLocal, golesVisitante)
if usuario!=None:
match=Partido.get_by_id(partido.key.id())
if match!=None:
res=ResultadoQuiniela.query(ResultadoQuiniela.partido == match.key, ResultadoQuiniela.usuario == usuario.key)
res=res.get()
if res!=None:
if res.resultado!="NO_ESPECIFICADO":
acierto = res.resultado==_resultado_oficial
if res.acierto==None:
res.acierto=acierto
res.put()
return respuesta #715 38 29
