def course_runs_with_state(self):
"""
Determine which course runs have been completed and failed by the user.
Returns:
dict with a list of completed and failed runs
"""
course_run_certificates = certificate_api.get_certificates_for_user(self.user.username)
completed_runs, failed_runs = [], []
for certificate in course_run_certificates:
certificate_type = certificate['type']
# Treat "no-id-professional" certificates as "professional" certificates
if certificate_type == CourseMode.NO_ID_PROFESSIONAL_MODE:
certificate_type = CourseMode.PROFESSIONAL
course_data = {
'course_run_id': unicode(certificate['course_key']),
'type': certificate_type,
}
if certificate_api.is_passing_status(certificate['status']):
completed_runs.append(course_data)
else:
failed_runs.append(course_data)
return {'completed': completed_runs, 'failed': failed_runs}
def course_runs_with_state(self):
"""
Determine which course runs have been completed and failed by the user.
Returns:
dict with a list of completed and failed runs
"""
course_run_certificates = certificate_api.get_certificates_for_user(
self.user.username)
completed_runs, failed_runs = [], []
for certificate in course_run_certificates:
certificate_type = certificate['type']
# Treat "no-id-professional" certificates as "professional" certificates
if certificate_type == CourseMode.NO_ID_PROFESSIONAL_MODE:
certificate_type = CourseMode.PROFESSIONAL
course_data = {
'course_run_id': unicode(certificate['course_key']),
'type': certificate_type,
}
if certificate_api.is_passing_status(certificate['status']):
completed_runs.append(course_data)
else:
failed_runs.append(course_data)
return {'completed': completed_runs, 'failed': failed_runs}
def course_runs_with_state(self):
"""
Determine which course runs have been completed and failed by the user.
A course run is considered completed for a user if they have a certificate in the correct state and
the certificate is available.
Returns:
dict with a list of completed and failed runs
"""
course_run_certificates = certificate_api.get_certificates_for_user(self.user.username)
completed_runs, failed_runs = [], []
for certificate in course_run_certificates:
course_key = certificate['course_key']
course_data = {
'course_run_id': str(course_key),
'type': self._certificate_mode_translation(certificate['type']),
}
try:
may_certify = CourseOverview.get_from_id(course_key).may_certify()
except CourseOverview.DoesNotExist:
may_certify = True
if (
certificate_api.is_passing_status(certificate['status'])
and may_certify
):
completed_runs.append(course_data)
else:
failed_runs.append(course_data)
return {'completed': completed_runs, 'failed': failed_runs}
def _available_date_for_program(self, program_data, certificates):
"""
Calculate the available date for the program based on the courses within it.
Arguments:
program_data (dict): nested courses and course runs
certificates (dict): course run key -> certificate mapping
Returns a datetime object or None if the program is not complete.
"""
program_available_date = None
for course in program_data['courses']:
earliest_course_run_date = None
for course_run in course['course_runs']:
key = CourseKey.from_string(course_run['key'])
# Get a certificate if one exists
certificate = certificates.get(key)
if certificate is None:
continue
# Modes must match (see _is_course_complete() comments for why)
course_run_mode = self._course_run_mode_translation(
course_run['type'])
certificate_mode = self._certificate_mode_translation(
certificate.mode)
modes_match = course_run_mode == certificate_mode
# Grab the available date and keep it if it's the earliest one for this catalog course.
if modes_match and certificate_api.is_passing_status(
certificate.status):
course_overview = CourseOverview.get_from_id(key)
available_date = available_date_for_certificate(
course_overview, certificate)
earliest_course_run_date = min([
date
for date in [available_date, earliest_course_run_date]
if date
])
# If we're missing a cert for a course, the program isn't completed and we should just bail now
if earliest_course_run_date is None:
return None
# Keep the catalog course date if it's the latest one
program_available_date = max([
date
for date in [earliest_course_run_date, program_available_date]
if date
])
return program_available_date
def completed_course_runs(self):
"""
Determine which course runs have been completed by the user.
Returns:
list of dicts, each representing a course run certificate
"""
course_run_certificates = certificate_api.get_certificates_for_user(self.user.username)
return [
{'course_run_id': unicode(certificate['course_key']), 'type': certificate['type']}
for certificate in course_run_certificates
if certificate_api.is_passing_status(certificate['status'])
]
def completed_course_runs(self):
"""
Determine which course runs have been completed by the user.
Returns:
list of dicts, each representing a course run certificate
"""
course_run_certificates = certificate_api.get_certificates_for_user(self.user.username)
return [
{'course_run_id': unicode(certificate['course_key']), 'type': certificate['type']}
for certificate in course_run_certificates
if certificate_api.is_passing_status(certificate['status'])
]
def test_certificate_status_visibility(self, status, is_passed_status):
"""
Verify that certificates are only displayed for passing status.
"""
# Add new certificate
cert = self._create_certificate(status=status)
cert.save()
# Ensure that this test is actually using both passing and non-passing certs.
self.assertEqual(is_passing_status(cert.status), is_passed_status)
response = self.client.get('/u/{username}'.format(username=self.user.username))
if is_passed_status:
self.assertContains(response, 'card certificate-card mode-{cert_mode}'.format(cert_mode=cert.mode))
else:
self.assertNotContains(response, 'card certificate-card mode-{cert_mode}'.format(cert_mode=cert.mode))
def test_certificate_status_visibility(self, status, is_passed_status):
"""
Verify that certificates are only displayed for passing status.
"""
# Add new certificate
cert = self._create_certificate(status=status)
cert.save()
# Ensure that this test is actually using both passing and non-passing certs.
self.assertEqual(is_passing_status(cert.status), is_passed_status)
response = self.client.get('/u/{username}'.format(username=self.user.username))
if is_passed_status:
self.assertContains(response, 'card certificate-card mode-{cert_mode}'.format(cert_mode=cert.mode))
else:
self.assertNotContains(response, 'card certificate-card mode-{cert_mode}'.format(cert_mode=cert.mode))
def get_completed_courses(student):
"""
Determine which courses have been completed by the user.
Args:
student:
User object representing the student
Returns:
iterable of dicts with structure {'course_id': course_key, 'mode': cert_type}
"""
all_certs = get_certificates_for_user(student.username)
return [{
'course_id': unicode(cert['course_key']),
'mode': cert['type']
} for cert in all_certs if is_passing_status(cert['status'])]
def get_completed_courses(student):
"""
Determine which courses have been completed by the user.
Args:
student:
User object representing the student
Returns:
iterable of dicts with structure {'course_id': course_key, 'mode': cert_type}
"""
all_certs = certificate_api.get_certificates_for_user(student.username)
return [
{'course_id': unicode(cert['course_key']), 'mode': cert['type']}
for cert in all_certs
if certificate_api.is_passing_status(cert['status'])
]
def course_runs_with_state(self):
"""
Determine which course runs have been completed and failed by the user.
Returns:
dict with a list of completed and failed runs
"""
course_run_certificates = certificate_api.get_certificates_for_user(
self.user.username)
completed_runs, failed_runs = [], []
for certificate in course_run_certificates:
course_data = {
'course_run_id': unicode(certificate['course_key']),
'type': certificate['type']
}
if certificate_api.is_passing_status(certificate['status']):
completed_runs.append(course_data)
else:
failed_runs.append(course_data)
return {'completed': completed_runs, 'failed': failed_runs}
def _available_date_for_program(self, program_data, certificates):
"""
Calculate the available date for the program based on the courses within it.
Arguments:
program_data (dict): nested courses and course runs
certificates (dict): course run key -> certificate mapping
Returns a datetime object or None if the program is not complete.
"""
program_available_date = None
for course in program_data['courses']:
earliest_course_run_date = None
for course_run in course['course_runs']:
key = CourseKey.from_string(course_run['key'])
# Get a certificate if one exists
certificate = certificates.get(key)
if certificate is None:
continue
# Modes must match (see _is_course_complete() comments for why)
course_run_mode = self._course_run_mode_translation(course_run['type'])
certificate_mode = self._certificate_mode_translation(certificate.mode)
modes_match = course_run_mode == certificate_mode
# Grab the available date and keep it if it's the earliest one for this catalog course.
if modes_match and certificate_api.is_passing_status(certificate.status):
course_overview = CourseOverview.get_from_id(key)
available_date = available_date_for_certificate(course_overview, certificate)
earliest_course_run_date = min(filter(None, [available_date, earliest_course_run_date]))
# If we're missing a cert for a course, the program isn't completed and we should just bail now
if earliest_course_run_date is None:
return None
# Keep the catalog course date if it's the latest one
program_available_date = max(filter(None, [earliest_course_run_date, program_available_date]))
return program_available_date
def course_runs_with_state(self):
"""
Determine which course runs have been completed and failed by the user.
Returns:
dict with a list of completed and failed runs
"""
course_run_certificates = certificate_api.get_certificates_for_user(self.user.username)
completed_runs, failed_runs = [], []
for certificate in course_run_certificates:
course_data = {
'course_run_id': unicode(certificate['course_key']),
'type': self._certificate_mode_translation(certificate['type']),
}
if certificate_api.is_passing_status(certificate['status']):
completed_runs.append(course_data)
else:
failed_runs.append(course_data)
return {'completed': completed_runs, 'failed': failed_runs}
