def fire_ungenerated_certificate_task(user,
course_key,
expected_verification_status=None):
"""
Helper function to fire un-generated certificate tasks
The 'mode_is_verified' query is copied from the GeneratedCertificate model,
but is done here in an attempt to reduce traffic to the workers.
If the learner is verified and their cert has the 'unverified' status,
we regenerate the cert.
"""
enrollment_mode, __ = CourseEnrollment.enrollment_mode_for_user(
user, course_key)
mode_is_verified = enrollment_mode in GeneratedCertificate.VERIFIED_CERTS_MODES
cert = GeneratedCertificate.certificate_for_student(user, course_key)
if mode_is_verified and (cert is None or cert.status == 'unverified'):
kwargs = {
'student': unicode(user.id),
'course_key': unicode(course_key)
}
if expected_verification_status:
kwargs['expected_verification_status'] = unicode(
expected_verification_status)
generate_certificate.apply_async(countdown=CERTIFICATE_DELAY_SECONDS,
kwargs=kwargs)
return True
def _listen_for_certificate_whitelist_append(sender, instance, **kwargs): # pylint: disable=unused-argument
switches = waffle.waffle()
# All flags enabled
if (not switches.is_enabled(waffle.SELF_PACED_ONLY)
and not switches.is_enabled(waffle.INSTRUCTOR_PACED_ONLY)):
return
# Only SELF_PACED_ONLY flag enabled
if not switches.is_enabled(waffle.INSTRUCTOR_PACED_ONLY):
if not courses.get_course_by_id(instance.course_id,
depth=0).self_paced:
return
# Only INSTRUCTOR_PACED_ONLY flag enabled
if not switches.is_enabled(waffle.SELF_PACED_ONLY):
if courses.get_course_by_id(instance.course_id, depth=0).self_paced:
return
generate_certificate.apply_async(
student=instance.user,
course_key=instance.course_id,
)
log.info(
u'Certificate generation task initiated for {user} : {course} via whitelist'
.format(user=instance.user.id, course=instance.course_id))
def fire_ungenerated_certificate_task(user, course_id):
"""
Helper function to fire un-generated certificate tasks
"""
if GeneratedCertificate.certificate_for_student(user, course_id) is None:
generate_certificate.apply_async(student=user, course_key=course_id)
return True
def _listen_for_passing_grade(sender, user, course_id, **kwargs): # pylint: disable=unused-argument
"""
Listen for a learner passing a course, send cert generation task,
downstream signal from COURSE_GRADE_CHANGED
"""
# No flags enabled
if (
not waffle.waffle().is_enabled(waffle.SELF_PACED_ONLY) and
not waffle.waffle().is_enabled(waffle.INSTRUCTOR_PACED_ONLY)
):
return
# Only SELF_PACED_ONLY flag enabled
if waffle.waffle().is_enabled(waffle.SELF_PACED_ONLY):
if not courses.get_course_by_id(course_key, depth=0).self_paced:
return
# Only INSTRUCTOR_PACED_ONLY flag enabled
elif waffle.waffle().is_enabled(waffle.INSTRUCTOR_PACED_ONLY):
if courses.get_course_by_id(course_key, depth=0).self_paced:
return
if GeneratedCertificate.certificate_for_student(self.user, self.course_id) is None:
generate_certificate.apply_async(
student=user,
course_key=course_id,
)
log.info(u'Certificate generation task initiated for {user} : {course} via passing grade'.format(
user=user.id,
course=course_id
))
def _listen_for_certificate_whitelist_append(sender, instance, **kwargs): # pylint: disable=unused-argument
switches = waffle.waffle()
# All flags enabled
if (
not switches.is_enabled(waffle.SELF_PACED_ONLY) and
not switches.is_enabled(waffle.INSTRUCTOR_PACED_ONLY)
):
return
# Only SELF_PACED_ONLY flag enabled
if not switches.is_enabled(waffle.INSTRUCTOR_PACED_ONLY):
if not courses.get_course_by_id(instance.course_id, depth=0).self_paced:
return
# Only INSTRUCTOR_PACED_ONLY flag enabled
if not switches.is_enabled(waffle.SELF_PACED_ONLY):
if courses.get_course_by_id(instance.course_id, depth=0).self_paced:
return
generate_certificate.apply_async(
student=instance.user,
course_key=instance.course_id,
)
log.info(u'Certificate generation task initiated for {user} : {course} via whitelist'.format(
user=instance.user.id,
course=instance.course_id
))
def fire_ungenerated_certificate_task(user, course_key):
"""
Helper function to fire un-generated certificate tasks
:param user: A User object.
:param course_id: A CourseKey object.
"""
if GeneratedCertificate.certificate_for_student(user, course_key) is None:
generate_certificate.apply_async(kwargs={
'student': unicode(user.id),
'course_key': unicode(course_key),
})
return True
def fire_ungenerated_certificate_task(user,
course_key,
expected_verification_status=None):
"""
Helper function to fire certificate generation task.
Auto-generation of certificates is available for following course modes:
1- VERIFIED
2- CREDIT_MODE
3- PROFESSIONAL
4- NO_ID_PROFESSIONAL_MODE
Certificate generation task is fired to either generate a certificate
when there is no generated certificate for user in a particular course or
update a certificate if it has 'unverified' status.
Task is fired to attempt an update to a certificate
with 'unverified' status as this method is called when a user is
successfully verified, any certificate associated
with such user can now be verified.
NOTE: Purpose of restricting other course modes (HONOR and AUDIT) from auto-generation is to reduce
traffic to workers.
"""
allowed_enrollment_modes_list = [
CourseMode.VERIFIED,
CourseMode.CREDIT_MODE,
CourseMode.PROFESSIONAL,
CourseMode.NO_ID_PROFESSIONAL_MODE,
]
enrollment_mode, __ = CourseEnrollment.enrollment_mode_for_user(
user, course_key)
cert = GeneratedCertificate.certificate_for_student(user, course_key)
generate_learner_certificate = (
enrollment_mode in allowed_enrollment_modes_list
and (cert is None or cert.status == 'unverified'))
if generate_learner_certificate:
kwargs = {
'student': unicode(user.id),
'course_key': unicode(course_key)
}
if expected_verification_status:
kwargs['expected_verification_status'] = unicode(
expected_verification_status)
generate_certificate.apply_async(countdown=CERTIFICATE_DELAY_SECONDS,
kwargs=kwargs)
return True
def fire_ungenerated_certificate_task(user, course_key):
"""
Helper function to fire un-generated certificate tasks
The 'mode_is_verified' query is copied from the GeneratedCertificate model,
but is done here in an attempt to reduce traffic to the workers.
If the learner is verified and their cert has the 'unverified' status,
we regenerate the cert.
"""
enrollment_mode, __ = CourseEnrollment.enrollment_mode_for_user(user, course_key)
mode_is_verified = enrollment_mode in GeneratedCertificate.VERIFIED_CERTS_MODES
cert = GeneratedCertificate.certificate_for_student(user, course_key)
if mode_is_verified and (cert is None or cert.status == 'unverified'):
generate_certificate.apply_async(kwargs={
'student': unicode(user.id),
'course_key': unicode(course_key),
})
return True
