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

learning_credentials/api/v1/permissions.py

@@ -2,7 +2,8 @@
 
 from typing import TYPE_CHECKING
 
-from learning_paths.models import LearningPathEnrollment
+from django.db.models import Q
+from learning_paths.models import LearningPath
 from opaque_keys import InvalidKeyError
 from opaque_keys.edx.keys import LearningContextKey
 from rest_framework.exceptions import NotFound, ParseError
@@ -11,35 +12,18 @@ from rest_framework.permissions import BasePermission
 from learning_credentials.compat import get_course_enrollments
 
 if TYPE_CHECKING:
+    from django.contrib.auth.models import User
+    from learning_paths.keys import LearningPathKey
+    from opaque_keys.edx.keys import CourseKey
     from rest_framework.request import Request
     from rest_framework.views import APIView
 
 
-class IsAdminOrSelf(BasePermission):
-    """
-    Permission to allow only admins or the user themselves to access the API.
-
-    Non-staff users cannot pass "username" that is not their own.
-    """
-
-    def has_permission(self, request: "Request", view: "APIView") -> bool:  # noqa: ARG002
-        """Check if the user is admin or accessing their own data."""
-        if request.user.is_staff:
-            return True
-
-        username = request.query_params.get("username") if request.method == "GET" else request.data.get("username")
-
-        # For learners, the username passed should match the logged in user.
-        if username:
-            return request.user.username == username
-        return True
-
-
 class CanAccessLearningContext(BasePermission):
     """Permission to allow access to learning context if the user is enrolled."""
 
     def has_permission(self, request: "Request", view: "APIView") -> bool:
-        """Check if the user is enrolled in the learning context."""
+        """Check if the user can access the learning context."""
         try:
             key = view.kwargs.get("learning_context_key") or request.query_params.get("learning_context_key")
             learning_context_key = LearningContextKey.from_string(key)
@@ -51,13 +35,47 @@ class CanAccessLearningContext(BasePermission):
             return True
 
         if learning_context_key.is_course:
-            if bool(get_course_enrollments(learning_context_key, request.user.id)):
+            if self._can_access_course(learning_context_key, request.user):
                 return True
+
             msg = "Course not found or user does not have access."
             raise NotFound(msg)
 
-        if LearningPathEnrollment.objects.filter(learning_path__key=learning_context_key, user=request.user).exists():
+        # For learning paths, check enrollment or if it's not invite-only.
+        if self._can_access_learning_path(learning_context_key, request.user):
             return True
 
         msg = "Learning path not found or user does not have access."
         raise NotFound(msg)
+
+    def _can_access_course(self, course_key: "CourseKey", user: "User") -> bool:
+        """Check if user can access a course."""
+        # Check if user is enrolled in the course.
+        if get_course_enrollments(course_key, user.id):  # ty: ignore[unresolved-attribute]
+            return True
+
+        # Check if the course is a part of a learning path the user can access.
+        return self._can_access_course_via_learning_path(course_key, user)
+
+    def _get_accessible_learning_paths_filter(self, user: "User") -> Q:
+        """Get Q filter for learning paths that the user can access."""
+        return Q(invite_only=False) | Q(learningpathenrollment__user=user, learningpathenrollment__is_active=True)
+
+    def _can_access_course_via_learning_path(self, course_key: "CourseKey", user: "User") -> bool:
+        """Check if user can access a course through learning path membership."""
+        accessible_paths = (
+            LearningPath.objects.filter(steps__course_key=course_key)
+            .filter(self._get_accessible_learning_paths_filter(user))
+            .distinct()
+        )
+
+        return accessible_paths.exists()
+
+    def _can_access_learning_path(self, learning_path_key: "LearningPathKey", user: "User") -> bool:
+        """Check if user can access a learning path."""
+        # Single query to check if learning path exists and user can access it
+        accessible_path = LearningPath.objects.filter(key=learning_path_key).filter(
+            self._get_accessible_learning_paths_filter(user)
+        )
+
+        return accessible_path.exists()

learning_credentials/api/v1/urls.py

@@ -2,16 +2,12 @@
 
 from django.urls import path
 
