def message_share_v1(token, og_message_id, message, channel_id, dm_id): with open('src/data.json', 'r') as FILE: data = json.load(FILE) # check token shareid = None for i in range(len(data['users'])): if data['users'][i]['token'] == token: shareid = data["users"][i]["u_id"] if shareid is None: raise AccessError("Invalid token") # check whether user is part of the channel/dm if channel_id == -1: if check_user_in_dm(shareid, dm_id) == False: raise AccessError("Authorised user is not part of the channel") new_message = message + "\n\"\"\"\n" + data["messages"][og_message_id][ "message"] + "\n\"\"\"" shared_message_id = message_senddm_v1(token, dm_id, new_message) if dm_id == -1: if check_user_in_channel(shareid, channel_id) == False: raise AccessError("Authorised user needs to be a member of the dm") new_message = message + "\n\"\"\"\n" + data["messages"][og_message_id][ "message"] + "\n\"\"\"" shared_message_id = message_send_v2(token, channel_id, new_message) return { 'shared_message_id': shared_message_id["message_id"], }
def admin_userpermission_change_v1(token, u_id, permission_id): # token check if check_token_valid(token) is False: raise AccessError("Invalid Token") if permission_id is not 1 and permission_id is not 2: raise InputError("Invalid permission_id") if not check_user_exists(u_id): raise InputError("invalid u_id") with open('src/data.json', 'r') as FILE: data = json.load(FILE) owner = False owner_id = convert_token(token) if data['users'][owner_id]['permission_id'] == 1: owner = True if owner == True: for i in range(len(data['users'])): if u_id == data['users'][i]['u_id']: data['users'][i]['permission_id'] = permission_id else: raise AccessError("Unauthorised user, user is not an owner") with open ('src/data.json', 'w') as FILE: json.dump(data, FILE, indent = 4) return { }
def channel_addowner_v1(token, channel_id, u_id): with open('src/data.json', 'r') as FILE: data = json.load(FILE) # check that token is valid user_id = None for i in range(len(data['users'])): if data['users'][i]['token'] == token: user_id = data['users'][i]['u_id'] if user_id is None: raise AccessError("Invalid token") # check if the channel_id exists if check_channel_exists(channel_id) == False: raise InputError("Invalid channel") # check if the user is already an owner of the channel for i in range(len(data["channels"][channel_id]["owner_members"])): if data["channels"][channel_id]["owner_members"][i]["u_id"] == u_id: raise InputError("User already an owner") # check if u_id belongs to an existing member of the channel if check_user_in_channel(u_id, channel_id) == False: raise InputError( "User must be a member of the channel to become owner") dreamsowner = False channelowner = False # confirm if token belongs to a dream owner if data['users'][user_id]['permission_id'] == 1: dreamsowner = True # confirm if token belongs to an owner for i in range(len(data["channels"][channel_id]["owner_members"])): if data["channels"][channel_id]["owner_members"][i]["u_id"] == user_id: channelowner = True if dreamsowner or channelowner: # information of new owner to be added new_owner = { "u_id": u_id, 'email': data["users"][u_id]["email"], 'name_first': data["users"][u_id]["name_first"], 'name_last': data["users"][u_id]["name_last"], 'handle': data["users"][u_id]["handle"] } data["channels"][channel_id]["owner_members"].append(new_owner) else: raise AccessError("Unauthorised user, user is not an owner") with open('src/data.json', 'w') as FILE: json.dump(data, FILE, indent=4) notif_msg = data["users"][u_id][ "handle"] + " added you as owner in " + data["channels"][channel_id][ "name"] create_notifications(u_id, channel_id, -1, notif_msg) return {}
def dm_invite_v1(token, dm_id, u_id): with open('src/data.json', 'r') as FILE: data = json.load(FILE) inviteid = None # check that token is valid for i in range(len(data['users'])): if data['users'][i]['token'] == token: inviteid = data["users"][i]["u_id"] if inviteid is None: raise AccessError("Invalid token") # check if the dm_id exists if check_dm_exists(dm_id) == False: raise InputError("Invalid dm") # check if the u_id is valid if check_user_exists(u_id) == False: raise InputError("Invalid User") # checking if the person inviting is in the dm if check_user_in_dm(inviteid, dm_id) == False: raise AccessError("Authorised user needs to be a member of the dm") # checking if the person being invited is already in the dm if check_user_in_dm(u_id, dm_id) == True: raise InputError("User already a member of this dm") new_user = { 'u_id': u_id, 'email': data["users"][u_id]["email"], 'name_first': data["users"][u_id]["name_first"], 'name_last': data["users"][u_id]["name_last"], 'handle': data["users"][u_id]["handle"] } memberslist = data["dms"][dm_id]["name"].split(", ") memberslist.append(data["users"][u_id]["handle"]) sortedlist = sorted(memberslist, key=str.lower) final_list = ", ".join(sortedlist) #name = data["dms"][dm_id]["name"] + ", " + data["users"][u_id]["handle"] data["dms"][dm_id]["members"].append(new_user) data["dms"][dm_id]["name"] = final_list num_dms_joined = data["user_stats"][u_id]["stats"]["dms_joined"][-1][ "num_dms_joined"] + 1 dms_joined = { "num_dms_joined": num_dms_joined, "time_stamp": create_timestamp() } data["user_stats"][u_id]["stats"]["dms_joined"].append(dms_joined) with open('src/data.json', 'w') as FILE: json.dump(data, FILE, indent=4) notif_msg = data["users"][inviteid][ "handle"] + " added you to dm " + final_list create_notifications(u_id, -1, dm_id, notif_msg) calc_involement_rate(u_id) calc_utilisation_rate() return {}
def message_send_v2(token, channel_id, message): with open('src/data.json', 'r') as FILE: data = json.load(FILE) u_id = None for i in range(len(data['users'])): if data['users'][i]['token'] == token: u_id = data["users"][i]["u_id"] if u_id is None: raise AccessError("Invalid token") if len(message) > 1000: raise InputError("Message is longer than the 1000 character limit") if check_user_in_channel(u_id, channel_id) == False: raise AccessError("Authorised user is not part of the channel") dm_id = -1 new_message = { 'message_id': get_new_message_id(), 'u_id': u_id, 'message': message, 'time_created': create_timestamp(), 'channel_id': channel_id, 'dm_id': dm_id, 'reacts': [{ 'react_id': 1, 'u_ids': [], 'is_this_user_reacted': False }], 'is_pinned': False } data["messages"].append(new_message) num_messages_sent = data["user_stats"][u_id]["stats"]["messages_sent"][-1][ "num_messages_sent"] + 1 messages_sent = { "num_messages_sent": num_messages_sent, "time_stamp": create_timestamp() } data["user_stats"][u_id]["stats"]["messages_sent"].append(messages_sent) num_messages = data["dreams_stats"]["messages_exist"][-1][ "num_messages_exist"] + 1 dreams_messages = { "num_messages_exist": num_messages, "time_stamp": create_timestamp() } data["dreams_stats"]["messages_exist"].append(dreams_messages) with open('src/data.json', 'w') as FILE: json.dump(data, FILE, indent=4) calc_involement_rate(u_id) calc_utilisation_rate() return { 'message_id': new_message["message_id"], }
def message_edit_v2(token, message_id, message): ''' Arguments: token (string) - the token of the user who wants to create a channel message_id (int) - the id of the message being edited message (string) - the new message Exceptions: InputError - Message is more than 1000 characters or the message id refers to a deleted message AccessError - The authorised user has not joined the channel they are trying to post to Return value: Returns {} ''' # get data data = getData() # get id auth_user_id = findUser(token) # Checks that the length is not above 1000 characters if len(message) > 1000: raise InputError( description="Message must be less than 1000 characters") # Finds the message msg = get_message(message_id, data) if msg == -1: raise AccessError(description="Message does not exist") # Checks the message was sent by the user requesting to edit it or # the user is a channel owner if msg['u_id'] != auth_user_id and get_user_details( auth_user_id, data)['permission_id'] != 1: raise AccessError( description= "User requesting edit did not post message or not channel owner") # Delete the message if message is empty, updates the message if it isn't if message == '': remove_msg_from_channel_or_dm(data, msg) else: msg_key = data['messages'].index(msg) data['messages'][msg_key]['message'] = message # Sends notification send_msg_notification(data, token, message, msg['channel_id'], msg['dm_id'], False, -1) append_user_stats(findUser(token), data) append_dream_stats(findUser(token), data) writeData(data) return {}
def standup_active_v1(token, channel_id): """ For a given channel which the user is a part of, return whether or not there is an active standup running Parameters: token(str): the user's token channel_id(int): the channel_id that is being checked for an active standup Returns: dict with keys is_active (boolean), time_finish (int): -is_active: True or False based on whether or not there is a standup active -time_finish: If no standup running, key value would be None, else returns the unix timestamp of when the standup finishes """ data = getData() auth_user_id = find_user_id(token) if auth_user_id == False: raise AccessError(description = 'User is not a registered user') channel_id = int(channel_id) #input error if channel id not a valid channel channel_found = False if data.get("channels") != None: for channel in data["channels"]: if channel["channel_id"] == channel_id: channel_found = True if channel_found == False: raise InputError(description = 'Channel ID is not a valid channel') #assumes that only a user in the channel can check if a standup is running user_found = False for memb in data["channels"][channel_id - 1]['all_members']: if memb["u_id"] == auth_user_id: user_found = True if user_found == False: raise AccessError(description = 'User not in channel') time_finish = None is_active = False if data.get("active_standups") == None: time_finish = None is_active = False else: for i in data["active_standups"]: if i["channel_id"] == channel_id: time_finish = i["time_finish"] is_active = True return {'is_active': is_active, 'time_finish': time_finish }
def check_user_permissions(data, msg_key, auth_user_id): if data['messages'][msg_key]['dm_id'] == -1: channel_members = get_channel_members( data['messages'][msg_key]['channel_id'], data) if auth_user_id not in channel_members: raise AccessError("User not in channel") else: dm_members = get_dm_members(data['messages'][msg_key]['dm_id'], data) if auth_user_id not in dm_members: raise AccessError("User not in DM")
def channel_removeowner_v1(token, channel_id, u_id): with open('src/data.json', 'r') as FILE: data = json.load(FILE) # check that token is valid removeid = None for i in range(len(data['users'])): if data['users'][i]['token'] == token: removeid = data['users'][i]['u_id'] if removeid is None: raise AccessError("Invalid token") # check if the channel_id exists if check_channel_exists(channel_id) == False: raise InputError("Invalid channel") ownercheck = False index = 0 # make sure person being removed is an existing owner for i in range(len(data["channels"][channel_id]["owner_members"])): if data["channels"][channel_id]["owner_members"][i]["u_id"] == u_id: ownercheck = True index = i if ownercheck is False: raise InputError("User not an owner") dreamsowner = False channelowner = False if len(data["channels"][channel_id]["owner_members"]) == 1 and len( data["channels"][channel_id]["all_members"]) == 1: raise AccessError("Last member can not remove themselves as an owner") # check person trying to remove owner is a dreams owner if data['users'][removeid]['permission_id'] == 1: dreamsowner = True # check person trying to remove owner is a channel owner for i in range(len(data["channels"][channel_id]["owner_members"])): if data["channels"][channel_id]["owner_members"][i][ "u_id"] == removeid: channelowner = True if dreamsowner or channelowner: del data["channels"][channel_id]["owner_members"][index] else: raise AccessError("Unauthorised user, user is not an owner") with open('src/data.json', 'w') as FILE: json.dump(data, FILE, indent=4) notif_msg = data["users"][removeid][ "handle"] + " removed you as owner in " + data["channels"][channel_id][ "name"] create_notifications(u_id, channel_id, -1, notif_msg) return {}
def channel_leave_v1(token, channel_id): with open('src/data.json', 'r') as FILE: data = json.load(FILE) # check that token is valid u_id = None for i in range(len(data['users'])): if data['users'][i]['token'] == token: u_id = data["users"][i]["u_id"] if u_id is None: raise AccessError("Invalid token") # check if the channel_id exists if check_channel_exists(channel_id) == False: raise InputError("Invalid channel") # check that the user attempting to leave is a member of the channel if check_user_in_channel(u_id, channel_id) == False: raise AccessError( "Authorised user needs to be a member of the channel") with open('src/data.json') as FILE: data2 = json.load(FILE) for i in range(len(data2["channels"][channel_id]["all_members"])): if u_id == data2["channels"][channel_id]["all_members"][i]["u_id"]: del data2["channels"][channel_id]["all_members"][i] break for i in range(len(data2["channels"][channel_id]["owner_members"])): if u_id == data2["channels"][channel_id]["owner_members"][i]["u_id"]: del data2["channels"][channel_id]["owner_members"][i] if len( data2["channels"][channel_id]["owner_members"] ) == 0 and len(data2["channels"][channel_id]["all_members"]) > 0: data2["channels"][channel_id]["owner_members"].append( data2["channels"][channel_id]["all_members"][0]) break num_channels_joined = data["user_stats"][u_id]["stats"]["channels_joined"][ -1]["num_channels_joined"] - 1 channels_joined = { "num_channels_joined": num_channels_joined, "time_stamp": create_timestamp() } data2["user_stats"][u_id]["stats"]["channels_joined"].append( channels_joined) with open('src/data.json', 'w') as FILE: json.dump(data2, FILE, indent=4) calc_involement_rate(u_id) calc_utilisation_rate() return {}
def dm_remove_v1(token, dm_id): with open('src/data.json', 'r') as FILE: data = json.load(FILE) u_id = None # check that token is valid and that the token belongs to the owner for i in range(len(data['users'])): if data['users'][i]['token'] == token: u_id = data['users'][i]['u_id'] if u_id is None: raise AccessError("Invalid token") # check if the dm_id exists if check_dm_exists(dm_id) == False: raise InputError("Invalid dm") # check that the owner is attempting to remove if check_owner_of_dm(u_id, dm_id) == False: raise AccessError("Only the dm owner can delete this dm") for i in range(len(data["dms"])): if data["dms"][i]["dm_id"] == dm_id: for j in range(len(data["dms"][dm_id]["members"])): u_id = data["dms"][dm_id]["members"][j]["u_id"] num_dms_joined = data["user_stats"][u_id]["stats"][ "dms_joined"][-1]["num_dms_joined"] - 1 dms_joined = { "num_dms_joined": num_dms_joined, "time_stamp": create_timestamp() } data["user_stats"][u_id]["stats"]["dms_joined"].append( dms_joined) num_dms = data["dreams_stats"]["dms_exist"][-1]["num_dms_exist"] - 1 dreams_dms = {"num_dms_exist": num_dms, "time_stamp": create_timestamp()} data["dreams_stats"]["dms_exist"].append(dreams_dms) with open('src/data.json', 'w') as FILE: json.dump(data, FILE, indent=4) with open('src/data.json') as FILE: data2 = json.load(FILE) for i in range(len(data2["dms"])): if data2["dms"][i]["dm_id"] == dm_id: del data2["dms"][i] break with open('src/data.json', 'w') as FILE: json.dump(data2, FILE, indent=4) calc_involement_rate(u_id) for u_id in range(len(data["dms"][dm_id]["members"])): calc_involement_rate(u_id) calc_utilisation_rate() return {}
def standup_send_v1(token, channel_id, message): ''' Starts a standup in a channel for 'length' seconds. Arguments: token (string) - token of user starting standup channel_id (integer) - id of channel standup is in message (string) - buffered message that is sent to standup Exceptions: InputError - Occurs when channel_id does not refer to a valid channel - Occurs when the message is over 1000 characters in length (excluding the name of the user) - Occurs when there is no active standup in the channel AccessError - Occurs when the token passed in is not valid - Occurs when the authorised user is not already a member of the channel Return Value: Returns {} ''' # exception checks with open('src/data.json', 'r') as FILE: data = json.load(FILE) u_id = None for i in range(len(data['users'])): if data['users'][i]['token'] == token: u_id = data['users'][i]['u_id'] if u_id is None: raise AccessError("Invalid token") if check_channel_exists(channel_id) == False: raise InputError("Invalid channel") if check_user_in_channel(u_id, channel_id) == False: raise AccessError("Authorised user is not part of the channel") if len(message) > 1000: raise InputError("Message is longer than the 1000 character limit") standupActive = standup_active_v1(token, channel_id) if standupActive['is_active'] == False: raise InputError("No active standup running in this channel") with open('src/data.json', 'r') as FILE: data = json.load(FILE) for i in range(len(data['users'])): if data["users"][i]['token'] == token: firstName = data["users"][i]['name_first'] new_message = {'name': firstName, 'message': message} for i in range(len(data["standups"])): if data["standups"][i]["channel_id"] == channel_id: data["standups"][i]["messages"].append(new_message) return {}
def message_edit_v2(token, message_id, message): with open('src/data.json', 'r') as FILE: data = json.load(FILE) editorid = None for i in range(len(data['users'])): if data['users'][i]['token'] == token: editorid = data["users"][i]["u_id"] if editorid is None: raise AccessError("Invalid token") if len(message) > 1000: raise InputError("Message is longer than the 1000 character limit") # check to see if message exists if check_message_exists(message_id) == False: raise InputError("Message does not exist") # check to see if message is being edited by authorised user valid = True if check_message_sent_by_user(editorid, message_id) == False: valid = False # check to see if token belongs to the owner of channel being deleted for i in range(len(data["messages"])): if data["messages"][i]["message_id"] == message_id: channel_id = data["messages"][i]["channel_id"] if channel_id is not -1: for i in range(len(data["messages"])): if data["messages"][i]["message_id"] == message_id: channel_id = data["messages"][i]["channel_id"] for i in range(len(data["channels"][channel_id]["owner_members"])): if data["channels"][channel_id]["owner_members"][i][ "u_id"] == editorid: valid = True if valid == False: raise AccessError( "Authorised User is not the owner of this channel and did not send this message" ) else: if valid == False: raise AccessError( "Authorised User is not the owner of this dm and did not send this message" ) with open('src/data.json') as FILE: data2 = json.load(FILE) for i in range(len(data2["messages"]) - 1): if data2["messages"][i]["message_id"] == message_id: if message is '': del data2["messages"][i] else: data2["messages"][i]["message"] = message with open('src/data.json', 'w') as FILE: json.dump(data2, FILE, indent=4) return {}
def check_user_owners_permissions(data, msg_key, auth_user_id): if data['messages'][msg_key]['dm_id'] == -1: channel_members = get_channel_members( data['messages'][msg_key]['channel_id'], data) owner_members = get_channel_owners( data['messages'][msg_key]['channel_id'], data) if auth_user_id not in channel_members or auth_user_id not in owner_members: raise AccessError("User not in channel or not channel owner") else: dm_members = get_dm_members(data['messages'][msg_key]['dm_id'], data) if auth_user_id not in dm_members or auth_user_id != get_dm_owner( data['messages'][msg_key]['dm_id'], data): raise AccessError("User not in DM or not DM owner")
def channel_invite_v2(token, channel_id, u_id): ''' Summary: Invites a user (with user id u_id) to join a channel with ID channel_id. Once invited the user is added to the channel immediately. Args: token (string): A user session token channel_id (int): A channel_id number u_id (int): A user id Returns: empty dictionary Raises: InputError when: channel_id does not refer to a valid channel u_id does not refer to a valid user AccessError when: the authorised user is not already a member of the channel ''' global users, channels assert check_token(token) auth_user = user_from_token(token) if valid_channel(channel_id) == False: raise InputError(f"Channel ID {channel_id} is not a valid channel") if valid_user(u_id) == False: raise InputError(f"u_id {u_id} does not refer to a valid user") current_channel = find_channel( channel_id) #current channel with the given channel id invitee = user_from_id(u_id) if auth_user['u_id'] not in current_channel['all_members']: raise AccessError( f"Authorised user {auth_user['u_id']} is not a member of channel with channel_id {channel_id}" ) if u_id in current_channel['all_members']: raise AccessError( f"u_id {u_id} you are inviting is already inside the channel") current_channel['all_members'].append(u_id) if invitee[ 'permission'] == 1: # Dreams owner is automatically channel owner current_channel['owner_members'].append(u_id) invitee['channels'].append(channel_id) update_user_channel_stats(invitee['u_id']) send_channel_added_notification(auth_user['handle_str'], u_id, current_channel['channel_id']) return {}
def message_pin_v1(token, message_id): '''Summary Given a message within a channel or DM, mark it as "pinned" to be given special display treatment by the frontend Args: token (string): A user session token message_id (int): A message_id of the message Returns: A empty dictionary Raises: Raises: InputError when: message_id is not a valid message Message with ID message_id is already pinned AccessError when: The authorised user is not a member of the channel The authorised user is not a member of the DM that the message is within The authorised user is not an owner of the channel or DM ''' check_token(token) auth_user = user_from_token(token) if valid_message(message_id) == False: raise InputError("message_id is not a valid message") message = get_message_from_message_id(message_id) if message['is_pinned'] == True: raise InputError("Message with ID message_id is already pinned") if message['channel_id'] == -1: #this means this is a dm message current_dm = find_dm(message['dm_id']) if auth_user['u_id'] not in current_dm['members']: raise AccessError("The authorised user is not a member of the DM") if auth_user['u_id'] != current_dm[ 'creator']: # this error will get raised twice is this ok? / this is kinda redundent because if u have to be the owner to pin whats the point of checking for members? raise AccessError("The authorised user is not an owner of the DM") message['is_pinned'] = True if message['dm_id'] == -1: # this means this a channel message current_channel = find_channel(message['channel_id']) if auth_user['u_id'] not in current_channel['all_members']: raise AccessError( "The authorised user is not a member of the channel") if auth_user['u_id'] not in current_channel['owner_members']: raise AccessError( "The authorised user is not an owner of the channel") message['is_pinned'] = True return {}
def message_share_v1(token, og_message_id, message, channel_id, dm_id): ''' Summary: og_message_id is the original message. channel_id is the channel that the message is being shared to, and is -1 if it is being sent to a DM. dm_id is the DM that the message is being shared to, and is -1 if it is being sent to a channel. message is the optional message in addition to the shared message, and will be an empty string '' if no message is given Args: token (string): A user session token og_message_id (int): the message id of the original message message (string): a message string added to the shared message channel_id (int): A channel_id number -1 if we are sharing to dms dm_id (int): A message_id number -1 if send to we are sharing to channels Returns: dictionary which contains the shared_message_id Raises: AccessError when: the authorised user has not joined the channel or DM they are trying to share the message to ''' global users, channels, next_message_id, dms, messages assert check_token(token) auth_user_id = user_from_token(token)['u_id'] og_message_text = get_message_from_message_id(og_message_id)['message'] shared_message = message + '\n\n' + og_message_text is_channel_message = (channel_id != -1) shared_message_id = -1 if is_channel_message: if is_channel_member(auth_user_id, channel_id): shared_message_id = message_send_v2(token, channel_id, shared_message)['message_id'] else: raise AccessError( f"Authorised user with id {auth_user_id} has not joined the channel they are trying to share the message to" ) else: if is_dm_member(dm_id, auth_user_id): shared_message_id = message_senddm_v1(token, dm_id, shared_message)['message_id'] else: raise AccessError( f"Authorised user with id {auth_user_id} has not joined the DM they are trying to share the message to" ) return {'shared_message_id': shared_message_id}
def message_remove_v1(token, message_id): ''' Arguments: token (string) - the token of the user who wants to create a channel message_id (int) - the id of the message being removed Exceptions: InputError - Message id no longer exists AccessError - User did not send message and is not an owner of the channel/dm or dreams Return value: Returns {} ''' # get data data = getData() # get id auth_user_id = findUser(token) # Checks the message was sent by the user requesting to edit it or # the user is a channel owner msg = get_message(message_id, data) if msg == -1: raise AccessError(description="Message does not exist") chan_owners = [] if msg['channel_id'] != -1: chan = get_channel_details(msg, data) chan_owners = get_channel_owners(chan['channel_id'], data) if msg['u_id'] != auth_user_id and get_user_details( auth_user_id, data)['permission_id'] != 1 and auth_user_id not in chan_owners: raise AccessError( description= "User requesting edit did not post message or not channel/DREAMS owner" ) # Remove from channels/dms list remove_msg_from_channel_or_dm(data, msg) append_user_stats(findUser(token), data) append_dream_stats(findUser(token), data) writeData(data) return {}
def dm_leave_v1(token, dm_id): with open('src/data.json', 'r') as FILE: data = json.load(FILE) # check that token is valid leaveid = None for i in range(len(data['users'])): if data['users'][i]['token'] == token: leaveid = data["users"][i]["u_id"] if leaveid is None: raise AccessError("Invalid token") # check if the dm_id exists if check_dm_exists(dm_id) == False: raise InputError("Invalid dm") # check that the user attempting to leave is a member of the dm if check_user_in_dm(leaveid, dm_id) == False: raise AccessError("Authorised user needs to be a member of the dm") memberslist = data["dms"][dm_id]["name"].split(", ") memberslist.remove(data["users"][leaveid]["handle"]) final_list = ", ".join(memberslist) data["dms"][dm_id]["name"] = final_list for i in range(len(data["dms"][dm_id]["members"])): if leaveid == data["dms"][dm_id]["members"][i]["u_id"]: del data["dms"][dm_id]["members"][i] break for i in range(len(data["dms"][dm_id]["owner_members"])): if leaveid == data["dms"][dm_id]["owner_members"][i]["u_id"]: del data["dms"][dm_id]["owner_members"][i] data["dms"][dm_id]["owner_members"].append( data["dms"][dm_id]["members"][0]) num_dms_joined = data["user_stats"][leaveid]["stats"]["dms_joined"][-1][ "num_dms_joined"] - 1 dms_joined = { "num_dms_joined": num_dms_joined, "time_stamp": create_timestamp() } data["user_stats"][leaveid]["stats"]["dms_joined"].append(dms_joined) with open('src/data.json', 'w') as FILE: json.dump(data, FILE, indent=4) calc_involement_rate(leaveid) calc_utilisation_rate() return {}
def dm_leave_v1(token, dm_id): ''' Summary: Given a DM ID, the user is removed as a member of this DM Args: token (string): A user session token dm_id (int): A dm_id number Returns: a empty dictionary Raises: InputError when: dm_id is not a valid DM AccessError when: Authorised user is not a member of DM with dm_id ''' global users, channels, dms assert check_token(token) auth_user = user_from_token(token) if valid_dm(dm_id) == False: raise InputError(f"dm_id is not a valid DM") current_dm = find_dm(dm_id) #find the current dm if auth_user['u_id'] not in current_dm['members']: raise AccessError(f"Authorised user is not a member of DM with dm_id") # Remove dm from user's list of dms auth_user['dms'].remove(dm_id) update_user_dm_stats(auth_user['u_id']) # Remove user from dm's members list current_dm['members'].remove(auth_user['u_id']) return {}
def channel_details(token, channel_id): ''' returns a dictionary of information about the channel and it's users ''' user_id = check_token(token) if not is_valid_channel(channel_id): raise InputError(description="Invalid channel id") if not is_user_a_member(channel_id, user_id): raise AccessError( description="User does not have access to this channel") owner_members = [] all_members = [] for user_id in get_channel_owners(channel_id): member_info = get_member_information(user_id) owner_members.append(member_info) all_members.append(member_info) for user_id in get_channel_members(channel_id): member_info = get_member_information(user_id) all_members.append(member_info) return { 'name': get_channels()[channel_id]['name'], 'owner_members': owner_members, 'all_members': all_members }
def channels_listall_v2(token): ''' Provides a list of all channels (and their associated details) Arguments: auth_user_id (integer) - id of user whose channels are to be listed Exceptions: AccessError - Occurs when the authorised user does not have a corresponding u_id Return Value: { channels } ''' with open('src/data.json', 'r') as FILE: data = json.load(FILE) # check if token is valid - still have to do auth_user_id = None for i in range(len(data['users'])): if data['users'][i]['token'] == token: auth_user_id = int(data['users'][i]['u_id']) if auth_user_id is None: raise AccessError("Invalid token") userch = [] for channel in data['channels']: new_dict = { 'channel_id': channel["channel_id"], 'name': channel['name'] } userch.append(new_dict) return {'channels': userch}
def message_sendlater(token, channel_id, message, time_sent): ''' sends a message at a given time_sent, where time_sent is a unix timestamp greater than the current time. ''' u_id = check_token(token) if not is_valid_channel(channel_id): raise InputError(description="No channel exists with that ID") if not is_user_a_member(channel_id, u_id): raise AccessError(description='You are not a member of this channel') if len(message) > 1000 or len(message) < 1: raise InputError( description= 'Your message should be less than 1000 characters and at least 1 character' ) curr_time = get_current_timestamp() if curr_time >= time_sent: raise InputError(description="You can not send a message back in time") delay = time_sent - curr_time message_id = get_num_messages() set_num_messages(message_id + 1) message_template = create_message(u_id, message_id, time_sent, message) timer = Timer(delay, sendlater_end, args=[channel_id, message_template]) timer.start() return {'message_id': message_id}
def message_pin(token, message_id): ''' Pins a message in a channel ''' u_id = check_token(token) channel_specific = get_channel_by_msg_id(message_id) message_specific = get_message_by_msg_id(message_id) if u_id not in channel_specific['members'] and not is_channel_owner( token, channel_specific): raise AccessError( description= 'The authorised user is not a member of the channel that the message is within' ) if not is_channel_owner(token, channel_specific): raise InputError(description='The authorised user is not an owner') if message_specific['is_pinned']: raise InputError( description='Message with ID message_id is already pinned') if is_channel_owner(token, channel_specific ) is True and message_specific['is_pinned'] is False: message_specific['is_pinned'] = True return {}
def admin_userpermission_change_v1(token, u_id, permission_id): """Summary Enables a Dreams owner to change the permissions of another user between Dreams owner (1) and standard user (2). Args: token (string): User session token u_id (integer): User id number permission_id (integer): Either 1, indicating Dreams owner, or 2, indicating standard user Returns: Empty dictionary Raises: AccessError: When an invalid token value is given, or when the user associated with the token is not a Dreams owner InputError: When permission_id does not refer to a valid permission, or u_id does not refer to a valid user """ check_token(token) # Check for invalid token if user_from_token(token)['permission'] != 1: raise AccessError("Authorised user is not an owner.") if not 1 <= permission_id <= 2: # Check for invalid permission_id raise InputError("permission_id does not refer to a valid permission.") # Search for user with user id u_id and change their permission if found for user in users: if user['u_id'] == u_id: user['permission'] = permission_id return {} raise InputError("u_id does not refer to a valid user.")
def user_profile_sethandle_v1(token, handle_str): # token check if check_token_valid(token) is False: raise AccessError("Invalid Token") handle = ''.join(handle_str.split()) handle = handle.replace("@","") handle = handle.lower() with open('src/data.json', 'r') as FILE: data = json.load(FILE) for i in range(len(data['users'])): if data['users'][i]['handle'] == handle: raise InputError("Handle already in use") for j in range(len(data['users'])): if data['users'][j]['token'] == token: if len(handle) < 3 or len(handle) > 20: raise InputError("Invalid handle") data['users'][j]['handle'] = handle with open('src/data.json', 'w') as FILE: json.dump(data,FILE, indent = 4) return { }
def user_profile_setname_v1(token, name_first, name_last): if check_token_valid(token) is False: raise AccessError("Invalid Token") # checks if first and last names are between 1-50 characters long if len(name_first) < 1 or len(name_first) > 50: raise InputError("Name must be between 1-50 characters") if len(name_last) < 1 or len(name_last) > 50: raise InputError("Name must be between 1-50 characters") with open('src/data.json', 'r') as FILE: data = json.load(FILE) for i in range(len(data['users'])): if data['users'][i]['token'] == token: data['users'][i]['name_first'] = name_first data['users'][i]['name_last'] = name_last with open('src/data.json', 'w') as FILE: json.dump(data,FILE, indent = 4) return { }
def search_v2(token, query_str): # token check if check_token_valid(token) is False: raise AccessError("Invalid Token") messages = [] # append to list all messages that match query string from # channels/DM that user has joined with open ("src/data.json") as FILE: data = json.load(FILE) u_id = convert_token(token) for i in range(len(data['messages'])): dm_id = data['messages'][i]['dm_id'] channel_id = data['messages'][i]['channel_id'] if dm_id == -1: if check_user_in_channel(u_id, channel_id): if query_str.lower() in data['messages'][i]['message'].lower(): messages.append(data['messages'][i]) else: if check_user_in_dm(u_id, dm_id): if query_str.lower() in data['messages'][i]['message'].lower(): messages.append(data['messages'][i]) print(messages) return { 'messages': messages }
def notifications_get_v1(token): ''' channel invite, channel addowner, channel removeowner message send, message share dm create, dm invite, senddm, admins ''' # token check if check_token_valid(token) is False: raise AccessError("Invalid Token") with open ("src/data.json") as FILE: data = json.load(FILE) user_id = convert_token(token) notifications = [] count = 0 for i in range(len(data["notifications"])): if count < 20: if data["notifications"][i]["u_id"] == user_id: notification = { "channel_id": data["notifications"][i]["channel_id"], "dm_id": data["notifications"][i]["dm_id"], "notification_message": data["notifications"][i]["notification_message"] } notifications.insert(0,notification) else: break count += 1 return { "notifications": notifications }
def permission_change(token, u_id, permission_id): '''change a user's permissions on the server :param token: jwt token :type token: str :param u_id: User id corresponding to the target user :type u_id: int :param permission_id: ID of user new permissions :type permission_id: int :raises InputError: u_id does not correspond to a user :raises InputError: Invalid Permission ID :raises AccessError: User is not a slackr owner :return: empty dictionary :rtype: dict ''' user_id = check_token(token) if not user_id in get_slackr_owners(): raise AccessError( description='You are not permitted to perform this action') if not is_valid_user(u_id): raise InputError(description='User does not exist') if permission_id not in (1, 2): raise InputError(description='Invalid permission ID') # all possible errors raised. if permission_id == 1: get_users()[u_id]['is_owner'] = True elif permission_id == 2: get_users()[u_id]['is_owner'] = False return {}