def post(self):
atributos = reqparse.RequestParser()
atributos.add_argument('nome',
type=str,
required=True,
help='The field nome must be filled')
atributos.add_argument('usuario',
type=str,
required=True,
help='The field usuario must be filled')
atributos.add_argument('senha',
type=str,
required=True,
help='The field senha must be filled')
atributos.add_argument('email',
type=str,
required=True,
help='The field email must be filled')
dados = atributos.parse_args()
if UsuarioModel.find_by_usuario(dados['usuario']):
return {'Message': 'Usuario already exists'}, 500
usuario = UsuarioModel(**dados)
usuario.save_usuario()
return {'Message': 'Usuario created with success'}, 201
def post(self):
data = self.serializer.parse_args()
nuevoUsuario = UsuarioModel(data['usuario_nombre'])
nuevoUsuario.save()
return {
'success': True,
'content': nuevoUsuario.json(),
'message': 'Usuario creado exitosamente'
}, 201
def post(self):
dados = atributos.parse_args()
if UsuarioModel.encontrar_por_email(dados['email']):
return {
'message':
'O email {} já está sendo utilizado.'.format(dados['email'])
}
usuario = UsuarioModel(**dados)
usuario.salvar_usuario()
return {'message': 'Usuário criado com sucesso.'}, 201
def post(self):
username = request.json.get('username', None)
password = request.json.get('password', None)
user = UsuarioModel.find_by_email(username)
if user and user.confirmado == 1 and safe_str_cmp(
user.password, password):
access_token = create_access_token(identity=user)
UsuarioModel.update_last_login(user.usuario_id)
return {'access_token': access_token}, 200
return {"message": "Usuário ou senha incorretos"}, 401
def post(self):
data = self.serializer.parse_args()
nuevoUsuario = UsuarioModel(
data['usuario_nombre'], data['usuario_apellido'],
data['usuario_correo'], data['usuario_password'],
data['usuario_titulo'], data['usuario_info'], data['usuario_cv'],
data['usuario_superuser'], data['usuario_foto'])
nuevoUsuario.save()
return {
'success': True,
'content': nuevoUsuario.json(),
'message': 'Usuario creado exitosamente'
}, 201
def post(cls):
dados = atributos.parse_args()
usuario = UsuarioModel.encontrar_por_email(dados['email'])
if usuario and safe_str_cmp(usuario.senha, dados['senha']):
token_de_acesso = create_access_token(identity=usuario.usuario_id)
return {'access_token': token_de_acesso}, 200
return {'message': 'O email ou senha estão incorretos.'}, 401
def get(self, user_id):
user = UsuarioModel.find(user_id)
if user:
return user.json(), 200
return {'message': 'User not found.'}, 404
def put(self, squad_id):
parser = reqparse.RequestParser()
parser.add_argument("nome",
type=str
)
parser.add_argument("administrador_id",
type=int
)
data = parser.parse_args()
squad = SquadModel.find_by_id(squad_id)
if squad is None:
return {'message': "Squad Inexistente."}, 400
else:
administrador = UsuarioModel.find_by_id(squad.administrador_id)
if not administrador:
return {'message': "Administrador não encontrado."}, 400
if(not safe_str_cmp(administrador.email, get_jwt_identity()) and get_jwt_claims()["perfil_id"] != 1):
return {'message': "Você não tem permissão para fazer essa ação."}, 403
if(data["nome"]):
squad.nome = data["nome"]
if(data["administrador_id"]):
squad.administrador_id = data["administrador_id"]
squad.data_ultima_atualizacao = datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')
squad.atualizado_por = get_jwt_identity()
squad.save_to_db()
return squad.json()
def delete(self, membros_squad_id):
if (get_jwt_claims()["perfil_id"] != 1
and get_jwt_claims()["perfil_id"] != 2):
return {
'message': "Você não tem permissão para fazer essa ação."
}, 403
membros_squad = MembrosSquadModel.find_by_id(membros_squad_id)
if not membros_squad:
return {"mensagem": "Id de membro do squad inexistente"}, 400
squad = SquadModel.find_by_id(membros_squad.squad_id)
if not squad:
return {"mensagem": "Id de squad inexistente"}, 400
administrador = UsuarioModel.find_by_id(squad.administrador_id)
if not administrador:
return {'message': "Administrador não encontrado."}, 400
if (not safe_str_cmp(administrador.email, get_jwt_identity())
and get_jwt_claims()["perfil_id"] != 1):
return {
'message': "Você não tem permissão para fazer essa ação."
}, 403
membros_squad.ativo = 0
membros_squad.data_ultima_atualizacao = datetime.datetime.utcnow(
).strftime('%Y-%m-%d %H:%M:%S')
membros_squad.atualizado_por = get_jwt_identity()
membros_squad.save_to_db()
return {"mensagem": "Membro do Squad excluído"}
def post(cls):
dados = atributos.parse_args()
usuario = UsuarioModel.find_usuario_by_login(dados['login'])
if usuario and check_password_hash(usuario.senha, dados.senha):
token = create_access_token(identity=usuario.usuario_id)
return {'token': token}, 200
return {'message': 'username or password incorrect'}, 401
def delete(self, usuario_id):
usuario = UsuarioModel.find_usuario(usuario_id)
if usuario:
try:
usuario.delete()
return {'message': 'User {} deleted.'.format(usuario.login)}, 200
except:
return {'message': 'Impossible to delete user {} try again later.'.format(usuario.usuario_id)}, 400
def post(cls):
data = attributes.parse_args()
usuario = UsuarioModel.find_by_login(data['login'])
if usuario and check_password_hash(usuario.senha, data['senha']):
token_de_acesso = create_access_token(identity=usuario.usuario_id)
return {'access_token': token_de_acesso}, 200
return {'message': 'The username or password is incorrect.'}, 401
def delete(self, user_id):
user = UsuarioModel.find(user_id)
if user is None:
return errors._NOT_FOUND, server_code.NOT_FOUND
try:
user.delete()
except:
return errors._DELETE_ERROR, server_code.INTERNAL_SERVER_ERROR
return success._DELETED, server_code.OK
def post(cls):
dados = _ARGUMENTOS.parse_args()
user = UsuarioModel.find_by_login(dados.get('login'))
if user is None or user.senha != dados.get('senha'):
return errors._NOT_FOUND, server_code.NOT_FOUND
if not user.ativado:
return {'message': "user has not been activated"}, 400
token_access = create_access_token(identity=user.user_id)
return {"access_token": token_access}, 200
def put(self, usuario_id):
data = attributes.parse_args()
data['senha'] = generate_password_hash(data['senha'])
usuario_encontrado = UsuarioModel.find_usuario(usuario_id)
if usuario_encontrado:
usuario_encontrado.update_usuario(**data)
usuario_encontrado.save_usuario()
return usuario_encontrado.json(), 200
return {'message': 'Usuario not found.'}, 404
def delete(self, id):
usuario = UsuarioModel.find_by_id(id)
if usuario:
try:
usuario.save_hotel()
return {
'hoteis': [
hotel.convertToDictionary()
for hotel in UsuarioModel.findAll_hotel()
]
}
except:
return {
'Message':
'An internal error ocurred while attempting to save the data'
}, 500
return {'Message': 'Hotel not found'}, 404
def delete(self, id: int):
usuario = UsuarioModel.find_by_id(id)
if usuario:
try:
usuario.delete()
return 200
except:
return {'message', 'An internal error'}, 500
return {'message': 'Nenhum usuário foi encontrado'}, 404
def delete(self, user_id):
user = UsuarioModel.find(user_id)
if user:
try:
user.delete()
return {'message': 'User deleted.'}, 200
except:
return {"message":"An internal error ocurred trying to delete 'User'."}, 500
return {'message': 'User not found.'}, 404
def get(cls, user_id):
user = UsuarioModel.find(user_id)
if user is None:
return errors._NOT_FOUND, server_code.NOT_FOUND
user.ativado = True
try:
user.save()
headers = {"Content-Type":"text/html"}
return make_response(render_template('confirm.html', email=user.email, login=user.login), 200, headers)
except:
return errors._SAVE_ERROR, server_code.INTERNAL_SERVER_ERROR
def put(self, usuario_id):
usuario = UsuarioModel.find_by_id(usuario_id)
if usuario is None:
return {'message': "Usuário Inexistente."}, 400
else:
usuario.ativo = 1
usuario.data_ultima_atualizacao = datetime.datetime.utcnow(
).strftime('%Y-%m-%d %H:%M:%S')
usuario.save_to_db()
return {"message", "Usuário ativo"}
def get(cls, user_id):
user = UsuarioModel.find(user_id)
if user:
try:
user.ativado = True
user.save()
return {'message': 'User cofirmed!'}, 200
except:
return {"message":"An internal error ocurred trying to confirme email from 'User'."}, 500
return {'message': 'User not found.'}, 404
def delete(self, cpf):
usuario = UsuarioModel.find_usuario(cpf)
if usuario:
try:
usuario.delete_usuario()
except:
return {
'message': 'Ocorreu um erro ao tentar deletar o usuario'
}
return {'message': 'Usuario deletado'}
return {'message': 'Usuario não encontrado'}, 404
def post(cls):
dados = arg.parse_args()
user = UsuarioModel.find_by_login(dados['login'])
if user and safe_str_cmp(user.senha, dados['senha']):
if not user.ativado:
return {'message', 'Usuário não ativado'}, 401
token = create_access_token(identity=user.user_id)
return {'token': token}, 200
return {'message', 'Usuário ou senha incorreto'}, 401
def verificar_senha(login_or_token, senha):
current_app.logger.info("Auth - Login ou Token: %s" % (login_or_token))
# Verificar token para usuários já autenticados.
usuario = UsuarioModel.verify_auth_token(login_or_token)
if not usuario:
# Autenticar com login/senha
usuario = UsuarioModel.query.filter_by(login=login_or_token).first()
if not usuario or not usuario.verificar_senha(senha):
return False
# Usuário autenticado
g.user = usuario
return True
def post(cls):
dados = atributos.parse_args()
user = UsuarioModel.find_by_login(dados['login'])
if user and safe_str_cmp(user.senha, dados['senha']):
if user.ativado:
token_acesso = create_access_token(identity=user.user_id)
return {'access_token': token_acesso}, 200
else:
return {'message': 'User not confirmed.'}, 400
return {'message': 'User not find.'}, 404
def post(self):
dados = atributos.parse_args()
if not dados['email'] or dados['email'] is None:
return {"message": "The field 'email' cannot be left blank."}, 422
if UsuarioModel.find_by_email(dados['email']):
return {'message': 'The email "{}" already exists.'.format(dados['email'])}, 422
if UsuarioModel.find_by_login(dados['login']):
return {'message': 'The login "{}" already exists.'.format(dados['login'])}, 422
user = UsuarioModel(**dados)
try:
user.save()
user.send_confirmacao_email()
except:
user.delete()
traceback.print_exc()
return {"message":"An internal error ocurred trying registry 'User'."}, 500
return {'message':'User created!'}, 201
def get(csl, id):
usuario = UsuarioModel.find_by_id(id)
if not usuario:
return {'message', 'user not found'}, 404
usuario.ativado = True
try:
usuario.save()
except:
return {'message': 'An server error'}, 500
return {'message', 'Usuário ativado com sucesso'}, 200
def post(self, acao_id):
if CarteiraModel.find_acao(acao_id):
return {'message': f"Stock id '{acao_id}' already exists."}, 400
dados = Acao.args.parse_args()
acao = CarteiraModel(acao_id, **dados)
if not UsuarioModel.find_usuario(dados['usuario']):
return {'message': 'Stock not associated'}, 400
try:
acao.save_acao()
except:
return {
'message': 'An internal error ocurred trying to save stock.'
}, 500
return acao.json(), 200
def post(self):
dados = arg.parse_args()
if UsuarioModel.find_by_login(dados['login']):
return {'message': 'Usuário já cadastrado'}, 400
novo_usuario = UsuarioModel(**dados)
novo_usuario.ativado = False
try:
novo_usuario.save()
except:
return {'message': 'An server error'}, 500
return novo_usuario.json(), 201
def post(self):
parser = reqparse.RequestParser()
parser.add_argument("nombre",
type=str,
required=True,
help="Se requiere el nombre")
parser.add_argument("apellido",
type=str,
required=True,
help="Se requiere el apellido")
parser.add_argument("tipo",
type=int,
required=True,
help="Se requiere el tipo")
parser.add_argument("password", type=str, required=False)
parser.add_argument("direccion",
type=str,
required=True,
help="Se requiere una direccion")
parser.add_argument("correo",
type=str,
required=True,
help="Se requiere el correo")
parser.add_argument("telefono",
type=str,
required=True,
help="Se requiere el telefono")
data = parser.parse_args()
# cuando queremos filtrar, tenemos que comprar basandonos en el campo del modelo, no del nombre del atributo de la tabla
consultar_usuario = UsuarioModel.query.filter_by(
correo=data['correo']).first()
# first => devuelve un objeto
# all => devuelve una lista de objetos
if not consultar_usuario:
try:
UsuarioModel(data['nombre'], data['apellido'], data['tipo'],
data['direccion'], data['correo'],
data['telefono'], data['password']).guardar_bd()
except:
return {
'message':
'Hubo un error al guardar el usuario, compruebe los campos'
}, 500 # INTERNAL SERVER ERRROR
return {'message': 'Usuario Creado exitosamente'}, 201 # CREATED
return {
'message': 'Ya hay un usuario con ese correo, no se pudo agregar'
}, 400 # BAD REQUEST