Skip to content

E
edx-platform
Commit 426bdbb6 by John Jarvis
Options

Updating the certificate app for testing

parent 1767719e
Showing with 91 additions and 156 deletions
lms/djangoapps/certificates/management/commands/ungenerated_certs.py
from django.utils.simplejson import dumps from django.utils.simplejson import dumps
from django.core.management.base import BaseCommand, CommandError from django.core.management.base import BaseCommand, CommandError
from certificates.models import GeneratedCertificate from certificates.models import GeneratedCertificate
from courseware import grades, courses
from django.contrib.auth.models import User
from django.test.client import RequestFactory
from profilehooks import profile
import cProfile
from pprint import pprint
from capa.xqueue_interface import XQueueInterface
from capa.xqueue_interface import make_xheader
from django.conf import settings
from requests.auth import HTTPBasicAuth
class Command(BaseCommand): class Command(BaseCommand):
help = """ help = """
This command finds all GeneratedCertificate objects that do not have a This command finds all users that have not been graded
certificate generated. These come into being when a user requests a for a single course.
certificate, or when grade_all_students is called (for pre-generating
certificates).
It returns a json formatted list of users and their user ids It returns a json formatted list of users and their user ids
""" """
# @profile
def _grade(self,student, request, course):
grades.grade(student, request, course)
def handle(self, *args, **options): def handle(self, *args, **options):
users = GeneratedCertificate.objects.filter( factory = RequestFactory()
download_url=None) course_id = 'BerkeleyX/CS169.1x/2012_Fall'
user_output = [{'user_id':user.user_id, 'name':user.name} course = courses.get_course_by_id(course_id)
for user in users] if settings.XQUEUE_INTERFACE.get('basic_auth') is not None:
self.stdout.write(dumps(user_output) + "\n") requests_auth = HTTPBasicAuth(
*settings.XQUEUE_INTERFACE['basic_auth'])
else:
requests_auth = None
xqueue_interface = XQueueInterface(
settings.XQUEUE_INTERFACE['url'],
settings.XQUEUE_INTERFACE['django_auth'],
requests_auth,
)
header = make_xheader('/certificate', 'foo', 'test-pull')
print "Sending test message to queue"
xqueue_interface.send_to_queue(header, { 'test': 'foo' })
#enrolled_students = User.objects.filter(
# courseenrollment__course_id=course_id).prefetch_related(
# "groups").order_by('username')
#generated_certificates = GeneratedCertificate.objects.filter(
# course_id=course_id)
#request = factory.get('/')
#student = User.objects.get(username='03199618')
#print "total students: {0}".format(len(enrolled_students))
#count = 0
#for student in enrolled_students:
# count += 1
# if count % 1000 == 0:
# print "{0}/{1}".format(count, len(enrolled_students))
# grades.grade(student, request, course)
#for student in enrolled_students:
# g = grades.grade(student, request, course)
# if g['grade'] is not None:
# print str(student)
# pprint(g)
# break
lms/djangoapps/certificates/models.py
...@@ -23,13 +23,14 @@ on the course overview page. ...@@ -23,13 +23,14 @@ on the course overview page.
class GeneratedCertificate(models.Model): class GeneratedCertificate(models.Model):
user = models.ForeignKey(User) user = models.ForeignKey(User)
course_id = models.CharField(max_length=255) course_id = models.CharField(max_length=255, default=False)
certificate_id = models.CharField(max_length=32) certificate_id = models.CharField(max_length=32, default=False)
graded_certificate_id = models.CharField(max_length=32) graded_certificate_id = models.CharField(max_length=32, default=False)
download_url = models.CharField(max_length=128) download_url = models.CharField(max_length=128, default=False)
graded_download_url = models.CharField(max_length=128) graded_download_url = models.CharField(max_length=128, default=False)
grade = models.CharField(max_length=5) grade = models.CharField(max_length=5, default=False)
key = models.CharField(max_length=32, default=False)
# enabled should only be true if the student has earned a passing grade # enabled should only be true if the student has earned a passing grade
# in the course. # in the course.
......
lms/djangoapps/certificates/views.py
import json
import logging import logging
import uuid from certificates.models import GeneratedCertificate
from pprint import pprint
from django.conf import settings
from django.contrib.auth.decorators import login_required
from django.core.mail import send_mail
from django.http import Http404, HttpResponse
from django.shortcuts import redirect
import courseware.grades as grades
from certificates.models import GeneratedCertificate, certificate_state_for_student, revoke_certificate
from mitxmako.shortcuts import render_to_response, render_to_string
from student.models import UserProfile
#TODO: Finish migrating these changes from stable
# from student.survey_questions import exit_survey_list_for_student
# from student.views import student_took_survey, record_exit_survey
log = logging.getLogger("mitx.certificates") log = logging.getLogger("mitx.certificates")
@login_required def update_certificate(request):
def certificate_request(request): """
''' Attempt to send a certificate. ''' Will update GeneratedCertificate for a new certificate or
if not settings.END_COURSE_ENABLED: modify an existing certificate entry.
raise Http404 """
if request.method == "POST": if request.method == "POST":
honor_code_verify = request.POST.get('cert_request_honor_code_verify', 'false') pprint(request)
name_verify = request.POST.get('cert_request_name_verify', 'false') # user = request.POST.get('user')
id_verify = request.POST.get('cert_request_id_verify', 'false') # try:
error = '' # generated_certificate = GeneratedCertificate.objects.get(
# key=key)
def return_error(error): # except GeneratedCertificate.DoesNotExist:
return HttpResponse(json.dumps({'success': False, # generated_certificate = GeneratedCertificate(user=user)
'error': error})) #
# enabled = request.POST.get('enabled')
if honor_code_verify != 'true': # enabled = True if enabled == 'True' else False
error += 'Please verify that you have followed the honor code to receive a certificate. ' # generated_certificate.grade = request.POST.get('grade')
# generated_certificate.download_url = request.POST.get('download_url')
if name_verify != 'true': # generated_certificate.graded_download_url = request.POST.get(
error += 'Please verify that your name is correct to receive a certificate. ' # 'graded_download_url')
# generated_certificate.course_id = request.POST.get('course_id')
if id_verify != 'true': # generated_certificate.enabled = enabled
error += 'Please certify that you understand the unique ID on the certificate. ' # generated_certificate.save()
if len(error) > 0:
return return_error(error)
survey_response = record_exit_survey(request, internal_request=True)
if not survey_response['success']:
return return_error(survey_response['error'])
grade = None
student_gradesheet = grades.grade(request.user, request, course)
grade = student_gradesheet['grade']
if not grade:
return return_error('You have not earned a grade in this course. ')
generate_certificate(request.user, grade)
return HttpResponse(json.dumps({'success': True}))
else:
#This is not a POST, we should render the page with the form
student_gradesheet = grades.grade(request.user, request, course)
certificate_state = certificate_state_for_student(request.user, grade_sheet['grade'])
if certificate_state['state'] != "requestable":
return redirect("/profile")
user_info = UserProfile.objects.get(user=request.user)
took_survey = student_took_survey(user_info)
if settings.DEBUG_SURVEY:
took_survey = False
survey_list = []
if not took_survey:
survey_list = exit_survey_list_for_student(request.user)
context = {'certificate_state': certificate_state,
'took_survey': took_survey,
'survey_list': survey_list,
'name': user_info.name}
return render_to_response('cert_request.html', context)
# This method should only be called if the user has a grade and has requested a certificate
def generate_certificate(user, grade):
# Make sure to see the comments in models.GeneratedCertificate to read about the valid
# states for a GeneratedCertificate object
if grade and user.is_active:
generated_certificate = None
try:
generated_certificate = GeneratedCertificate.objects.get(user=user)
except GeneratedCertificate.DoesNotExist:
generated_certificate = GeneratedCertificate(user=user)
generated_certificate.enabled = True
if generated_certificate.graded_download_url and (generated_certificate.grade != grade):
log.critical(u"A graded certificate has been pre-generated with the grade "
"of {gen_grade} but requested by user id {userid} with grade "
"{req_grade}! The download URLs were {graded_dl_url} and "
"{ungraded_dl_url}".format(
gen_grade=generated_certificate.grade,
req_grade=grade,
graded_dl_url=generated_certificate.graded_download_url,
ungraded_dl_url=generated_certificate.download_url,
userid=user.id))
revoke_certificate(generated_certificate, "The grade on this certificate may be inaccurate.")
user_name = UserProfile.objects.get(user=user).name
if generated_certificate.download_url and (generated_certificate.name != user_name):
log.critical(u"A Certificate has been pre-generated with the name of "
"{gen_name} but current name is {user_name} (user id is "
"{userid})! The download URLs were {graded_dl_url} and "
"{ungraded_dl_url}".format(
gen_name=generated_certificate.name.encode('utf-8'),
user_name=user_name.encode('utf-8'),
graded_dl_url=generated_certificate.graded_download_url,
ungraded_dl_url=generated_certificate.download_url,
userid=user.id))
revoke_certificate(generated_certificate, "The name on this certificate may be inaccurate.")
generated_certificate.grade = grade
generated_certificate.name = user_name
generated_certificate.save()
certificate_id = generated_certificate.certificate_id
log.debug("Generating certificate for " + str(user.username) + " with ID: " + str(certificate_id))
# TODO: If the certificate was pre-generated, send the email that it is ready to download
if certificate_state_for_student(user, grade)['state'] == "downloadable":
subject = render_to_string('emails/certificate_ready_subject.txt', {})
subject = ''.join(subject.splitlines())
message = render_to_string('emails/certificate_ready.txt', {})
res = send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [user.email, ])
else:
log.warning("Asked to generate a certificate for student " + str(user.username) + " but with a grade of " + str(grade) + " and active status " + str(user.is_active))
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment