learning-credentials 0.3.0rc3__tar.gz → 0.3.0rc4__tar.gz

{learning_credentials-0.3.0rc3/learning_credentials.egg-info → learning_credentials-0.3.0rc4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: learning-credentials
-Version: 0.3.0rc3
+Version: 0.3.0rc4
 Summary: A pluggable service for preparing Open edX credentials.
 Author-email: OpenCraft <help@opencraft.com>
 License-Expression: AGPL-3.0-or-later

{learning_credentials-0.3.0rc3 → learning_credentials-0.3.0rc4}/learning_credentials/api/v1/serializers.py

@@ -45,7 +45,7 @@ class CredentialEligibilitySerializer(serializers.Serializer):
     name = serializers.CharField()
     is_eligible = serializers.BooleanField()
     existing_credential = serializers.UUIDField(required=False, allow_null=True)
-    existing_credential_url = serializers.URLField(required=False, allow_null=True)
+    existing_credential_url = serializers.URLField(required=False, allow_blank=True, allow_null=True)
 
     current_grades = serializers.DictField(required=False)
     required_grades = serializers.DictField(required=False)

{learning_credentials-0.3.0rc3 → learning_credentials-0.3.0rc4}/learning_credentials/api/v1/urls.py

@@ -2,9 +2,15 @@
 
 from django.urls import path
 
-from .views import CredentialEligibilityView, CredentialListView
+from .views import CredentialConfigurationCheckView, CredentialEligibilityView, CredentialListView
 
 urlpatterns = [
+    # Credential configuration check endpoint
+    path(
+        'configured/<str:learning_context_key>/',
+        CredentialConfigurationCheckView.as_view(),
+        name='credential-configuration-check',
+    ),
     # Credential eligibility endpoints
     path('eligibility/<str:learning_context_key>/', CredentialEligibilityView.as_view(), name='credential-eligibility'),
     path(

{learning_credentials-0.3.0rc3 → learning_credentials-0.3.0rc4}/learning_credentials/api/v1/views.py

@@ -28,6 +28,66 @@ if TYPE_CHECKING:
 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)
+
+    @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: "Boolean indicating if credentials are configured.",
+            400: "Invalid context key format.",
+            404: "Learning context not found or user does not have access.",
+        },
+    )
+    def get(self, _request: "Request", learning_context_key: str) -> Response:
+        """
+        Check if any credentials are configured for the given learning context.
+
+        **Example Request**
+
+            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.
+
+        **Example Response**
+
+        ```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
+
+        **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()
+
+        response_data = {
+            'has_credentials': credential_count > 0,
+            'credential_count': credential_count,
+        }
+
+        return Response(response_data, status=status.HTTP_200_OK)
+
+
 class CredentialEligibilityView(APIView):
     """
     API view for credential eligibility and generation.
@@ -37,6 +97,10 @@ class CredentialEligibilityView(APIView):
     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)
@@ -93,6 +157,9 @@ class CredentialEligibilityView(APIView):
         - 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/
