feat: implement Certificate XBlock

Author: Agrendalath

learning_credentials/api.py

@@ -0,0 +1,76 @@
+"""API functions for the Learning Credentials app."""
+
+from __future__ import annotations
+
+import logging
+
+from django.contrib.auth.models import User
+from opaque_keys.edx.keys import CourseKey
+
+from .models import Credential, CredentialConfiguration
+from .tasks import generate_credential_for_user_task
+
+logger = logging.getLogger(__name__)
+
+
+def get_eligible_users_by_credential_type(course_id: CourseKey, user_id: int | None = None) -> dict[str, list[User]]:
+    """
+    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 credential type as the key and eligible users as the value.
+    """
+    credential_configs = CredentialConfiguration.objects.filter(course_id=course_id)
+
+    if not credential_configs:
+        return {}
+
+    eligible_users_by_type = {}
+    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[credential_config.credential_type.name] = list(set(filtered_user_ids) & {user_id})
+        else:
+            eligible_users_by_type[credential_config.credential_type.name] = filtered_user_ids
+
+    return eligible_users_by_type
+
+
+def get_user_credentials_by_type(course_id: CourseKey, user_id: int) -> dict[str, dict[str, str]]:
+    """
+    Retrieve the available credentials for a given user in a course.
+
+    :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.
+    """
+    credentials = Credential.objects.filter(user_id=user_id, course_id=course_id)
+
+    return {cred.credential_type: {'download_url': cred.download_url, 'status': cred.status} for cred in credentials}
+
+
+def generate_credential_for_user(course_id: CourseKey, credential_type: str, user_id: int, force: bool = False):
+    """
+    Generate a credential for a user in a course.
+
+    :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.
+    """
+    credential_config = CredentialConfiguration.objects.get(
+        course_id=course_id, credential_type__name=credential_type
+    )
+
+    if not credential_config:
+        logger.error('No course configuration found for course %s', course_id)
+        return
+
+    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_credential_for_user_task.delay(credential_config.id, user_id)

learning_credentials/apps.py

@@ -20,5 +20,9 @@ class LearningCredentialsConfig(AppConfig):
                 'common': {'relative_path': 'settings.common'},
                 'production': {'relative_path': 'settings.production'},
             },
+            'cms.djangoapp': {
+                'common': {'relative_path': 'settings.common'},
+                'production': {'relative_path': 'settings.production'},
+            },
         },
     }

learning_credentials/compat.py

@@ -73,12 +73,21 @@ 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) -> list[User]:
-    """Get the course enrollments from Open edX."""
+def get_course_enrollments(course_id: CourseKey, user_id: int | None = None) -> list[User]:
+    """
+    Get the course enrollments from Open edX.
+
+    :param course_id: The course ID.
+    :param user_id: Optional. If provided, will filter the enrollments by user.
+    :return: A list of users enrolled in the course.
+    """
     # noinspection PyUnresolvedReferences,PyPackageRequirements
     from common.djangoapps.student.models import CourseEnrollment
 
     enrollments = CourseEnrollment.objects.filter(course_id=course_id, is_active=True).select_related('user')
+    if user_id:
+        enrollments = enrollments.filter(user__id=user_id)
+
     return [enrollment.user for enrollment in enrollments]
 
 

learning_credentials/models.py

@@ -165,10 +165,11 @@ def filter_out_user_ids_with_credentials(self, user_ids: list[int]) -> list[int]
         filtered_user_ids_set = set(user_ids) - set(users_ids_with_credentials)
         return list(filtered_user_ids_set)
 
-    def get_eligible_user_ids(self) -> list[int]:
+    def get_eligible_user_ids(self, user_id: int = None) -> list[int]:
         """
         Get the list of eligible learners for the given course.
 
+        :param user_id: Optional. If provided, will check eligibility for the specific user.
         :return: A list of user IDs.
         """
         func_path = self.credential_type.retrieval_func
@@ -177,7 +178,7 @@ def get_eligible_user_ids(self) -> list[int]:
         func = getattr(module, func_name)
 
         custom_options = {**self.credential_type.custom_options, **self.custom_options}
-        return func(self.learning_context_key, custom_options)
+        return func(self.learning_context_key, custom_options, user_id=user_id)
 
     def generate_credential_for_user(self, user_id: int, celery_task_id: int = 0):
         """

learning_credentials/processors.py

@@ -38,8 +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 = None,
 ) -> list[int]:
     """
     Process a learning context (course or learning path) using the given course processor function.
@@ -53,19 +54,20 @@ 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
     """
     if learning_context_key.is_course:
-        return course_processor(learning_context_key, options)
+        return course_processor(learning_context_key, options, user_id)
 
     learning_path = LearningPath.objects.get(key=learning_context_key)
 
     results = None
     for course in learning_path.steps.all():
         course_options = options.get("steps", {}).get(str(course.course_key), options)
-        course_results = set(course_processor(course.course_key, course_options))
+        course_results = set(course_processor(course.course_key, course_options, user_id))
 
         if results is None:
             results = course_results
@@ -162,30 +164,31 @@ 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]) -> 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()}
 
-    users = get_course_enrollments(course_id)
+    users = get_course_enrollments(course_id, user_id)
     grades = _get_grades_by_format(course_id, users)
     log.debug(grades)
     weights = _get_category_weights(course_id)
 
     eligible_users = []
-    for user_id, user_grades in grades.items():
+    for uid, user_grades in grades.items():
         if _are_grades_passing_criteria(user_grades, required_grades, weights):
-            eligible_users.append(user_id)
+            eligible_users.append(uid)
 
     return eligible_users
 
 
-def retrieve_subsection_grades(learning_context_key: LearningContextKey, options: dict[str, Any]) -> 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:
@@ -232,7 +235,7 @@ def retrieve_subsection_grades(learning_context_key: LearningContextKey, options
             }
           }
     """
-    return _process_learning_context(learning_context_key, _retrieve_course_subsection_grades, options)
+    return _process_learning_context(learning_context_key, _retrieve_course_subsection_grades, options, user_id)
 
 
 def _prepare_request_to_completion_aggregator(course_id: CourseKey, query_params: dict, url: str) -> APIView:
@@ -262,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]) -> 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.
@@ -290,15 +293,20 @@ def _retrieve_course_completions(course_id: CourseKey, options: dict[str, Any])
         query_params['page'] += 1
         view = _prepare_request_to_completion_aggregator(course_id, query_params.copy(), url)
 
+    if user_id:
+        username = get_user_model().objects.get(id=user_id).username
+        return [user_id] if username in completions else []
+
     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:
@@ -322,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.
 
@@ -331,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/credentials_xblock.css

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

learning_credentials/public/html/credentials_xblock.html

@@ -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/js/credentials_xblock.js

@@ -0,0 +1,23 @@
+function CredentialsXBlock(runtime, element) {
+    function generateCredential(event) {
+        const button = event.target;
+        const credentialType = $(button).data('credential-type');
+        const handlerUrl = runtime.handlerUrl(element, 'generate_credential');
+
+        $.post(handlerUrl, JSON.stringify({ credential_type: credentialType }))
+          .done(function(data) {
+              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-' + credentialType);
+              messageArea.html('<p style="color:red;">An error occurred while processing your request.</p>');
+          });
+    }
+
+    $(element).find('.generate-credential').on('click', generateCredential);
+}