def http_standup_start():
"""
http_standup_start:
For a given channel, start the stand up period whereby for the next "length" seconds if someone calls "standup_send" with a message, it is buffered during the X second window then at the end of the X second window a message will be added to the message queue in the channel from the user who started the standup. X is an integer that denotes the number of seconds that the standup occurs for
Input:
- (JSON) {token, channel_id, length}
Output:
- (JSON) {time_finish}
"""
# Get input and server data
input_data = request.get_json()
server_data = get_server_data_obj()
channel_id = input_handle_ids(input_data["channel_id"])
length = input_handle_ids(input_data["length"])
output = standup_start(server_data, input_data["token"], channel_id,
length)
#create a multithread on the standup
thread = threading.Thread(target=standup_handler,
args=(channel_id, int(output["time_finish"])))
thread.start()
return dumps(output)
def http_message_sendlater():
"""
http_message_sendlater:
Send a message from authorized_user to the channel specified by channel_id automatically at a secified time in the future
Input:
- (JSON) {token, channel_id, message, time_sent}
Output:
- (JSON) {message_id}
"""
# Get input and server data
input_data = request.get_json()
server_data = get_server_data_obj()
channel_id = input_handle_ids(input_data["channel_id"])
# Construct the necessary information here
message_info = process_message_infos(server_data, input_data["token"],
channel_id, input_data["message"],
int(input_data["time_sent"]))
queue = get_message_queue()
queue.append(message_info)
return dumps({"message_id": message_info["message_id"]})
def http_admin_userpermission_change():
"""
http_admin_userpermission_change:
Given a user by their u_id, set their permission to new permissions described by permission_id
Input:
- (JSON) {token, u_id, permission_id}
Output:
- (JSON) {}
"""
# Get input and server data
input_data = request.get_json()
server_data = get_server_data_obj()
u_id = input_handle_ids(input_data["u_id"])
permission_id = input_handle_ids(input_data["permission_id"])
output_data = admin_userpermission_change(server_data, input_data["token"],
u_id, permission_id)
return dumps(output_data)
def http_message_unreact():
"""
http_message_unreact:
Given a message within a channel the authorized user is a part of, remove a react to that particular message
Input:
- (JSON) {token, message_id, react_id}
Output:
- (JSON) {}
"""
# Get input and server data
input_data = request.get_json()
server_data = get_server_data_obj()
message_id = input_handle_ids(input_data["message_id"])
react_id = input_handle_ids(input_data["react_id"])
output_data = message_unreact(server_data, input_data["token"], message_id,
react_id)
return dumps(output_data)
def http_channel_removeowner():
"""
http_channel_removeowner:
Remove user with u_id an owner of this channel
Input:
- (JSON) {token, channel_id, u_id}
Output:
- (JSON) {}
"""
# Get input and server data
input_data = request.get_json()
server_data = get_server_data_obj()
channel_id = input_handle_ids(input_data["channel_id"])
u_id = input_handle_ids(input_data["u_id"])
output_data = channel_removeowner(server_data, input_data["token"],
channel_id, u_id)
return dumps(output_data)
def http_channel_messages():
"""
http_channel_messages:
Given a channel with channel_id that the user is a part of, return up to 50 messages between index start and start+50 exclusive. 0 is the most recent message
Input:
- (URL) {token, channel_id, start}
Output:
- (JSON) {message, start, end}
"""
# Get input and server data
input_token = request.args.get("token")
input_channel_id = input_handle_ids(request.args.get("channel_id"))
input_start = input_handle_ids(request.args.get("start"))
server_data = get_server_data_obj()
output_data = channel_messages(server_data, input_token, input_channel_id,
input_start)
return dumps(output_data)
def http_channel_invite():
"""
http_channel_invite:
Invites a user to join a channel with channel_id. Once invited the user is added to the channel immediately
Input:
- (JSON) {token, channel_id, u_id}
Output:
- (JSON) {}
"""
# Get input and server data
channel_id = -1
u_id = -1
input_data = request.get_json()
server_data = get_server_data_obj()
channel_id = input_handle_ids(input_data["channel_id"])
u_id = input_handle_ids(input_data["u_id"])
output_data = channel_invite(server_data, input_data["token"], channel_id,
u_id)
return dumps(output_data)
def http_admin_remove_user():
"""
http_admin_remove_user:
Remove the user from the server
Input:
- (JSON) {token, u_id}
Output:
- (JSON) {}
"""
server_data = get_server_data_obj()
input_data = request.get_json()
u_id = input_handle_ids(input_data["u_id"])
remove_user(server_data, input_data["token"], u_id)
return dumps({})
def http_standup_active():
"""
http_standup_active:
For a given channel, return whether a standup is active in it, and what time the standup finishes. If no standup is active then time_finish returns None
Input:
- (URL) {token, channel_id}
Output:
- (JSON) {is_active, time_finish}
"""
# Get input and server data
input_token = request.args.get("token")
input_channel_id = input_handle_ids(request.args.get("channel_id"))
server_data = get_server_data_obj()
output = standup_active(server_data, input_token, input_channel_id)
return dumps(output)
def http_message_remove():
"""
http_message_remove:
Given a message_id for a message, this message is removed from the channel
Input:
- (JSON) {token, message_id}
Output:
- (JSON) {}
"""
# Get input and server data
input_data = request.get_json()
server_data = get_server_data_obj()
message_id = input_handle_ids(input_data["message_id"])
output_data = message_remove(server_data, input_data["token"], message_id)
return dumps(output_data)
def http_message_unpin():
"""
http_message_unpin:
Given a message within a channel, mark it as unpinned
Input:
- (JSON) {token, message_id}
Output:
- (JSON) {}
"""
# Get input and server data
input_data = request.get_json()
server_data = get_server_data_obj()
message_id = input_handle_ids(input_data["message_id"])
output_data = message_unpin(server_data, input_data["token"], message_id)
return dumps(output_data)
def http_message_pin():
"""
http_message_pin:
Given a message within a channel, mark it as pinned to be given special display treatment by the front end
Input:
- (JSON) {token, message_id}
Output:
- (JSON) {}
"""
# Get input and server data
input_data = request.get_json()
server_data = get_server_data_obj()
message_id = input_handle_ids(input_data["message_id"])
output_data = message_pin(server_data, input_data["token"], message_id)
return dumps(output_data)
def http_channel_join():
"""
http_channel_join:
Given a channel_id of a channel that the authorized user can join, adds them to that channel
Input:
- (JSON) {token, channel_id}
Output:
- (JSON) {}
"""
# Get input and server data
input_data = request.get_json()
server_data = get_server_data_obj()
channel_id = input_handle_ids(input_data["channel_id"])
output_data = channel_join(server_data, input_data["token"], channel_id)
return dumps(output_data)
def http_channel_leave():
"""
http_channel_leave:
Gievn a channel ID, the user removed as a member of this channel
Input:
- (JSON) {token, channel_id}
Output:
- (JSON) {}
"""
# Get input and server data
input_data = request.get_json()
server_data = get_server_data_obj()
channel_id = input_handle_ids(input_data["channel_id"])
output_data = channel_leave(server_data, input_data["token"], channel_id)
return dumps(output_data)
def http_standup_send():
"""
http_standup_send:
Sending a message to get buffered in the standup queue, assuming a standup is currently active
Input:
- (JSON) {token, channel_id, message}
Output:
- (JSON) {}
"""
# Get input and server data
input_data = request.get_json()
server_data = get_server_data_obj()
channel_id = input_handle_ids(input_data["channel_id"])
output = standup_send(server_data, input_data["token"], channel_id,
input_data["message"])
return dumps(output)
def http_user_profile():
"""
http_user_profile:
For a valid user, returns information about their user_id, email, first name, last name and handle
Input:
- (URL) {token, u_id}
Output:
- (JSON) {user}
"""
# Get input and server data
input_token = request.args.get("token")
input_u_id = input_handle_ids(request.args.get("u_id"))
server_data = get_server_data_obj()
output_data = user_profile(server_data, input_token, input_u_id)
return dumps(output_data)
def http_message_send():
"""
http_message_send:
Send a message from authorised_user to the channel specified by channel_id
Input:
- (JSON) {token, channel_id, message}
Output:
- (JSON) {message_id}
"""
# Get input and server data
input_data = request.get_json()
server_data = get_server_data_obj()
channel_id = input_handle_ids(input_data["channel_id"])
output_data = message_send(server_data, input_data["token"], channel_id,
input_data["message"])
return dumps(output_data)
def http_channel_details():
"""
http_channel_details:
Given a channel with channel_id that the authorized user is a part of, provide basic details about the channel
Input:
- (URL) {token, channel_id}
Output:
- (JSON) {name, owner_members, all_members}
"""
# Get input and server data
input_token = request.args.get("token")
input_channel_id = input_handle_ids(request.args.get("channel_id"))
server_data = get_server_data_obj()
output_data = channel_details(server_data, input_token, input_channel_id)
return dumps(output_data)
def http_message_edit():
"""
http_message_edit:
Given a message, update it's text with new text. If new message is an empty string, the message is deleted.
Input:
- (JSON) {token, message_id, message}
Output:
- (JSON) {}
"""
# Get input and server data
input_data = request.get_json()
server_data = get_server_data_obj()
message_id = input_handle_ids(input_data["message_id"])
if not input_data["message"]:
output_data = message_remove(server_data, input_data["token"],
message_id)
else:
output_data = message_edit(server_data, input_data["token"],
message_id, input_data["message"])
return dumps(output_data)
