Example #1
0
def message_react(token, message_id, react_id):
    global data
    global valid_tokens
    global channels
    try:
        u_id = decodeToken(token)
        #check if react_id is valid at the start
        if react_id != 1:
            raise ValueError("Invalid react ID!")

        message = getMessage(message_id)
        channel = getMessageChannel(message_id)
        isUserChan(u_id, channel)
        for react in message["reacts"]:
            for react_users in react[
                    "u_ids"]:  #check that the user hasn't already reacted
                if react_users == u_id:
                    raise ValueError(
                        "User already has an active react for this message!")
        for react in message["reacts"]:
            if react["react_id"] == react_id:
                react["u_ids"].append(u_id)  #add the reaction
                return {}
        message["reacts"].append({
            "react_id": react_id,
            "u_ids": [u_id]
        })  # genereate the react and ass
        return {}

    except ValueError as e:
        raise e
    except AccessError as e:
        raise e
Example #2
0
def admin_userpermission_change(token, u_id, permission_id):
    
    try:
        # Check if user is authenticated and get the requesting user ID from token
        granterID = decodeToken(token)

        # Check if the target uID format is valid
        if not u_id.isdigit():
            raise ValueError("Invalid user ID!")

        # Check if the target permission ID is valid
        if int(permission_id) > 3 or int(permission_id) < 1:
            raise ValueError("Invalid permission id")

        # Find the requesting user
        permissions = getUser(granterID)['permission_id']

        # Check if requesting user has permissions for the action
        if permissions < 3:
            setPermission(u_id, permission_id)
            return {}
        raise AccessError("Granter is not an admin or owner")     
        
    except ValueError as e:
        raise e
    except AccessError as e:
        raise e 
Example #3
0
def standup_send(token, channel_id, message):
    try:
        u_id = decodeToken(token)
        # Check length is OK
        if len(message) > 1000:
            raise ValueError("Length is too long")
        # Get user permissions
        for user in data:
            if user['u_id'] == u_id:
                permissions = user['permission_id']
                name_first = user['name_first']
        # Prepare a new message
        newMessage = name_first + ': ' + message + ' '
        # Add the new message if allowed
        channel = getChannel(channel_id)
        for member in channel['all_members']:
            if member['u_id'] == u_id or permissions < 3:
                if channel['standup_status']:
                    channel['standup_message'] += newMessage
                    return {}
                raise ValueError("Standup not running!")
        raise AccessError("User is not an owner!")
    except ValueError as e:
        raise e
    except AccessError as e:
        raise e
Example #4
0
def user_profiles_uploadphoto(token, img_url, x_start, y_start, x_end, y_end, port):
    auser_dic = get_user_from_token(token)
    if not helper_check_HTTPstatus(img_url):
        raise ValueError("img_url is returns an HTTP status other than 200.")

    # check whether exists this folder
    path = "static/images/"
    # if not exists path, then mkdir
    if not os.path.isdir(path):
        os.mkdir(path)

    filename = str(auser_dic['handle'] + ".jpg")
    urllib.request.urlretrieve(img_url, path+filename)

    if img_url.rsplit('.', 1)[1].lower() != "jpg" and img_url.rsplit('.', 1)[1].lower() != "jpeg":
    # the photo uploaded should be jpg
        raise ValueError("Image uploaded is not a JPG.")

    image = Image.open(path+filename)
    if not helper_check_validdimensions(path+filename, x_start, y_start, x_end, y_end):
        # x_start, y_start, x_end, y_end should be within the dimensions of the image
        raise ValueError("any of x_start, y_start, x_end, y_end are not within the dimensions of the image at the URL.")

    cropped = image.crop((x_start, y_start, x_end, y_end))
    cropped.save(path+filename)
    auser_dic['profile_img_url'] = "http://localhost:" + str(port) + "/static/images/" + filename
    # update the user profile
    print(path + filename)
    return {}
