def activity_stream_follow_activity(logged_in_user, following_user): # Add this activity to the Activity Stream activity_stream_item = ActivityStreamItem( activity_context_vocab="https://www.w3.org/ns/activitystreams", activity_summary="{} {} started following {} {}".format( logged_in_user.name, logged_in_user.surname, following_user.name, following_user.surname), activity_type="Follow", activity_actor_type="Person", activity_actor_id=logged_in_user.id, activity_actor_name=(logged_in_user.name + " " + logged_in_user.surname), activity_actor_image_url=profile_photo_link( logged_in_user.profile_photo, logged_in_user.id), activity_object_type="Person", activity_object_id=following_user.id, activity_object_name=following_user.name + " " + following_user.surname, activity_object_image_url=profile_photo_link( following_user.profile_photo, following_user.id)) try: db.session.add(activity_stream_item) # Creating a new database entry. db.session.commit() except: return make_response(jsonify({'error': 'Database Connection Error'}), 500)
def activity_stream_quit_workspace(user_id, form): try: current_user = User.query.filter(User.id == user_id).first() workspace = Workspace.query.filter( Workspace.id == form.workspace_id.data).first() except: return make_response(jsonify({'error': 'DB connection error'}), 500) activity_stream_entry = ActivityStreamItem( activity_context_vocab="https://www.w3.org/ns/activitystreams", activity_summary="{} {} left {} workspace".format( current_user.name, current_user.surname, workspace.title), activity_type="Leave", activity_actor_type="Person", activity_actor_id=current_user.id, activity_actor_name=(current_user.name + " " + current_user.surname), activity_actor_image_url=profile_photo_link(current_user.profile_photo, current_user.id), activity_object_type="Group", activity_object_name=workspace.title, activity_object_id=workspace.id) try: db.session.add(activity_stream_entry) db.session.commit() except: return make_response(jsonify({'error': 'Database Connection Error'}), 500) return make_response( jsonify({"msg": "You successfully quited from workspace."}), 201)
def activity_stream_accept_collaboration_application(application): try: workspace = Workspace.query.filter( Workspace.id == application.workspace_id).first() current_user = User.query.filter( User.id == application.applicant_id).first() except: return make_response( jsonify({"error": "The server is not connected to the database."}), 500) activity_stream_entry = ActivityStreamItem( activity_context_vocab="https://www.w3.org/ns/activitystreams", activity_summary="{} {} is now a contributor in {} workspace".format( current_user.name, current_user.surname, workspace.title), activity_type="Join", activity_actor_type="Person", activity_actor_id=current_user.id, activity_actor_name=(current_user.name + " " + current_user.surname), activity_actor_image_url=profile_photo_link(current_user.profile_photo, current_user.id), activity_target_type="Group", activity_target_name=workspace.title, activity_target_id=workspace.id, ) try: db.session.add(activity_stream_entry) db.session.commit() except: return make_response(jsonify({'error': 'Database Connection Error'}), 500)
def get(requester_id, self): # Tries to connect to the database. # If it fails, an error is raised. try: logged_in_user = User.query.filter_by(id=requester_id).first() user_job = Jobs.query.filter( Jobs.id == logged_in_user.job_id).first() except: return make_response( jsonify( {"error": "The server is not connected to the database."}), 500) else: # Checks whether there is an already existing user in the database with the given user ID. # If yes, user information is returned. # If not, an error is raised. if logged_in_user is not None: try: notification_status = NotificationStatus.query.get( logged_in_user.id) except: return make_response( jsonify({ "error": "The server is not connected to the database." }), 500) account_information = { "id": logged_in_user.id, "name": logged_in_user.name, "surname": logged_in_user.surname, "is_private": logged_in_user.is_private, "rate": logged_in_user.rate, "profile_photo": profile_photo_link(logged_in_user.profile_photo, logged_in_user.id), "e_mail": logged_in_user.e_mail, "google_scholar_name": logged_in_user.google_scholar_name, "researchgate_name": logged_in_user.researchgate_name, "job": user_job.name, "institution": logged_in_user.institution, "is_email_allowed": notification_status.is_email_allowed, "is_notification_allowed": notification_status.is_notification_allowed } return make_response(jsonify(account_information), 200) else: return make_response( jsonify({"error": "The user is not found."}), 404)
def get(user_id, self): ''' Returns a list of dictionaries with id, name, surname, e_mail, rate and is_private informations. ''' form = GetFollowersForm(request.args) if form.validate(): try: followSearch = Follow.query.filter( Follow.following_id == form.following_id.data).all() except: return make_response( jsonify({'error': 'Database Connection Error'}), 500) if followSearch is []: return make_response(jsonify({'error': 'User not found'}), 404) follower_users = [] for follow in followSearch: follower_users.append( User.query.filter(User.id == follow.follower_id).first()) followers_list = [{ 'id': follower_user.id, 'name': follower_user.name, 'surname': follower_user.surname, 'e_mail': follower_user.e_mail, 'rate': follower_user.rate, 'is_private': follower_user.is_private, 'profile_photo': profile_photo_link(follower_user.profile_photo, follower_user.id) } for follower_user in follower_users] # Pagination functionality number_of_pages = 1 if form.page.data is not None and form.per_page.data is not None: per_page = form.per_page.data number_of_pages = math.ceil(len(followers_list) / per_page) # Assign the page index to the maximum if it exceeds the max index page = form.page.data if form.page.data < number_of_pages else number_of_pages - 1 followers_list = followers_list[page * per_page:(page + 1) * per_page] return make_response( jsonify({ 'number_of_pages': number_of_pages, 'followers': followers_list }), 200) else: return make_response(jsonify({'error': 'Input Format Error'}), 400)
def activity_stream_create_issue(user_id, issue): try: current_user = User.query.filter(User.id == user_id).first() except: return make_response( jsonify({"error": "The server is not connected to the database."}), 500) try: # Activity is added into Activity Stream activity_stream_entry = ActivityStreamItem( activity_context_vocab="https://www.w3.org/ns/activitystreams", activity_summary= "{} {} created an issue titled '{}' in the workspace '{}'".format( current_user.name, current_user.surname, issue.title, get_workspace_title_of_issue(issue)), activity_type="Create", activity_actor_type="Person", activity_actor_id=current_user.id, activity_actor_name=(current_user.name + " " + current_user.surname), activity_actor_image_url=profile_photo_link( current_user.profile_photo, current_user.id), activity_object_type="Note", activity_object_name=issue.title, activity_object_id=issue.id, activity_object_content=issue.description, activity_target_type="Group", activity_target_id=issue.workspace_id, activity_target_name=get_workspace_title_of_issue(issue)) except: return make_response( jsonify({ "error": "error happened while creating activity stream entry" }), 500) try: db.session.add(activity_stream_entry) db.session.commit() except: return make_response(jsonify({'error': 'Database Connection Error'}), 500) return make_response( jsonify({ 'msg': 'Issue is successfully created', "issue_id": issue.id, "workspace_id": issue.workspace_id, "title": issue.title, "description": issue.description, "deadline": issue.deadline, "is_open": issue.is_open, "creator_id": issue.creator_id }), 200)
def activity_stream_user_comment_activity(user_id, form, comment): try: current_user = User.query.filter(User.id == user_id).first() other_user = User.query.filter( User.id == form.commented_user_id.data).first() except: return make_response(jsonify({'error': 'DB connection error'}), 500) activity_stream_entry = ActivityStreamItem( activity_context_vocab="https://www.w3.org/ns/activitystreams", activity_context_ext='http://schema.org/Rating', activity_summary="{} {} commented and rated {} {}".format( current_user.name, current_user.surname, other_user.name, other_user.surname), activity_type="Add", activity_actor_type="Person", activity_actor_id=current_user.id, activity_actor_name=(current_user.name + " " + current_user.surname), activity_actor_image_url=profile_photo_link(current_user.profile_photo, current_user.id), activity_object_type="Note", activity_object_name="Comment", activity_object_id=comment.id, activity_object_content=comment.text, activity_object_rating_value=comment.rate, activity_target_type="Person", activity_target_id=other_user.id, activity_target_name=other_user.name + " " + other_user.surname, activity_target_image_url=profile_photo_link(other_user.profile_photo, other_user.id)) try: db.session.add(activity_stream_entry) db.session.commit() except: return make_response(jsonify({'error': 'Database Connection Error'}), 500)
def activity_stream_delete_folder(user_id, workspace_id, path): try: current_user = User.query.filter(User.id == user_id).first() workspace = Workspace.query.filter( Workspace.id == workspace_id).first() except: return make_response( jsonify({"error": "The server is not connected to the database."}), 500) folder_name = path.split("/")[-1] try: # Activity is added into Activity Stream activity_stream_entry = ActivityStreamItem( activity_context_vocab="https://www.w3.org/ns/activitystreams", activity_summary= "{} {} deleted the folder named '{}' in the workspace '{}'".format( current_user.name, current_user.surname, folder_name, workspace.title), activity_type="Create", activity_actor_type="Person", activity_actor_id=current_user.id, activity_actor_name=(current_user.name + " " + current_user.surname), activity_actor_image_url=profile_photo_link( current_user.profile_photo, current_user.id), activity_object_type="Document", activity_object_name=folder_name, activity_target_type="Group", activity_target_id=workspace.id, activity_target_name=workspace.title) except: return make_response( jsonify({ "error": "error happened while creating activity stream entry" }), 500) try: db.session.add(activity_stream_entry) db.session.commit() except: return make_response(jsonify({'error': 'Database Connection Error'}), 500) return make_response(jsonify({"msg": "Folder is successfully deleted"}), 200)
def get(user_id, self): form = UserForm(request.args) if form.validate(): # Fetch recommendations from database try: all_recommendations = FollowRecommendationItem.query.filter_by( owner_id=user_id).order_by( FollowRecommendationItem.score.desc()).all() except: return make_response( jsonify({"error": "Database Connection Error"}), 500) # Fetch the user information from database (Also reduce number of them to required number) try: all_users = [ User.query.get(recommendation.recommendation_id) for recommendation in all_recommendations[:form.number_of_recommendations.data] ] except: return make_response( jsonify({"error": "Database Connection Error"}), 500) # Create the response format try: response = [{ 'id': user.id, 'name': user.name, 'surname': user.surname, 'profile_photo': profile_photo_link(user.profile_photo, user.id), "job": Jobs.query.get(user.job_id).name, "institution": user.institution, "is_private": int(user.is_private) } for user in all_users] except: return make_response( jsonify({"error": "Database Connection Error"}), 500) return make_response(jsonify({"recommendation_list": response}), 200) else: return make_response(jsonify({"error": "Input Format Error"}), 400)
def activity_stream_delete_workspace(requested_workspace, requester_id): if not requested_workspace.is_private: try: current_user = User.query.filter(User.id == requester_id).first() except: return make_response( jsonify( {"error": "The server is not connected to the database."}), 500) # Activity is added into Activity Stream activity_stream_entry = ActivityStreamItem( activity_context_vocab="https://www.w3.org/ns/activitystreams", activity_summary="{} {} deleted the workspace {}".format( current_user.name, current_user.surname, requested_workspace.title), activity_type="Delete", activity_actor_type="Person", activity_actor_id=current_user.id, activity_actor_name=(current_user.name + " " + current_user.surname), activity_actor_image_url=profile_photo_link( current_user.profile_photo, current_user.id), activity_object_type="Group", activity_object_name=requested_workspace.title, activity_object_id=requested_workspace.id, ) try: db.session.add(activity_stream_entry) db.session.commit() except: return make_response( jsonify({'error': 'Database Connection Error'}), 500) return make_response( jsonify({"message": "Workspace has been successfully deleted."}), 200)
def get(requester_id, self): ''' Returns the profile information of the requested user. ''' # Parses the form data. form = GetUserForm(request.args) # Checks whether the data is in valid form. # If yes, starts processing the data. # If not, an error is raised. if form.validate(): # Tries to connect to the database. # If it fails, an error is raised. try: existing_user = User.query.filter_by( id=form.user_id.data).first() user_job = Jobs.query.filter( Jobs.id == existing_user.job_id).first() except: return make_response( jsonify({ "error": "The server is not connected to the database." }), 500) else: # Checks whether there is an already existing user in the database with the given user ID. # If yes, user information is returned. # If not, an error is raised. if existing_user is not None: # Checks whether the requester user follows the requested user or not. if Follow.query.filter_by(follower_id=requester_id, following_id=form.user_id.data ).first() is not None: following_status = 1 # Represents that the requester user follows the requested user. elif FollowRequests.query.filter_by( follower_id=requester_id, following_id=form.user_id.data).first( ) is not None: following_status = 0 # Represents that the requester user has already sent a follow request to the requested user and it is pending. else: following_status = -1 # Represents that the requester user does not follow the requested user and has not yet sent a request to follow them. user_job = Jobs.query.filter( Jobs.id == existing_user.job_id).first() try: collaboration = Collaboration.query.filter_by( user_1_id=requester_id, user_2_id=form.user_id.data).first() except: return make_response( jsonify({ "error": "The server is not connected to the database." }), 500) account_information = { "id": existing_user.id, "name": existing_user.name, "surname": existing_user.surname, "e_mail": existing_user.e_mail, "is_private": existing_user.is_private, "following_status": following_status, "rate": existing_user.rate, "profile_photo": profile_photo_link(existing_user.profile_photo, existing_user.id), "google_scholar_name": existing_user.google_scholar_name, "researchgate_name": existing_user.researchgate_name, "job": user_job.name, "institution": existing_user.institution, "can_comment": collaboration is not None } return make_response(jsonify(account_information), 200) else: return make_response( jsonify({"error": "The user is not found."}), 404) else: return make_response( jsonify({"error": "Missing data fields or invalid data."}), 400)
def get(user_id, self): ''' Get Comments. ''' form = GetCommentsForm(request.args) if form.validate(): try: user_comments = Comments.query.filter( Comments.commented_user_id == form.commented_user_id.data).order_by( Comments.timestamp.desc()).all() except: return make_response( jsonify({'error': 'Database Connection Error'}), 500) if len(user_comments) == 0: return make_response(jsonify({'result': []}), 200) return_list = [] for comment in user_comments: try: commenter = User.query.filter( User.id == comment.owner_id).first() except: return make_response( jsonify({'error': 'Database Connection Error'}), 500) if commenter is None: return make_response( jsonify({'error': 'Commenter is None, smth wrong'}), 500) return_list.append({ "comment_id": comment.id, "owner_id": comment.owner_id, "owner_name": commenter.name, "owner_surname": commenter.surname, "owner_profile_photo": profile_photo_link(commenter.profile_photo, commenter.id), "commented_user_id": comment.commented_user_id, "timestamp": comment.timestamp, "rate": comment.rate, "text": comment.text }) # Pagination functionality number_of_pages = 1 if form.page.data is not None and form.per_page.data is not None: per_page = form.per_page.data number_of_pages = math.ceil(len(return_list) / per_page) # Assign the page index to the maximum if it exceeds the max index page = form.page.data if form.page.data < number_of_pages else number_of_pages - 1 return_list = return_list[page * per_page:(page + 1) * per_page] return make_response( jsonify({ 'number_of_pages': number_of_pages, 'result': return_list }), 200) else: return make_response(jsonify({'error': 'Input Format Error'}), 400)
def delete(user_id, self): ''' Takes the follower_id and following_id as inputs and replies the corresponding Follow Request. ''' form = ReplyFollowRequestsForm(request.form) if form.validate(): # Current user should be the following. if user_id != form.following_id.data: return make_response(jsonify({'error': 'Unauthorized'}), 401) # Check if the given FollowRequest instance exists. try: followSearch = FollowRequests.query.filter( FollowRequests.following_id == form.following_id.data, FollowRequests.follower_id == form.follower_id.data).all() except: return make_response( jsonify({'error': 'Database Connection Error'}), 500) if len(followSearch) == 0: return make_response( jsonify({'error': 'Follow Request not found'}), 404) follow_request = followSearch[0] # Accept if the state of the reply is 1. if form.state.data == 1: new_follow_entry = Follow(follow_request.follower_id, follow_request.following_id) try: db.session.add(new_follow_entry) db.session.delete(follow_request) db.session.commit() except: return make_response( jsonify({'error': 'Database Connection Error'}), 500) # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # Add notification to follower that his/her follow request is accepted. try: follower_user = User.query.filter( User.id == follow_request.follower_id).first() following_user = User.query.filter( User.id == follow_request.following_id).first() text = "{} accepted your follow request".format( following_user.name + " " + following_user.surname) NotificationManager.add_notification( follower_user.id, [following_user.id], text) except: return make_response( jsonify({'error': 'Database Connection Error'}), 500) # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! # Add this activity into Activity Stream activity_stream_entry = ActivityStreamItem( activity_context_vocab= "https://www.w3.org/ns/activitystreams", activity_summary="{} {} started following {} {}".format( follower_user.name, follower_user.surname, following_user.name, following_user.surname), activity_type="Follow", activity_actor_type="Person", activity_actor_id=follower_user.id, activity_actor_name=(follower_user.name + " " + follower_user.surname), activity_actor_image_url=profile_photo_link( follower_user.profile_photo, follower_user.id), activity_object_type="Person", activity_object_id=following_user.id, activity_object_name=following_user.name + " " + following_user.surname, activity_object_image_url=profile_photo_link( following_user.profile_photo, following_user.id)) try: db.session.add(activity_stream_entry) db.session.commit() except: return make_response( jsonify({'error': 'Database Connection Error'}), 500) # Reject if the state of the reply is 2. elif form.state.data == 2: try: db.session.delete(follow_request) db.session.commit() except: return make_response( jsonify({'error': 'Database Connection Problem'}), 500) # Return error if the state of reply is other than 1 or 2. else: return make_response( jsonify({ 'error': 'State of FollowRequest answer can only be 1 or 2!' }), 400) return make_response( jsonify({'msg': 'Follow Request is successfully replied'}), 200) else: return make_response(jsonify({'error': 'Input Format Error'}), 400)
def get(self): form = TagSearchForm(request.args) if form.validate(): skill_list = json.loads(form.skills.data) # Find the ids of the skills try: skill_ids = [ Skills.query.filter_by(name=skill.title()).first().id for skill in skill_list ] except: return make_response( jsonify({"error": "Database Connection Problem."}), 500) result_lists = [] # Return Users if form.search_type.data == 0: for skill_id in skill_ids: try: user_ids = [ user_skill.user_id for user_skill in UserSkills.query.filter_by( skill_id=skill_id).all() ] except: return make_response( jsonify({"error": "Database Connection Problem."}), 500) result_lists.append(set(user_ids)) result_list = set.intersection(*result_lists) result_response = [] for user_id in result_list: try: user = User.query.get(user_id) result_response.append({ "id": user.id, "name": user.name, "surname": user.surname, "profile_photo": profile_photo_link(user.profile_photo, user.id), "job": Jobs.query.get(user.job_id).name, "institution": user.institution }) except: return make_response( jsonify({"error": "Database Connection Problem."}), 500) else: for skill_id in skill_ids: try: ws_ids = [ ws_skill.workspace_id for ws_skill in WorkspaceSkill.query.filter_by( skill_id=skill_id).all() ] except: return make_response( jsonify({"error": "Database Connection Problem."}), 500) result_lists.append(set(ws_ids)) result_list = set.intersection(*result_lists) result_response = [] for ws_id in result_list: try: ws = Workspace.query.get(ws_id) except: return make_response( jsonify({"error": "Database Connection Problem."}), 500) if ws.is_private: continue try: contributors = Contribution.query.filter( Contribution.workspace_id == ws.id).all() except: return make_response( jsonify({"error": "Database Connection Error"}), 500) contributor_list = [] for contributor in contributors: try: user = User.query.get(contributor.user_id) except: return make_response( jsonify({"error": "Database Connection Error"}), 500) contributor_list.append({ "id": user.id, "name": user.name, "surname": user.surname }) try: creator_info = User.query.filter( User.id == ws.creator_id).first() except: return make_response( jsonify({"error": "Database Connection Error"}), 500) result_response.append({ "id": ws.id, "title": ws.title, "is_private": int(ws.is_private), "description": ws.description, "state": ws.state, "deadline": ws.deadline, "creation_time": ws.timestamp, "max_contributors": ws.max_collaborators, "contributor_list": contributor_list, "creator_id": creator_info.id, "creator_name": creator_info.name, "creator_surname": creator_info.surname }) # Apply Pagination number_of_pages = 1 if form.page.data is not None and form.per_page.data is not None: per_page = form.per_page.data number_of_pages = math.ceil(len(result_list) / per_page) page = form.page.data if form.page.data < number_of_pages else number_of_pages - 1 result_response = result_response[page * per_page:(page + 1) * per_page] return make_response( jsonify({ "result_list": result_response, "number_of_pages": number_of_pages }), 200 + form.search_type.data) else: return make_response( jsonify({"error": "Missing data fields or invalid data."}), 400)
def get(self): form = UserSearchForm(request.args) if form.validate(): search_query = form.search_query.data.lower() # Remove the punctuation in the search query search_query = SearchEngine.remove_punctuation(search_query) # Tokenize the search query tokens = search_query.split() # Get stopwords form the API stopwords = SearchEngine.get_stopwords() # Remove stopwords from the list of tokens tokens = list(set(tokens) - set(stopwords)) # Get the semantically related list for our tokens tokens = SearchEngine.semantic_related_list(tokens) # List of user dictionaries that will be send as a search output result_list = [] # Score of each user record result_id_score = [] # Search tokens in Jobs Table for token, score in tokens: try: related_job = Jobs.query.filter( func.lower(Jobs.name) == token).first() except: return make_response( jsonify({"error": "Database Connection Problem."}), 500) if related_job is not None: try: owner_list = User.query.filter( User.job_id == related_job.id).all() except: return make_response( jsonify({"error": "Database Connection Problem."}), 500) for user in owner_list: id_list = [i[0] for i in result_id_score] if user.id not in id_list: if user.is_valid == 0: continue result_list.append({ "id": user.id, "name": user.name, "surname": user.surname, "profile_photo": profile_photo_link(user.profile_photo, user.id), "is_private": int(user.is_private), "job_id": user.job_id }) result_id_score.append((user.id, score)) else: id_index = id_list.index(user.id) result_id_score[id_index] = ( user.id, result_id_score[id_index][1] + score) # Search tokens in Skills Table for token, score in tokens: try: related_skill = Skills.query.filter( func.lower(Skills.name) == token).first() except: return make_response( jsonify({"error": "Database Connection Problem."}), 500) if related_skill is not None: try: owner_id_list = UserSkills.query.filter( UserSkills.skill_id == related_skill.id).all() except: return make_response( jsonify({"error": "Database Connection Problem."}), 500) for owner_id in owner_id_list: # Creates the list of currently found ids id_list = [i[0] for i in result_id_score] if owner_id.user_id not in id_list: # Take user information from the DB try: user = User.query.filter( User.id == owner_id.user_id).first() except: return make_response( jsonify({ "error": "Database Connection Problem." }), 500) if user.is_valid == 0: continue result_list.append({ "id": user.id, "name": user.name, "surname": user.surname, "profile_photo": profile_photo_link(user.profile_photo, user.id), "is_private": int(user.is_private), "job_id": user.job_id }) result_id_score.append((user.id, score)) else: id_index = id_list.index(owner_id.user_id) result_id_score[id_index] = ( user.id, result_id_score[id_index][1] + score) # Search tokens for name, surname, institution or email match for token, score in tokens: try: query = '(LOWER(name) REGEXP ".*{0}.*" OR LOWER(surname) REGEXP ".*{0}.*" \ OR LOWER(`e_mail`) REGEXP ".*{0}.*" OR LOWER(institution) REGEXP ".*{0}.*")' \ .format(token) sql_statement = "SELECT id,name,surname,profile_photo,is_private,job_id,is_valid FROM users WHERE {}".format( query) result = db.engine.execute(sql_statement) for user in result: id_list = [i[0] for i in result_id_score] if user[0] not in id_list: if user[-1] == 0: continue result_list.append({ "id": user[0], "name": user[1], "surname": user[2], "profile_photo": profile_photo_link(user[3], user[0]), "is_private": int(user[4]), "job_id": user.job_id }) result_id_score.append((user[0], score)) else: id_index = id_list.index(user[0]) result_id_score[id_index] = ( user[0], result_id_score[id_index][1] + score) except: return make_response( jsonify({"error": "Database Connection Problem."}), 500) sorted_result_list = [] # Sort result ids according to their scores if form.sorting_criteria.data is None: sorted_id_list = SearchEngine.sort_ids(result_id_score) for user_id, score in sorted_id_list: index = [user["id"] for user in result_list].index(user_id) sorted_result_list.append(result_list[index]) # Sort Results according to Sorting Criteria else: reverse = form.sorting_criteria.data == 1 sorted_result_list = SearchEngine.sort_results( result_list, ["name", "surname"], reverse) # Apply given filters if form.job_filter.data is not None: for i, user in enumerate(sorted_result_list): if user["job_id"] != form.job_filter.data: sorted_result_list.pop(i) number_of_pages = 1 # Apply Pagination if form.page.data is not None and form.per_page.data is not None: per_page = form.per_page.data number_of_pages = math.ceil(len(sorted_result_list) / per_page) page = form.page.data if form.page.data < number_of_pages else number_of_pages - 1 sorted_result_list = sorted_result_list[page * per_page:(page + 1) * per_page] # Add Search History Item try: auth_token = request.headers.get('auth_token') SearchEngine.add_search_history_item(decode_token(auth_token), search_query, int(SearchType.USER)) except: pass # Remove Non-Valid Users return make_response( jsonify({ "number_of_pages": number_of_pages, "result_list": sorted_result_list })) return make_response( jsonify({"error": "Missing data fields or invalid data."}), 400)