learning-paths-plugin 0.2.3__py2.py3-none-any.whl

learning_paths/__init__.py

@@ -0,0 +1,5 @@
+"""
+Learning Paths plugin.
+"""
+
+__version__ = "0.2.3"

learning_paths/admin.py

@@ -0,0 +1,155 @@
+"""
+Django Admin for learning_paths.
+"""
+
+from django import forms
+from django.contrib import admin, auth
+from django.core.exceptions import ValidationError
+from django.db import transaction
+from django.utils.translation import gettext_lazy as _
+
+from .compat import get_course_keys_with_outlines
+from .models import (
+    AcquiredSkill,
+    LearningPath,
+    LearningPathEnrollment,
+    LearningPathGradingCriteria,
+    LearningPathStep,
+    RequiredSkill,
+    Skill,
+)
+
+User = auth.get_user_model()
+
+
+def get_course_keys_choices():
+    """Get course keys in an adequate format for a choice field."""
+    yield None, ""
+    for key in get_course_keys_with_outlines():
+        yield key, key
+
+
+class LearningPathStepForm(forms.ModelForm):
+    """Admin form for Learning Path step."""
+
+    # TODO: Use autocomplete select instead.
+    # See <https://github.com/open-craft/section-to-course/blob/db6fd6f8f4478e91bb531e6c2fa50143e1c2e012/
+    #      section_to_course/admin.py#L31-L140>
+    course_key = forms.ChoiceField(choices=get_course_keys_choices, label=_("Course"))
+
+
+class LearningPathStepInline(admin.TabularInline):
+    """Inline Admin for Learning Path step."""
+
+    model = LearningPathStep
+    form = LearningPathStepForm
+
+
+class AcquiredSkillInline(admin.TabularInline):
+    """Inline Admin for Learning Path acquired skill."""
+
+    model = AcquiredSkill
+
+
+class RequiredSkillInline(admin.TabularInline):
+    """Inline Admin for Learning Path required skill."""
+
+    model = RequiredSkill
+
+
+class LearningPathGradingCriteriaInline(admin.TabularInline):
+    """Inline Admin for Learning path grading criteria."""
+
+    model = LearningPathGradingCriteria
+
+
+class BulkEnrollUsersForm(forms.ModelForm):
+    """Form to bulk enroll users in a learning path."""
+
+    usernames = forms.CharField(
+        widget=forms.Textarea,
+        help_text="Enter usernames separated by newlines",
+        label="Bulk enroll users",
+        required=False,
+    )
+
+    class Meta:
+        """Form options."""
+
+        model = LearningPath
+        fields = "__all__"
+
+    def clean_usernames(self):
+        """Validate usernames and return a list of users."""
+        data = self.cleaned_data["usernames"]
+        if not data:
+            return []
+        usernames = [username.strip() for username in data.split("\n")]
+        users = User.objects.filter(username__in=usernames)
+        found_usernames = list(users.values_list("username", flat=True))
+        invalid_usernames = set(usernames) - set(found_usernames)
+        if invalid_usernames:
+            raise ValidationError(
+                f"The following usernames are not valid: {', '.join(invalid_usernames)}"
+            )
+        return users
+
+
+class LearningPathAdmin(admin.ModelAdmin):
+    """Admin for Learning Path."""
+
+    model = LearningPath
+    form = BulkEnrollUsersForm
+
+    search_fields = [
+        "slug",
+        "display_name",
+    ]
+    list_display = (
+        "uuid",
+        "slug",
+        "display_name",
+        "level",
+        "duration_in_days",
+    )
+
+    inlines = [
+        LearningPathStepInline,
+        RequiredSkillInline,
+        AcquiredSkillInline,
+        LearningPathGradingCriteriaInline,
+    ]
+
+    def save_related(self, request, form, formsets, change):
+        """Save related objects and enroll users in the learning path."""
+        super().save_related(request, form, formsets, change)
+        with transaction.atomic():
+            for user in form.cleaned_data["usernames"]:
+                LearningPathEnrollment.objects.get_or_create(
+                    user=user, learning_path=form.instance
+                )
+
+
+class SkillAdmin(admin.ModelAdmin):
+    """Admin for Learning Path generic skill."""
+
+    model = Skill
+
+
+class EnrolledUsersAdmin(admin.ModelAdmin):
+    """Admin for Learning Path enrollment."""
+
+    model = LearningPathEnrollment
+
+    search_fields = [
+        "id",
+        "user__username",
+        "learning_path__uuid",
+        "learning_path__slug",
+        "learning_path__display_name",
+    ]
+
+
+admin.site.register(LearningPath, LearningPathAdmin)
+admin.site.register(Skill, SkillAdmin)
+admin.site.register(LearningPathEnrollment, EnrolledUsersAdmin)

