Пример #1
0
def profile_setname(payload):
    '''
    Update the authorised user's first and last name
    '''
    user = get_user_token(payload['token'])

    if not 1 < len(payload['name_first']) < 50:
        raise InputError(
            description='Invalid name_first, above the range of 50 characters')
    if not 1 < len(payload['name_last']) < 50:
        raise InputError(
            description='Invalid name_last, above the range of 50 characters')

    user['name_first'] = payload['name_first']
    user['name_last'] = payload['name_last']
    return {}
Пример #2
0
def channel_addowner(server_data, token, channel_id, u_id):
    """
    Make user with user u_id an owner of this channel
    
    Input:
    - server_data(obj)
    - token (string)
    - channel_id (int)
    - u_id (int)
    
    Output:
    - {}
    """

    # Check if the channel exists
    verify_channel_id(server_data, channel_id)
   
    # Verify if token is active, and if so, get u_id from the active session
    u_id_owner = verify_n_get_valid_token(server_data, token)

    # Verify if the u_id_owner is a owner of the channel or owner of slacker
    verify_user_channel_status(server_data, channel_id, u_id_owner, const.PERMISSION_LOCAL_OWNER)
    
    channel_obj = server_data.get_channel_by_id(channel_id)        
    user_obj = server_data.get_user_by_id(u_id)
    # Is either slackr owner or channel owner
    # Now check if the user being added is already an owner
    if not channel_obj.is_user_owner(u_id): 
        assert channel_obj.add_owner(user_obj.get_user_member_info())
    else:
        raise InputError(description="User is already an owner")

    return {}
Пример #3
0
def message_unpin(token, message_id):
    """
    Sets a message to unpinned by setting is_pinned to False

    Parameters:
        token (str): Used to authenticate and identify the user
        message_id (int): the unique id of a message in the system

    Return:
    	{}
    """
    # Check if token is valid
    user_id = authenticate_token(token)
    user = valid_user_id(user_id)

    # Check if message exists in the data
    # Function will raise InputError if message does not exist
    msg_check = check_message_valid(message_id)
    ch_index = msg_check['ch_index']
    msg_index = msg_check['msg_index']

    channel = valid_channel_id(ch_index)

    # Check if user is an owner of the channel, raise AccessError if not
    if user not in channel.owner_members:
        raise AccessError("User not not an owner inside desired channel")

    # check is pinned and set
    if channel.channel_messages[msg_index].is_pinned:
        channel.channel_messages[msg_index].is_pinned = False
    else:
        raise InputError(description="message wasn't pinned")

    return {}
Пример #4
0
def echo():
    data = request.args.get('data')
    if data == 'echo':
   	    raise InputError(description='Cannot echo "echo"')
    return dumps({
        'data': data
    })
def message_react(token, message_id, react_id):

    token = request.form.get('token')
    message_id = request.form.get('message_id')
    react_id = request.form.get("react_id")
    message_index = message_id - 1
    message_data = get_global_messages()
    user_data = get_global_users()
    channel_list = get_global_channel()

    position = position_in_user_data(token, user_data)

    check_valid_react_id(react_id)
    check_valid_message_id(message_id, message_data)
    is_user_in_channel_mid(position, user_data, channel_list, message_id, message_data)
    check_if_deleted(message_id, message_data)

    if user_data[position]['u_id'] in message_data[message_index]['reacts']['u_id']:
            message['reacts']['is_this_user_reacted'] = True
            raise InputError(description='Already reacted by requested user')
    else:
        message['reacts']['u_id'].append(user_data[position]['u_id'])
        message['reacts']['is_this_user_reacted'] = True    #This is the scary one

    return dumps({})
Пример #6
0
def user_remove():
    '''admin removes a user from slackr'''
    data = get_data()
    payload = request.get_json()
    token = payload['token']
    u_id = int(payload['u_id'])
    check_token(token)

    user_data = get_user_data(u_id)
    if user_data == {}:
        raise InputError(description='No such user exists')
    person_u_id = get_user_from_token(token)
    person_data = get_user_data(person_u_id)
    if person_data['permission_id'] != 1:
        raise AccessError(description='The authorised person is not an owner of slackr')
    user_info = {
        'u_id': u_id,
        'name_first': user_data['name_first'],
        'name_last': user_data['name_last'],
    }
    for channel in data['channels']:
        if user_info in channel['owner_members']:
            curr_channel_id = channel['channel_id']
            data['channels'][curr_channel_id - 1]['owner_members'].remove(user_info)
            data['channels'][curr_channel_id - 1]['all_members'].remove(user_info)
        elif user_info in channel['all_members']:
            curr_channel_id = channel['channel_id']
            data['channels'][curr_channel_id - 1]['all_members'].remove(user_info)
    dumps({})
