Skip to content

E
edx-platform
Commit 9aa0a01c by Saleem Latif
Options

Allow PMs to Invalidate Certificates

parent 5e972b2a
Showing with 833 additions and 24 deletions
common/test/acceptance/pages/lms/instructor_dashboard.py
......@@ -1006,6 +1006,16 @@ class CertificatesPage(PageObject):
)
self.wait_for_element_visibility('#add-exception', 'Add Exception button is visible')
def wait_for_certificate_invalidations_section(self): # pylint: disable=invalid-name
"""
Wait for certificate invalidations section to be rendered on page
"""
self.wait_for_element_visibility(
'div.certificate-invalidation-container',
'Certificate invalidations section is visible.'
)
self.wait_for_element_visibility('#invalidate-certificate', 'Invalidate Certificate button is visible')
def refresh(self):
"""
Refresh Certificates Page and wait for the page to load completely.
......@@ -1064,6 +1074,42 @@ class CertificatesPage(PageObject):
"""
self.get_selector('#add-exception').click()
def add_certificate_invalidation(self, student, notes):
"""
Add certificate invalidation for 'student'.
"""
self.wait_for_element_visibility('#invalidate-certificate', 'Invalidate Certificate button is visible')
self.get_selector('#certificate-invalidation-user').fill(student)
self.get_selector('#certificate-invalidation-notes').fill(notes)
self.get_selector('#invalidate-certificate').click()
self.wait_for_ajax()
self.wait_for(
lambda: student in self.get_selector('div.invalidation-history table tr:last-child td').text,
description='Certificate invalidation added to list.'
)
def remove_first_certificate_invalidation(self):
"""
Remove certificate invalidation from the invalidation list.
"""
self.wait_for_element_visibility('#invalidate-certificate', 'Invalidate Certificate button is visible')
self.get_selector('div.invalidation-history table tr td .re-validate-certificate').first.click()
self.wait_for_ajax()
def fill_certificate_invalidation_user_name_field(self, student): # pylint: disable=invalid-name
"""
Fill username/email field with given text
"""
self.get_selector('#certificate-invalidation-user').fill(student)
def click_invalidate_certificate_button(self):
"""
Click 'Invalidate Certificate' button in 'certificates invalidations' section
"""
self.get_selector('#invalidate-certificate').click()
@property
def generate_certificates_button(self):
"""
......@@ -1111,4 +1157,18 @@ class CertificatesPage(PageObject):
"""
Returns the Message (error/success) in "Certificate Exceptions" section.
"""
return self.get_selector('div.message')
return self.get_selector('.certificate-exception-container div.message')
@property
def last_certificate_invalidation(self):
"""
Returns last certificate invalidation from "Certificate Invalidations" section.
"""
return self.get_selector('div.certificate-invalidation-container table tr:last-child td')
@property
def certificate_invalidation_message(self): # pylint: disable=invalid-name
"""
Returns the message (error/success) in "Certificate Invalidation" section.
"""
return self.get_selector('.certificate-invalidation-container div.message')
lms/djangoapps/certificates/migrations/0007_certificateinvalidation.py 0 → 100644
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import migrations, models
import django.utils.timezone
from django.conf import settings
import model_utils.fields
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('certificates', '0006_certificatetemplateasset_asset_slug'),
]
operations = [
migrations.CreateModel(
name='CertificateInvalidation',
fields=[
('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
('created', model_utils.fields.AutoCreatedField(default=django.utils.timezone.now, verbose_name='created', editable=False)),
('modified', model_utils.fields.AutoLastModifiedField(default=django.utils.timezone.now, verbose_name='modified', editable=False)),
('notes', models.TextField(default=None, null=True)),
('active', models.BooleanField(default=True)),
('generated_certificate', models.ForeignKey(to='certificates.GeneratedCertificate')),
('invalidated_by', models.ForeignKey(to=settings.AUTH_USER_MODEL)),
],
),
]
lms/djangoapps/certificates/models.py
......@@ -253,6 +253,12 @@ class GeneratedCertificate(models.Model):
self.save()
def is_valid(self):
"""
Return True if certificate is valid else return False.
"""
return self.status == CertificateStatuses.downloadable
class CertificateGenerationHistory(TimeStampedModel):
"""
......@@ -309,6 +315,59 @@ class CertificateGenerationHistory(TimeStampedModel):
("regenerated" if self.is_regeneration else "generated", self.generated_by, self.created, self.course_id)
class CertificateInvalidation(TimeStampedModel):
"""
Model for storing Certificate Invalidation.
"""
generated_certificate = models.ForeignKey(GeneratedCertificate)
invalidated_by = models.ForeignKey(User)
notes = models.TextField(default=None, null=True)
active = models.BooleanField(default=True)
class Meta(object):
app_label = "certificates"
def __unicode__(self):
return u"Certificate %s, invalidated by %s on %s." % \
(self.generated_certificate, self.invalidated_by, self.created)
def deactivate(self):
"""
Deactivate certificate invalidation by setting active to False.
"""
self.active = False
self.save()
@classmethod
def get_certificate_invalidations(cls, course_key, student=None):
"""
Return certificate invalidations filtered based on the provided course and student (if provided),
Returned value is JSON serializable list of dicts, dict element would have the following key-value pairs.
1. id: certificate invalidation id (primary key)
2. user: username of the student to whom certificate belongs
3. invalidated_by: user id of the instructor/support user who invalidated the certificate
4. created: string containing date of invalidation in the following format "December 29, 2015"
5. notes: string containing notes regarding certificate invalidation.
"""
certificate_invalidations = cls.objects.filter(
generated_certificate__course_id=course_key,
active=True,
)
if student:
certificate_invalidations = certificate_invalidations.filter(generated_certificate__user=student)
data = []
for certificate_invalidation in certificate_invalidations:
data.append({
'id': certificate_invalidation.id,
'user': certificate_invalidation.generated_certificate.user.username,
'invalidated_by': certificate_invalidation.invalidated_by.username,
'created': certificate_invalidation.created.strftime("%B %d, %Y"),
'notes': certificate_invalidation.notes,
})
return data
@receiver(post_save, sender=GeneratedCertificate)
def handle_post_cert_generated(sender, instance, **kwargs): # pylint: disable=unused-argument
"""
......
lms/djangoapps/certificates/tests/factories.py
......@@ -9,7 +9,7 @@ from student.models import LinkedInAddToProfileConfiguration
from certificates.models import (
GeneratedCertificate, CertificateStatuses, CertificateHtmlViewConfiguration, CertificateWhitelist, BadgeAssertion,
BadgeImageConfiguration,
BadgeImageConfiguration, CertificateInvalidation,
)
......@@ -35,6 +35,15 @@ class CertificateWhitelistFactory(DjangoModelFactory):
notes = 'Test Notes'
class CertificateInvalidationFactory(DjangoModelFactory):
class Meta(object):
model = CertificateInvalidation
notes = 'Test Notes'
active = True
class BadgeAssertionFactory(DjangoModelFactory):
class Meta(object):
model = BadgeAssertion
......
lms/djangoapps/instructor/views/api.py
......@@ -89,7 +89,7 @@ from instructor.views import INVOICE_KEY
from submissions import api as sub_api # installed from the edx-submissions repository
from certificates import api as certs_api
from certificates.models import CertificateWhitelist, GeneratedCertificate, CertificateStatuses
from certificates.models import CertificateWhitelist, GeneratedCertificate, CertificateStatuses, CertificateInvalidation
from bulk_email.models import CourseEmail
from student.models import get_user_by_username_or_email
......@@ -2839,26 +2839,53 @@ def parse_request_data_and_get_user(request, course_key):
:param course_key: Course Identifier of the course for whom to process certificate exception
:return: key-value pairs containing certificate exception data and User object
"""
try:
certificate_exception = json.loads(request.body or '{}')
except ValueError:
raise ValueError(_('The record is not in the correct format. Please add a valid username or email address.'))
certificate_exception = parse_request_data(request)
user = certificate_exception.get('user_name', '') or certificate_exception.get('user_email', '')
if not user:
raise ValueError(_('Student username/email field is required and can not be empty. '
'Kindly fill in username/email and then press "Add to Exception List" button.'))
db_user = get_student(user, course_key)
return certificate_exception, db_user
def parse_request_data(request):
"""
Parse and return request data, raise ValueError in case of invalid JSON data.
:param request: HttpRequest request object.
:return: dict object containing parsed json data.
"""
try:
data = json.loads(request.body or '{}')
except ValueError:
raise ValueError(_('The record is not in the correct format. Please add a valid username or email address.'))
return data
def get_student(username_or_email, course_key):
"""
Retrieve and return User object from db, raise ValueError
if user is does not exists or is not enrolled in the given course.
:param username_or_email: String containing either user name or email of the student.
:param course_key: CourseKey object identifying the current course.
:return: User object
"""
try:
db_user = get_user_by_username_or_email(user)
student = get_user_by_username_or_email(username_or_email)
except ObjectDoesNotExist:
raise ValueError(_("{user} does not exist in the LMS. Please check your spelling and retry.").format(user=user))
raise ValueError(_("{user} does not exist in the LMS. Please check your spelling and retry.").format(
user=username_or_email
))
# Make Sure the given student is enrolled in the course
if not CourseEnrollment.is_enrolled(db_user, course_key):
if not CourseEnrollment.is_enrolled(student, course_key):
raise ValueError(_("{user} is not enrolled in this course. Please check your spelling and retry.")
.format(user=user))
return certificate_exception, db_user
.format(user=username_or_email))
return student
@transaction.non_atomic_requests
......@@ -3014,3 +3041,142 @@ def generate_bulk_certificate_exceptions(request, course_id): # pylint: disable
}
return JsonResponse(results)
@transaction.non_atomic_requests
@ensure_csrf_cookie
@cache_control(no_cache=True, no_store=True, must_revalidate=True)
@require_global_staff
@require_http_methods(['POST', 'DELETE'])
def certificate_invalidation_view(request, course_id):
"""
Invalidate/Re-Validate students to/from certificate.
:param request: HttpRequest object
:param course_id: course identifier of the course for whom to add/remove certificates exception.
:return: JsonResponse object with success/error message or certificate invalidation data.
"""
course_key = CourseKey.from_string(course_id)
# Validate request data and return error response in case of invalid data
try:
certificate_invalidation_data = parse_request_data(request)
certificate = validate_request_data_and_get_certificate(certificate_invalidation_data, course_key)
except ValueError as error:
return JsonResponse({'message': error.message}, status=400)
# Invalidate certificate of the given student for the course course
if request.method == 'POST':
try:
certificate_invalidation = invalidate_certificate(request, certificate, certificate_invalidation_data)
except ValueError as error:
return JsonResponse({'message': error.message}, status=400)
return JsonResponse(certificate_invalidation)
# Re-Validate student certificate for the course course
elif request.method == 'DELETE':
try:
re_validate_certificate(request, course_key, certificate)
except ValueError as error:
return JsonResponse({'message': error.message}, status=400)
return JsonResponse({}, status=204)
def invalidate_certificate(request, generated_certificate, certificate_invalidation_data):
"""
Invalidate given GeneratedCertificate and add CertificateInvalidation record for future reference or re-validation.
:param request: HttpRequest object
:param generated_certificate: GeneratedCertificate object, the certificate we want to invalidate
:param certificate_invalidation_data: dict object containing data for CertificateInvalidation.
:return: dict object containing updated certificate invalidation data.
"""
if len(CertificateInvalidation.get_certificate_invalidations(
generated_certificate.course_id,
generated_certificate.user,
)) > 0:
raise ValueError(
_("Certificate of {user} has already been invalidated. Please check your spelling and retry.").format(
user=generated_certificate.user.username,
)
)
# Verify that certificate user wants to invalidate is a valid one.
if not generated_certificate.is_valid():
raise ValueError(
_("Certificate for student {user} is already invalid, kindly verify that certificate was generated "
"for this student and then proceed.").format(user=generated_certificate.user.username)
)
# Add CertificateInvalidation record for future reference or re-validation
certificate_invalidation, __ = CertificateInvalidation.objects.update_or_create(
generated_certificate=generated_certificate,
defaults={
'invalidated_by': request.user,
'notes': certificate_invalidation_data.get("notes", ""),
'active': True,
}
)
# Invalidate GeneratedCertificate
generated_certificate.invalidate()
return {
'id': certificate_invalidation.id,
'user': certificate_invalidation.generated_certificate.user.username,
'invalidated_by': certificate_invalidation.invalidated_by.username,
'created': certificate_invalidation.created.strftime("%B %d, %Y"),
'notes': certificate_invalidation.notes,
}
def re_validate_certificate(request, course_key, generated_certificate):
"""
Remove certificate invalidation from db and start certificate generation task for this student.
Raises ValueError if certificate invalidation is present.
:param request: HttpRequest object
:param course_key: CourseKey object identifying the current course.
:param generated_certificate: GeneratedCertificate object of the student for the given course
"""
try:
# Fetch CertificateInvalidation object
certificate_invalidation = CertificateInvalidation.objects.get(generated_certificate=generated_certificate)
except ObjectDoesNotExist:
raise ValueError(_("Certificate Invalidation does not exist, Please refresh the page and try again."))
else:
# Deactivate certificate invalidation if it was fetched successfully.
certificate_invalidation.deactivate()
# We need to generate certificate only for a single student here
students = [certificate_invalidation.generated_certificate.user]
instructor_task.api.generate_certificates_for_students(request, course_key, students=students)
def validate_request_data_and_get_certificate(certificate_invalidation, course_key):
"""
Fetch and return GeneratedCertificate of the student passed in request data for the given course.
Raises ValueError in case of missing student username/email or
if student does not have certificate for the given course.
:param certificate_invalidation: dict containing certificate invalidation data
:param course_key: CourseKey object identifying the current course.
:return: GeneratedCertificate object of the student for the given course
"""
user = certificate_invalidation.get("user")
if not user:
raise ValueError(
_('Student username/email field is required and can not be empty. '
'Kindly fill in username/email and then press "Invalidate Certificate" button.')
)
student = get_student(user, course_key)
certificate = GeneratedCertificate.certificate_for_student(student, course_key)
if not certificate:
raise ValueError(_(
"The student {student} does not have certificate for the course {course}. Kindly verify student "
"username/email and the selected course are correct and try again."
).format(student=student.username, course=course_key.course))
return certificate
lms/djangoapps/instructor/views/api_urls.py
......@@ -161,4 +161,8 @@ urlpatterns = patterns(
url(r'^generate_bulk_certificate_exceptions',
'instructor.views.api.generate_bulk_certificate_exceptions',
name='generate_bulk_certificate_exceptions'),
url(r'^certificate_invalidation_view/$',
'instructor.views.api.certificate_invalidation_view',
name='certificate_invalidation_view'),
)
lms/djangoapps/instructor/views/instructor_dashboard.py
......@@ -43,6 +43,7 @@ from certificates.models import (
GeneratedCertificate,
CertificateStatuses,
CertificateGenerationHistory,
CertificateInvalidation,
)
from certificates import api as certs_api
from util.date_utils import get_default_time_display
......@@ -184,6 +185,13 @@ def instructor_dashboard_2(request, course_id):
kwargs={'course_id': unicode(course_key)}
)
certificate_invalidation_view_url = reverse( # pylint: disable=invalid-name
'certificate_invalidation_view',
kwargs={'course_id': unicode(course_key)}
)
certificate_invalidations = CertificateInvalidation.get_certificate_invalidations(course_key)
context = {
'course': course,
'studio_url': get_studio_url(course, 'course'),
......@@ -191,9 +199,11 @@ def instructor_dashboard_2(request, course_id):
'disable_buttons': disable_buttons,
'analytics_dashboard_message': analytics_dashboard_message,
'certificate_white_list': certificate_white_list,
'certificate_invalidations': certificate_invalidations,
'generate_certificate_exceptions_url': generate_certificate_exceptions_url,
'generate_bulk_certificate_exceptions_url': generate_bulk_certificate_exceptions_url,
'certificate_exception_view_url': certificate_exception_view_url
'certificate_exception_view_url': certificate_exception_view_url,
'certificate_invalidation_view_url': certificate_invalidation_view_url,
}
return render_to_response('instructor/instructor_dashboard_2/instructor_dashboard_2.html', context)
......
lms/static/js/certificates/collections/certificate_invalidation_collection.js 0 → 100644
// Backbone.js Application Collection: CertificateInvalidationCollection
/*global define, RequireJS */
;(function(define) {
'use strict';
define(
['backbone', 'js/certificates/models/certificate_invalidation'],
function(Backbone, CertificateInvalidation) {
return Backbone.Collection.extend({
model: CertificateInvalidation
});
}
);
}).call(this, define || RequireJS.define);
\ No newline at end of file
lms/static/js/certificates/factories/certificate_invalidation_factory.js 0 → 100644
// Backbone.js Page Object Factory: Certificate Invalidation Factory
/*global define, RequireJS */
;(function(define) {
'use strict';
define(
[
'js/certificates/views/certificate_invalidation_view',
'js/certificates/collections/certificate_invalidation_collection'
],
function(CertificateInvalidationView, CertificateInvalidationCollection) {
return function(certificate_invalidation_collection_json, certificate_invalidation_url) {
var certificate_invalidation_collection = new CertificateInvalidationCollection(
JSON.parse(certificate_invalidation_collection_json), {
parse: true,
canBeEmpty: true,
url: certificate_invalidation_url
}
);
var certificate_invalidation_view = new CertificateInvalidationView({
collection: certificate_invalidation_collection
});
certificate_invalidation_view.render();
};
}
);
}).call(this, define || RequireJS.define);
\ No newline at end of file
lms/static/js/certificates/models/certificate_invalidation.js 0 → 100644
// Backbone.js Application Model: CertificateInvalidation
/*global define, RequireJS */
;(function(define) {
'use strict';
define(
['underscore', 'underscore.string', 'gettext', 'backbone'],
function(_, str, gettext, Backbone) {
return Backbone.Model.extend({
idAttribute: 'id',
defaults: {
user: '',
invalidated_by: '',
created: '',
notes: ''
},
url: function() {
return this.get('url');
},
validate: function(attrs) {
if (!_.str.trim(attrs.user)) {
// A username or email must be provided for certificate invalidation
return gettext('Student username/email field is required and can not be empty. ' +
'Kindly fill in username/email and then press "Invalidate Certificate" button.');
}
}
});
}
);
}).call(this, define || RequireJS.define);
\ No newline at end of file
lms/static/js/certificates/views/certificate_invalidation_view.js 0 → 100644
// Backbone Application View: CertificateInvalidationView
/*global define, RequireJS */
;(function(define) {
'use strict';
define(
['jquery', 'underscore', 'gettext', 'backbone', 'js/certificates/models/certificate_invalidation'],
function($, _, gettext, Backbone, CertificateInvalidationModel) {
return Backbone.View.extend({
el: "#certificate-invalidation",
messages: "div.message",
events: {
'click #invalidate-certificate': 'invalidateCertificate',
'click .re-validate-certificate': 'reValidateCertificate'
},
initialize: function() {
this.listenTo(this.collection, 'change add remove', this.render);
},
render: function() {
var template = this.loadTemplate('certificate-invalidation');
this.$el.html(template({certificate_invalidations: this.collection.models}));
},
loadTemplate: function(name) {
var templateSelector = "#" + name + "-tpl",
templateText = $(templateSelector).text();
return _.template(templateText);
},
invalidateCertificate: function() {
var user = this.$("#certificate-invalidation-user").val();
var notes = this.$("#certificate-invalidation-notes").val();
var certificate_invalidation = new CertificateInvalidationModel({
url: this.collection.url,
user: user,
notes: notes
});
if (this.collection.findWhere({user: user})) {
this.showMessage(
gettext("Certificate of ") + user +
gettext(" has already been invalidated. Please check your spelling and retry."
));
}
else if (certificate_invalidation.isValid()) {
var self = this;
certificate_invalidation.save(null, {
wait: true,
success: function(model) {
self.collection.add(model);
self.showMessage(
gettext('Certificate has been successfully invalidated for ') + user + '.'
);
},
error: function(model, response) {
try {
var response_data = JSON.parse(response.responseText);
self.showMessage(response_data.message);
}
catch(exception) {
self.showMessage(gettext("Server Error, Please refresh the page and try again."));
}
}
});
}
else {
this.showMessage(certificate_invalidation.validationError);
}
},
reValidateCertificate: function(event) {
var certificate_invalidation = $(event.target).data();
var model = this.collection.get(certificate_invalidation),
self = this;
if (model) {
model.destroy({
success: function() {
self.showMessage(gettext('The certificate for this learner has been re-validated and ' +
'the system is re-running the grade for this learner.'));
},
error: function(model, response) {
try {
var response_data = JSON.parse(response.responseText);
self.showMessage(response_data.message);
}
catch(exception) {
self.showMessage(gettext("Server Error, Please refresh the page and try again."));
}
},
wait: true,
data: JSON.stringify(model.attributes)
});
}
else {
self.showMessage(gettext('Could not find Certificate Invalidation in the list. ' +
'Please refresh the page and try again'));
}
},
isEmailAddress: function validateEmail(email) {
var re = /^([\w-]+(?:\.[\w-]+)*)@((?:[\w-]+\.)*\w[\w-]{0,66})\.([a-z]{2,6}(?:\.[a-z]{2})?)$/i;
return re.test(email);
},
showMessage: function(message) {
$(this.messages + ">p" ).remove();
this.$(this.messages).removeClass('hidden').append("<p>"+ gettext(message) + "</p>");
}
});
}
);
}).call(this, define || RequireJS.define);
\ No newline at end of file
lms/static/js/spec/main.js
......@@ -655,6 +655,7 @@
'lms/include/js/spec/instructor_dashboard/ecommerce_spec.js',
'lms/include/js/spec/instructor_dashboard/student_admin_spec.js',
'lms/include/js/spec/instructor_dashboard/certificates_exception_spec.js',
'lms/include/js/spec/instructor_dashboard/certificates_invalidation_spec.js',
'lms/include/js/spec/instructor_dashboard/certificates_bulk_exception_spec.js',
'lms/include/js/spec/instructor_dashboard/certificates_spec.js',
'lms/include/js/spec/student_account/account_spec.js',
......
lms/static/sass/course/instructor/_instructor_2.scss
......@@ -2159,16 +2159,18 @@ input[name="subject"] {
}
}
.student-username-or-email {
width: 300px;
margin-bottom: 10px;
}
.notes-field {
width: 400px;
}
#certificate-white-list-editor {
padding-top: 5px;
.certificate-exception-inputs {
.student-username-or-email {
width: 300px;
margin-bottom: 10px;
}
.notes-field {
width: 400px;
}
p + p {
margin-top: 5px;
}
......@@ -2178,7 +2180,7 @@ input[name="subject"] {
}
}
.white-listed-students {
.white-listed-students, .invalidation-history {
margin-top: 10px;
padding-top: 5px;
table {
......
lms/templates/instructor/instructor_dashboard_2/certificate-invalidation.underscore 0 → 100644
<p class="under-heading info">
<%= gettext("To invalidate a certificate for a particular learner, add the username or email address below.") %>
</p>
<div class="add-certificate-invalidation">
<input class='student-username-or-email' id="certificate-invalidation-user" type="text" placeholder="<%= gettext('Username or email address') %>" aria-describedby='student-user-name-or-email-tip'>
<textarea class='notes-field' id="certificate-invalidation-notes" rows="10" placeholder="<%= gettext('Add notes about this learner') %>" aria-describedby='notes-field-tip'></textarea>
<br/>
<button type="button" class="btn-blue" id="invalidate-certificate"><%= gettext('Invalidate Certificate') %></button>
</div>
<div class="message hidden"></div>
<div class="invalidation-history">
<% if (certificate_invalidations.length === 0) { %>
<p><%- gettext("No results") %></p>
<% } else { %>
<table>
<thead>
<tr>
<th class='user-name'><%= gettext('Student') %></th>
<th class='user-name'><%= gettext('Invalidated By') %></th>
<th class='date'><%= gettext('Invalidated') %></th>
<th class='notes'><%= gettext('Notes') %></th>
<th class='action'><%= gettext('Action') %></th>
</tr>
</thead>
<tbody>
<% for (var i = 0; i < certificate_invalidations.length; i++) {
var certificate_invalidation = certificate_invalidations[i];
%>
<tr>
<td><%- certificate_invalidation.get("user") %></td>
<td><%- certificate_invalidation.get("invalidated_by") %></td>
<td><%- certificate_invalidation.get("created") %></td>
<td><%- certificate_invalidation.get("notes") %></td>
<td><button class='re-validate-certificate' data-cid='<%- certificate_invalidation.cid %>'><%- gettext("Remove from Invalidation Table") %></button></td>
</tr>
<% } %>
</tbody>
</table>
<% } %>
</div>
lms/templates/instructor/instructor_dashboard_2/certificates.html
......@@ -8,6 +8,10 @@ import json
CertificateWhitelistFactory('${json.dumps(certificate_white_list)}', "${generate_certificate_exceptions_url}", "${certificate_exception_view_url}", "${generate_bulk_certificate_exceptions_url}");
</%static:require_module>
<%static:require_module module_name="js/certificates/factories/certificate_invalidation_factory" class_name="CertificateInvalidationFactory">
CertificateInvalidationFactory('${json.dumps(certificate_invalidations)}', '${certificate_invalidation_view_url}');
</%static:require_module>
<%page args="section_data"/>
<div class="certificates-wrapper">
......@@ -165,10 +169,25 @@ import json
<div class="certificate-exception-section">
<div id="certificate-white-list-editor"></div>
<div class="bulk-white-list-exception"></div>
<div class="white-listed-students" id="white-listed-students"></div>
<div class="white-listed-students" id="white-listed-students">
<div class="ui-loading">
<span class="spin"><i class="icon fa fa-refresh" aria-hidden="true"></i></span> <span class="copy">${_('Loading')}</span>
</div>
</div>
<br/>
</div>
<div class="no-pending-tasks-message"></div>
</div>
<hr class="section-divider" />
<div class="certificate-invalidation-container">
<h2> ${_("Invalidate Certificates")} </h2>
<div id="certificate-invalidation">
<div class="ui-loading">
<span class="spin"><i class="icon fa fa-refresh" aria-hidden="true"></i></span> <span class="copy">${_('Loading')}</span>
</div>
</div>
</div>
</div>
lms/templates/instructor/instructor_dashboard_2/instructor_dashboard_2.html
......@@ -66,7 +66,7 @@ from django.core.urlresolvers import reverse
## Include Underscore templates
<%block name="header_extras">
% for template_name in ["cohorts", "enrollment-code-lookup-links", "cohort-editor", "cohort-group-header", "cohort-selector", "cohort-form", "notification", "cohort-state", "cohort-discussions-inline", "cohort-discussions-course-wide", "cohort-discussions-category","cohort-discussions-subcategory","certificate-white-list","certificate-white-list-editor","certificate-bulk-white-list"]:
% for template_name in ["cohorts", "enrollment-code-lookup-links", "cohort-editor", "cohort-group-header", "cohort-selector", "cohort-form", "notification", "cohort-state", "cohort-discussions-inline", "cohort-discussions-course-wide", "cohort-discussions-category", "cohort-discussions-subcategory", "certificate-white-list", "certificate-white-list-editor", "certificate-bulk-white-list", "certificate-invalidation"]:
<script type="text/template" id="${template_name}-tpl">
<%static:include path="instructor/instructor_dashboard_2/${template_name}.underscore" />
</script>
......
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