learning-credentials 0.3.0rc4__py3-none-any.whl → 0.3.1rc1__py3-none-any.whl

learning_credentials/api/urls.py

@@ -2,11 +2,8 @@
 
 from django.urls import include, path
 
+from .v1 import urls as v1_urls
+
 urlpatterns = [
-    path(
-        "v1/",
-        include(
-            ("learning_credentials.api.v1.urls", "learning_credentials_api_v1"), namespace="learning_credentials_api_v1"
-        ),
-    ),
+    path("v1/", include((v1_urls, "learning_credentials_api_v1"), namespace="learning_credentials_api_v1")),
 ]

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,22 +2,12 @@
 
 from django.urls import path
 
-from .views import CredentialConfigurationCheckView, CredentialEligibilityView, CredentialListView
+from .views import CredentialConfigurationCheckView
 
 urlpatterns = [
-    # Credential configuration check endpoint
     path(
         'configured/<str:learning_context_key>/',
         CredentialConfigurationCheckView.as_view(),
-        name='credential-configuration-check',
+        name='credential_configuration_check',
     ),
-    # 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',
-    ),
-    # Credential listing endpoints
-    path('credentials/', CredentialListView.as_view(), name='credential-list'),
 ]

learning_credentials/api/v1/views.py

@@ -1,37 +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."""
 
-    permission_classes = (IsAuthenticated, IsAdminOrSelf, CanAccessLearningContext)
+    permission_classes = (IsAuthenticated, CanAccessLearningContext)
 
     @apidocs.schema(
         parameters=[
@@ -47,6 +36,7 @@ class CredentialConfigurationCheckView(APIView):
         responses={
             200: "Boolean indicating if credentials are configured.",
             400: "Invalid context key format.",
+            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.",
         },
     )
@@ -56,26 +46,31 @@ class CredentialConfigurationCheckView(APIView):
 
         **Example Request**
 
-            GET /api/learning_credentials/v1/configured/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.
+        - **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**
 
-        ```json
-        {
-          "has_credentials": true,
-          "credential_count": 2
-        }
-        ```
+        .. code-block:: json
+
+            {
+              "has_credentials": true,
+              "credential_count": 2
+            }
 
         **Response Fields**
-        - `has_credentials`: Boolean indicating if any credentials are configured
-        - `credential_count`: Number of credential configurations available
+
+        - ``has_credentials``: Boolean indicating if any credentials are configured
+        - ``credential_count``: Number of credential configurations available
 
         **Note**
+
         This endpoint does not perform learning context existence validation, so it will not return 404 for staff users.
         """
         credential_count = CredentialConfiguration.objects.filter(learning_context_key=learning_context_key).count()
@@ -86,346 +81,3 @@ class CredentialConfigurationCheckView(APIView):
         }
 
         return Response(response_data, status=status.HTTP_200_OK)
-
-
-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`
-
-    **Staff Features**:
-    - Staff users can view eligibility for any user by providing `username` parameter
-    - Non-staff users can only view their own eligibility
-    """
-
-    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,
-        }
-
-    @apidocs.schema(
-        parameters=[
-            apidocs.string_parameter(
-                "learning_context_key",
-                ParameterLocation.PATH,
-                description=(
-                    "Learning context identifier. Can be a course key (course-v1:OpenedX+DemoX+DemoCourse) "
-                    "or learning path key (path-v1:OpenedX+DemoX+DemoPath+Demo)"
-                ),
-            ),
-        ],
-        responses={
-            200: CredentialEligibilityResponseSerializer,
-            400: "Invalid context key format.",
-            403: "User is not authenticated.",
-            404: "Learning context not found or user does not have access.",
-        },
-    )
-    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
-
-        **Query Parameters:**
-        - `username` (staff only): View eligibility for a specific user
-
-        **Example Request**
-
-            GET /api/learning_credentials/v1/eligibility/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
-
-        **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 for Completion-based Credential**
-
-        ```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
-            }
-          ]
-        }
-        ```
-        """
-        username = request.query_params.get('username')
-        user = get_object_or_404(User, username=username) if username else request.user
-
-        configurations = CredentialConfiguration.objects.filter(
-            learning_context_key=learning_context_key
-        ).select_related('credential_type')
-
-        eligibility_data = [self._get_eligibility_data(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.
-
-        **Query Parameters:**
-        - `username` (staff only): Trigger credential generation for a specific user
-
-        **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.
-
-        **Example Response**
-
-        ```json
-        {
-          "status": "generating",
-          "credential_id": "123e4567-e89b-12d3-a456-426614174000",
-          "message": "Credential generation started. You will receive an email when ready."
-        }
-        ```
-        """
-        username = request.query_params.get('username')
-        user = get_object_or_404(User, username=username) if username else request.user
-
-        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=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=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, 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.
-
-    **Authentication Required**: Yes
-
-    **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:
-        """
-        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
-        - `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
-
-        **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"
-            }
-          ]
-        }
-        ```
-        """
-        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})

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: name,
+                PluginURLs.APP_NAME: name,
             }
         },
-        '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

@@ -52,10 +52,13 @@ def get_course_grading_policy(course_id: CourseKey) -> dict:
 def _get_course_name(course_id: CourseKey) -> str:
     """Get the course name from Open edX."""
     # noinspection PyUnresolvedReferences,PyPackageRequirements
-    from openedx.core.djangoapps.content.learning_sequences.api import get_course_outline
+    from openedx.core.djangoapps.content.course_overviews.api import get_course_overview_or_none
 
-    course_outline = get_course_outline(course_id)
-    return (course_outline and course_outline.title) or str(course_id)
+    name = str(course_id)
+    if course_overview := get_course_overview_or_none(course_id):
+        name = course_overview.cert_name_long or course_overview.display_name or name
+
+    return name
 
 
 def _get_learning_path_name(learning_path_key: LearningPathKey) -> str:
@@ -74,13 +77,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