learning-credentials 0.2.3__py3-none-any.whl → 0.3.0rc2__py3-none-any.whl

learning_credentials/models.py

@@ -7,7 +7,7 @@ import logging
 import uuid
 from importlib import import_module
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 import jsonfield
 from django.conf import settings
@@ -165,11 +165,12 @@ class CredentialConfiguration(TimeStampedModel):
         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 _call_retrieval_func(self, user_id: int | None = None) -> list[int] | dict[str, Any]:
         """
-        Get the list of eligible learners for the given course.
+        Call the retrieval function with the given parameters.
 
-        :return: A list of user IDs.
+        :param user_id: Optional. If provided, will check eligibility for the specific user.
+        :return: Raw result from the retrieval function - list of user IDs or user details dict.
         """
         func_path = self.credential_type.retrieval_func
         module_path, func_name = func_path.rsplit('.', 1)
@@ -177,7 +178,40 @@ class CredentialConfiguration(TimeStampedModel):
         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 get_eligible_user_ids(self, user_id: int | None = 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.
+        """
+        result = self._call_retrieval_func(user_id)
+
+        if user_id is not None:
+            # Single user case: return list with user ID if eligible
+            if isinstance(result, dict) and result.get('is_eligible', False):
+                return [user_id]
+            return []
+
+        # Multiple users case: result should already be a list of user IDs
+        return result if isinstance(result, list) else []
+
+    def get_user_eligibility_details(self, user_id: int) -> dict[str, Any]:
+        """
+        Get detailed eligibility information for a specific user.
+
+        :param user_id: The user ID to check eligibility for.
+        :return: Dictionary containing eligibility details and progress information.
+        """
+        result = self._call_retrieval_func(user_id)
+
+        if isinstance(result, dict):
+            return result
+
+        # Fallback for processors that don't support detailed results
+        return {'is_eligible': False}
 
     def generate_credential_for_user(self, user_id: int, celery_task_id: int = 0):
         """
@@ -294,15 +328,15 @@ class Credential(TimeStampedModel):
         learning_context_name = get_learning_context_name(self.learning_context_key)
         user = get_user_model().objects.get(id=self.user_id)
         msg = Message(
-            name="certificate_generated",
-            app_label="learning_credentials",
-            recipient=Recipient(lms_user_id=user.id, email_address=user.email),
-            language='en',
+            name="certificate_generated",  # type: ignore[unknown-argument]
+            app_label="learning_credentials",  # type: ignore[unknown-argument]
+            recipient=Recipient(lms_user_id=user.id, email_address=user.email),  # type: ignore[unknown-argument]
+            language='en',  # type: ignore[unknown-argument]
             context={
                 'certificate_link': self.download_url,
                 'course_name': learning_context_name,
                 'platform_name': settings.PLATFORM_NAME,
-            },
+            },  # type: ignore[unknown-argument]
         )
         ace.send(msg)
 

learning_credentials/processors.py

@@ -38,46 +38,63 @@ log = logging.getLogger(__name__)
 
 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], dict[int, dict[str, Any]]],
     options: dict[str, Any],
-) -> list[int]:
+    user_id: int | None = None,
+) -> dict[int, dict[str, Any]]:
     """
     Process a learning context (course or learning path) using the given course processor function.
 
     For courses, runs the processor directly. For learning paths, runs the processor on each
-    course in the path with step-specific options (if available), and returns the intersection
-    of eligible users across all courses.
+    course in the path with step-specific options (if available), and returns detailed results
+    with step breakdown.
 
     Args:
         learning_context_key: A course key or learning path key to process
-        course_processor: A function that processes a single course and returns eligible user IDs
+        course_processor: A function that processes a single course and returns detailed progress for all users
         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 filter to the specific user.
 
     Returns:
-        A list of eligible user IDs
+        A dict mapping user_id to detailed progress, with step breakdown for learning paths
     """
     if learning_context_key.is_course:
-        return course_processor(learning_context_key, options)
+        return course_processor(learning_context_key, options, user_id)  # type: ignore[invalid-argument-type]
 
     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))
+    step_results_by_course = {}
+    all_user_ids = set()
 
-        if results is None:
-            results = course_results
-        else:
-            results &= course_results
+    # TODO: Use a single Completion Aggregator request when retrieving step results for a single user.
+    for step in learning_path.steps.all():
+        course_options = options.get("steps", {}).get(str(step.course_key), options)
+        step_results = course_processor(step.course_key, course_options, user_id)
+
+        step_results_by_course[str(step.course_key)] = step_results
+        all_user_ids.update(step_results.keys())
 
     # Filter out users who are not enrolled in the Learning Path.
