learning-credentials 0.3.0rc4__py3-none-any.whl → 0.3.0rc10__py3-none-any.whl

learning_credentials/core_api.py

@@ -1,77 +0,0 @@
-"""API functions for the Learning Credentials app."""
-
-import logging
-from typing import TYPE_CHECKING
-
-from .models import Credential, CredentialConfiguration
-from .tasks import generate_credential_for_user_task
-
-if TYPE_CHECKING:
-    from django.contrib.auth.models import User
-    from opaque_keys.edx.keys import CourseKey
-
-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)
-        msg = 'User is not eligible for the credential.'
-        raise ValueError(msg)
-
-    generate_credential_for_user_task.delay(credential_config.id, user_id)

learning_credentials/public/css/credentials_xblock.css

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

learning_credentials/public/html/credentials_xblock.html

@@ -1,48 +0,0 @@
-<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

@@ -1,23 +0,0 @@
-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/xblocks.py

@@ -1,85 +0,0 @@
-"""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'}