learning-paths-plugin 0.3.3__tar.gz → 0.3.4rc1__tar.gz

{learning_paths_plugin-0.3.3 → learning_paths_plugin-0.3.4rc1}/CHANGELOG.rst

@@ -16,6 +16,14 @@ Unreleased
 
 *
 
+0.3.4 - 2025-05-23
+******************
+
+Added
+=====
+
+* Enrollment audit model that tracks the enrollment state transitions.
+
 0.3.3 - 2025-05-23
 ******************
 

{learning_paths_plugin-0.3.3/learning_paths_plugin.egg-info → learning_paths_plugin-0.3.4rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: learning-paths-plugin
-Version: 0.3.3
+Version: 0.3.4rc1
 Summary: Learning Paths plugin
 Home-page: https://github.com/open-craft/learning-paths-plugin
 Author: OpenCraft
@@ -18,7 +18,6 @@ Requires-Python: >=3.11
 License-File: LICENSE.txt
 Requires-Dist: Django
 Requires-Dist: django-model-utils
-Requires-Dist: django-simple-history==3.4.0
 Requires-Dist: djangorestframework
 Requires-Dist: edx-django-utils
 Requires-Dist: edx-opaque-keys
@@ -121,6 +120,14 @@ Unreleased
 
 *
 
+0.3.4 - 2025-05-23
+******************
+
+Added
+=====
+
+* Enrollment audit model that tracks the enrollment state transitions.
+
 0.3.3 - 2025-05-23
 ******************
 

{learning_paths_plugin-0.3.3 → learning_paths_plugin-0.3.4rc1}/learning_paths/__init__.py

@@ -2,4 +2,4 @@
 Learning Paths plugin.
 """
 
-__version__ = "0.3.3"
+__version__ = "0.3.4-rc1"

{learning_paths_plugin-0.3.3 → learning_paths_plugin-0.3.4rc1}/learning_paths/admin.py

@@ -13,6 +13,8 @@ from .models import (
     AcquiredSkill,
     LearningPath,
     LearningPathEnrollment,
+    LearningPathEnrollmentAllowed,
+    LearningPathEnrollmentAudit,
     LearningPathGradingCriteria,
     LearningPathStep,
     RequiredSkill,
@@ -182,12 +184,63 @@ class SkillAdmin(admin.ModelAdmin):
     model = Skill
 
 
+class LearningPathEnrollmentAuditInline(admin.TabularInline):
+    """Inline admin for LearningPathEnrollmentAudit records."""
+
+    model = LearningPathEnrollmentAudit
+    fk_name = "enrollment"
+    extra = 0
+    exclude = ["enrollment_allowed"]
+    readonly_fields = [
+        "state_transition",
+        "enrolled_by",
+        "reason",
+        "org",
+        "role",
+        "created",
+    ]
+
+    def has_add_permission(self, request, obj=None):
+        """Disable manual creation of audit records."""
+        return False
+
+    def has_delete_permission(self, request, obj=None):
+        """Disable deletion of audit records."""
+        return False
+
+
+class LearningPathEnrollmentAllowedAuditInline(admin.TabularInline):
+    """Inline admin for LearningPathEnrollmentAudit records related to enrollment allowed."""
+
+    model = LearningPathEnrollmentAudit
+    fk_name = "enrollment_allowed"
+    extra = 0
+    exclude = ["enrollment"]
+    readonly_fields = [
+        "state_transition",
+        "enrolled_by",
+        "reason",
+        "org",
+        "role",
+        "created",
+    ]
+
+    def has_add_permission(self, request, obj=None):
+        """Disable manual creation of audit records."""
+        return False
+
+    def has_delete_permission(self, request, obj=None):
+        """Disable deletion of audit records."""
+        return False
+
+
 class EnrolledUsersAdmin(admin.ModelAdmin):
     """Admin for Learning Path enrollment."""
 
     model = LearningPathEnrollment
     raw_id_fields = ("user",)
     autocomplete_fields = ["learning_path"]
+    inlines = [LearningPathEnrollmentAuditInline]
 
     search_fields = [
         "id",
@@ -197,6 +250,111 @@ class EnrolledUsersAdmin(admin.ModelAdmin):
     ]
 
 
+@admin.register(LearningPathEnrollmentAllowed)
+class LearningPathEnrollmentAllowedAdmin(admin.ModelAdmin):
+    """Admin configuration for LearningPathEnrollmentAllowed model."""
+
+    list_display = [
+        "id",
+        "email",
+        "get_user",
+        "learning_path",
+        "created",
+    ]
+
+    list_filter = [
+        "learning_path",
+        "user",
+        "created",
+    ]
+
+    search_fields = [
+        "email",
+        "user__username",
+        "user__email",
+        "learning_path__title",
+        "learning_path__key",
+    ]
+
+    readonly_fields = [
+        "user",
+        "created",
+        "modified",
+    ]
+
+    inlines = [LearningPathEnrollmentAllowedAuditInline]
+
+    def get_user(self, obj):
+        """Get the associated user, if any."""
+        return obj.user.username if obj.user else "-"
+
+    get_user.short_description = "User"
+
+
+@admin.register(LearningPathEnrollmentAudit)
+class LearningPathEnrollmentAuditAdmin(admin.ModelAdmin):
+    """Admin configuration for LearningPathEnrollmentAudit model."""
+
+    list_display = [
+        "id",
+        "state_transition",
+        "enrolled_by",
+        "get_enrollee",
+        "get_learning_path",
+        "created",
+        "org",
+        "role",
+    ]
+
+    list_filter = [
+        "state_transition",
+        "created",
+        "org",
+        "role",
+        "enrolled_by",
+    ]
+
+    search_fields = [
+        "enrolled_by__username",
+        "enrolled_by__email",
+        "enrollment__user__username",
+        "enrollment__user__email",
+        "enrollment_allowed__email",
+        "enrollment__learning_path__title",
+        "enrollment_allowed__learning_path__title",
+        "reason",
+    ]
+
+    readonly_fields = [
+        "enrollment",
+        "enrollment_allowed",
+        "enrolled_by",
+        "state_transition",
+        "created",
+        "modified",
+    ]
+
+    def get_enrollee(self, obj):
+        """Get the enrollee (user or email)."""
+        if obj.enrollment:
+            return obj.enrollment.user.username
+        elif obj.enrollment_allowed:
+            return obj.enrollment_allowed.user.username if obj.enrollment_allowed.user else obj.enrollment_allowed.email
+        return "-"
+
+    get_enrollee.short_description = "Enrollee"
+
+    def get_learning_path(self, obj):
+        """Get the learning path title."""
+        if obj.enrollment:
+            return obj.enrollment.learning_path.key
+        elif obj.enrollment_allowed:
+            return obj.enrollment_allowed.learning_path.key
+        return "-"
+
+    get_learning_path.short_description = "Learning Path"
+
+
 admin.site.register(LearningPath, LearningPathAdmin)
 admin.site.register(Skill, SkillAdmin)
 admin.site.register(LearningPathEnrollment, EnrolledUsersAdmin)

{learning_paths_plugin-0.3.3 → learning_paths_plugin-0.3.4rc1}/learning_paths/api/v1/views.py

@@ -33,6 +33,7 @@ from learning_paths.models import (
     LearningPath,
     LearningPathEnrollment,
     LearningPathEnrollmentAllowed,
+    LearningPathEnrollmentAudit,
 )
 
 from .filters import AdminOrSelfFilterBackend
@@ -329,6 +330,14 @@ class BulkEnrollView(APIView):
         learning_paths_keys = data.get("learning_paths", "").split(",")
         emails = data.get("emails", "").split(",")
 
+        audit_data = {
+            "enrolled_by": request.user,
+            "reason": data.get("reason", ""),
+            "org": data.get("org", ""),
+            "role": data.get("role", ""),
+            "state_transition": LearningPathEnrollmentAudit.DEFAULT_TRANSITION_STATE,
+        }
+
         valid_learning_paths_keys = []
         for key in learning_paths_keys:
             try:
@@ -351,16 +360,20 @@ class BulkEnrollView(APIView):
             for user in existing_users:
                 enrollment = LearningPathEnrollment.objects.filter(user=user, learning_path=learning_path).first()
                 enrolled_now = False
-                if not enrollment:
-                    enrollment = LearningPathEnrollment(
-                        user=user,
-                        learning_path=learning_path,
-                    )
-                    enrolled_now = True
-                if not enrollment.is_active:
-                    enrollment.is_active = True
-                    enrollment.enrolled_at = datetime.now(timezone.utc)
+                audit_data["state_transition"] = LearningPathEnrollmentAudit.UNENROLLED_TO_ENROLLED
+                if enrollment:
+                    if not enrollment.is_active:
+                        enrollment.is_active = True
+                        enrollment.enrolled_at = datetime.now(timezone.utc)
+                        enrolled_now = True
+                    else:
+                        audit_data["state_transition"] = LearningPathEnrollmentAudit.ENROLLED_TO_ENROLLED
+                else:
+                    enrollment = LearningPathEnrollment(user=user, learning_path=learning_path)
                     enrolled_now = True
+
+                # Set enrollment audit data that will be used by the post_save receiver.
+                enrollment._audit = audit_data  # pylint: disable=protected-access
                 enrollment.save()
                 if enrolled_now:
                     enrollments_created.append(enrollment)
@@ -378,6 +391,10 @@ class BulkEnrollView(APIView):
                 if created:
                     enrollment_allowed_created.append(allowed)
 
+                audit_data["state_transition"] = LearningPathEnrollmentAudit.UNENROLLED_TO_ALLOWEDTOENROLL
+                allowed._audit = audit_data  # pylint: disable=protected-access
+                allowed.save()
+
         return Response(
             {
                 "enrollments_created": len(enrollments_created),

learning_paths_plugin-0.3.4rc1/learning_paths/conftest.py

@@ -0,0 +1,51 @@
+"""Pytest fixtures."""
+
+# pylint: disable=redefined-outer-name
+
+import pytest
+from django.test import override_settings
+
+from learning_paths.tests.factories import (
+    LearningPathEnrollmentFactory,
+    LearningPathFactory,
+    UserFactory,
+)
+
+
+@pytest.fixture
+def user():
+    """Create a single user for testing."""
+    return UserFactory()
+
+
+@pytest.fixture
+def learning_path():
+    """Create a single learning path for testing."""
+    return LearningPathFactory(invite_only=False)
+
+
+@pytest.fixture
+def learning_path_with_invite_only():
+    """Create a learning path that is invite-only."""
+    return LearningPathFactory()
+
+
+@pytest.fixture
+def active_enrollment(user, learning_path):
+    """Create an active enrollment for the user in the learning path."""
+    return LearningPathEnrollmentFactory(user=user, learning_path=learning_path, is_active=True)
+
+
+@pytest.fixture
+def inactive_enrollment(user, learning_path):
+    """Create an inactive enrollment for the user in the learning path."""
+    return LearningPathEnrollmentFactory(user=user, learning_path=learning_path, is_active=False)
+
+
+@pytest.fixture
+def temp_media(tmpdir):
+    """Temporarily override MEDIA_ROOT to a pytest tmpdir."""
+    temp_dir = str(tmpdir.mkdir("media"))
+
+    with override_settings(MEDIA_ROOT=temp_dir):
+        yield temp_dir

learning_paths_plugin-0.3.4rc1/learning_paths/migrations/0006_enrollment_models.py

@@ -0,0 +1,39 @@
+# Generated by Django 4.2.16 on 2025-03-28 09:54
+
+from django.conf import settings
+from django.db import migrations, models
+import django.utils.timezone
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('learning_paths', '0005_learningpathstep_weight_learningpathgradingcriteria'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='learningpathenrollment',
+            name='enrolled_at',
+            field=models.DateTimeField(auto_now_add=True, default=django.utils.timezone.now, help_text='Timestamp of enrollment or un-enrollment. To be explicitly set when performing a learner enrollment.'),
+            preserve_default=False,
+        ),
+        migrations.AddField(
+            model_name='learningpathenrollment',
+            name='is_active',
+            field=models.BooleanField(default=True, help_text='Indicates if the learner is enrolled or not in the Learning Path'),
+        ),
+        migrations.CreateModel(
+            name='LearningPathEnrollmentAllowed',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('email', models.EmailField(max_length=254)),
+                ('learning_path', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='learning_paths.learningpath')),
+                ('user', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'unique_together': {('email', 'learning_path')},
+            },
+        ),
+    ]

learning_paths_plugin-0.3.4rc1/learning_paths/migrations/0013_enrollment_audit.py

@@ -0,0 +1,158 @@
+# Generated by Django 4.2.20 on 2025-05-26 16:31
+
+from django.conf import settings
+from django.db import migrations, models
+import django.utils.timezone
+import model_utils.fields
+
+
+def delete_historical_model_if_exists(apps, schema_editor):
+    """Delete HistoricalLearningPathEnrollment model if it exists."""
+    try:
+        HistoricalLearningPathEnrollment = apps.get_model(
+            "learning_paths", "HistoricalLearningPathEnrollment"
+        )
+        schema_editor.delete_model(HistoricalLearningPathEnrollment)
+    except LookupError:
+        # Model doesn't exist in Django's registry, skip deletion
+        pass
+
+
+def reverse_delete_historical_model(apps, schema_editor):
+    """Reverse operation - this is a no-op since we cannot recreate the model."""
+    pass
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ("learning_paths", "0012_alter_learningpath_subtitle"),
+    ]
+
+    operations = [
+        migrations.RunPython(
+            delete_historical_model_if_exists, reverse_delete_historical_model
+        ),
+        migrations.AddField(
+            model_name="learningpathenrollmentallowed",
+            name="created",
+            field=model_utils.fields.AutoCreatedField(
+                default=django.utils.timezone.now,
+                editable=False,
+                verbose_name="created",
+            ),
+        ),
+        migrations.AddField(
+            model_name="learningpathenrollmentallowed",
+            name="modified",
+            field=model_utils.fields.AutoLastModifiedField(
+                default=django.utils.timezone.now,
+                editable=False,
+                verbose_name="modified",
+            ),
+        ),
+        migrations.AlterField(
+            model_name="learningpathenrollmentallowed",
+            name="email",
+            field=models.EmailField(db_index=True, max_length=254),
+        ),
+        migrations.CreateModel(
+            name="LearningPathEnrollmentAudit",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "created",
+                    model_utils.fields.AutoCreatedField(
+                        default=django.utils.timezone.now,
+                        editable=False,
+                        verbose_name="created",
+                    ),
+                ),
+                (
+                    "modified",
+                    model_utils.fields.AutoLastModifiedField(
+                        default=django.utils.timezone.now,
+                        editable=False,
+                        verbose_name="modified",
+                    ),
+                ),
+                (
+                    "state_transition",
+                    models.CharField(
+                        choices=[
+                            (
+                                "from unenrolled to allowed to enroll",
+                                "from unenrolled to allowed to enroll",
+                            ),
+                            (
+                                "from allowed to enroll to enrolled",
+                                "from allowed to enroll to enrolled",
+                            ),
+                            ("from enrolled to enrolled", "from enrolled to enrolled"),
+                            (
+                                "from enrolled to unenrolled",
+                                "from enrolled to unenrolled",
+                            ),
+                            (
+                                "from unenrolled to enrolled",
+                                "from unenrolled to enrolled",
+                            ),
+                            (
+                                "from allowed to enroll to unenrolled",
+                                "from allowed to enroll to unenrolled",
+                            ),
+                            (
+                                "from unenrolled to unenrolled",
+                                "from unenrolled to unenrolled",
+                            ),
+                            ("N/A", "N/A"),
+                        ],
+                        default="N/A",
+                        max_length=255,
+                    ),
+                ),
+                ("reason", models.TextField(blank=True)),
+                ("org", models.CharField(blank=True, db_index=True, max_length=255)),
+                ("role", models.CharField(blank=True, max_length=255)),
+                (
+                    "enrolled_by",
+                    models.ForeignKey(
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="learning_path_audit",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+                (
+                    "enrollment",
+                    models.ForeignKey(
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="audit",
+                        to="learning_paths.learningpathenrollment",
+                    ),
+                ),
+                (
+                    "enrollment_allowed",
+                    models.ForeignKey(
+                        null=True,
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="audit",
+                        to="learning_paths.learningpathenrollmentallowed",
+                    ),
+                ),
+            ],
+            options={
+                "abstract": False,
+            },
+        ),
+    ]

{learning_paths_plugin-0.3.3 → learning_paths_plugin-0.3.4rc1}/learning_paths/models.py

@@ -17,7 +17,6 @@ from django.utils.translation import gettext_lazy as _
 from model_utils import FieldTracker
 from model_utils.models import TimeStampedModel
 from opaque_keys.edx.django.models import CourseKeyField
-from simple_history.models import HistoricalRecords
 from slugify import slugify
 
 from .compat import get_course_due_date, get_user_course_grade
@@ -296,8 +295,7 @@ class LearningPathEnrollment(TimeStampedModel):
             "Timestamp of enrollment or un-enrollment. To be explicitly set when performing a learner enrollment."
         ),
     )
-
-    history = HistoricalRecords()
+    tracker = FieldTracker(fields=["is_active"])
 
     def __str__(self):
         """User-friendly string representation of this model."""
@@ -354,7 +352,7 @@ class LearningPathGradingCriteria(models.Model):
         return weighted_sum / total_weight if total_weight > 0 else 0.0
 
 
-class LearningPathEnrollmentAllowed(models.Model):
+class LearningPathEnrollmentAllowed(TimeStampedModel):
     """
     Represents an allowed enrollment in a learning path for a user email.
 
@@ -371,10 +369,63 @@ class LearningPathEnrollmentAllowed(models.Model):
 
         unique_together = ("email", "learning_path")
 
-    email = models.EmailField()
+    email = models.EmailField(db_index=True)
     learning_path = models.ForeignKey(LearningPath, on_delete=models.CASCADE)
     user = models.ForeignKey(User, on_delete=models.CASCADE, blank=True, null=True)
 
     def __str__(self):
         """User-friendly string representation of this model."""
-        return f"LearningPathEnrollmentAllowed for {self.user.username} in {self.learning_path.display_name}"
+        return f"LearningPathEnrollmentAllowed for {self.email} in {self.learning_path.key}"
+
+
+class LearningPathEnrollmentAudit(TimeStampedModel):
+    """
+    Audit model for tracking changes to learning path enrollments.
+
+    .. no_pii:
+    """
+
+    # State transition constants (copied from edx-platform to maintain consistency)
+    UNENROLLED_TO_ALLOWEDTOENROLL = "from unenrolled to allowed to enroll"
+    ALLOWEDTOENROLL_TO_ENROLLED = "from allowed to enroll to enrolled"
+    ENROLLED_TO_ENROLLED = "from enrolled to enrolled"
+    ENROLLED_TO_UNENROLLED = "from enrolled to unenrolled"
+    UNENROLLED_TO_ENROLLED = "from unenrolled to enrolled"
+    ALLOWEDTOENROLL_TO_UNENROLLED = "from allowed to enroll to unenrolled"
+    UNENROLLED_TO_UNENROLLED = "from unenrolled to unenrolled"
+    DEFAULT_TRANSITION_STATE = "N/A"
+
+    TRANSITION_STATES = (
+        (UNENROLLED_TO_ALLOWEDTOENROLL, UNENROLLED_TO_ALLOWEDTOENROLL),
+        (ALLOWEDTOENROLL_TO_ENROLLED, ALLOWEDTOENROLL_TO_ENROLLED),
+        (ENROLLED_TO_ENROLLED, ENROLLED_TO_ENROLLED),
+        (ENROLLED_TO_UNENROLLED, ENROLLED_TO_UNENROLLED),
+        (UNENROLLED_TO_ENROLLED, UNENROLLED_TO_ENROLLED),
+        (ALLOWEDTOENROLL_TO_UNENROLLED, ALLOWEDTOENROLL_TO_UNENROLLED),
+        (UNENROLLED_TO_UNENROLLED, UNENROLLED_TO_UNENROLLED),
+        (DEFAULT_TRANSITION_STATE, DEFAULT_TRANSITION_STATE),
+    )
+
+    enrolled_by = models.ForeignKey(User, on_delete=models.CASCADE, null=True, related_name="learning_path_audit")
+    enrollment = models.ForeignKey(LearningPathEnrollment, on_delete=models.CASCADE, null=True, related_name="audit")
+    enrollment_allowed = models.ForeignKey(
+        LearningPathEnrollmentAllowed, on_delete=models.CASCADE, null=True, related_name="audit"
+    )
+    state_transition = models.CharField(max_length=255, choices=TRANSITION_STATES, default=DEFAULT_TRANSITION_STATE)
+    reason = models.TextField(blank=True)
+    org = models.CharField(max_length=255, blank=True, db_index=True)
+    role = models.CharField(max_length=255, blank=True)
+
+    def __str__(self):
+        """User-friendly string representation of this model."""
+        enrollee = "unknown"
+        learning_path = "unknown"
+
+        if self.enrollment:
+            enrollee = self.enrollment.user
+            learning_path = self.enrollment.learning_path.key
+        elif self.enrollment_allowed:
+            enrollee = self.enrollment_allowed.user or self.enrollment_allowed.email
+            learning_path = self.enrollment_allowed.learning_path.key
+
+        return f"{self.state_transition} for {enrollee} in {learning_path}"

learning_paths_plugin-0.3.4rc1/learning_paths/receivers.py

@@ -0,0 +1,127 @@
+"""Django signal handler for learning paths plugin."""
+
+# pylint: disable=unused-argument
+
+import logging
+
+from django.db import IntegrityError
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+
+from learning_paths.models import (
+    LearningPathEnrollment,
+    LearningPathEnrollmentAllowed,
+    LearningPathEnrollmentAudit,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def process_pending_enrollments(sender, instance, created, **kwargs):
+    """
+    Process pending enrollments after a user instance has been created.
+
+    Bulk enrollment API allows enrolling users with just the email. So learners who
+    do not have an account yet would also be enrolled. This information is stored
+    in the LearningPathEnrollmentAllowed model. This signal handler processes such
+    instances and created the corresponding LearningPathEnrollment objects.
+
+    Args:
+        sender: User model class.
+        instance: The actual instance being saved.
+        created: A boolean indicating whether this is a creation and not an update.
+    """
+    if not created:
+        logger.debug(
+            "[LearningPaths] Skipping processing of pending enrollments for user %s.",
+            instance,
+        )
+        return
+
+    logger.info("[LearningPaths] Processing pending enrollments for user %s", instance)
+    pending_enrollments = LearningPathEnrollmentAllowed.objects.filter(email=instance.email)
+    enrollments_created = 0
+
+    for entry in pending_enrollments:
+        try:
+            enrollment = LearningPathEnrollment(learning_path=entry.learning_path, user=instance)
+            enrollment._audit = {  # pylint: disable=protected-access
+                "enrolled_by": instance,
+                "state_transition": LearningPathEnrollmentAudit.ALLOWEDTOENROLL_TO_ENROLLED,
+            }
+            enrollment.save()
+            enrollments_created += 1
+        except IntegrityError:  # pragma: no cover
+            logger.info(
+                "[LearningPaths] Enrollment already exists for user %s in learning path %s",
+                instance,
+                entry.learning_path.key,
+            )
+        finally:
+            entry.user = instance
+            entry.save()
+
+    logger.info(
+        "[LearningPaths] Processed %d pending Learning Path enrollments for user %s.",
+        enrollments_created,
+        instance,
+    )
+
+
+def _create_enrollment_audit(instance: LearningPathEnrollment | LearningPathEnrollmentAllowed, audit_data: dict):
+    """Create an audit record for the given instance with the provided audit data."""
+    # If a previous audit exists, copy over missing fields
+    previous_audit = instance.audit.order_by("-created").first()
+    if previous_audit:
+        for field in ["reason", "org", "role"]:
+            if not audit_data.get(field):
+                audit_data[field] = getattr(previous_audit, field)
+
+    instance.audit.create(
+        state_transition=audit_data.get("state_transition"),
+        enrolled_by=audit_data.get("enrolled_by"),
+        reason=audit_data.get("reason", ""),
+        org=audit_data.get("org", ""),
+        role=audit_data.get("role", ""),
+    )
+
+
+@receiver(post_save, sender=LearningPathEnrollment)
+def create_enrollment_audit(sender, instance, created, **kwargs):
+    """Create audit records when LearningPathEnrollment is saved."""
+    audit_data = getattr(instance, "_audit", {})
+
+    # Determine state transition if not provided
+    if "state_transition" not in audit_data:
+        if created:
+            audit_data["state_transition"] = LearningPathEnrollmentAudit.UNENROLLED_TO_ENROLLED
+        elif instance.is_active and not instance.tracker.previous("is_active"):
+            audit_data["state_transition"] = LearningPathEnrollmentAudit.UNENROLLED_TO_ENROLLED
+        elif not instance.is_active and instance.tracker.previous("is_active"):
+            audit_data["state_transition"] = LearningPathEnrollmentAudit.ENROLLED_TO_UNENROLLED
+        elif instance.is_active and instance.tracker.previous("is_active"):
+            audit_data["state_transition"] = LearningPathEnrollmentAudit.ENROLLED_TO_ENROLLED
+        elif not instance.is_active and not instance.tracker.previous("is_active"):
+            audit_data["state_transition"] = LearningPathEnrollmentAudit.UNENROLLED_TO_UNENROLLED
+        else:  # pragma: no cover
+            # No relevant state change. This should not happen.
+            audit_data["state_transition"] = LearningPathEnrollmentAudit.DEFAULT_TRANSITION_STATE
+
+    _create_enrollment_audit(instance, audit_data)
+
+
+@receiver(post_save, sender=LearningPathEnrollmentAllowed)
+def create_enrollment_allowed_audit(sender, instance, created, **kwargs):
+    """Create audit records when LearningPathEnrollmentAllowed is saved."""
+    # The audit data can be missing in the following scenarios:
+    # 1. The instance is created with `get_or_create`, so we want to provide this data later.
+    # 2. The instance is updated when the user creates an account. In this case, the audit record is already created for
+    #    the enrollment record, so we do not need to create it here.
+    if not (audit_data := getattr(instance, "_audit", {})):
+        return
+
+    audit_data["state_transition"] = audit_data.get(
+        "state_transition", LearningPathEnrollmentAudit.UNENROLLED_TO_ALLOWEDTOENROLL
+    )
+
+    _create_enrollment_audit(instance, audit_data)

{learning_paths_plugin-0.3.3 → learning_paths_plugin-0.3.4rc1/learning_paths_plugin.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: learning-paths-plugin
-Version: 0.3.3
+Version: 0.3.4rc1
 Summary: Learning Paths plugin
 Home-page: https://github.com/open-craft/learning-paths-plugin
 Author: OpenCraft
@@ -18,7 +18,6 @@ Requires-Python: >=3.11
 License-File: LICENSE.txt
 Requires-Dist: Django
 Requires-Dist: django-model-utils
-Requires-Dist: django-simple-history==3.4.0
 Requires-Dist: djangorestframework
 Requires-Dist: edx-django-utils
 Requires-Dist: edx-opaque-keys
@@ -121,6 +120,14 @@ Unreleased
 
 *
 
+0.3.4 - 2025-05-23
+******************
+
+Added
+=====
+
+* Enrollment audit model that tracks the enrollment state transitions.
+
 0.3.3 - 2025-05-23
 ******************
 

{learning_paths_plugin-0.3.3 → learning_paths_plugin-0.3.4rc1}/learning_paths_plugin.egg-info/SOURCES.txt

@@ -36,6 +36,7 @@ learning_paths/migrations/0009_remove_learningpath_slug.py
 learning_paths/migrations/0010_learningpath_invite_only.py
 learning_paths/migrations/0011_replace_learningpath_image_url_with_image.py
 learning_paths/migrations/0012_alter_learningpath_subtitle.py
+learning_paths/migrations/0013_enrollment_audit.py
 learning_paths/migrations/__init__.py
 learning_paths/templates/learning_paths/base.html
 learning_paths_plugin.egg-info/PKG-INFO

{learning_paths_plugin-0.3.3 → learning_paths_plugin-0.3.4rc1}/learning_paths_plugin.egg-info/requires.txt

@@ -1,6 +1,5 @@
 Django
 django-model-utils
-django-simple-history==3.4.0
 djangorestframework
 edx-django-utils
 edx-opaque-keys

{learning_paths_plugin-0.3.3 → learning_paths_plugin-0.3.4rc1}/requirements/base.in

@@ -9,5 +9,4 @@ edx-django-utils
 edx-opaque-keys
 openedx-atlas
 openedx-completion-aggregator  # Required for fetching course completion
-django-simple-history
 pillow                         # Required for the ImageField

{learning_paths_plugin-0.3.3 → learning_paths_plugin-0.3.4rc1}/requirements/constraints.txt

@@ -9,9 +9,4 @@
 # linking to it here is good.
 
 # Common constraints for edx repos
--c common_constraints.txt
-
-# django-simple-history has been pinned on the edx-platform to version 3.4.0
-# since the platform was updated to Django 4.2
-# Ref: https://github.com/openedx/edx-platform/commit/e40a01c7ccfcc853e5be8cc25bdaa0d14248a270#diff-86d5fe588ff2fc7dccb1f4cdd8019d4473146536e88d7a9ede946ea962a91acb
-django-simple-history==3.4.0
+-c https://raw.githubusercontent.com/edx/edx-lint/master/edx_lint/files/common_constraints.txt

learning_paths_plugin-0.3.3/learning_paths/conftest.py

@@ -1,13 +0,0 @@
-"""Pytest fixtures."""
-
-import pytest
-from django.test import override_settings
-
-
-@pytest.fixture
-def temp_media(tmpdir):
-    """Temporarily override MEDIA_ROOT to a pytest tmpdir."""
-    temp_dir = str(tmpdir.mkdir("media"))
-
-    with override_settings(MEDIA_ROOT=temp_dir):
-        yield temp_dir

learning_paths_plugin-0.3.3/learning_paths/migrations/0006_enrollment_models.py

@@ -1,66 +0,0 @@
-# Generated by Django 4.2.16 on 2025-03-28 09:54
-
-from django.conf import settings
-from django.db import migrations, models
-import django.db.models.deletion
-import django.utils.timezone
-import model_utils.fields
-import simple_history.models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
-        ('learning_paths', '0005_learningpathstep_weight_learningpathgradingcriteria'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='learningpathenrollment',
-            name='enrolled_at',
-            field=models.DateTimeField(auto_now_add=True, default=django.utils.timezone.now, help_text='Timestamp of enrollment or un-enrollment. To be explicitly set when performing a learner enrollment.'),
-            preserve_default=False,
-        ),
-        migrations.AddField(
-            model_name='learningpathenrollment',
-            name='is_active',
-            field=models.BooleanField(default=True, help_text='Indicates if the learner is enrolled or not in the Learning Path'),
-        ),
-        migrations.CreateModel(
-            name='HistoricalLearningPathEnrollment',
-            fields=[
-                ('id', models.IntegerField(auto_created=True, blank=True, db_index=True, verbose_name='ID')),
-                ('created', model_utils.fields.AutoCreatedField(default=django.utils.timezone.now, editable=False, verbose_name='created')),
-                ('modified', model_utils.fields.AutoLastModifiedField(default=django.utils.timezone.now, editable=False, verbose_name='modified')),
-                ('is_active', models.BooleanField(default=True, help_text='Indicates if the learner is enrolled or not in the Learning Path')),
-                ('enrolled_at', models.DateTimeField(blank=True, editable=False, help_text='Timestamp of enrollment or un-enrollment. To be explicitly set when performing a learner enrollment.')),
-                ('history_id', models.AutoField(primary_key=True, serialize=False)),
-                ('history_date', models.DateTimeField(db_index=True)),
-                ('history_change_reason', models.CharField(max_length=100, null=True)),
-                ('history_type', models.CharField(choices=[('+', 'Created'), ('~', 'Changed'), ('-', 'Deleted')], max_length=1)),
-                ('history_user', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='+', to=settings.AUTH_USER_MODEL)),
-                ('learning_path', models.ForeignKey(blank=True, db_constraint=False, null=True, on_delete=django.db.models.deletion.DO_NOTHING, related_name='+', to='learning_paths.learningpath')),
-                ('user', models.ForeignKey(blank=True, db_constraint=False, null=True, on_delete=django.db.models.deletion.DO_NOTHING, related_name='+', to=settings.AUTH_USER_MODEL)),
-            ],
-            options={
-                'verbose_name': 'historical learning path enrollment',
-                'verbose_name_plural': 'historical learning path enrollments',
-                'ordering': ('-history_date', '-history_id'),
-                'get_latest_by': ('history_date', 'history_id'),
-            },
-            bases=(simple_history.models.HistoricalChanges, models.Model),
-        ),
-        migrations.CreateModel(
-            name='LearningPathEnrollmentAllowed',
-            fields=[
-                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('email', models.EmailField(max_length=254)),
-                ('learning_path', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='learning_paths.learningpath')),
-                ('user', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
-            ],
-            options={
-                'unique_together': {('email', 'learning_path')},
-            },
-        ),
-    ]

learning_paths_plugin-0.3.3/learning_paths/receivers.py

@@ -1,46 +0,0 @@
-"""Django signal handler for learning paths plugin."""
-
-import logging
-
-from learning_paths.models import LearningPathEnrollment, LearningPathEnrollmentAllowed
-
-logger = logging.getLogger(__name__)
-
-
-def process_pending_enrollments(sender, instance, created, **kwargs):  # pylint: disable=unused-argument
-    """
-    Process pending enrollments after a user instance has been created.
-
-    Bulk enrollment API allows enrolling users with just the email. So learners who
-    do not have an account yet would also be enrolled. This information is stored
-    in the LearningPathEnrollmentAllowed model. This signal handler processes such
-    instances and created the corresponding LearningPathEnrollment objects.
-
-    Args:
-        sender: User model class.
-        instance: The actual instance being saved.
-        created: A boolean indicating whether this is a creation and not an update.
-    """
-    if not created:
-        logger.debug(
-            "[LearningPaths] Skipping processing of pending enrollments for user %s.",
-            instance,
-        )
-        return
-
-    logger.info("[LearningPaths] Processing pending enrollments for user %s", instance)
-    pending_enrollments = LearningPathEnrollmentAllowed.objects.filter(email=instance.email).all()
-
-    enrollments = []
-
-    for entry in pending_enrollments:
-        entry.user = instance
-        entry.save()
-
-        enrollments.append(LearningPathEnrollment(learning_path=entry.learning_path, user=instance))
-    new_enrollments = LearningPathEnrollment.objects.bulk_create(enrollments)
-    logger.info(
-        "[LearningPaths] Processed %d pending Learning Path enrollments for user %s.",
-        instance,
-        len(new_enrollments),
-    )