-    results &= set(
-        learning_path.enrolled_users.filter(learningpathenrollment__is_active=True).values_list('id', flat=True),
+    all_user_ids &= set(
+        learning_path.enrolled_users.filter(learningpathenrollment__is_active=True).values_list('id', flat=True)
     )
 
-    return list(results) if results else []
+    final_results = {}
+    for uid in all_user_ids:
+        overall_eligible = True
+        user_step_results = {}
+
+        for course_key, step_results in step_results_by_course.items():
+            if uid in step_results:
+                user_step_results[course_key] = step_results[uid]
+                overall_eligible = overall_eligible and step_results[uid].get('is_eligible', False)
+            else:
+                overall_eligible = False
+
+        final_results[uid] = {'is_eligible': overall_eligible, 'steps': user_step_results}
+
+    return final_results
 
 
 def _get_category_weights(course_id: CourseKey) -> dict[str, float]:
@@ -100,7 +117,7 @@ def _get_category_weights(course_id: CourseKey) -> dict[str, float]:
     return category_weight_ratios
 
 
-def _get_grades_by_format(course_id: CourseKey, users: list[User]) -> dict[int, dict[str, int]]:
+def _get_grades_by_format(course_id: CourseKey, users: list[User]) -> dict[int, dict[str, float]]:
     """
     Get the grades for each user, categorized by assignment types.
 
@@ -162,30 +179,65 @@ 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]:
-    """Implementation for retrieving course grades."""
+def _calculate_grades_progress(
+    user_grades: dict[str, float],
+    required_grades: dict[str, float],
+    category_weights: dict[str, float],
+) -> dict[str, Any]:
+    """
+    Calculate detailed progress information for grade-based criteria.
+
+    :param user_grades: The grades of the user, divided by category.
+    :param required_grades: The required grades for each category.
+    :param category_weights: The weight of each category.
+    :returns: Dict with is_eligible, current_grades, and required_grades.
+    """
+    # Calculate total score
+    total_score = 0
+    for category, score in user_grades.items():
+        if category in category_weights:
+            total_score += score * category_weights[category]
+
+    # Add total to user grades
+    user_grades_with_total = {**user_grades, 'total': total_score}
+
+    is_eligible = _are_grades_passing_criteria(user_grades, required_grades, category_weights)
+
+    return {
+        'is_eligible': is_eligible,
+        'current_grades': user_grades_with_total,
+        'required_grades': required_grades,
+    }
+
+
+def _retrieve_course_subsection_grades(
+    course_id: CourseKey, options: dict[str, Any], user_id: int | None = None
+) -> dict[int, dict[str, Any]]:
+    """Implementation for retrieving course grades. Always returns detailed progress for all users."""
     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():
-        if _are_grades_passing_criteria(user_grades, required_grades, weights):
-            eligible_users.append(user_id)
+    results = {}
+    for uid, user_grades in grades.items():
+        results[uid] = _calculate_grades_progress(user_grades, required_grades, weights)
 
-    return eligible_users
+    return results
 
 
-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] | dict[str, Any]:
     """
     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 +284,16 @@ def retrieve_subsection_grades(learning_context_key: LearningContextKey, options
             }
           }
     """
-    return _process_learning_context(learning_context_key, _retrieve_course_subsection_grades, options)
+    detailed_results = _process_learning_context(
+        learning_context_key, _retrieve_course_subsection_grades, options, user_id
+    )
+
+    if user_id is not None:
+        if user_id in detailed_results:
+            return detailed_results[user_id]
+        return {'is_eligible': False, 'current_grades': {}, 'required_grades': {}}
+
+    return [uid for uid, result in detailed_results.items() if result.get('is_eligible', False)]
 
 
 def _prepare_request_to_completion_aggregator(course_id: CourseKey, query_params: dict, url: str) -> APIView:
@@ -252,7 +313,7 @@ def _prepare_request_to_completion_aggregator(course_id: CourseKey, query_params
     drf_request = Request(django_request)  # convert django.core.handlers.wsgi.WSGIRequest to DRF request
 
     view = CompletionDetailView()
-    view.request = drf_request
+    view.request = drf_request  # type: ignore[invalid-assignment]
 
     # HACK: Bypass the API permissions.
     staff_user = get_user_model().objects.filter(is_staff=True).first()
@@ -262,8 +323,10 @@ 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]:
-    """Implementation for retrieving course completions."""
+def _retrieve_course_completions(
+    course_id: CourseKey, options: dict[str, Any], user_id: int | None = None
+) -> dict[int, dict[str, Any]]:
+    """Implementation for retrieving course completions. Always returns detailed progress for all users."""
     # 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.
     # 2. Get this data from the `Aggregator` model. Filter by `aggregation name == 'course'`, `course_key`, `percent`.
@@ -276,29 +339,47 @@ def _retrieve_course_completions(course_id: CourseKey, options: dict[str, Any])
 
     # TODO: Extract the logic of this view into an API. The current approach is very hacky.
     view = _prepare_request_to_completion_aggregator(course_id, query_params.copy(), url)
-    completions = []
+    completions = {}
 
     while True:
         # noinspection PyUnresolvedReferences
         response = view.get(view.request, str(course_id))
         log.debug(response.data)
-        completions.extend(
-            res['username'] for res in response.data['results'] if res['completion']['percent'] >= required_completion
-        )
+        for res in response.data['results']:
+            completions[res['username']] = res['completion']['percent']
         if not response.data['pagination']['next']:
             break
         query_params['page'] += 1
         view = _prepare_request_to_completion_aggregator(course_id, query_params.copy(), url)
 
-    return list(get_user_model().objects.filter(username__in=completions).values_list('id', flat=True))
+    # Get all enrolled users and map usernames to user IDs
+    users = get_course_enrollments(course_id, user_id)
+    username_to_id = {user.username: user.id for user in users}  # type: ignore[unresolved-attribute]
+
+    # Always return detailed progress for all users as dict
+    detailed_results = {}
+    for username, current_completion in completions.items():
+        if username in username_to_id:
+            user_id_for_result = username_to_id[username]
+            progress = {
+                'is_eligible': current_completion >= required_completion,
+                'current_completion': current_completion,
+                'required_completion': required_completion,
+            }
+            detailed_results[user_id_for_result] = progress
 
+    return detailed_results
 
-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] | dict[str, Any]:
     """
     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 user_id: Optional. If provided, will check eligibility for the specific user.
     :returns: The IDs of the users that have achieved the required completion percentage.
 
     Options:
