feat: add ol-openedx-course-propagator

Author: asadali145

src/ol_openedx_course_sync/BUILD

@@ -0,0 +1,26 @@
+python_sources(
+    name="ol_openedx_course_sync_source",
+    dependencies=[
+        "src/ol_openedx_course_sync/migrations:ol_openedx_course_sync_migrations",
+        "//:external_dependencies#edx-opaque-keys",
+        "//:external_dependencies#celery",
+    ],
+)
+
+python_distribution(
+    name="ol_openedx_course_sync_package",
+    dependencies=[":ol_openedx_course_sync_source"],
+    provides=setup_py(
+        name="ol-openedx-course-sync",
+        version="0.1.0",
+        description="An edX plugin to sync changes in a course to its target/child/rerun courses",
+        license="BSD-3-Clause",
+        author="MIT Office of Digital Learning",
+        entry_points={
+            "lms.djangoapp": [],
+            "cms.djangoapp": [
+                "ol_openedx_course_sync=ol_openedx_course_sync.apps:OLOpenEdxCourseSyncConfig",
+            ],
+        },
+    ),
+)

src/ol_openedx_course_sync/LICENCE.txt

@@ -0,0 +1,28 @@
+Copyright (C) 2025  MIT Open Learning
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

src/ol_openedx_course_sync/README.rst

@@ -0,0 +1,30 @@
+OL Open edX Course Sync
+=======================
+
+A plugin to enable course updates to sync with the target/child/rerun courses.
+
+Version Compatibility
+---------------------
+
+It only supports the latest releases of Open edX.
+
+Installing The Plugin
+---------------------
+
+For detailed installation instructions, please refer to the `plugin installation guide <../../docs#installation-guide>`_.
+
+Installation required in:
+
+* CMS
+
+Usage
+-----
+
+1. Install the plugin and run the migrations in the CMS.
+2. Add the parent/source organization in the CMS admin model `CourseSyncParentOrg`.
+  #. Course sync will only work for this organization. It will treat all the courses under this organization as parent/source courses.
+3. The plugin will automatically add course reruns created from the CMS as the target/child courses for any of the parent courses from the organization added above.
+  #. The organization can be different for the reruns.
+4. Target/child/rerun courses can be managed in the CMS admin model `CourseSyncMap`.
+  #. You can update the comma-separated target course list.
+5. Now, any changes made in the parent/source course will be synced to the target/child/rerun courses.

src/ol_openedx_course_sync/__init__.py

@@ -0,0 +1,5 @@
+"""
+ol-openedx-course-sync plugin
+"""
+
+default_app_config = "ol_openedx_course_sync.apps.OLOpenEdxCourseSyncConfig"

src/ol_openedx_course_sync/admin.py

@@ -0,0 +1,19 @@
+"""
+Django admin for ol-openedx-course-sync plugin
+"""
+
+from django.contrib import admin
+from ol_openedx_course_sync.models import CourseSyncMap, CourseSyncParentOrg
+
+
+class CourseSyncParentOrgAdmin(admin.ModelAdmin):
+    list_display = ("organization",)
+
+
+class CourseSyncMapAdmin(admin.ModelAdmin):
+    list_display = ("source_course", "target_courses")
+    search_fields = ("source_course", "target_courses")
+
+
+admin.site.register(CourseSyncParentOrg, CourseSyncParentOrgAdmin)
+admin.site.register(CourseSyncMap, CourseSyncMapAdmin)

src/ol_openedx_course_sync/apps.py

