def run_usuario_registrar(request):
if request.method == 'POST':
email = request.POST['email']
#verifica se o email ja esta cadastrado
try:
usuario = Usuario.objects.get(email=email)
except:
#se nao esta, cadastra o novo usuario
nome = request.POST['nome']
senha = request.POST['senha']
hash_senha = hashlib.sha224(senha.encode('utf8'))
senha = hash_senha.hexdigest()
usuario = Usuario(nome=nome, email=email, senha=senha)
try:
usuario.save()
resultado = True
except:
resultado = False
return {'resultado': resultado}
else:
return {'resultado': False}
def new_user():
data = request.get_json()
if 'nome' not in data or 'email' not in data or 'senha' not in data or 'tag_id' not in data:
return bad_request(403, 'Precisa passar nome, email,senha e tag')
if Usuario.query.filter_by(nome=data['nome']).first():
return bad_request(403, 'Use um outro nome')
if Usuario.query.filter_by(email=data['email']).first():
return bad_request(403, 'Use um outro email')
data['ativo'] = 'S'
usuario = Usuario()
usuario.from_dict(data)
cadastro = Cadastro()
cadastro.passwd(data['senha'])
usuario.cadastro_usuario = [cadastro]
db.session.add(usuario)
db.session.add(cadastro)
db.session.commit()
message = {'message': 'usuario criado'}
return jsonify(message), 200
def registro():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = RegistrationForm()
if form.validate_on_submit():
user = Usuario(username=form.username.data, email=form.email.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
flash('Congratulations, you are now a registered user!')
return redirect(url_for('login'))
return render_template('register.html', title='Registre-se', form=form)
def deploy():
from flask_migrate import upgrade
from app.models import Cargo, Usuario
# Migrar banco de dados para última versão
# A pasta "migrations" precisa existir e deve ter pelo menos uma
# versão de migração de banco de dados
upgrade()
# Cria os cargos dos usuários, se ainda não foram criados
Cargo.criar_cargos()
# Criar administrador padrão, caso ainda não haja um
Usuario.criar_administrador()
def create_user():
json = request.get_json()
try:
usuario = Usuario(nome=json.get('nome', None),
email=json.get('email', None),
senha=json.get('senha', None))
db.session.add(usuario)
db.session.commit()
except AssertionError as err:
return jsonify({'status': str(err)}), 403
return jsonify(usuario.to_json()), 201
def register():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = RegistrationForm()
if form.validate_on_submit():
username = unidecode.unidecode(form.username.data)
if username.isalpha():
user = Usuario(nome=username, email=form.email.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
flash('Parabéns, você foi registrado com suceso!')
return redirect(url_for('login'))
flash('Por favor, não utilize caractéres especiais como "/ $ #" ' +
'ou palavras acentuádas.')
return render_template('register.html', title='Registro', form=form)
def cadastrar():
form = UsuarioCadastrarForm()
if form.is_submitted():
if form.validate():
is_primeiro_usuario = Usuario.query.count() == 0
# O primeiro usuário cadastrado será um administrador
if is_primeiro_usuario:
tipo_desc = 'Administrador'
# Os outros são funcionários, por padrão
else:
tipo_desc = 'Funcionário'
tipo = TipoUsuario.query.filter_by(descricao=tipo_desc).first()
existente_email = Usuario.query.filter_by(
email=form.email.data).first()
existente_cpf = Usuario.query.filter_by(cpf=form.cpf.data).first()
if existente_email is not None:
form.email.errors.append("Email já cadastrado!")
elif existente_cpf is not None:
form.cpf.errors.append("CPF já cadastrado!")
else:
usuario = Usuario(
nome=form.nome.data,
email=form.email.data,
cpf=form.cpf.data,
hash_senha=bcrypt.generate_password_hash(form.senha.data),
tipo=tipo,
)
db.session.add(usuario)
db.session.commit()
flash('Usuário criado com sucesso.', 'success')
return redirect(url_for('usuario.listar_usuarios'))
return render_template('usuarios/cadastrar.html', form=form)
def entrar():
form=formLogin()
if request.method == 'POST':
if form.validate:
busca={'email':request.form['email'],'senha':hashlib.sha256(request.form['senha'])}
usuario = Usuario.buscaGenerica(busca)
medico = Medico.buscaGenerica(busca)
adm = Adm.buscaGenerica(busca)
if usuario != None:
user = usuario
tipo = 'paciente'
elif medico != None:
user = medico
tipo = 'profissional'
elif adm != None:
user = adm
tipo = 'adm'
else:
redirect('/entrar')
session['user'] = user.toJson()
session['tipo'] = tipo
session['logado'] = True
redirect('/inicio')
return render_template('entrar.html',form=form)
def crear2(request):
creado=""
crear='crear.html'
if request.method == "POST":
nombre=request.POST['nombre']
#me retorna un objeto
contra=request.POST['contra']
email=request.POST['email']
p1=Usuario(nombre=nombre,correo=email,clave=contra,)
p1.save()
creado="registro exitoso"
else:
creado=""
return render(request,crear ,{'error':creado})
def register():
"""
Agrega el usuario a la base de datos
-- Actualmente todas las funciones están hechas para administradores
-- y solo se puede poner la marca de admin por base de datos
-- está creado en el modelo el flag de editor para dar permiso a
-- todo excepto a datos de seguimiento de gente por privacidad
"""
form = RegistrationForm()
if form.validate_on_submit():
usuario = Usuario(email=form.email.data,
username=form.username.data,
first_name=form.first_name.data,
last_name=form.last_name.data,
password=form.password.data)
try:
# agregar usuario a la BD
db.session.add(usuario)
db.session.commit()
flash(u'Se ha creado correctamente el usuario.', 'success')
except Exception as e:
# error
flash('Error:', e, 'danger')
# redirect to the login page
return redirect(url_for('auth.login'))
# load registration template
return render_template('auth/register.html', form=form)
def create_user():
data = request.get_json() or {}
if 'login' not in data or 'email' not in data or 'senha' not in data:
return bad_request('deve incluir login, email e senha!')
if Usuario.query.filter_by(login=data['login']).first():
return bad_request('Por favor use outro login')
if Usuario.query.filter_by(email=data['email']).first():
return bad_request('Por favor use outro endereço de email')
user = Usuario()
user.from_dict(data, new_user=True)
db.session.add(user)
db.session.commit()
response = jsonify(user.to_dict())
response.status_code = 201
response.headers['Location'] = url_for('api.get_user', id=user.id)
return response
def registrar():
if current_user.is_authenticated:
return redirect(url_for('main.index'))
form = RegisterForm()
if form.validate_on_submit():
usuario = Usuario(nickname=form.username.data,
senha=form.password.data)
usuario.set_password()
db.session.add(usuario)
db.session.commit()
usuario = Usuario.query.filter_by(nickname=form.username.data).first()
login_user(usuario)
return redirect(url_for('main.index'))
return render_template('usuario/registrar.html',
title="Registrar",
form=form)
def login(request):
if request.method=='POST':
password=request.POST.get('id_password')
email=request.POST.get('id_email')
usuario=Usuario.objects(email=email)[0]
print "ususario ", usuario.username
#obtener hash la contraseña y compararla, si coinciden
m = hashlib.md5()
m.update(password)
hashPass=m.hexdigest()
#print user._query
#print user.explain()
if hashPass==usuario.password:
#print hashPass
#print usuario.password
login=True
request.session['email']=usuario.email
request.session['username']=usuario.username
request.session['authenticated']=True
return render(request,'index.html',{'login':login,'user':usuario,})
else:
return render(request,'login.html')
else:
return render(request,'login.html')
def verificar_token(token):
g.usuario_actual = Usuario.verificar_token(token) if token else None
if g.usuario_actual is None:
idUsuario = Firebase.firebase_verificar_token(token) if token else None
g.usuario_actual = Usuario.query.filter_by(idUsuario=idUsuario).first()
print('idUsuario: {}'.format(g.usuario_actual.idUsuario))
return g.usuario_actual is not None
def seed_data():
# tb_tipo_usuario = sa.sql.table('tipo_usuario', sa.sql.column('descricao', sa.String))
# op.bulk_insert(
# tb_tipo_usuario,
# [
# {'id': 1, 'descricao': 'Administrador'},
# {'id': 2, 'descricao': 'Cliente'},
# {'id': 3, 'descricao': 'Funcionário'},
# {'id': 4, 'descricao': 'Convidado'},
# ]
# )
Tipo_Usuario.inserir_tipos_usuarios()
user = Usuario(login='******', email='*****@*****.**', senha='admin')
user2 = Usuario(login='******', email='*****@*****.**', senha='user')
db.session.add_all([user, user2])
db.session.commit()
def crear_usuario():
datos = request.get_json() or {}
if 'correo' not in datos or 'alias' not in datos or 'contrasena' not in datos:
return peticion_erronea(
'Debe incluir los campos correo electrónico, contraseña y alias.')
if Usuario.query.filter_by(correo=datos['correo']).first():
return peticion_erronea(
'Ya hay un usuario con esa dirección correo de correo electrónico, por favor utilice una dirección de correo electrónico diferente.'
)
datos['idUsuario'] = Firebase.firebase_crear_usuario(datos)
usuario = Usuario()
usuario.from_dict(datos, nuevo_usuario=True)
db.session.add(usuario)
db.session.commit()
respuesta = jsonify(usuario.to_dict())
respuesta.status_code = 201
respuesta.headers['Location'] = url_for('api.obtener_usuario',
idUsuario=usuario.idUsuario)
return respuesta
def registro(request):
if request.method=='POST':
username=request.POST.get('id_username')
email=request.POST.get('id_email')
password1=request.POST.get('id_password1')
password2=request.POST.get('id_password2')
print "username="******"email=",email
print "password1=",password1
print "password2=",password2
#user_form=UsuarioForm(data=request.POST)
#if user_form.is_valid():
print "formulario correcto"
#comprobar que las contraseñas coinciden
if password1==password2:
print "contraseñas coinciden"
#comprobar que el email del usuario no existe en la base de datos
userBD=Usuario.objects(email=email)
#print userBD.email
#aplicacion de hash sobre el password
m = hashlib.md5()
m.update(password1)
hashPass=m.hexdigest()
#no existe ese usuario
if userBD.count()==0:
print "user es none"
user=Usuario(username=username,email=email,password=hashPass)
#user.switch_collection('usuarios')
user.save()
res='<div class="alert alert-warning alert-dismissable"><button type="button" class="close" data-dismiss="alert">×</button><strong>Usuario existente!</strong> Ya hay un usuario registrado con este correo .</div>'
return render(request,'index.html',{'registrado':res})
else:
print "existe el ususario en la base de datos",userBD
res='<div class="alert alert-warning alert-dismissable"> <button type="button" class="close" data-dismiss="alert">×</button> <strong>Gracias por registrarse</strong> Acaba usted de registrarse ,puede iniciar sesión.</div>'
return render(request,'registro.html',{'registrado':res})
return render(request,'registro.html')
def registro():
form = RegistroForm()
# if request.method=='GET':
# return render_template("registro.html", form=form)
if request.method != 'GET' and form.validate_on_submit():
usuario = form.usuario.data
senha = form.senha.data
email = form.email.data
existeU = Usuario.query.filter_by(usuario=usuario).first()
existeEmail = Usuario.query.filter_by(email=email).first()
if existeU == None and existeEmail == None:
novoUsuario = Usuario(usuario=usuario, email=email)
novoUsuario.set_senha(senha)
db.session.add(novoUsuario)
db.session.commit()
flash("Usuario registrado com sucesso")
return redirect(url_for('login'))
else:
flash("Nome de usuário ou email já registrado.")
return render_template("registro.html", form=form)
def seed():
usuarios = [
Usuario(nome='Leanne Graham', email='*****@*****.**', senha='Gwenborough'),
Usuario(nome='Ervin Howell', email='*****@*****.**', senha='Wisokyburgh'),
Usuario(nome='Clementine Bauch', email='*****@*****.**', senha='McKenziehaven'),
Usuario(nome='Patricia Lebsack', email='*****@*****.**', senha='South Elvis'),
Usuario(nome='Chelsey Dietrich', email='*****@*****.**', senha='Roscoeview'),
Usuario(nome='Mrs. Dennis Schulist', email='*****@*****.**', senha='South Christy'),
Usuario(nome='Kurtis Weissnat', email='*****@*****.**', senha='Howemouth'),
Usuario(nome='Nicholas Runolfsdottir V', email='*****@*****.**', senha='Aliyaview'),
Usuario(nome='Glenna Reichert', email='*****@*****.**', senha='Bartholomebury'),
Usuario(nome='Clementina DuBuque', email='*****@*****.**', senha='Lebsackbury')
]
for usuario in usuarios:
print('Incluindo usuario {}'.format(usuario.nome))
db.session.add(usuario)
db.session.commit()
print('Seed finnalizado.')
def post():
response = request.get_json()
name = response['name']
age = response['age']
height = response['height']
usuario = Usuario(name, age, height)
q.post(usuario)
return jsonify({name: 'Created'}), 201
def carrega_usuarios(arquivo_csv):
with open(arquivo_csv) as csvfile:
usuarios = csv.reader(csvfile)
for linha in usuarios:
u = Usuario()
u.email = linha[0]
u.nome = unicode(linha[1], "utf-8")
u.tipo = unicode(linha[2], "utf-8")
u.in_coordenador = linha[3]
u.coordenacao_id = linha[4]
u.password = "******"
db.session.add(u)
db.session.commit()
def create_user_record(valid_payload):
try:
pessoa = Pessoa(valid_payload["nome"],
valid_payload["data_nascimento"])
db.session.add(pessoa)
db.session.flush()
usuario = Usuario(valid_payload["email"], pessoa.id)
usuario.fazer_hash_senha(valid_payload["senha"])
db.session.add(usuario)
db.session.commit()
return Response(
json.dumps(valid_payload),
status=201,
mimetype="application/json",
)
except Exception:
return Response(
json.dumps({"errors": "Internal Server Error"}),
status=500,
mimetype="application/json",
)
def cadastrar_usuario():
form = UsuarioForm()
if form.validate_on_submit():
if form.is_admin.data:
usuario = Administrador(form.nome.data, form.email.data, form.senha.data)
else:
usuario = Usuario(form.nome.data, form.email.data, form.senha.data)
db.session.add(usuario)
db.session.commit()
flash('Usuário criado com sucesso')
return redirect('/')
return render_template('usuario/cadastrar.html', title='Sign In', form=form)
def incluirUsuario(request):
objEndereco = Endereco.create(request.POST['CEP'],request.POST['Estado'],request.POST['Cidade'], request.POST['Bairro'],request.POST['Logradouro'],request.POST['Numero'],request.POST['Complemento'] )
objEndereco.save()
objEndereco = p_endereco.recuperaUltimoEndereco()
tipo = request.GET['tipo']
if tipo == 'p':
objPerfil = p_perfil.recuperaPerfil('2') #perfil 2 = Prestador
else:
objPerfil = p_perfil.recuperaPerfil('3') #perfil 3 = Contratante
objUsuario = Usuario.create(objEndereco, objPerfil, request.POST['IndicadorTipoPessoa'],request.POST['CpfCnpj'],request.POST['Nome'],request.POST['Telefone1'],request.POST['Telefone2'],request.POST['Email'],request.POST['Senha'])
objUsuario.save()
return objUsuario.Nome.split(' ')[0]
def put(id):
response = request.get_json()
name = response['name']
age = response['age']
height = response['height']
usuario = Usuario(name, age, height)
user = q.get(id)
if user:
q.put(id, usuario)
return jsonify({user['name']: 'Updated'}), 200
else:
return jsonify({'Error': 'User not found'}), 404
def test_balance_positivo(self):
usuario = Usuario()
data = {
"username": "******",
"first_name": "jose",
"last_name": "perez",
"password": "******",
"email": "*****@*****.**",
"balance": 1000
}
serializer = UserSerializer(usuario, data=data)
self.assertEqual(serializer.is_valid(), True)
def setUp(self):
"""
Será chamado antes de cada teste
"""
db.create_all()
# cria usuario teste
user = Usuario(nome="Pontotel",
password="******",
email='*****@*****.**')
# salva usuário no banco de dados
db.session.add(user)
db.session.commit()
def cadastrar():
if current_user.is_authenticated:
return redirect(url_for('bp_main.main'))
form = CadastroForm()
if form.validate_on_submit():
senha_hash = bcrypt.generate_password_hash(
form.senha.data).decode('utf-8')
novo_usuario = Usuario(nome=form.nome.data,
email=form.email.data,
senha=senha_hash)
db.session.add(novo_usuario)
db.session.commit()
flash(f'Conta criada!', 'success')
return redirect(url_for('bp_usuarios.entrar'))
return render_template('usuarios/cadastro.html', form=form)
def cadastrar():
form = RegistrationForm()
if form.validate_on_submit():
user = Usuario(email=form.email.data,
login=form.user.data,
nome=form.nome.data,
sobrenome=form.sobrenome.data,
password=form.senha.data)
db.session.add(user)
db.session.commit()
flash('Cadastro realizado com sucesso! Faça login abaixo.')
return redirect(url_for('auth.login'))
return render_template('auth/cadastro.html', form=form, title='Cadastrar')
def createdb(passwd):
""" Creates a database with all of the tables defined in
your SQLAlchemy models
"""
db.create_all()
u = Usuario('admin', passwd)
db.session.add(u)
s1 = Status(description='CRIADO')
db.session.add(s1)
s2 = Status(description='MIGRANDO')
db.session.add(s2)
s3 = Status(description='CONCLUIDO')
db.session.add(s3)
s4 = Status(description='ERRO')
db.session.add(s4)
db.session.commit()
def nova_senha(token):
if current_user.is_authenticated:
return redirect(url_for('bp_main.main'))
usuario = Usuario.verify_token(token)
if usuario is None:
flash('Requsição invalida ou expirada', 'warning')
return redirect(url_for('bp_usuarios.get_token'))
form = NovaSenhaForm()
if form.validate_on_submit():
senha_hash = bcrypt.generate_password_hash(
form.senha.data).decode('utf-8')
usuario.senha = senha_hash
db.session.commit()
flash('Senha atualizada!', 'success')
return redirect(url_for('bp_usuarios.login'))
return render_template('usuarios/nova_senha.html', form=form)
def create_user(name, email, password):
"""Create a new persistent user"""
from app.email import send_email
hashed_password = PasswordManager(password).hash()
usuario = Usuario(nombre_usuario=email,
readable_name=name,
hashed_password=hashed_password)
db.session.add(usuario)
db.session.commit()
send_email(email,
'Una cuenta a sido creada para ti',
'email/created_account',
name=name,
username=email,
password=password,
contact_email=os.getenv('ECCEJU_MAIL_SENDER'))
def incluir(request):
objEndereco = Endereco.create(request.POST['CEP'],request.POST['Estado'],request.POST['Cidade'], request.POST['Bairro'],request.POST['Logradouro'],request.POST['Numero'],request.POST['Complemento'] )
objEndereco.save()
objEndereco = p_endereco.recuperaUltimoEndereco()
objPerfil = p_perfil.recuperaPerfil('3')
objUsuario = Usuario.create(objEndereco, objPerfil, request.POST['IndicadorTipoPessoa'],request.POST['CpfCnpj'],request.POST['Nome'],request.POST['Telefone1'],request.POST['Telefone2'],request.POST['Email'],request.POST['Senha'])
objUsuario.save()
form = UsuarioForm()
end = EnderecoForm()
assert isinstance(request, HttpRequest)
return render(
request,
'app/site/indexSite.html',{'form': form, 'endereco': end},
context_instance = RequestContext(request,
{
'title':'Colmeia | Início',
'year':datetime.now().year,
})
)
def registrar_usuario():
form = UserRegisterForm()
if form.validate_on_submit():
nombre = form.nombre.data
email = form.email.data
password = form.password.data
nuevo_usuario = Usuario(nombre=nombre, email=email, password=password)
db.session.add(nuevo_usuario)
db.session.commit()
app.logger.info(f'{datetime.now()}: User {nuevo_usuario} registered')
flash('Estas registrado!', 'success')
return redirect(url_for('home'))
return render_template('registrar.html',
barra_busqueda=True,
titulo='Registrarse',
form=form,
debug=app.config['DEBUG'])
def populate_db():
from faker import Faker
from app.models import Usuario, Viagem
fake = Faker('pt_BR')
for _ in range(100):
user = Usuario(nome=fake.name(),
email=fake.email(),
firebase_id=fake.uuid4())
db.session.add(user)
db.session.commit()
# add rides for the 20 fst users
for user_id in range(1, 21):
ride = Viagem(
usuario_id=user_id,
de=fake.city(),
para=fake.city(),
data=fake.date_time_between(start_date="-20d",
end_date="+20d"),
)
db.session.add(ride)
db.session.commit()