@@ -319,10 +400,19 @@ def retrieve_completions(learning_context_key: LearningContextKey, options: dict
             }
           }
     """
-    return _process_learning_context(learning_context_key, _retrieve_course_completions, options)
+    detailed_results = _process_learning_context(learning_context_key, _retrieve_course_completions, options, user_id)
+
+    if user_id is not None:
+        if user_id in detailed_results:
+            return detailed_results[user_id]
+        return {'is_eligible': False, 'current_completion': 0.0, 'required_completion': 0.9}
 
+    return [uid for uid, result in detailed_results.items() if result.get('is_eligible', False)]
 
-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] | dict[str, Any]:
     """
     Retrieve the users that meet both completion and grade criteria.
 
@@ -331,6 +421,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:
@@ -372,6 +463,23 @@ def retrieve_completions_and_grades(learning_context_key: LearningContextKey, op
             }
           }
     """
+    if user_id is not None:
+        completion_result = retrieve_completions(learning_context_key, options, user_id)
+        grades_result = retrieve_subsection_grades(learning_context_key, options, user_id)
+
+        if type(grades_result) is not dict or type(completion_result) is not dict:
+            msg = 'Both results must be dictionaries when user_id is provided.'
+            raise ValueError(msg)
+
+        completion_eligible = completion_result.get('is_eligible', False)
+        grades_eligible = grades_result.get('is_eligible', False)
+
+        return {
+            **completion_result,
+            **grades_result,
+            'is_eligible': completion_eligible and grades_eligible,
+        }
+
     completion_eligible_users = set(retrieve_completions(learning_context_key, options))
     grades_eligible_users = set(retrieve_subsection_grades(learning_context_key, 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);
+}

learning_credentials/urls.py

@@ -1,9 +1,7 @@
 """URLs for learning_credentials."""
 
-# from django.urls import re_path  # noqa: ERA001, RUF100
-# from django.views.generic import TemplateView  # noqa: ERA001, RUF100
+from django.urls import include, path
 
-urlpatterns = [  # pragma: no cover
-    # TODO: Fill in URL patterns and views here.
-    # re_path(r'', TemplateView.as_view(template_name="learning_credentials/base.html")),  # noqa: ERA001, RUF100
+urlpatterns = [
+    path('api/learning_credentials/', include('learning_credentials.api.urls')),
 ]

learning_credentials/xblocks.py

@@ -0,0 +1,85 @@
+"""XBlocks for Learning Credentials."""
+
+import logging
+
+from xblock.core import XBlock
+from xblock.fields import Scope, String
+from xblock.fragment import Fragment
+from xblock.utils.resources import ResourceLoader
+from xblock.utils.studio_editable import StudioEditableXBlockMixin
+
+from .core_api import generate_credential_for_user, get_eligible_users_by_credential_type, get_user_credentials_by_type
+
+loader = ResourceLoader(__name__)
+logger = logging.getLogger(__name__)
+
+
+class CredentialsXBlock(StudioEditableXBlockMixin, XBlock):
+    """XBlock that displays the credential eligibility status and allows eligible users to generate credentials."""
+
+    display_name = String(
+        help='The display name for this component.',
+        scope=Scope.content,
+        display_name="Display name",
+        default='Credentials',
+    )
+
+    def student_view(self, context) -> Fragment:  # noqa: ANN001, ARG002
+        """Main view for the student. Displays the credential eligibility or ineligibility status."""
+        fragment = Fragment()
+        eligible_types = False
+        credentials = []
+
+        if not (is_author_mode := getattr(self.runtime, 'is_author_mode', False)):
+            credentials = self.get_credentials()
+            eligible_types = self.get_eligible_credential_types()
+
+            # Filter out the eligible types that already have a credential generated
+            for cred_type in credentials:
+                if cred_type in eligible_types:
+                    del eligible_types[cred_type]
+
+        fragment.add_content(
+            loader.render_django_template(
+                'public/html/credentials_xblock.html',
+                {
+                    'credentials': credentials,
+                    'eligible_types': eligible_types,
+                    'is_author_mode': is_author_mode,
+                },
+            )
+        )
+
+        fragment.add_css_url(self.runtime.local_resource_url(self, "public/css/credentials_xblock.css"))
+        fragment.add_javascript_url(self.runtime.local_resource_url(self, "public/js/credentials_xblock.js"))
+        fragment.initialize_js('CredentialsXBlock')
+        return fragment
+
+    def get_eligible_credential_types(self) -> dict[str, bool]:
+        """Retrieve the eligibility status for each credential type."""
+        eligible_users = get_eligible_users_by_credential_type(self.runtime.course_id, user_id=self.scope_ids.user_id)
+
+        return {credential_type: bool(users) for credential_type, users in eligible_users.items()}
+
+    def get_credentials(self) -> dict[str, dict[str, str]]:
+        """Retrieve the credentials for the current user in the current course."""
+        return get_user_credentials_by_type(self.runtime.course_id, self.scope_ids.user_id)
+
+    @XBlock.json_handler
+    def generate_credential(self, data: dict, suffix: str = '') -> dict[str, str]:  # noqa: ARG002
+        """Handler for generating a credential for a specific type."""
+        credential_type = data.get('credential_type')
+        if not credential_type:
+            return {'status': 'error', 'message': 'No credential type specified.'}
+
+        course_id = self.runtime.course_id
+        user_id = self.scope_ids.user_id
+        logger.info(
+            'Generating a credential for user %s in course %s with type %s.', user_id, course_id, credential_type
+        )
+
+        try:
+            generate_credential_for_user(course_id, credential_type, user_id)
+        except ValueError as e:
+            return {'status': 'error', 'message': str(e)}
+        return {'status': 'success'}

{learning_credentials-0.2.3.dist-info → learning_credentials-0.3.0rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: learning-credentials
-Version: 0.2.3
+Version: 0.3.0rc2
 Summary: A pluggable service for preparing Open edX credentials.
 Author-email: OpenCraft <help@opencraft.com>
 License-Expression: AGPL-3.0-or-later
@@ -31,6 +31,7 @@ Requires-Dist: pypdf
 Requires-Dist: reportlab
 Requires-Dist: openedx-completion-aggregator
 Requires-Dist: edx_ace
+Requires-Dist: edx-api-doc-tools
 Requires-Dist: learning-paths-plugin>=0.3.4
 Dynamic: license-file
 

{learning_credentials-0.2.3.dist-info → learning_credentials-0.3.0rc2.dist-info}/RECORD

@@ -1,14 +1,22 @@
 learning_credentials/__init__.py,sha256=8Q0-3Hdnfmcj41EKu1GSfzEfwWcYNDlItyEEke2r9bs,62
 learning_credentials/admin.py,sha256=ynK3tVJwLsIeV7Jk66t1FAVyVsU1G-KRIAdRkycVTmA,10439
-learning_credentials/apps.py,sha256=AA6JYUyqKYvNJ5POtQKw_s1g1VrUXuQI96hbea9H220,761
-learning_credentials/compat.py,sha256=Btm1Ii3D0nHuPZWZya_VR0JkkFcNRstuwg7A1DXlWG0,4547
+learning_credentials/apps.py,sha256=F3W0q1BCWOm2MxqLr7GsDGkwqvNq3Icxc9OqgomdD7k,1128
+learning_credentials/compat.py,sha256=g32MLgTnSZLGa6H3Qsq1WIPJXWPlFaNVuyZfbZXsKR8,4832
+learning_credentials/core_api.py,sha256=ZVNPm7SQk54roZ8rmZ0Bc6T6NLvumKWJZjJepAxM6L8,3232
 learning_credentials/exceptions.py,sha256=UaqBVXFMWR2Iob7_LMb3j4NNVmWQFAgLi_MNMRUvGsI,290
-learning_credentials/generators.py,sha256=Tzl9fLEVxrjAB1lUYhifGEpIU3JzWPcwvFHeHcVxc4M,8960
-learning_credentials/models.py,sha256=Wepzng9WYDAxF8ptyQokp_9jCmuEv_4FY7ytkKFS4uU,16047
-learning_credentials/processors.py,sha256=LkdjmkLBnXc9qeMcksB1T8AQ5ZhYaECyQO__KfHB_aU,15212
+learning_credentials/generators.py,sha256=aDo1_r9IE1ad31oHmuIpU0MxqFV8K8ymMVVGfNdeXlg,9098
+learning_credentials/models.py,sha256=GurLaQ2-hY7bflOYKV5vwqTnNwM6puE0tOg4KZ8-bqQ,17694
+learning_credentials/processors.py,sha256=CfHuotWjCsg_Yx-uyZNTKzSREJj3xXD_LnTWUw3g2ms,19806
 learning_credentials/tasks.py,sha256=byoFEUvN_ayVaU5K5SlEiA7vu9BRPaSSmKnB9g5toec,1927
-learning_credentials/urls.py,sha256=2YLZZW738D7Afyzq6hr5ajWIl6azmX-hNDGUg_8AFpE,370
-learning_credentials/views.py,sha256=1iBgQYelVHO_QWtoUZfVeyUc0o89IxQWAIwjPjaYaBQ,12
+learning_credentials/urls.py,sha256=9Xc-imliMCIOWqFHfm-CSAgwm2tQGfMR18jCyBpKcho,176
+learning_credentials/xblocks.py,sha256=gb-bfkOlRnBzwUg7CTqBJfg-BOJ1UOtaBQRmbyGuD0w,3568
+learning_credentials/api/__init__.py,sha256=q8sLFfwo5RwQu8FY6BJUL_Jrt3TUojbZK-Zlw9v08EM,40
+learning_credentials/api/urls.py,sha256=JfGSbzvC5d7s9dRq4C0d-AzTDuOVnen3wvFYSJQoEdQ,255
+learning_credentials/api/v1/__init__.py,sha256=A7ZqENtM4QM1A7j_cAfnzw4zn0kuyfXSWtylFIE0_f8,43
+learning_credentials/api/v1/permissions.py,sha256=DZMa2A6Q1ltPdWCksr7I8Ltv_qV46B9yvMM0UXXWo8E,2379
+learning_credentials/api/v1/serializers.py,sha256=c4gNva-OzBUfmKHFOgsb1Ti1GiHSnsyIeT3gYBt7fMk,2685
+learning_credentials/api/v1/urls.py,sha256=n8CTXgKyXyCkgNr210Jl5c5HQ2bZ1iEYMNLSnaB39Hc,585
+learning_credentials/api/v1/views.py,sha256=LrlHRzURWi_zEii_zq55CH05tpC2ZqPhZLyebx1Jy8M,13606
 learning_credentials/conf/locale/config.yaml,sha256=jPen2DmckNDKK30axCKEd2Q2ha9oOG3IBxrJ63Pvznk,2280
 learning_credentials/migrations/0001_initial.py,sha256=61EvThCv-0UAnhCE5feyQVfjRodbp-6cDaAr4CY5PMA,8435
 learning_credentials/migrations/0002_migrate_to_learning_credentials.py,sha256=vUhcnQKDdwOsppkXsjz2zZwOGMwIJ-fkQRsaj-K7l1o,1779
@@ -17,6 +25,9 @@ learning_credentials/migrations/0004_replace_course_keys_with_learning_context_k
 learning_credentials/migrations/0005_rename_processors_and_generators.py,sha256=5UCqjq-CBJnRo1qBAoWs91ngyEuSMN8_tQtfzsuR5SI,5271
 learning_credentials/migrations/0006_cleanup_openedx_certificates_tables.py,sha256=aJs_gOP4TmW9J-Dmr21m94jBfLQxzjAu6-ua7x4uYLE,727
 learning_credentials/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+learning_credentials/public/css/credentials_xblock.css,sha256=O_16evZyQ6c1vr5IfkKVtwt9JbE1R4w7_mBaiXgfi4k,140
+learning_credentials/public/html/credentials_xblock.html,sha256=U00jJKJfxhfKSJDcj6xyddXqjhCgi6ftCb5-2qb8qUM,2775
+learning_credentials/public/js/credentials_xblock.js,sha256=zx0mXAPY4UOZeWKsm4rmD3yBlSDvFoX8acEoIFqKhG8,1094
 learning_credentials/settings/__init__.py,sha256=tofc5eg3Q2lV13Ff_jjg1ggGgWpKYoeESkP1qxl3H_A,29
 learning_credentials/settings/common.py,sha256=4n9AeQD-GB2MYFVrwXWEsTSrKC9btn8bgyr9OQuXNsY,302
 learning_credentials/settings/production.py,sha256=yEvsCldHOdsIswW7TPLW__b9YNEK-Qy05rX5WSAcEeo,484
@@ -26,9 +37,9 @@ learning_credentials/templates/learning_credentials/edx_ace/certificate_generate
 learning_credentials/templates/learning_credentials/edx_ace/certificate_generated/email/from_name.txt,sha256=-n8tjPSwfwAfeOSZ1WhcCTrpOah4VswzMZ5mh63Pxow,20
 learning_credentials/templates/learning_credentials/edx_ace/certificate_generated/email/head.html,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 learning_credentials/templates/learning_credentials/edx_ace/certificate_generated/email/subject.txt,sha256=S7Hc5T_sZSsSBXm5_H5HBNNv16Ohl0oZn0nVqqeWL0g,132
-learning_credentials-0.2.3.dist-info/licenses/LICENSE.txt,sha256=GDpsPnW_1NKhPvZpZL9imz25P2nIpbwJPEhrlq4vPAU,34523
-learning_credentials-0.2.3.dist-info/METADATA,sha256=bGXo0uhxTIqHjjVvY4VJdFhjd37NggDgf8mgqpBgSgI,6828
-learning_credentials-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-learning_credentials-0.2.3.dist-info/entry_points.txt,sha256=hHqqLUEdzAN24v5OGBX9Fr-wh3ATDPjQjByKz03eC2Y,91
-learning_credentials-0.2.3.dist-info/top_level.txt,sha256=Ce-4_leZe_nny7CpmkeRiemcDV6jIHpIvLjlcQBuf18,21
-learning_credentials-0.2.3.dist-info/RECORD,,
+learning_credentials-0.3.0rc2.dist-info/licenses/LICENSE.txt,sha256=GDpsPnW_1NKhPvZpZL9imz25P2nIpbwJPEhrlq4vPAU,34523
+learning_credentials-0.3.0rc2.dist-info/METADATA,sha256=HgEuWC93fRcs84MGP4vJ6qMOiueVHhtAcPBGi-Mw3WA,6864
+learning_credentials-0.3.0rc2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+learning_credentials-0.3.0rc2.dist-info/entry_points.txt,sha256=kaYKfkH1k_yFaGqe-MXjBxA5RsjkqOLxz7XLrF5BUC0,258
+learning_credentials-0.3.0rc2.dist-info/top_level.txt,sha256=Ce-4_leZe_nny7CpmkeRiemcDV6jIHpIvLjlcQBuf18,21
+learning_credentials-0.3.0rc2.dist-info/RECORD,,