@@ -150,11 +217,14 @@ class CredentialEligibilityView(APIView):
         }
         ```
         """
+        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(request.user, config) for config in configurations]
+        eligibility_data = [self._get_eligibility_data(user, config) for config in configurations]
 
         response_data = {
             'context_key': learning_context_key,
@@ -210,6 +280,9 @@ class CredentialEligibilityView(APIView):
         **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/
@@ -228,6 +301,9 @@ class CredentialEligibilityView(APIView):
         }
         ```
         """
+        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,
@@ -236,7 +312,7 @@ class CredentialEligibilityView(APIView):
 
         existing_credential = (
             Credential.objects.filter(
-                user_id=request.user.id,
+                user_id=user.id,
                 learning_context_key=learning_context_key,
                 credential_type=config.credential_type.name,
             )
@@ -247,10 +323,10 @@ class CredentialEligibilityView(APIView):
         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):
+        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, request.user.id)
+        generate_credential_for_user_task.delay(config.id, user.id)
         return Response({"detail": "Credential generation started."}, status=status.HTTP_201_CREATED)
 
 
@@ -307,8 +383,6 @@ class CredentialListView(APIView):
 
         **Query Parameters:**
         - `username` (staff only): View credentials for a specific user
-
-        **Path Parameters:**
         - `learning_context_key` (optional): Filter credentials by learning context
 
         **Response includes:**

{learning_credentials-0.3.0rc3 → learning_credentials-0.3.0rc4/learning_credentials.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: learning-credentials
-Version: 0.3.0rc3
+Version: 0.3.0rc4
 Summary: A pluggable service for preparing Open edX credentials.
 Author-email: OpenCraft <help@opencraft.com>
 License-Expression: AGPL-3.0-or-later

{learning_credentials-0.3.0rc3 → learning_credentials-0.3.0rc4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "learning-credentials"
-version = "0.3.0-rc3"
+version = "0.3.0-rc4"
 description = "A pluggable service for preparing Open edX credentials."
 dynamic = ["readme"]
 requires-python = ">=3.11"

{learning_credentials-0.3.0rc3 → learning_credentials-0.3.0rc4}/tests/test_views.py

@@ -128,6 +128,275 @@ def credential_instance(user: User, course_key: CourseKey) -> Credential:
 
 
 # Test classes
+@pytest.mark.django_db
+class TestCredentialConfigurationCheckViewAuthentication:
+    """Test authentication requirements for credential configuration check endpoint."""
+
+    def test_unauthenticated_user_gets_403(self, api_client: APIClient, course_key: CourseKey):
+        """Test that unauthenticated user gets 403."""
+        url = reverse(
+            'learning_credentials_api_v1:credential-configuration-check',
+            kwargs={'learning_context_key': str(course_key)},
+        )
+        response = api_client.get(url)
+        assert response.status_code == status.HTTP_403_FORBIDDEN
+
+
+@pytest.mark.django_db
+class TestCredentialConfigurationCheckViewPermissions:
+    """Test permission requirements for credential configuration check endpoint."""
+
+    @patch('learning_credentials.api.v1.permissions.get_course_enrollments')
+    def test_enrolled_user_can_access_course_check(
+        self, mock_course_enrollments: Mock, authenticated_client: APIClient, user: User, course_key: CourseKey
+    ):
+        """Test that enrolled user can access course configuration check."""
+        mock_course_enrollments.return_value = [user]
+
+        url = reverse(
+            'learning_credentials_api_v1:credential-configuration-check',
+            kwargs={'learning_context_key': str(course_key)},
+        )
+        response = authenticated_client.get(url)
+
+        assert response.status_code == status.HTTP_200_OK
+        data = response.json()
+        assert data['has_credentials'] is False
+        assert data['credential_count'] == 0
+        mock_course_enrollments.assert_called_once_with(course_key, user.id)
+
+    @patch('learning_credentials.api.v1.permissions.get_course_enrollments')
+    def test_non_enrolled_user_denied_course_access(
+        self, mock_course_enrollments: Mock, authenticated_client: APIClient, course_key: CourseKey
+    ):
+        """Test that non-enrolled user is denied course access."""
+        mock_course_enrollments.return_value = []
+
+        url = reverse(
+            'learning_credentials_api_v1:credential-configuration-check',
+            kwargs={'learning_context_key': str(course_key)},
+        )
+        response = authenticated_client.get(url)
+
+        assert response.status_code == status.HTTP_404_NOT_FOUND
+        assert 'Course not found or user does not have access' in str(response.data)
+
+    @patch('learning_paths.models.LearningPathEnrollment.objects')
+    def test_enrolled_user_can_access_learning_path_check(
+        self, mock_learning_path_enrollment: Mock, authenticated_client: APIClient, learning_path_key: LearningPathKey
+    ):
+        """Test that enrolled user can access learning path configuration check."""
+        mock_learning_path_enrollment.filter.return_value.exists.return_value = True
+
+        url = reverse(
+            'learning_credentials_api_v1:credential-configuration-check',
+            kwargs={'learning_context_key': str(learning_path_key)},
+        )
+        response = authenticated_client.get(url)
+
+        assert response.status_code == status.HTTP_200_OK
+        data = response.json()
+        assert data['has_credentials'] is False
+        assert data['credential_count'] == 0
+
+    @patch('learning_paths.models.LearningPathEnrollment.objects')
+    def test_non_enrolled_user_denied_learning_path_access(
+        self, mock_learning_path_enrollment: Mock, authenticated_client: APIClient, learning_path_key: LearningPathKey
+    ):
+        """Test that non-enrolled user is denied learning path access."""
+        mock_learning_path_enrollment.filter.return_value.exists.return_value = False
+
+        url = reverse(
+            'learning_credentials_api_v1:credential-configuration-check',
+            kwargs={'learning_context_key': str(learning_path_key)},
+        )
+        response = authenticated_client.get(url)
+
+        assert response.status_code == status.HTTP_404_NOT_FOUND
+        assert 'Learning path not found or user does not have access' in str(response.data)
+
+    def test_invalid_learning_context_key_returns_400(self, authenticated_client: APIClient):
+        """Test that invalid learning context key returns 400."""
+        url = reverse(
+            'learning_credentials_api_v1:credential-configuration-check',
+            kwargs={'learning_context_key': 'invalid-key'},
+        )
+        response = authenticated_client.get(url)
+
+        assert response.status_code == status.HTTP_400_BAD_REQUEST
+        assert 'Invalid learning context key' in str(response.data)
+
+    @patch('learning_credentials.api.v1.permissions.get_course_enrollments')
+    def test_staff_can_view_any_context_check(
+        self, mock_course_enrollments: Mock, staff_client: APIClient, course_key: CourseKey
+    ):
+        """Test that staff can view configuration check for any context without enrollment check."""
+        # Staff users bypass enrollment checks, so we don't need to mock enrollment
+        url = reverse(
+            'learning_credentials_api_v1:credential-configuration-check',
+            kwargs={'learning_context_key': str(course_key)},
+        )
+        response = staff_client.get(url)
+
+        assert response.status_code == status.HTTP_200_OK
+        data = response.json()
+        assert data['has_credentials'] is False
+        assert data['credential_count'] == 0
+        # Staff users don't trigger enrollment checks
+        mock_course_enrollments.assert_not_called()
+
+
+@pytest.mark.django_db
+class TestCredentialConfigurationCheckView:
+    """Test the CredentialConfigurationCheckView functionality."""
+
+    @patch('learning_credentials.api.v1.permissions.get_course_enrollments')
+    def test_no_credentials_configured(
+        self, mock_course_enrollments: Mock, authenticated_client: APIClient, user: User, course_key: CourseKey
+    ):
+        """Test response when no credentials are configured for a learning context."""
+        mock_course_enrollments.return_value = [user]
+
+        url = reverse(
+            'learning_credentials_api_v1:credential-configuration-check',
+            kwargs={'learning_context_key': str(course_key)},
+        )
+        response = authenticated_client.get(url)
+
+        assert response.status_code == status.HTTP_200_OK
+        data = response.json()
+
+        assert data['has_credentials'] is False
+        assert data['credential_count'] == 0
+
+    @patch('learning_credentials.api.v1.permissions.get_course_enrollments')
+    def test_single_credential_configured(
+        self,
+        mock_course_enrollments: Mock,
+        authenticated_client: APIClient,
+        user: User,
+        course_key: CourseKey,
+        grade_config: CredentialConfiguration,
+    ):
+        """Test response when one credential is configured for a learning context."""
+        mock_course_enrollments.return_value = [user]
+
+        url = reverse(
+            'learning_credentials_api_v1:credential-configuration-check',
+            kwargs={'learning_context_key': str(course_key)},
+        )
+        response = authenticated_client.get(url)
+
+        assert response.status_code == status.HTTP_200_OK
+        data = response.json()
+
+        assert data['has_credentials'] is True
+        assert data['credential_count'] == 1
+
+    @patch('learning_credentials.api.v1.permissions.get_course_enrollments')
+    def test_multiple_credentials_configured(
+        self,
+        mock_course_enrollments: Mock,
+        authenticated_client: APIClient,
+        user: User,
+        course_key: CourseKey,
+        grade_config: CredentialConfiguration,
+        completion_config: CredentialConfiguration,
+    ):
+        """Test response when multiple credentials are configured for a learning context."""
+        mock_course_enrollments.return_value = [user]
+
+        url = reverse(
+            'learning_credentials_api_v1:credential-configuration-check',
+            kwargs={'learning_context_key': str(course_key)},
+        )
+        response = authenticated_client.get(url)
+
+        assert response.status_code == status.HTTP_200_OK
+        data = response.json()
+
+        assert data['has_credentials'] is True
+        assert data['credential_count'] == 2
+
+    @patch('learning_paths.models.LearningPathEnrollment.objects')
+    def test_learning_path_credentials_configured(
+        self, mock_learning_path_enrollment: Mock, authenticated_client: APIClient, learning_path_key: LearningPathKey
+    ):
+        """Test response for learning path context with configured credentials."""
+        mock_learning_path_enrollment.filter.return_value.exists.return_value = True
+
+        # Create a credential configuration for the learning path
+        credential_type = CredentialType.objects.create(
+            name="Learning Path Certificate",
+            retrieval_func="learning_credentials.processors.retrieve_completions",
+            generation_func="learning_credentials.generators.generate_pdf_credential",
+        )
+        CredentialConfiguration.objects.create(
+            learning_context_key=learning_path_key,
+            credential_type=credential_type,
+        )
+
+        url = reverse(
+            'learning_credentials_api_v1:credential-configuration-check',
+            kwargs={'learning_context_key': str(learning_path_key)},
+        )
+        response = authenticated_client.get(url)
+
+        assert response.status_code == status.HTTP_200_OK
+        data = response.json()
+
+        assert data['has_credentials'] is True
+        assert data['credential_count'] == 1
+
+    @patch('learning_credentials.api.v1.permissions.get_course_enrollments')
+    def test_response_structure(
+        self,
+        mock_course_enrollments: Mock,
+        authenticated_client: APIClient,
+        user: User,
+        course_key: CourseKey,
+        grade_config: CredentialConfiguration,
+    ):
+        """Test that response has the correct structure and field types."""
+        mock_course_enrollments.return_value = [user]
+
+        url = reverse(
+            'learning_credentials_api_v1:credential-configuration-check',
+            kwargs={'learning_context_key': str(course_key)},
+        )
+        response = authenticated_client.get(url)
+
+        assert response.status_code == status.HTTP_200_OK
+        data = response.json()
+
+        # Verify all expected fields are present
+        assert 'has_credentials' in data
+        assert 'credential_count' in data
+
+        # Verify field types
+        assert isinstance(data['has_credentials'], bool)
+        assert isinstance(data['credential_count'], int)
+
+        # Verify values
+        assert data['has_credentials'] is True
+        assert data['credential_count'] == 1
+
+    def test_staff_can_check_any_context(
+        self, staff_client: APIClient, course_key: CourseKey, grade_config: CredentialConfiguration
+    ):
+        """Test that staff can check configuration for any context without enrollment."""
+        url = reverse(
+            'learning_credentials_api_v1:credential-configuration-check',
+            kwargs={'learning_context_key': str(course_key)},
+        )
+        response = staff_client.get(url)
+
+        assert response.status_code == status.HTTP_200_OK
+        data = response.json()
+        assert data['has_credentials'] is True
+        assert data['credential_count'] == 1
+
+
 @pytest.mark.django_db
 class TestCredentialEligibilityViewAuthentication:
     """Test authentication requirements for credential eligibility endpoints."""