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 channel_addowner_v1(token, channel_id, u_id):
'''
Summary:
Make user with user id u_id an owner of this channel
Args:
token (string): A user session token
channel_id (int): A channel_id number
u_id (int): A user id number
Returns:
a empty dictionary
Raises:
InputError when:
Channel ID is not a valid channel
When user with user id u_id is already an owner of the channel
AccessError when:
the authorised user is not an owner of the **Dreams**,
or an owner of this channel
'''
global users, channels
assert check_token(token)
assert valid_user(u_id)
if valid_channel(channel_id) == False:
raise InputError(f"Channel ID is not a valid channel")
auth_user = user_from_token(token)
current_channel = find_channel(
channel_id) #current channel with the given channel id
if not is_channel_owner(auth_user['u_id'],
channel_id) and not is_dreams_owner(
auth_user['u_id']):
raise AccessError(
f"the authorised user is not an owner of the channel or Dreams")
if is_channel_owner(u_id, channel_id) == True:
raise InputError(
f"User with user id {u_id} is already an owner of the channel")
target_user = user_from_id(u_id)
current_channel['owner_members'].append(u_id)
if u_id not in current_channel['all_members']:
current_channel['all_members'].append(u_id)
target_user['channels'].append(channel_id)
update_user_channel_stats(u_id)
send_channel_added_notification(auth_user['handle_str'], u_id,
current_channel['channel_id'])
return {}
def dm_invite_v1(token, dm_id, u_id):
"""Summary
Inviting a user to an existing dm
Args:
token (string): A user session token
dm_id (int): A dm id number
u_id (int): An user's id, who want to add this dm
Returns:
Empty dictionary
Raises:
AccessError: When an invalid token is given, or the user that token refers to is not the creator of the dm
with id dm_id
"""
check_token(token)
auth_user = user_from_token(token)
invitee = user_from_id(u_id)
# InputError: When u_id does not refer to a valid user.
if invitee == {}:
raise InputError(f"id {u_id} does not refer to a valid user")
# search all the dm in dms, and search the current dm by dm_id
for dm in dms:
if dm['dm_id'] == dm_id:
# if auth user is a member of the dm, add the u_id to this dm
if auth_user['u_id'] in dm['members']:
dm['members'].append(u_id)
invitee['dms'].append(dm_id)
update_user_dm_stats(invitee['u_id'])
send_dm_added_notification(auth_user['handle_str'], u_id,
dm['dm_id'])
return {}
else:
raise AccessError(
f"The authorised user {auth_user['handle_str']} is not already a member of the DM with id {dm_id}"
)
# InputError: When dm_id does not refer to a valid dm
raise InputError(f"id {dm_id} does not refer to a valid dm")
def dm_create_v1(token, u_id):
'''
Summary:
u_ids is the user(s) that this DM is directed to, and will not include the creator.
The creator is the owner of the DM.
name should be automatically generated based on the user(s) that is in this dm.
The name should be an alphabetically-sorted, comma-separated list of user handles, e.g.
'handle1, handle2, handle3'.
Args:
token (string): A user session token
u_ids (list): A list of user ids
Returns:
a dictionary which contains the id of the dm (dm_id)
and the name of the dm which is the concatenated handles
Raises:
InputError when:
u_id does not refer to a valid user
'''
global users, channels, next_dm_id, dms
assert check_token(token)
auth_user = user_from_token(token)
user_list_handles = [auth_user['handle_str']]
for i in range(len(u_id)):
if valid_user(u_id[i]) == False:
raise InputError(f"u_id {u_id[i]} does not refer to a valid user")
else:
member = user_from_id(u_id[i])
user_list_handles.append(member['handle_str'])
name = join_handle(user_list_handles)
dm_id = next_dm_id['id'] #give the current global id number to this dm
next_dm_id['id'] += 1 #after add one so the the dm id is always unique
dm_members = [auth_user['u_id']]
for user_id in u_id:
dm_members.append(user_id)
# Add dm to each member's list of dms
for user in users:
if user['u_id'] in dm_members:
user['dms'].append(dm_id)
update_user_dm_stats(user['u_id'])
new_dm = {
'dm_id': dm_id,
'name': name,
'creator': auth_user['u_id'],
'messages': [],
'members': dm_members
}
dms.append(new_dm)
update_dm_stats()
for user_id in new_dm['members']:
send_dm_added_notification(auth_user['handle_str'], user_id, dm_id)
return {'dm_id': dm_id, 'dm_name': new_dm['name']}
def admin_user_remove_v1(token, u_id):
'''
Summary:
Given a User by their user ID, remove the user from the Dreams.
Dreams owners can remove other **Dreams** owners (including the original first owner).
Once users are removed from **Dreams**, the contents of the messages they sent will be replaced by 'Removed user'.
Their profile must still be retrievable with user/profile/v2, with their name replaced by 'Removed user'.
Args:
token (string): A user session token
u_id (int): A user id number
Returns:
empty dictionary
Raises:
InputError when:
u_id does not refer to a valid user
The user is currently the only owner
AccessError when:
The authorised user is not an owner
'''
global users, channels, tokens, dms
assert check_token(token)
auth_user = user_from_token(token)
if valid_user(u_id) == False:
raise InputError(f"User with u_id is not a valid user")
dream_owners = find_all_dream_owners() #list of all dream owners
if auth_user['permission'] != 1:
raise AccessError("The authorised user is not an owner")
elif auth_user['u_id'] == u_id and len(dream_owners) == 1:
# Only way that user being removed can be only owner is if they are removing themself
raise InputError("The user is currently the only owner")
# Remove all tokens associated with user being removed
cleared_tokens = [
tkn for tkn in tokens if user_from_token(tkn)['u_id'] != u_id
]
tokens.clear()
for tkn in cleared_tokens:
tokens.append(tkn)
user = user_from_id(u_id)
user['name_first'] = 'Removed'
user['name_last'] = 'user'
user['permission'] = 0 # User permission id 0 indicates a removed user
for channel in channels:
for owner_member in channel['owner_members']:
if owner_member == u_id:
channel['owner_members'].remove(u_id)
for normal_member in channel['all_members']:
if normal_member == u_id:
channel['all_members'].remove(u_id)
for dm in dms:
for member in dm['members']:
if member == u_id:
dm['members'].remove(u_id)
for message in messages:
if message['author_id'] == u_id:
message['message'] = 'Removed user'
return {}
def message_send_v2(token, channel_id, message):
'''
Summary:
Send a message from authorised_user to the channel specified by channel_id.
Note: Each message should have it's own unique ID.
I.E. No messages should share an ID with another message,
even if that other message is in a different channel.
Args:
token (string): A user session token
channel_id (int): A channel_id number
message (string): a message string
Returns:
empty dictionary which contains the message_id
Raises:
InputError when:
Message is more than 1000 characters
AccessError when:
the authorised user has not joined the channel they are trying to post to
'''
global users, channels, next_message_id, messages
assert check_token(token)
assert valid_channel(channel_id)
auth_user = user_from_token(token)
current_channel = find_channel(
channel_id) #current channel with the given channel id
if current_channel['standup']['is_active']:
standup_send_v1(token, channel_id, message)
return
if len(message) > 1000:
raise InputError(f"Message more than 1000 characters")
if auth_user['u_id'] not in current_channel['all_members']:
raise AccessError(
f"the authorised user has not joined the channel they are trying to post to"
)
current_time = current_unix_timestamp() #gives us the current timestamp
current_message = {}
current_message['message_id'] = next_message_id['id'] #message_id
current_message['channel_id'] = channel_id
current_message[
'dm_id'] = -1 #this is a channel message not dm so for all dm's give -1
current_message['author_id'] = auth_user['u_id']
current_message['message'] = message
current_message['reacts'] = []
current_message['time_created'] = current_time
current_message['is_pinned'] = False
current_channel['messages'].append(current_message['message_id'])
next_message_id[
'id'] += 1 #update the global message id so we get unique ids
message_words = message.split(' ')
# Standup start checker
# Start a standup if message is exactly "/standup X" where X is a number of seconds
if message.startswith('/standup') and len(
message_words) == 2 and message_words[1].isdigit():
duration = int(message_words[1])
standup_start_v1(token, channel_id, duration)
#notications checker and handler
contains_tag = False
tag_strings = []
if '@' in message:
for word in message_words:
if word.startswith('@'):
tag_strings.append(word[1:])
contains_tag = True
if contains_tag:
for user_id in current_channel['all_members']:
user = user_from_id(user_id)
if user['handle_str'] in tag_strings:
send_channel_tag_notification(auth_user['handle_str'], user_id,
channel_id, message)
messages.append(current_message)
update_user_message_stats(auth_user['u_id'])
update_message_stats()
return {
'message_id': current_message['message_id'] #message_id
}
def message_senddm_v1(token, dm_id, message):
"""Summary
Send a message from authorised_user to the DM specified by dm_id. Note: Each message should have it's own unique ID. I.E.
No messages should share an ID with another message, even if that other message is in a different channel or DM.
Args:
token (string): A user session token
dm_id (int): A dream id number which the message will be sented to
message (string): The text with which the user wishes to sent to dream
Returns:
Dictionary: { message_id } the new message
Raises:
AccessError: when: the authorised user is not a member of the DM they are trying to post to
InputError: Message is more than 1000 characters
"""
global next_message_id
check_token(token)
auth_user = user_from_token(token)
# InputError: Message is more than 1000 characters
if len(message) > 1000:
raise InputError(f"Message {message} is more than 1000 characters")
for dm in dms:
if dm['dm_id'] == dm_id:
# AccessError: when: the authorised user is not a member of the DM they are trying to post to
if auth_user['u_id'] not in dm['members']:
raise AccessError(
f"the authorised user is not a member of the DM {dm_id}")
else:
current_time = current_unix_timestamp()
message_id = next_message_id['id']
next_message_id['id'] += 1
# create a new message which will be sent to the dm
current_message = {}
current_message['message_id'] = message_id
current_message['channel_id'] = -1
current_message['dm_id'] = dm_id
current_message['author_id'] = auth_user['u_id']
current_message['message'] = message
current_message['reacts'] = []
current_message['time_created'] = current_time
current_message['is_pinned'] = False
contains_tag = False
tag_strings = []
if '@' in message:
for word in message.split(' '):
if word.startswith('@'):
tag_strings.append(word[1:])
contains_tag = True
# the massage is already in the taget dm, send a notification
if contains_tag:
for user_id in dm['members']:
user = user_from_id(user_id)
if user['handle_str'] in tag_strings:
send_dm_tag_notification(auth_user['handle_str'],
user_id, dm_id, message)
# add the new massage to the messages list in the data
dm['messages'].append(message_id)
messages.append(current_message)
update_user_message_stats(auth_user['u_id'])
update_message_stats()
return {'message_id': message_id}
raise InputError(f"DM id {dm_id} does not refer to a valid dm")