def message_sendlater_fn(token, channel_id, message, time_sent, MESSAGES, \
                        MESSAGE_COUNTER, USERS, channel_list):

    position = position_in_user_data(token, USERS)
    is_user_in_channel(position, USERS, channel_id, channel_list)
    check_valid_message(message)

    tz = pytz.timezone("Australia/NSW")
    time_now = datetime.timestamp(datetime.now(tz))

    print('\ntime_now is: ' + str(time_now))
    print('time_sent is: ' + str(time_sent))

    interval = time_sent - time_now
    print('sent - d_aware is: ' + str(interval) + '\n')

    if interval < 0:
        raise InputError(
            description='Time sent can not be less than current time.')

    timer = threading.Timer(int(interval), \
            message_send_fn, \
            [token, channel_id, message, MESSAGES, MESSAGE_COUNTER, USERS, channel_list])
    timer.start()

    return dumps({'message_id': MESSAGE_COUNTER})
Пример #8
0
def channels_create(token, name, is_public):
    if len(name) > 20:
        raise InputError(f"{name!r} is more than 20 characters long")

    if name == "":
        name = "new_channel"

    creator_data = auth_get_user_data_from_id(
        auth_get_current_user_id_from_token(token))

    id = database["channels_id_head"]
    new_channel = {
        "id": id,
        "name": name,
        "is_public": is_public,
        "owner_members_id": [creator_data["id"]],
        "all_members_id": [creator_data["id"]],
        "messages": {},
        "standup_queue": [],
        "standup_is_active": False,
        "standup_finish_time": None,
    }
    database["channels"][id] = new_channel
    database["channels_id_head"] += 1

    return {"channel_id": new_channel["id"]}
Пример #9
0
def log_in(username, password):
    """
    Log a user in if given a valid username/password.

        Paramters:
            username (str): username entered by user
            password (str): password entered by user

        Returns:
            None

        Exceptions:
            AuthError when one of:
                username exists and password incorrect

            InputError when:
                username does not exist
                username exists, password correct, and already logged in
    """
    check_username(username)

    hashed_password = sha256(password.encode()).hexdigest()
    if data.users[username].hash_pwd != hashed_password:
        raise AuthError("Incorrect password")

    if data.users[username].logged_in:
        raise InputError("Already logged in")

    data.users[username].logged_in = True
Пример #10
0
def channel_messages(token, channel_id, start):
    """
    Returns a list of messages, start and end.

    Parameters:
        token (str): a unique token (to determine authorisation)
        channel_id(int): a unique id for such channel
        start (int): index indicating when the messages start

    Returns:
        {
            messages (str): the message which will be sent in the channel
            start (int): index indicating when the messages start
            end (int): index indicating when the messages end
        }
    """
    # Check that token is valid and gets it index(u_id)
    user_id = authenticate_token(token)
    user = valid_user_id(user_id)

    # Check that channel_id is valid
    channel = valid_channel_id(channel_id)

    # Check that user is part of the desired channel
    if not channel.existing_member(user):
        raise AccessError(description="User not in desired channel.")

    # Check that start is not greater
    # than the total number of messages in the channel and not negative
    msg_count = channel.num_messages()
    if (start > msg_count or start < 0):
        raise InputError("invalid start")

    # Initialize the desired return data
    ch_messages = {}
    ch_messages['messages'] = []

    msg_load = msg_count - start
    if msg_count == 0:  # No messages to load
        end = -1
    elif start == msg_count:  # Only loads a single message if start is equal to message_count
        msg = channel.channel_messages[msg_count - 1].message_details()
        ch_messages['messages'].append(msg)
        end = -1
    elif msg_load <= 50:  # Loads all the messages in the channel if there are less than 50 messages to load
        for i in range(msg_load, start, -1):
            msg = channel.channel_messages[i - 1].message_details()
            ch_messages['messages'].append(msg)
        end = -1
    else:  # Only loads the first 50 messages if there are more than 50 messages in the channel
        for i in range(start + 50, start, -1):
            msg = channel.channel_messages[i - 1].message_details()
            ch_messages['messages'].append(msg)
        end = start + 50

    # Updates the start and end value which needs to be returned
    ch_messages['start'] = start
    ch_messages['end'] = end

    return ch_messages
