def test_user_login(self):
user = User(username='******',
email='*****@*****.**',
password='******',
first_name='charlie',
last_name='fei',
role='volunteer',
location='nashville')
schema = UserSchema()
register_response = self.client.post('/users/',
data=schema.dumps(user).data,
content_type='application/json')
registration_data = json.loads(register_response.data.decode())
self.assertTrue(registration_data['status'] == 'success')
self.assertTrue(
registration_data['message'] == 'Successfully registered.')
self.assertTrue(registration_data['auth_token'])
self.assertTrue(register_response.content_type == 'application/json')
self.assertEqual(register_response.status_code, 201)
login_response = self.client.post('/users/login',
data=schema.dumps(user).data,
content_type='application/json')
login_data = json.loads(login_response.data.decode())
self.assertTrue(login_data['status'] == 'success')
self.assertTrue(login_data['message'] == 'Successfully logged in.')
self.assertTrue(login_data['auth_token'])
self.assertTrue(login_response.content_type == 'application/json')
self.assertEqual(login_response.status_code, 200)
def post(self):
"""
Create New User
"""
user_schema = UserSchema()
user_data = request.get_json()
# Validate user data
validated_user_data, errors = user_schema.load(user_data)
if errors:
return dict(status="fail", message=errors), 400
email = validated_user_data.get('email', None)
# Check if user email exists
user_existant = User.query.filter_by(email=email).first()
if user_existant:
return dict(status="fail", message=f"Email {validated_user_data['email']} already in use."), 400
# add validated data to user object
user = User(**validated_user_data)
saved_user = user.save()
if not saved_user:
return dict(status='fail', message=f'Internal Server Error'), 500
# for returning to user
new_user_data, errors = user_schema.dumps(user)
return dict(status='success', data=dict(user=json.loads(new_user_data))), 201
def patch(self, user_id):
"""
"""
try:
user_schema = UserSchema(only=("name", ))
user_data = request.get_json()
validate_user_data, errors = user_schema.load(user_data)
if errors:
return dict(status='fail', message=errors), 400
user = User.get_by_id(user_id)
if not user:
return dict(status='fail',
message=f'User {user_id} not found'), 404
updated = User.update(user, **validate_user_data)
if not updated:
return dict(status='fail',
message='Internal Server Error'), 500
return dict(status='success',
message=f'User {user_id} updated successfully'), 200
except Exception as e:
return dict(status='fail', message=str(e)), 500
def patch(self, user_id):
"""
Update User
"""
user_schema = UserSchema()
update_data = request.get_json()
validated_update_data, errors = user_schema.load(update_data)
if errors:
return dict(status="fail", message=errors), 400
user = User.get_by_id(user_id)
if not user:
return dict(status="fail", message=f"User with id {user_id} not found"), 404
if 'username' in validated_update_data:
user.username = validated_update_data['username']
if 'email' in validated_update_data:
user.email = validated_update_data['email']
if 'password' in validated_update_data:
user.password = validated_update_data['password']
updated_user = user.save()
if not updated_user:
return dict(status='fail', message='Internal Server Error'), 500
return dict(status="success", message=f"User {user.username} updated successfully"), 200
def get(self):
users = User.query.all()
result = []
schema = UserSchema()
for user in users:
result.append(schema.dump(user))
return {"data": result}
def test_fdc_can_be_edited(self):
"""Test API can edit an existing DC. (PUT request)"""
user = User(username='******',
email='*****@*****.**',
password='******',
first_name='charlie',
last_name='fei',
role='fdcAdmin',
location='nashville')
schema = UserSchema()
#Register a new FDC Admin
register_response = self.client.post('/users/',
data=schema.dumps(user).data,
content_type='application/json')
registration_data = json.loads(register_response.data.decode())
self.assertTrue(registration_data['status'] == 'success')
self.assertTrue(
registration_data['message'] == 'Successfully registered.')
self.assertTrue(registration_data['auth_token'])
self.assertTrue(register_response.content_type == 'application/json')
self.assertEqual(register_response.status_code, 201)
#Login as FDC Admin
login_response = self.client.post('/users/login',
data=schema.dumps(user).data,
content_type='application/json')
login_data = json.loads(login_response.data.decode())
self.assertTrue(login_data['status'] == 'success')
self.assertTrue(login_data['message'] == 'Successfully logged in.')
self.assertTrue(login_data['auth_token'])
self.assertTrue(login_response.content_type == 'application/json')
self.assertEqual(login_response.status_code, 200)
fdc_schema = FDCSchema()
creation_response = self.client.post(
'/fdcs/',
data=fdc_schema.dumps(self.fdc).data,
headers=dict(Authorization='Bearer ' + login_data['auth_token']),
content_type='application/json')
creation_data = json.loads(creation_response.data.decode())
self.assertTrue(creation_data['status'] == 'success')
self.assertTrue(
creation_data['message'] == 'Successfully created FDC.')
self.assertTrue(creation_response.content_type == 'application/json')
self.assertEqual(creation_response.status_code, 201)
put_response = self.client.put('/fdcs/1',
headers=dict(Authorization='Bearer ' +
login_data['auth_token']),
data={'name': 'Wendys'},
content_type='application/json')
print(put_response.data)
self.assertEqual(put_response.status_code, 200)
results = self.client().get('/fdcs/1')
self.assertIn('Wendys', str(results.data))
def patch(self, user_id):
"""
Update a single user
"""
# To do check if user is admin
schema = UserSchema(partial=True)
update_data = request.get_json()
validated_update_data, errors = schema.load(update_data)
if errors:
return dict(status="fail", message=errors), 400
user = User.get_by_id(user_id)
if not user:
return dict(status="fail",
message=f"User with id {user_id} not found"), 404
updated_user = User.update(user, **validated_update_data)
if not updated_user:
return dict(status='fail', message='Internal Server Error'), 500
return dict(status="success", message="User updated successfully"), 200
def get_user(id):
if current_user().id != id:
abort(403)
one_user = User.query.get_or_404(id)
user_schema = UserSchema()
output = user_schema.dump(one_user).data
return jsonify({'user' : output})
def test_user_get_info(self):
user = User(username='******',
email='*****@*****.**',
password='******',
first_name='charlie',
last_name='fei',
role='volunteer',
location='nashville')
schema = UserSchema()
register_response = self.client.post('/users/',
data=schema.dumps(user).data,
content_type='application/json')
register_data = json.loads(register_response.data.decode())
get_response = self.client.get(
'/users/' + user.username,
headers=dict(Authorization='Bearer ' +
register_data['auth_token']))
data = json.loads(get_response.data.decode())
self.assertTrue(data['status'] == 'success')
self.assertTrue(data['data'] is not None)
self.assertTrue(data['data']['username'] == 'charlie')
self.assertTrue(data['data']['email'] == '*****@*****.**')
self.assertTrue(data['data']['first_name'] == 'charlie')
self.assertTrue(data['data']['last_name'] == 'fei')
self.assertTrue(data['data']['role'] == 'volunteer')
def get(self, _id: str):
user = UserModel.get_user_by_id(_id)
if user:
user_schema = UserSchema()
result: dict = user_schema.dump(user)
return result, 200
return {"msg": "User Not found"}, 404
def get(self):
schema = UserSchema(many=True)
args = parser.parse_args()
search = args["search"]
data = self.user.search_user(search=search)
return schema.dump(data)
def test_dc_deletion(self):
"""Test API can delete an existing fdc. (DELETE request)."""
user = User(username='******',
email='*****@*****.**',
password='******',
first_name='charlie',
last_name='fei',
role='fdcAdmin',
location='nashville')
schema = UserSchema()
#Register a new FDC Admin
register_response = self.client.post('/users/',
data=schema.dumps(user).data,
content_type='application/json')
registration_data = json.loads(register_response.data.decode())
self.assertTrue(registration_data['status'] == 'success')
self.assertTrue(
registration_data['message'] == 'Successfully registered.')
self.assertTrue(registration_data['auth_token'])
self.assertTrue(register_response.content_type == 'application/json')
self.assertEqual(register_response.status_code, 201)
#Login as FDC Admin
login_response = self.client.post('/users/login',
data=schema.dumps(user).data,
content_type='application/json')
login_data = json.loads(login_response.data.decode())
self.assertTrue(login_data['status'] == 'success')
self.assertTrue(login_data['message'] == 'Successfully logged in.')
self.assertTrue(login_data['auth_token'])
self.assertTrue(login_response.content_type == 'application/json')
self.assertEqual(login_response.status_code, 200)
fdc_schema = FDCSchema()
creation_response = self.client.post(
'/fdcs/',
data=fdc_schema.dumps(self.fdc).data,
headers=dict(Authorization='Bearer ' + login_data['auth_token']),
content_type='application/json')
creation_data = json.loads(creation_response.data.decode())
self.assertTrue(creation_data['status'] == 'success')
self.assertTrue(
creation_data['message'] == 'Successfully created FDC.')
self.assertTrue(creation_response.content_type == 'application/json')
self.assertEqual(creation_response.status_code, 201)
res = self.client.delete('/fdcs/1',
headers=dict(Authorization='Bearer ' +
login_data['auth_token']))
self.assertEqual(res.status_code, 200)
# Test to see if it exists, should return a 404
result = self.client().get('/fdcs/1')
self.assertEqual(result.status_code, 404)
def post(self):
"""
"""
user_schema = UserSchema()
user_data = request.get_json()
validated_user_data, errors = user_schema.load(user_data)
email = validated_user_data.get('email', None)
client_base_url = os.getenv('CLIENT_BASE_URL',
f'https://{request.host}/users')
# To do change to a frontend url
verification_url = f"{client_base_url}/verify/"
secret_key = current_app.config["SECRET_KEY"]
password_salt = current_app.config["VERIFICATION_SALT"]
sender = current_app.config["MAIL_DEFAULT_SENDER"]
template = "user/verify.html"
subject = "Please confirm your email"
if errors:
return dict(status="fail", message=errors), 400
# get the customer role
user_role = Role.find_first(name='customer')
user_existant = User.query.filter_by(email=email).first()
if user_existant:
return dict(
status="fail",
message=f"Email {validated_user_data['email']} already in use."
), 400
user = User(**validated_user_data)
if user_role:
user.roles.append(user_role)
saved_user = user.save()
if not saved_user:
return dict(status='fail', message=f'Internal Server Error'), 500
# send verification
send_verification(email, user.name, verification_url, secret_key,
password_salt, sender,
current_app._get_current_object(), template, subject)
new_user_data, errors = user_schema.dumps(user)
return dict(status='success',
data=dict(user=json.loads(new_user_data))), 201
def test_api_can_get_all_fdc(self):
"""Test API can get a FDC (GET request)."""
user = User(username='******',
email='*****@*****.**',
password='******',
first_name='charlie',
last_name='fei',
role='fdcAdmin',
location='nashville')
schema = UserSchema()
#Register a new FDC Admin
register_response = self.client.post('/users/',
data=schema.dumps(user).data,
content_type='application/json')
registration_data = json.loads(register_response.data.decode())
self.assertTrue(registration_data['status'] == 'success')
self.assertTrue(
registration_data['message'] == 'Successfully registered.')
self.assertTrue(registration_data['auth_token'])
self.assertTrue(register_response.content_type == 'application/json')
self.assertEqual(register_response.status_code, 201)
#Login as FDC Admin
login_response = self.client.post('/users/login',
data=schema.dumps(user).data,
content_type='application/json')
login_data = json.loads(login_response.data.decode())
self.assertTrue(login_data['status'] == 'success')
self.assertTrue(login_data['message'] == 'Successfully logged in.')
self.assertTrue(login_data['auth_token'])
self.assertTrue(login_response.content_type == 'application/json')
self.assertEqual(login_response.status_code, 200)
fdc_schema = FDCSchema()
creation_response = self.client.post(
'/fdcs/',
data=fdc_schema.dumps(self.fdc).data,
headers=dict(Authorization='Bearer ' + login_data['auth_token']),
content_type='application/json')
creation_data = json.loads(creation_response.data.decode())
self.assertTrue(creation_data['status'] == 'success')
self.assertTrue(
creation_data['message'] == 'Successfully created FDC.')
self.assertTrue(creation_response.content_type == 'application/json')
self.assertEqual(creation_response.status_code, 201)
get_response = self.client.get('/fdcs/')
data = json.loads(get_response.data.decode())
self.assertTrue(data['status'] == 'success')
self.assertIn('Nashville Food Project', str(data['fdcs']))
self.assertEqual(get_response.status_code, 200)
def get_user_by_firebase_id():
user_schema = UserSchema()
fb_id = request.args['firebase_id']
user = db.session.query(User).filter(User.firebase_id == fb_id).first()
if user:
return user_schema.dumps(user)
else:
raise NotFound(
"Could not find user with firebase_id of '{}'".format(fb_id))
def post(self):
try:
requested_data = request.get_json()
if UserModel.get_user_by_username(requested_data["username"]):
return {"msg": "Username already exists"}, 400
if UserModel.get_user_by_email(requested_data["email"]):
return {"msg": "Email already exists"}, 400
user_schema = UserSchema()
result: dict = user_schema.load(requested_data)
UserModel.register_user(**result)
return {"msg": "Registration successful"}, 201
except ValidationError as err:
return jsonify(err.messages, 400)
def post(self):
candidate = request.get_json()
schema = UserSchema()
errors = schema.validate(candidate)
if errors:
return {'massage': errors}, 400
data = schema.dump(candidate)
if UserModel.find_by_email(data['email']):
return {'massage': 'this mail already exist'}, 400
user = UserModel(**data)
user.save_to_db()
return {'massage': 'User has been created'}, 201
def test_pickup_accept:
#User we're using
user = User(username='******', email='*****@*****.**', password='******', first_name='charlie', last_name='fei', role='donor', location='nashville')
volunteer = User(username='******', email='*****@*****.**', password='******', first_name='vol', last_name='fei', role='volunteer', location='nashville')
schema = UserSchema()
#Register User
register_response = self.client.post('/users/',
data = schema.dumps(user).data,
content_type = 'application/json'
)
registration_data = json.loads(register_response.data.decode())
self.assertTrue(registration_data['status'] == 'success')
self.assertTrue(
registration_data['message'] == 'Successfully registered.'
)
self.assertTrue(registration_data['auth_token'])
self.assertTrue(register_response.content_type == 'application/json')
self.assertEqual(register_response.status_code, 201)
#Login User
login_response = self.client.post('/users/login',
data = schema.dumps(user).data,
content_type = 'application/json'
)
login_data = json.loads(login_response.data.decode())
self.assertTrue(login_data['status'] == 'success')
self.assertTrue(login_data['message'] == 'Successfully logged in.')
self.assertTrue(login_data['auth_token'])
self.assertTrue(login_response.content_type == 'application/json')
self.assertEqual(login_response.status_code, 200)
pickup_schema = PickupSchema()
pickup = Pickup(description="My Pickup", donor=user)
creation_response = self.client.post('/users/charlie/pickups/',
data = pickup_schema.dumps(pickup).data,
headers=dict(
Authorization='Bearer ' + login_data['auth_token']
),
content_type = 'application/json'
)
creation_data = json.loads(creation_response.data.decode())
self.assertTrue(creation_data['status'] == 'success')
self.assertTrue(creation_data['message'] == 'Successfully created pickup.')
self.assertTrue(creation_response.content_type == 'application/json')
self.assertEqual(creation_response.status_code, 201)
def update_user(id):
if current_user().id != id:
abort(403)
user = User.query.get_or_404(id)
data = request.get_json() or {}
if 'username' in data and data['username'] != user.username and User.query.filter_by(username=data['username']).first():
return bad_request('please use a different username')
if 'email' in data and data['email'] != user.email and User.query.filter_by(email=data['email']).first():
return bad_request('please use a different email address')
user.from_dict(data, new_user=False)
db.session.commit()
user_schema = UserSchema()
output = user_schema.dump(user).data
return jsonify({'user': output})
def get(self, token):
"""
"""
user_schema = UserSchema()
secret = current_app.config["SECRET_KEY"]
salt = current_app.config["VERIFICATION_SALT"]
email = validate_token(token, secret, salt)
if not email:
return dict(status="fail", message="invalid token"), 401
user = User.find_first(**{'email': email})
if not user:
return dict(status='fail',
message=f'User with email {email} not found'), 404
if user.verified:
return dict(status='fail',
message='Email is already verified'), 400
user.verified = True
user_saved = user.save()
user_dict, _ = user_schema.dump(user)
if user_saved:
# generate access token
access_token = user.generate_token(user_dict)
if not access_token:
return dict(status='fail',
message='Internal Server Error'), 500
return dict(status='success',
message='Email verified successfully',
data=dict(
access_token=access_token,
email=user.email,
username=user.username,
verified=user.verified,
id=str(user.id),
)), 200
return dict(status='fail', message='Internal Server Error'), 500
def get(self):
"""
"""
user_schema = UserSchema(many=True)
users = User.find_all()
users_data, errors = user_schema.dumps(users)
if errors:
return dict(status='fail', message=errors), 400
return dict(status='success',
data=dict(users=json.loads(users_data))), 200
def get(self):
"""
Getting All users
"""
user_schema = UserSchema(many=True)
users = User.find_all()
users_data, errors = user_schema.dumps(users)
if errors:
return dict(status="fail", message="Internal Server Error"), 500
return dict(status="success",
data=dict(users=json.loads(users_data))), 200
def create_account():
json_data = request.get_json(silent=True) or {}
ts = URLSafeTimedSerializer(current_app.config["SECRET_KEY"])
token = json_data.get("emailToken")
try:
email = ts.loads(
token, salt=current_app.config["EMAIL_CONFIRM_SALT"] # max_age=86400
)
except:
abort(400)
name = json_data.get("name")
password = json_data.get("password")
new_user_data = {"name": name, "email": email, "password": password}
print(new_user_data)
try:
data = UserSchema().load(new_user_data)
except:
abort(400)
new_user = User(email=data["email"], name=data["name"])
new_user.set_password(data["password"])
db.session.add(new_user)
try:
db.session.commit()
except:
abort(500)
return "", 200
class UserResourceFlaskAccepts(Resource):
@responds(schema=UserSchema(many=True), api=api)
@roles_required("admin")
def get(self):
users = User.query.all()
return users
def test_user_email_validation(email):
data = {"name": "marco", "email": email}
try:
UserSchema().load(data)
except ValidationError as exc:
assert exc.messages == {"email": ["Not a valid email address."]}
def get(self, user_id: int):
user = User.query.get(user_id)
if not user:
abort(404, "User was not found")
return jsonify(UserSchema().dump(user))
class UserResource(Resource):
def get(self, id):
user = User.query.get(id)
if user is None:
return error_object('User not found', 404)
return UserSchema().dump(user).data, 200
@use_args(UserSchema())
def put(self, user_args, id):
user = User.query.get(id)
if user is None:
return error_object('User not found', 404)
for key, value in user_args.items():
setattr(user, key, value)
try:
db.session.add(user)
db.session.commit()
except IntegrityError:
return error_object('Email already registered', 422)
return UserSchema().dump(user).data, 200
def delete(self, id):
user = User.query.get(id)
if user is None:
return error_object('User not found', 404)
db.session.delete(user)
db.session.commit()
return '', 204
def auth():
try:
auth = request.authorization
if not auth or not auth.username or not auth.password:
return Response(json.dumps(AuthExceptions.AUTH_NOT_FOUND.value),
mimetype='application/json')
user = User.query.filter_by(username=auth.username).first()
if not user:
return Response(json.dumps(AuthExceptions.USER_NOT_FOUND.value),
mimetype='application/json')
if not check_password_hash(user.password, auth.password):
return Response(json.dumps(
AuthExceptions.PASSWORD_NOT_MATCH.value),
mimetype='application/json')
response = {
"token":
jwt.encode(UserSchema().dump(user), app.config['SECRET_KEY'],
'HS256'),
"expired":
datetime.timestamp(datetime.now() + timedelta(hours=12))
}
return Response(json.dumps(response), mimetype='application/json')
except Exception as e:
print(f"Error: {e}")
return Response(json.dumps(AuthExceptions.ERROR.value),
mimetype='application/json')
def get(self, user_id):
"""
Get specific user
"""
user_schema = UserSchema()
user = User.get_by_id(user_id)
if not user:
return dict(status='fail', message=f'User with id {user_id} does not exist'), 404
user_data, errors = user_schema.dumps(user)
if errors:
return dict(status='fail', message=errors), 400
return dict(status='success', data=dict(users=json.loads(user_data))), 200
def post(self, user_id):
"""
"""
user_role_schema = UserRoleSchema()
user_role_data = request.get_json()
validated_user_role_data, errors = user_role_schema.load(
user_role_data)
if errors:
return dict(status='fail', message=errors), 400
# Get User
user = User.get_by_id(user_id)
if not user:
return dict(status='fail', message='User not found'), 404
# Get role
role = Role.get_by_id(validated_user_role_data.get('role_id', None))
if not role:
return dict(status='fail', message='Role not found'), 404
if role in user.roles:
return dict(status='fail', message='User already has role'), 409
# adding role to user roles
if role in user.roles:
return dict(status='fail', message='Role already Exists'), 404
user.roles.append(role)
saved_user_role = user.save()
user_schema = UserSchema()
if not saved_user_role:
return dict(status='fail', message='Internal Server Error'), 500
new_user_role_data, errors = user_schema.dumps(user)
return dict(status='success',
data=dict(user_role=json.loads(new_user_role_data))), 201
