def __init__(self, context, users):
self.certs = _CertificateBulkContext(context, users)
self.teams = _TeamBulkContext(context, users)
self.enrollments = _EnrollmentBulkContext(context, users)
bulk_cache_cohorts(context.course_id, users)
BulkRoleCache.prefetch(users)
prefetch_course_and_subsection_grades(context.course_id, users)
BulkCourseTags.prefetch(context.course_id, users)
def bulk_gradebook_view_context(course_key, users):
"""
Prefetches all course and subsection grades in the given course for the given
list of users, also, fetch all the score relavant data,
storing the result in a RequestCache and deleting grades on context exit.
"""
prefetch_course_and_subsection_grades(course_key, users)
CourseEnrollment.bulk_fetch_enrollment_states(users, course_key)
cohorts.bulk_cache_cohorts(course_key, users)
BulkRoleCache.prefetch(users)
try:
yield
finally:
clear_prefetched_course_and_subsection_grades(course_key)
def bulk_gradebook_view_context(course_key, users):
"""
Prefetches all course and subsection grades in the given course for the given
list of users, also, fetch all the score relavant data,
storing the result in a RequestCache and deleting grades on context exit.
"""
prefetch_course_and_subsection_grades(course_key, users)
CourseEnrollment.bulk_fetch_enrollment_states(users, course_key)
cohorts.bulk_cache_cohorts(course_key, users)
BulkRoleCache.prefetch(users)
try:
yield
finally:
clear_prefetched_course_and_subsection_grades(course_key)
def get_rows_to_export(self):
"""
Return iterator of rows to export.
"""
enrollments = list(
_get_enrollments(self._course_key,
track=self.MASTERS_TRACK,
cohort=self.cohort))
grades_api.prefetch_course_and_subsection_grades(
self._course_key, [enroll['user'] for enroll in enrollments])
client = LearnerAPIClient()
intervention_list = client.courses(
self.course_id).user_engagement().get()
intervention_data = {val['username']: val for val in intervention_list}
for enrollment in enrollments:
grades = grades_api.get_subsection_grades(enrollment['user_id'],
self._course_key)
if self._subsection and (self.subsection_grade_max
or self.subsection_grade_min):
short_id = self._subsection.block_id[:8]
(filtered_subsection, _) = self._subsections[short_id]
subsection_grade = grades.get(filtered_subsection.location,
None)
if not subsection_grade:
continue
try:
effective_grade = (
subsection_grade.override.earned_graded_override /
subsection_grade.override.possible_graded_override
) * 100
except AttributeError:
effective_grade = (subsection_grade.earned_graded /
subsection_grade.possible_graded) * 100
if ((self.subsection_grade_min and
(effective_grade < self.subsection_grade_min))
or (self.subsection_grade_max and
(effective_grade > self.subsection_grade_max))):
continue
# pylint: disable=E1111
course_grade = grades_api.CourseGradeFactory().read(
enrollment['user'], course_key=self._course_key)
if self.course_grade_min or self.course_grade_max:
course_grade_normalized = (course_grade.percent * 100)
if ((self.course_grade_min and
(course_grade_normalized < self.course_grade_min)) or
(self.course_grade_max and
(course_grade_normalized > self.course_grade_max))):
continue
cohort = get_cohort(enrollment['user'],
self._course_key,
assign=False)
int_user = intervention_data.get(enrollment['user'].username, {})
row = {
'user_id':
enrollment['user_id'],
'username':
enrollment['username'],
'email':
enrollment['user'].email,
'student_key':
enrollment['student_uid'],
'full_name':
enrollment['full_name'],
'track':
enrollment['track'],
'course_id':
self.course_id,
'cohort':
cohort.name if cohort else None,
'number of videos overall':
int_user.get('videos_overall', 0),
'number of videos last week':
int_user.get('videos_last_week', 0),
'number of problems overall':
int_user.get('problems_overall', 0),
'number of problems last week':
int_user.get('problems_last_week', 0),
'number of correct problems overall':
int_user.get('correct_problems_overall', 0),
'number of correct problems last week':
int_user.get('correct_problems_last_week', 0),
'number of problem attempts overall':
int_user.get('problems_attempts_overall', 0),
'number of problem attempts last week':
int_user.get('problems_attempts_last_week', 0),
'number of forum posts overall':
int_user.get('forum_posts_overall', 0),
'number of forum posts last week':
int_user.get('forum_posts_last_week', 0),
'date last active':
int_user.get('date_last_active', 0),
'course grade letter':
course_grade.letter_grade,
'course grade numeric':
course_grade.percent
}
for block_id, (subsection,
display_name) in self._subsections.items():
row[f'name-{block_id}'] = display_name
grade = grades.get(subsection.location, None)
if grade:
if getattr(grade, 'override', None):
row[f'grade-{block_id}'] = grade.override.earned_graded_override
else:
row[f'grade-{block_id}'] = grade.earned_graded
yield row
def get_rows_to_export(self):
"""
Return iterator of rows to export.
"""
enrollments = list(
_get_enrollments(
self._course_key,
track=self.track,
cohort=self.cohort,
active_only=self.active_only,
excluded_course_roles=self.excluded_course_roles,
))
enrolled_users = [enroll['user'] for enroll in enrollments]
grades_api.prefetch_course_and_subsection_grades(
self._course_key, enrolled_users)
for enrollment in enrollments:
cohort = get_cohort(enrollment['user'],
self._course_key,
assign=False)
row = {
'user_id':
enrollment['user_id'],
'username':
enrollment['username'],
'student_key':
enrollment['student_uid']
if enrollment['track'] == 'masters' else None,
'track':
enrollment['track'],
'course_id':
self.course_id,
'cohort':
cohort.name if cohort else None,
}
grades = grades_api.get_subsection_grades(enrollment['user_id'],
self._course_key)
if self._subsection and (self.subsection_grade_max
or self.subsection_grade_min):
short_id = self._subsection.block_id[:8]
(filtered_subsection, _) = self._subsections[short_id]
subsection_grade = grades.get(filtered_subsection.location,
None)
if not subsection_grade:
continue
try:
effective_grade = (
subsection_grade.override.earned_graded_override /
subsection_grade.override.possible_graded_override
) * 100
except AttributeError:
effective_grade = (subsection_grade.earned_graded /
subsection_grade.possible_graded) * 100
if ( # pragma: no brach
(self.subsection_grade_min and
(effective_grade < self.subsection_grade_min))
or (self.subsection_grade_max and
(effective_grade > self.subsection_grade_max))):
continue
# pylint: disable=E1111
course_grade = grades_api.CourseGradeFactory().read(
enrollment['user'], course_key=self._course_key)
course_grade_normalized = course_grade.percent * 100
if ((self.course_grade_min
and course_grade_normalized < self.course_grade_min)
or (self.course_grade_max
and course_grade_normalized > self.course_grade_max)):
continue
for block_id, (subsection,
display_name) in self._subsections.items():
row[f'name-{block_id}'] = display_name
grade = grades.get(subsection.location, None)
if grade:
effective_grade = grade.earned_graded
row[f'original_grade-{block_id}'] = grade.earned_graded
try:
effective_grade = grade.override.earned_graded_override
row[f'previous_override-{block_id}'] = grade.override.earned_graded_override
except AttributeError:
row[f'previous_override-{block_id}'] = None
row[f'grade-{block_id}'] = effective_grade
yield row