Пример #11
0
def message_send(token, channel_id, message):
    #Send a message from authorised_user to the channel specified by channel_id

    with open('data_store.json', 'r') as FILE:
        database = json.load(FILE)

    #Check if lenght of string is <1000
    if len(message) > 1000:
        raise InputError(description='Message length greater than 1000.')

    email = find_token(token)
    for user in database["users"]:
        if user["email"] == email:
            for channel in database["channels"]:
                if channel["channel_id"] == channel_id:
                    for member in channel["members"]:
                        if member == user["u_id"]:
                            timestamp = datetime.now().timestamp()
                            message_id = uuid.uuid4().int
                            text = {
                                "message_id": message_id,
                                "u_id": user["u_id"],
                                "message": message,
                                "time_created": timestamp,
                                "reacts": [],
                                "is_pinned": False
                            }
                            channel["messages"].append(text)
                            with open('data_store.json', 'w') as FILE:
                                json.dump(database, FILE)
                            return {"message_id": message_id}
                    raise AccessError(
                        description='User is not a memmber of the channel')
    raise AccessError(description='Invalid token')
Пример #12
0
def channel_join(token, channel_id):
    """
    Adds a user from a channel,
    User should have been authenticated and authorised to join the channel.

    Parameters:
        token (str): a unique token (to determine authorisation)
        channel_id(int): a unique id for such channel

    Returns:
        {}
    """
    # Check that token is valid
    user_id = authenticate_token(token)
    user = valid_user_id(user_id)

    # Check that channel_id is valid
    channel = valid_channel_id(channel_id)

    # Check that user is allowed to join
    if not channel.is_public and not user.permission_id == 1:
        raise AccessError("Channel is private, unable to join")

    # Check that the user is not in the channel yet
    if channel.existing_member(user):
        raise InputError(description="User is already a member.")

    # Adds user to the channel
    channel.new_member(user)

    # Promote to owner if user is flockr owner
    if user.permission_id == 1:
        channel.new_owner(user)

    return {}
Пример #13
0
def channels_create(token, name, is_public):
    #check len(name) is greater than 20
    if len(name) > 20:
        raise InputError()

#get unique channel_id
    channel_id = random.randint(1, 1000)
    for x in data['channels']:
        if channel_id == x['channel_id']:
            channel_id = random.randint(1000, 2000)

    # make channel
    new_channel = {
        'channel_id': channel_id,
        'name': name,
        'is_public': is_public,
        'all_members': [],
        'owner_members': [],
        'messages': []
    }

    data['channels'].append(new_channel)

    ## add authorised user to list of channel owners
    # get user id from token
    u_id = data['tok_uid'][token]

    # get user dictionary
    user = get_user_info(u_id)

    new_i = len(data['channels']) - 1
    data['channels'][new_i]['all_members'].append(user)
    data['channels'][new_i]['owner_members'].append(user)

    return {'channel_id': channel_id}
Пример #14
0
def user_profile(token, u_id):
    '''
    For a valid user, returns information about their
    user id, email, first name, last name, handle, and image profile URL

    Parameters:
        token - The user's token that was generated from their user id
        u_id - The profile id number to be checked

    Returns:
        An dictionary containing all the users information

    Errors:
        InputError:
            Given a u_id for a non-existent user
    '''
    check_token(token)
    data = get_data()
    # Finding the user
    for user in data['users']:
        if user['u_id'] == u_id:
            profile = {
                'u_id': u_id,
                'email': user['email'],
                'name_first': user['name_first'],
                'name_last': user['name_last'],
                'handle_str': user['handle_str'],
                'profile_img_url': user['profile_img_url']
            }
            return {
                'user': profile
            }
    # If u_id hasn't been found then it is obviously invalid
    raise InputError(description="Invalid u_id")
Пример #15
0
def channel_leave(token, channel_id):
    '''
    Given a channel ID, the user removed as a member of this channel
    Input: token (str), channel_id (int)
    Output: empty dict
    '''
    # Retrieve data
    auth_user = user_with_token(token)
    channel = channel_with_id(channel_id)

    # Error check
    if auth_user is None:
        raise AccessError('Invalid token')
    elif channel is None:
        raise InputError('Invalid channel_id')
    elif auth_user not in channel.get_all_members():
        raise AccessError('Authorised user not a member of channel')

    # Remove user from all_members
    channel.get_all_members().remove(auth_user)

    # Attempt to remove user from owner_members if they are an owner
    if auth_user in channel.get_owner_members():
        channel.get_owner_members().remove(auth_user)

    return {
    }
