def leave_event(username, event_id): """ Leave an event. Parameters: username (str): username of event leaver event_id (int): unique ID of event Exceptions: InputError when any of: username does not exist event_id does not exist username is not a member of event username is the event admin AuthError when: username is not logged in Returns: None """ check_username(username) check_event_id(event_id) check_is_member(username, event_id) check_logged_in(username) event = data.events.get(event_id) if username == event.admin_username: raise InputError("Admin cannot leave event") event.member_usernames.remove(username) del event.availabilities[username]
def remove_user(admin_username, member_username, event_id): """ Remove a user from an event Paramters: admin_username (str): username of event admin member_username (str): username of member being removed event_id (int): unique ID of event Exceptions: InputError when any of: admin_username does not exist member_username is not in the event with event_id member_username is admin_username event_id does not exist AuthError when any of: admin_username is not the event admin admin_username is not logged in Returns: None """ check_username(admin_username) check_event_id(event_id) check_is_admin(admin_username, event_id) check_logged_in(admin_username) check_username(member_username) check_is_member(member_username, event_id) if admin_username == member_username: raise InputError("Cannot remove self") event = data.events.get(event_id) event.member_usernames.remove(member_username) del event.availabilities[member_username]
def edit_availability_special(username, event_id, edit_mode, start, end): """ Set availability for a non-repeating specific time interval. Parameters: username (str): username of editor event_id (int): unique ID of event edit_mode (bool): True for available, False for unavailable start (datetime.datetime): start time end (datetime.datetime): end time (start and end are in intervals of 30 minutes) Exceptions: AuthError when any of: username is not logged in InputError when any of: event_id does not exist username does not exist username is not a member of event end is before or the same as start start or end is more than 60 days after event creation start or end is before the event creation time Returns: None """ check_username(username) check_event_id(event_id) check_is_member(username, event_id) check_logged_in(username) if end <= start: raise InputError("Invalid time range") event = data.events.get(event_id) if start < event.create_time or end < event.create_time: raise InputError("Start or end time is in the past") if (start > timedelta(days=60) + event.create_time or end > timedelta(days=60) + event.create_time): raise InputError("Start or end time is too late") start_index = (start.date() - event.create_time.date()).days end_index = (end.date() - event.create_time.date()).days schedule = event.availabilities[username].times current_interval = start.hour * 2 + start.minute // 30 current_day_index = start_index current = start while current < end: schedule[current_day_index][current_interval] = edit_mode current_interval += 1 if current_interval == INTERVALS: current_interval = 0 current_day_index += 1 current += timedelta(seconds=(60 * 30))
def edit_availability_weekly(username, event_id, edit_mode, day, start, end): """ Add a weekly schedule of availabilities Parameters: username (str): username of editor event_id (int): unique ID of event edit_mode (bool): True for available, False for unavailable day (int): day of week in schedule, 0 is Mon, 6 is Sun start (datetime.time): start time in scheduled day of week end (datetime.time): end time in scheduled day of week (start and end are in intervals of 30 minutes) Exceptions: InputError when any of: username does not exist event_id does not exist day is not valid end is at or before start username is not member of event AuthError when any of: username is not logged in Returns: None """ check_username(username) check_event_id(event_id) check_is_member(username, event_id) check_logged_in(username) if not MON <= day <= SUN: raise InputError("Invalid week day") if end <= start: raise InputError("Invalid time interval") event = data.events.get(event_id) schedule = event.availabilities[username] offset = (day - event.create_time.weekday() + 7) % 7 start = start.hour * 2 + start.minute // 30 end = end.hour * 2 + end.minute // 30 for d in range(offset, MAX_DAYS, 7): for t in range(start, end): schedule.times[d][t] = edit_mode
def find_best_times(username, event_id): """ Find the best three closest time intervals for meeting, where 'best' is defined to be the date with the most members available. If the event length is set, the start of the best time intervals of that length will be found, otherwise a 3 hour interval will be assumed. If the event deadline is set, the best times before the deadline will be found, otherwise the maximum deadline of 60 days past the creation date. If not modified, the best times will be found within the default desired time range of the event. Parameters: username (str): username of user event_id (int): unique ID of event Exceptions: InputError when any of: username does not exist event_id does not exist username is not a member of event AuthError when any of: username is not logged in Returns: times ([datetime.datetime]): a list of the best times, from best to worst """ check_username(username) check_event_id(event_id) check_is_member(username, event_id) check_logged_in(username) event = data.events.get(event_id) schedules = [s.times for s in list(event.availabilities.values())] intersection = find_intersection(schedules) print(event.admin_username) for u in event.availabilities: print(u, event.availabilities[u].times[:9]) #print(intersection) best_intervals = find_best_intervals(intersection, CUTOFF, event) return best_intervals
def event_details(username, event_id): """ Give details about the given event, specifically a list of event members, event creation date, event deadline, event length, event admin. Parameters: username (str): username of user requesting event details event_id (int): unique ID of event Exceptions: InputError when any of: username does not exist event_id does not exist username is not a member of event AuthError when: username is not logged in Returns: members ({str}): a set of event member usernames admin (str): username of event admin create_time (datetime.datetime): create time of event length (int): event length in hours deadline (datetime.date): event deadline """ check_username(username) check_event_id(event_id) check_is_member(username, event_id) check_logged_in(username) event = data.events.get(event_id) details = { "members": event.member_usernames, "admin": event.admin_username, "create_time": event.create_time, "length": event.event_length, "deadline": event.event_deadline, } return details
def edit_availability_daily(username, event_id, edit_mode, day): """ Set availability for a full day. Parameters: username (str): username of editor event_id (int): unique ID of event edit_mode (bool): True for available, False for unavailable day (datetime.date): day chosen Exceptions: AuthError when any of: username is not logged in InputError when any of: username does not exist event_id does not exist username is not part of the event day is a date before the event creation date day is a date beyond 60 days after event creation Returns: None """ check_username(username) check_event_id(event_id) check_is_member(username, event_id) check_logged_in(username) event = data.events.get(event_id) if day < event.create_time.date(): raise InputError("Date cannot be in the past") if day >= event.create_time.date() + timedelta(days=MAX_DAYS): raise InputError("Date is too far into future") schedule = event.availabilities[username].times offset = (day - event.create_time.date()).days schedule[offset] = [edit_mode for _ in range(INTERVALS)]