def channel_leave_v1(token, channel_id):
"""Given channel id, removes an authorised user from that channel.
Arguments:
token (string) - token of an authenticated user
channel_id (integer) - id of channel to leave
Exceptions:
InputError - Occurs when channel_id is not a valid channel
- Occurs when the last owner tries to leave
AccessError - Occurs when token refers to a user who is not
a member of the channel
- Occurs when token is not a valid
Return value:
{}
"""
# Load .json data store
data_store = getData()
# Check validity of channel_id
ch_index = check_validity(data_store["channels"], channel_id, "channel_id",
INVALID_CHANNEL_ID)
ch_src = data_store["channels"][ch_index]
# Check validity of token
u_index = findUser(token) - 1
u_src = data_store["users"][u_index]
# Check user is actually a member
if not is_member(ch_src, u_src):
raise AccessError(description="user is not a member of this channel.")
# Check not last owner
owner = is_owner(ch_src, u_src)
if owner and len(ch_src["owner_members"]) == 1:
raise InputError(description="last owner cannot leave the channel.")
# Remove user from *_members
user_remove = {
"u_id": u_src["u_id"],
"name_first": u_src["name_first"],
"name_last": u_src["name_last"],
"email": u_src["email"],
"handle_str": u_src["handle_str"],
"profile_img_url": u_src["profile_img_url"],
}
if owner:
ch_src["owner_members"].remove(user_remove)
ch_src["all_members"].remove(user_remove)
append_user_stats(findUser(token), data_store)
append_dream_stats(findUser(token), data_store)
writeData(data_store)
return {}
def dm_remove_v1(user_token, dm_id):
'''
the function is given a token and a dm_id. we need to user the parameters to
remove the exactly dm with the dm_id. also, we need to check the validity of the
paremeters.
Arguments:
user_token (string) - some encoded information about one auth user
dm_id (int) - the id of the dm needed removing
...
Exceptions:
AccessError - Occurs when the token is not a valid token
InputError - Occurs when dm_id is not valid
AccessError - Occurs when the auth_user is not the owner of the dm
Return Value:
Returns {}
'''
database = {}
with open(file_address, "r") as f:
database = json.load(f)
#get the required value
kicker_id = findUser(user_token)
#check if the input is valid
if dm_id > database['dms'][len(database['dms']) - 1]['dm_id'] or database['dms'][dm_id - 1]['dm_id'] == -1:
raise InputError(description="The dm_id is not valid.")
if kicker_id != database['dms'][dm_id - 1]['dm_owner']:
raise AccessError(description="The one who wants to remove the dm_id does not have right.")
for msg_id in database['dms'][dm_id - 1]['message_ids']:
for message in database['messages']:
if message['message_id'] == msg_id:
msg = message
dm = get_dm_details(msg, database)
dm_key = database['dms'].index(dm)
database['dms'][dm_key]['message_ids'].remove(msg['message_id'])
database['messages'].remove(msg)
#remove the dm with some specific dm_id
database['dms'][dm_id - 1]['dm_id'] = -1
append_user_stats(findUser(user_token), database)
for u_id in database['dms'][dm_id - 1]['dm_members']:
append_user_stats(u_id, database)
append_dream_stats(findUser(user_token), database)
#put the data back to the data file
with open(file_address, "w") as f:
json.dump(database, f)
return {}
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 message_senddm_v1(token, dm_id, message):
'''
Arguments:
token (string) - the token of the user who wants to create a channel
dm_id (int) - the id of the dm the message is being sent to
message (string) - the message being sent
Exceptions:
InputError - Message is more than 1000 characters
AccessError - The authorised user has not joined the dm they are trying to post to
Return value:
Returns {'message_id': message_id}
'''
# get data
data = getData()
# get id
auth_user_id = findUser(token)
# Checks the message is not more than 1000 characters
if len(message) > 1000:
raise InputError(
description="Message must be less than 1000 characters")
# Checks the auth_user_id is part of the dm
dm_members = get_dm_members(dm_id, data)
if auth_user_id not in dm_members:
raise AccessError(description="User not in DM being posted to")
# Get new message id
new_message_id = get_new_message_id(data)
# Adds message to data dictionary
add_data(data, new_message_id, auth_user_id, -1, dm_id, message,
int(time.time()), [], False)
# Adds message to dm
for dm in data['dms']:
if dm_id == dm['dm_id']:
dm['message_ids'].append(new_message_id)
# Sends notification
send_msg_notification(data, token, message, -1, dm_id, False, -1)
append_user_stats(findUser(token), data)
append_dream_stats(findUser(token), data)
# Adds message to dm and makes notification
writeData(data)
return {
'message_id': new_message_id,
}
def channel_join_v2(token, channel_id):
"""Given channel id, adds an authorised user to that channel.
Arguments:
token (string) - token of an authenticated user
channel_id (integer) - id of channel to be joined
Exceptions:
InputError - Occurs when channel_id is not a valid channel
AccessError - Occurs when channel_id refers to private channel
and user is not a global owner
- Occurs when token is not a valid id
Return value:
{}
"""
# Load .json data store
data_store = getData()
# Check validity of channel_id
ch_index = check_validity(data_store["channels"], channel_id, "channel_id",
INVALID_CHANNEL_ID)
ch_src = data_store["channels"][ch_index]
# Check validity of token
u_id = findUser(token)
for user in data_store["users"]:
if user["u_id"] == u_id:
u_src = user
# Check permissions of channel and user
u_permission = u_src["permission_id"]
if not ch_src["is_public"] and u_permission != 1:
raise AccessError(description="Can't join a private channel")
# Add user to the channel
user_add = {
"u_id": u_src["u_id"],
"name_first": u_src["name_first"],
"name_last": u_src["name_last"],
"email": u_src["email"],
"handle_str": u_src["handle_str"],
"profile_img_url": u_src["profile_img_url"],
}
ch_src["all_members"].append(user_add)
append_user_stats(findUser(token), data_store)
append_dream_stats(findUser(token), data_store)
writeData(data_store)
return {}
def dm_leave_v1(user_token, dm_id):
'''
The function is given the token who is gonna leave the dm without destroy the dm.
Arguments:
user_token (string) - some encoded information about one auth user
dm_id (int) - the id of the dm needed removing
...
Exceptions:
AccessError - Occurs when the token is not a valid token
InputError - Occurs when dm_id is not valid
AccessError - Occurs when the auth_user is not the member of the dm
Return Value:
Returns {}
'''
database = {}
with open(file_address, "r") as f:
database = json.load(f)
#get the required value
auth_user_id = findUser(user_token)
#check if the input is valid
if dm_id > database['dms'][-1]['dm_id'] or database['dms'][dm_id - 1]['dm_id'] == -1:
raise InputError(description="The dm_id is not valid.")
if auth_user_id not in database['dms'][dm_id - 1]['dm_members']:
raise AccessError(description="The one who wants to leave the dm is not in the dm.")
#remove the dm with some specific dm_id
pos = database['dms'][dm_id - 1]['dm_members'].index(auth_user_id, 0, len(database['dms'][dm_id - 1]['dm_members']))
database['dms'][dm_id - 1]['dm_members'].pop(pos)
if len(database['dms'][dm_id - 1]['dm_members']) == 0:
database['dms'][dm_id - 1]['dm_id'] = -1
elif database['dms'][dm_id - 1]['dm_owner'] == auth_user_id:
database['dms'][dm_id - 1]['dm_owner'] = database['dms'][dm_id - 1]['dm_members'][0]
append_user_stats(findUser(user_token), database)
append_dream_stats(findUser(user_token), database)
#put the data back to the data file
with open(file_address, "w") as f:
json.dump(database, f)
return {}
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_invite_v1(user_token, dm_id, u_id):
'''
the function is given a invitor token, a dm id, and the invited's id.
the invited id should be added into the member list in the dm.
Arguments:
user_token (string) - some encoded information about one auth user
dm_id (int) - the id of the dm needed removing
u_id (int) - the id of the user been invited
...
Exceptions:
AccessError - Occurs when the token is not a valid token
InputError - Occurs when dm_id is not valid
InputsError - Occurs when the u_id is not valid
AccessError - Occurs when the auth_user is not the member of the dm
Return Value:
Returns {}
'''
#get the value
invited_id = u_id
database = {}
with open(file_address, "r") as f:
database = json.load(f)
#get the required value
invitor_id = findUser(user_token)
#check if the dm id valid
if dm_id > database['dms'][len(database['dms']) - 1]['dm_id'] or database['dms'][dm_id - 1]['dm_id'] == -1:
raise InputError(description="The dm_id is not valid.")
invited_user = use_id_to_find_user(invited_id)
if invited_user == {} or invited_id in database['dms'][dm_id - 1]['dm_members']:
raise InputError(description="The user who will be invited does not have the correct id.")
if invitor_id not in database['dms'][dm_id - 1]['dm_members']:
raise AccessError(description="The one who wants to invite someone to the dm is not in the dm.")
database['dms'][dm_id - 1]['dm_members'].append(invited_id)
#put the data back to the data file
with open(file_address, "w") as f:
json.dump(database, f)
# Open file again to get updated database
with open(file_address, "r") as f:
database = json.load(f)
# Create a notification for the added user
user_notification = new_added_notification(user_token, -1, dm_id, u_id)
database['user_notifications'].append(user_notification)
append_user_stats(invited_id, database)
append_dream_stats(findUser(user_token), database)
# Put the data back to the data file
with open(file_address, "w") as f:
json.dump(database, f)
return {}
def dm_create_v1(user_token, u_id_list):
'''
the function is given a user_token, which is encoded and is a string. Also, the function
is given a list of user id. We need to use the proper parameters to create a direct message\
and return the dm_id as a integer
Arguments:
user_token (string) - some encoded information about one auth user
u_id_list (list of int) - a list of user ids who are going to be in the dm
...
Exceptions:
AccessError - Occurs when the token is not a valid token
Return Value:
Returns {'dm_id': dm_id,
'dm_name': dm_name,}
'''
database = {}
with open(file_address, "r") as f:
database = json.load(f)
auth_user_id = findUser(user_token)
#the user_id of the creater of the dm
user_name_list = []
u_id_list.append(auth_user_id)
#check all if all the u_id is valid and get their handle to generate the name of dm
for some_u_id in u_id_list:
new_user = use_id_to_find_user(some_u_id)
if new_user == {}:
raise InputError(description="Invalid u_id in the u_ids list.")
user_name_list.append(new_user['handle_str'])
user_name_list.sort(reverse=False)
#generate the name of the new dm
dm_name = ""
dm_name += user_name_list[0]
for i in range(1, len(user_name_list)):
dm_name += ", "
dm_name += user_name_list[i]
#generate the new dm_id
if len(database['dms']) == 0:
dm_id = 1
else:
dm_id = database['dms'][len(database['dms']) - 1]['dm_id'] + 1
#store the new dm into the database
new_dm = {'dm_id' : dm_id,
'dm_name': dm_name,
'dm_owner': auth_user_id,
'dm_members': u_id_list,
'message_ids':[],}
database['dms'].append(new_dm)
#put the data back to the data file
with open(file_address, "w") as f:
json.dump(database, f)
# Open file again to get updated database
with open(file_address, "r") as f:
database = json.load(f)
# Create a notification for the added users
for user in u_id_list:
if auth_user_id != user:
user_notification = new_added_notification(user_token, -1, dm_id, user)
database['user_notifications'].append(user_notification)
append_user_stats(findUser(user_token), database)
for u_id in u_id_list:
append_user_stats(u_id, database)
append_dream_stats(findUser(user_token), database)
# Put the data back to the data file
with open(file_address, "w") as f:
json.dump(database, f)
return {'dm_id': dm_id,
'dm_name': dm_name,}
def channel_removeowner_v1(token, channel_id, u_id):
"""Given channel id, removes u_id from owners of the channel.
Arguments:
token (string) - token of an authenticated user who is
either an owner of the channel or a global owner
channel_id (integer) - id of channel with ownership
u_id (integer) - id of user to be removed of channel ownership
Exceptions:
InputError - Occurs when channel_id is not a valid channel
- Occurs when u_id refers to a user who is not an owner
- Occurs when u_id is currently the only owner
AccessError - Occurs when token refers to a user who is not a global owner
or an owner of the target channel
- Occurs when token is not valid
Return value:
{}
"""
# Load .json data store
data_store = getData()
# Check validity of channel_id
ch_index = check_validity(data_store["channels"], channel_id, "channel_id",
INVALID_CHANNEL_ID)
ch_src = data_store["channels"][ch_index]
# Check validity of token
token_index = findUser(token) - 1
token_src = data_store["users"][token_index]
# Check validity of u_id
u_index = check_validity(data_store["users"], u_id, "u_id", INVALID_U_ID)
u_src = data_store["users"][u_index]
# Check user to be removed of ownership is actually an owner
if not is_owner(ch_src, u_src):
raise InputError(description="user is not an owner of this channel.")
# Check token user is either global owner or an owner of the channel
token_permission = token_src["permission_id"]
if token_permission != 1 and not is_owner(ch_src, token_src):
raise AccessError(
description="token does not have permission to remove owner.")
# Check user is not the only owner
if len(ch_src["owner_members"]) == 1:
raise InputError(description="user is the only owner remaining.")
# Remove user from owner_members
owner_remove = {
"u_id": u_src["u_id"],
"name_first": u_src["name_first"],
"name_last": u_src["name_last"],
"email": u_src["email"],
"handle_str": u_src["handle_str"],
"profile_img_url": u_src["profile_img_url"],
}
ch_src["owner_members"].remove(owner_remove)
append_user_stats(u_id, data_store)
append_dream_stats(u_id, data_store)
writeData(data_store)
return {}
def channel_addowner_v1(token, channel_id, u_id):
"""Given channel id, makes a u_id owner of that channel.
Arguments:
token (string) - token of an authenticated user who is
either an owner of the channel or a global owner
channel_id (integer) - id of channel for ownership
u_id (integer) - id of user to be granted ownership of channel
Exceptions:
InputError - Occurs when channel_id is not a valid channel
- Occurs when u_id refers to a user who is already an owner
AccessError - Occurs when token refers to a user who is not a global owner
or an owner of the target channel
- Occurs when token is not valid
Return value:
{}
"""
# Load .json data store
data_store = getData()
# Check validity of channel_id
ch_index = check_validity(data_store["channels"], channel_id, "channel_id",
INVALID_CHANNEL_ID)
ch_src = data_store["channels"][ch_index]
# Check validity of token
token_index = findUser(token) - 1
token_src = data_store["users"][token_index]
# Check validity of u_id
u_index = check_validity(data_store["users"], u_id, "u_id", INVALID_U_ID)
u_src = data_store["users"][u_index]
# Check user to be added is not already an owner
if is_owner(ch_src, u_src):
raise InputError(
description="user is already an owner of this channel.")
# Check token user is either global owner
# or an owner of the channel
token_permission = token_src["permission_id"]
if token_permission != 1 and not is_owner(ch_src, token_src):
raise AccessError(
description="token does not have permission to add owner")
# Add user to owner_members
owner_add = {
"u_id": u_src["u_id"],
"name_first": u_src["name_first"],
"name_last": u_src["name_last"],
"email": u_src["email"],
"handle_str": u_src["handle_str"],
"profile_img_url": u_src["profile_img_url"],
}
ch_src["owner_members"].append(owner_add)
# If user was not originally member of channel,
# add them to all_members too
if not is_member(ch_src, u_src):
ch_src["all_members"].append(owner_add)
# Create a notification for the added user
user_notification = new_added_notification(token, channel_id, -1, u_id)
data_store["user_notifications"].append(user_notification)
append_user_stats(u_id, data_store)
append_dream_stats(u_id, data_store)
writeData(data_store)
return {}
def channel_invite_v2(token, channel_id, u_id):
"""
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.
Arguments:
token (str) - token passed in to the function
channel_id (int) - the id of the channel to invite to
u_id (int) - the id of the user that is being invited
Exceptions:
InputError - Occurs when channel_id does not refer to a valid channel.
InputError - Occurs when u_id does not refer to a valid user.
AccessError - Occurs when token pass in is not a valid id.
AccessError - Occurs when the authorised user is not already a member of the channel.
Return Value:
Returns {} on successful invite
"""
auth_user_id = findUser(token)
database = getData()
# Check for exceptions
channel_index = check_validity(database["channels"], channel_id,
"channel_id", INVALID_CHANNEL_ID)
channel_src = database["channels"][channel_index]
user_index = check_validity(database["users"], u_id, "u_id", INVALID_U_ID)
user_src = database["users"][user_index]
check_validity(channel_src["all_members"], auth_user_id, "u_id",
UNAUTHORISED_AUTH_U_ID)
# Only add the user if they are not already in the channel
for member in channel_src["all_members"]:
if u_id in member.values():
return {}
# Create a new dictionary for the added user with their details
# and add them to the channel
new_member = {
"u_id": user_src["u_id"],
"name_first": user_src["name_first"],
"name_last": user_src["name_last"],
"email": user_src["email"],
"handle_str": user_src["handle_str"],
"profile_img_url": user_src["profile_img_url"],
}
channel_src["all_members"].append(new_member)
# Create a notification for the added user
user_notification = new_added_notification(token, channel_id, -1, u_id)
database["user_notifications"].append(user_notification)
append_user_stats(u_id, database)
append_dream_stats(u_id, database)
writeData(database)
return {}
def channels_create_v2(token, name, is_public):
'''
Arguments:
token (string) - the token of the one who wants to create a channel
name (string) - the name of the channel which is going to be created
is_public (boolean) - whether the channel is public or private
Exceptions:
Inputerror - occur when the name of channel is larger than 20 characters
Accesserror - occur when the token is not valid or hasn't been registered.
Return value:
Returns {'channel_id': } when there is no exception being raised
'''
data = getData()
auth_user_id = findUser(token)
if len(name) > 20:
raise InputError(description="Name too long.")
else:
new_channel_id = len(data['channels']) + 1
name_last = data['users'][auth_user_id - 1]['name_last']
name_first = data['users'][auth_user_id - 1]['name_first']
email = data['users'][auth_user_id - 1]['email']
handle_str = data['users'][auth_user_id - 1]['handle_str']
is_active = False
stand_up_finished_time = 0
stand_up_length = 0
data['channels'].append({
'channel_id': new_channel_id,
'channel_name' : name,
'all_members': [{
'u_id':auth_user_id,
'name_last': name_last,
'name_first': name_first,
'email': email,
'handle_str': handle_str,
'profile_img_url' : data['users'][auth_user_id - 1]['profile_img_url'],
},],
'owner_members':[{
'u_id':auth_user_id,
'name_last': name_last,
'name_first': name_first,
'email': email,
'handle_str': handle_str,
'profile_img_url' : data['users'][auth_user_id - 1]['profile_img_url'],
},],
'is_public' : is_public,
'standup': {
'is_active': is_active,
'messages':"",
'time_finish': stand_up_finished_time,
'stand_up_length': stand_up_length,
},
'messages' : [],
})
append_user_stats(auth_user_id, data)
append_dream_stats(auth_user_id, data)
writeData(data)
return {
'channel_id': new_channel_id,
}
def standup_package(index, user_token, channel_id, time_finish):
"""a helper function to store the messages sent in the standup period
"""
database = getData()
new_message = database['channels'][index]['standup']['messages']
auth_user_id = findUser(user_token)
if database['messages'] == []:
new_message_id = 1
else:
new_message_id = database['messages'][-1]['message_id'] + 1
database['messages'].append({
'message_id' : new_message_id,
'u_id' : auth_user_id,
'channel_id': channel_id,
'dm_id' : -1,
'message' : new_message,
'time_created' : time_finish,
'reacts' : [],
'is_pinned' : False,
})
database['channels'][index]['messages'].append(new_message_id)
database['channels'][index]['standup']['is_active'] = False
database['channels'][index]['standup']['standup_length'] = 0
database['channels'][index]['standup']['time_finish'] = 0
database['channels'][index]['standup']['messages'] = ""
append_user_stats(auth_user_id, database)
append_dream_stats(auth_user_id, database)
words = new_message.split()
handle_list = []
for word in words:
if word[0] == '@':
word = word.replace(',','')
handle_list.append(word[1:])
u_id = -1
handle_status = False
member_status = False
for handle in handle_list:
u_id = -1
handle_status = False
member_status = False
for user in database['users']:
if handle == user['handle_str']:
handle_status = True
u_id = user['u_id']
channel_ids = {'channel_id' : channel_id}
channel = get_channel_details(channel_ids, database)
for members in channel['all_members']:
if u_id == members['u_id']:
member_status = True
with open(file_address, "w") as f:
json.dump(database, f)
if handle_status == True and member_status == True:
user_notification = new_tagged_notification(user_token, channel_id, -1, u_id, new_message)
database['user_notifications'].append(user_notification)
with open(file_address, "w") as f:
json.dump(database, f)
def message_sendlater_v1(token, channel_id, message, time_sent):
''' Send a message from authorised user to the channel,
automatically at a specified time in the future
Arguments:
token (string) - token of an authenticated user
who is part of the channel
channel_id (integer) - id of channel to send message in
message (string) - actual message content
time_sent (integer) - unix timestamp of when message will be sent
Exceptions:
InputError - Occurs when channel_id is not a valid channel
- Occurs when message is more than 1000 characters
- Occurs when time_sent before current time
AccessError - Occurs when authorised user is not a member of channel
- Occurs when token is not valid
Return value:
{
message_id
}
'''
current_time = int(time.time())
# Load .json data store
data_store = getData()
# Check validity of channel_id
check_validity(data_store["channels"], channel_id, "channel_id", 0)
# Check message is less than 1000 characters
if len(message) > 1000:
raise InputError(
description="Message must be less than 1000 characters")
# Check time_sent is in the future
if time_sent < current_time:
raise InputError(description="Cannot send a message in the past")
# Get user from token and check they are member of channel
u_id = findUser(token)
channel_members = get_channel_members(channel_id, data_store)
if u_id not in channel_members:
raise AccessError(description="User not in channel!")
# Get new message_id
new_message_id = get_new_message_id(data_store)
# Add message to data_store
add_data(data_store, new_message_id, u_id, channel_id, -1, message,
time_sent, [], False)
# Set up thread to send message in channel later
if (time_sent == current_time):
# Append message to channel messages
for channel in data_store["channels"]:
if channel_id == channel["channel_id"]:
channel["messages"].append(new_message_id)
send_msg_notification(data_store, token, message, channel_id, -1,
False, new_message_id)
else:
sendlater_thread = Timer(time_sent - current_time,
send_msg_notification,
args=[
data_store, token, message, channel_id,
-1, True, new_message_id
])
sendlater_thread.start()
append_user_stats(findUser(token), data_store)
append_dream_stats(findUser(token), data_store)
writeData(data_store)
return {"message_id": new_message_id}
def message_share_v1(token, og_message_id, message, channel_id, dm_id):
'''
Arguments:
token (string) - the token of the user who wants to create a channel
og_message_id - the id of the inital message
message (string) - the message being appended at the end of the share
channel_id (int) - the id of the channel the message is being sent to
dm_id (int) - the id of the dm the message is being sent to
Exceptions:
InputError - Message is more than 1000 characters
AccessError - The authorised user has not joined the channel/dm they are trying to share to
Return value:
Returns {'shared_message_id': shared_message_id}
'''
# get data
data = getData()
# get id
auth_user_id = findUser(token)
# Checks that the user is part of the channel or dm they are sharing to
channel_members = get_channel_members(channel_id, data)
dm_members = get_dm_members(dm_id, data)
if auth_user_id not in channel_members and auth_user_id not in dm_members:
raise AccessError(description="User not member of channel")
# Get og message
msg = get_message(og_message_id, data)
# Check user has access to og message
if auth_user_id != msg['u_id']:
raise AccessError(
"User not member of channel from which the message comes from")
# Checks the new message is not more than 1000 characters
if len(msg['message'] + '\n' + message) > 1000 and message != '':
raise InputError(
description="Message must be less than 1000 characters")
# Get new message id
new_message_id = get_new_message_id(data)
# Copies og message
new_msg = msg['message']
# Add optional message at end
if message != '':
new_msg = msg['message'] + '\n' + message
# Adds message to data dictionary field 'messages'
add_data(data, new_message_id, auth_user_id, channel_id, -1, new_msg,
int(time.time()), [], False)
# Share to DM/Channel
if channel_id != -1 and dm_id != -1:
raise InputError("Usage: One of channel_id or dm_id must be -1.")
elif channel_id == -1:
# Adds message to dm
for dm in data['dms']:
if dm_id == dm['dm_id']:
dm['message_ids'].append(new_message_id)
else:
# Adds message to channel
for chan in data['channels']:
if channel_id == chan['channel_id']:
chan['messages'].append(new_message_id)
# Sends notification
send_msg_notification(data, token, new_msg, channel_id, dm_id, False, -1)
append_user_stats(findUser(token), data)
append_dream_stats(findUser(token), data)
writeData(data)
return {'shared_message_id': new_message_id}