def post(self):
args = get_args()
if not args:
return send_message("Parâmetros inválidos", 422)
user = (Usuario.query.filter(Usuario.alive == False).filter(
Usuario.email == args["email"]).first())
if user:
return self.resurrect(user, args)
else:
try:
user = Usuario(args["nome"], args["email"], args["rfid"],
args["tipo"])
user.add(user)
if args["direito_acesso"]:
try:
for sala in args["direito_acesso"]:
acesso = DireitoAcesso(user.id, sala["id_sala"])
acesso.add(acesso)
except SQLAlchemyError as e:
return rollback(e, db)
query = Usuario.query.get(user.id)
except SQLAlchemyError as e:
return rollback(e, db)
else:
return schema.dump(query).data, 201
def cargaMasivaProfesorJP(datos, idEspecialidad):
semestre = Semestre().getOne()
idSemestre = semestre.id_semestre
name = pathCargaMasivaCursoHorario + datos.filename
data = datos.read()
with open(name, 'wb') as file:
file.write(data)
df = pd.read_excel(name, enconding='latin1')
longitud = len(df)
for i in range(longitud):
codigoCurso = str(df.iat[i, 0])
codigoPucp = str(df.iat[i, 1])
nombreCompleto = str(df.iat[i, 2])
aux = SplitNombres(nombreCompleto)
nombres = aux[0]
apellidoPaterno = aux[1]
apellidoMaterno = aux[2]
email = str(df.iat[i, 3])
objUsuario = Usuario(nombre=nombres,
codigo_pucp=codigoPucp,
email=email,
clave=codigoPucp,
apellido_paterno=apellidoPaterno,
apellido_materno=apellidoMaterno,
flg_admin=0)
idUsuario = Usuario().addOne(objUsuario)
idCurso = Curso().getOneClave(codigoCurso, idSemestre)
tipo = str(df.iat[i, 4])
if tipo == "1":
horarios = str(df.iat[i, 5]).split(',')
for horario in horarios:
horario = horario.replace(' ', '')
print(idCurso, horario, idSemestre)
idHorario = Horario().getOneClave(idCurso, idSemestre, horario)
objUsuaHorario = Permiso_usuario_horario(
id_horario=idHorario,
id_usuario=idUsuario,
id_permiso=1,
id_semestre=idSemestre)
Permiso_usuario_horario().addOne(objUsuaHorario)
else:
horarios = Horario().getAll(idCurso, idSemestre)
for horario in horarios:
idHorario = horario.id_horario
objUsuaHorario = Permiso_usuario_horario(
id_horario=idHorario,
id_usuario=idUsuario,
id_permiso=3,
id_semestre=idSemestre)
Permiso_usuario_horario().addOne(objUsuaHorario)
return {'message': 'leyo bien'}
def obtenerNotasFinales(idActividad, idRubrica):
actividad = Actividad().getOne(idActividad)
tipo = actividad.tipo
rpta = []
if tipo == 'I':
lstIdAlumnos = [
reg.id_alumno
for reg in Alumno_actividad().getAllAlumnos(idActividad)
]
listaAlumnos = Alumno_actividad_calificacion().getAllAlumnos(
idActividad, idRubrica)
for alumno in listaAlumnos:
d = {}
auxAl = Usuario().getOneId(alumno.id_alumno)
d['idAlumno'] = alumno.id_alumno
lstIdAlumnos.remove(alumno.id_alumno)
d['codigoPucp'] = auxAl.codigo_pucp
d['nombreAlumno'] = auxAl.nombre + " " + auxAl.apellido_paterno + " " + auxAl.apellido_materno
if alumno.flg_falta == 1:
d['nota'] = 'F'
else:
d['nota'] = alumno.nota
rpta.append(d)
for idAlumno in lstIdAlumnos:
d = {}
auxAl = Usuario().getOneId(idAlumno)
d['idAlumno'] = idAlumno
d['codigoPucp'] = auxAl.codigo_pucp
d['nombreAlumno'] = auxAl.nombre + " " + auxAl.apellido_paterno + " " + auxAl.apellido_materno
d['nota'] = '--'
rpta.append(d)
else:
listarGrupos = Alumno_actividad().getAllGrupos(idActividad)
for grupo in listarGrupos:
d = {}
auxGrupo = Grupo().getOne(grupo.id_grupo).first()
d['idGrupo'] = auxGrupo.id_grupo
d['nombreGrupo'] = auxGrupo.nombre
print(d)
auxAl = Alumno_actividad().getAlumnoGrupo(auxGrupo.id_grupo,
idActividad).first()
auxAl2 = Alumno_actividad_calificacion().getNotaGrupo(
idActividad, auxAl.id_alumno, idRubrica)
if auxAl2 != None:
d['nota'] = auxAl2.nota
else:
d['nota'] = None
rpta.append(d)
r = {}
r['listaNotas'] = rpta
return r
def responderComentarioAlumno(idActividad, idAlumno, idProfesor, respuesta):
# test if exists
d = ResponseMessage()
try:
reg_resp = Alumno_actividad_calificacion.query.filter(
and_(Alumno_actividad_calificacion.id_alumno == idAlumno,
Alumno_actividad_calificacion.id_actividad ==
idActividad)).first()
if reg_resp is None:
d.opcode = 1
d.errcode = 1
d.message = "Alumno o actividad no válidas"
# elif reg_resp.id_jp != idProfesor:
# d.opcode = 1
# d.errcode = 1
# d.message = "No tiene autoridad para responder el comentario."
else:
reg_resp.comentario_jp = respuesta
db.session.commit()
u = Usuario().getOneId(idAlumno)
act = Actividad().getOne(idActividad)
envioCorreo(
u.email, 'RESPUESTA DE COMENTARIO EN LA ACTIVIDAD {}'.format(
act.nombre), respuesta)
d.message = "Respuesta agregada correctamente"
except Exception as ex:
d.opcode = 1
d.errcode = 2
d.message = str(ex)
#Alumno_actividad_calificacion().updateComentarioJP(idActividad,idAlumno,idProfesor,reg_resp)
return d.jsonify()
def registro_post():
email = request.form.get('email')
nome = request.form.get('nome')
up_uo = request.form.get('up_uo')
senha = request.form.get('senha')
confirmar_senha = request.form.get('confirmar_senha')
privilegio = 'admin'
user = Usuario.query.filter_by(email=email).first(
) # if this returns a user, then the email already exists in database
if user: # if a user is found, we want to redirect back to signup page so user can try again
flash('Já existe esse email cadastrado!')
return redirect(url_for('auth.registro'))
elif senha != confirmar_senha:
flash('Senhas não correspondem!')
return redirect(url_for('auth.registro'))
print(email, senha, nome)
novo_usuario = Usuario(email=email,
nome=nome,
up_uo=up_uo,
privilegio=privilegio,
senha=generate_password_hash(senha,
method='sha256'))
db.session.add(novo_usuario)
db.session.commit()
return redirect(url_for('auth.login'))
def ingresarComentarioAlumno(idActividad, idAlumno, comentario):
# test if exists
d = ResponseMessage()
try:
reg_comment = Alumno_actividad_calificacion.query.filter(
and_(Alumno_actividad_calificacion.id_alumno == idAlumno,
Alumno_actividad_calificacion.id_actividad ==
idActividad)).first()
if reg_comment is None:
d.opcode = 1
d.errcode = 1
d.message = "Alumno o actividad no válidas"
else:
reg_comment.comentario_alumno = comentario
u = Usuario().getOneId(reg_comment.id_calificador)
act = Actividad().getOne(idActividad)
envioCorreo(
u.email, 'COMENTARIO EN LA ACTIVIDAD {} DE {} {}'.format(
act.nombre, u.nombre, u.apellido_paterno), comentario)
db.session.commit()
d.message = "Comentario agregado correctamente"
except Exception as ex:
d.opcode = 1
d.errcode = 2
d.message = str(ex)
#Alumno_actividad_calificacion().updateComentarioAlumno(idActividad,idAlumno,reg_comment)
return d.jsonify()
def index(estado):
if session.get('logged_in'):
usuario = Usuario.obtener(int(session['current_user_id']))
pedidos = usuario.buscar_pedidos(estado)
return render_template('pedidos/index.html', logged_in=session['logged_in'], pedidos = toJSON(pedidos), usuario = usuario.toJSON(), estado=estado)
else:
return redirect(url_for('inicio_page.inicio'), estado=estado)
def api_addNew( self ):
self.setCordsHeaders()
response = { "success": False , "error": "" }
try:
jsonObject = self.getPostDataObject()
email = jsonObject['email']
name = jsonObject['name']
self.context['data'] = jsonObject
if ( email and name ):
newUser = Usuario( email = email, name = name )
newUser.put()
response['success'] = True
self.context['data'] = response
except:
response['success'] = False
response['error'] = sys.exc_info()
self.context['data'] = response
def valida_usuario():
numero_usuario = len(Usuario.query.all())
print(f"Número de Usuários: {numero_usuario}")
if numero_usuario < 1:
usuario = Usuario('admin', 'admin#2021')
db.session.add(usuario)
db.session.commit()
return None
def create():
"""Esta función crea una sesión"""
#Creacion de nuevo objeto usuario sin atributos
usuario = Usuario()
#Extrer datos del formulario y asignarlo a atributos del objeto creado
usuario.correo = request.form['correo']
#Se pone el correo en minúsculas
usuario.correo = usuario.correo.lower()
usuario.password = request.form['password']
#Se verifican las credenciales del usuario
if usuario.inicio_de_sesion_valido():
#Se establece que hay una sesión iniciada
session['logged_in'] = True
#Se busca al usuario actual
current_user = Usuario.obtener(correo="*****@*****.**")
#Se establece que el id del usuario que inició sesión
session['current_user_id'] = current_user.id
flash('Inicio de sesión exitoso.')
#Se redirecciona la página de inicio
return redirect(url_for('inicio_page.inicio'))
#Si las credenciales no coinciden, no se inicia la sesión
else:
session['logged_in'] = False
flash('Correo electrónico o contraseña incorrectos.')
return render_template('login.html')
def signup():
form = CadastroForm()
if form.validate_on_submit():
u = Usuario(nome=form.nome.data, nome_usuario=form.nome_usuario.data)
u.adicionar_senha(form.senha.data)
confirma = Usuario.query.filter_by(
nome_usuario=form.nome_usuario.data).first()
if (confirma == None):
db.session.add(u)
db.session.commit()
flash("Conta Criada")
return redirect(url_for('login'))
else:
flash("Conta existente! Faça login")
return render_template('cadastro.html', form=form)
def cargaMasivaHorarios(datos, idCurso, idEspecialidad):
semestre = Semestre().getOne()
idSemestre = semestre.id_semestre
print("=" * 20)
print(idSemestre)
name = pathCargaMasivaAlumnoHorario + datos.filename
data = datos.read()
with open(name, 'wb') as file:
file.write(data)
doc = codecs.open(name, 'rU', 'latin1')
for i in range(6):
doc.readline()
df = pd.read_csv(doc, sep='\t', encoding='latin1')
#print(df)
df['E-mail'] = df['E-mail'].apply(lambda x: getCorreoPucp(x))
df['nombres'] = df['Nombre'].apply(lambda x: SplitNombres(x)[0])
df['apellido_paterno'] = df['Nombre'].apply(lambda x: SplitNombres(x)[1])
df['apellido_materno'] = df['Nombre'].apply(lambda x: SplitNombres(x)[2])
longitud = len(df)
for i in range(longitud):
idHorario = Horario().addOne(str(df.iat[i, 2]), idCurso, idSemestre)
codigoPucp = str(df.iat[i, 0])
nombre = str(df.iat[i, 5])
email = str(df.iat[i, 4])
apellidoPaterno = str(df.iat[i, 6])
apellidoMaterno = str(df.iat[i, 7])
objUsuario = Usuario(nombre=nombre,
email=email,
apellido_paterno=apellidoPaterno,
apellido_materno=apellidoMaterno,
flg_admin=0,
codigo_pucp=codigoPucp,
clave=codigoPucp)
idUsuario = Usuario().addOne(objUsuario)
objAlumnoHorario = Permiso_usuario_horario(id_horario=idHorario,
id_usuario=idUsuario,
id_permiso=2,
id_semestre=idSemestre)
Permiso_usuario_horario().addOne(objAlumnoHorario)
return {'message': 'leyo bien'}
def show(id_pedido):
#Si el usuario está logeado, se busca el pedido
if session.get('logged_in'):
#Se obtiene el objeto Pedido a partir del id
pedido = Pedido.obtener(id_pedido)
usuario = Usuario.obtener(int(session['current_user_id']))
productos_por_pedido = pedido.buscar_productos_por_pedido()
return render_template('pedidos/show.html', pedido=pedido.toJSON(), productos_por_pedido = toJSON(productos_por_pedido), usuario = usuario.toJSON())
else:
session["logged_in"] = False
session["current_user_id"] = 0
return redirect(url_for('inicio_page.inicio'))
def show(id_categoria):
#Se obtiene el objeto Canasta a partir del id
categoria = Categoria.obtener(id_categoria)
#Se obtienen los productos dentro de esta categoría
productos = Producto.listar_productos_nombre(id_categoria = categoria.id)
if session.get('logged_in') == True:
usuario = Usuario.obtener(session['current_user_id'])
return render_template('productos/index.html', resultados = toJSON(productos), usuario=usuario.toJSON(), categoria = categoria.toJSON())
else:
session["current_user_id"] = 0
session["logged_in"] = False
return render_template('productos/index.html', logged_in = session["logged_in"], current_user_id = session["current_user_id"], resultados = toJSON(productos), categoria = categoria.toJSON())
def listaAlumnos(idActividad):
## ver si es grupal o indiviual
listaAlumnos = Alumno_actividad().getAllAlumnos(idActividad)
alumnos = []
for alumno in listaAlumnos:
d = {}
d['idAlumno'] = alumno.id_alumno
aux = Usuario().getOneId(alumno.id_alumno)
d['codigoPUCP'] = aux.codigo_pucp
d['nombre'] = aux.nombre + " " + aux.apellido_paterno
alumnos.append(d)
return alumnos
"""
def listarIntegrantes(idGrupo):
listaIntegrante = Grupo_alumno_horario().getAll(idGrupo)
rpta = []
for integrante in listaIntegrante:
d = dict()
alumno = Usuario().getOneId(integrante.id_usuario)
d['nombre'] = alumno.nombre
d['codigoPucp'] = alumno.codigo_pucp
d['apellidoPaterno'] = alumno.apellido_paterno
d['apellidoMaterno'] = alumno.apellido_materno
d['idUsuario'] = alumno.id_usuario
rpta.append(d)
return rpta
def listarAlumnosHorario(idHorario):
semestreActivo = Semestre().getOne().id_semestre
listaAlumnosHorario = Permiso_usuario_horario().getAllAlumnos(
idHorario, semestreActivo)
rpta = []
for alumnos in listaAlumnosHorario:
d = dict()
alumno = Usuario().getOneId(alumnos.id_usuario)
d['nombre'] = alumno.nombre
d['codigoPucp'] = alumno.codigo_pucp
d['apellidoPaterno'] = alumno.apellido_paterno
d['apellidoMaterno'] = alumno.apellido_materno
d['idUsuario'] = alumno.id_usuario
rpta.append(d)
return rpta
def inicio():
categorias = Categoria.todas()
session["categorias"] = toJSON(categorias)
if session.get('logged_in') == True:
usuario = Usuario.obtener(session["current_user_id"])
return render_template('welcome/index.html',
logged_in=session["logged_in"],
current_user_id=session["current_user_id"],
usuario=usuario.toJSON())
else:
session["logged_in"] = False
session["current_user_id"] = 0
return render_template('welcome/index.html',
logged_in=session["logged_in"],
current_user_id=session["current_user_id"])
def listarCompanherosCalificar(idActividad, idUsuario):
idGrupo = Alumno_actividad().getIdGrupo(idActividad, idUsuario)
listaIntegrante = Grupo_alumno_horario().getAll(idGrupo)
rpta = []
for integrante in listaIntegrante:
if str(integrante.id_usuario) != str(idUsuario):
d = dict()
alumno = Usuario().getOneId(integrante.id_usuario)
d['nombre'] = alumno.nombre
d['codigoPucp'] = alumno.codigo_pucp
d['apellidoPaterno'] = alumno.apellido_paterno
d['apellidoMaterno'] = alumno.apellido_materno
d['idUsuario'] = alumno.id_usuario
rpta.append(d)
return rpta
def buscar_productos_por_palabra_clave():
"""Este método se encarga de la búsqueda por palabras claves"""
#Texto a buscar extraído del formulario
texto_a_buscar = request.form['texto_a_buscar']
#id_categoria extraido del formulario, debe ser un número
id_categoria = int(request.form['id_categoria'])
#Si la búsqueda sea en blanco y la categoria también, se muestran todos los productos
if (texto_a_buscar == None or texto_a_buscar
== "") and (id_categoria == 0 or id_categoria == None):
lista_productos = Producto.listar_productos_nombre()
#Si la búsqueda es en blanco pero la categoría no, se muestran todos los productos dentro de esta categoría
elif (texto_a_buscar == None or texto_a_buscar == "") and id_categoria > 0:
lista_productos = Producto.listar_productos_nombre(
id_categoria=id_categoria)
#Si la búsqueda no es en blanco y no se seleccione una categoría, se muestran los productos que coinciden con la búsqueda en cualquier categoria.
elif (texto_a_buscar != None
and texto_a_buscar != "") and (id_categoria == None
or id_categoria == 0):
lista_productos = Producto.listar_productos_nombre(
cadena_a_buscar=texto_a_buscar)
#Si la búsqueda no es en blanco y se selecciona una categoría, se muestran los productos que coinciden con la búsqueda en la categoría seleccionada.
elif (texto_a_buscar != None
and texto_a_buscar != "") and id_categoria > 0:
lista_productos = Producto.listar_productos_nombre(
cadena_a_buscar=texto_a_buscar, id_categoria=id_categoria)
#Finalmente, se retornan los resultados de la búsqueday el resultado de la búsqueda en el view index.html
if session.get('logged_in') == True:
usuario = Usuario.obtener(session['current_user_id'])
return render_template('productos/index.html',
logged_in=session["logged_in"],
current_user_id=session["current_user_id"],
resultados=toJSON(lista_productos),
texto_a_buscar=texto_a_buscar,
usuario=usuario.toJSON())
else:
session["current_user_id"] = 0
session["logged_in"] = False
return render_template('productos/index.html',
logged_in=session["logged_in"],
current_user_id=session["current_user_id"],
resultados=toJSON(lista_productos),
texto_a_buscar=texto_a_buscar)
def show():
#Si el usuario está logeado, se busca su canasta
if session.get('logged_in'):
canasta = Canasta.obtener(session['current_user_id'])
usuario = Usuario.obtener(session['current_user_id'])
productos_por_canasta = canasta.buscar_productos_por_canasta()
return render_template(
'show.html',
productos_por_canasta=toJSON(productos_por_canasta),
canasta=canasta.toJSON(),
usuario=usuario.toJSON())
#Si el usuario no está logeado, no se buscará ninguna canasta
else:
session["logged_in"] = False
session["current_user_id"] = 0
return render_template('show.html',
logged_in=session["logged_in"],
current_user_id=session["current_user_id"])
def show(id_producto):
#Se obtiene el objeto Producto a partir del id
producto = Producto.obtener(id_producto)
if session.get('logged_in') == True:
usuario = Usuario.obtener(session["current_user_id"])
#Se pasan los atributos del producto y del usuario como un JSON
return render_template('/productos/show.html',
producto=producto.toJSON(),
logged_in=session["logged_in"],
current_user_id=session["current_user_id"],
usuario=usuario.toJSON())
else:
session["logged_in"] = False
session["current_user_id"] = 0
#Se pasan los atributos del producto como un JSON
return render_template('/productos/show.html',
producto=producto.toJSON(),
logged_in=session["logged_in"],
current_user_id=session["current_user_id"])
def obtenerAlumnosEntregableEntregado(idActividad):
tipoActividad = Actividad().getOne(idActividad).tipo
if tipoActividad == 'I':
listaAlumnos = Alumno_actividad().getAllAlumnos(idActividad)
alumnosEntregableEntregado = []
for alumno in listaAlumnos:
entregable = Entregable().getAll(idActividad, alumno.id_alumno)
d = {}
d['idAlumno'] = alumno.id_alumno
aux = Usuario().getOneId(alumno.id_alumno)
d['codigoPUCP'] = aux.codigo_pucp
d['nombre'] = aux.nombre + " " + aux.apellido_paterno
d['entregables'] = []
if entregable != None:
for e in entregable:
d['entregables'].append(e.json())
alumnosEntregableEntregado.append(d)
rpta = {}
rpta['lista'] = alumnosEntregableEntregado
rpta['cantidad'] = len(alumnosEntregableEntregado)
return rpta
else:
##try:
listarGrupos = Alumno_actividad().getAllGrupos(idActividad)
lstGrupos = []
for grupo in listarGrupos:
idGrupo = grupo.id_grupo
d = dict()
d['idGrupo'] = idGrupo
d['nombreGrupo'] = Grupo().getOne(idGrupo).first().nombre
lstGrupos.append(d)
return lstGrupos
##except:
"""
def Login_Controlador(email, clave):
usuario = Usuario().getOne(email, clave)
semestreActivo = Semestre().getOne()
#print(semestreActivo,usuario.flg_admin)
if usuario is None:
return {'message': 'error datos'}
if semestreActivo == None and str(usuario.flg_admin) == "1":
d = {}
d['idUser'] = usuario.id_usuario
d['codigoPUCP'] = usuario.codigo_pucp
d['nombre'] = usuario.nombre + ' ' + usuario.apellido_paterno
d['superUsuario'] = usuario.flg_admin
d['profesor'] = 0
d['jp'] = 0
d['alumno'] = 0
return d
lista = Permiso_usuario_horario().getHorarioActivo(
semestreActivo.id_semestre, usuario.id_usuario)
contProfesor = 0
contJP = 0
contAlumno = 0
for usuarioHorario in lista:
if usuarioHorario.id_permiso == 1:
contProfesor = 1
elif usuarioHorario.id_permiso == 2:
contAlumno = 1
else:
contJP = 1
d = {}
d['idUser'] = usuario.id_usuario
d['codigoPUCP'] = usuario.codigo_pucp
d['nombre'] = usuario.nombre + ' ' + usuario.apellido_paterno
d['superUsuario'] = usuario.flg_admin
d['profesor'] = contProfesor
d['jp'] = contJP
d['alumno'] = contAlumno
return d
def api_getOne(self, email): self.setCordsHeaders() self.context['data'] = Usuario.find_by_email( email )
def cadastrar_usuario():
if current_user.is_authenticated:
return redirect(url_for('index_user'))
form = RegistrationForm()
current_url = request.url.split(current_port)
current_url = current_url[1]
categorias = Categoria.query.order_by('nome').all()
estados = [
"AC", "AL", "AP", "AM", "BA", "CE", "DF", "ES", "GO", "MA", "MT", "MS",
"MG", "PA", "PB", "PR", "PE", "PI", "RJ", "RN", "RS", "RO", "RR", "SC",
"SP", "SE", "TO"
]
if form.validate_on_submit():
if (form.nome.data == ""):
flash("O campo NOME é obrigatório e não pode estar vazio.")
return redirect(url_for('cadastrar_usuario'))
elif (form.nascimento.data == ""):
flash("O campo NASCIMENTO é obrigatório e não pode estar vazio.")
return redirect(url_for('cadastrar_usuario'))
elif (form.telefone.data == ""):
flash("O campo TELEFONE é obrigatório e não pode estar vazio.")
return redirect(url_for('cadastrar_usuario'))
elif (form.cpf.data == ""):
flash("O campo CPF é obrigatório e não pode estar vazio.")
return redirect(url_for('cadastrar_usuario'))
elif (form.email.data == ""):
flash("O campo EMAIL é obrigatório e não pode estar vazio.")
return redirect(url_for('cadastrar_usuario'))
elif (form.senha.data == ""):
flash("O campo SENHA é obrigatório e não pode estar vazio.")
return redirect(url_for('cadastrar_usuario'))
elif (form.confirmar_senha.data == ""):
flash(
"O campo CONFIRMAR_SENHA é obrigatório e não pode estar vazio."
)
return redirect(url_for('cadastrar_usuario'))
elif (form.senha.data != form.confirmar_senha.data):
flash(
"As SENHAS não correspondem. Verifique-as e tente novamente.")
return redirect(url_for('cadastrar_usuario'))
elif (form.cep.data == ""):
flash("O campo CEP é obrigatório e não pode estar vazio.")
return redirect(url_for('cadastrar_usuario'))
elif (form.numero.data == ""):
flash("O campo NÚMERO é obrigatório e não pode estar vazio.")
return redirect(url_for('cadastrar_usuario'))
usuario = Usuario(nome=form.nome.data,
nascimento=form.nascimento.data,
cpf=form.cpf.data,
email=form.email.data,
tipo=2)
senha_criptografada = generate_password_hash(form.senha.data)
checar_senhas_confirmam = check_password_hash(
senha_criptografada, form.confirmar_senha.data)
if (checar_senhas_confirmam):
usuario.senha = senha_criptografada
else:
flash(
"As SENHAS não correspondem. Verifique-as e tente novamente.")
return redirect(url_for('cadastrar_usuario'))
# FORMATAR TELEFONE
formatar_telefone = form.telefone.data
novo_telefone = formatar_telefone.replace(" ", "").replace(
"-", "").replace("(", "").replace(")", "")
usuario.telefones.append(Telefone(telefone=novo_telefone))
usuario.enderecos.append(
Endereco(cep=form.cep.data,
logradouro=form.logradouro.data + ", Nº: " +
form.numero.data,
complemento=form.complemento.data,
referencia=form.referencia.data,
bairro=form.bairro.data,
cidade=form.cidade.data,
estado=form.estado.data))
db.session.add(usuario)
db.session.commit()
flash('Parabéns, seu cadastro foi concluído com êxito!')
return redirect(url_for('login'))
return render_template('cadastro_usuario.html',
title='Ecommerce - Cadastre-se',
form=form,
url=current_url,
categorias=categorias,
estados=estados)
def api_getAll(self): self.setCordsHeaders() usuarios = Usuario.all() self.context['data'] = usuarios
def api_list(self): self.response.headers['Access-Control-Allow-Origin'] = '*' self.response.headers['Access-Control-Allow-Methods'] = 'POST, GET, PUT, DELETE, OPTIONS' usuarios = Usuario.all() self.context['data'] = usuarios
def create():
#Array de errores
errores = []
#Creación de nuevo objeto
usuario = Usuario()
#Datos introducidos por el usuario
usuario.correo = request.form['correo']
usuario.nombre_de_usuario = request.form['nombre_de_usuario']
usuario.password = request.form['password']
usuario.nombre_completo = request.form['nombre_completo']
usuario.celular = request.form['celular']
usuario.dni = request.form['dni']
dia = int(request.form['fecha_de_nacimiento_dia'])
mes = int(request.form['fecha_de_nacimiento_mes'])
anho = int(request.form['fecha_de_nacimiento_anho'])
usuario.fecha_nacimiento = datetime(anho, mes, dia)
usuario.numero_de_tarjeta = request.form['numero_de_tarjeta']
if usuario.es_mayor_de_edad() and usuario.nombre_completo_es_valido():
if usuario.crear():
#Se logea al usuario automaticamente
session['logged_in'] = True
session['current_user_id'] = usuario.id
#Se crea una nueva canasta si el usuario logra registrarse
canasta = Canasta()
#El usuario de esta canasta será el usuario que se acaba de registrar
canasta.usuario = usuario
#Se crea la canasta
if canasta.crear():
print("Canasta registrada")
return redirect(url_for('inicio_page.inicio'))
else:
errores.append('Hubo un error al crear tu cuenta.')
return render_template('usuarios/registrations/new.html',
errores=errores)
else:
if not usuario.es_mayor_de_edad():
errores.append("Debes ser mayor de edad para registrarte")
if not usuario.nombre_completo_es_valido():
errores.append("Tu nombre no debe contener caracteres especiales.")
return render_template('usuarios/registrations/new.html',
errores=errores)