learning_paths/api/urls.py

@@ -0,0 +1,7 @@
+"""API URLs."""
+
+from django.urls import include, path
+
+urlpatterns = [
+    path("v1/", include("learning_paths.api.v1.urls")),
+]

learning_paths/api/v1/filters.py

@@ -0,0 +1,16 @@
+"""
+Django REST framework filters.
+"""
+
+from rest_framework.filters import BaseFilterBackend
+
+
+class AdminOrSelfFilterBackend(BaseFilterBackend):
+    """
+    A filter backend that limits the queryset to the current user for non-staff.
+    """
+
+    def filter_queryset(self, request, queryset, view):
+        if request.user.is_staff:
+            return queryset
+        return queryset.filter(user=request.user)

learning_paths/api/v1/permissions.py

@@ -0,0 +1,27 @@
+"""
+Django REST framework permissions.
+"""
+
+from rest_framework.permissions import BasePermission
+
+
+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, view):
+        if request.user.is_staff:
+            return True
+
+        if request.method == "GET":
+            username = request.query_params.get("username")
+        else:
+            username = request.data.get("username")
+
+        # For learners, the username passed should match the logged in user
+        if username:
+            return request.user.username == username
+        return True

learning_paths/api/v1/serializers.py

@@ -0,0 +1,93 @@
+"""
+Serializer for LearningPath.
+"""
+
+from rest_framework import serializers
+
+from learning_paths.models import LearningPath, LearningPathEnrollment
+
+DEFAULT_STATUS = "active"
+IMAGE_WIDTH = 1440
+IMAGE_HEIGHT = 480
+
+
+class LearningPathAsProgramSerializer(serializers.ModelSerializer):
+    """
+    Serialize LearningPath as a Program to be ingested by course-discovery.
+
+    Mocked data example:
+    https://github.com/openedx/course-discovery/blob/d6a57fd69479b3d5f5afb682d2668b58503a6af6/course_discovery/apps/course_metadata/data_loaders/tests/mock_data.py#L580
+    """
+
+    name = serializers.CharField(source="display_name")
+    marketing_slug = serializers.SerializerMethodField()
+    title = serializers.CharField(source="display_name")
+    status = serializers.SerializerMethodField()
+    banner_image_urls = serializers.SerializerMethodField()
+    organizations = serializers.SerializerMethodField()
+    course_codes = serializers.SerializerMethodField()
+
+    def get_marketing_slug(self, obj):
+        return obj.slug
+
+    def get_status(self, obj):  # pylint: disable=unused-argument
+        return DEFAULT_STATUS
+
+    def get_banner_image_urls(self, obj):
+        if obj.image_url:
+            image_key = f"w{IMAGE_WIDTH}h{IMAGE_HEIGHT}"
+            return {image_key: obj.image_url}
+        return {}
+
+    def get_organizations(self, obj):  # pylint: disable=unused-argument
+        return []
+
+    def get_course_codes(self, obj):
+        """returns course_codes as expected by course-discovery"""
+        course_codes_dict = {}
+        learning_path_course_keys = [course.course_key for course in obj.steps.all()]
+        for course_key in learning_path_course_keys:
+            run_mode = {"course_key": str(course_key), "run_key": course_key.run}
+            if course_key.course in course_codes_dict:
+                course_codes_dict[course_key.course]["run_modes"].append(run_mode)
+            else:
+                course_codes_dict[course_key.course] = {"run_modes": [run_mode]}
+
+        return [{"key": key, **value} for key, value in course_codes_dict.items()]
+
+    class Meta:
+        model = LearningPath
+        fields = (
+            "uuid",
+            "name",
+            "marketing_slug",
+            "title",
+            "subtitle",
+            "status",
+            "banner_image_urls",
+            "organizations",
+            "course_codes",
+        )
+
+
+# pylint: disable=abstract-method
+class LearningPathProgressSerializer(serializers.Serializer):
+    learning_path_id = serializers.UUIDField()
+    progress = serializers.FloatField()
+    required_completion = serializers.FloatField()
+
+
+class LearningPathGradeSerializer(serializers.Serializer):
+    """
+    Serializer for learning path grade.
+    """
+
+    learning_path_id = serializers.UUIDField()
+    grade = serializers.FloatField()
+    required_grade = serializers.FloatField()
+
+
+class LearningPathEnrollmentSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LearningPathEnrollment
+        fields = ("user", "learning_path", "is_active", "enrolled_at")