-from .views import CredentialEligibilityView, CredentialListView
+from .views import CredentialConfigurationCheckView
 
 urlpatterns = [
-    # Credential eligibility endpoints
-    path('eligibility/<str:learning_context_key>/', CredentialEligibilityView.as_view(), name='credential-eligibility'),
     path(
-        'eligibility/<str:learning_context_key>/<int:credential_type_id>/',
-        CredentialEligibilityView.as_view(),
-        name='credential-generation',
+        'configured/<str:learning_context_key>/',
+        CredentialConfigurationCheckView.as_view(),
+        name='credential-configuration-check',
     ),
-    # Credential listing endpoints
-    path('credentials/', CredentialListView.as_view(), name='credential-list'),
 ]

learning_credentials/api/v1/views.py

@@ -1,68 +1,26 @@
 """API views for Learning Credentials."""
 
-import logging
 from typing import TYPE_CHECKING
 
 import edx_api_doc_tools as apidocs
-from django.contrib.auth.models import User
-from django.shortcuts import get_object_or_404
 from edx_api_doc_tools import ParameterLocation
 from rest_framework import status
 from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
 from rest_framework.views import APIView
 
-from learning_credentials.models import Credential, CredentialConfiguration
-from learning_credentials.tasks import generate_credential_for_user_task
+from learning_credentials.models import CredentialConfiguration
 
-from .permissions import CanAccessLearningContext, IsAdminOrSelf
-from .serializers import (
-    CredentialEligibilityResponseSerializer,
-    CredentialListResponseSerializer,
-    CredentialModelSerializer,
-)
+from .permissions import CanAccessLearningContext
 
 if TYPE_CHECKING:
     from rest_framework.request import Request
 
-logger = logging.getLogger(__name__)
 
+class CredentialConfigurationCheckView(APIView):
+    """API view to check if any credentials are configured for a specific learning context."""
 
-class CredentialEligibilityView(APIView):
-    """
-    API view for credential eligibility and generation.
-
-    This endpoint manages credential eligibility checking and generation for users in specific learning contexts.
-
-    Supported Learning Contexts:
-    - Course keys: `course-v1:org+course+run`
-    - Learning path keys: `path-v1:org+path+run+group`
-    """
-
-    permission_classes = (IsAuthenticated, IsAdminOrSelf, CanAccessLearningContext)
-
-    def _get_eligibility_data(self, user: User, config: CredentialConfiguration) -> dict:
-        """Calculate eligibility data for a credential configuration."""
-        progress_data = config.get_user_eligibility_details(user_id=user.id)  # ty: ignore[unresolved-attribute]
-
-        existing_credential = (
-            Credential.objects.filter(
-                user_id=user.id,  # ty: ignore[unresolved-attribute]
-                learning_context_key=config.learning_context_key,
-                credential_type=config.credential_type.name,
-            )
-            .exclude(status=Credential.Status.ERROR)
-            .first()
-        )
-
-        return {
-            'credential_type_id': config.credential_type.pk,
-            'name': config.credential_type.name,
-            'is_eligible': progress_data.get('is_eligible', False),
-            'existing_credential': existing_credential.uuid if existing_credential else None,
-            'existing_credential_url': existing_credential.download_url if existing_credential else None,
-            **progress_data,
-        }
+    permission_classes = (IsAuthenticated, CanAccessLearningContext)
 
     @apidocs.schema(
         parameters=[
@@ -76,282 +34,50 @@ class CredentialEligibilityView(APIView):
             ),
         ],
         responses={
-            200: CredentialEligibilityResponseSerializer,
+            200: "Boolean indicating if credentials are configured.",
             400: "Invalid context key format.",
-            403: "User is not authenticated.",
+            403: "User is not authenticated or does not have permission to access the learning context.",
             404: "Learning context not found or user does not have access.",
         },
     )
