def remove_user_collection_self(args):
"""Leave the collection (member)"""
is_parameter_exists([constants.ID], args)
collection_id = int(args[constants.ID])
request_user = args[constants.USER]
# Check Collection Id
if not Collection.objects.filter(id=collection_id).exists():
raise ApiError(constants.NOT_EXIST_OBJECT)
try:
collection_user = CollectionUser.objects.get(
collection_id=collection_id, user_id=request_user.id)
except ObjectDoesNotExist:
raise ApiError(constants.NOT_EXIST_OBJECT)
# if request_user is not member, then raise AUTH_ERROR
# the owner cannot delete himself or herself
# if the owner want to leave a collection, he or she must transfer it to other user
# or deleting the collection would be a solution
if collection_user.type != COLLECTION_USER_TYPE[1]:
raise ApiError(constants.AUTH_ERROR)
collection_user.delete()
# Get the number of Members(including owner) Of Collections
user_counts = __get_collection_user_count([collection_id], 'collection_id')
return {
constants.USERS:
user_counts[collection_id] if collection_id in user_counts else 0
}
def remove_review(args):
"""Remove Review"""
is_parameter_exists([constants.ID], args)
# Review ID
review_id = args[constants.ID]
# Request User
request_user = args[constants.USER]
try:
review = Review.objects.get(id=review_id)
except ObjectDoesNotExist:
raise ApiError(constants.NOT_EXIST_OBJECT)
# Auth
if review.user_id != request_user.id:
raise ApiError(constants.AUTH_ERROR)
paper_id = review.paper_id
review.delete()
obj = UserAction.objects.get(user_id=request_user.id,
paper_id=paper_id,
type=USER_ACTION_TYPE[2])
obj.count = obj.count - 1
obj.save()
def select_session(args):
"""Sign In"""
is_parameter_exists([constants.EMAIL, constants.PASSWORD], args)
# Email
email = args[constants.EMAIL]
# Password
password = args[constants.PASSWORD]
# Request
request = args[constants.REQUEST]
try:
user = User.objects.get(email=email)
except ObjectDoesNotExist:
raise ApiError(constants.NOT_EXIST_OBJECT)
else:
if not __is_correct_password(password, user):
raise ApiError(constants.AUTH_ERROR)
# Set Session Id
request.session[constants.ID] = user.id
users, _, _ = __get_users(Q(id=user.id), user, None)
if not users:
raise ApiError(constants.NOT_EXIST_OBJECT)
return users[0]
def remove_like_paper(args):
"""Remove Like of Paper"""
is_parameter_exists([constants.ID], args)
# Paper ID
paper_id = int(args[constants.ID])
# Request User
request_user = args[constants.USER]
try:
paper_like = PaperLike.objects.get(paper_id=paper_id,
user_id=request_user.id)
except ObjectDoesNotExist:
raise ApiError(constants.NOT_EXIST_OBJECT)
paper_like.delete()
# Update action count for recommendation
obj = UserAction.objects.get(user_id=request_user.id,
paper_id=paper_id,
type=USER_ACTION_TYPE[1])
obj.count = obj.count - 1
obj.save()
like_counts = __get_paper_like_count([paper_id], 'paper_id')
return {
constants.LIKES:
like_counts[paper_id] if paper_id in like_counts else 0
}
def update_user_collection_pending(args):
"""'pending' user accepts invitation"""
is_parameter_exists([constants.ID], args)
collection_id = int(args[constants.ID])
request_user = args[constants.USER]
# Check CollectionUser
try:
collection_user = CollectionUser.objects.get(
collection_id=collection_id, user_id=request_user.id)
except ObjectDoesNotExist:
raise ApiError(constants.NOT_EXIST_OBJECT)
# Check Collection Id
if not Collection.objects.filter(id=collection_id).exists():
raise ApiError(constants.NOT_EXIST_OBJECT)
# if request_user is not 'pending', then raise AUTH_ERROR
if collection_user.type != COLLECTION_USER_TYPE[2]:
raise ApiError(constants.AUTH_ERROR)
collection_user.type = COLLECTION_USER_TYPE[1] # change to member
collection_user.save()
# Get the number of Members(including owner) Of Collections
user_counts = __get_collection_user_count([collection_id], 'collection_id')
return {
constants.USERS:
user_counts[collection_id] if collection_id in user_counts else 0
}
def select_paper_collection(args):
"""Select Collections' Paper"""
is_parameter_exists([
constants.ID
], args)
# Request User
request_user = args[constants.USER]
# Collection Id
collection_id = args[constants.ID]
# Page Number
page_number = 1 if constants.PAGE_NUMBER not in args else int(args[constants.PAGE_NUMBER])
# Papers Queryset
queryset = CollectionPaper.objects.filter(
collection_id=collection_id
)
# Papers
collection_papers = get_results_from_queryset(queryset, 10, page_number)
# is_finished
is_finished = not collection_papers.has_next()
paper_ids = [collection_paper.paper_id for collection_paper in collection_papers]
papers, _ = __get_papers(Q(id__in=paper_ids), request_user, 10)
return papers, page_number, is_finished
def select_collection_search(args):
"""Select Collection Search"""
is_parameter_exists([constants.TEXT], args)
# Request User
request_user = args[constants.USER]
# Search Keyword
keyword = args[constants.TEXT]
# Page Number
page_number = 1 if constants.PAGE_NUMBER not in args else int(
args[constants.PAGE_NUMBER])
# Collections Queryset
queryset = (Q(title__icontains=keyword) | Q(text__icontains=keyword)) & (
Q(type=COLLECTION_SHARE_TYPE[0])
| Q(is_member=True))
# Collections
params = {
constants.TOTAL_COUNT: True # count whole collections
}
collections, _, is_finished, total_count = __get_collections(
queryset, request_user, 10, params=params, page_number=page_number)
return collections, page_number, is_finished, total_count
def insert_like_collection(args):
"""Insert Like of Collection"""
is_parameter_exists([constants.ID], args)
# Collection Id
collection_id = int(args[constants.ID])
# Request User
request_user = args[constants.USER]
# Check Collection Id
if not Collection.objects.filter(id=collection_id).exists():
raise ApiError(constants.NOT_EXIST_OBJECT)
# If Not Already Like, Create One
if not CollectionLike.objects.filter(collection_id=collection_id,
user_id=request_user.id).exists():
collection_like = CollectionLike(
collection_id=collection_id,
user_id=request_user.id,
)
collection_like.save()
collection = Collection.objects.get(id=collection_id)
collection_members = CollectionUser.objects.filter(
Q(collection_id=collection_id))
member_ids = [
collection_member.user_id
for collection_member in collection_members
]
member_ids = list(set(member_ids))
members = User.objects.filter(Q(id__in=member_ids))
# store an action for subscription feed
try:
subscription = Subscription.objects.get(
actor=request_user,
verb="liked",
action_object_object_id=collection_id)
subscription.save() # for updating time
except Subscription.DoesNotExist:
Subscription.objects.create(actor=request_user,
verb="liked",
action_object=collection)
notify.send(
request_user,
recipient=members,
verb='liked',
action_object=collection_like,
target=collection,
)
like_counts = __get_collection_like_count([collection_id], 'collection_id')
return {
constants.LIKES:
like_counts[collection_id] if collection_id in like_counts else 0
}
def select_collection_user_shared(args):
"""Select User's Shared Collections"""
is_parameter_exists([constants.ID], args)
# Request User
request_user = args[constants.USER]
# User Id
user_id = args[constants.ID]
# Page Number
page_number = 1 if constants.PAGE_NUMBER not in args else int(
args[constants.PAGE_NUMBER])
# Collections Queryset
queryset = Q(is_user_collection=True) & Q(is_shared=True) & (
Q(type=COLLECTION_SHARE_TYPE[0]) | Q(is_member=True))
# Collections
params = {
constants.USER_ID: user_id,
constants.TOTAL_COUNT: True # count whole shared collections
}
collections, _, is_finished, total_count = __get_collections(
queryset, request_user, 10, page_number=page_number, params=params)
return collections, page_number, is_finished, total_count
def select_review_user(args):
"""Get User's Reviews"""
is_parameter_exists([constants.ID], args)
# User Id
user_id = args[constants.ID]
# Request Uer
request_user = args[constants.USER]
# Page Number
page_number = 1 if constants.PAGE_NUMBER not in args else int(
args[constants.PAGE_NUMBER])
# Reviews Queryset
if int(user_id) == int(request_user.id):
queryset = Q(user_id=user_id)
else:
queryset = Q(user_id=user_id) & Q(anonymous=False)
params = {
constants.TOTAL_COUNT: True # count whole reviews
}
reviews, _, is_finished, total_count = __get_reviews(
queryset, request_user, 10, params=params, page_number=page_number)
return reviews, page_number, is_finished, total_count
def select_user_following_collection(args):
"""Get Following Users Not in Collection"""
is_parameter_exists([constants.COLLECTION_ID], args)
# Collection ID
collection_id = args[constants.COLLECTION_ID]
# Request User
request_user = args[constants.USER]
# Page Number
page_number = 1 if constants.PAGE_NUMBER not in args else int(
args[constants.PAGE_NUMBER])
# QuerySet
queryset = UserFollow.objects.annotate(is_in_collection=__is_in_collection(
'followed_user', collection_id)).filter(
following_user=request_user.id,
is_in_collection=False).values_list('followed_user', flat=True)
# User Ids
user_ids = get_results_from_queryset(queryset, 10, page_number)
# is_finished
is_finished = not user_ids.has_next()
# Filter Query
filter_query = Q(id__in=user_ids)
# Users
users, _, _ = __get_users(filter_query, request_user, 10)
return users, page_number, is_finished
def select_user_search_collection(args):
"""Search Users Not in Collection"""
is_parameter_exists([constants.TEXT, constants.COLLECTION_ID], args)
# Collection ID
collection_id = args[constants.COLLECTION_ID]
# Request User
request_user = args[constants.USER]
# Search Keyword
keyword = args[constants.TEXT]
# Page Number
page_number = 1 if constants.PAGE_NUMBER not in args else int(
args[constants.PAGE_NUMBER])
# User Queryset
queryset = User.objects.annotate(
is_in_collection=__is_in_collection('id', collection_id)).filter(
username__icontains=keyword,
is_in_collection=False).values_list('id', flat=True)
# User Ids
user_ids = get_results_from_queryset(queryset, 10, page_number)
# is_finished
is_finished = not user_ids.has_next()
# Users
users, _, _ = __get_users(Q(id__in=user_ids), request_user, 10)
return users, page_number, is_finished
def remove_user_collection(args):
"""Remove the Users from the Collection"""
is_parameter_exists([constants.ID, constants.USER_IDS], args)
collection_id = int(args[constants.ID])
user_ids = json.loads(args[constants.USER_IDS])
request_user = args[constants.USER]
# Check Collection Id
if not Collection.objects.filter(id=collection_id).exists():
raise ApiError(constants.NOT_EXIST_OBJECT)
# if request_user is not owner, then raise AUTH_ERROR
collection_user = CollectionUser.objects.get(collection_id=collection_id,
user_id=request_user.id)
if collection_user.type != COLLECTION_USER_TYPE[0]:
raise ApiError(constants.AUTH_ERROR)
# the owner cannot delete himself or herself
# if the owner want to leave a collection, he or she must transfer it to other user
# or deleting the collection would be a solution
if request_user.id in user_ids:
raise ApiError(constants.UNPROCESSABLE_ENTITY)
CollectionUser.objects.filter(user_id__in=user_ids,
collection_id=collection_id).delete()
# Get the number of Members(including owner) Of Collections
user_counts = __get_collection_user_count([collection_id], 'collection_id')
return {
constants.USERS:
user_counts[collection_id] if collection_id in user_counts else 0
}
def update_user_collection(args):
"""Transfer ownership of the Collection to the User"""
is_parameter_exists([constants.ID, constants.USER_ID], args)
collection_id = int(args[constants.ID])
user_id = args[constants.USER_ID]
request_user = args[constants.USER]
# Revoke ownership from request_user
try:
collection_user = CollectionUser.objects.get(
collection_id=collection_id, user_id=request_user.id)
except ObjectDoesNotExist:
raise ApiError(constants.NOT_EXIST_OBJECT)
# if request_user is not owner, then raise AUTH_ERROR
if collection_user.type != COLLECTION_USER_TYPE[0]:
raise ApiError(constants.AUTH_ERROR)
collection_user.type = COLLECTION_USER_TYPE[1] # change to member
collection_user.save()
# Grant ownership to the user whose id is user_id
try:
collection_user = CollectionUser.objects.get(
collection_id=collection_id, user_id=user_id)
except ObjectDoesNotExist:
raise ApiError(constants.NOT_EXIST_OBJECT)
collection_user.type = COLLECTION_USER_TYPE[0] # change to owner
collection_user.save()
def select_reply_review(args):
"""Select reply collection"""
is_parameter_exists([constants.ID], args)
# Review Id
review_id = args[constants.ID]
# Request User
request_user = args[constants.USER]
# Page Number
page_number = 1 if constants.PAGE_NUMBER not in args else int(
args[constants.PAGE_NUMBER])
# Replies Queryset
queryset = ReplyReview.objects.filter(review_id=review_id)
# Replies
review_replies = get_results_from_queryset(queryset, 10, page_number)
# is_finished
is_finished = not review_replies.has_next()
reply_ids = [review_reply.reply_id for review_reply in review_replies]
replies, _ = __get_replies(Q(id__in=reply_ids), request_user, 10)
return replies, page_number, is_finished
def select_user_search(args):
"""Select User Search"""
is_parameter_exists([constants.TEXT], args)
# Request User
request_user = args[constants.USER]
# Search Keyword
keyword = args[constants.TEXT]
# Page Number
page_number = 1 if constants.PAGE_NUMBER not in args else int(
args[constants.PAGE_NUMBER])
# User Queryset
queryset = User.objects.filter(Q(username__icontains=keyword)).values_list(
'id', flat=True)
total_count = queryset.count() # count whole users
# User Ids
user_ids = get_results_from_queryset(queryset, 10, page_number)
# is_finished
is_finished = not user_ids.has_next()
# Users
users, _, _ = __get_users(Q(id__in=user_ids), request_user, 10)
return users, page_number, is_finished, total_count
def insert_collection(args):
"""Insert Collection"""
is_parameter_exists([constants.TITLE, constants.TEXT], args)
# Request User
request_user = args[constants.USER]
# User Id
user_id = request_user.id
# Title
title = args[constants.TITLE]
# Text
text = args[constants.TEXT]
request_user = args[constants.USER]
# Check Valid
if not title or not text:
raise ApiError(constants.PARAMETER_ERROR)
# default type is 'public'
collection_share_type = args[
constants.TYPE] if constants.TYPE in args else COLLECTION_SHARE_TYPE[0]
if collection_share_type not in COLLECTION_SHARE_TYPE:
raise ApiError(constants.PARAMETER_ERROR)
# Create New Collection
collection = Collection.objects.create(title=title,
text=text,
type=collection_share_type)
# store an action for subscription feed
Subscription.objects.create(
actor=request_user,
verb="created",
action_object=collection,
)
# Add User To Collection
CollectionUser.objects.create(collection_id=collection.id,
user_id=user_id,
type=COLLECTION_USER_TYPE[0])
collection_id = collection.id
collections, _, _, _ = __get_collections(Q(id=collection_id), request_user,
None)
# Does Not Exist
if not collections:
raise ApiError(constants.NOT_EXIST_OBJECT)
collection = collections[0]
return collection
def insert_reply_collection(args):
"""Insert Reply Collection"""
is_parameter_exists([constants.ID, constants.TEXT], args)
# Collection Id
collection_id = args[constants.ID]
# Request User
request_user = args[constants.USER]
# Text
text = args[constants.TEXT]
# Check parameter
if not text:
raise ApiError(constants.PARAMETER_ERROR)
# Check collection id
if not Collection.objects.filter(id=collection_id).exists():
raise ApiError(constants.NOT_EXIST_OBJECT)
# Create
reply = Reply.objects.create(
user_id=request_user.id,
text=text,
)
ReplyCollection.objects.create(collection_id=collection_id,
reply_id=reply.id)
# send notifications to members of the collection
collection = Collection.objects.get(id=collection_id)
collection_members = CollectionUser.objects.filter(
Q(collection_id=collection_id))
member_ids = [
collection_member.user_id for collection_member in collection_members
]
member_ids = list(set(member_ids))
members = User.objects.filter(Q(id__in=member_ids))
notify.send(request_user,
recipient=members,
verb='replied to',
action_object=reply,
target=collection)
replies, _ = __get_replies(Q(id=reply.id), request_user, None)
if not replies:
raise ApiError(constants.NOT_EXIST_OBJECT)
reply = replies[0]
return reply
def insert_like_paper(args):
"""Insert Like of Paper"""
is_parameter_exists([constants.ID], args)
# Paper Id
paper_id = int(args[constants.ID])
# Request User
request_user = args[constants.USER]
# Check Paper Id
if not Paper.objects.filter(id=paper_id).exists():
raise ApiError(constants.NOT_EXIST_OBJECT)
# If Not Already Like, Create One
if not PaperLike.objects.filter(paper_id=paper_id,
user_id=request_user.id).exists():
PaperLike.objects.create(
paper_id=paper_id,
user_id=request_user.id,
)
# store an action for subscription feed
try:
subscription = Subscription.objects.get(
actor=request_user,
verb="liked",
action_object_object_id=paper_id)
subscription.save() # for updating time
except Subscription.DoesNotExist:
paper = Paper.objects.get(id=paper_id)
Subscription.objects.create(actor=request_user,
verb="liked",
action_object=paper)
# Create action for recommendation
try:
obj = UserAction.objects.get(user_id=request_user.id,
paper_id=paper_id,
type=USER_ACTION_TYPE[1])
obj.count = obj.count + 1
obj.save()
except ObjectDoesNotExist:
UserAction.objects.create(
user_id=request_user.id,
paper_id=paper_id,
type=USER_ACTION_TYPE[1],
count=1,
)
like_counts = __get_paper_like_count([paper_id], 'paper_id')
return {
constants.LIKES:
like_counts[paper_id] if paper_id in like_counts else 0
}
def insert_like_reply(args):
"""Insert Like of Reply"""
is_parameter_exists([constants.ID], args)
# Reply Id
reply_id = int(args[constants.ID])
# Request User
request_user = args[constants.USER]
# Check Reply Id
if not Reply.objects.filter(id=reply_id).exists():
raise ApiError(constants.NOT_EXIST_OBJECT)
# If Not Already Like, Create One
if not ReplyLike.objects.filter(reply_id=reply_id,
user_id=request_user.id).exists():
ReplyLike.objects.create(
reply_id=reply_id,
user_id=request_user.id,
)
# send notifications to the author of the reply
reply = Reply.objects.get(id=reply_id)
reply_author = User.objects.get(id=reply.user_id)
# consider target as the object which has the reply, instead of reply object
try: # assume it is the reply of a collection
collection_id = ReplyCollection.objects.get(
reply_id=reply_id).collection_id
target = Collection.objects.get(id=collection_id)
except ObjectDoesNotExist: # maybe it is the reply of a review
try:
review_id = ReplyReview.objects.get(
reply_id=reply_id).review_id
target = Review.objects.get(id=review_id)
except ObjectDoesNotExist:
raise ApiError(constants.NOT_EXIST_OBJECT)
notify.send(
request_user,
recipient=[reply_author],
verb='liked your reply of',
action_object=reply, # reply instead of reply_like
target=target,
)
like_counts = __get_reply_like_count([reply_id], 'reply_id')
return {
constants.LIKES:
like_counts[reply_id] if reply_id in like_counts else 0
}
def update_paper_collection(args):
"""Update Paper Collection"""
is_parameter_exists([constants.ID, constants.COLLECTION_IDS], args)
# Request User
request_user = args[constants.USER]
# Paper Id
paper_id = args[constants.ID]
# Collection IDs
collection_ids = args[constants.COLLECTION_IDS]
# Containing Collections
containing_collection_ids = __get_collections_contains_paper(
paper_id, request_user)
# Not Containing Collections
not_containing_collection_ids = list(
set(collection_ids) - set(containing_collection_ids))
# Add To Collections
__add_paper_to_collections(paper_id, not_containing_collection_ids,
request_user)
# Remove From Collections
__remove_paper_from_collections(
paper_id, list(set(containing_collection_ids) - set(collection_ids)),
request_user)
# store an action for subscription feed
if not_containing_collection_ids:
try:
subscription = Subscription.objects.get(
actor=request_user,
verb="added",
action_object_object_id=paper_id,
target_object_id=not_containing_collection_ids[0],
)
subscription.save() # for updating time
except Subscription.DoesNotExist:
paper = Paper.objects.get(id=paper_id)
collection = Collection.objects.get(
id=not_containing_collection_ids[0])
Subscription.objects.create(
actor=request_user,
verb="added",
action_object=paper,
target=collection,
)
def update_review(args):
"""Update Review"""
is_parameter_exists([constants.ID], args)
# Review ID
review_id = args[constants.ID]
# Request User
request_user = args[constants.USER]
try:
review = Review.objects.get(id=review_id)
except ObjectDoesNotExist:
raise ApiError(constants.NOT_EXIST_OBJECT)
# Auth
if review.user_id != request_user.id:
raise ApiError(constants.AUTH_ERROR)
# Title
title = args[constants.TITLE] if constants.TITLE in args else None
# Text
text = args[constants.TEXT] if constants.TEXT in args else None
# Anonymous
is_anonymous = args[
constants.IS_ANONYMOUS] if constants.IS_ANONYMOUS in args else None
# Update Title
if title:
review.title = title
# Update Text
if text:
review.text = text
# Update Anonymous
if is_anonymous:
review.anonymous = is_anonymous
review.save()
reviews, _, _, _ = __get_reviews(Q(id=review.id), request_user, None)
if not reviews:
raise ApiError(constants.NOT_EXIST_OBJECT)
review = reviews[0]
return review
def insert_like_review(args):
"""Insert Like of Review"""
is_parameter_exists([constants.ID], args)
# Review Id
review_id = int(args[constants.ID])
# Request User
request_user = args[constants.USER]
# Check Review Id
if not Review.objects.filter(id=review_id).exists():
raise ApiError(constants.NOT_EXIST_OBJECT)
# If Not Already Like, Create One
if not ReviewLike.objects.filter(review_id=review_id,
user_id=request_user.id).exists():
review_like = ReviewLike(
review_id=review_id,
user_id=request_user.id,
)
review_like.save()
review = Review.objects.get(id=review_id)
review_author = User.objects.get(id=review.user_id)
# store an action for subscription feed
try:
subscription = Subscription.objects.get(
actor=request_user,
verb="liked",
action_object_object_id=review_id)
subscription.save() # for updating time
except Subscription.DoesNotExist:
Subscription.objects.create(actor=request_user,
verb="liked",
action_object=review)
notify.send(
request_user,
recipient=[review_author],
verb='liked',
action_object=review_like,
target=review,
)
like_counts = __get_review_like_count([review_id], 'review_id')
return {
constants.LIKES:
like_counts[review_id] if review_id in like_counts else 0
}
def select_user_collection(args):
"""Get Users of the given Collection"""
is_parameter_exists([constants.ID], args)
collection_id = args[constants.ID]
request_user = args[constants.USER]
# Decide if results include request_user if she or he is one of members
includes_me = True if constants.INCLUDES_ME not in args else json.loads(
args[constants.INCLUDES_ME])
# Page Number
page_number = 1 if constants.PAGE_NUMBER not in args else int(
args[constants.PAGE_NUMBER])
# Check Collection Id
if not Collection.objects.filter(id=collection_id).exists():
raise ApiError(constants.NOT_EXIST_OBJECT)
# Members QuerySet (except 'pending')
if includes_me:
query = Q(
collection_id=collection_id) & ~Q(type=COLLECTION_USER_TYPE[2])
else:
query = Q(collection_id=collection_id) & ~Q(
user_id=request_user.id) & ~Q(type=COLLECTION_USER_TYPE[2])
queryset = CollectionUser.objects.filter(query)
# Members(including owner) Of Collections
collection_members = get_results_from_queryset(queryset, 10, page_number)
# is_finished
is_finished = not collection_members.has_next()
# Member Ids
member_ids = [
collection_member.user_id for collection_member in collection_members
]
member_ids = list(set(member_ids))
# Get Members
params = {constants.COLLECTION_ID: collection_id}
members, _, _ = __get_users(Q(id__in=member_ids),
request_user,
10,
params=params)
return members, page_number, is_finished
def select_user(args):
"""Get Single User"""
is_parameter_exists([constants.ID], args)
# Request User
request_user = args[constants.USER] if constants.USER in args else None
# User ID
user_id = args[constants.ID]
users, _, _ = __get_users(Q(id=user_id), request_user, None)
if not users:
raise ApiError(constants.NOT_EXIST_OBJECT)
return users[0]
def insert_user(args):
"""Insert New User"""
is_parameter_exists(
[constants.EMAIL, constants.USERNAME, constants.PASSWORD], args)
# # Request User
# request_user = args[constants.USER]
# Email
email = args[constants.EMAIL]
# User Name
username = args[constants.USERNAME]
# Password
password = args[constants.PASSWORD]
# Check parameters are valid
if not email or not username or not password:
raise ApiError(constants.PARAMETER_ERROR)
# Check username
if User.objects.filter(username=username).exists():
raise ApiError(constants.USERNAME_ALREADY_EXISTS)
# Check email
if User.objects.filter(email=email).exists():
raise ApiError(constants.EMAIL_ALREADY_EXISTS)
hashed, salt = __hash_password(password)
try:
user = User.objects.create_user(description=None,
email=email,
username=username,
password=hashed,
salt=salt)
except IntegrityError:
raise ApiError(constants.USERNAME_ALREADY_EXISTS)
users, _, _ = __get_users(Q(id=user.id), user, None)
if not users:
raise ApiError(constants.NOT_EXIST_OBJECT)
return users[0]
def remove_paper_collection(args):
"""Remove paper from the collection"""
is_parameter_exists([
constants.ID, constants.PAPER_ID
], args)
collection_id = int(args[constants.ID])
paper_id = int(args[constants.PAPER_ID])
if not CollectionPaper.objects.filter(collection_id=collection_id, paper_id=paper_id).exists():
raise ApiError(constants.NOT_EXIST_OBJECT)
CollectionPaper.objects.filter(collection_id=collection_id, paper_id=paper_id).delete()
# Get the number of papers in the collection
paper_counts = get_collection_paper_count([collection_id], 'collection_id')
return {constants.PAPERS: paper_counts[collection_id] if collection_id in paper_counts else 0}
def update_collection_type(args):
"""Update Collection Type"""
is_parameter_exists([constants.ID, constants.TYPE], args)
# Request User
request_user = args[constants.USER]
# Collection Share Type
share_type = args[constants.TYPE]
# Collection Id
collection_id = args[constants.ID]
# Check CollectionUser
try:
collection_user = CollectionUser.objects.get(
collection_id=collection_id, user_id=request_user.id)
except ObjectDoesNotExist:
raise ApiError(constants.NOT_EXIST_OBJECT)
# if request_user is not owner, then raise AUTH_ERROR
if collection_user.type != COLLECTION_USER_TYPE[0]:
raise ApiError(constants.AUTH_ERROR)
# Get Collection
try:
collection = Collection.objects.get(id=collection_id)
except ObjectDoesNotExist:
raise ApiError(constants.NOT_EXIST_OBJECT)
if share_type == COLLECTION_SHARE_TYPE[0]:
collection.type = COLLECTION_SHARE_TYPE[0]
elif share_type == COLLECTION_SHARE_TYPE[1]:
collection.type = COLLECTION_SHARE_TYPE[1]
else:
raise ApiError(constants.PARAMETER_ERROR)
collection.save()
collections, _, _, _ = __get_collections(Q(id=collection.id), request_user,
None)
if not collections:
raise ApiError(constants.NOT_EXIST_OBJECT)
return collections[0]
def insert_reply_review(args):
"""Insert Reply Review"""
is_parameter_exists([constants.ID, constants.TEXT], args)
# Review Id
review_id = args[constants.ID]
# Request User
request_user = args[constants.USER]
# Text
text = args[constants.TEXT]
# Check parameter
if not text:
raise ApiError(constants.PARAMETER_ERROR)
# Check review id
if not Review.objects.filter(id=review_id).exists():
raise ApiError(constants.NOT_EXIST_OBJECT)
# Create
reply = Reply.objects.create(user_id=request_user.id, text=text)
ReplyReview.objects.create(review_id=review_id, reply_id=reply.id)
# send notifications to the author of the review
review = Review.objects.get(id=review_id)
review_author = User.objects.get(id=review.user_id)
notify.send(request_user,
recipient=[review_author],
verb='replied to',
action_object=reply,
target=review)
replies, _ = __get_replies(Q(id=reply.id), request_user, None)
if not replies:
raise ApiError(constants.NOT_EXIST_OBJECT)
reply = replies[0]
return reply
def update_collection(args):
"""Update Collection"""
is_parameter_exists([constants.ID], args)
# Request User
request_user = args[constants.USER]
# Collection Id
collection_id = args[constants.ID]
# Get Collection
try:
collection = Collection.objects.get(id=collection_id)
except ObjectDoesNotExist:
raise ApiError(constants.NOT_EXIST_OBJECT)
# Check Collection User Id
if not request_user or not CollectionUser.objects.filter(
collection_id=collection_id, user_id=request_user.id).exists():
raise ApiError(constants.AUTH_ERROR)
# Title
title = args[constants.TITLE]
# Text
text = args[constants.TEXT]
# Update Title
if title:
collection.title = title
# Update Text
if text:
collection.text = text
collection.save()
collections, _, _, _ = __get_collections(Q(id=collection.id), request_user,
None)
if not collections:
raise ApiError(constants.NOT_EXIST_OBJECT)
return collections[0]
