def user_tag_add(username):
"""
Add new tags to a user
:param username:
:return:
"""
try:
assert username == request.view_args['username']
if not auth( # authenticate user
app.config['SECRET_KEY'],
request,
username
):
return response_unauthorised()
json_request = request.json
# Check user_tags parameter exists
try:
new_tags = json_request['user_tags']
current_tags = user.user_info(username)['user_tags']
separate = "" if current_tags == "" else "," # stop incorrect commas at start of comma separated lists
current_tags = current_tags + separate + new_tags.replace(" ", "") # remove whitespace in tags
user.update_user(username, tags=current_tags)
except:
return response_invalid()
response_json = json_dict({"user_tags": current_tags}, indent=4)
return Response(response_json, status=success_code, mimetype='application/json')
except Exception as e:
print(e)
return response_unknown()
def delete_comment(comment_id):
"""
Delete a single comment
:param comment_id:
:return:
"""
try:
assert comment_id == request.view_args['comment_id']
try:
if not auth_comment( # authenticate user
app.config['SECRET_KEY'],
request,
comment_id
):
return response_unauthorised()
post.remove_comment(comment_id)
except:
return response_notFound()
response_json = json_dict({"Comment deleted: ": comment_id}, indent=4, default=str)
return Response(response_json, status=success_code, mimetype='application/json')
except Exception as e:
print(e)
return response_unknown()
def get_token(username):
"""
Generate authentication token, checks password
:param username:
:return:
"""
try:
assert username == request.view_args['username']
password = request.headers.get("Password")
if password is None: return response_invalid()
# hash password
hashed_password = util.hash_password(password)
# check password
if not user.check_password(username, hashed_password):
return response_unauthorised()
token = authentication.encode_token(app.config['SECRET_KEY'], username)
response_json = json_dict({"token": token}, indent=4, default=str)
return Response(response_json, status=success_code, mimetype='application/json')
except Exception as e:
print(e)
return response_unknown()
def post_tags(post_id):
"""
Update a post tags
:param post_id:
:return:
"""
try:
try:
assert post_id == request.view_args['post_id']
if not auth_post( # authenticate user
app.config['SECRET_KEY'],
request,
post_id
):
return response_unauthorised()
except:
return response_notFound()
try:
tags = request.json['post_tags']
current_tags = post.get_post(post_id)['post_tags']
new_tags = util.tag_validator(current_tags + "," + tags)
post.update_post(
post_id,
new_tags
)
except:
return response_invalid()
response_json = json_dict({"post_tags": new_tags}, indent=4, default=str)
return Response(response_json, status=success_code, mimetype='application/json')
except Exception as e:
print(e)
return response_unknown()
def user_premium_update(username):
"""
set a users profile to premium
:param username:
:return:
"""
try:
assert username == request.view_args['username']
try:
values = util.json_key(
request,
{
"premium": True
}
)
except:
return response_invalid()
user.update_user(
username,
premium=values['premium']
)
response_json = json_dict({"premium": values['premium']}, indent=4)
return Response(response_json, status=success_code, mimetype='application/json')
except Exception as e:
print(e)
return response_unknown()
def user_reward_update(username):
"""
Update a users reward points
:param username:
:return:
"""
try:
assert username == request.view_args['username']
if not auth( # authenticate user
app.config['SECRET_KEY'],
request,
username
):
return response_unauthorised()
json_request = request.json
try:
points = json_request['reward_points']
user.update_user(username, reward_points=points)
except:
return response_invalid()
response_json = json_dict({"reward_points": points}, indent=4)
return Response(response_json, status=success_code, mimetype='application/json')
except Exception as e:
print(e)
return response_unknown()
def user_posts_filter():
"""
Retrive posts associated with a (filter) paramters: tags & name
If no paramters, returns all posts
:return:
"""
try:
tags = request.headers.get("tags")
name = request.headers.get("name")
if tags is None and name is None:
posts = post.get_posts()
else:
posts = post.get_post_tag_name(
tags=tags,
name=name
)
response_json = json_dict(posts, indent=4, default=str)
return Response(response_json, status=success_code, mimetype='application/json')
except Exception as e:
print(e)
return response_unknown()
def user_credit_update(username):
"""
Sets a users credit
:param username:
:return:
"""
try:
assert username == request.view_args['username']
try:
values = util.json_key(
request,
{
"credit": True
}
)
except:
return response_invalid()
user.user_credit_change(username,
values['credit'])
response_json = json_dict({"credit": user.user_credit_amount(username)}, indent=4)
return Response(response_json, status=success_code, mimetype='application/json')
except Exception as e:
print(e)
return response_unknown()
def user_tag_remove(username):
"""
Delete SINGLE tag associate with user
:param username:
:return:
"""
if not auth( # authenticate user
app.config['SECRET_KEY'],
request,
username
):
return response_unauthorised()
try:
assert username == request.view_args['username']
try:
tag = request.json['user_tag']
tags = user.user_info(username)['user_tags']
new_tags = tags.replace(tag, '')
new_tags = util.tag_validator(new_tags) # format tags
user.update_user(username, tags=new_tags)
except KeyError:
return response_invalid()
response_json = json_dict({"user_tags": new_tags}, indent=4)
return Response(response_json, status=success_code, mimetype='application/json')
except Exception as e:
print(e)
return response_unknown()
def user_credit_get(username):
"""
Get a users credit
:param username:
:return:
"""
try:
assert username == request.view_args['username']
points = user.user_credit_amount(username)
response_json = json_dict({"credit": points}, indent=4)
return Response(response_json, status=success_code, mimetype='application/json')
except:
return response_notFound()
def user_type(username):
"""
Get a users type (free or premium)
:param username:
:return:
"""
try:
assert username == request.view_args['username']
type = user.user_type(username)
response_json = json_dict({"type": type}, indent=4)
return Response(response_json, status=success_code, mimetype='application/json')
except:
return response_notFound()
def get_user(username):
assert username == request.view_args['username']
if not verify.verify_str(username):
return response_invalid()
try:
response_json = json_dict(
user.user_info(username),
indent=4,
default=str
)
except:
return response_notFound()
return Response(response_json, status=success_code, mimetype='application/json')
def encode_token(key, username):
"""
Generate authentication token
:param key:
:param username:
:return:
"""
try:
payload = {'iat': datetime.datetime.utcnow(), 'username': username}
token = jwt.encode(payload, key, algorithm="HS256")
return token
except Exception as e:
response_json = json_dict({"status": "unable to generate token"},
indent=4)
return Response(response_json, status=401, mimetype='application/json')
def user_posts(username):
"""
Retrieves posts associated with a user
:param username:
:return:
"""
try:
posts = post.get_post_user(username)
if not posts:
return response_notFound()
response_json = json_dict(posts, indent=4, default=str)
return Response(response_json, status=success_code, mimetype='application/json')
except Exception as e:
print(e)
return response_unknown()
def add_comment(post_id):
"""
Adds a comment to a post
:param post_id:
:return:
"""
try:
assert post_id == request.view_args['post_id']
if not auth_post( # authenticate user
app.config['SECRET_KEY'],
request,
post_id
):
return response_unauthorised()
try: # verify required body parameters
values = util.json_key(
request,
{
"username": True,
"message": True
}
)
print(values['username'])
except:
return response_invalid()
try:
comment_id = post.add_comment(
post_id,
values['message'],
values['username']
)
except:
return response_notFound()
response_json = json_dict({"comment_id": comment_id}, indent=4)
return Response(response_json, status=created_code, mimetype='application/json')
except Exception as e:
print(e)
return response_unknown()
def user_tag_get(username):
"""
Retrive tags associated with user
:param username:
:return:
"""
try:
assert username == request.view_args['username']
tags = user.user_info(username)['user_tags']
if not isinstance(tags, str):
return response_invalid()
response_json = json_dict({"user_tags": tags}, indent=4)
return Response(response_json, status=success_code, mimetype='application/json')
except Exception as e:
print(e)
return response_notFound()
def delete_user(username):
"""
Delete a user
:param username:
:return:
"""
assert username == request.view_args['username']
if not auth( # authenticate user
app.config['SECRET_KEY'],
request,
username
):
return response_unauthorised()
try:
user.delete_user(username)
response_json = json_dict({"User deleted: ": username}, indent=4)
return Response(response_json, status=success_code, mimetype='application/json')
except Exception as e:
print(e)
return response_unknown()
def create_post():
"""
Create a new post
:return:
"""
try:
try: # Check parameters follow expected schema
body_param = util.json_key(request,
{
"username": True,
"message": True,
"photo_path": False,
"video_path": False,
"post_tags": True
})
except:
return response_invalid()
if body_param['message'] == "" or body_param['post_tags'] == "":
response_invalid()
if not auth(app.config['SECRET_KEY'], request, body_param['username']):
return response_unauthorised()
post_id = post.create_post(
body_param['username'],
body_param['message'],
0,
util.tag_validator(body_param['post_tags']), # format tags
body_param['photo_path'],
body_param['video_path']
)
response_json = json_dict({"post_id": post_id}, indent=4)
return Response(response_json, status=created_code, mimetype='application/json')
except Exception as e:
print(e)
return response_unknown()
def get_post_info(post_id):
"""
Get information post
Formatted as specific in API documentation
:param post_id:
:return:
"""
try:
assert post_id == request.view_args['post_id']
try:
post_info = post.get_post(post_id)
except:
return response_notFound()
response_json = json_dict(post_info, indent=4, default=str)
return Response(response_json, status=success_code, mimetype='application/json')
except Exception as e:
print(e)
return response_unknown()
def user_update(username):
assert username == request.view_args['username']
if not auth( # authenticate user
app.config['SECRET_KEY'],
request,
username
):
return response_unauthorised()
try:
json_request = request.json
values = util.json_key(
request,
{
"name": False,
"avatar_path": False,
"reward_points": False,
"credit": False,
"tags": False,
"desc": False
}
)
user.update_user(
username,
values['name'],
values['avatar_path'],
values['reward_points'],
values['tags'],
values['desc'],
values['credit']
)
response_json = json_dict(values, indent=4)
return Response(response_json, status=success_code, mimetype='application/json')
except Exception as e:
print(e)
return response_unknown()
def update_post_likes(post_id):
"""
Update the likes associated with a post
:param post_id:
:return:
"""
try:
try:
json_request = request.json
username = json_request["username"]
except:
return response_invalid()
if not auth( # authenticate user
app.config['SECRET_KEY'],
request,
username
):
return response_unauthorised()
assert post_id == request.view_args['post_id']
# Get current likes
try:
current_likes = post.get_post(post_id)['likes']
except:
return response_notFound()
new_likes = current_likes + 1
post.update_post(
post_id,
likes=new_likes
)
response_json = json_dict({"post_likes": new_likes}, indent=4)
return Response(response_json, status=success_code, mimetype='application/json')
except Exception as e:
print(e)
return response_unknown()
def get_comments(post_id):
"""
Get a (JSON) list of all comments associated with a post
:param post_id:
:return:
"""
try:
assert post_id == request.view_args['post_id']
try:
comments = post.get_comments(
post_id
)
except:
return response_notFound()
response_json = json_dict(comments, indent=4, default=str)
return Response(response_json, status=success_code, mimetype='application/json')
except Exception as e:
print(e)
return response_unknown()
def delete_tag(post_id):
"""
Remove tag from post
:param post_id:
:return:
"""
try:
try:
if not auth_post( # authenticate user
app.config['SECRET_KEY'],
request,
post_id
):
return response_unauthorised()
except:
return response_notFound()
try:
tag = request.json['post_tag']
current_tags = post.get_post(post_id)['post_tags']
new_tags = util.tag_validator(
current_tags.replace(tag, "")
)
post.update_post(
post_id,
post_tags=new_tags
)
except KeyError:
return response_invalid()
response_json = json_dict({"post_tags": new_tags}, indent=4, default=str)
return Response(response_json, status=success_code, mimetype='application/json')
except Exception as e:
print(e)
return response_unknown()
def get_dict(json):
return json_dict(json)