Example #5
0
def channels_create(token, name, is_public):
    check_tokenlogin(token)

    data = getdata()
    auser_dic = get_user_from_token(token)
    auid = auser_dic['u_id']

    # check if the channel name valid
    if len(name) > 20:
        raise ValueError('channel name not valid')

    channel_id = -1
    for channel in data['channels']:
        channel_id = channel['channel_id']

    # channel id will be automaticlly updated with every creation
    channel_id = channel_id + 1

    channel_dic = {
        'channel_id': channel_id,
        'name': name,
        'is_public': is_public,
        'standup_messages': '',
        'standup_is_active': False,
        'standup_time_finish': None,
        'owner_members': [auid],
        'all_members': [auid],
        # the one who created this channel will be the owner of the channel
        'messages': []
    }

    # channel will be added into the channels list after creation
    data['channels'].append(channel_dic)

    return {'channel_id': channel_id}
Example #6
0
def message_pin(token, message_id):
    # 1. authorise user should be in the channel
    # 2. the message should be valid
    # 3. the message should be unpinned
    check_tokenlogin(token)

    auser_dic = get_user_from_token(token)
    auid = auser_dic['u_id']

    m_c_dic = get_message_from_mid(message_id)
    check_validmessage(m_c_dic)
    message_dic = m_c_dic['message_dic']
    channel_dic = m_c_dic['channel_dic']

    #check if the authorise user is in the channel
    check_auser_not_in_channel(auid, channel_dic['all_members'])
    check_user_admin(auser_dic)

    # cannot pin the message which is pinned
    if message_dic['is_pinned']:
        raise ValueError("Message with ID message_id is already pinned.")

    message_dic['is_pinned'] = True

    return {}
def auth_passwordreset_request(email):
    try:
        # Check email is provided and is valid
        if email is None:
            raise ValueError("Invalid Email Format")

        if not re.search(regex, email):
            raise ValueError("Invalid Email Format")

        # Generate a reset code for the corresponding user
        u_id = getUserByEmail(email)['u_id']
        resetReq(u_id)
        return {}

    except ValueError as e:
        raise e
Example #8
0
def channel_addowner(token, channel_id, u_id):
    global channels

    try:
        # Get user information
        userID = decodeToken(token)
        users = getUser(int(u_id))
        target = {'u_id':int(u_id), 'name_first':users['name_first'], 'name_last':users['name_last'], "profile_img_url": users['profile_img_url']}
        grantusers = getUser(userID)
        granter = {'u_id':userID, 'name_first':grantusers['name_first'], 'name_last':grantusers['name_last'], "profile_img_url": grantusers['profile_img_url']}
        permissions = grantusers['permission_id']

        # Channel operations
        channel = getChannel(channel_id)
        if granter in channel['owner_members'] or permissions < 3:
            if target in channel['owner_members']:
                raise ValueError("User already an owner")
            elif target in channel['all_members']:
                channel['owner_members'].append(target)
                return {}
            else:
                channel['owner_members'].append(target)
                channel['all_members'].append(target)
                return {}
        raise AccessError("User is not an owner")

    except ValueError as e:
        raise e
    except AccessError as e:
        raise e
Example #9
0
def channels_create(token, name, is_public):
    try:
        if len(name) > 20:
            raise ValueError("Name must be 20 characters or less.")

        # Get user information
        channel_id = len(channels)
        u_id = decodeToken(token)
        users = getUser(u_id)
        name_first = users['name_first']
        name_last = users['name_last']
        profile_img_url = users['profile_img_url']

        owner_members = [{
            "u_id": u_id,
            "name_first": name_first,
            "name_last": name_last,
            "profile_img_url": profile_img_url
        }]
        all_members = [{
            "u_id": u_id,
            "name_first": name_first,
            "name_last": name_last,
            "profile_img_url": profile_img_url
        }]

        newChannel(channel_id, name, is_public, owner_members, all_members)
        return channel_id

    except ValueError as e:
        raise e
    except AccessError as e:
        raise e