@@ -0,0 +1,26 @@
+"""
+App configuration for ol-openedx-course-sync plugin
+"""
+
+from django.apps import AppConfig
+from edx_django_utils.plugins import PluginSignals
+from openedx.core.djangoapps.plugins.constants import ProjectType
+
+
+class OLOpenEdxCourseSyncConfig(AppConfig):
+    name = "ol_openedx_course_sync"
+    verbose_name = "Open edX Course Sync"
+
+    plugin_app = {
+        PluginSignals.CONFIG: {
+            ProjectType.CMS: {
+                PluginSignals.RECEIVERS: [
+                    {
+                        PluginSignals.RECEIVER_FUNC_NAME: "listen_for_course_publish",
+                        PluginSignals.SIGNAL_PATH: "xmodule.modulestore.django.COURSE_PUBLISHED",  # noqa: E501
+                        PluginSignals.DISPATCH_UID: "ol_openedx_course_sync.signals.listen_for_course_publish",  # noqa: E501
+                    }
+                ],
+            },
+        },
+    }

src/ol_openedx_course_sync/constants.py

@@ -0,0 +1,5 @@
+"""
+Constants for ol-openedx-course-sync plugin
+"""
+
+COURSE_RERUN_STATE_SUCCEEDED = "succeeded"

src/ol_openedx_course_sync/migrations/0001_initial.py

