def handle_connection_fetch(): """ Fetches all of the users that the calling user is connected with Params: (token) Returns JSON: { users: [ { user_id, email, username, profile_img_url, summary, first_name, last_name, location, education, ... other bio fields }, ... ] } """ token = request.args.get("token") calling_user = get_user_from_token(token) printColour(" ➤ Connections: {} is fetching a list of their existing connections".format({ calling_user.username }), colour="blue") return jsonify(connections.connection_fetch_users(token))
def handle_connection_send_message(token, user_id, message, room): try: connection_send_message(token, user_id, message) except InputError as err: emit_error(err.get_message()) printColour("Client sent a direct message to {}".format(user_id)) emit("receive_connection_message", "The server says: your chat partner has sent a new message", broadcast=True, room=room)
def handle_connection_remove_message(token, message_id, room): try: connection_remove_message(token, message_id) except InputError as err: emit_error(err.get_message()) printColour("Client removed a direct message") emit("connection_message_removed", "The server says: your chat partner has removed a message", broadcast=True, room=room)
def handle_auth_logout(): """ HTTP Route: /auth/logout HTTP Method: POST Params: (token) Returns JSON: { } """ request_data = request.get_json() printColour(" ➤ Logged out: {}".format(request_data["token"]), colour="blue") return jsonify(auth_logout(request_data["token"]))
def handle_users_all(): """ HTTP Route: /users/all HTTP Method: GET Params: (token) Returns JSON: { users } Where users: array of objects { user_id, email, username, profile_img_url } """ token = request.args.get("token") printColour(" ➤ User List All: Getting all list of all users", colour="blue") return jsonify(users.users_all(token))
def handle_auth_login(): """ HTTP Route: /auth/login HTTP Method: POST Params: (email, password) Returns JSON: { token, user_id, username, profile_img_url } """ request_data = request.get_json() email = request_data["email"] password = request_data['password'] printColour(" ➤ Logged in: {}".format(email), colour="blue") return jsonify(auth_login(email, password))
def handle_auth_signup(): """ HTTP Route: /auth/register HTTP Method: POST Params: (email, username, password) Returns JSON: { token, user_id, username, profile_img_url } """ request_data = request.get_json() email = request_data["email"] password = request_data["password"] username = request_data["username"] printColour(" ➤ Signed up: {}, {}".format(username, email), colour="blue") return jsonify(auth_signup(email, password, username))
def handle_user_profile(): """ HTTP Route: /users/profile HTTP Method: GET Params: (token, user_id) Returns JSON: { user_id, email, username, profile_img_url, is_connected_to, connection_is_pending } """ token = request.args.get("token") user_id = int(request.args.get("user_id")) user = get_user_from_id(user_id) printColour(" ➤ User Profile: Fetching user profile data: {}".format( user.username), colour="blue") return jsonify(users.users_profile(token, user_id))
def handle_user_get_channels(): """ HTTP Route: /users/profile/channels HTTP Method: GET Params: (token, user_id) Returns JSON: { channels: [{ channel_id, name, description, visibility, member_of, owner_of }, ...] } """ request_data = request.get_json() token = request.args.get("token") user_id = int(request.args.get("user_id")) printColour(" ➤ User Profile Channels: getting channels", colour="blue") return jsonify(users.user_channels_list(token, user_id))
def handle_users_bio_fetch(): """ HTTP Route: /users/bio HTTP Method: GET Params: (token, user_id) Returns JSON: { first_name, last_name, cover_img_url, summary, location, title, education } """ token = request.args.get("token") user_id = int(request.args.get("user_id")) user = get_user_from_id(user_id) printColour(" ➤ User Bio: Fetching user {}'s bio".format(user.username), colour="blue") return jsonify(users.users_bio_fetch(token, user_id))
def handle_user_profile_upload_photo(): """ HTTP Route: /users/profile/uploadphoto HTTP Method: POST Params: (token, user_id, x_start, y_start, x_end, y_end, file) Returns JSON: { succeeded } """ token = request.form["token"] user_id = request.form["user_id"] x_start = int(request.form["x_start"]) y_start = int(request.form["y_start"]) x_end = int(request.form["x_end"]) y_end = int(request.form["y_end"]) user = get_user_from_id(user_id) printColour( " ➤ User Profile Upload Photo: Uploading profile picture image for {}". format(user.username), colour="blue") printColour(" ➤ Crop coordinates: start = ({}, {}), end = ({}, {})".format( x_start, y_start, x_end, y_end), colour="cyan") # check if the post request has the file part if 'file' not in request.files: printColour(" ➤ User didn't upload a photo", colour="red") return jsonify({"succeeded": False}) else: file = request.files['file'] if file.filename == '': # If user does not select file, browser also submits an empty part without filename printColour(" ➤ No selected file", colour="red") return jsonify({"succeeded": False}) if file and allowed_file(file.filename): # Saving the image to local storage filename = get_latest_filename( "user_{}_profile.jpg".format(user_id)) file.save(os.path.join(UPLOAD_FOLDER, filename)) crop_image_file(filename, x_start, y_start, x_end, y_end) # Saving the image endpoint to the user's bio tuple under the profile_img_url field image_endpoint = "{0}/images/{1}".format(BASE_URL, filename) users.users_profile_upload_photo(token, user_id, image_endpoint) printColour( " ➤ Successfully uploaded profile image for {}. Available at: {}" .format(user.username, image_endpoint), colour="green", bordersOn=False) return jsonify({"succeeded": True})
def handle_channels_listall(): """ HTTP Route: /channels/listall HTTP Method: GET Params: (token) Returns JSON: { channels: [{ channel_id, name, description, visibility, member_of, owner_of }, ...] } """ token = request.args.get("token") calling_user = get_user_from_token(token) printColour( " ➤ Channel List All: {} fetched a list of channels they belong to". format(calling_user.username), colour="blue") return jsonify(channels.channels_listall(token))
def handle_user_channel_leave(event_data): """ Parameter event_data is a dictionary containing: - token - room """ token = event_data["token"] user = get_user_from_token(token) room = event_data["room"] leave_room(room) printColour( " ➤ Socket event: connection_user_leave. User {} left channel {}". format(user.username, room), colour="cyan", bordersOn=False)
def handle_user_profile_update(): """ HTTP Route: /users/profile HTTP Method: POST Params: (token, email, username) Returns JSON: { } """ request_data = request.get_json() token = request_data["token"] email = request_data["email"] username = request_data["username"] printColour( " ➤ User Profile Update: setting username to {}, email to {}".format( username, email), colour="blue") return jsonify(users.users_profile_update(token, email, username))
def handle_connection_outgoing(): """ Fetches all of the users that the calling user has sent requests to Params: (token) Returns JSON: { users: [ { user_id, email, username, profile_img_url }, ... ] } """ token = request.args.get("token") calling_user = get_user_from_token(token) printColour(" ➤ Connections: {} is fetching a list of their outgoing connections".format( calling_user.username ), colour="blue") return jsonify(connections.connection_fetch_outgoing_users(token))
def handle_channel_details(): """ HTTP Route: /channels/details HTTP Method: GET Params: (token, channel_id) Returns JSON: { name, description, visibility, channel_img_url, owner_members, all_members } """ token = request.args.get("token") channel_id = int(request.args.get("channel_id")) target_channel = select_channel(channel_id) calling_user = get_user_from_token(token) printColour(" ➤ Channel Details: {}'s details fetched by {}".format( target_channel.name, calling_user.username), colour="blue") return jsonify(channels.channels_details(token, channel_id))
def handle_connection_get_info(): """ Fetches details regarding the connection between two users Params: (token, user_id) Returns JSON: { is_connected, connection_is_pending, is_requester } """ token = request.args.get("token") user_id = int(request.args.get("user_id")) calling_user = get_user_from_token(token) target_user = get_user_from_id(user_id) printColour(" ➤ Connections: {} is fetching connection details with {}".format( calling_user.username, target_user.username ), colour="blue") return jsonify(connections.connection_fetch_info(token, user_id))
def handle_remove_message(token, message_id, room): calling_user = get_user_from_token(token) printColour( " ➤ Socket event: remove_message. Channel message {} was edited by {}". format(message_id, calling_user.username), colour="cyan", bordersOn=False) printColour(" ➤ Emitting event: message_removed", colour="cyan", bordersOn=False) try: message_remove(token, message_id) except InputError as err: emit_error(err.get_message()) emit("message_removed", "The server says: someone has deleted a message", broadcast=True, room=room)
def handle_conection_remove_message(): """ HTTP Route: /connections/message HTTP Method: DELETE Params: (token, message_id) Returns JSON: { } """ request_data = request.get_json() token = request_data["token"] message_id = int(request_data["message_id"]) calling_user = get_user_from_token(token) printColour(" ➤ Connections Messages: {} removed message id: {}".format( calling_user.username, message_id ), colour="blue") return jsonify(connections.connection_remove_message(token, message_id))
def handle_channel_messages(): """ HTTP Route: /channels/messages HTTP Method: GET Params: (token, channel_id, start) Returns JSON: { messages, exhausted } """ token = request.args.get("token") channel_id = int(request.args.get("channel_id")) start = int(request.args.get("start")) target_channel = select_channel(channel_id) calling_user = get_user_from_token(token) printColour(" ➤ Channel Messages: {}'s messages fetched by {}".format( target_channel.name, calling_user.username), colour="blue") return jsonify(channels.channels_messages(token, channel_id, start))
def handle_channel_leave(): """ HTTP Route: /channels/leave HTTP Method: POST Params: (token, channel_id) Returns JSON: { } """ request_data = request.get_json() token = request_data["token"] channel_id = int(request_data["channel_id"]) target_channel = select_channel(channel_id) calling_user = get_user_from_token(token) printColour(" ➤ Channel Leave: {} left channel {}".format( calling_user.username, target_channel.name), colour="blue") return jsonify(channels.channels_leave(token, channel_id))
def handle_conection_request(): """ HTTP Route: /connections/request HTTP Method: POST Params: (token, user_id) Returns JSON: { } """ request_data = request.get_json() token = request_data["token"] user_id = int(request_data["user_id"]) calling_user = get_user_from_token(token) target_user = get_user_from_id(user_id) printColour(" ➤ Connections Request: {} sent a connection request to {}".format( calling_user.username, target_user.username ), colour="blue") return jsonify(connections.connection_request(token, user_id))
def handle_conection_fetch_messages(): """ HTTP Route: /connections/message HTTP Method: GET Params: (token, user_id) Returns JSON: { messages: [ { message_id, message, sender_id, time_created } ] } """ token = request.args.get("token") user_id = int(request.args.get("user_id")) calling_user = get_user_from_token(token) target_user = get_user_from_id(user_id) printColour(" ➤ Connections Messages: {} fetched messages with {}".format( calling_user.username, target_user.username ), colour="blue") return jsonify(connections.connection_fetch_messages(token, user_id))
def on_join(event_data): """ Parameter event_data is a dictionary containing: - token - user_id - room """ token = event_data["token"] calling_user = get_user_from_token(token) target_user = get_user_from_id(int(event_data["user_id"])) room = str(get_connection(calling_user.id, target_user.id).id) join_room(room) printColour( " ➤ Socket event: connection_user_enter. User {} started connection chat with {} (room: {})" .format(calling_user.username, target_user.username, room), colour="cyan", bordersOn=False) emit("connection_user_entered", room, broadcast=True, room=room)
def on_join(event_data): """ Parameter event_data is a dictionary containing: - token - user_id - channel_id - room """ token = event_data["token"] user = get_user_from_token(token) room = event_data["room"] join_room(room) printColour( " ➤ Socket event: user_enter. User {} entered channel {}".format( user.username, room), colour="cyan", bordersOn=False) emit("user_entered", broadcast=True, room=room)
def handle_channel_add_owner(): """ HTTP Route: /channels/addowner HTTP Method: POST Params: (token, channel_id, user_id) Returns JSON: { } """ request_data = request.get_json() token = request_data["token"] channel_id = int(request_data["channel_id"]) user_id = int(request_data["user_id"]) target_channel = select_channel(channel_id) calling_user = get_user_from_token(token) target_user = get_user_from_id(user_id) printColour(" ➤ Channel Add Owner: {} added {} as an owner in {}".format( calling_user.username, target_user.username, target_channel.name), colour="blue") return jsonify(channels.channels_addowner(token, channel_id, user_id))
def handle_send_message(token, channel_id, message, room): calling_user = get_user_from_token(token) target_channel = select_channel(channel_id) printColour( " ➤ Socket event: send_message. Message sent by {} to channel {}". format(calling_user.username, target_channel.name), colour="cyan") printColour(" ➤ Emitting event: receive_message", colour="cyan", bordersOn=False) try: message_send(token, int(channel_id), message) except InputError as err: emit_error(err.get_message()) # Broadcast the newly sent message to all listening client sockets so the # chat field updates in 'realtime' emit("receive_message", "The server says: someone has sent a new message", broadcast=True, room=room)
def error_handler(err): """ Default error handler """ response = err.get_response() try: printColour(" ➤ Error: {} {}".format(err, err.get_message()), colour="red") response.data = dumps({ "code": err.code, "name": "System Error", "message": err.get_message(), }) response.content_type = 'application/json' return response except: printColour(" ➤ Error: {}".format(err), colour="red") response.data = dumps({"code": err.code, "name": "System Error"}) response.content_type = 'application/json' return response
def handle_conection_send_message(): """ HTTP Route: /connections/message HTTP Method: POST Params: (token, user_id, message) Returns JSON: { } """ request_data = request.get_json() token = request_data["token"] user_id = int(request_data["user_id"]) message = request_data["message"] calling_user = get_user_from_token(token) target_user = get_user_from_id(user_id) printColour(" ➤ Connections Messages: {} sent a message to {}".format( calling_user.username, target_user.username ), colour="blue") return jsonify(connections.connection_send_message(token, user_id, message))
def handle_search(): """ HTTP Route: /channels/search HTTP Method: GET Params: (token, channel_id, query_str) Returns JSON: { messages: [ { message_id, u_id, message, time_created, reacts }, ...] } """ token = request.args.get("token") channel_id = request.args.get("channel_id") query_str = request.args.get("query_str") calling_user = get_user_from_token(token) target_channel = select_channel(channel_id) printColour( " ➤ Channel Search: {} looking for '{}' in {}'s messages".format( calling_user.username, query_str, target_channel.name), colour="blue") return jsonify(messages.messages_search_match(token, channel_id, query_str))