Пример #16
0
def standup_active(server_data, token, channel_id):
    """
    standup_active
    A function that checks if a standup is currently active in channel

    Input:
    - (str) token
    - (int) channel_id
    Output:
    - {is_active, time_finish}
    """
    # Check if the channel exists
    if not server_data.does_channel_exist(channel_id):
        raise InputError(description="Invalid channel")

    channel_obj = server_data.get_channel_by_id(channel_id)

    # Obtain session object from server_data
    session_obj = server_data.get_sessions_list()
    # Check if the token is active
    if not session_obj.is_token_active(token):
        raise AccessError(description="Invalid Token")

    return_info = {
        "is_active": channel_obj.is_standup_active,
        "time_finish": channel_obj.time_finish,
    }

    return return_info
Пример #17
0
def channels_create(server_data, token, name, is_public):

    """
    channel_create function:
    A function that creates a channel in the server_data, if the token is valid. Returns a channel_id from the server_data function

    Inputs:
    - server_data (obj)
    - token (string)
    - name (string)
    - is_public (bool)

    Outputs
    - {channel_id} (dics)
    """

    # Check if the token is active, and get u_id if the token is active
    # Get u_id from the active session
    u_id = verify_n_get_valid_token(server_data, token)

    # Get user object from the u_id
    user_obj = server_data.get_user_by_id(u_id)
    # Then get the user info containing {u_id, name_first, name_last}
    user_info = user_obj.get_user_member_info()

    # Now check if the name is longer than 20 characters
    if len(name) > 20:
        raise InputError(description="Channel name too long")

    # Everything checks out, create channel in the database
    channel_id = server_data.create_channel(name, user_info, is_public)

    return {"channel_id": channel_id}
Пример #18
0
def channel_details(tokne, channels_id):
    auth_store = get_auth_data_store
    channel_store = get_channel_data_store

    is_valid_user_id(u_id)
    owner_members = []
    all_members = []

    # Check if channel exists using helper function
    channel = get_channel(channel_id)

    # InputError when we try to get details of an invalid channelID
    if channel is None:
        raise InputError(description='Invalid channel_id')

    # Get details of owners and members in the channel
    if u_id in channel['members']:
        name = channel['name']
        for owners in channel['owner_members']:
            owner_members_details = user_details(owners)
            owner_members.append(owners_members_details)
        for members in channel['all_members']:
            all_members_details = user_details(members)
            all_members.append(all_members_details)
        return {
            "name": channel['name'],
            "owner_members": channel['owner_members'],
            "all_members": channel['all_members']
        }
    # AccessError when authorised user is not a member of the channel
    else:
        raise AccessError(
            description='Authorised user is not a member of the channel')
Пример #19
0
def channels_create(token, name, is_public):
    '''Creates a channel and assigns first user as owner.'''
    # Opens database
    with open('data_store.json', 'r') as FILE:
        database = json.load(FILE)
    # Find email from token
    email = find_token(token)
    for user in database["users"]:
        if user["email"] == email:
            #Checks the length of channel name
            if len(name) > 20:
                raise InputError(
                    description='Name cannot be over 20 characters long')

            # Generate channel_id that is 5 digits long, convert to string
            new_id = uuid.uuid4().int
            channel_id = str(new_id)[:5]
            # Create new channel
            new_channel = {
                "channel_id": channel_id,
                "name": name,
                "is_public": is_public,
                "members": [user["u_id"]],
                "owners": [user["u_id"]],
                "messages": []
            }

            # Add channel to list of channels
            database["channels"].append(new_channel)
            with open('data_store.json', 'w') as FILE:
                json.dump(database, FILE)
            return {"channel_id": new_channel["channel_id"]}
    raise AccessError(description="Invalid token")
