fixup! feat: implement Certificate XBlock

Author: Agrendalath

learning_credentials/api.py

@@ -1,4 +1,4 @@
-"""API functions for the Open edX Certificates app."""
+"""API functions for the Learning Credentials app."""
 
 from __future__ import annotations
 
@@ -7,70 +7,70 @@
 from django.contrib.auth.models import User
 from opaque_keys.edx.keys import CourseKey
 
-from .models import ExternalCertificate, ExternalCertificateCourseConfiguration
-from .tasks import generate_certificate_for_user_task
+from .models import Credential, CredentialConfiguration
+from .tasks import generate_credential_for_user_task
 
 logger = logging.getLogger(__name__)
 
 
-def get_eligible_users_by_certificate_type(course_id: CourseKey, user_id: int = None) -> dict[str, list[User]]:
+def get_eligible_users_by_credential_type(course_id: CourseKey, user_id: int | None = None) -> dict[str, list[User]]:
     """
-    Retrieve eligible users for each certificate type in the given course.
+    Retrieve eligible users for each credential type in the given course.
 
     :param course_id: The key of the course for which to check eligibility.
     :param user_id: Optional. If provided, will check eligibility for the specific user.
-    :return: A dictionary with certificate type as the key and eligible users as the value.
+    :return: A dictionary with credential type as the key and eligible users as the value.
     """
-    certificate_configs = ExternalCertificateCourseConfiguration.objects.filter(course_id=course_id)
+    credential_configs = CredentialConfiguration.objects.filter(course_id=course_id)
 
-    if not certificate_configs:
+    if not credential_configs:
         return {}
 
     eligible_users_by_type = {}
-    for certificate_config in certificate_configs:
-        user_ids = certificate_config.get_eligible_user_ids(user_id)
-        filtered_user_ids = certificate_config.filter_out_user_ids_with_certificates(user_ids)
+    for credential_config in credential_configs:
+        user_ids = credential_config.get_eligible_user_ids(user_id)
+        filtered_user_ids = credential_config.filter_out_user_ids_with_credentials(user_ids)
 
         if user_id:
-            eligible_users_by_type[certificate_config.certificate_type.name] = list(set(filtered_user_ids) & {user_id})
+            eligible_users_by_type[credential_config.credential_type.name] = list(set(filtered_user_ids) & {user_id})
         else:
-            eligible_users_by_type[certificate_config.certificate_type.name] = filtered_user_ids
+            eligible_users_by_type[credential_config.credential_type.name] = filtered_user_ids
 
     return eligible_users_by_type
 
 
-def get_user_certificates_by_type(course_id: CourseKey, user_id: int) -> dict[str, dict[str, str]]:
+def get_user_credentials_by_type(course_id: CourseKey, user_id: int) -> dict[str, dict[str, str]]:
     """
-    Retrieve the available certificates for a given user in a course.
+    Retrieve the available credentials for a given user in a course.
 
-    :param course_id: The course ID for which to retrieve certificates.
-    :param user_id: The ID of the user for whom certificates are being retrieved.
-    :return: A dict where keys are certificate types and values are dicts with the download link and status.
+    :param course_id: The course ID for which to retrieve credentials.
+    :param user_id: The ID of the user for whom credentials are being retrieved.
+    :return: A dict where keys are credential types and values are dicts with the download link and status.
     """
-    certificates = ExternalCertificate.objects.filter(user_id=user_id, course_id=course_id)
+    credentials = Credential.objects.filter(user_id=user_id, course_id=course_id)
 
-    return {cert.certificate_type: {'download_url': cert.download_url, 'status': cert.status} for cert in certificates}
+    return {cred.credential_type: {'download_url': cred.download_url, 'status': cred.status} for cred in credentials}
 
 
-def generate_certificate_for_user(course_id: CourseKey, certificate_type: str, user_id: int, force: bool = False):
+def generate_credential_for_user(course_id: CourseKey, credential_type: str, user_id: int, force: bool = False):
     """
-    Generate a certificate for a user in a course.
+    Generate a credential for a user in a course.
 
-    :param course_id: The course ID for which to generate the certificate.
-    :param certificate_type: The type of certificate to generate.
-    :param user_id: The ID of the user for whom the certificate is being generated.
-    :param force: If True, will generate the certificate even if the user is not eligible.
+    :param course_id: The course ID for which to generate the credential.
+    :param credential_type: The type of credential to generate.
+    :param user_id: The ID of the user for whom the credential is being generated.
+    :param force: If True, will generate the credential even if the user is not eligible.
     """
