def approve():
term_id = app.config['CURRENT_TERM_ID']
term_name = term_name_for_sis_id(term_id)
params = request.get_json()
publish_type = params.get('publishType')
recording_type = params.get('recordingType')
section_id = params.get('sectionId')
course = SisSection.get_course(term_id, section_id) if section_id else None
if not course or publish_type not in get_all_publish_types() or recording_type not in get_all_recording_types():
raise BadRequestError('One or more required params are missing or invalid')
if not current_user.is_admin and current_user.uid not in [i['uid'] for i in course['instructors']]:
raise ForbiddenRequestError('Sorry, request unauthorized')
if Approval.get_approval(approved_by_uid=current_user.uid, section_id=section_id, term_id=term_id):
raise ForbiddenRequestError(f'You have already approved recording of {course["courseName"]}, {term_name}')
meetings = course.get('meetings', {}).get('eligible', [])
if len(meetings) != 1:
raise BadRequestError('Unique eligible meeting pattern not found for course')
meeting = meetings[0]
location = meeting and meeting.get('location')
room = Room.find_room(location=location)
if not room:
raise BadRequestError(f'{location} is not eligible for Course Capture.')
previous_approvals = Approval.get_approvals_per_section_ids(section_ids=[section_id], term_id=term_id)
approval = Approval.create(
approved_by_uid=current_user.uid,
approver_type_='admin' if current_user.is_admin else 'instructor',
course_display_name=course['label'],
publish_type_=publish_type,
recording_type_=recording_type,
room_id=room.id,
section_id=section_id,
term_id=term_id,
)
if previous_approvals:
# Compare the current approval with preferences submitted in previous approval
previous_approval = previous_approvals[-1]
if (approval.publish_type, approval.recording_type) != (previous_approval.publish_type, previous_approval.recording_type):
notify_instructors_of_changes(course, approval, previous_approvals)
all_approvals = previous_approvals + [approval]
if len(course['instructors']) > len(all_approvals):
approval_uids = [a.approved_by_uid for a in all_approvals]
pending_instructors = [i for i in course['instructors'] if i['uid'] not in approval_uids]
last_approver = next((i for i in course['instructors'] if i['uid'] == approval.approved_by_uid), None)
if last_approver:
notify_instructor_waiting_for_approval(course, last_approver, pending_instructors)
return tolerant_jsonify(_after_approval(course=SisSection.get_course(term_id, section_id)))
def _get_approvals_and_scheduled(section_ids, term_id):
approvals = Approval.get_approvals_per_section_ids(section_ids=section_ids,
term_id=term_id)
scheduled = None
for section_id in section_ids:
if not scheduled:
scheduled = Scheduled.get_scheduled(section_id=section_id,
term_id=term_id)
scheduled = scheduled and scheduled.to_api_json()
break
return [a.to_api_json() for a in approvals], scheduled
def _approval_uids_per_section_id(scheduled, term_id):
section_ids = [s.section_id for s in scheduled]
all_approvals = Approval.get_approvals_per_section_ids(
section_ids=section_ids, term_id=term_id)
approval_uids_per_section_id = {
section_id: []
for section_id in section_ids
}
for approval in all_approvals:
approval_uids_per_section_id[approval.section_id].append(
approval.approved_by_uid)
return approval_uids_per_section_id
def approve():
term_id = app.config['CURRENT_TERM_ID']
term_name = term_name_for_sis_id(term_id)
params = request.get_json()
publish_type = params.get('publishType')
recording_type = params.get('recordingType')
section_id = params.get('sectionId')
course = SisSection.get_course(term_id, section_id) if section_id else None
if not course or publish_type not in get_all_publish_types() or recording_type not in get_all_recording_types():
raise BadRequestError('One or more required params are missing or invalid')
if not current_user.is_admin and current_user.uid not in [i['uid'] for i in course['instructors']]:
raise ForbiddenRequestError('Sorry, request unauthorized')
if Approval.get_approval(approved_by_uid=current_user.uid, section_id=section_id, term_id=term_id):
raise ForbiddenRequestError(f'You have already approved recording of {course["courseName"]}, {term_name}')
location = course['meetingLocation']
room = Room.find_room(location=location)
if not room:
raise BadRequestError(f'{location} is not eligible for Course Capture.')
previous_approvals = Approval.get_approvals_per_section_ids(section_ids=[section_id], term_id=term_id)
approval = Approval.create(
approved_by_uid=current_user.uid,
approver_type_='admin' if current_user.is_admin else 'instructor',
cross_listed_section_ids=[c['sectionId'] for c in course['crossListings']],
publish_type_=publish_type,
recording_type_=recording_type,
room_id=room.id,
section_id=section_id,
term_id=term_id,
)
_notify_instructors_of_approval(
approval=approval,
course=course,
previous_approvals=previous_approvals,
)
return tolerant_jsonify(SisSection.get_course(term_id, section_id))
def _to_api_json(term_id, rows, include_rooms=True):
rows = rows.fetchall()
section_ids = list(set(int(row['section_id']) for row in rows))
courses_per_id = {}
# Perform bulk queries and build data structures for feed generation.
section_ids_opted_out = CoursePreference.get_section_ids_opted_out(
term_id=term_id)
invited_uids_by_section_id = {section_id: [] for section_id in section_ids}
for invite in SentEmail.get_emails_of_type(section_ids=section_ids,
template_type='invitation',
term_id=term_id):
if invite.recipient_uid not in invited_uids_by_section_id[
invite.section_id]:
invited_uids_by_section_id[invite.section_id].append(
invite.recipient_uid)
approval_results = Approval.get_approvals_per_section_ids(
section_ids=section_ids, term_id=term_id)
scheduled_results = Scheduled.get_scheduled_per_section_ids(
section_ids=section_ids, term_id=term_id)
room_ids = set(row['room_id'] for row in rows)
room_ids.update(a.room_id for a in approval_results)
room_ids.update(s.room_id for s in scheduled_results)
rooms = Room.get_rooms(list(room_ids))
rooms_by_id = {room.id: room for room in rooms}
approvals_by_section_id = {section_id: [] for section_id in section_ids}
for approval in approval_results:
approvals_by_section_id[approval.section_id].append(
approval.to_api_json(rooms_by_id=rooms_by_id))
scheduled_by_section_id = {
s.section_id: s.to_api_json(rooms_by_id=rooms_by_id)
for s in scheduled_results
}
cross_listings_per_section_id, instructors_per_section_id, canvas_sites_by_section_id = _get_cross_listed_courses(
section_ids=section_ids,
term_id=term_id,
approvals=approvals_by_section_id,
invited_uids=invited_uids_by_section_id,
)
# Construct course objects.
# If course has multiple instructors or multiple rooms then the section_id will be represented across multiple rows.
# Multiple rooms are rare, but a course is sometimes associated with both an eligible and an ineligible room. We
# order rooms in SQL by capability, NULLS LAST, and use scheduling data from the first row available.
for row in rows:
section_id = int(row['section_id'])
if section_id in courses_per_id:
course = courses_per_id[section_id]
else:
# Approvals and scheduled (JSON)
approvals = approvals_by_section_id.get(section_id)
scheduled = scheduled_by_section_id.get(section_id)
# Instructors per cross-listings
cross_listed_courses = cross_listings_per_section_id.get(
section_id, [])
instructors = instructors_per_section_id.get(section_id, [])
# Construct course
course = {
'allowedUnits':
row['allowed_units'],
'approvals':
approvals,
'canvasCourseSites':
canvas_sites_by_section_id.get(section_id, []),
'courseName':
row['course_name'],
'courseTitle':
row['course_title'],
'crossListings':
cross_listed_courses,
'deletedAt':
safe_strftime(row['deleted_at'], '%Y-%m-%d'),
'hasOptedOut':
section_id in section_ids_opted_out,
'instructionFormat':
row['instruction_format'],
'instructors':
instructors,
'invitees':
invited_uids_by_section_id.get(section_id),
'isPrimary':
row['is_primary'],
'label':
_construct_course_label(
course_name=row['course_name'],
instruction_format=row['instruction_format'],
section_num=row['section_num'],
cross_listings=cross_listed_courses,
),
'meetings': {
'eligible': [],
'ineligible': [],
},
'nonstandardMeetingDates':
False,
'sectionId':
section_id,
'sectionNum':
row['section_num'],
'scheduled':
scheduled,
'termId':
row['term_id'],
}
courses_per_id[section_id] = course
# Note: Instructors associated with cross-listings are slurped up separately.
instructor_uid = row['instructor_uid']
if instructor_uid and instructor_uid not in [
i['uid'] for i in course['instructors']
]:
course['instructors'].append(
_to_instructor_json(
row=row,
approvals=course['approvals'],
invited_uids=course['invitees'],
), )
meeting = _to_meeting_json(row)
eligible_meetings = course['meetings']['eligible']
ineligible_meetings = course['meetings']['ineligible']
if not next((m for m in (eligible_meetings + ineligible_meetings)
if meeting.items() <= m.items()), None):
room = rooms_by_id.get(
row['room_id']) if 'room_id' in row.keys() else None
if room and room.capability:
meeting['eligible'] = True
meeting.update({
'recordingEndDate':
safe_strftime(get_recording_end_date(meeting), '%Y-%m-%d'),
'recordingStartDate':
safe_strftime(get_recording_start_date(meeting),
'%Y-%m-%d'),
})
eligible_meetings.append(meeting)
eligible_meetings.sort(
key=lambda m: f"{m['startDate']} {m['startTime']}")
if meeting['startDate'] != app.config[
'CURRENT_TERM_BEGIN'] or meeting[
'endDate'] != app.config['CURRENT_TERM_END']:
course['nonstandardMeetingDates'] = True
else:
meeting['eligible'] = False
ineligible_meetings.append(meeting)
ineligible_meetings.sort(
key=lambda m: f"{m['startDate']} {m['startTime']}")
if include_rooms:
meeting['room'] = room.to_api_json() if room else None
# Next, construct the feed
api_json = []
for section_id, course in courses_per_id.items():
_decorate_course(course)
# Add course to the feed
api_json.append(course)
return api_json
