def send_message(token, channel_id, message_str):
"""
Send a message to the channel associated with channel_id
"""
data = get_data()
channel = get_channel(data, channel_id)
user = get_user_from_token(data, token)
message_id = get_next_message_id(data)
if not valid_message_len(message_str):
raise ValueError("Message too long")
if not user_in_channel(user['u_id'], channel):
raise AccessError("User is not in channel")
# get the current time in utc
now = datetime.utcnow().replace(tzinfo=timezone.utc).timestamp()
# set up the information to save in the 'database'
message_info = generate_message_info(channel_id, message_id, user['u_id'],
message_str, now)
# insert the message into the front of the message ids
# stored in the channel
channel['message_ids'].insert(0, message_id)
# add the message object to the messages list
data['messages'].append(message_info)
pickle_data(data)
return {'message_id': message_id}
def start_standup(token, channel_id, length):
'''
Start a standup
Length is in seconds
'''
data = get_data()
channel = get_channel(data, channel_id)
user = get_user_from_token(data, token)
# If the channel is Invalid
if channel == None:
raise ValueError(description='Invalid Channel')
# If the channel is alreay in stadup mode
if is_standup_active(channel):
raise ValueError(description='Standup is already active')
# If the user is not in this channel
if not user_in_channel(user['u_id'], channel):
raise AccessError(description='User is not in channel')
# Else start a start up session
channel['standup_active'] = True
# setup the timer for with the length specified
timer = threading.Timer(length, stop_standup, [token, channel_id])
time_finish = (datetime.now() + timedelta(seconds=length)).timestamp()
channel['standup_finish'] = time_finish
pickle_data(data)
timer.start()
return {'time_finish': time_finish}
def get_messages(token, channel_id, start):
'''
given a token, channel_id and the start, show all th emessages in channel with
channel_id after the start as long as the user with token is part of the channel
'''
data = get_data()
user = get_user_from_token(data, token)
channel = get_channel(data, channel_id)
if channel is None:
raise ValueError('Channel does not exist')
num_messages = len(channel['message_ids'])
if start > num_messages:
raise ValueError('Start is greater than the total number of messages')
if not user_in_channel(user['u_id'], channel):
raise AccessError('User is not in channel')
end = start + 50
if end > num_messages:
end = -1
messages = return_messages(data, channel['message_ids'][start:], token)
else:
messages = return_messages(data, channel['message_ids'][start:end],
token)
return {'messages': messages, 'start': start, 'end': end}
def stop_standup(token, channel_id):
'''
stop current standup
'''
data = get_data()
channel = get_channel(data, channel_id)
channel['standup_active'] = False
channel['standup_finish'] = None
message = ' '.join(channel['standup_messages'])
channel['standup_messages'] = []
pickle_data(data)
send_message(token, channel['channel_id'], message)
def active_standup(token, channel_id):
'''
check if standup is active
'''
data = get_data()
channel = get_channel(data, channel_id)
if channel == None:
raise ValueError(description='Invalid Channel')
return {
'is_active': channel['standup_active'],
'time_finish': channel['standup_finish']
}
def join_channel(token, channel_id):
'''
given a user's token and a channel_id, the user can join the channel as long as the channel
is private or the user has permissions such as being an admin or owner of slackr
'''
data = get_data()
user = get_user_from_token(data, token)
channel = get_channel(data, channel_id)
#print(user_in_channel(user['email'], channel))
if channel is None or user_in_channel(user['u_id'], channel):
raise ValueError('invalid channel id')
if user['perm_id'] == MEMBER_ID and not channel['is_public']:
raise AccessError('User is not an admin or owner of slackr')
user_info = generate_user_info(user)
channel['members'].append(user_info)
pickle_data(data)
return {}
def leave_channel(token, channel_id):
'''
given a user's token and a channel_id, the user will leave the channel with channel_id as long
as the user is part of the channel
'''
data = get_data()
user = get_user_from_token(data, token)
channel = get_channel(data, channel_id)
#checks if the user is in the channel
if not user_in_channel(user['u_id'], channel):
raise ValueError("User not part of channel")
user_info = generate_user_info(user)
remove_user_with_u_id(channel, user_info['u_id'])
pickle_data(data)
return {}
def edit_message(token, message_id, message_str):
"""
Edit message with message_id with new message
If message is empty, delete the message
"""
if len(message_str) == 0:
return remove_message(token, message_id)
data = get_data()
og_message = get_msg_from_msg_id(data, message_id)
user = get_user_from_token(data, token)
channel = get_channel(data, og_message['channel_id'])
# check if user did not send original message and user is admin/owner
if (not user_sent_message(user['u_id'], og_message)
and not user_is_admin_or_owner(user, channel)):
raise AccessError("User did not send message or not enough privileges")
# edit the original message with the new message
og_message['message'] = message_str
pickle_data(data)
return {}
def details_channel(token, channel_id):
'''
given a token of a user and a channel_id, show the owners and members of the channel
with channel_id as long as the user is a member of the channel
'''
data = get_data()
user = get_user_from_token(data, token)
channel = get_channel(data, channel_id)
if channel is None:
raise ValueError('invalid channel id')
if not user_in_channel(user['u_id'], channel):
raise AccessError('user not part of channel')
pickle_data(data)
return {
'name': channel['name'],
'owner_members': get_members(channel['owners']),
'all_members': get_members(channel['members'])
}
def removeowner_channel(token, channel_id, u_id):
'''
given a token, channel_id and a u_id, remove ownership of the user
with u_id as long as the user was originally an owner and the user with token
is also an owner
'''
data = get_data()
owner_user = get_user_from_token(data, token)
channel = get_channel(data, channel_id)
removed_user = get_user_from_u_id(data, u_id)
if channel is None or not user_in_channel(owner_user['u_id'], channel):
raise ValueError('invalid channel id')
if not user_is_owner_channel(removed_user,
channel) or owner_user['perm_id'] != OWNER_ID:
raise ValueError('User is not an owner of channel or slackr')
user_info = generate_user_info(removed_user)
#channel['owners'].remove(user_info)
remove_user_with_u_id(channel, user_info['u_id'], mode='owners')
pickle_data(data)
return {}
def remove_message(token, message_id):
"""
Remove message with message_id from channel
"""
data = get_data()
user = get_user_from_token(data, token)
message = get_msg_from_msg_id(data, message_id)
if message is None:
raise ValueError('Message no longer exists')
channel = get_channel(data, message['channel_id'])
if not user_sent_message(user['u_id'],
message) and not user_is_admin_or_owner(
user, channel):
raise AccessError("User did not send message or not enough privileges")
# remove the message object and the message_id from the 'database'
data['messages'].remove(message)
channel['message_ids'].remove(message_id)
pickle_data(data)
return {}
def unpin_message(token, message_id):
"""
Unpin message with message_id
"""
data = get_data()
user = get_user_from_token(data, token)
message = get_msg_from_msg_id(data, message_id)
if message is None:
raise ValueError("Invalid message_id")
channel = get_channel(data, message['channel_id'])
if not perm_id_is_admin_owner(user['perm_id']):
raise ValueError("User is not an admin or owner")
if not message['is_pinned']:
raise ValueError("Message is not pinned")
if not user_in_channel(user['u_id'], channel):
raise AccessError(
"User not part of channel that the message is within")
# set the pin flag on the message to False
message['is_pinned'] = False
pickle_data(data)
return {}
def addowner_channel(token, channel_id, u_id):
'''
given a token of a user and a channel_id and another user's u_id, the user with u_id is
promoted to being an owner of the channel with channel_id as long as the user with token
has permissions to do so (is an admin or owner)
'''
data = get_data()
owner_user = get_user_from_token(data, token)
channel = get_channel(data, channel_id)
promoted_user = get_user_from_u_id(data, u_id)
if channel is None:
raise ValueError("Channel does not exist")
if user_is_owner_channel(promoted_user, channel):
raise ValueError("User with u_id is already owner of channel")
if not user_is_admin_or_owner(owner_user, channel):
raise AccessError("Not enough permissions to add user as owner")
user_info = generate_user_info(promoted_user)
channel['owners'].append(user_info)
pickle_data(data)
return {}
def invite_user(token, channel_id, u_id):
'''
Given a user's token, channel_id, and another user's u_id,
invite the user with the given u_id into the channel with the channel_id so long
as the user with token has the correct permissions (is an admin or owner of channel)
'''
data = get_data()
inviting_user = get_user_from_token(data, token)
user_to_add = get_user_from_u_id(data, u_id)
channel = get_channel(data, channel_id)
#if channel does not exist or the user is not in the channel
if channel is None:
raise ValueError('invalid channel id')
if user_to_add is None:
raise ValueError('invalid user id')
if not user_in_channel(inviting_user['u_id'], channel):
raise AccessError('user not part of channel')
# add user to the channel
user_info = generate_user_info(user_to_add)
channel['members'].append(user_info)
pickle_data(data)
return {}
def send_later(token, channel_id, message_str, time_sent):
"""
Send a message to channel with channel_id at time time_sent
"""
data = get_data()
user = get_user_from_token(data, token)
channel = get_channel(data, channel_id)
now = datetime.now().timestamp()
# get the difference between the time_sent parameter and the current time
time_diff = time_sent - now
if channel is None:
raise ValueError('channel does not exist')
if not valid_message_len(message_str):
raise ValueError('message is too long')
if time_diff < 0:
# time_sent is in the past
raise ValueError('invalid date')
if not user_in_channel(user['u_id'], channel):
raise ValueError('user not part of channel')
# set a timer to call send_message once time_diff seconds are finished
timer = threading.Timer(time_diff, send_message,
[token, channel_id, message_str])
timer.start()
def send_standup(token, channel_id, message_str):
'''
Send message to standup
'''
data = get_data()
channel = get_channel(data, channel_id)
user = get_user_from_token(data, token)
# If the channel is invalid
if channel == None:
raise ValueError(description='Invalid Channel')
# If the message is too long
if not valid_message_len(message_str):
raise ValueError(description='Invalid Channel')
# If the channel is already in stand up mode
if not is_standup_active(channel):
raise ValueError(description='No active standup')
# If the curret user is not in the channel
if not user_in_channel(user['u_id'], channel):
raise AccessError(description='User is not in channel')
user_message = f"{user['name_first']}: {message_str}"
channel['standup_messages'].append(user_message)
pickle_data(data)
return {}