Example #10
0
def auth_login(email, password):
    password = str(encode({'password' : password}))

    check_validemail(email)

    user_dic = get_user_from_email(email)

    # if not find the email in the user, raise error
    if not user_dic:
        raise ValueError("Email entered does not belong to a user")

    # if find the user, and password correct
    if user_dic['password'] == password:
        user_dic['is_log_in'] = True
        return {'u_id': user_dic['u_id'], 'token': user_dic['token']}
    # if find the user, but password not correct
    raise ValueError("Password incorrect")
Example #11
0
def auth_passwordreset_request(email):
    resetcode = generaterestcode()

    user_dic = get_user_from_email(email)
    if not user_dic:
        raise ValueError("Email not exists")

    user_dic.update({'resetCode': resetcode})
    send_mail(resetcode, email)
    return {}
Example #12
0
def get_args(arg_name, arg_type=str):
    parser = reqparse.RequestParser()
    parser.add_argument(arg_name, type=arg_type)
    args = parser.parse_args()

    arg = args.get(arg_name)

    if arg is None:
        raise ValueError("Miss args: %s" % arg_name)

    return arg
Example #13
0
def user_profile_setemail(token, email):
    check_tokenlogin(token)

    users = getdata()['users']

    auser_dic = get_user_from_token(token)

    check_validemail(email)
    # check if the email is valid

    for user in users:
        if user['email'] == email:
            raise ValueError("email has been used.")

    if auser_dic['email'] == email:
        raise ValueError('No new email entered')

    auser_dic['email'] = email

    return {}
Example #14
0
def message_unpin(token, message_id):
    global data
    global valid_tokens
    global channels
    try:
        u_id = decodeToken(token)
        message = getMessage(message_id)
        channel = getMessageChannel(message_id)
        isUserChan(u_id, channel) #Will raise error if fails
        for members in data: 
            if members["u_id"] == u_id:
                if int(members["permission_id"]) == 1 or int(members["permission_id"]) == 2: #check user is admin ############ ADMIN OR OWNER?
                    if message["is_pinned"]: #check if pinned
                        message["is_pinned"] = False
                        return {}
                    raise ValueError("Message is not pinned!")
        raise ValueError("User does not have permission to unpin!")   
    except ValueError as e:
        raise e
    except AccessError as e:
        raise e
Example #15
0
def auth_passwordreset_reset(reset_code, new_password):

    try:
        # Check new password is satisfactory            
        if new_password is None:
            raise ValueError("New password is too short")
        
        if len(new_password) < 5:
            raise ValueError("New password is too short")

        # Check reset code is valid and reset
        for reset_dict in reset_codes:
            if reset_dict['reset_code'] == int(reset_code):
                u_id = reset_dict['u_id']
                setPassword(u_id, new_password)
                resetRemove(reset_dict)
                return {}
        raise ValueError("Invalid code")

    except ValueError as e:
        raise e
Example #16
0
def message_send(token, channel_id, message):
    global data
    global valid_tokens
    global channels

    try:
        u_id = decodeToken(token)
        channel = getChannel(channel_id)
        isUserChan(u_id, channel)  #Will raise error if fails
        if len(message) > 1000:
            raise ValueError(
                "Message can not be greather than 1000 character limit")
        elif len(message) == 0:  #this appears to be handled by front end...
            raise ValueError("Message can not be empty")
        else:
            return addMessage(channel, message, u_id)

    except ValueError as e:
        raise e
    except AccessError as e:
        raise e
