def usuariosView(request):
if request.method == "POST":
formularioUsuarios = UsuariosForm(request.POST)
if formularioUsuarios.is_valid():
#if formularioUsuarios.cleaned_data['password']=formularioUsuarios.cleaned_data['password2']:
dia=formularioUsuarios.cleaned_data['fecha_nacimiento_dia']
mes=formularioUsuarios.cleaned_data['mes']
ano=formularioUsuarios.cleaned_data['ano']
fecha=ano+"-"+mes+"-"+dia
usuarios= Usuarios(
nombre=formularioUsuarios.cleaned_data['nombre'],
apellidos=formularioUsuarios.cleaned_data['apellidos'],
ci=formularioUsuarios.cleaned_data['ci'],
fecha_nacimiento=fecha,
direccion=formularioUsuarios.cleaned_data['direccion'],
telefono=formularioUsuarios.cleaned_data['telefono'],
email=formularioUsuarios.cleaned_data['email'],
nickname=formularioUsuarios.cleaned_data['nickname'],
password=formularioUsuarios.cleaned_data['password']
)
usuarios.save()
return redirect('/db/menu/')
#else:
else:
formularioUsuarios= UsuariosForm()
return render_to_response("usuarios.html",{"formularioUsuarios": formularioUsuarios}, context_instance=RequestContext(request))
def post(self, nome):
if nome == 'Admin':
response = login_igual_nome(nome)
if response == True:
dados = request.json
if "nome" in dados and "idade" in dados and "senha" in dados:
pessoa = Pessoas(nome=dados['nome'], idade=dados['idade'])
usuario = Usuarios(login=dados['nome'],senha=dados['senha'], status=1)
pessoa.save()
usuario.save()
response = {
'id': pessoa.id,
'senha':usuario.senha,
'nome': pessoa.nome,
'idade': pessoa.idade
}
return response
else:
response = {
'status': 'error',
'mensagem': [{
'nome': '????',
'senha': '????',
'idade': '????'}]
}
return response
else:
return response
else:
response = {
'status': 'error',
'mensagem': 'Função requer acesso de administrador '
}
return response
def mostrartemplate(request,recurso):
salida = " "
if request.method == "GET":
lista = Usuarios.objects.filter(name=recurso)
salida += logueo(request)
if not lista:
return NotFound(request,recurso)
for i in lista:
salida += "<br>Name: " + i.name + "<br>Birthday: " + i.birthday
if request.method == "PUT":
print request.body
if request.user.is_authenticated():
nuevo = Usuarios(name = recurso, birthday = request.body)
nuevo.save()
salida += "Creado el recurso, pruebe en /usuarios/" + recurso + "o /anotated/" + recurso
else:
salida = logueo(request)
try:
lista = Usuarios.objects.filter(name=recurso)
nombre = " "
birthday = " "
for i in lista:
nombre += i.name
birthday += i.birthday
# 1. Indicar la plantilla a utilizar
plantilla = get_template('index.html')
# 2. Definir el contexto
c = Context({'title': recurso, 'nombre': nombre, 'cumple': birthday,})
# 3. Renderizar
renderizado = plantilla.render(c)
return HttpResponse(renderizado)
except Usuarios.DoesNotExist:
salida += "Page not found: " + recurso
return HttpResponseNotFound(salida)
def lista_usuarios(cls, request):
try:
token = jwt.decode(request.tokenint, 'secret') #checa token
user = Usuarios.get_by_id(
token['user_id']) #obtiene usuario dado el token
lista = [] #crea lista
lstMessage = UserList(code=1) # crea objeto mensaje
lstBd = Usuarios.query().fetch() # recupera de base de datos
for i in lstBd: # recorre
lista.append(
UserUpdate(
token='',
entityKey=i.entityKey,
#empresa_key=user.empresa_key.urlsafe(),
email=i.email,
codigo_empresa=i.codigo_empresa)) # agrega a la lista
lstMessage.data = lista # la manda al messa
message = lstMessage #regresa
except jwt.DecodeError:
message = UserList(code=-1, data=[]) #token invalido
except jwt.ExpiredSignatureError:
message = UserList(code=-2, data=[]) #token expiro
return message
def post(self):
dados = request.json
usuario = Usuarios(nome=dados['nome'])
usuario.save()
response = {
'id': usuario.id,
'nome': usuario.nome,
}
return response
def get_user_compensar(self, id, id_type):
"""
Get Usuarios active or inactive
:param id:
:return:
"""
#records = Usuarios.objects(id_usuario__exact=id)
#rows = Usuarios.objects(id_usuario='1000000765')
try:
elemento_usos = []
record = records = Usuarios.objects(
id_usuario__exact=id, tipo_id_usurio__exact=id_type.upper())
if record.count() == 0:
return {'msg': 'User Not Activated', 'code': 0}
records = Usuarios.objects(id_usuario__exact=id, tipo_id_usurio__exact=id_type.upper()).aggregate(*[
{
'$lookup': {
'from': Usos._get_collection_name(),
'localField': 'id_trabajador',
'foreignField': 'id_trabajador',
'as': 'Usos'
},
},
{
'$lookup': {
'from': Cluster._get_collection_name(),
'localField': 'cluster_id',
'foreignField': 'cluster_id',
'as': 'Cluster'
}
},
])
for element in records:
elemento_usos = element
elemento_usos = copy.deepcopy(elemento_usos)
if len(element['Usos']) == 0:
elemento_usos['Usos'] = {'red': 0, 'aliados': 0}
else:
elemento_usos['Usos'] = []
elemento_usos['Usos'] = {
"red": element['Usos'][0]['usos_red'],
"aliados": element['Usos'][0]['usos_aliados'],
}
return elemento_usos
except Exception as err:
print(err)
return err
def registro(request):
if request.method == 'POST':
formulario = UserCreateForm(request.POST)
if formulario.is_valid:
formulario.save()
u = User.objects.get(username=request.POST['username'])
u.is_active=False
u.save()
usuario = Usuarios(usuario=u)
usuario.save()
return HttpResponseRedirect('/usuario/editar/')
else:
formulario = UserCreateForm()
context={"formulario":formulario}
return render_to_response('usuario/registro.html', context, context_instance=RequestContext(request))
def user_add(cls, request):
try:
token = jwt.decode(request.token, 'secret') #CHECA EL TOKEN
user = Usuarios.get_by_id(token['user_id'])
if validarEmail(request.email
) == False: #checa si el email esta registrado
#empresakey = ndb.Key(urlsafe=request.empresa_key) #convierte el string dado a entityKey
if user.usuario_m(
request, user.empresa_key
) == 0: #llama a la funcion declarada en models.py en la seccion de USUARIOS
codigo = 1
else:
codigo = -3
#la funcion josue_m puede actualizar e insertar
#depende de la ENTRADA de este endpoint method
message = CodeMessage(code=codigo, message='Succesfully added')
else:
message = CodeMessage(code=-4,
message='El email ya ha sido registrado')
except jwt.DecodeError:
message = CodeMessage(code=-2, message='Invalid token')
except jwt.ExpiredSignatureError:
message = CodeMessage(code=-1, message='Token expired')
print message
return message
def get(self):
self.response.headers.add_header('Access-Control-Allow-Origin', '*')
self.response.headers['Content-Type'] = 'application/json'
id_user = self.request.get('user')
objemp = Usuarios.query(Usuarios.email == id_user).get()
if objemp is None:
myList = []
json_string = json.dumps(myList, default=MyClass)
self.response.write(json_string)
return None
strKey = objemp.key.urlsafe()
ownerKey = ndb.Key(urlsafe=strKey)
myEntities = Publisher.query(Publisher.user_key == ownerKey)
myList = []
for i in myEntities:
myObj = DemoClass()
myObj.entityKey = i.entityKey
myObj.nameA = i.nameA
myObj.location = i.location
myObj.year = i.year
myObj.logo = i.logo
myList.append(myObj)
json_string = json.dumps(myList, default=MyClass)
self.response.write(json_string)
def rec_pass():
"""
Function which displays the form to retrieve the user's password.
"""
if request.method == 'POST':
login = request.form["usuario"]
if login:
user = Usuarios.objects(usuario=login).first()
if user:
email = user.email
if email:
passw = gen_passwd(8)
user.password = passw
user.save(clean=False)
send_email(email, passw)
return render_template('user/rec_pass.html', email=email)
else:
error = u"No ha introducido ningún email válido en su perfil"
else:
error = u"El usuario introducido no es válido"
else:
error = u"Debe introducir un usuario"
return render_template("user/rec_pass.html", error=error)
return render_template('user/rec_pass.html')
def client_update(cls, request):
try:
token = jwt.decode(request.token, 'secret') #CHECA EL TOKEN
user = Usuarios.get_by_id(
token['user_id']
) #obtiene el usuario para poder acceder a los metodos declarados en models.py en la seccion de USUARIOS
#empresakey = ndb.Key(urlsafe=user.empresa_key.urlsafe())#convierte el string dado a entityKey
print(request.name)
print(request.lastname)
client = Client(
) #Se crea para instanciarse solamente, no para hacer uno nuevo
if client.client_m(
request, user.key
) == 0: #llama a la funcion declarada en models.py en la seccion de USUARIOS
codigo = 1
else:
codigo = -3
#la funcion josue_m puede actualizar e insertar
#depende de la ENTRADA de este endpoint method
message = CodeMessage(
code=1, message='Sus cambios han sido guardados exitosamente')
except jwt.DecodeError:
message = CodeMessage(code=-2, message='Invalid token')
except jwt.ExpiredSignatureError:
message = CodeMessage(code=-1, message='Token expired')
return message
def users_get(cls, request):
try:
token = jwt.decode(request.tokenint, 'secret') #checa token
userentity = ndb.Key(urlsafe=request.entityKey)
user = Usuarios.get_by_id(userentity.id()) #obtiene usuario
#user = Usuarios.get_by_id(token['user_id']) #obtiene usuario dado el token
lista = [] #crea lista
lstMessage = UserList(code=1) # crea objeto mensaje
lista.append(
UserUpdate(
token='',
entityKey=user.entityKey,
#empresa_key = user.empresa_key.urlsafe(),
email=user.email,
nombre=user.nombre,
talla=user.talla,
edad=user.edad,
urlImage=user.urlImage))
lstMessage.data = lista #ASIGNA a la salida la lista
message = lstMessage
except jwt.DecodeError:
message = UserList(code=-1, data=[]) #token invalido
except jwt.ExpiredSignatureError:
message = UserList(code=-2, data=[]) #token expiro
return message
def users_login(cls, request):
try:
user = Usuarios.query(Usuarios.email == request.email).fetch(
) #obtiene el usuario dado el email
if not user or len(user) == 0: #si no encuentra user saca
raise NotFoundException()
user = user[0]
keye = user.empresa_key.urlsafe(
) # regresa como mensaje el empresa key
if not user.verify_password(
request.password): # checa la contrasena
raise NotFoundException()
token = jwt.encode(
{
'user_id': user.key.id(),
'exp': time.time() + 43200
}, 'secret') #crea el token
message = TokenMessage(token=token, message=keye,
code=1) # regresa token
except NotFoundException:
message = TokenMessage(token=None,
message='Wrong username or password',
code=-1)
return message
def product_list(cls, request):
try:
token = jwt.decode(request.tokenint, 'secret') #checa token
user = Usuarios.get_by_id(
token['user_id']) #obtiene usuario dado el token
lista = [] #crea lista
lstMessage = ProductList(code=1) # crea objeto mensaje
lstBd = Product.query().fetch(
) # recupera de base de datos igual a un select * from blabla
for i in lstBd: # recorre
lista.append(
ProductUpdate(
token='',
entityKey=i.entityKey,
#empresa_key=user.empresa_key.urlsafe(),
code=i.code,
description=i.description,
urlImage=i.urlImage)) # agrega a la lista
lstMessage.data = lista # la manda al messa
message = lstMessage #regresa
except jwt.DecodeError:
message = ProductList(code=-1, data=[]) #token invalido
except jwt.ExpiredSignatureError:
message = ProductList(code=-2, data=[]) #token expiro
return message
def empresa_list(cls, request):
try:
token = jwt.decode(request.tokenint, 'secret') #CHECA EL TOKEN
user = Usuarios.get_by_id(
token['user_id']) #obtiene usuario dado el token
#if user.importante==1 or user.importante==2:
lista = [] #crea lista para guardar contenido de la BD
lstMessage = EmpresaList(code=1) #CREA el mensaje de salida
lstBdEmpresa = Empresa.query().fetch(
) #obtiene de la base de datos
for i in lstBdEmpresa: #recorre la base de datos
#inserta a la lista creada con los elementos que se necesiten de la base de datos
#i.empresa_key.urlsafe() obtiene el entityKey
#lista.append(ClientesUpdate(token='', nombre=i.nombre, status=i.status, empresa_key=i.empresa_key.urlsafe(), entityKey=i.entityKey))
lista.append(
EmpresaUpdate(token='',
entityKey=i.entityKey,
codigo_empresa=i.codigo_empresa,
nombre_empresa=i.nombre_empresa))
lstMessage.data = lista #ASIGNA a la salida la lista
message = lstMessage
#else:
# message = EmpresaList(code=-3, data=[])
except jwt.DecodeError:
message = EmpresaList(code=-1, data=[])
except jwt.ExpiredSignatureError:
message = EmpresaList(code=-2, data=[])
return message
def tweet_list(cls, request):
try:
token = jwt.decode(request.tokenint, 'secret') #CHECA EL TOKEN
user = Usuarios.get_by_id(
token['user_id']) #obtiene usuario dado el token
lista = [] #crea lista para guardar contenido de la BD
lstMessage = TweetList(code=1) #CREA el mensaje de salida
lstBd = Tweet.query().fetch() #obtiene de la base de datos
for i in lstBd: #recorre la base de datos
#inserta a la lista creada con los elementos que se necesiten de la base de datos
#i.empresa_key.urlsafe() obtiene el entityKey
lista.append(
TweetUpdate(
token='',
entityKey=i.entityKey,
#empresa_key=i.empresa_key.urlsafe(),
title=i.title,
description=i.description,
urlImage=i.urlImage))
lstMessage.data = lista #ASIGNA a la salida la lista
message = lstMessage
except jwt.DecodeError:
message = TweetList(code=-1, data=[])
except jwt.ExpiredSignatureError:
message = TweetList(code=-2, data=[])
return message
def register():
dic = json.loads(request.get_data())
nombre = dic['nombre']
apellido = dic['apellido']
email = dic['email']
password = dic['password']
edad = dic['edad']
ciudad = dic['ciudad']
genero = dic['genero']
estado = dic['estado']
interes = dic['interes']
fotoPerfil = dic['fotoPerfil']
fecha = str(datetime.datetime.now())
uri = save(fotoPerfil, fecha)
try:
usuario = Usuarios(nombre=nombre,
apellido=apellido,
email=email,
password=password,
edad=edad,
ciudad=ciudad,
genero=genero,
estado=estado,
interes=interes,
fotoPerfil=uri)
db.session.add(usuario)
db.session.commit()
dic = {"userId": str(usuario.id)}
return json.dumps(dic)
except Exception as e:
return (str(e))
def instructor_list(cls, request):
try:
token = jwt.decode(request.tokenint, 'secret') #checa token
user = Usuarios.get_by_id(
token['user_id']) #obtiene usuario dado el token
lista = [] #crea lista
lstMessage = InstructorList(code=1) # crea objeto mensaje
lstBd = Instructor.query().fetch(
) # recupera de base de datos igual a un select * from blabla
for i in lstBd: # recorre
lista.append(
InstructorUpdate(
token='',
entityKey=i.entityKey,
#empresa_key=user.empresa_key.urlsafe(),
name=i.name,
lastname=i.lastname,
age=i.age,
sport=i.sport,
urlImage=i.urlImage))
lstMessage.data = lista # la manda al messa
message = lstMessage #regresa
except jwt.DecodeError:
message = ClientList(code=-1, data=[]) #token invalido
except jwt.ExpiredSignatureError:
message = ClientList(code=-2, data=[]) #token expiro
return message
def signup():
from models import Usuarios
form = formRegistro()
if form.validate_on_submit():
user_exist = Usuarios.query.\
filter_by(username=form.username.data).first()
if user_exist is None and form.password_c is form.password:
user = Usuarios()
form.populate_obj(user)
user.admin = False
db.session.add(user)
db.session.commit()
return redirect(url_for('home'))
elif form.password_c is not form.password:
form.password.errors.append("la contraseña no coincide")
else:
form.username.errors.append("Nombre de Usuario en uso")
return render_template('signup_form.html', form=form)
def post(self):
dados = request.json
try:
hashed_password = generate_password_hash(dados['senha'],
method='sha256')
usuario = Usuarios(nome_completo=dados['nome_completo'],
cpf=dados['cpf'],
email=dados['email'],
senha=hashed_password,
public_id=str(uuid.uuid4()))
usuario.save()
mensagem = f'Usuário {usuario.nome_completo} cadastrado com sucesso.'
response = {'status': 'Sucesso', 'message': mensagem}
except:
response = {
'status': 'Error',
'message': 'Este CPF e/ou e-mail já possui conta cadastrada.'
}
return response
def valores(request,recurso):
salida = " "
if request.method == "GET":
lista = Usuarios.objects.filter(name=recurso)
salida += logueo(request)
if not lista:
return NotFound(request,recurso)
for i in lista:
salida += "<br>Name: " + i.name + "<br>Birthday: " + i.birthday
if request.method == "PUT":
print request.body
if request.user.is_authenticated():
nuevo = Usuarios(name = recurso, birthday = request.body)
nuevo.save()
salida += "Creado el recurso, pruebe en /usuarios/" + recurso + "o /anotated/" + recurso
else:
salida = logueo(request)
return HttpResponse(salida)
def valores(request,recurso):
salida = " "
if request.method == "GET":
lista = Usuarios.objects.filter(name=recurso)
salida += logueo(request)
if not lista:
return NotFound(request,recurso)
for i in lista:
salida += "<br>Name: " + i.name + "<br>Birthday: " + i.birthday
if request.method == "PUT":
print request.body
if request.user.is_authenticated():
nuevo = Usuarios(name = recurso, birthday = request.body)
nuevo.save()
salida += "Creado el recurso, pruebe en /usuarios/" + recurso
else:
salida = logueo(request)
return HttpResponse(salida)
def register_view(self):
""" handle user register """
# User registration is performed through the form "RegistrationForm"
form = RegistrationForm(request.form)
# when the response is received and validated the form
if request.method == 'POST' and form.validate():
user = Usuarios()
form.populate_obj(user)
user.save()
login.login_user(user)
return redirect(url_for('.index'))
link = '<p>Si ya tiene una cuenta de usuario <a href="' + url_for('.login_view') + '">Pulse aquí para iniciar sesión.</a></p>'
self._template_args['form'] = form
self._template_args['legend'] = "Nuevo usuario"
self._template_args['link'] = link
return super(MyAdminIndexView, self).index()
def examenes_view(nombre=None, asignatura=None, usuario=None, export=None):
"""
the list of exams is shown for both the export menu and the menu to perform exams
"""
exams = Examenes.public()
if request.method == 'POST':
# the corrected exam is displayed
if nombre:
asig = Asignaturas.objects(asignatura=asignatura).first()
user = Usuarios.objects(usuario=usuario).first()
exam = Examenes.public(asignatura=asig.get_id(), nombre=nombre, usuario=user).first()
i = 1
respuestas = []
for pregunta in exam.preguntas:
pre = "pregunta" + str(i)
if pregunta.tipo == 0:
respuestas.append(request.form[pre].strip())
pregunta.respuesta = request.form[pre].strip()
if pregunta.tipo == 1 or pregunta.tipo == 2:
if request.form.get(pre) <> None:
respuestas.append(request.form.get(pre))
pregunta.respuesta = request.form.get(pre)
i = i + 1
return render_template('exams/exam.html', exam=exam, respuestas=respuestas)
# if we pass to the function an exam name, displays the full exam
if nombre:
asig = Asignaturas.objects(asignatura=asignatura).first()
user = Usuarios.objects(usuario=usuario).first()
exam = Examenes.public(asignatura=asig.get_id(), nombre=nombre, usuario=user).first()
return render_template('exams/exam.html', exam=exam)
# the complete list of exams are shown
else:
return render_template('exams/public_exam.html', exams=exams, export=export)
def post(self):
self.response.headers.add_header('Access-Control-Allow-Origin', '*')
self.response.headers['Content-Type'] = 'application/json'
c = ModelClass()
try:
myEmail = self.request.get('email')
myPasswd = self.request.get('password')
myNuevoUsuario = Usuarios(email=myEmail, password=myPasswd)
myUsuarioKey = myNuevoUsuario.put()
c.message = "inserted"
c.key = myUsuarioKey.urlsafe()
except:
c.message = "Exception ..."
json_string = json.dumps(c, default=ObjectClass)
self.response.write(json_string)
def newUser():
if request.method == "POST":
if "DNI" in session and "Tipo" in session:
if session["Tipo"] == 'Administrador':
pword = request.form['Password']
result = hashlib.md5(bytes(pword, encoding='utf-8'))
newuser = Usuarios(DNI=request.form['Usuario'],
Clave=result.hexdigest(),
Tipo=request.form['Tipo'])
basedatos.session.add(newuser)
basedatos.session.commit()
return redirect(url_for('index'))
return render_template("newUser.html")
def register_view(self):
""" handle user register """
# User registration is performed through the form "RegistrationForm"
form = RegistrationForm(request.form)
# when the response is received and validated the form
if request.method == 'POST' and form.validate():
user = Usuarios()
form.populate_obj(user)
user.save()
login.login_user(user)
return redirect(url_for('.index'))
link = '<p>Si ya tiene una cuenta de usuario <a href="' + url_for(
'.login_view'
) + '">Pulse aquí para iniciar sesión.</a></p>'
self._template_args['form'] = form
self._template_args['legend'] = "Nuevo usuario"
self._template_args['link'] = link
return super(MyAdminIndexView, self).index()
def signUp(username, password):
salt = helper.saltGenerator(60)
hash_value = hashing.hash_value(password, salt)
usuario = Usuarios.query.filter_by(nombre=username).first()
if (usuario):
return False
usuario = Usuarios(nombre=username, contrasena=hash_value, salt=salt)
db.session.add(usuario)
try:
db.session.commit()
except exc.SQLAlchemyError:
return False
return True
def get(self):
self.response.headers.add_header('Access-Control-Allow-Origin', '*')
self.response.headers['Content-Type'] = 'application/json'
c = ModelClass()
try:
userkey = self.request.get('key')
id_userkey = ndb.Key(urlsafe=userkey)
myUser = Usuarios.query(Usuarios.key == id_userkey).get()
c.key = userkey
if myUser is not None:
c.email = myUser.email
c.passwd = myUser.password
else:
c.message = "error: not found"
except:
c.message = "Exception ..."
json_string = json.dumps(c, default=ObjectClass)
self.response.write(json_string)
def get(self):
self.response.headers.add_header('Access-Control-Allow-Origin', '*')
self.response.headers['Content-Type'] = 'application/json'
id_empresa = self.request.get('empresa')
objemp = Empresa.query(Empresa.codigo_empresa == id_empresa).get()
myUsers = Usuarios.query()
myList = []
for i in myUsers:
myObj = DemoClass()
myObj.nombre = i.nombre
myObj.email = i.email
myObj.edad = i.edad
myObj.talla = i.talla
myObj.urlImage = i.urlImage
myList.append(myObj)
json_string = json.dumps(myList, default=MyClass)
self.response.write(json_string)
def empresa_add(cls, request):
try:
token = jwt.decode(request.token, 'secret') #CHECA EL TOKEN
user = Usuarios.get_by_id(
token['user_id']) #obtiene el usuario models.py
myempresa = Empresa()
if myempresa.empresa_m(request) == 0:
codigo = 1
else:
codigo = -3
#la funcion josue_m puede actualizar e insertar
#depende de la ENTRADA de este endpoint method
message = CodeMessage(code=codigo, message='Succesfully added')
#else:
# message = CodeMessage(code=-4, message='Succesfully added')
except jwt.DecodeError:
message = CodeMessage(code=-2, message='Invalid token')
except jwt.ExpiredSignatureError:
message = CodeMessage(code=-1, message='Token expired')
return message
def cuenta_view():
"""
Function to display the form that allows to query and modify the user profile
"""
form = ProfileForm(request.form)
user = Usuarios.objects(id=login.current_user.get_id()).first()
if request.method == 'POST':
user.usuario = form.usuario.data
user.nombre = form.nombre.data
user.apellidos = form.apellidos.data
user.password = form.password.data
user.email = form.email.data
save = False
if form.validate():
save = True
user.save(clean=False)
return render_template("user/profile.html", user=user, form=form, save=save)
return render_template('user/profile.html', user=user, form=form)
def tweet_add(cls, request):
try:
token = jwt.decode(request.token, 'secret') #CHECA EL TOKEN
user = Usuarios.get_by_id(
token['user_id']
) #obtiene el usuario para poder acceder a los metodos declarados en models.py en la seccion de
mytweet = Tweet()
if mytweet.tweet_m(
request, user.empresa_key
) == 0: #llama a la funcion declarada en models.py en la seccion de USUARIOS
codigo = 1
else:
codigo = -3
#la funcion josue_m puede actualizar e insertar
#depende de la ENTRADA de este endpoint method
message = CodeMessage(code=codigo, message='Tweet added')
except jwt.DecodeError:
message = CodeMessage(code=-2, message='Invalid token')
except jwt.ExpiredSignatureError:
message = CodeMessage(code=-1, message='Token expired')
return message
def factura_list(cls, request):
try:
token = jwt.decode(request.tokenint, 'secret') #CHECA EL TOKEN
user = Usuarios.get_by_id(
token['user_id']) #obtiene usuario dado el token
lista = [] #crea lista para guardar contenido de la BD
lstMessage = FacturaList(code=1) #CREA el mensaje de salida
lstBd = Factura.query().fetch() #obtiene de la base de datos
for i in lstBd: #recorre la base de datos
#inserta a la lista creada con los elementos que se necesiten de la base de datos
#i.empresa_key.urlsafe() obtiene el entityKey
lista.append(
FacturaUpdate(
token='',
entityKey=i.entityKey,
#empresa_key=i.empresa_key.urlsafe(),
tipoDePersona=i.tipoDePersona,
nombre=i.nombre,
idTicket=i.idTicket,
rfc=i.rfc,
pais=i.pais,
estado=i.estado,
municipio=i.municipio,
colonia=i.colonia,
cp=i.cp,
calle=i.calle,
numExt=i.numExt,
numInt=i.numInt,
email=i.email,
numFolio=i.numFolio,
fecha=i.fecha))
lstMessage.data = lista #ASIGNA a la salida la lista
message = lstMessage
except jwt.DecodeError:
message = FacturaList(code=-1, data=[])
except jwt.ExpiredSignatureError:
message = FacturaList(code=-2, data=[])
return message
def get(self):
self.response.headers.add_header('Access-Control-Allow-Origin', '*')
self.response.headers['Content-Type'] = 'application/json'
myList = []
try:
lstUsers = Usuarios.query().fetch()
for i in lstUsers:
c = ModelClass()
c.id = i.key.urlsafe()
c.email = i.email
c.passwd = i.password
myList.append(c)
except:
c = ModelClass()
c.message = "Exception ..."
myList.append(c)
json_string = json.dumps(myList, default=ObjectClass)
self.response.write(json_string)
def validate_usuario(self, field):
""" Function to validate the user """
if Usuarios.objects(usuario=self.usuario.data):
raise validators.ValidationError('El nombre de usuario ya existe en el sistema.')
def get_user(self):
return Usuarios.objects(usuario=self.usuario.data).first()