-    certificate_config = ExternalCertificateCourseConfiguration.objects.get(
-        course_id=course_id, certificate_type__name=certificate_type
+    credential_config = CredentialConfiguration.objects.get(
+        course_id=course_id, credential_type__name=credential_type
     )
 
-    if not certificate_config:
+    if not credential_config:
         logger.error('No course configuration found for course %s', course_id)
         return
 
-    if not force and not certificate_config.get_eligible_user_ids(user_id):
-        logger.error('User %s is not eligible for the certificate in course %s', user_id, course_id)
-        raise ValueError('User is not eligible for the certificate.')
+    if not force and not credential_config.get_eligible_user_ids(user_id):
+        logger.error('User %s is not eligible for the credential in course %s', user_id, course_id)
+        raise ValueError('User is not eligible for the credential.')
 
-    generate_certificate_for_user_task.delay(certificate_config.id, user_id)
+    generate_credential_for_user_task.delay(credential_config.id, user_id)

learning_credentials/compat.py

@@ -73,7 +73,7 @@ def get_learning_context_name(learning_context_key: LearningContextKey) -> str:
     return _get_learning_path_name(learning_context_key)
 
 
-def get_course_enrollments(course_id: CourseKey, user_id: int = None) -> list[User]:
+def get_course_enrollments(course_id: CourseKey, user_id: int | None = None) -> list[User]:
     """
     Get the course enrollments from Open edX.
 

learning_credentials/processors.py

@@ -38,9 +38,9 @@
 
 def _process_learning_context(
     learning_context_key: LearningContextKey,
-    course_processor: Callable[[CourseKey, dict[str, Any]], list[int]],
+    course_processor: Callable[[CourseKey, dict[str, Any], int | None], list[int]],
     options: dict[str, Any],
-    user_id: int = None,
+    user_id: int | None = None,
 ) -> list[int]:
     """
     Process a learning context (course or learning path) using the given course processor function.
@@ -54,6 +54,7 @@ def _process_learning_context(
         course_processor: A function that processes a single course and returns eligible user IDs
         options: Options to pass to the processor. For learning paths, may contain a "steps" key
                 with step-specific options in the format: {"steps": {"<course_key>": {...}}}
+        user_id: Optional. If provided, will check eligibility for the specific user.
 
     Returns:
         A list of eligible user IDs
@@ -163,7 +164,7 @@ def _are_grades_passing_criteria(
     return total_score >= required_grades.get('total', 0)
 
 
-def _retrieve_course_subsection_grades(course_id: CourseKey, options: dict[str, Any], user_id: int = None) -> list[int]:
+def _retrieve_course_subsection_grades(course_id: CourseKey, options: dict[str, Any], user_id: int | None = None) -> list[int]:
     """Implementation for retrieving course grades."""
     required_grades: dict[str, int] = options['required_grades']
     required_grades = {key.lower(): value * 100 for key, value in required_grades.items()}
@@ -181,12 +182,13 @@ def _retrieve_course_subsection_grades(course_id: CourseKey, options: dict[str,
     return eligible_users
 
 
-def retrieve_subsection_grades(learning_context_key: LearningContextKey, options: dict[str, Any], user_id: int = None) -> list[int]:
+def retrieve_subsection_grades(learning_context_key: LearningContextKey, options: dict[str, Any], user_id: int | None = None) -> list[int]:
     """
     Retrieve the users that have passing grades in all required categories.
 
     :param learning_context_key: The learning context key (course or learning path).
     :param options: The custom options for the credential.
+    :param user_id: Optional. If provided, will check eligibility for the specific user.
     :returns: The IDs of the users that have passing grades in all required categories.
 
     Options:
@@ -263,7 +265,7 @@ def _prepare_request_to_completion_aggregator(course_id: CourseKey, query_params
     return view
 
 
-def _retrieve_course_completions(course_id: CourseKey, options: dict[str, Any], user_id: int = None) -> list[int]:
+def _retrieve_course_completions(course_id: CourseKey, options: dict[str, Any], user_id: int | None = None) -> list[int]:
     """Implementation for retrieving course completions."""
     # If it turns out to be too slow, we can:
     # 1. Modify the Completion Aggregator to emit a signal/event when a user achieves a certain completion threshold.
@@ -298,12 +300,13 @@ def _retrieve_course_completions(course_id: CourseKey, options: dict[str, Any],
     return list(get_user_model().objects.filter(username__in=completions).values_list('id', flat=True))
 
 
-def retrieve_completions(learning_context_key: LearningContextKey, options: dict[str, Any]) -> list[int]:
+def retrieve_completions(learning_context_key: LearningContextKey, options: dict[str, Any], user_id: int | None = None) -> list[int]:
     """
     Retrieve the course completions for all users through the Completion Aggregator API.
 
     :param learning_context_key: The learning context key (course or learning path).
-    :param options: The custom options for the credential.
+    :param options: The custom options for the credentia
+    :param user_id: Optional. If provided, will check eligibility for the specific user.l.
     :returns: The IDs of the users that have achieved the required completion percentage.
 
     Options:
@@ -327,7 +330,7 @@ def retrieve_completions(learning_context_key: LearningContextKey, options: dict
     return _process_learning_context(learning_context_key, _retrieve_course_completions, options)
 
 
-def retrieve_completions_and_grades(learning_context_key: LearningContextKey, options: dict[str, Any]) -> list[int]:
+def retrieve_completions_and_grades(learning_context_key: LearningContextKey, options: dict[str, Any], user_id: int | None = None) -> list[int]:
     """
     Retrieve the users that meet both completion and grade criteria.
 
@@ -336,6 +339,7 @@ def retrieve_completions_and_grades(learning_context_key: LearningContextKey, op
 
     :param learning_context_key: The learning context key (course or learning path).
     :param options: The custom options for the credential.
+    :param user_id: Optional. If provided, will check eligibility for the specific user.
     :returns: The IDs of the users that meet both sets of criteria.
 
     Options:

learning_credentials/public/css/certificates_xblock.css

@@ -0,0 +1,7 @@
+.credentials-block .credentials-list .credential {
+    padding-bottom: 20px;
+
+    .credential-status {
+        margin-bottom: 10px;
+    }
+}

learning_credentials/public/css/credentials_xblock.css

@@ -0,0 +1,48 @@
+<div class="credentials-block">
+    {% if is_author_mode %}
+        <p>The Studio view of this XBlock is not supported yet. Please preview the XBlock in the LMS.</p>
+    {% else %}
+        <h3>Check Your Certificate Eligibility Status</h3>
+        <ul class="credentials-list">
+            {% if credentials %}
+                {% for credential_type, credential in credentials.items %}
+                    <li class="credential">
+                        <strong>Type:</strong> {{ credential_type }}
+                        {% if credential.download_url %}
+                            <p class="credential-status">Congratulations on finishing strong!</p>
+                            <strong>Download Link:</strong> <a href="{{ credential.download_url }}">Download Certificate</a>
+                        {% elif credential.status == credential.Status.ERROR %}
+                            <p class="credential-status">Something went wrong. Please contact us via the Help page for assistance.</p>
+                        {% endif %}
+                        <button class="btn-brand generate-credential" data-credential-type="{{ credential_type }}" disabled>
+                            Certificate Claimed
+                        </button>
+                        <div id="message-area-{{ credential_type }}"></div>
+                    </li>
+                {% endfor %}
+            {% endif %}
+
+            {% if eligible_types %}
+                {% for credential_type, is_eligible in eligible_types.items %}
+                    {% if not credentials or credential_type not in credentials %}
+                        <li class="credential">
+                            <strong>Type:</strong> {{ credential_type }}
+                            {% if is_eligible %}
+                                <p class="credential-status">Congratulations! You have earned this certificate. Please claim it below.</p>
+                                <button class="btn-brand generate-credential" data-credential-type="{{ credential_type }}">
+                                    Claim Certificate
+                                </button>
+                            {% else %}
+                                <p class="certificate-status">You are not yet eligible for this certificate.</p>
+                                <button class="btn-brand generate-certificate" data-certificate-type="{{ credential_type }}" disabled>
+                                    Claim Certificate
+                                </button>
+                            {% endif %}
+                            <div id="message-area-{{ credential_type }}"></div>
+                        </li>
+                    {% endif %}
+                {% endfor %}
+            {% endif %}
+        </ul>
+    {% endif %}
+</div>

learning_credentials/public/html/certificates_xblock.html

@@ -1,23 +1,23 @@
-function CertificatesXBlock(runtime, element) {
-    function generateCertificate(event) {
+function CredentialsXBlock(runtime, element) {
+    function generateCredential(event) {
         const button = event.target;
-        const certificateType = $(button).data('certificate-type');
-        const handlerUrl = runtime.handlerUrl(element, 'generate_certificate');
+        const credentialType = $(button).data('credential-type');
+        const handlerUrl = runtime.handlerUrl(element, 'generate_credential');
 
-        $.post(handlerUrl, JSON.stringify({ certificate_type: certificateType }))
+        $.post(handlerUrl, JSON.stringify({ credential_type: credentialType }))
           .done(function(data) {
-              const messageArea = $(element).find('#message-area-' + certificateType);
+              const messageArea = $(element).find('#message-area-' + credentialType);
               if (data.status === 'success') {
                   messageArea.html('<p style="color:green;">Certificate generation initiated successfully.</p>');
               } else {
                   messageArea.html('<p style="color:red;">' + data.message + '</p>');
               }
           })
           .fail(function() {
-              const messageArea = $(element).find('#message-area-' + certificateType);
+              const messageArea = $(element).find('#message-area-' + credentialType);
               messageArea.html('<p style="color:red;">An error occurred while processing your request.</p>');
           });
     }
 
-    $(element).find('.generate-certificate').on('click', generateCertificate);
+    $(element).find('.generate-credential').on('click', generateCredential);
 }