Example #17
0
def auth_register(email, password, name_first, name_last):
    #set up the initial value
    data = getdata()
    permission_ids_dic = get_permission_ids()
    owner = permission_ids_dic['Owner']
    member = permission_ids_dic['Member']
    uid = 0

    # argument checking
    # check password
    check_validpassword(password)

    # check email
    check_validemail(email)

    # check firstname, lastname
    check_validname(name_first, name_last)

    # get a new u_id for new user, and check whether the email has been used
    for user in data['users']:
        uid = user['u_id']
        if user['email'] == email:
            raise ValueError("email has been used.")
    uid = uid + 1

    # if uid = 1, which means this is the first one to register the slackr
    # this user is the owner of slackr
    # else the user is just a member
    if uid == owner:
        permissionid = owner
    else:
        permissionid = member

    handle = creatHandle(name_first, name_last)
    userdic = {
        'email': email,
        'password': str(encode({'password': password})),
        'u_id': uid,
        'name_first': name_first,
        'name_last': name_last,
        'is_log_in': True,
        'handle': handle,
        'permission_id':permissionid,
        'profile_img_url': None
    }

    token = generateToken(userdic)
    userdic.update({'token':token})

    data['users'].append(userdic)

    return {'u_id': uid, 'token': token}
Example #18
0
def user_profile_sethandle(token, handle_str):
    check_tokenlogin(token)

    auser_dic = get_user_from_token(token)
    check_validhandle(handle_str)
    # the handle should be valid

    if not handle_is_unique(handle_str):
    # this handle has been used
        raise ValueError('handle is already used by another user')

    auser_dic['handle'] = handle_str
    return {}
Example #19
0
def auth_login(email, password):

    try:
        # Check email is provided and is valid
        if email is None:
            raise ValueError("Invalid Email Format")

        if not re.search(regex,email):
            raise ValueError("Invalid Email Format")

        # Hash the password
        hashPass = hashlib.sha256(password.encode()).hexdigest()

        # Find the user by email
        user = getUserByEmail(email)
        if user['password'] == hashPass: # Match their password
            token = addToken(user['u_id'])
            return {'u_id':user['u_id'], 'token': token} # Return them their new token
        raise ValueError("Password incorrect")

    except ValueError as e:
        raise e
Example #20
0
def auth_passwordreset_reset(resetCode, newPassword):
    #verify if this user is the correct user then check the format of the new password
    #then update data
    data = getdata()
    check_validpassword(newPassword)
    newPassword = str(encode({'password': newPassword}))

    for user in data['users']:
        if user['resetCode'] == resetCode:
            user['password'] = newPassword
            return {}

    raise ValueError("not a vaild reset code")
Example #21
0
def message_unreact(token, message_id, react_id):
    global channels
    try:
        u_id = decodeToken(token)
        #check if react_id is valid at the start
        if react_id != 1:
            raise ValueError("Invalid react ID!")

        channel = getMessageChannel(message_id)
        message = getMessage(message_id)
        isUserChan(u_id, channel) #Will raise error if fails
        for react in message["reacts"]: 
            for react_users in react["u_ids"]: #check that the user hasn't already reacted
                if react_users == u_id:
                    react["u_ids"].remove(u_id)
                    return {}
        raise ValueError("User already has no active react for this message!")

    except ValueError as e:
        raise e
    except AccessError as e:
        raise e
Example #22
0
def user_profile_setemail(token, email):
    global data
    try:
        u_id = decodeToken(token)
        #check if email is already in use
        for user in data:
            if user['email'] == email:
                raise ValueError("Email already in use")
        #check email is valid
        if not re.search(regex, email):
            raise ValueError("Invalid Email")
        # set email
        for user in data:
            if user['u_id'] == int(u_id):
                user['email'] = email
                return {}
        raise ValueError("Not a valid user")  #technically impossible to reach

    except ValueError as e:
        raise e
    except AccessError as e:
        raise e
