def put(self):
try:
user = current_identity.user()
if user is None:
return {
"message": "Unable to find user information"
}, status.HTTP_401_UNAUTHORIZED
parser = reqparse.RequestParser()
parser.add_argument("event_id", type=str, location="json")
parser.add_argument("text_context", type=str, location="json")
body = parser.parse_args()
event = BaseEvent.objects(id=body.event_id).first()
if event is None or event not in user.posted_events:
return {
"message": "no permission to delete"
}, status.HTTP_203_NON_AUTHORITATIVE_INFORMATION
event.update(text_context=body.text_context,
is_edited=True,
last_edit_at=datetime.utcnow())
user.update(last_online=datetime.utcnow())
return event.get_complete_json(), status.HTTP_200_OK
except Exception as e:
return {"error": str(e)}, status.HTTP_400_BAD_REQUEST
def delete(self):
try:
# Parsing JSON
body = parser.parse_args()
friend_username = body.username
user = current_identity.user()
friend = User.objects(username=friend_username).first()
if user is None or friend is None:
return {"message": "failed to find user"}, status.HTTP_203_NON_AUTHORITATIVE_INFORMATION
'''
Checking if the requesting user is in the friend list
'''
if any(friend_username in sublist for sublist in user.friends) is True:
# Getting the relationship object
relationship = Relationship.objects(between_users=[user.username, friend_username]).first()
if relationship is None:
relationship = Relationship.objects(between_users=[friend_username, user.username]).first()
if relationship is None:
return {"message": "unable to find relationship"}, status.HTTP_204_NO_CONTENT
# If the friend request found
user.update(pull__friends=relationship)
friend.update(pull__friends=relationship)
relationship.delete()
return {"message": "success"}, status.HTTP_200_OK
else:
return {"message": "not active friend"}
except Exception as e:
return {"message": str(e)}, status.HTTP_400_BAD_REQUEST
def post(self):
try:
body = parser.parse_args()
username = body.username
# Getting two users
user = current_identity.user()
blocking_user = User.objects(username=username).first()
if user is None or blocking_user is None:
return {"message": "failed to find user"}, status.HTTP_203_NON_AUTHORITATIVE_INFORMATION
'''
Getting the relationship between two users and go from there
*** NOTES: need to sort the relationship twice because there might be the wrong other of between_users
'''
relationship = Relationship.objects(between_users=[user.username, username]).first()
if relationship is None:
relationship = Relationship.objects(between_users=[username, user.username]).first()
if relationship is None or relationship.status != app_constant.user_blocked:
return {"message": "you are not blocking this user"}, status.HTTP_204_NO_CONTENT
user.update(pull__blocking=relationship)
blocking_user.update(pull__blocked_by=relationship)
relationship.delete()
return {"message": "success"}, status.HTTP_200_OK
except Exception as e:
return {"message": str(e)}, status.HTTP_400_BAD_REQUEST
def post(self):
try:
user = current_identity.user()
if user is None:
return {
"message": "Unable to find user information"
}, status.HTTP_401_UNAUTHORIZED
parser = reqparse.RequestParser()
parser.add_argument("event_id", type=str, location="json")
body = parser.parse_args()
event = BaseEvent.objects(id=body.event_id).first()
if event is None:
return {
"message": "event does not exists"
}, status.HTTP_501_NOT_IMPLEMENTED
if event in user.posted_events:
return {
"message": "can not report your own event"
}, status.HTTP_203_NON_AUTHORITATIVE_INFORMATION
# Enough permission and information -> remove event
user.update(add_to_set__reported_events=event,
last_online=datetime.utcnow())
event.update(add_to_set__reported_by=user)
return {"message": "success"}, status.HTTP_200_OK
except Exception as e:
return {"error": str(e)}, status.HTTP_400_BAD_REQUEST
def delete(self):
try:
user = current_identity.user()
if user is None:
return {
"message": "Unable to find user information"
}, status.HTTP_401_UNAUTHORIZED
parser = reqparse.RequestParser()
parser.add_argument("comment_id", type=str, location="json")
body = parser.parse_args()
comment_id = body.comment_id
comment = BaseComment.objects(id=comment_id).first()
if comment is None:
return {
"message": "unable to fine event"
}, status.HTTP_204_NO_CONTENT
comment.update(pull__liked_by=user)
user.update(last_online=datetime.utcnow())
return {"message": "request success"}, status.HTTP_200_OK
except ValueError as err:
return {"error": str(err)}, status.HTTP_400_BAD_REQUEST
except Exception as e:
return {"error": str(e)}, status.HTTP_400_BAD_REQUEST
def post(self):
try:
# Parsing JSON
body = parser.parse_args()
from_username = body.username
user = current_identity.user()
from_user = User.objects(username=from_username).first()
if user is None or from_user is None:
return {"message": "failed to find user"}, status.HTTP_203_NON_AUTHORITATIVE_INFORMATION
# Checking if this user requested friend yet
if any(from_username in sublist for sublist in user.friends_request_from) is True:
# Getting the relationship object
relationship = Relationship.objects(between_users=[user.username, from_username]).first()
if relationship is None:
relationship = Relationship.objects(between_users=[from_username, user.username]).first()
if relationship is None:
return {"message": "unable to find friend request"}, status.HTTP_204_NO_CONTENT
# If the friend request found
user.update(pull__friends_request_from=relationship)
from_user.update(pull__friends_request_to=relationship)
relationship.update(time_of_action=datetime.utcnow(), status=app_constant.is_friend)
user.update(add_to_set__friends=relationship)
from_user.update(add_to_set__friends=relationship)
return {"message": "success"}, status.HTTP_200_OK
else:
return {"message": "unable to find user request"}, status.HTTP_204_NO_CONTENT
except Exception as e:
return {"message": str(e)}, status.HTTP_400_BAD_REQUEST
def post(self):
try:
body = parser.parse_args()
username = body.username
# Getting two users
user = current_identity.user()
blocking_user = User.objects(username=username).first()
if user is None or blocking_user is None:
return {"message": "failed to find user"}, status.HTTP_203_NON_AUTHORITATIVE_INFORMATION
'''
Getting the relationship between two users and go from there
*** NOTES: need to sort the relationship twice because there might be the wrong other of between_users
'''
relationship = Relationship.objects(between_users=[user.username, username]).first()
if relationship is None:
relationship = Relationship.objects(between_users=[username, user.username]).first()
# if there is no relationship, simply add both users to the relationship
if relationship is None:
blocked_request = Relationship(between_users=[user.username, username],
status=app_constant.user_blocked).save()
user.update(add_to_set__blocking=blocked_request)
blocking_user.update(add_to_set__blocked_by=blocked_request)
return {"message": "success"}, status.HTTP_200_OK
'''
If this the relationship exists, we have a friend request from them
-- Blocking will also remove the user's request
'''
if relationship in user.friends_request_from:
user.update(pull__friends_request_from=relationship)
blocking_user.update(pull__friends_request_to=relationship)
relationship.update(status=app_constant.user_blocked,
time_of_action=datetime.utcnow())
user.update(add_to_set__blocking=relationship)
blocking_user.update(add_to_set__blocked_by=relationship)
return {"message": "success"}, status.HTTP_200_OK
if relationship in user.friends_request_to:
user.update(pull__friends_request_to=relationship)
blocking_user.update(pull__friends_request_from=relationship)
relationship.update(status=app_constant.user_blocked,
time_of_action=datetime.utcnow())
user.update(add_to_set__blocking=relationship)
blocking_user.update(add_to_set__blocked_by=relationship)
return {"message": "success"}, status.HTTP_200_OK
if relationship in user.friends:
user.update(pull__friends=relationship)
blocking_user.update(pull__friends=relationship)
relationship.update(status=app_constant.user_blocked,
time_of_action=datetime.utcnow())
user.update(add_to_set__blocking=relationship)
blocking_user.update(add_to_set__blocked_by=relationship)
return {"message": "success"}, status.HTTP_200_OK
except Exception as e:
return {"error": str(e)}, status.HTTP_400_BAD_REQUEST
def get(self):
try:
user = current_identity.user()
if user is not None:
user.update(last_online=datetime.utcnow())
return user.get_json(), status.HTTP_200_OK
return {"message": "Unable to find user information"}, status.HTTP_401_UNAUTHORIZED
except Exception as e:
return {"message": str(e)}
def get(self, task_id):
args = parser.parse_args()
user = current_identity.user()
task = Task.objects(local_id=task_id, user=user).first()
if task is None:
return {"code": 0, "message": "Not found"}, 404
else:
return task.get_json(), 200
def put(self):
# Getting current identified user
parser = reqparse.RequestParser()
user = current_identity.user()
if user is None:
return {"message": "null"}, status.HTTP_401_UNAUTHORIZED
try:
# Update user info
parser.add_argument("profile_url", type=str, location="json")
parser.add_argument("gender", type=str, location="json")
parser.add_argument("display_name", type=str, location="json")
parser.add_argument("nickname", type=str, location="json")
parser.add_argument("birthday", type=str, location="json")
parser.add_argument("longitude", type=float, location="json")
parser.add_argument("latitude", type=float, location="json")
body = parser.parse_args()
# Getting the gender
gender = body.gender
if gender is not None and len(gender) > 0:
user.gender = gender
# Getting profile Url
profile_url = body.profile_url
if profile_url is not None and len(profile_url) > 0:
user.profile_url = profile_url
# Getting display name
display_name = body.display_name
if display_name is not None and len(display_name) > 0:
user.display_name = display_name
# Getting nickname
nickname = body.nickname
if nickname is not None and len(nickname) > 0:
user.nickname = nickname
# Getting user birthday
birthday = body.birthday
if birthday is not None and len(birthday) > 0:
user.birthday = utils.date_from_iso8601(birthday)
# Getting the location
latitude = body.latitude
longitude = body.longitude
if latitude is not None and latitude > -181 and (longitude is not None and longitude > -181):
user.location = [longitude, latitude]
user.save()
user.update(last_online=datetime.utcnow())
return user.get_json(), status.HTTP_200_OK
except Exception as e:
print(str(e))
return {"message": str(e)}, status.HTTP_400_BAD_REQUEST
def delete(self, task_id):
args = parser.parse_args()
user = current_identity.user()
task = Task.objects(local_id=task_id, user=user).first()
if task is None:
return {"code": 0, "message": "Not found"}, 404
else:
for task_progress in TaskProgress.objects(task=task):
task_progress.delete()
task.delete()
return {"code": 1, "message": "Deleted"}, 200
def post(self):
try:
# Parsing JSON
body = parser.parse_args()
to_username = body.username
user = current_identity.user()
to_user = User.objects(username=to_username).first()
if user is None or to_user is None:
return {"message": "failed to find user"}, status.HTTP_203_NON_AUTHORITATIVE_INFORMATION
'''
**********
If this user already sent you a request -- sent back to him a request means accept friendship
**********
'''
if any(to_username in sublist for sublist in user.friends_request_from) is True:
# Getting the relationship object
relationship = Relationship.objects(between_users=[user.username, to_username]).first()
if relationship is None:
relationship = Relationship.objects(between_users=[to_username, user.username]).first()
if relationship is None:
return {"message": "unable to find friend request"}, status.HTTP_204_NO_CONTENT
# If the friend request found
user.update(pull__friends_request_from=relationship)
to_user.update(pull__friends_request_to=relationship)
relationship.update(time_of_action=datetime.utcnow(), status=app_constant.is_friend)
user.update(add_to_set__friends=relationship)
to_user.update(add_to_set__friends=relationship)
'''
**********
If you already sent this user a friend request before
**********
'''
if any(to_username in sublist for sublist in user.friends_request_to) is True:
return {"message": "request already sent"}, status.HTTP_201_CREATED
'''
**********
Nothing happened before, send branch new request to the user
**********
'''
friend_request = Relationship(between_users=[user.username, to_username],
status=app_constant.friend_requesting).save()
user.update(add_to_set__friends_request_to=friend_request)
to_user.update(add_to_set__friends_request_from=friend_request)
return {"message": "success"}, status.HTTP_200_OK
except Exception as e:
return {"message": str(e)}, status.HTTP_400_BAD_REQUEST
def put(self):
# Getting current identified user
parser = reqparse.RequestParser()
user = current_identity.user()
try:
# Getting new password and update
parser.add_argument("password", type=str, location="json")
body = parser.parse_args()
password = body.password
if password is not None and len(password) > 0:
user.update(last_online=datetime.utcnow(), password=password)
return {"message": "success"}, status.HTTP_200_OK
return {"message": "invalid password"}, 204
except Exception as e:
return {"message": str(e)}, 401
def post(self):
try:
user = current_identity.user()
if user is None:
return {
"message": "Unable to find user information"
}, status.HTTP_401_UNAUTHORIZED
parser = reqparse.RequestParser()
parser.add_argument("event_id", type=str, location="json")
parser.add_argument("text_content", type=str, location="json")
parser.add_argument("image", type=str, location="json")
body = parser.parse_args()
event_id = body.event_id
text_content = body.text_content
image = body.image
# Now file the event and then add comment to it
event = BaseEvent.objects(id=event_id).first()
if event is None:
return {
"message": "event not found"
}, status.HTTP_204_NO_CONTENT
comment = BaseComment(create_by=user,
text_content=text_content,
image=image).save()
event.update(add_to_set__comments=comment)
# Now create an action
action = BaseAction(
by_user=user,
action_type=app_constant.action_comment_event,
target=event.id,
content=comment.id,
action_priority=app_constant.priority_low).save()
user.update(last_online=datetime.utcnow(),
add_to_set__recent_actions=action)
return {"message": "request success"}, status.HTTP_200_OK
except ValueError as err:
return {"error": str(err)}, status.HTTP_400_BAD_REQUEST
except Exception as e:
return {"error": str(e)}, status.HTTP_400_BAD_REQUEST
def post(self):
try:
body = parser.parse_args()
username = body.username
# Getting current user
user = current_identity.user()
ignore_ppl = User.objects(username=username).first()
if user is None or ignore_ppl is None:
return {
"message": "failed to find user"
}, status.HTTP_203_NON_AUTHORITATIVE_INFORMATION
if ignore_ppl in user.ignoring:
return {"message": "already ignored"}, status.HTTP_201_CREATED
user.update(add_to_set__ignoring=ignore_ppl)
return {"message": "success"}, status.HTTP_200_OK
except Exception as e:
return {"error": str(e)}, status.HTTP_400_BAD_REQUEST
def post(self):
args = parser.parse_args()
user = current_identity.user()
local_id = args["local_id"]
name = args["name"]
due_date = utils.date_from_iso8601(args["due_date"])
color = args["color"]
payment_per_hour = args["payment_per_hour"]
task = Task(user=user,
local_id=local_id,
name=name,
due_date=due_date,
color=color,
payment_per_hour=payment_per_hour,
done=False)
task.save()
return task.get_json(), 201
def post(self):
try:
user = current_identity.user()
if user is None:
return {
"message": "Unable to find user information"
}, status.HTTP_401_UNAUTHORIZED
parser = reqparse.RequestParser()
parser.add_argument("name", type=str, location="json")
parser.add_argument("subname", type=str, location="json")
parser.add_argument("profile_url", type=str, location="json")
parser.add_argument("wallpaper_url", type=str, location="json")
parser.add_argument("description", type=str, location="json")
parser.add_argument("tags", type=list, location="json")
body = parser.parse_args()
name = body.name
subname = body.subname
description = body.description
profile_url = body.profile_url
wallpaper_url = body.wallpaper_url
tags = body.tags
channel = BaseChannel(created_by=user,
owner=user,
name=name,
subname=subname,
description=description,
profile_url=profile_url,
wallpaper_url=wallpaper_url,
tags=tags).save()
user.update(last_online=datetime.utcnow(),
add_to_set__owner_channels=channel,
add_to_set__created_channels=channel)
return {"message": "request success"}, status.HTTP_200_OK
except ValueError as err:
return {"error": str(err)}, status.HTTP_400_BAD_REQUEST
except Exception as e:
return {"error": str(e)}, status.HTTP_400_BAD_REQUEST
def delete(self):
try:
user = current_identity.user()
if user is None:
return {"message": "Unable to find user information"}, status.HTTP_401_UNAUTHORIZED
# Delete everything created by the current user
# Todo: Need to delete references of things created by this user
for action in BaseAction.objects(by_user=user):
action.delete()
for comment in BaseComment.objects(create_by=user):
comment.delete()
for event in BaseEvent.objects(create_by=user):
event.delete()
user.delete()
return {"message": "delete account complete"}, status.HTTP_200_OK
except Exception as e:
return {"message": str(e)}
def get(self, _from, _to):
try:
user = current_identity.user()
if user is None:
return {"message": "Unable to find user information"}, status.HTTP_401_UNAUTHORIZED
try:
_from = int(_from)
_to = int(_to)
except ValueError as err:
pass
user.update(last_online=datetime.utcnow())
if _from > len(user.posted_events):
return [], status.HTTP_200_OK
elif _to >= len(user.posted_events):
return [event.get_complete_json() for event in user.posted_events[_from:]], status.HTTP_200_OK
else:
return [event.get_complete_json() for event in user.posted_events[_from:_to]], status.HTTP_200_OK
except Exception as e:
return {"error": str(e)}, status.HTTP_400_BAD_REQUEST
def delete(self):
try:
user = current_identity.user()
if user is None:
return {"message": "Unable to find user information"}, status.HTTP_401_UNAUTHORIZED
parser = reqparse.RequestParser()
parser.add_argument("event_id", type=str, location="json")
body = parser.parse_args()
event = BaseEvent.objects(id=body.event_id).first()
if event is None:
return {"message": "failed to find event"}, status.HTTP_204_NO_CONTENT
if user not in event.liked_by:
return {"message": "you did not like the event"}, status.HTTP_204_NO_CONTENT
event.update(pull__liked_by=user)
user.update(last_online=datetime.utcnow())
except Exception as e:
return {"error": str(e)}, status.HTTP_400_BAD_REQUEST
def put(self):
# Getting current identified user
user = current_identity.user()
if user is None:
return {"message": "Unable to find user information"}, status.HTTP_401_UNAUTHORIZED
# Try to save user display name
try:
parser = reqparse.RequestParser()
parser.add_argument("birthday", type=str, location="json")
body = parser.parse_args()
birthday = body.birthday
if birthday is not None and len(birthday) > 0:
user.birthday = utils.date_from_iso8601(birthday)
user.save()
user.update(last_online=datetime.utcnow())
return status.HTTP_200_OK
else:
return {"message": "Invalid Birthday"}, status.HTTP_417_EXPECTATION_FAILED
except Exception as e:
return {"message": str(e)}, status.HTTP_400_BAD_REQUEST
def post(self):
try:
user = current_identity.user()
if user is None:
return {"message": "Unable to find user information"}, status.HTTP_401_UNAUTHORIZED
parser = reqparse.RequestParser()
parser.add_argument("event_id", type=str, location="json")
body = parser.parse_args()
event = BaseEvent.objects(id=body.event_id).first()
if event is None:
return {"message": "failed to find event"}, status.HTTP_204_NO_CONTENT
event.update(add_to_set__liked_by=user)
# Now create an action
action = BaseAction(by_user=user, action_type=app_constant.action_like_event, target=event.id,
action_priority=app_constant.priority_low).save()
user.update(add_to_set__recent_actions=action, last_online=datetime.utcnow())
except Exception as e:
return {"error": str(e)}, status.HTTP_400_BAD_REQUEST
def post(self):
try:
user = current_identity.user()
if user is None:
return {
"message": "Unable to find user information"
}, status.HTTP_401_UNAUTHORIZED
parser = reqparse.RequestParser()
parser.add_argument("text_context", type=str, location="json")
parser.add_argument("images", type=list, location="json")
parser.add_argument("contain_event", type=str, location="json")
parser.add_argument("privacy", type=str, location="json")
parser.add_argument("longitude", type=float, location="json")
parser.add_argument("latitude", type=float, location="json")
parser.add_argument("tags", type=list, location="json")
body = parser.parse_args()
event = BaseEvent(create_by=user,
text_context=body.text_context,
images=body.images,
contain_event=body.contain_event,
privacy=body.privacy,
location=[body.longitude, body.latitude],
tags=body.tags).save()
# Now create an action
action = BaseAction(
by_user=user,
action_type=app_constant.action_create_new_event,
target=event.id,
action_priority=app_constant.priority_medium).save()
user.update(add_to_set__posted_events=event,
add_toset__recent_actions=action,
last_online=datetime.utcnow())
return event.get_initial_json(), status.HTTP_200_OK
except Exception as e:
return {"error": str(e)}, status.HTTP_400_BAD_REQUEST
def delete(self):
try:
body = parser.parse_args()
username = body.username
# Getting current user
user = current_identity.user()
ignore_ppl = User.objects(username=username).first()
if user is None or ignore_ppl is None:
return {
"message": "failed to find user"
}, status.HTTP_203_NON_AUTHORITATIVE_INFORMATION
if ignore_ppl not in user.ignoring:
return {
"message": "not ignore this person"
}, status.HTTP_204_NO_CONTENT
user.update(pull__ignoring=ignore_ppl)
return {"message": "success"}, status.HTTP_200_OK
except Exception as e:
return {"error": str(e)}, status.HTTP_400_BAD_REQUEST
def put(self):
# Getting current identified user
user = current_identity.user()
if user is None:
return {"message": "Unable to find user information"}, status.HTTP_401_UNAUTHORIZED
# Try to save user display name
try:
parser = reqparse.RequestParser()
parser.add_argument("gender", type=str, location="json")
body = parser.parse_args()
gender = body.gender
if gender is not None and len(gender) > 0 and gender in GENDER:
user.gender = gender
user.save()
user.update(last_online=datetime.utcnow())
return status.HTTP_200_OK
else:
return {"message": "Invalid gender! Gender must be one of 'Male', 'Female', 'Other'"},\
status.HTTP_417_EXPECTATION_FAILED
except Exception as e:
return {"message": str(e)}, status.HTTP_400_BAD_REQUEST
def get(self, _from, _to):
try:
user = current_identity.user()
if user is None:
return {
"message": "Unable to find user information"
}, status.HTTP_401_UNAUTHORIZED
parser = reqparse.RequestParser()
parser.add_argument("event_id", type=str, location="json")
body = parser.parse_args()
event_id = body.event_id
event = BaseEvent.objects(id=event_id).first()
if event is None:
return {
"message": "event not found"
}, status.HTTP_204_NO_CONTENT
comments = event.comments
comments.sort(operator.attrgetter('liked_by'))
if _from > len(comments):
return [], status.HTTP_200_OK
elif _to >= len(comments):
return [
comment.get_complete_json() for comment in comments[_from:]
], status.HTTP_200_OK
else:
return [
comment.get_complete_json()
for comment in comments[_from:_to]
], status.HTTP_200_OK
except ValueError as err:
return {"error": str(err)}, status.HTTP_400_BAD_REQUEST
except Exception as e:
return {"error": str(e)}, status.HTTP_400_BAD_REQUEST
def put(self, task_id):
args = parser.parse_args()
user = current_identity.user()
task = Task.objects(local_id=task_id, user=user).first()
if task is None:
return {"code": 0, "message": "Not found"}, 404
else:
args = parser.parse_args()
local_id = args["local_id"]
name = args["name"]
due_date = utils.date_from_iso8601(args["due_date"])
color = args["color"]
done = args["done"]
payment_per_hour = args["payment_per_hour"]
task.update(set__local_id=local_id,
set__name=name,
set__due_date=due_date,
set__color=color,
set__done=done,
set__payment_per_hour=payment_per_hour)
return Task.objects().with_id(task.id).get_json(), 200
def post(self):
try:
user = current_identity.user()
if user is None:
return {
"message": "failed to find user"
}, status.HTTP_401_UNAUTHORIZED
parser = reqparse.RequestParser()
parser.add_argument("from_pos", type=int, location="json")
parser.add_argument("to_pos", type=int, location="json")
body = parser.parse_args()
# Getting the values
_from_pos = body.from_pos
_to_pos = body.to_pos
return [
friend.get_simple()
for friend in user.friends[_from_pos:_to_pos]
]
except Exception as e:
return {"error": str(e)}, status.HTTP_400_BAD_REQUEST
def get(self):
user = current_identity.user()
tasks = Task.objects(user=user)
return [task.get_json() for task in tasks], 200
