def test_get(self):
""" The GET on `/user` should return an user """
UserRepository.create(first_name='John', last_name='Doe', age=25)
response = self.client.get('/application/user/Doe/John')
self.assertEqual(response.status_code, 200)
response_json = json.loads(response.data.decode('utf-8'))
self.assertEqual(response_json, {'user': {'age': 25, 'first_name': 'John', 'last_name': 'Doe'}})
def test_get(self):
UserRepository.create(id='curso-departamento-pessoal---presencial-manha__534240')
response = self.client.get('/application/event/curso-departamento-pessoal---presencial-manha__534240')
self.assertEqual(response.status_code, 200)
response_json = json.loads(response.data.decode('utf-8'))
self.assertEqual(
response_json,
{'event': {'id': 'curso-departamento-pessoal---presencial-manha__534240'}}
)
def test_get(self):
""" The GET on `/user` should return an user """
UserRepository.create(first_name="John", last_name="Doe", age=25)
response = self.client.get("/application/user/Doe/John")
self.assertEqual(response.status_code, 200)
response_json = json.loads(response.data.decode("utf-8"))
self.assertEqual(
response_json,
{"user": {"age": 25, "first_name": "John", "last_name": "Doe"}},
)
def test_create(self, mock_decorator):
""" The POST on `/user` should create an user """
UserRepository.create(first_name='John', last_name='Doe', age=25)
response = self.client.post(
'/api/users/Doe/John',
content_type='application/json',
headers={'Authorization': 'Bearer token'},
data=json.dumps({
'age': 30
})
)
self.assertEqual(response.status_code, 400)
def test_update(self):
""" The PUT on `/user` should update an user's age """
UserRepository.create(first_name='John', last_name='Doe', age=25)
response = self.client.put(
'/application/user/Doe/John',
content_type='application/json',
data=json.dumps({
'age': 30
})
)
self.assertEqual(response.status_code, 200)
response_json = json.loads(response.data.decode('utf-8'))
self.assertEqual(response_json, {'user': {'age': 30, 'first_name': 'John', 'last_name': 'Doe'}})
user = UserRepository.get(first_name='John', last_name='Doe')
self.assertEqual(user.age, 30)
def test_update(self):
""" The PUT on `/user` should update an user's info"""
user = UserRepository.create(first_name="John", last_name="Doe")
response = self.client.put(
"/application/user/{}".format(user.id),
content_type="application/json",
data=json.dumps(
dict(first_name="John",
last_name="Doe",
emails=["*****@*****.**"],
phone_numbers=["+491424324435"])),
)
self.assertEqual(response.status_code, 200)
response_json = json.loads(response.data.decode("utf-8"))
self.assertEqual(
response_json,
{
"user":
dict(user_id=user.id,
first_name="John",
last_name="Doe",
emails=["*****@*****.**"],
phone_numbers=["+491424324435"])
},
)
user = UserRepository.get(user_id=user.id)
self.assertEqual(user.first_name, "John")
def post(last_name, first_name, emails, phone_numbers):
""" Create an user based on the sent information """
user = UserRepository.create(last_name=last_name,
first_name=first_name,
emails=emails,
phone_numbers=phone_numbers)
return jsonify({"user": user.json})
def create():
""" Create a auth """
body = request.get_json()
auth = AuthRepository.getByUsername(body["username"].lower())
expires = datetime.timedelta(days=1)
if not auth:
pw_hash = generate_password_hash(body["password"], 10)
auth = AuthRepository.create(body["username"].lower(), pw_hash)
user = UserRepository.create(body["username"], None, None)
expires = datetime.timedelta(days=1)
# access_token = create_access_token(identity = { "username": auth.username, "id": auth.id }, expires_delta=expires)
access_token = create_access_token(identity={
"username": auth.username,
"id": auth.id
})
response = jsonify({"success": True, "access_token": access_token})
response.status_code = 200
return response
validatePassword = check_password_hash(auth.password, body["password"])
if not validatePassword:
response = jsonify({
"success": False,
"message": "Invalid username or password"
})
response.status_code = 200
return response
access_token = create_access_token(identity={
"username": auth.username,
"id": auth.id
})
AuthRepository.updateToken(id=auth.id, token=access_token)
response = jsonify({"success": True, "access_token": access_token})
response.status_code = 200
return response
def auth_wrapper(*args, **kwargs):
try:
auth_header = request.headers['Authorization']
token = auth_header.split(' ')[1]
id_info = id_token.verify_oauth2_token(token, requests.Request(),
config.GOOGLE_CLIENT_ID)
oid = id_info["sub"]
picture = id_info["picture"]
name = id_info["name"]
email = id_info["email"]
user = UserRepository.get(oid)
if user:
user = UserRepository.update(oid, email, picture, name)
else:
user = UserRepository.create(oid, email, picture, name)
if 'oid' in kwargs:
if kwargs['oid'] != user.oid:
return render_error(
"You don't have right access to this page", 403)
kwargs.update({'user': user})
return method(*args, **kwargs)
except Exception as exc:
return render_error(str(exc), 401)
def post(email: str, password: str):
if UserRepository.find_by_email(email):
return {"message": "Email already exits"}, 400
else:
user = UserRepository.create(
email=email, password=generate_password_hash(password))
return user.json
def post(last_name, first_name, email, age, gender):
""" Create an user based on the sent information """
user = UserRepository.create(last_name=last_name,
first_name=first_name,
email=email,
age=age,
gender=gender)
return jsonify({"user": user.json})
def post(key, last_name, first_name, age):
print(key, last_name, first_name)
""" Create an user based on the sent information """
user = UserRepository.create(key=key,
last_name=last_name,
first_name=first_name,
age=age)
return jsonify({"user": user.json})
def post(last_name, first_name, age):
""" Create an user based on the sent information """
user = UserRepository.create(
last_name=last_name,
first_name=first_name,
age=age
)
return jsonify({'user': user.json})
def test_update(self):
""" The PUT on `/user` should update an user's age """
UserRepository.create(first_name="John", last_name="Doe", age=25)
response = self.client.put(
"/application/user/Doe/John",
content_type="application/json",
data=json.dumps({"age": 30}),
)
self.assertEqual(response.status_code, 200)
response_json = json.loads(response.data.decode("utf-8"))
self.assertEqual(
response_json,
{"user": {"age": 30, "first_name": "John", "last_name": "Doe"}},
)
user = UserRepository.get(first_name="John", last_name="Doe")
self.assertEqual(user.age, 30)
def post(self):
"""
Sign Up
"""
parser = reqparse.RequestParser()
parser.add_argument("name", type=str, location="form")
parser.add_argument("password", type=str, location="form")
parser.add_argument("nickname", type=str, location="form")
# parser.add_argument('profile', type=werkzeug.datastructures.FileStorage, location='files')
args = parser.parse_args()
name = args["name"]
password = args["password"]
nickname = args["nickname"]
# profile_file = args['profile']
profile = name + ".jpg"
# profile_file.save(profile)
try:
hash = generate_password_hash(password, method="sha256")
user = UserRepository.create(name, hash, nickname, profile)
print("User created", user)
token = jwt.encode(
{
"id":
user["id"],
"username":
user["name"],
"exp":
datetime.datetime.utcnow() +
datetime.timedelta(minutes=30),
},
"SECRET",
)
response = {
"data": {
"user": user,
"csrf_token": token
},
"code": 200,
"messages": [{
"content": "Success",
"type": 4
}],
}
status_code = 200
return response, status_code, {
"Content-Type": "json; charset=utf-8"
}
except Exception as e:
print(e)
response = {
"data": {},
"code": 400,
"messages": [{
"content": "Fail",
"type": 1
}],
}
return response, 400, {"Content-Type": "json; charset=utf-8"}
def post(username, password, name, type):
ensure_user(user_type="admin")
if UserRepository.get(username) is not None:
abort(400, msg="existing user")
user = UserRepository.create(username, password, name, type)
user_json = user.json
del user_json["password"]
return user_json, 200
def post(user_email, user_name, password, is_safe):
""" Create an user based on the sent information """
user = UserRepository.create(
user_name=user_name,
user_email=user_email,
age=age,
is_safe=is_safe
)
return jsonify({'user': user.json})
def post(username, hashed_password):
""" Create an user based on the sent information """
try:
user = UserRepository.create(username=username,
hashed_password=hashed_password)
access_token = create_access_token(identity=username)
return jsonify({"access_token": access_token})
except:
return abort(403, description="Username already exists!")
def post(last_name, first_name, age):
""" Create an user based on the sent information """
existing_user = UserRepository.get(last_name=last_name,
first_name=first_name)
if existing_user:
return bad_request('user already in database')
user = UserRepository.create(last_name=last_name,
first_name=first_name,
age=age)
if user:
return jsonify({'user': user.json})
return bad_request('unable to create user')
def post(self):
"""Create user."""
request_json = request.get_json(silent=True)
username: str = request_json.get('username')
avatar_url: str = request_json.get('avatar_url', '')
password: str = request_json.get('password')
try:
user = UserRepository.create(username, avatar_url, password)
return user, 200
except ResourceExists:
response = {"message": "user already exists."}, 400
except Exception as ex:
response = {"message": str(ex)}, 500
return response
def post(self):
"""
Create user
"""
request_json = request.get_json(silent=True)
username: str = request_json['username']
avatar_url: str = request_json.get('avatar_url', '')
try:
user = UserRepository.create(username, avatar_url)
return user, 200
except Exception as e:
response = jsonify(e.to_dict())
response.status_code = e.status_code
return response
def test_get(self):
""" The GET on `/user` should return an user """
user = UserRepository.create(first_name="John",
last_name="Doe",
emails=["*****@*****.**"],
phone_numbers=["+491424324435"])
response = self.client.get("/application/user/{}".format(user.id))
self.assertEqual(response.status_code, 200)
response_json = json.loads(response.data.decode("utf-8"))
self.assertEqual(
response_json,
{
"user":
dict(user_id=user.id,
first_name="John",
last_name="Doe",
emails=["*****@*****.**"],
phone_numbers=["+491424324435"])
},
)
def post(last_name, first_name, age):
"""
Create an user based on the sent information
---
tags:
- user
parameters:
- name: last_name
in: path
type: string
description: the last name of the user
- name: first_name
in: path
type: string
description: the last name of the user
- name: body
in: body
schema:
type: object
properties:
age:
type: integer
description: The age of the user
responses:
200:
description: The user was successfully created
schema:
example:
user:
last_name: Doe
first_name: John
age: 30
"""
user = UserRepository.create(
last_name=last_name,
first_name=first_name,
age=age
)
return jsonify({'user': user.json})
def post(username, email, password):
user = UserRepository.create(
username=username, email=email, password=password
)
return jsonify({"data": user})
def post(email, password, first_name, last_name):
repository = UserRepository()
token = repository.create(email, password, first_name, last_name)
return jsonify(token=token.decode("utf-8")), 201
def post(self, new_data):
"""Add a new user"""
result, created = UserRepository.create(**new_data)
if not created:
abort(409, message="User already exists.")
return result
def post(username, age):
""" Create an user based on the sent information """
user = UserRepository.create(
username=username, age=age
)
return jsonify({"user": user.json})
def test_get(self):
""" The GET on `/user` should return an pdf file """
UserRepository.create(first_name="John", last_name="Doe", age=25)
response = self.client.get("/application/user/Doe")
self.assertEqual(response.status_code, 200)