-    def get(self, request: "Request", learning_context_key: str) -> Response:
+    def get(self, _request: "Request", learning_context_key: str) -> Response:
         """
-        Get credential eligibility for a learning context.
-
-        Retrieve detailed eligibility information for all available credentials in a learning context.
-        This endpoint returns comprehensive progress data including:
-        - Current grades and requirements for grade-based credentials
-        - Completion percentages for completion-based credentials
-        - Step-by-step progress for learning paths
-        - Eligibility status for each credential type
+        Check if any credentials are configured for the given learning context.
 
         **Example Request**
 
-            GET /api/learning_credentials/v1/eligibility/course-v1:OpenedX+DemoX+DemoCourse/
+        ``GET /api/learning_credentials/v1/configured/course-v1:OpenedX+DemoX+DemoCourse/``
 
         **Response Values**
 
-        If the request is successful, an HTTP 200 "OK" response is returned.
-
-        The response structure adapts based on credential types:
-        - Grade-based credentials include `current_grades` and `required_grades`
-        - Completion-based credentials include `current_completion` and `required_completion`
-        - Learning paths include detailed `steps` breakdown
+        - **200 OK**: Request successful, returns credential configuration status.
+        - **400 Bad Request**: Invalid learning context key format.
+        - **403 Forbidden**: User is not authenticated or does not have permission to access the learning context.
+        - **404 Not Found**: Learning context not found or user does not have access.
 
-        **Example Response for Grade-based Credential**
-
-        ```json
-        {
-          "context_key": "course-v1:OpenedX+DemoX+DemoCourse",
-          "credentials": [
-            {
-              "credential_type_id": 1,
-              "name": "Certificate of Achievement",
-              "description": "",
-              "is_eligible": true,
-              "existing_credential": null,
-              "current_grades": {
-                "Final Exam": 86,
-                "Overall Grade": 82
-              },
-              "required_grades": {
-                "Final Exam": 65,
-                "Overall Grade": 80
-              }
-            }
-          ]
-        }
-        ```
+        **Example Response**
 
-        **Example Response for Completion-based Credential**
+        .. code-block:: json
 
-        ```json
-        {
-          "context_key": "course-v1:OpenedX+DemoX+DemoCourse",
-          "credentials": [
             {
-              "credential_type_id": 2,
-              "name": "Certificate of Completion",
-              "description": "",
-              "is_eligible": false,
-              "existing_credential": null,
-              "current_completion": 74.0,
-              "required_completion": 100.0
+              "has_credentials": true,
+              "credential_count": 2
             }
-          ]
-        }
-        ```
-        """
-        configurations = CredentialConfiguration.objects.filter(
-            learning_context_key=learning_context_key
-        ).select_related('credential_type')
-
-        eligibility_data = [self._get_eligibility_data(request.user, config) for config in configurations]
-
-        response_data = {
-            'context_key': learning_context_key,
-            'credentials': eligibility_data,
-        }
-
-        serializer = CredentialEligibilityResponseSerializer(data=response_data)
-        serializer.is_valid(raise_exception=True)
-        return Response(serializer.data)
-
-    @apidocs.schema(
-        parameters=[
-            apidocs.string_parameter(
-                "learning_context_key",
-                ParameterLocation.PATH,
-                description="Learning context identifier (e.g. course-v1:OpenedX+DemoX+DemoCourse)",
-            ),
-            apidocs.parameter(
-                "credential_type_id",
-                ParameterLocation.PATH,
-                int,
-                description="ID of the credential type to generate",
-            ),
-        ],
-        responses={
-            201: "Credential generation started.",
-            400: "User is not eligible for this credential or validation error.",
-            403: "User is not authenticated.",
-            404: "Learning context or credential type not found, or user does not have access.",
-            409: "User already has a valid credential of this type.",
-            500: "Internal server error during credential generation.",
-        },
-    )
-    def post(self, request: "Request", learning_context_key: str, credential_type_id: int) -> Response:
-        """
-        Trigger credential generation for an eligible user.
-
-        This endpoint initiates the credential generation process for a specific credential type.
-        The user must be eligible for the credential based on the configured requirements.
-
-        **Prerequisites:**
-        - User must be authenticated
-        - User must be enrolled in the course or have access to the learning path
-        - User must meet the eligibility criteria for the specific credential type
-        - User must not already have an existing valid credential of this type
-
-        **Process:**
-        1. Validates user eligibility using the configured processor function
-        2. Checks for existing credentials to prevent duplicates
-        3. Initiates asynchronous credential generation
-        4. Returns credential status and tracking information
-
-        **Notification:**
-        Users will receive an email notification when credential generation completes.
-
-        **Example Request**
-
-            POST /api/learning_credentials/v1/eligibility/course-v1:OpenedX+DemoX+DemoCourse/1/
-
-        **Response Values**
 
-        If the request is successful, an HTTP 201 "Created" response is returned.
+        **Response Fields**
 
-        **Example Response**
-
-        ```json
-        {
-          "status": "generating",
-          "credential_id": "123e4567-e89b-12d3-a456-426614174000",
-          "message": "Credential generation started. You will receive an email when ready."
-        }
-        ```
-        """
-        config = get_object_or_404(
-            CredentialConfiguration.objects.select_related('credential_type'),
-            learning_context_key=learning_context_key,
-            credential_type_id=credential_type_id,
-        )
-
-        existing_credential = (
-            Credential.objects.filter(
-                user_id=request.user.id,
-                learning_context_key=learning_context_key,
-                credential_type=config.credential_type.name,
-            )
-            .exclude(status=Credential.Status.ERROR)
-            .first()
-        )
-
-        if existing_credential:
-            return Response({"detail": "User already has a credential of this type."}, status=status.HTTP_409_CONFLICT)
-
-        if not config.get_eligible_user_ids(user_id=request.user.id):
-            return Response({"detail": "User is not eligible for this credential."}, status=status.HTTP_400_BAD_REQUEST)
-
-        generate_credential_for_user_task.delay(config.id, request.user.id)
-        return Response({"detail": "Credential generation started."}, status=status.HTTP_201_CREATED)
-
-
-class CredentialListView(APIView):
-    """
-    API view to list user credentials with staff override capability.
-
-    This endpoint provides access to user credential records with optional filtering
-    by learning context and staff oversight capabilities.
+        - ``has_credentials``: Boolean indicating if any credentials are configured
+        - ``credential_count``: Number of credential configurations available
 
-    **Authentication Required**: Yes
+        **Note**
 
-    **Staff Features**:
-    - Staff users can view credentials for any user by providing `username` parameter
-    - Non-staff users can only view their own credentials
-    """
-
-    def get_permissions(self) -> list:
-        """Instantiate and return the list of permissions required for this view."""
-        permission_classes = [IsAuthenticated, IsAdminOrSelf]
-
-        if self.request.query_params.get('learning_context_key'):
-            permission_classes.append(CanAccessLearningContext)
-
-        return [permission() for permission in permission_classes]
-
-    @apidocs.schema(
-        parameters=[
-            apidocs.string_parameter(
-                "learning_context_key",
-                ParameterLocation.QUERY,
-                description="Optional learning context to filter credentials (e.g. course-v1:OpenedX+DemoX+DemoCourse)",
-            ),
-            apidocs.string_parameter(
-                "username",
-                ParameterLocation.QUERY,
-                description="Username to view credentials for (staff only)",
-            ),
-        ],
-        responses={
-            200: CredentialListResponseSerializer,
-            403: "User is not authenticated or lacks permission to view specified user's credentials.",
-            404: "Specified user not found or learning context not found/accessible.",
-        },
-    )
-    def get(self, request: "Request") -> Response:
+        This endpoint does not perform learning context existence validation, so it will not return 404 for staff users.
         """
-        Retrieve a list of credentials for the authenticated user or a specified user.
-
-        This endpoint returns credential records with filtering options:
-        - Filter by learning context (course or learning path)
-        - Staff users can view credentials for any user
-        - Regular users can only view their own credentials
-
-        **Query Parameters:**
-        - `username` (staff only): View credentials for a specific user
-
-        **Path Parameters:**
-        - `learning_context_key` (optional): Filter credentials by learning context
-
-        **Response includes:**
-        - Credential ID and type
-        - Learning context information
-        - Creation date and status
-        - Download URL for completed credentials
-
-        **Example Request**
-
-            GET /api/learning_credentials/v1/credentials/
-            GET /api/learning_credentials/v1/credentials/course-v1:OpenedX+DemoX+DemoCourse/
-            GET /api/learning_credentials/v1/credentials/?username=student123  # staff only
+        credential_count = CredentialConfiguration.objects.filter(learning_context_key=learning_context_key).count()
 
-        **Response Values**
-
-        If the request is successful, an HTTP 200 "OK" response is returned.
-
-        **Example Response**
-
-        ```json
-        {
-          "credentials": [
-            {
-              "credential_id": "123e4567-e89b-12d3-a456-426614174000",
-              "credential_type": "Certificate of Achievement",
-              "context_key": "course-v1:OpenedX+DemoX+DemoCourse",
-              "status": "available",
-              "created_date": "2024-08-20T10:30:00Z",
-              "download_url": "https://example.com/credentials/123e4567.pdf"
-            }
-          ]
+        response_data = {
+            'has_credentials': credential_count > 0,
+            'credential_count': credential_count,
         }
-        ```
-        """
-        learning_context_key = request.query_params.get('learning_context_key')
-        username = request.query_params.get('username')
-        user = get_object_or_404(User, username=username) if username else request.user
-
-        credentials_queryset = Credential.objects.filter(user_id=user.pk)
-
-        if learning_context_key:
-            credentials_queryset = credentials_queryset.filter(learning_context_key=learning_context_key)
 