@@ -0,0 +1,55 @@
+# Generated by Django 4.2.20 on 2025-05-14 09:11
+
+import opaque_keys.edx.django.models
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = []  # type: ignore[var-annotated]
+
+    operations = [
+        migrations.CreateModel(
+            name="CourseSyncMap",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "source_course",
+                    opaque_keys.edx.django.models.CourseKeyField(
+                        max_length=255, unique=True
+                    ),
+                ),
+                (
+                    "target_courses",
+                    models.TextField(
+                        blank=True,
+                        help_text="Comma separated list of target course keys",
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="CourseSyncParentOrg",
+            fields=[
+                (
+                    "id",
+                    models.AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("organization", models.CharField(max_length=255, unique=True)),
+            ],
+        ),
+    ]

src/ol_openedx_course_sync/migrations/BUILD

@@ -0,0 +1 @@
+python_sources(name="ol_openedx_course_sync_migrations")

src/ol_openedx_course_sync/migrations/__init__.py

@@ -0,0 +1,102 @@
+"""
+Models for ol-openedx-course-sync plugin
+"""
+
+from django.core.exceptions import ValidationError
+from django.db import models
+from opaque_keys.edx.django.models import (
+    CourseKeyField,
+)
+
+
+class CourseSyncParentOrg(models.Model):
+    """
+    Model for source course organizations
+
+    Any source course that is part of this organization
+    will sync changes with the child/rerun courses. This model
+    will help us exclude any organizations, where we don't
+    want to sync source course.
+    """
+
+    organization = models.CharField(max_length=255, unique=True)
+
+    def __str__(self):
+        return f"{self.organization} Course Sync Parent Org"
+
+
+class CourseSyncMap(models.Model):
+    """
+    Model to keep track of source and target courses.
+
+    Any changes in the source course sync with the target courses.
+    Target courses are autopopulated for all the reruns of source
+    courses that are part of any organization added in `CourseSyncParentOrg`.
+    """
+
+    source_course = CourseKeyField(max_length=255, unique=True)
+    target_courses = models.TextField(
+        blank=True, help_text="Comma separated list of target course keys"
+    )
+
+    def __str__(self):
+        return f"{self.source_course} Course Sync Map"
+
+    def save(self, *args, **kwargs):
+        """
+        Override save method to perform custom validations.
+        """
+        self.full_clean()
+        super().save(*args, **kwargs)
+
+    def clean(self):
+        """
+        Override clean method to perform custom validations.
+        """
+        super().clean()
+
+        conflicting_targets = CourseSyncMap.objects.filter(
+            target_courses__contains=self.source_course
+        )
+        if conflicting_targets:
+            raise ValidationError(
+                {
+                    "source_course": f"This course is already used as target course of: "  # noqa: E501
+                    f"{', '.join(str(ct.source_course) for ct in conflicting_targets)}"
+                }
+            )
+
+        conflicting_sources = CourseSyncMap.objects.filter(
+            source_course__in=self.target_course_keys
+        )
+        if conflicting_sources:
+            raise ValidationError(
+                {
+                    "target_courses": f"These course(s) are already used as source courses: "  # noqa:E501
+                    f"{', '.join(str(cs.source_course) for cs in conflicting_sources)}"
+                }
+            )
+
+        if self.target_course_keys:
+            query = models.Q()
+            for key in self.target_course_keys:
+                query |= models.Q(**{"target_courses__contains": key})
+            duplicate_targets = CourseSyncMap.objects.filter(query)
+
+            if self.pk:
+                duplicate_targets = duplicate_targets.exclude(pk=self.pk)
+
+            if duplicate_targets:
+                raise ValidationError(
+                    {
+                        "target_courses": f"Some of these course(s) are already used as target course(s) for: "  # noqa:E501
+                        f"{', '.join(str(dt.source_course) for dt in duplicate_targets)}"  # noqa:E501
+                    }
+                )
+
+    @property
+    def target_course_keys(self):
+        """
+        Returns a list of target course keys.
+        """
+        return [key for key in self.target_courses.strip().split(",") if key]

src/ol_openedx_course_sync/models.py

@@ -0,0 +1,91 @@
+"""
+Signal handlers for ol-openedx-course-sync plugin
+"""
+
+import logging
+
+from common.djangoapps.course_action_state.models import CourseRerunState
+from django.core.exceptions import ValidationError
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+from ol_openedx_course_sync.constants import COURSE_RERUN_STATE_SUCCEEDED
+from ol_openedx_course_sync.models import CourseSyncMap, CourseSyncParentOrg
+from ol_openedx_course_sync.tasks import async_course_sync
+from xmodule.modulestore.django import SignalHandler
+
+log = logging.getLogger(__name__)
+
+
+@receiver(SignalHandler.course_published)
+def listen_for_course_publish(
+    sender,  # noqa: ARG001
+    course_key,
+    **kwargs,  # noqa: ARG001
+):
+    """
+    Listen for course publish signal and trigger course sync task
+    """
+    if not CourseSyncParentOrg.objects.filter(organization=course_key.org).exists():
+        return
+
+    course_sync_map = CourseSyncMap.objects.filter(source_course=course_key).first()
+    if not (course_sync_map and course_sync_map.target_courses):
+        log.info("No mapping found for course %s. Skipping copy.", str(course_key))
+        return
+
+    source_course = str(course_sync_map.source_course)
+    user_id = None
+    target_keys = [
+        key for key in course_sync_map.target_courses.strip().split(",") if key
+    ]
+    for target_course_key in target_keys:
+        log.info(
+            "Initializing async course content sync from %s to %s",
+            source_course,
+            target_course_key,
+        )
+        # Call the async task to copy the course content
+        async_course_sync.delay(user_id, source_course, target_course_key)
+
+
+@receiver(post_save, sender=CourseRerunState)
+def listen_for_course_rerun_state_post_save(sender, instance, **kwargs):  # noqa: ARG001
+    """
+    Listen for `CourseRerunState` post_save and update target courses in `CourseSyncMap`
+    """
+    if instance.state != COURSE_RERUN_STATE_SUCCEEDED:
+        return
+
+    if not CourseSyncParentOrg.objects.filter(
+        organization=instance.source_course_key.org
+    ).exists():
+        return
+
+    try:
+        course_sync_map, _ = CourseSyncMap.objects.get_or_create(
+            source_course=instance.source_course_key
+        )
+    except ValidationError:
+        log.exception(
+            "Failed to create CourseSyncMap for %s",
+            instance.source_course_key,
+        )
+        return
+
+    target_courses = course_sync_map.target_course_keys
+    target_courses.append(str(instance.course_key))
+    course_sync_map.target_courses = ",".join(target_courses)
+
+    try:
+        course_sync_map.save()
+    except ValidationError:
+        log.exception(
+            "Failed to update CourseSyncMap for %s",
+            instance.source_course_key,
+        )
+    else:
+        log.info(
+            "Added course %s to target courses for %s",
+            instance.course_key,
+            instance.source_course_key,
+        )