def anon_posts_request_impl(args):
try:
user = user_from_token(args['token'])
posts = anon_posts_undefined_for_user_paginated(user, page=int(args['page']), limit=int(args['limit']))
return Response(True, "Anon Posts For User Searched", PostSchema(many=True).dumps(posts).data).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def search_posts_request_impl(args):
try:
user = user_from_token(args['token'])
posts = search_posts_with_string(user ,args['search_string'], page=int(args['page']), limit=int(args['limit']))
return Response(True, "Posts Searched", PostSchema(many=True).dumps(posts).data).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def comment_request_impl(args):
try:
author = user_from_token(args['token'])
post = post_from_id(author, args['post_id'])
comment = Comment(args['content'])
post.comments.append(comment)
author.comments.append(comment)
post.add_hot(5, None)
if args.has_key("picture") and args['picture'] is not None:
output = s3_upload(args['picture'])
url = 'https://{}.s3.amazonaws.com/{}'.format(os.environ['S3_BUCKET_NAME'], output)
comment.pic = url
db.session.commit()
#send notification to author
send_notification_for_user_commenting_on_post(device_token=post.user.device_token,
user_id=author.id,
user_pic=author.pic,
comment_id=comment.id,
nickname=author.nickname,
post_id=post.id,
platform=post.user.platform)
return Response(True, "Comment Succeded", CommentSchema().dumps(comment).data).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def deletes_request_impl(args):
try:
user = user_from_token(args['token'])
date = dateutil.parser.parse(args['date'])
deleted_groups = []
deleted_posts = []
deleted_comments = []
#comments
comments = deleted_comments_since_date(date)
for comment in comments:
deleted_comments.append(comment.id)
#posts
posts = deleted_posts_since_date(date)
for post in posts:
deleted_posts.append(post.id)
#groups
groups = deleted_groups_since_date(user, date)
for group in groups:
deleted_groups.append(group.id)
deleted_dict = {'groups' : deleted_groups , 'posts' : deleted_posts, 'comments' : deleted_comments}
return Response(True, "Deleteds Searched", json.dumps(deleted_dict)).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def users_pending_join_approval_request_impl(args):
try:
admin = user_from_token(args['token'])
page = args.pop('page', 1)
users = admin_pending_subscriptions_to_approve(admin, page=int(page), limit=50)
return Response(True, "Subscriptions Fetched", UserSchema(many=True).dumps(users).data).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def comments_request_impl(args):
try:
user = user_from_token(args['token'])
post = post_from_id(user ,args['post_id'])
comments = comments_from_post_paginated(post, int(args['page']), int(args['limit']))
return Response(True, "Comments Searched", CommentSchema(many=True).dumps(comments).data).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def __add_nickname_request_impl(args):
try:
user = user_from_token(args['token'])
user.nickname = args['nickname']
db.session.commit()
return Response(True, "Nickname Added", UserSchema().dumps(user).data).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def login_request_impl(args):
try:
user = user_from_facebook_id(args['facebook_id'])
delete_last_token_from_facebook_id(args['facebook_id'])
if user is not None:
__set_values_for_user_from_args(user, args)
__generate_token_for_user(user)
#needs to call it to assign to builtin, we need to use it later on group hybrid property.
user_from_token(user.user_token.token)
user_groups = json.loads(GroupSchema(many=True).dumps(groups_from_user(user)).data)
user_data = json.loads(MyselfSchema().dumps(user).data)
return Response(True, "Login Succeed", json.dumps(dict(groups=user_groups, myself=user_data))).output()
else:
return signup_request_impl(args)
except Exception as exception:
return Response(False, str(exception), None).output()
def search_users_and_groups_request_impl(args):
try:
user = user_from_token(args['token'])
groups = json.loads(GroupSchema(many=True).dumps(group_with_title(args['search'])).data)
users = json.loads(UserSchema(many=True).dumps(users_from_nickname_or_name(args['search'])).data)
response_dict = dict(groups=groups, users=users)
return Response(True, "Search Complete!", json.dumps(response_dict)).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def report_request_impl(args):
try:
user = user_from_token(args['token'])
report = Report(user, args['type'], args['id'], args['reason'])
db.session.add(report)
db.session.commit()
return Response(True, "Report Submitted!", ReportSchema().dumps(report).data).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def unblock_user_from_group_request_impl(args):
try:
admin = user_from_token(args['token'])
group = group_from_id(int(args['group_id']))
is_group_admin(admin, group)
group.blocked_users.remove(user_from_id(args['user_id']))
db.session.commit()
return Response(True, "Unblocked!", GroupSchema().dumps(group).data).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def screenshot_post_request_impl(args):
try:
user = user_from_token(args['token'])
post = post_from_id(user, args['post_id'])
if post.user != user:
post_screenshot_notification.delay(post, user)
return Response(True, "Screenshot Sent", None).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def delete_comment_request_impl(args):
try:
author = user_from_token(args['token'])
comment = comment_from_id(args['comment_id'])
if author.id != comment.user_id:
raise NoPermissionException()
comment.active = False
db.session.commit()
return Response(True, "Comment Deleted", None).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def fetch_user_request_impl(args):
try:
user = user_from_token(args['token'])
user_to_fetch = user_from_id(args['user_id'])
groups = json.loads(GroupSchema(many=True).dumps(groups_from_user(user_to_fetch)).data)
posts = json.loads(PostSchema(many=True).dumps(posts_from_user_paginate(user, user_to_fetch)).data)
marshal_user = json.loads(UserSchemaWithPostsAndGroups().dumps(user_to_fetch).data)
response = dict(user=marshal_user, posts=posts, groups=groups)
return Response(True, "User Searched", json.dumps(response)).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def add_admin_request_impl(args):
try:
admin = user_from_token(args['token'])
group = group_from_id(args['group_id'])
is_group_admin(admin, group)
for user_id in args['user_ids']:
group.admins.append(user_from_id(user_id))
db.session.commit()
return Response(True, "Admin Added!", GroupSchema().dumps(group).data).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def anon_posts_request_impl(args):
try:
admin = user_from_token(args['token'])
groups = groups_from_ids(args['group_ids'])
posts = []
for group in groups:
is_group_admin(admin, group)
posts.extend(anon_posts_undefined_paginated(group, page=args['page'], limit=args['limit']))
return Response(True, "Group Created", PostSchema(many=True).dumps(posts).data).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def invite_request_impl(args):
try:
inviter = user_from_token(args['token'])
group = group_from_id(args['group_id'])
invitee = user_from_id(args['user_id'])
invite = Invite(inviter, invitee, group)
db.session.add(invite)
db.session.commit()
invited_for_group.delay(invite, group)
return Response(True, "Invitation Made", InviteSchema().dumps(invite).data).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def create_rule_request_impl(args):
try:
user = user_from_token(args['token'])
group = group_from_id(args['group_id'])
is_group_admin(user, group)
rule = Rule(args['property'], args['operand'] ,args['value'], args['value_type'], group)
rule.name = args['name']
db.session.add(rule)
db.session.commit()
return Response(True, "Rule Created" , RuleSchema().dumps(rule).data).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def join_group_request_impl(args):
try:
joiner = user_from_token(args['token'])
group = group_from_id(int(args['group_id']))
is_blocked_from_group(joiner, group)
user_can_join_group(joiner, group)
group.subscriptions.append(joiner)
if group.needs_approval_to_join is False:
approve_subscription_of_user(joiner, group)
db.session.commit()
return Response(True, "Joined Group!", GroupSchema().dumps(group).data).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def delete_post_request_impl(args):
try:
deleter = user_from_token(args['token'])
post = post_from_id(deleter, args['post_id'])
if post.user.id != deleter.id:
is_group_admin(deleter, post.group)
post.active = False
for comment in post.comments:
comment.active = False
db.session.commit()
return Response(True, "Delete Succeded", None).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def delete_group_request_impl(args):
try:
admin = user_from_token(args['token'])
group = group_from_id(args['group_id'])
is_group_admin(admin,group)
group.active = False
for post in group.posts:
post.active = False
for comment in post.comments:
comment.active = False
db.session.commit()
return Response(True, "Group Deleted", GroupSchema().dumps(group).data).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def group_post_request_impl(args):
try:
user = user_from_token(args["token"])
group = group_from_id(int(args["group_id"]))
user_is_a_approved_subscriber(user, group)
return Response(
True,
"Posts Searched",
PostSchema(many=True)
.dumps(posts_from_group_paginate(user, group, int(args["page"]), int(args["limit"])))
.data,
).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def leave_group_request_impl(args):
try:
leaver = user_from_token(args['token'])
group = group_from_id(int(args['group_id']))
if user_has_subscribed(leaver, group) is False:
raise UserCannotDoThisBecuaseIsNotSubscripted
if is_group_admin_returning_bool(leaver, group):
if len(group.admins) == 1:
raise UserCannotLeaveBecauseIsTheLastAdmin
else:
group.admins.remove(leaver)
group.subscriptions.remove(leaver)
db.session.commit()
return Response(True, "Leaved Group", None).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def update_user_request_impl(args):
try:
user = user_from_token(args['token'])
#name
if args.has_key("picture") and args['picture'] is not None:
user.name = args['name']
#friends
if args.has_key("friends") and args['friends'] is not None:
user.friends = args['friends']
#email
if args.has_key("email") and args['email'] is not None:
user.email = args['email']
#gender
if args.has_key("gender") and args['gender'] is not None:
user.gender = args['gender']
#device_token
if args.has_key("device_token") and args['device_token'] is not None:
user.device_token = args['device_token']
#platform
if args.has_key("platform") and args['platform'] is not None:
user.platform = args['platform']
#nickname
if args.has_key("nickname") and args['nickname'] is not None:
user.nickname = args['nickname']
#birthday
if args.has_key("birthday") and args['birthday'] is not None:
user.birthday = dateutil.parser.paser(args['birthday'])
#picture
if args.has_key("picture") and args['picture'] is not None:
output = s3_upload(args['picture'])
url = 'https://{}.s3.amazonaws.com/{}'.format(os.environ['S3_BUCKET_NAME'], output)
user.pic = url
db.session.commit()
return Response(True,"User Updated.", MyselfSchema().dumps(user).data).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def explore_request_impl(args):
try:
update_keywords()
user = user_from_token(args["token"])
hottests_groups_result = json.loads(GroupSchema(many=True).dumps(hottest_groups(user)).data)
lastest_groups_created_result = json.loads(GroupSchema(many=True).dumps(lastest_groups_created(user)).data)
hottest_users_result = json.loads(UserSchema(many=True).dumps(hottest_users()).data)
keywords_result = json.loads(KeywordSchema(many=True).dumps(query_availble_keywords()).data)
result = dict(
hottest_groups=hottests_groups_result,
lastest_groups=lastest_groups_created_result,
hottest_users=hottest_users_result,
trending=keywords_result,
)
return Response(True, "Explore!", json.dumps(result)).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def approve_join_request_impl(args):
try:
admin = user_from_token(args["token"])
user_pending = user_from_id(args["user_id"])
group = group_from_id(int(args["group_id"]))
is_group_admin(admin, group)
approved = bool(args["approved"])
if approved:
approve_subscription_of_user(user_pending, group)
else:
remove_subscription_of_user(user_pending, group)
db.session.commit()
return Response(
True, "Joined Group!" if approved is True else "Cannot Join Group!", GroupSchema().dumps(group).data
).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def anon_action_request_impl(args):
try:
user = user_from_token(args['token'])
post = post_from_id(user, args['post_id'])
group = group_from_id(args['group_id'])
status = int(args['status'])
post.approved = status
if status == UNDEFINED:
raise CannotAssignValueException
elif status == APPROVED:
post_auth_approved_request_notification.delay(post)
elif status == REMOVED:
post_auth_removed_request_notification.delay(post)
db.session.commit()
return Response(True, "Action taken", PostSchema().dumps(post).data).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def post_request_impl(args):
try:
poster = user_from_token(args['token'])
group = group_from_id(args['group_id'])
user_is_a_approved_subscriber(poster, group)
new_post = Post(args['content'], args['anon'])
if args.has_key("picture") and args['picture'] is not None:
output = s3_upload(args['picture'])
url = 'https://{}.s3.amazonaws.com/{}'.format(os.environ['S3_BUCKET_NAME'], output)
new_post.pic = url
group.posts.append(new_post)
poster.posts.append(new_post)
db.session.add(new_post)
db.session.commit()
#notifications
if new_post.anon == 1:
post_auth_request_notification.delay(new_post)
return Response(True, "Posted Successfully", PostSchema().dumps(new_post).data).output()
except Exception as exception:
return Response(False, str(exception), None).output()
def create_group_request_impl(args):
new_group = Group()
try:
admin = user_from_token(args['token'])
new_group.title = args['title']
new_group.description = args['description']
new_group.admins.append(admin)
new_group.subscriptions.append(admin)
new_group.needs_approval_to_join = bool(args['needs_approval'])
db.session.add(new_group)
db.session.commit()
approve_subscription_of_user(admin, new_group)
#add rules
if args.has_key('rules') and args['rules'] is not None:
for rule_dict in args['rules']:
new_rule = Rule(rule_dict['property'], int(rule_dict['operand']), rule_dict['value'], rule_dict['value_type'], new_group)
new_rule.name = rule_dict['name']
db.session.add(new_rule)
new_group.rules.append(new_rule)
db.session.commit()
user_can_join_group(admin, new_group)
#invite users
if args.has_key('invited_user_ids') and args['invited_user_ids'] is not None:
for invite_user_id in args['invited_user_ids']:
args = {'token': admin.user_token.token, 'group_id': new_group.id, 'user_id': int(invite_user_id)}
invite_request_impl(args)
db.session.commit()
return Response(True, "Group Created", GroupSchema().dumps(new_group).data).output()
except Exception as exception:
new_group.active = False
return Response(False, str(exception), None).output()
def get_group_request_impl(args):
try:
user_from_token(args['token'])
return Response(True, "Group Created", GroupSchema().dumps(group_from_id(args['group_id'])).data).output()
except Exception as exception:
return Response(False, str(exception), None).output()
