class CourseAPIMixin(object):
access_token = None
course_api_enabled = False
course_api = None
course_id = None
@cached_property
def course_info(self):
"""
Returns course info.
All requests for course info should be made against this property to take advantage of caching.
"""
return self.get_course_info(self.course_id)
def dispatch(self, request, *args, **kwargs):
self.course_api_enabled = switch_is_active('enable_course_api')
if self.course_api_enabled and request.user.is_authenticated():
self.access_token = settings.COURSE_API_KEY or request.user.access_token
self.course_api = CourseStructureApiClient(settings.COURSE_API_URL,
self.access_token)
return super(CourseAPIMixin, self).dispatch(request, *args, **kwargs)
def _course_detail_cache_key(self, course_id):
return sanitize_cache_key(u'course_{}_details'.format(course_id))
def get_course_info(self, course_id):
"""
Retrieve course info from the Course API.
Retrieved data is cached.
Arguments
course_id -- ID of the course for which data should be retrieved
"""
key = self._course_detail_cache_key(course_id)
info = cache.get(key)
if not info:
try:
logger.debug("Retrieving detail for course: %s", course_id)
info = self.course_api.courses(course_id).get()
cache.set(key, info)
except HttpClientError as e:
logger.error("Unable to retrieve course info for %s: %s",
course_id, e)
info = {}
return info
def get_courses(self):
# Check the cache for the user's courses
key = sanitize_cache_key(u'user_{}_courses'.format(
self.request.user.pk))
courses = cache.get(key)
# If no cached courses, iterate over the data from the course API.
if not courses:
courses = []
page = 1
while page:
try:
logger.debug('Retrieving page %d of course info...', page)
response = self.course_api.courses.get(page=page,
page_size=100)
course_details = response['results']
# Cache the information so that it doesn't need to be retrieved later.
for course in course_details:
course_id = course['id']
_key = self._course_detail_cache_key(course_id)
cache.set(_key, course)
courses += course_details
if response['pagination']['next']:
page += 1
else:
page = None
logger.debug(
'Completed retrieval of course info. Retrieved info for %d courses.',
len(courses))
except HttpClientError as e:
logger.error("Unable to retrieve course data: %s", e)
page = None
break
cache.set(key, courses)
return courses
class CoursePerformancePresenter(CourseAPIPresenterMixin, CoursePresenter):
"""
Presenter for the performance page.
"""
# limit for the number of bars to display in the answer distribution chart
CHART_LIMIT = 12
# minimum screen space a grading policy bar will take up (even if a policy is 0%, display some bar)
MIN_POLICY_DISPLAY_PERCENT = 5
def __init__(self, access_token, course_id, timeout=settings.LMS_DEFAULT_TIMEOUT):
super(CoursePerformancePresenter, self).__init__(access_token, course_id, timeout)
self.grading_policy_client = CourseStructureApiClient(settings.GRADING_POLICY_API_URL, access_token)
def course_module_data(self):
try:
return self._course_module_data()
except BaseCourseError:
raise NotFoundError
def get_answer_distribution(self, problem_id, problem_part_id):
"""
Retrieve answer distributions for a particular module/problem and problem part.
"""
module = self.client.modules(self.course_id, problem_id)
api_response = module.answer_distribution()
questions = self._build_questions(api_response)
filtered_active_question = [i for i in questions if i['part_id'] == problem_part_id]
if not filtered_active_question:
raise NotFoundError
else:
active_question = filtered_active_question[0]['question']
answer_distributions = self._build_answer_distribution(api_response, problem_part_id)
problem_part_description = self._build_problem_description(problem_part_id, questions)
is_random = self._is_answer_distribution_random(answer_distributions)
answer_distribution_limited = None
if not is_random:
# only display the top in the chart
answer_distribution_limited = answer_distributions[:self.CHART_LIMIT]
answer_type = self._get_answer_type(answer_distributions)
last_updated = self.parse_api_datetime(answer_distributions[0]['created'])
self._last_updated = last_updated
return AnswerDistributionEntry(last_updated, questions, active_question, answer_distributions,
answer_distribution_limited, is_random, answer_type, problem_part_description)
def _build_problem_description(self, problem_part_id, questions):
""" Returns the displayable problem name. """
problem = [q for q in questions if q['part_id'] == problem_part_id][0]
return problem['short_description']
def _get_answer_type(self, answer_distributions):
"""
Returns either 'text' or 'numeric' to describe the answer and used in the JS table to format
and sort the dataset.
"""
field = 'answer_value'
for ad in answer_distributions:
if ad[field] is not None and not utils.number.is_number(ad[field]):
return 'text'
return 'numeric'
def _is_answer_distribution_random(self, answer_distributions):
"""
Problems are considered randomized if variant is populated with values
greater than 1.
"""
for ad in answer_distributions:
variant = ad['variant']
if variant is not None and variant is not 1:
return True
return False
# pylint: disable=redefined-variable-type
def _build_questions(self, answer_distributions):
"""
Builds the questions and part_id from the answer distribution. Displayed
drop down.
"""
questions = []
part_id_to_problem = {}
# Collect unique questions from the answer distribution
for question_answer in answer_distributions:
question = question_answer.get('question_text', None)
problem_name = question_answer.get('problem_display_name', None)
part_id_to_problem[question_answer['part_id']] = {
'question': question,
'problem_name': problem_name
}
for part_id, problem in part_id_to_problem.iteritems():
questions.append({
'part_id': part_id,
'question': problem['question'],
'problem_name': problem['problem_name']
})
utils.sorting.natural_sort(questions, 'part_id')
# add an enumerated label
has_parts = len(questions) > 1
for i, question in enumerate(questions):
text = question['question']
question_num = i + 1
question_template = _('Submissions')
short_description_template = ''
if text:
if has_parts:
question_template = _('Submissions for Part {part_number}: {part_description}')
short_description_template = _('Part {part_number}: {part_description}')
else:
question_template = _('Submissions: {part_description}')
short_description_template = _('{part_description}')
else:
if has_parts:
question_template = _('Submissions for Part {part_number}')
short_description_template = _('Part {part_number}')
# pylint: disable=no-member
question['question'] = question_template.format(part_number=question_num, part_description=text)
question['short_description'] = short_description_template.format(
part_number=question_num, part_description=text)
return questions
def _build_answer_distribution(self, api_response, problem_part_id):
""" Filter for this problem part and sort descending order. """
answer_distributions = [i for i in api_response if i['part_id'] == problem_part_id]
for answer_dist in answer_distributions:
# First and last response counts were added, we can handle both types of API responses at the moment.
# If just the count is specified it is assumed to be the last response count.
# TODO: teach downstream logic about first and last response counts
count = answer_dist.get('last_response_count')
if count is not None:
answer_dist['count'] = count
answer_distributions = sorted(answer_distributions, key=lambda a: -a['count'])
return answer_distributions
def grading_policy(self):
""" Returns the grading policy for the represented course."""
key = self.get_cache_key('grading_policy')
grading_policy = cache.get(key)
if not grading_policy:
logger.debug('Retrieving grading policy for course: %s', self.course_id)
grading_policy = self.grading_policy_client.courses(self.course_id).policy.get()
# Remove empty assignment types as they are not useful and will cause issues downstream.
grading_policy = [item for item in grading_policy if item['assignment_type']]
cache.set(key, grading_policy)
return grading_policy
def get_max_policy_display_percent(self, grading_policy):
"""
Returns the maximum width that a grading bar can be for display, given
the min width, MIN_POLICY_DISPLAY_PERCENT.
"""
max_percent = 100
for policy in grading_policy:
if policy['weight'] < (self.MIN_POLICY_DISPLAY_PERCENT / 100.0):
max_percent -= self.MIN_POLICY_DISPLAY_PERCENT
return max_percent
def assignment_types(self):
""" Returns the assignment types for the represented course."""
grading_policy = self.grading_policy()
# return the results in a similar format to the course structure for standard parsing
return [
{
'name': gp['assignment_type'],
'url': reverse('courses:performance:graded_content_by_type',
kwargs={
'course_id': self.course_id,
'assignment_type': slugify(gp['assignment_type'])
})
} for gp in grading_policy
]
def fetch_course_module_data(self):
# Implementation of abstract method. Returns problems from data api.
try:
problems = self.client.courses(self.course_id).problems()
except NotFoundError:
raise NoAnswerSubmissionsError(course_id=self.course_id)
return problems
def attach_computed_data(self, problem):
# Change the id key name
problem['id'] = problem.pop('module_id')
# Add an percent and incorrect_submissions field
total = problem['total_submissions']
problem['correct_percent'] = utils.math.calculate_percent(problem['correct_submissions'], total)
problem['incorrect_submissions'] = total - problem['correct_submissions']
problem['incorrect_percent'] = utils.math.calculate_percent(problem['incorrect_submissions'], total)
def post_process_adding_data_to_blocks(self, data, parent_block, child_block, url_func=None):
# not all problems have submissions
if data['part_ids']:
utils.sorting.natural_sort(data['part_ids'])
if url_func:
data['url'] = url_func(parent_block, child_block, data)
@property
def default_block_data(self):
return {
'total_submissions': 0,
'correct_submissions': 0,
'correct_percent': 0,
'incorrect_submissions': 0,
'incorrect_percent': 0,
'part_ids': []
}
def assignments(self, assignment_type=None):
""" Returns the assignments (and problems) for the represented course. """
assignment_type_name = None if assignment_type is None else assignment_type['name']
assignment_type_key = self.get_cache_key(u'assignments_{}'.format(assignment_type_name))
assignments = cache.get(assignment_type_key)
if not assignments:
all_assignments_key = self.get_cache_key(u'assignments')
assignments = cache.get(all_assignments_key)
if not assignments:
structure = self._get_structure()
assignments = CourseStructure.course_structure_to_assignments(
structure, graded=True, assignment_type=None)
cache.set(all_assignments_key, assignments)
if assignment_type:
assignment_type['name'] = assignment_type['name'].lower()
assignments = [assignment for assignment in assignments if
assignment['assignment_type'].lower() == assignment_type['name']]
self.add_child_data_to_parent_blocks(assignments, self._build_graded_answer_distribution_url)
self.attach_data_to_parents(assignments, self._build_assignment_url)
# Cache the data for the course-assignment_type combination.
cache.set(assignment_type_key, assignments)
return assignments
def attach_aggregated_data_to_parent(self, index, parent, url_func=None):
children = parent['children']
total_submissions = sum(child.get('total_submissions', 0) for child in children)
correct_submissions = sum(child.get('correct_submissions', 0) for child in children)
incorrect_submissions = total_submissions - correct_submissions
parent.update({
'total_submissions': total_submissions,
'correct_submissions': correct_submissions,
'correct_percent': utils.math.calculate_percent(correct_submissions, total_submissions),
'incorrect_submissions': incorrect_submissions,
'incorrect_percent': utils.math.calculate_percent(incorrect_submissions, total_submissions),
'index': index + 1,
'average_submissions': 0,
'average_correct_submissions': 0,
'average_incorrect_submissions': 0,
})
if parent['num_modules']:
num_modules = float(parent['num_modules'])
parent.update({
'average_submissions': total_submissions / num_modules,
'average_correct_submissions': correct_submissions / num_modules,
'average_incorrect_submissions': incorrect_submissions / num_modules,
})
# removing the URL keeps navigation between the menu and bar chart consistent
if url_func and parent['total_submissions'] > 0:
parent['url'] = url_func(parent)
def _build_graded_answer_distribution_url(self, parent, problem, parts):
return reverse('courses:performance:answer_distribution',
kwargs={
'course_id': self.course_id,
'assignment_id': parent['id'],
'problem_id': problem['id'],
'problem_part_id': parts['part_ids'][0]
})
def build_module_url_func(self, section_id):
def build_url(parent, problem, parts):
return reverse('courses:performance:ungraded_answer_distribution',
kwargs={
'course_id': self.course_id,
'section_id': section_id,
'subsection_id': parent['id'],
'problem_id': problem['id'],
'problem_part_id': parts['part_ids'][0]
})
return build_url
def _build_assignment_url(self, assignment):
return reverse('courses:performance:assignment', kwargs={
'course_id': self.course_id, 'assignment_id': assignment['id']})
def build_section_url(self, section):
return reverse('courses:performance:ungraded_section', kwargs={'course_id': self.course_id,
'section_id': section['id']})
def build_subsection_url_func(self, section_id):
"""
Returns a function for creating the ungraded subsection URL.
"""
# Using closures to keep the section ID available
def subsection_url(subsection):
return reverse('courses:performance:ungraded_subsection',
kwargs={'course_id': self.course_id,
'section_id': section_id,
'subsection_id': subsection['id']})
return subsection_url
def blocks_have_data(self, assignments):
if assignments:
for assignment in assignments:
if assignment['total_submissions'] > 0:
return True
return False
def assignment(self, assignment_id):
""" Retrieve a specific assignment. """
filtered = [assignment for assignment in self.assignments() if assignment['id'] == assignment_id]
if filtered:
return filtered[0]
return None
@property
def section_type_template(self):
return u'ungraded_sections_{}_{}'
@property
def all_sections_key(self):
return u'ungraded_sections'
@property
def module_type(self):
return 'problem'
@property
def module_graded_type(self):
"""
Get ungraded blocks.
This is a bit confusing as this presenter is used to show both graded and
ungraded content. The ungraded content uses CourseAPIPresenterMixin::course_structure
which then gets the module grade type for filtering.
"""
return False
class CoursePerformancePresenter(CourseAPIPresenterMixin, CoursePresenter):
"""
Presenter for the performance page.
"""
# limit for the number of bars to display in the answer distribution chart
CHART_LIMIT = 12
# minimum screen space a grading policy bar will take up (even if a policy is 0%, display some bar)
MIN_POLICY_DISPLAY_PERCENT = 5
def __init__(self, access_token, course_id, timeout=settings.LMS_DEFAULT_TIMEOUT):
super(CoursePerformancePresenter, self).__init__(access_token, course_id, timeout)
self.grading_policy_client = CourseStructureApiClient(settings.GRADING_POLICY_API_URL, access_token)
def course_module_data(self):
try:
return self._course_module_data()
except BaseCourseError:
raise NotFoundError
def get_answer_distribution(self, problem_id, problem_part_id):
"""
Retrieve answer distributions for a particular module/problem and problem part.
"""
module = self.client.modules(self.course_id, problem_id)
api_response = module.answer_distribution()
questions = self._build_questions(api_response)
filtered_active_question = [i for i in questions if i['part_id'] == problem_part_id]
if len(filtered_active_question) == 0:
raise NotFoundError
else:
active_question = filtered_active_question[0]['question']
answer_distributions = self._build_answer_distribution(api_response, problem_part_id)
problem_part_description = self._build_problem_description(problem_part_id, questions)
is_random = self._is_answer_distribution_random(answer_distributions)
answer_distribution_limited = None
if not is_random:
# only display the top in the chart
answer_distribution_limited = answer_distributions[:self.CHART_LIMIT]
answer_type = self._get_answer_type(answer_distributions)
last_updated = self.parse_api_datetime(answer_distributions[0]['created'])
self._last_updated = last_updated
return AnswerDistributionEntry(last_updated, questions, active_question, answer_distributions,
answer_distribution_limited, is_random, answer_type, problem_part_description)
def _build_problem_description(self, problem_part_id, questions):
""" Returns the displayable problem name. """
problem = [q for q in questions if q['part_id'] == problem_part_id][0]
return problem['short_description']
def _get_answer_type(self, answer_distributions):
"""
Returns either 'text' or 'numeric' to describe the answer and used in the JS table to format
and sort the dataset.
"""
field = 'answer_value'
for ad in answer_distributions:
if ad[field] is not None and not utils.number.is_number(ad[field]):
return 'text'
return 'numeric'
def _is_answer_distribution_random(self, answer_distributions):
"""
Problems are considered randomized if variant is populated with values
greater than 1.
"""
for ad in answer_distributions:
variant = ad['variant']
if variant is not None and variant is not 1:
return True
return False
# pylint: disable=redefined-variable-type
def _build_questions(self, answer_distributions):
"""
Builds the questions and part_id from the answer distribution. Displayed
drop down.
"""
questions = []
part_id_to_problem = {}
# Collect unique questions from the answer distribution
for question_answer in answer_distributions:
question = question_answer.get('question_text', None)
problem_name = question_answer.get('problem_display_name', None)
part_id_to_problem[question_answer['part_id']] = {
'question': question,
'problem_name': problem_name
}
for part_id, problem in part_id_to_problem.iteritems():
questions.append({
'part_id': part_id,
'question': problem['question'],
'problem_name': problem['problem_name']
})
utils.sorting.natural_sort(questions, 'part_id')
# add an enumerated label
has_parts = len(questions) > 1
for i, question in enumerate(questions):
text = question['question']
question_num = i + 1
question_template = _('Submissions')
short_description_template = ''
if text:
if has_parts:
question_template = _('Submissions for Part {part_number}: {part_description}')
short_description_template = _('Part {part_number}: {part_description}')
else:
question_template = _('Submissions: {part_description}')
short_description_template = _('{part_description}')
else:
if has_parts:
question_template = _('Submissions for Part {part_number}')
short_description_template = _('Part {part_number}')
# pylint: disable=no-member
question['question'] = question_template.format(part_number=question_num, part_description=text)
question['short_description'] = short_description_template.format(
part_number=question_num, part_description=text)
return questions
def _build_answer_distribution(self, api_response, problem_part_id):
""" Filter for this problem part and sort descending order. """
answer_distributions = [i for i in api_response if i['part_id'] == problem_part_id]
for answer_dist in answer_distributions:
# First and last response counts were added, we can handle both types of API responses at the moment.
# If just the count is specified it is assumed to be the last response count.
# TODO: teach downstream logic about first and last response counts
count = answer_dist.get('last_response_count')
if count is not None:
answer_dist['count'] = count
answer_distributions = sorted(answer_distributions, key=lambda a: -a['count'])
return answer_distributions
def grading_policy(self):
""" Returns the grading policy for the represented course."""
key = self.get_cache_key('grading_policy')
grading_policy = cache.get(key)
if not grading_policy:
logger.debug('Retrieving grading policy for course: %s', self.course_id)
grading_policy = self.grading_policy_client.courses(self.course_id).policy.get()
# Remove empty assignment types as they are not useful and will cause issues downstream.
grading_policy = [item for item in grading_policy if item['assignment_type']]
cache.set(key, grading_policy)
return grading_policy
def get_max_policy_display_percent(self, grading_policy):
"""
Returns the maximum width that a grading bar can be for display, given
the min width, MIN_POLICY_DISPLAY_PERCENT.
"""
max_percent = 100
for policy in grading_policy:
if policy['weight'] < (self.MIN_POLICY_DISPLAY_PERCENT / 100.0):
max_percent -= self.MIN_POLICY_DISPLAY_PERCENT
return max_percent
def assignment_types(self):
""" Returns the assignment types for the represented course."""
grading_policy = self.grading_policy()
# return the results in a similar format to the course structure for standard parsing
return [
{
'name': gp['assignment_type'],
'url': reverse('courses:performance:graded_content_by_type',
kwargs={
'course_id': self.course_id,
'assignment_type': slugify(gp['assignment_type'])
})
} for gp in grading_policy
]
def fetch_course_module_data(self):
# Implementation of abstract method. Returns problems from data api.
try:
problems = self.client.courses(self.course_id).problems()
except NotFoundError:
raise NoAnswerSubmissionsError(course_id=self.course_id)
return problems
def attach_computed_data(self, problem):
# Change the id key name
problem['id'] = problem.pop('module_id')
# Add an percent and incorrect_submissions field
total = problem['total_submissions']
problem['correct_percent'] = utils.math.calculate_percent(problem['correct_submissions'], total)
problem['incorrect_submissions'] = total - problem['correct_submissions']
problem['incorrect_percent'] = utils.math.calculate_percent(problem['incorrect_submissions'], total)
def post_process_adding_data_to_blocks(self, data, parent_block, child_block, url_func=None):
# not all problems have submissions
if len(data['part_ids']) > 0:
utils.sorting.natural_sort(data['part_ids'])
if url_func:
data['url'] = url_func(parent_block, child_block, data)
@property
def default_block_data(self):
return {
'total_submissions': 0,
'correct_submissions': 0,
'correct_percent': 0,
'incorrect_submissions': 0,
'incorrect_percent': 0,
'part_ids': []
}
def assignments(self, assignment_type=None):
""" Returns the assignments (and problems) for the represented course. """
assignment_type_name = None if assignment_type is None else assignment_type['name']
assignment_type_key = self.get_cache_key(u'assignments_{}'.format(assignment_type_name))
assignments = cache.get(assignment_type_key)
if not assignments:
all_assignments_key = self.get_cache_key(u'assignments')
assignments = cache.get(all_assignments_key)
if not assignments:
structure = self._get_structure()
assignments = CourseStructure.course_structure_to_assignments(
structure, graded=True, assignment_type=None)
cache.set(all_assignments_key, assignments)
if assignment_type:
assignment_type['name'] = assignment_type['name'].lower()
assignments = [assignment for assignment in assignments if
assignment['assignment_type'].lower() == assignment_type['name']]
self.add_child_data_to_parent_blocks(assignments, self._build_graded_answer_distribution_url)
self.attach_data_to_parents(assignments, self._build_assignment_url)
# Cache the data for the course-assignment_type combination.
cache.set(assignment_type_key, assignments)
return assignments
def attach_aggregated_data_to_parent(self, index, parent, url_func=None):
children = parent['children']
total_submissions = sum(child.get('total_submissions', 0) for child in children)
correct_submissions = sum(child.get('correct_submissions', 0) for child in children)
incorrect_submissions = total_submissions - correct_submissions
parent.update({
'total_submissions': total_submissions,
'correct_submissions': correct_submissions,
'correct_percent': utils.math.calculate_percent(correct_submissions, total_submissions),
'incorrect_submissions': incorrect_submissions,
'incorrect_percent': utils.math.calculate_percent(incorrect_submissions, total_submissions),
'index': index + 1,
'average_submissions': 0,
'average_correct_submissions': 0,
'average_incorrect_submissions': 0,
})
if parent['num_modules']:
num_modules = float(parent['num_modules'])
parent.update({
'average_submissions': total_submissions / num_modules,
'average_correct_submissions': correct_submissions / num_modules,
'average_incorrect_submissions': incorrect_submissions / num_modules,
})
# removing the URL keeps navigation between the menu and bar chart consistent
if url_func and parent['total_submissions'] > 0:
parent['url'] = url_func(parent)
def _build_graded_answer_distribution_url(self, parent, problem, parts):
return reverse('courses:performance:answer_distribution',
kwargs={
'course_id': self.course_id,
'assignment_id': parent['id'],
'problem_id': problem['id'],
'problem_part_id': parts['part_ids'][0]
})
def build_module_url_func(self, section_id):
def build_url(parent, problem, parts):
return reverse('courses:performance:ungraded_answer_distribution',
kwargs={
'course_id': self.course_id,
'section_id': section_id,
'subsection_id': parent['id'],
'problem_id': problem['id'],
'problem_part_id': parts['part_ids'][0]
})
return build_url
def _build_assignment_url(self, assignment):
return reverse('courses:performance:assignment', kwargs={
'course_id': self.course_id, 'assignment_id': assignment['id']})
def build_section_url(self, section):
return reverse('courses:performance:ungraded_section', kwargs={'course_id': self.course_id,
'section_id': section['id']})
def build_subsection_url_func(self, section_id):
"""
Returns a function for creating the ungraded subsection URL.
"""
# Using closures to keep the section ID available
def subsection_url(subsection):
return reverse('courses:performance:ungraded_subsection',
kwargs={'course_id': self.course_id,
'section_id': section_id,
'subsection_id': subsection['id']})
return subsection_url
def blocks_have_data(self, assignments):
if assignments:
for assignment in assignments:
if assignment['total_submissions'] > 0:
return True
return False
def assignment(self, assignment_id):
""" Retrieve a specific assignment. """
filtered = [assignment for assignment in self.assignments() if assignment['id'] == assignment_id]
if filtered:
return filtered[0]
else:
return None
@property
def section_type_template(self):
return u'ungraded_sections_{}_{}'
@property
def all_sections_key(self):
return u'ungraded_sections'
@property
def module_type(self):
return 'problem'
@property
def module_graded_type(self):
"""
Get ungraded blocks.
This is a bit confusing as this presenter is used to show both graded and
ungraded content. The ungraded content uses CourseAPIPresenterMixin::course_structure
which then gets the module grade type for filtering.
"""
return False
class CourseAPIMixin(object):
access_token = None
course_api_enabled = False
course_api = None
course_id = None
@cached_property
def course_info(self):
"""
Returns course info.
All requests for course info should be made against this property to take advantage of caching.
"""
return self.get_course_info(self.course_id)
def dispatch(self, request, *args, **kwargs):
self.course_api_enabled = switch_is_active('enable_course_api')
if self.course_api_enabled and request.user.is_authenticated():
self.access_token = settings.COURSE_API_KEY or request.user.access_token
self.course_api = CourseStructureApiClient(settings.COURSE_API_URL, self.access_token)
return super(CourseAPIMixin, self).dispatch(request, *args, **kwargs)
def _course_detail_cache_key(self, course_id):
return sanitize_cache_key(u'course_{}_details'.format(course_id))
def get_course_info(self, course_id):
"""
Retrieve course info from the Course API.
Retrieved data is cached.
Arguments
course_id -- ID of the course for which data should be retrieved
"""
key = self._course_detail_cache_key(course_id)
info = cache.get(key)
if not info:
try:
logger.debug("Retrieving detail for course: %s", course_id)
info = self.course_api.courses(course_id).get()
cache.set(key, info)
except HttpClientError as e:
logger.error("Unable to retrieve course info for %s: %s", course_id, e)
info = {}
return info
def get_courses(self):
# Check the cache for the user's courses
key = sanitize_cache_key(u'user_{}_courses'.format(self.request.user.pk))
courses = cache.get(key)
# If no cached courses, iterate over the data from the course API.
if not courses:
courses = []
page = 1
while page:
try:
logger.debug('Retrieving page %d of course info...', page)
response = self.course_api.courses.get(page=page, page_size=100)
course_details = response['results']
# Cache the information so that it doesn't need to be retrieved later.
for course in course_details:
course_id = course['id']
_key = self._course_detail_cache_key(course_id)
cache.set(_key, course)
courses += course_details
if response['pagination']['next']:
page += 1
else:
page = None
logger.debug('Completed retrieval of course info. Retrieved info for %d courses.', len(courses))
except HttpClientError as e:
logger.error("Unable to retrieve course data: %s", e)
page = None
break
cache.set(key, courses)
return courses
