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 _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}), } }