def standup_start(token, channel_id, length):
global end_time
sender = get_user_from_token(token)
sender_uid = sender.get_uid()
try:
curr_channel = get_verified_channel_from_id(channel_id,
get_channel_list())
except:
raise ValueError("Channel ID is not a valid channel")
if sender_uid in curr_channel.get_mem_list():
if not curr_channel.get_active_standup():
curr_channel.set_active_standup(True)
start_time = datetime.now()
t = Timer(length, standup_output_message, [token, channel_id], {})
t.start()
end_time = start_time + timedelta(seconds=length)
return {'time_finish': int(end_time.timestamp())}
else:
raise ValueError("Standup is already running.")
else:
raise AccessError("Authorised user is not a member of the channel.")
def test_login_corr():
global my_users
data_delete()
user = auth_register("*****@*****.**", "password", "Student", "Citizen")
userDict = auth_login("*****@*****.**", 'password')
assert userDict['u_id'] == user['u_id']
assert get_user_from_token(userDict['token']) == my_users[0]
def search(token, quer_str):
user = get_user_from_token(token)
search_result = []
search_list = []
channels_dict = channels_list(token)
for channel in channels_dict:
search_list.append(channel['channel_id'])
for channel_id in search_list:
channel = get_verified_channel_from_id(channel_id, get_channel_list())
for message in channel.get_mess():
if quer_str in message.get_message_content():
message_dict = {
'message_id': message.get_message_id(),
'u_id': message.get_user_id(),
'message': message.get_message_content(),
'time_created':
int(message.get_time_created().timestamp()),
'reacts': [],
'is_pinned': message.get_is_pinned()
}
message_dict['reacts'] = generate_reacts_dictionary(
user, message)
search_result.append(message_dict)
return {'messages': search_result}
def append_message(channel_id, token, message_id, message, time_created):
channel_messages = get_channel_messages(channel_id)
user_id = get_user_from_token(token).get_uid()
new_message = Message(message_id, user_id, message, time_created)
channel_messages.append(new_message)
return {"message_id": message_id}
def standup_send(token, channel_id, message):
global list_of_messages
global end_time
curr_user = get_user_from_token(token)
try:
curr_channel = get_verified_channel_from_id(channel_id,
get_channel_list())
except:
raise ValueError("Channel ID is not a valid channel")
if curr_user.get_uid() in curr_channel.get_mem_list():
if (len(message) <= 1000):
if curr_channel.get_active_standup():
list_of_messages.append({
"handle_str":
curr_user.get_handle_str(),
"message":
message
})
return {}
else:
raise ValueError("Standup is not active at the moment")
else:
raise ValueError("Message is more that 1000 characters")
else:
raise AccessError("The user is not a valid user")
def authorized_user(token, channel_id):
user_id = get_user_from_token(token)
channel = get_verified_channel_from_id(channel_id, get_channel_list())
channel_members = channel.get_mem_list()
for member in channel_members:
if user_id.get_uid() == member:
return True
return False
def test_invalid_permission_id():
global my_users
data_delete()
userDict1 = auth_register("*****@*****.**", "password", "Student", "Citizen")
userDict2 = auth_register("*****@*****.**", "password", "Student", "Citizen")
with pytest.raises(ValueError):
admin_userpermission_change(userDict1['token'], userDict2['u_id'], 5)
userClass = get_user_from_token(userDict2['token'])
assert userClass.get_permission_id() == 3
def test_handle_already_used2():
global my_users
data_delete()
auth_register("*****@*****.**", "password", "Studentabcde", "Citizen")
auth_register("*****@*****.**", "password", "Studentabcde", "Citizen")
user = auth_login("*****@*****.**", 'password')
userClass = get_user_from_token(user['token'])
# Checking handle
assert (userClass.get_handle_str() == "studentabcdecitizen1")
def test_owner_change_admin_to_member():
global my_users
data_delete()
userDict1 = auth_register("*****@*****.**", "password", "Student", "Citizen")
userDict2 = auth_register("*****@*****.**", "password", "Student", "Citizen")
channel_id = channels_create(userDict1['token'], 'Channel1', False)
admin_userpermission_change(userDict1['token'], userDict2['u_id'], 2)
channel_join(userDict2['token'], channel_id['channel_id'])
admin_userpermission_change(userDict1['token'], userDict2['u_id'], 3)
userClass = get_user_from_token(userDict2['token'])
assert userClass.get_permission_id() == 3
def test_member_change_to_owner_or_admin():
global my_users
data_delete()
userDict1 = auth_register("*****@*****.**", "password", "Student", "Citizen")
userDict2 = auth_register("*****@*****.**", "password", "Student", "Citizen")
userDict3 = auth_register("*****@*****.**", "password", "Student",
"Citizen")
with pytest.raises(AccessError):
admin_userpermission_change(userDict2['token'], userDict3['u_id'], 2)
userClass = get_user_from_token(userDict3['token'])
assert userClass.get_permission_id() == 3
def test_admint_change_admin_to_admin():
global my_users
data_delete()
userDict1 = auth_register("*****@*****.**", "password", "Student", "Citizen")
userDict2 = auth_register("*****@*****.**", "password", "Student", "Citizen")
userDict3 = auth_register("*****@*****.**", "password", "Student",
"Citizen")
admin_userpermission_change(userDict1['token'], userDict2['u_id'], 2)
admin_userpermission_change(userDict1['token'], userDict3['u_id'], 2)
admin_userpermission_change(userDict2['token'], userDict3['u_id'], 3)
userClass = get_user_from_token(userDict3['token'])
assert userClass.get_permission_id() == 3
def message_remove(token, message_id):
user_id = get_user_from_token(token).get_uid()
message = get_message_from_m_id(message_id)
channel = get_verified_channel_from_id(
get_channel_from_message(message_id), get_channel_list())
if not channel_owner(user_id, channel):
if not message_poster(user_id, message):
raise AccessError("Not authorized user of message")
channel.get_mess().remove(message)
return {}
def message_edit(token, message_id, message_str):
if not user_valid_token(token):
raise AccessError("User is not a valid user")
user_id = get_user_from_token(token).get_uid()
message = get_message_from_m_id(message_id)
channel = get_verified_channel_from_id(
get_channel_from_message(message_id), get_channel_list())
if not channel_owner(user_id, channel):
if not message_poster(user_id, message):
raise AccessError("Not authorized user of message")
message.change_content(message_str)
return {}
def message_react(token, message_id, react_id):
user_id = get_user_from_token(token).get_uid()
if not valid_message_in_channel(user_id, message_id):
raise ValueError("Invalid message_id with in the user joined channel")
message = get_message_from_m_id(message_id)
if already_reacted(user_id, message, react_id):
raise ValueError("Already contains an active react")
react = get_react_from_id(message, react_id)
react.user_react(user_id)
return {}
def message_unreact(token, message_id, react_id):
user_id = get_user_from_token(token).get_uid()
if not valid_message_in_channel(user_id, message_id):
raise ValueError("Invalid message_id with in the user joined channel")
message = get_message_from_m_id(message_id)
if not already_reacted(user_id, message, react_id):
raise ValueError("Does not contain an active react")
if not user_valid_token(token):
raise AccessError("User is not a valid user")
react = get_react_from_id(message, react_id)
react.user_unreact(user_id)
return {}
def message_unpin(token, message_id):
user_id = get_user_from_token(token).get_uid()
message = get_message_from_m_id(message_id)
channel = get_verified_channel_from_id(
get_channel_from_message(message_id), get_channel_list())
if not authorized_user(token, channel.get_channel_id()):
raise AccessError("User is not a member of the channel")
if not user_valid_token(token):
raise AccessError("User is not a valid user")
if not channel_owner(user_id, channel):
raise ValueError("The user is not an admin")
if not message.pinned():
raise ValueError("Message is already unpinned")
message.unpin_message()
return {}
def standup_output_message(token, channel_id):
global list_of_messages
get_verified_channel_from_id(channel_id,
get_channel_list()).set_active_standup(False)
u_id = get_user_from_token(token).get_uid()
channel = get_verified_channel_from_id(channel_id, get_channel_list())
output_string = ""
for dictionary in list_of_messages:
str1 = dictionary['handle_str']
str2 = dictionary['message']
adjusted_string = str1 + ": " + str2 + "\n"
output_string += adjusted_string
adjusted_string = ""
list_of_messages.clear()
message = Message(set_global_message_id(), u_id, output_string,
datetime.now())
output_string = None
channel.get_mess().append(message)
def get_verified_user_from_token(token):
user = get_user_from_token(token)
if user == None: #pragma: no cover
raise ValueError("The user does not exists.")
return user