Example #23
0
def user_profile_sethandle(token, handle_str):
    global data
    try:
        u_id = decodeToken(token)
        #check if handle is already in use
        for user in data:
            if user['handle'] == handle_str:
                raise ValueError("Handle already in use")
        #check handle is valid
        if (len(handle_str) < 3) or (len(handle_str) >
                                     20):  #inclusive? assumed to be inclusive
            raise ValueError("Handle must be between 3 and 20 characters")
        # make the change
        for user in data:
            if user['u_id'] == int(u_id):
                user['handle'] = handle_str
                return {}
        raise ValueError("Not a valid user")
    except ValueError as e:
        raise e
    except AccessError as e:
        raise e
Example #24
0
def standup_start(token, channel_id, length):
    try:
        u_id = decodeToken(token)
        permissions = getUserPerm(u_id)
        channel = getChannel(channel_id)
        for owner in channel['owner_members']:
            if owner['u_id'] == u_id or permissions < 3:
                if not channel['standup_status']:
                    time_finish = datetime.now(timezone.utc).timestamp() + length
                    channel['standup_status'] = True
                    channel['time_finish'] = time_finish
                    return {"time_finish":time_finish}
                raise ValueError("Standup already running!")
        raise AccessError("User is not an owner!")
    except ValueError as e:
        raise e
    except AccessError as e:
        raise e
Example #25
0
def channel_removeowner(token, channel_id, u_id):
    check_tokenlogin(token)

    channel_dic = get_channel_from_cid(channel_id)
    auser_dic = get_user_from_token(token)

    check_validchannel(channel_dic)

    check_auser_permission_of_channel(auser_dic, channel_dic)
    # only the owner can remove an owner, remove oneself is okay
    if u_id not in channel_dic['owner_members']:
        raise ValueError("The user with uid is not a owner of this channel")

    check_only_owner(channel_dic)

    # add uid to the owner of the channel
    channel_dic['owner_members'].remove(u_id)
    return {}
Example #26
0
def channel_invite(token, channel_id, u_id):
    check_tokenlogin(token)

    channel_dic = get_channel_from_cid(channel_id)
    auser_dic = get_user_from_token(token)

    check_validchannel(channel_dic)

    members = channel_dic['all_members']
    check_auser_not_in_channel(auser_dic['u_id'], members)

    uid_dic = get_user_from_uid(u_id)
    # add this user in the channel if this user is not a member of the channel
    check_validuid(uid_dic)
    if u_id in members:
        raise ValueError("the invited user already in channel")
    members.append(u_id)
    return {}
Example #27
0
def channel_messages(token, channel_id, start):
    check_tokenlogin(token)

    #set up the initial value
    max = 50
    returned_least_recent = -1

    channel_dic = get_channel_from_cid(channel_id)
    auser_dic = get_user_from_token(token)

    check_validchannel(channel_dic)
    check_auser_not_in_channel(auser_dic['u_id'], channel_dic['all_members'])

    # check if the start is valid
    total_messages = len(channel_dic['messages'])
    return_messages = []

    if total_messages == 0:
        return {'messages': return_messages, 'start': start, 'end': -1}

    if start > total_messages:
        raise ValueError(
            'Start is greater than the total number of messages in the channel'
        )

    counter = start
    end = start + max

    # get the messages between start and end
    # if end > total, just get the messages between start and last message
    while counter < end and counter < total_messages:
        return_messages.append(channel_dic['messages'][counter])
        counter = counter + 1

    # if this function has returned the least recent messages in the channel
    # returns -1 in "end" to indicate there are no more messages to load after this return.
    if start == total_messages:
        end = returned_least_recent

    # else return the counter of last message in the list of returned messages
    else:
        end = counter

    return {'messages': return_messages, 'start': start, 'end': end}
