def post(self):
# Extract user who tends to like from jwt
current_user = get_jwt_identity()
# Create an object using request data
view_object = view_schema.load(request.get_json())
# Check if the target valid or not
discovered_story = StoryModel.find_story_by_sid(view_object.target)
if discovered_story is None or discovered_story.status == 'unapproved':
return {'message': INVALID_REQUEST}, 400
if current_user is not None:
# Make an object of current user
active_user_object = ActiveModel.find_entry_by_uid(current_user)
# Check if already viewed or not
if view_object.target not in [view.target for view in active_user_object.viewed]:
view_object.source = current_user
view_object.time = time.asctime(time.gmtime(time.time()))
if view_object.create_entry() == ERROR_WRITING_VIEWS_TABLE:
return {'message': VIEW_UNSUCCESSFUL}, 500
# Add the number of views by one
StoryModel.add_views_by_one(view_object.target)
ActiveModel.add_views_by_one(discovered_story.author.uid)
# Use dump to create a dictionary
story_data = story_schema.dump(discovered_story)
# Pop status and add the name of the author
story_data.pop('status')
story_data.pop('author')
story_data.pop('viewers')
story_data.pop('fans')
story_data['name'] = discovered_story.author.name
story_data['uid'] = discovered_story.author.uid
if current_user is not None:
story_data['already_liked'] = view_object.target in [like.target for like in active_user_object.favourites]
return story_data
def post(self):
# Get the latest story
latest_story_object = StoryModel.force_find_latest_story_by_uid(get_jwt_identity())
current_time = time.time()
epoch = datetime.datetime.utcfromtimestamp(0)
# Check if there is a latest story or not
if latest_story_object is not None:
story_time = (latest_story_object.time - epoch).total_seconds()
if (current_time-story_time) < 86400:
return {'message': NOT_BEFORE_A_DAY}, 400
# Loaded incoming data into story
story_object = story_schema.load(request.get_json(), db.session)
# Check if the the genres is valid or not
# Accepts 3 genres only
genre_list = story_object.genre.split(',')
if not (len(genre_list) <= 3 and set(genre_list).issubset(set(genres))):
return {'message': INVALID_GENRE}, 400
# Check word length of various elements
if StoryModel.words_counter(story_object.title) > 7:
return {'message': TITLE_TOO_LONG}, 400
if StoryModel.words_counter(story_object.summary) > 80:
return {'message': SUMMARY_TOO_LONG}, 400
if StoryModel.words_counter(story_object.story) > 10000:
return {'message': STORY_TOO_LONG}, 400
# Adding time, uid and sid fields to story object
story_object.time = time.asctime(time.gmtime(time.time()))
story_object.uid = get_jwt_identity()
story_object.sid = StoryModel.generate_fresh_sid()
story_object.status = 'unapproved'
story_object.views = 0
story_object.likes = 0
# Creating a new entry in story table and checking for success
if story_object.create_story() == ERROR_WRITING_STORY_TABLE:
return {'message': ERROR_SUBMITTING_STORY}, 500
return {'message': STORY_SUCCESSFULLY_SUBMITTED}, 200
def put(self):
# Loaded incoming data into dict
story_data = edit_schema.load(request.get_json())
# Find the target story
discovered_story = StoryModel.find_story_by_sid(story_data['sid'])
# First check existence and then check for valid status
if (discovered_story is None) or (not StoryModel.check_story_status(discovered_story)):
return {'message': INVALID_REQUEST}, 400
else:
# Check the genre data
genre_list = story_data['genre'].split(',')
if not (len(genre_list) <= 3 and set(genre_list).issubset(set(genres))):
return {'message': INVALID_GENRE}, 400
# Check word length of various elements
if StoryModel.words_counter(story_data['title']) > 7:
return {'message': TITLE_TOO_LONG}, 400
if StoryModel.words_counter(story_data['summary']) > 80:
return {'message': SUMMARY_TOO_LONG}, 400
if StoryModel.words_counter(story_data['story']) > 10000:
return {'message': STORY_TOO_LONG}, 400
# Now update the fields of the story
discovered_story.story = story_data['story']
discovered_story.summary = story_data['summary']
discovered_story.title = story_data['title']
discovered_story.genre = story_data['genre']
if discovered_story.create_story() == ERROR_WRITING_STORY_TABLE:
return {'message': ERROR_SUBMITTING_STORY}, 500
return {'message': STORY_SUCCESSFULLY_UPDATED}, 200
def delete(self):
# Extract user who tends to like from jwt
current_user = get_jwt_identity()
# Create an object using request data
unlike_object = like_schema.load(request.get_json())
# Check target story is present and has valid status
discovered_story = StoryModel.find_story_by_sid(unlike_object.target)
if discovered_story is None or discovered_story.status == 'unapproved':
return {'message': INVALID_REQUEST}, 500
# Creating an for the requesting active user
active_user_object = ActiveModel.find_entry_by_uid(current_user)
# Check if the requesting user is the author of target story or not
if unlike_object.target in [
story.sid for story in active_user_object.submissions
]:
return {'message': CANNOT_UNLIKE_OWN_STORY}, 400
# Run a loop for checking and perform database operation
for list_item in active_user_object.favourites:
if list_item.target == unlike_object.target:
if list_item.delete_entry() == ERROR_DELETING_LIKE_TABLE:
return {'message': UNLIKE_UNSUCCESSFUL}, 500
else:
# Now reduce the number of likes by one for story as well as author
StoryModel.reduce_likes_by_one(unlike_object.target)
ActiveModel.reduce_likes_by_one(
discovered_story.author.uid)
return {'message': UNLIKE_SUCCESSFUL}, 200
return {'message': NOT_LIKED}, 400
def post(self):
# Extract user who tends to like from jwt
current_user = get_jwt_identity()
# Create an object using request data
like_object = like_schema.load(request.get_json())
# Creating an for the requesting active user
active_user_object = ActiveModel.find_entry_by_uid(current_user)
# Check target story is present and has valid status
discovered_story = StoryModel.find_story_by_sid(like_object.target)
if discovered_story is None or discovered_story.status == 'unapproved':
return {'message': INVALID_REQUEST}, 500
# Check if the requesting user is the author of target story or not
if like_object.target in [
story.sid for story in active_user_object.submissions
]:
return {'message': CANNOT_LIKE_OWN_STORY}, 400
# Check if the requesting user has already liked the target story
if like_object.target in [
story.target for story in active_user_object.favourites
]:
return {'message': ALREADY_LIKED}, 400
# If valid then fill the object fields with remaining data
like_object.source = current_user
like_object.time = time.asctime(time.gmtime(time.time()))
# Check for write errors and return appropriate messages
if like_object.create_entry() == ERROR_WRITING_LIKE_TABLE:
return {'message': LIKE_UNSUCCESSFUL}, 500
# Now add the number of likes by one for story as well as author
StoryModel.add_likes_by_one(like_object.target)
ActiveModel.add_likes_by_one(discovered_story.author.uid)
# Send a success message
return {'message': LIKE_SUCCESSFUL}, 202
class EditSchema(Schema):
sid = fields.String(required=True, validate=lambda c: len(c) == 8)
story = fields.String(
required=True, validate=lambda c: StoryModel.words_counter(c) <= 10000)
summary = fields.String(
required=True, validate=lambda c: StoryModel.words_counter(c) <= 80)
title = fields.String(required=True,
validate=lambda c: StoryModel.words_counter(c) <= 10)
genre = fields.String(required=True,
validate=lambda c: len(c.split(',')) <= 3 and set(
c.split(',')).issubset(set(genres)))
def delete(self):
# Extract and parse the data from request
delete_data = delete_schema.load(request.get_json())
# Create an object of requesting user
active_user_object = ActiveModel.find_entry_by_uid(get_jwt_identity())
# Check if the story is present in submissions and has valid status
for story in active_user_object.submissions:
if story.sid == delete_data['sid'] and StoryModel.check_story_status(story):
# Set counter to zero
ctr = 0
# Delete all likes
for fan in story.fans:
ctr += 1
if fan.delete_entry() == ERROR_DELETING_LIKE_TABLE:
return {'message': OPERATION_UNSUCCESSFUL}
# Decrease the total likes of the user
active_user_object.likes -= ctr
# Set counter to zero
ctr = 0
# Delete all views
for viewer in story.viewers:
ctr += 1
if viewer.delete_entry() == ERROR_DELETING_VIEWS_TABLE:
return {'message': OPERATION_UNSUCCESSFUL}
# Decrease the total views of the user
active_user_object.views -= ctr
# Commit changes done to active user
if active_user_object.create_active_user() == ERROR_WRITING_ACTIVE_TABLE:
return {'message': OPERATION_UNSUCCESSFUL}
# Delete the story
if story.delete_story() == ERROR_DELETING_STORY_TABLE:
return {'message': OPERATION_UNSUCCESSFUL}
return {'message': OPERATION_SUCCESSFUL}
return {'message': INVALID_REQUEST}
def post(self):
# Get the current user
current_user = get_jwt_identity()
# Parse incoming data and extract required field
search_data = search_schema.load(request.get_json())
incoming_string = search_data['string']
incoming_version = search_data['version']
incoming_content = search_data['content']
if incoming_content == 'authors':
active_user_objects = ActiveModel.find_entry_by_name(
incoming_string, incoming_version, current_user)
# Slice the results according to the need
if incoming_version > 1:
active_user_objects = active_user_objects[(incoming_version -
1) * 15:]
# Return results and if there are no users matching the criteria then return empty list
# Return empty list if there are no more versions with users matching the criteria
if len(active_user_objects) != 0:
return {
'results':
ActiveModel.generate_search_data(active_user_objects,
current_user)
}
else:
return {'message': NO_MORE_SEARCH_DATA}, 400
elif incoming_content == 'stories':
discovered_story_objects = StoryModel.find_stories_by_title(
incoming_string, incoming_version)
# Slice the results according to the need
if incoming_version > 1:
discovered_story_objects = discovered_story_objects[
(incoming_version - 1) * 15:]
# Return results and if there are no users matching the criteria then return empty list
# Return empty list if there are no more versions with users matching the criteria
if len(discovered_story_objects) != 0:
return {
'results': [
StoryModel.generate_story_element_data(story)
for story in discovered_story_objects
]
}
else:
return {'message': NO_MORE_SEARCH_DATA}, 400
def post(self):
genre_data = genre_schema.load(request.get_json())
discovered_stories = StoryModel.find_stories_by_genre(
genre_data['genre'], genre_data['version'])
# Slice the results based on version
if genre_data['version'] > 1:
discovered_stories = discovered_stories[(genre_data['version'] -
1) * 15:]
# Send appropriate response
if len(discovered_stories) != 0:
return {
'results': [
StoryModel.generate_story_element_data(story)
for story in discovered_stories
]
}
else:
return {'message': NO_MORE_GENRE_DATA}, 400
def post(self):
# Parse incoming data and extract required field
feed_data = feed_schema.load(request.get_json())
incoming_version = feed_data['version']
# Create an object of the active user
active_user_object = ActiveModel.find_entry_by_uid(get_jwt_identity())
# The final list to be returned
genre_based_list, follow_based_list, final_list = [], [], []
if active_user_object.basic is not None:
preferences_list = active_user_object.basic.preferences.split(',')
# append fetched stories for every preference
for preference in preferences_list:
genre_based_list.append(
StoryModel.find_feed_stories_by_genre(
preference, incoming_version))
# Set counter to zero
ctr = 0
for user in active_user_object.following:
# This will set a limit at the maximum no. of stories that can be selected
if ctr > incoming_version * 5:
break
latest_user_story = StoryModel.find_latest_story_by_uid(
user.target)
if latest_user_story is not None:
follow_based_list.append(latest_user_story)
ctr += 1
# Slice all the elementary lists
for sub_list in genre_based_list:
sub_list = sub_list[(incoming_version - 1) * 5:]
final_list.extend(sub_list)
final_list.extend(follow_based_list[(incoming_version - 1) * 5:])
# Now filter the list for duplicated and self composed stories
final_list = return_unique_list(final_list, active_user_object.uid)
# Return the results or send an error if final list is empty
if len(final_list) != 0:
return {
'results': [
StoryModel.generate_feed_element_data(story)
for story in final_list
]
}
else:
return {'message': NO_MORE_FEED}, 400
def put(self):
claims = get_jwt_claims()
# Will ensure admin privileges
if not claims['is_admin']:
return {'message': 'Admin privilege required.'}
# Parse incoming data using schema
parsed_data = approve_schema.load(request.get_json())
# Get the story to be approved from story table and check existence
discovered_story = StoryModel.find_entry_by_sid(parsed_data['sid'])
if discovered_story is None:
return {'message': INVALID_STORY_IDENTITY}
# Run create_story function to reflect changes
discovered_story.delete_story()
# Send a success message
return {'message': REJECTED_SUCCESSFULLY}, 202
def post(self):
# Extract user who tends to like from jwt
current_user = get_jwt_identity()
# Check if the jwt was sent or not
if not current_user:
# Create an object using request data
profile_object = profile_schema.load(request.get_json())
active_user_object = ActiveModel.find_entry_by_uid(
profile_object['uid'])
if active_user_object is None:
return {'message': INVALID_REQUEST}
else:
return {
# If basic data is not yet added then empty dict will be returned
# If data is kept private then appropriate message is returned
'basic':
BasicModel.generate_basic_profile_data(active_user_object),
'stories': [
StoryModel.generate_story_element_data(story)
for story in StoryModel.filter_story_object_list(
active_user_object.submissions)
],
'following':
FollowModel.generate_following_profile_data(
active_user_object),
'followers':
FollowModel.generate_followers_profile_data(
active_user_object),
'favourites':
LikesModel.generate_favourites_profile_data(
active_user_object),
'achievements': {
'views': active_user_object.views,
'likes': active_user_object.likes
}
}
else:
# Create an object using request data
active_user_object = ActiveModel.find_entry_by_uid(
get_jwt_identity())
return {
'basic':
BasicModel.force_generate_basic_profile_data(
active_user_object),
'stories': [
StoryModel.generate_story_element_data(story)
for story in StoryModel.filter_story_object_list(
active_user_object.submissions)
],
'following':
FollowModel.force_generate_following_profile_data(
active_user_object),
'followers':
FollowModel.generate_followers_profile_data(
active_user_object),
'favourites':
LikesModel.force_generate_favourites_profile_data(
active_user_object),
'achievements': {
'views': active_user_object.views,
'likes': active_user_object.likes
}
}