-        credentials_data = CredentialModelSerializer(credentials_queryset, many=True).data
-        return Response({'credentials': credentials_data})
+        return Response(response_data, status=status.HTTP_200_OK)

learning_credentials/apps.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from typing import ClassVar
 
 from django.apps import AppConfig
+from edx_django_utils.plugins.constants import PluginSettings, PluginURLs
 
 
 class LearningCredentialsConfig(AppConfig):
@@ -15,20 +16,16 @@ class LearningCredentialsConfig(AppConfig):
 
     # https://edx.readthedocs.io/projects/edx-django-utils/en/latest/plugins/how_tos/how_to_create_a_plugin_app.html
     plugin_app: ClassVar[dict[str, dict[str, dict]]] = {
-        'url_config': {
+        PluginURLs.CONFIG: {
             'lms.djangoapp': {
-                'namespace': 'learning_credentials',
-                'app_name': 'learning_credentials',
+                PluginURLs.NAMESPACE: 'learning_credentials',
+                PluginURLs.APP_NAME: 'learning_credentials',
             }
         },
-        'settings_config': {
+        PluginSettings.CONFIG: {
             'lms.djangoapp': {
-                'common': {'relative_path': 'settings.common'},
-                'production': {'relative_path': 'settings.production'},
+                'common': {PluginSettings.RELATIVE_PATH: 'settings.common'},
+                'production': {PluginSettings.RELATIVE_PATH: 'settings.production'},
             },
-            # 'cms.djangoapp': {
-            #     'common': {'relative_path': 'settings.common'},
-            #     'production': {'relative_path': 'settings.production'},
-            # },
         },
     }

learning_credentials/compat.py

@@ -74,13 +74,7 @@ def get_learning_context_name(learning_context_key: LearningContextKey) -> str:
 
 
 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.
-    """
+    """Get the course enrollments from Open edX."""
     # noinspection PyUnresolvedReferences,PyPackageRequirements
     from common.djangoapps.student.models import CourseEnrollment
 

learning_credentials/generators.py

@@ -89,7 +89,6 @@ def _write_text_on_template(template: any, font: str, username: str, context_nam
     pdf_canvas = canvas.Canvas(io.BytesIO(), pagesize=(template_width, template_height))
 
     # Write the learner name.
-    # TODO: Add tests.
     pdf_canvas.setFont(font, options.get('name_size', 32))
     name_color = options.get('name_color', '#000')
     pdf_canvas.setFillColorRGB(*hex_to_rgb(name_color))

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, Any
+from typing import TYPE_CHECKING
 
 import jsonfield
 from django.conf import settings
@@ -165,12 +165,11 @@ class CredentialConfiguration(TimeStampedModel):
         filtered_user_ids_set = set(user_ids) - set(users_ids_with_credentials)
         return list(filtered_user_ids_set)
 
-    def _call_retrieval_func(self, user_id: int | None = None) -> list[int] | dict[str, Any]:
+    def get_eligible_user_ids(self) -> list[int]:
         """
-        Call the retrieval function with the given parameters.
+        Get the list of eligible learners for the given course.
 
-        :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.
+        :return: A list of user IDs.
         """
         func_path = self.credential_type.retrieval_func
         module_path, func_name = func_path.rsplit('.', 1)
@@ -178,40 +177,7 @@ 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, 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}
+        return func(self.learning_context_key, custom_options)
 
     def generate_credential_for_user(self, user_id: int, celery_task_id: int = 0):
         """
@@ -328,15 +294,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",  # 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]
+            name="certificate_generated",
+            app_label="learning_credentials",
+            recipient=Recipient(lms_user_id=user.id, email_address=user.email),
+            language='en',
             context={
                 'certificate_link': self.download_url,
                 'course_name': learning_context_name,
                 'platform_name': settings.PLATFORM_NAME,
-            },  # type: ignore[unknown-argument]
+            },
         )
         ace.send(msg)