Example #28
0
def channel_messages(token, channel_id, start):
    global channels
    try:
        u_id = decodeToken(token)
        # Channel operations
        channel = getChannel(channel_id)
        for users in channel['all_members']:
            if users['u_id'] == u_id or data[u_id]['permission_id'] < 3:
                if int(start) > len(channel['messages']):
                    raise ValueError(
                        "Start is greater than the number of messages")
                newMsg = channel[
                    'messages']  #inject is_user_reacts into messages to return
                for messages in newMsg:
                    for reacts in messages['reacts']:
                        reacts['is_this_user_reacted'] = False  #default
                        for react_users in reacts['u_ids']:
                            if react_users == u_id:
                                reacts[
                                    'is_this_user_reacted'] = True  #if user has reacted
                if len(newMsg) <= int(start) + 50:
                    return {
                        'messages':
                        newMsg[len(channel['messages']) - int(start)::-1],
                        'start':
                        start,
                        'end':
                        -1
                    }
                else:
                    return {
                        'messages':
                        newMsg[len(channel['messages']
                                   ):len(channel['messages']) - 51:-1],
                        'start':
                        start,
                        'end':
                        int(start) + 50
                    }
        raise AccessError("Must be a member of channel to see messages")
    except ValueError as e:
        raise e
    except AccessError as e:
        raise e
Example #29
0
def message_react(token, message_id, react_id):
    # 1. authorise user should be in the channel
    # 2. the message should be valid
    # 3. the message should be unreacted
    check_tokenlogin(token)

    #get the information of the user
    auser_dic = get_user_from_token(token)
    auid = auser_dic['u_id']

    m_c_dic = get_message_from_mid(message_id)
    check_validmessage(m_c_dic)
    # check if the message is valid then get the message
    message_dic = m_c_dic['message_dic']
    channel_dic = m_c_dic['channel_dic']

    check_uid_not_in_channel(auid, channel_dic)
    check_validreact(react_id)

    m_reacts = message_dic['reacts']

    this_react = helper_check_react_exists(m_reacts, react_id)
    user_reacted = helper_is_the_user_reacted(message_dic, auid)
    # if there is no this react in the message
    # add a react
    if not this_react:
        m_reacts.append({
            'react_id': react_id,
            'u_ids': [auid],
            'is_this_user_reacted': user_reacted
        })
        return {}

    # if there is this react in the message
    if auid in this_react['u_ids']:
        raise ValueError(
            "Message already contains an active React with react_id from user."
        )

    this_react['u_ids'].append(auid)
    if not user_reacted:
        this_react['is_this_user_reacted'] = True

    return {}
Example #30
0
def auth_register(email,password,name_first,name_last):

    #check email is valid
    if not re.search(regex,email):  
        raise ValueError("Invalid Email")

    #check password is not less than 6 chars
    if len(password) < 5:
        raise ValueError("Password too short")

    #check email isn't already registered
    for user in data:
        if user['email'] == email:
            raise ValueError("Email already in use")

    #check first name is between 1 and 50 chars
    if len(name_first) > 50:
        raise ValueError("First name has to be 50 characters or less")
    elif len(name_first) == 0:                                            #Assumed that first name has to be at least 1 char
        raise ValueError("Name has to be at least one character")
    
    #check first name is between 1 and 50 chars
    if len(name_last) > 50:
        raise ValueError("Last name has to be 50 characters or less")
    elif len(name_last) == 0:                                             #Assumed that last name has to be at least 1 char
        raise ValueError("Last name has to be at least one character")

    #count how many people have same first name and last name
    count = 0
    for user in data:
        if (user.get('name_first')).lower() == name_first.lower() and (user.get('name_last')).lower() == name_last.lower():
            count += 1

    #If the handle would be greater than 20 digits,
    if len(name_first + name_last) < 20:
        if count == 0:
            handle = name_first.lower() + name_last.lower()
        else:
            handle = name_first.lower() + name_last.lower() + str(count)
    else:
        if count == 0:
            handle = (name_first.lower() + name_last.lower())[0:20]
        else:
            handle = (name_first.lower() + name_last.lower())[0:19] + str(count)             
    
    return createUser(email,password,name_first,name_last, handle)