def test_enable_self_generated_certs_on_publish_for_self_paced(self):
""" Verify the default behavior is maintained, self-generated certs enabled
for self-paced courses
"""
self.assertFalse(certs_api.cert_generation_enabled(self.course.id))
signals.toggle_self_generated_certs(self.course.id, self.course.self_paced)
self.assertTrue(certs_api.cert_generation_enabled(self.course.id))
def test_cert_generation_enabled_for_self_paced(self):
""" Verify the signal enable the self-generated certificates by default for
self-paced courses.
"""
self.assertFalse(certs_api.cert_generation_enabled(self.course.id))
_listen_for_course_publish('store', self.course.id)
self.assertTrue(certs_api.cert_generation_enabled(self.course.id))
def test_dont_enable_self_generated_certs_on_publish_for_instructor_paced(self):
""" Verify that self-generated certs are not enabled for instructor-paced courses
unless explicitly enabled by setting
"""
course = CourseFactory.create(self_paced=False)
self.assertFalse(certs_api.cert_generation_enabled(course.id))
signals.toggle_self_generated_certs(course.id, course.self_paced)
self.assertFalse(certs_api.cert_generation_enabled(course.id))
def test_cert_generation_flag_on_pacing_toggle(self):
"""
Verify that signal enables or disables self-generated certificates
according to course-pacing.
"""
self.course = CourseFactory.create(self_paced=False, emit_signals=True)
self.assertFalse(certs_api.cert_generation_enabled(self.course.id))
self.course.self_paced = True
self.store.update_item(self.course, self.user.id)
self.assertTrue(certs_api.cert_generation_enabled(self.course.id))
self.course.self_paced = False
self.store.update_item(self.course, self.user.id)
self.assertFalse(certs_api.cert_generation_enabled(self.course.id))
def _section_certificates(course):
"""Section information for the certificates panel.
The certificates panel allows global staff to generate
example certificates and enable self-generated certificates
for a course.
Arguments:
course (Course)
Returns:
dict
"""
example_cert_status = None
html_cert_enabled = certs_api.has_html_certificates_enabled(course.id, course)
if html_cert_enabled:
can_enable_for_course = True
else:
example_cert_status = certs_api.example_certificates_status(course.id)
# Allow the user to enable self-generated certificates for students
# *only* once a set of example certificates has been successfully generated.
# If certificates have been misconfigured for the course (for example, if
# the PDF template hasn't been uploaded yet), then we don't want
# to turn on self-generated certificates for students!
can_enable_for_course = example_cert_status is not None and all(
cert_status["status"] == "success" for cert_status in example_cert_status
)
instructor_generation_enabled = settings.FEATURES.get("CERTIFICATES_INSTRUCTOR_GENERATION", False)
certificate_statuses_with_count = {
certificate["status"]: certificate["count"]
for certificate in GeneratedCertificate.get_unique_statuses(course_key=course.id)
}
return {
"section_key": "certificates",
"section_display_name": _("Certificates"),
"example_certificate_status": example_cert_status,
"can_enable_for_course": can_enable_for_course,
"enabled_for_course": certs_api.cert_generation_enabled(course.id),
"instructor_generation_enabled": instructor_generation_enabled,
"html_cert_enabled": html_cert_enabled,
"active_certificate": certs_api.get_active_web_certificate(course),
"certificate_statuses_with_count": certificate_statuses_with_count,
"status": CertificateStatuses,
"certificate_generation_history": CertificateGenerationHistory.objects.filter(course_id=course.id).order_by(
"-created"
),
"urls": {
"generate_example_certificates": reverse("generate_example_certificates", kwargs={"course_id": course.id}),
"enable_certificate_generation": reverse("enable_certificate_generation", kwargs={"course_id": course.id}),
"start_certificate_generation": reverse("start_certificate_generation", kwargs={"course_id": course.id}),
"start_certificate_regeneration": reverse(
"start_certificate_regeneration", kwargs={"course_id": course.id}
),
"list_instructor_tasks_url": reverse("list_instructor_tasks", kwargs={"course_id": course.id}),
},
}
def test_cert_generation_flag_on_pacing_toggle(self):
"""
Verify that signal enables or disables self-generated certificates
according to course-pacing.
"""
#self-generation of cert disables by default
self.assertFalse(certs_api.cert_generation_enabled(self.course.id))
_listen_for_course_pacing_changed('store', self.course.id, self.course.self_paced)
#verify that self-generation of cert is enabled for self-paced course
self.assertTrue(certs_api.cert_generation_enabled(self.course.id))
self.course.self_paced = False
self.store.update_item(self.course, self.user.id)
_listen_for_course_pacing_changed('store', self.course.id, self.course.self_paced)
# verify that self-generation of cert is disabled for instructor-paced course
self.assertFalse(certs_api.cert_generation_enabled(self.course.id))
def test_dont_enable_self_generated_certs_on_publish_for_self_paced_when_disabled_by_setting(self):
""" Verify that self-generated certs are not enabled for self-paced courses
if it is explicitly disabled by setting
"""
self.mock_app_settings.DISABLE_SELF_GENERATED_CERTS_FOR_SELF_PACED = True
with mock.patch('appsembler_credentials_extensions.apps.course_certs_extensions.signals.app_settings',
new=self.mock_app_settings):
signals.toggle_self_generated_certs(self.course.id, self.course.self_paced)
self.assertFalse(certs_api.cert_generation_enabled(self.course.id))
def test_cert_generation_flag_on_pacing_toggle(self):
"""
Verify that signal enables or disables self-generated certificates
according to course-pacing.
"""
#self-generation of cert disables by default
self.assertFalse(certs_api.cert_generation_enabled(self.course.id))
_listen_for_course_pacing_changed('store', self.course.id, self.course.self_paced)
#verify that self-generation of cert is enabled for self-paced course
self.assertTrue(certs_api.cert_generation_enabled(self.course.id))
self.course.self_paced = False
self.store.update_item(self.course, self.user.id)
_listen_for_course_pacing_changed('store', self.course.id, self.course.self_paced)
# verify that self-generation of cert is disabled for instructor-paced course
self.assertFalse(certs_api.cert_generation_enabled(self.course.id))
def _section_certificates(course):
"""Section information for the certificates panel.
The certificates panel allows global staff to generate
example certificates and enable self-generated certificates
for a course.
Arguments:
course (Course)
Returns:
dict
"""
example_cert_status = certs_api.example_certificates_status(course.id)
# Allow the user to enable self-generated certificates for students
# *only* once a set of example certificates has been successfully generated.
# If certificates have been misconfigured for the course (for example, if
# the PDF template hasn't been uploaded yet), then we don't want
# to turn on self-generated certificates for students!
can_enable_for_course = (
example_cert_status is not None and
all(
cert_status['status'] == 'success'
for cert_status in example_cert_status
)
)
instructor_generation_enabled = settings.FEATURES.get('CERTIFICATES_INSTRUCTOR_GENERATION', False)
return {
'section_key': 'certificates',
'section_display_name': _('Certificates'),
'example_certificate_status': example_cert_status,
'can_enable_for_course': can_enable_for_course,
'enabled_for_course': certs_api.cert_generation_enabled(course.id),
'instructor_generation_enabled': instructor_generation_enabled,
'urls': {
'generate_example_certificates': reverse(
'generate_example_certificates',
kwargs={'course_id': course.id}
),
'enable_certificate_generation': reverse(
'enable_certificate_generation',
kwargs={'course_id': course.id}
),
'start_certificate_generation': reverse(
'start_certificate_generation',
kwargs={'course_id': course.id}
),
'list_instructor_tasks_url': reverse(
'list_instructor_tasks',
kwargs={'course_id': course.id}
),
}
}
def _section_certificates(course):
"""Section information for the certificates panel.
The certificates panel allows global staff to generate
example certificates and enable self-generated certificates
for a course.
Arguments:
course (Course)
Returns:
dict
"""
example_cert_status = certs_api.example_certificates_status(course.id)
# Allow the user to enable self-generated certificates for students
# *only* once a set of example certificates has been successfully generated.
# If certificates have been misconfigured for the course (for example, if
# the PDF template hasn't been uploaded yet), then we don't want
# to turn on self-generated certificates for students!
can_enable_for_course = (
example_cert_status is not None and
all(
cert_status['status'] == 'success'
for cert_status in example_cert_status
)
)
instructor_generation_enabled = settings.FEATURES.get('CERTIFICATES_INSTRUCTOR_GENERATION', False)
return {
'section_key': 'certificates',
'section_display_name': _('Certificates'),
'example_certificate_status': example_cert_status,
'can_enable_for_course': can_enable_for_course,
'enabled_for_course': certs_api.cert_generation_enabled(course.id),
'instructor_generation_enabled': instructor_generation_enabled,
'urls': {
'generate_example_certificates': reverse(
'generate_example_certificates',
kwargs={'course_id': course.id}
),
'enable_certificate_generation': reverse(
'enable_certificate_generation',
kwargs={'course_id': course.id}
),
'start_certificate_generation': reverse(
'start_certificate_generation',
kwargs={'course_id': course.id}
),
'list_instructor_tasks_url': reverse(
'list_instructor_tasks',
kwargs={'course_id': course.id}
),
}
}
def test_enable_self_generated_certs_on_publish_for_instructor_paced_if_always_enabled_by_setting(self):
""" Verify that self-generated certs are enabled for self-paced courses
if it is explicitly enabled by setting
"""
self.mock_app_settings.ALWAYS_ENABLE_SELF_GENERATED_CERTS = True
with mock.patch('appsembler_credentials_extensions.apps.course_certs_extensions.signals.app_settings',
new=self.mock_app_settings):
course = CourseFactory.create(self_paced=False)
signals.toggle_self_generated_certs(course.id, course.self_paced)
self.assertTrue(certs_api.cert_generation_enabled(course.id))
def test_enable_certificate_generation(self, is_enabled):
self.client.login(username=self.global_staff.username, password="******")
url = reverse("enable_certificate_generation", kwargs={"course_id": unicode(self.course.id)})
params = {"certificates-enabled": "true" if is_enabled else "false"}
response = self.client.post(url, data=params)
# Expect a redirect back to the instructor dashboard
self._assert_redirects_to_instructor_dash(response)
# Expect that certificate generation is now enabled for the course
actual_enabled = certs_api.cert_generation_enabled(self.course.id)
self.assertEqual(is_enabled, actual_enabled)
def get_cert_status(self):
student_id = self.scope_ids.user_id
course_id = str(self.xmodule_runtime.course_id)
course_key = CourseKey.from_string(course_id)
student = User.objects.prefetch_related("groups").get(id=student_id)
course = get_course_with_access(student, 'load', course_key, depth=None, check_if_enrolled=True)
show_generate_cert_btn = certs_api.cert_generation_enabled(course_key)
grade_summary = get_grades(course,student)
print "grade_summary====================",grade_summary
failed = None
if grade_summary["totaled_scores"]:
if grade_summary["percent"] < course.grading_policy["GRADE_CUTOFFS"]["Pass"]:
failed = True
context = {
'passed': grade_summary,
'course':course,
'student':student,
'failed':failed
}
if grade_summary["percent"] and grade_summary["percent"] >= course.grading_policy["GRADE_CUTOFFS"]["Pass"]:
print "in totaled score"
context.update({
'show_generate_cert_btn':True
})
cert_status = certs_api.certificate_downloadable_status(student, course_key)
context.update(cert_status)
# showing the certificate web view button if feature flags are enabled.
if certs_api.has_html_certificates_enabled(course_key, course):
if certs_api.get_active_web_certificate(course) is not None:
context.update({
'show_cert_web_view': True,
'cert_web_view_url': certs_api.get_certificate_url(course_id=course_key, uuid=cert_status['uuid']),
'show_generate_cert_btn':True
})
else:
context.update({
'is_downloadable': False,
'is_generating': True,
'download_url': None
})
print "outside totaled score"
return context
def test_enable_certificate_generation(self, is_enabled):
self.client.login(username=self.global_staff.username, password='******')
url = reverse('enable_certificate_generation',
kwargs={'course_id': unicode(self.course.id)})
params = {'certificates-enabled': 'true' if is_enabled else 'false'}
response = self.client.post(url, data=params)
# Expect a redirect back to the instructor dashboard
self._assert_redirects_to_instructor_dash(response)
# Expect that certificate generation is now enabled for the course
actual_enabled = certs_api.cert_generation_enabled(self.course.id)
self.assertEqual(is_enabled, actual_enabled)
def _assert_enabled_for_course(self, course_key, expect_enabled):
"""Check that self-generated certificates are enabled or disabled for the course. """
actual_enabled = certs_api.cert_generation_enabled(course_key)
self.assertEqual(expect_enabled, actual_enabled)
def _section_certificates(course):
"""Section information for the certificates panel.
The certificates panel allows global staff to generate
example certificates and enable self-generated certificates
for a course.
Arguments:
course (Course)
Returns:
dict
"""
example_cert_status = None
html_cert_enabled = certs_api.has_html_certificates_enabled(course.id, course)
if html_cert_enabled:
can_enable_for_course = True
else:
example_cert_status = certs_api.example_certificates_status(course.id)
# Allow the user to enable self-generated certificates for students
# *only* once a set of example certificates has been successfully generated.
# If certificates have been misconfigured for the course (for example, if
# the PDF template hasn't been uploaded yet), then we don't want
# to turn on self-generated certificates for students!
can_enable_for_course = (
example_cert_status is not None and
all(
cert_status['status'] == 'success'
for cert_status in example_cert_status
)
)
instructor_generation_enabled = settings.FEATURES.get('CERTIFICATES_INSTRUCTOR_GENERATION', False)
certificate_statuses_with_count = {
certificate['status']: certificate['count']
for certificate in GeneratedCertificate.get_unique_statuses(course_key=course.id)
}
return {
'section_key': 'certificates',
'section_display_name': _('Certificates'),
'example_certificate_status': example_cert_status,
'can_enable_for_course': can_enable_for_course,
'enabled_for_course': certs_api.cert_generation_enabled(course.id),
'is_self_paced': course.self_paced,
'instructor_generation_enabled': instructor_generation_enabled,
'html_cert_enabled': html_cert_enabled,
'active_certificate': certs_api.get_active_web_certificate(course),
'certificate_statuses_with_count': certificate_statuses_with_count,
'status': CertificateStatuses,
'certificate_generation_history':
CertificateGenerationHistory.objects.filter(course_id=course.id).order_by("-created"),
'urls': {
'generate_example_certificates': reverse(
'generate_example_certificates',
kwargs={'course_id': course.id}
),
'enable_certificate_generation': reverse(
'enable_certificate_generation',
kwargs={'course_id': course.id}
),
'start_certificate_generation': reverse(
'start_certificate_generation',
kwargs={'course_id': course.id}
),
'start_certificate_regeneration': reverse(
'start_certificate_regeneration',
kwargs={'course_id': course.id}
),
'list_instructor_tasks_url': reverse(
'list_instructor_tasks',
kwargs={'course_id': course.id}
),
}
}
def _section_certificates(course):
"""Section information for the certificates panel.
The certificates panel allows global staff to generate
example certificates and enable self-generated certificates
for a course.
Arguments:
course (Course)
Returns:
dict
"""
example_cert_status = None
html_cert_enabled = certs_api.has_html_certificates_enabled(
course.id, course)
if html_cert_enabled:
can_enable_for_course = True
else:
example_cert_status = certs_api.example_certificates_status(course.id)
# Allow the user to enable self-generated certificates for students
# *only* once a set of example certificates has been successfully generated.
# If certificates have been misconfigured for the course (for example, if
# the PDF template hasn't been uploaded yet), then we don't want
# to turn on self-generated certificates for students!
can_enable_for_course = (example_cert_status is not None and all(
cert_status['status'] == 'success'
for cert_status in example_cert_status))
instructor_generation_enabled = settings.FEATURES.get(
'CERTIFICATES_INSTRUCTOR_GENERATION', False)
certificate_statuses_with_count = {
certificate['status']: certificate['count']
for certificate in GeneratedCertificate.get_unique_statuses(
course_key=course.id)
}
return {
'section_key':
'certificates',
'section_display_name':
_('Certificates'),
'example_certificate_status':
example_cert_status,
'can_enable_for_course':
can_enable_for_course,
'enabled_for_course':
certs_api.cert_generation_enabled(course.id),
'instructor_generation_enabled':
instructor_generation_enabled,
'html_cert_enabled':
html_cert_enabled,
'active_certificate':
certs_api.get_active_web_certificate(course),
'certificate_statuses_with_count':
certificate_statuses_with_count,
'status':
CertificateStatuses,
'certificate_generation_history':
CertificateGenerationHistory.objects.filter(
course_id=course.id).order_by("-created"),
'urls': {
'generate_example_certificates':
reverse('generate_example_certificates',
kwargs={'course_id': course.id}),
'enable_certificate_generation':
reverse('enable_certificate_generation',
kwargs={'course_id': course.id}),
'start_certificate_generation':
reverse('start_certificate_generation',
kwargs={'course_id': course.id}),
'start_certificate_regeneration':
reverse('start_certificate_regeneration',
kwargs={'course_id': course.id}),
'list_instructor_tasks_url':
reverse('list_instructor_tasks', kwargs={'course_id': course.id}),
}
}
def _assert_enabled_for_course(self, course_key, expect_enabled):
"""Check that self-generated certificates are enabled or disabled for the course. """
actual_enabled = certs_api.cert_generation_enabled(course_key)
self.assertEqual(expect_enabled, actual_enabled)
