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 } }