learning_paths/api/v1/urls.py

@@ -0,0 +1,46 @@
+"""API v1 URLs."""
+
+from django.urls import path
+from rest_framework import routers
+
+from learning_paths.api.v1.views import (
+    BulkEnrollView,
+    LearningPathAsProgramViewSet,
+    LearningPathEnrollmentView,
+    LearningPathUserGradeView,
+    LearningPathUserProgressView,
+    ListEnrollmentsView,
+)
+
+router = routers.SimpleRouter()
+router.register(
+    r"programs", LearningPathAsProgramViewSet, basename="learning-path-as-program"
+)
+
+urlpatterns = router.urls + [
+    path(
+        "<uuid:learning_path_uuid>/progress/",
+        LearningPathUserProgressView.as_view(),
+        name="learning-path-progress",
+    ),
+    path(
+        "<uuid:learning_path_uuid>/grade/",
+        LearningPathUserGradeView.as_view(),
+        name="learning-path-grade",
+    ),
+    path(
+        "<uuid:learning_path_id>/enrollments/",
+        LearningPathEnrollmentView.as_view(),
+        name="learning-path-enrollments",
+    ),
+    path(
+        "enrollments/",
+        ListEnrollmentsView.as_view(),
+        name="list-enrollments",
+    ),
+    path(
+        "enrollments/bulk-enroll/",
+        BulkEnrollView.as_view(),
+        name="bulk-enroll",
+    ),
+]

learning_paths/api/v1/utils.py

@@ -0,0 +1,65 @@
+"""
+Util methods for LearningPath
+"""
+
+from typing import Any
+
+from django.conf import settings
+from opaque_keys.edx.keys import CourseKey
+from requests.exceptions import HTTPError
+from rest_framework.exceptions import APIException
+
+from ...compat import get_catalog_api_client
+from ...models import LearningPathStep
+
+
+def get_course_completion(username: str, course_key: CourseKey, client: Any) -> float:
+    """
+    Fetch the completion percentage of a course for a specific user via an internal API request.
+    """
+    course_id = str(course_key)
+    lms_base_url = settings.LMS_ROOT_URL
+    completion_url = f"{lms_base_url}/completion-aggregator/v1/course/{course_id}/?username={username}"
+
+    try:
+        response = client.get(completion_url)
+        response.raise_for_status()
+        data = response.json()
+    except HTTPError as err:
+        if err.response.status_code == 404:
+            return 0.0
+        else:
+            raise APIException(
+                f"Error fetching completion for course {course_id}: {err}"
+            ) from err
+
+    if data and data.get("results"):
+        return data["results"][0]["completion"]["percent"]
+    return 0.0
+
+
+def get_aggregate_progress(user, learning_path):
+    """
+    Calculate the aggregate progress for all courses in the learning path.
+    """
+    steps = LearningPathStep.objects.filter(learning_path=learning_path)
+
+    client = get_catalog_api_client(user)
+    # TODO: Create a native Python API in the completion aggregator
+    # to avoid the overhead of making HTTP requests and improve performance.
+
+    total_completion = 0.0
+
+    for step in steps:
+        course_completion = get_course_completion(
+            user.username, step.course_key, client
+        )
+        total_completion += course_completion
+
+    total_courses = len(steps)
+
+    if total_courses == 0:
+        return 0.0
+
+    aggregate_progress = total_completion / total_courses
+    return aggregate_progress