Пример #20
0
def build_string(payload):
    """
    Returns a string for details of weather
    """
    if payload['location']['name'] == "Weather":
        raise InputError('Location is not a real place')
    return f"""
def message_unreact_fn(token, message_id, react_id, MESSAGES, USERS,
                       channel_list):

    message_index = int(message_id) - 1
    react_index = int(react_id) - 1
    position = int(position_in_user_data(token, USERS))

    check_valid_react_id(react_id)
    check_valid_message_id(message_id, MESSAGES)
    is_user_in_channel_mid(position, USERS, channel_list, message_id, MESSAGES)
    check_if_deleted(message_id, MESSAGES)

    if USERS[position]['u_id'] not in MESSAGES[message_index]['reacts'][
            react_index]['u_ids']:
        MESSAGES[message_index]['reacts'][react_index][
            'is_this_user_reacted'] = False
        raise InputError(
            description='No reaction to unreact for specified react_id')
    else:
        MESSAGES[message_index]['reacts'][react_index]['u_ids'].remove(
            USERS[position]['u_id'])
        MESSAGES[message_index]['reacts'][react_index][
            'is_this_user_reacted'] = False

    return dumps({})
Пример #22
0
def channel_leave(token, channel_id):

    # get user's u_id
    u_id = data['tok_uid'][token]

    # InputError: invalid channel ID
    if not is_valid_channel(channel_id):
        raise InputError('Channel ID does not refer to a valid channel')

    # AccessError: authorised user is not a member of the channel
    elif not is_channel_member(u_id, channel_id):
        raise AccessError('Authorised user is not a member of the channel')

    # no errors: user is removed from all_members and owner_members (if applicable)
    for channel in data['channels']:
        if channel['channel_id'] == channel_id:
            # find user dictionary
            for member in channel['all_members']:
                if member['u_id'] == u_id:
                    # remove user dictionary from all_members
                    channel['all_members'].remove(member)
            # if user is also owner, remove from owner_members
            if is_channel_owner(u_id, channel_id):
                for owner in channel['owner_members']:
                    if owner['u_id'] == u_id:
                        channel['owner_members'].remove(owner)

    return {}
Пример #23
0
def standup_start(token, channel_id, length):
    """
    standup_start

    Args:
        token: authorises user
        channel_id: the target channel to initiate the standup in
        length: how long the standup will last (in seconds)

    Returns:
        time_finish: the time the startup will end and consequently send the start up messages into the message queue of the channel
    """
    token_validator(token)
    channel_validator(channel_id)  

    # Check if there is a standup currently running in the channel
    if standup_active(token, channel_id)['is_active']:
        raise InputError("There is already a standup currently active")

    # Start the standup period, for length (seconds) where messages using standup 
    # will be sent to a standup_queue, then all added to the channel_messages by a 
    # packed message sent by the creator of the standup when the standup finishes
    time_finish = get_timestamp(length)
    standup_start = threading.Thread(target=thread_standup, args=(token, channel_id, length))
    standup_start.start()

    for channel in data['channels']:
        if channel['channel_id'] == channel_id:
            channel['time_finish'] = time_finish
    
    return {
        'time_finish': time_finish
    }
Пример #24
0
def standup_active_fn(token, channel_id, channels, users, messages):
    #position_in_user will check if it is a valid token
    position_in_user_data(token, users)

    for channel in channels:
        #once we get to the time standup finish time we send message
        if (channel['standup'])['time_finish'] and \
            (channel['standup'])['is_active'] and \
                int(time.mktime(datetime.datetime.now().timetuple())) >= \
                    (channel['standup'])['time_finish']:

            time_now = datetime.datetime.now()
            #print(time_now)
            time_now = time_now.replace(tzinfo=timezone.utc).timestamp()
            new_message = create_message((channel['standup'])['start_member'], \
                (channel['standup'])['message'], time_now, channel_id)
            messages.append(new_message)
            (channel['standup'])['start_member'] = None
            (channel['standup'])['is_active'] = False
            (channel['standup'])['message'] = []
            (channel['standup'])['time_finish'] = None

            return {'is_active': False, 'time_finish': None}

        if not (channel['standup'])['is_active']:
            return {'is_active': False, 'time_finish': None}

        return {
            'is_active': True,
            'time_finish': (channel['standup'])['time_finish']
        }

    raise InputError(
        description="Channel ID is not a valid channel, standup active")
Пример #25
0
def message_remove(token, message_id):
    """ Remove a message

    Parameters:
        token (str): The token of the active user
        message_id(int): The ID of the message to remove

    Returns:
        None

    """
    # check whether the token is valid
    user_id = database.verify_token(token)
    if not user_id:
        raise AccessError(description='The token does not exist')
    #check whether the message exist
    channel = check_msg(message_id)
    if not channel:
        raise InputError(description='The message does not exist')
    #check whether the user have access to remove it
    access = check_access(user_id, channel, message_id)
    if not access:
        raise AccessError(
            description=
            'The user doed not have permission to remove this message')
    #remove it
    remove(message_id, channel)

    return {}
Пример #26
0
def change_permission(token, u_id, permission_id):
    """ Change the permission of user with u_id

    Parameters:
        token (str): The token of the active user
        u_id(int): The user ID of the user to change
        permission_id (int): New permission ID

    Returns:
        channels (list): List of dictionaries, where each dictionary contains types { channel_id, name }

    """
    DATA = getData()

    if permission_id != 1 and permission_id != 2:
        raise InputError("Invalid permission ID")

    owner_flag = False
    user_to_change = None

    for users in DATA['users']:
        if users['u_id'] == u_id:
            user_to_change = users
        if users['u_id'] == verify_token(token):
            if users['permission_id'] == 1:
                owner_flag = True

    if not owner_flag:
        raise AccessError("Authorised user not an owner")

    user_to_change['permission_id'] = permission_id
    update_database(DATA)
    return {}
Пример #27
0
def channel_removeowner(server_data, token, channel_id, u_id):
    """
    Remove user with user u_id from an owner of this channel
    
    Input:
    - server_data(obj)
    - token (string)
    - channel_id (int)
    - u_id (int)
    
    Output:
    - {}
    """

    # Check if the channel exists
    verify_channel_id(server_data, channel_id)
        
    channel_obj = server_data.get_channel_by_id(channel_id)
        
    # Verify the token and get u_id from the active token
    u_id_owner = verify_n_get_valid_token(server_data, token)
    user_obj_owner = server_data.get_user_by_id(u_id_owner)

    # Verify if the u_id_owner is a owner of the channel or owner of slacker
    verify_user_channel_status(server_data, channel_id, u_id_owner, const.PERMISSION_LOCAL_OWNER)
            
    if channel_obj.is_user_owner(u_id):
        channel_obj.remove_owner(u_id) 
    else:
        # user is not an owner of the channel
        raise InputError(description="User is not an owner of the channel")

    return {}
Пример #28
0
def remove_users(token, u_id):
    """ Remove a user with u_id from Slackr

    Parameters:
        token (str): The token of the active user
        u_id(int):user ID of the user to remove

    Returns:
        None

    """
    DATA = getData()

    owner_flag = False
    user_to_change = None

    for users in DATA['users']:
        if users['u_id'] == u_id:
            user_to_change = users
        if users['u_id'] == verify_token(token):
            if users['permission_id'] == 1:
                owner_flag = True

    if not owner_flag:
        raise AccessError("Authorised user not an owner")

    if not user_to_change:
        raise InputError("User ID does not refer to valid user")

    DATA['users'].remove(user_to_change)
    update_database(DATA)
    return {}
Пример #29
0
def request(payload):                       # pylint disable=R1771
    '''
    Function to request a reset code
    '''

    reset_store = get_reset_code_store()
    send_to_email = test_email(payload['email'])

    email_match = 0  # if found = 1

    user = get_user_from('email', send_to_email)    # pylint: disable=W0612

    email_match = 1
    reset_code = id_generator()

    code_password = {
        'email': send_to_email,
        'reset_code': reset_code,
    }

    server = smtplib.SMTP_SSL('smtp.gmail.com', 465)
    server.login(EMAIL, PASSWORD)
    server.sendmail(
        EMAIL,
        send_to_email,
        reset_code)
    server.quit()

    if email_match == 0:
        raise InputError(description="Email entered does not belong to a user")

    reset_store.append(code_password)
Пример #30
0
def channels_listall(token):
    """
    Lists all the channels that exist.

    Paramaters:
    token (str): A string that validates the users actions while
                 they are logged in.

    Returns:
        {
            channels: []
        }: A list of all the channel dicitionaries.
    """
    # raise InputError if inputed data is the wrong type
    if not isinstance(token, str):
        raise AccessError("Invalid token")

    # raise InputError if any of the inputs is empty
    if token == '':
        raise InputError("Invalid input")

    # check that token is authorised
    authenticate_token(token)
    
    return_list = []
    for channel in data.channels:
        return_list.append({'channel_id': channel.channel_id, 'name': channel.name})

    return {
        'channels' : return_list
    }