feat: add Canvas due date sync functionality

Introduce new functionality for syncing Canvas assignment due dates with Open edX. This includes:
- A management command (`sync_canvas_due_dates`) for syncing due dates across courses.
- New Celery task `_sync_canvas_due_dates` to update due dates on Open edX from Canvas.
- New test suite (`CanvasDueDateSyncTests`) to verify due date syncing logic.
- Adjustments to `run_edx_integration_tests.sh` to include `ol_openedx_canvas_integration` tests.
- Extended `CanvasClient` to fetch `due_at` data for assignments.

Added pytest configuration for warning filters to reduce unnecessary warnings.
Previous tests for the canvas integration were not running since the integration script only runs tests in the tests folder so the tests were moved there.
The previous tests were not updated after a change to `diff_assignments` in a previous PR. This went unnoticed since the tests weren't running.

Author: xitij2000

run_edx_integration_tests.sh

@@ -179,7 +179,7 @@ run_plugin_tests() {
     fi
 
     # Run the pytest command with CMS settings (for ol_openedx_chat)
-    if [[ "$plugin_dir" == *"ol_openedx_chat"* || "$plugin_dir" == *"ol_openedx_course_sync"* ]]; then
+    if [[ "$plugin_dir" == *"ol_openedx_chat"* || "$plugin_dir" == *"ol_openedx_course_sync"* || "$plugin_dir" == *"ol_openedx_canvas_integration"* ]]; then
         pytest . --cov . --ds=cms.envs.test
 
         PYTEST_SUCCESS=$?

src/ol_openedx_canvas_integration/CHANGELOG.rst

@@ -11,6 +11,33 @@ Change Log
 .. There should always be an "Unreleased" section for changes pending release.
 Unreleased
 ~~~~~~~~~~
+* Corrected documentation for due date syncing direction (Canvas to Open edX).
+* Updated management command instructions for Tutor.
+* Fixed the Tutor patch example in README.rst.
+
+[0.7.0] - 2026-05-12
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Added
+-----
+* Support for optional Canvas due date syncing.
+
+[0.6.0] - 2025-10-13
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Changed
+-------
+* Support for Django 5.0.
+
+[0.5.3] - 2025-10-08
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Changed
+-------
+* Use login_id to match canvas and openedx users.
+
+[0.5.2] - 2025-09-19
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Fixed
+-----
+* Assignments are now synced with the correct published state.
 
 [0.5.1] - 2025-08-26
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

src/ol_openedx_canvas_integration/README.rst

@@ -81,7 +81,8 @@ Configuration
 1) Open your course in Studio.
 2) Navigate to "Advanced Settings".
 3) Enable other course settings by enabling ``ENABLE_OTHER_COURSE_SETTINGS`` feature flag in CMS
-4) Open course advanced settings in Open edX CMS, Add a dictionary in ``{"canvas_id": <canvas_course_id>}``. The ``canvas_course_id`` should be the id of a course that exists on Canvas. (NOTE: Canvas tab would only be visible if this value is set)
+4) Open course advanced settings in Open edX CMS, Add a dictionary in ``{"canvas_id": <canvas_course_id>, "use_canvas_due_dates": <True/False>}``. The ``canvas_course_id`` should be the id of a course that exists on Canvas.
+   The ``use_canvas_due_dates`` is an optional flag (defaults to ``False``) to sync the assignment due dates from Canvas to Open edX. (NOTE: Canvas tab would only be visible if ``canvas_id`` is set)
 
 
 How To Use
@@ -115,6 +116,7 @@ Whenever the course is **Published** from the Studio, the **graded subsections**
 * adding new assignments when new graded subsections are added
 * updating the existing assignments
 * removing any assignment that might exist, when subsections are removed
+* syncing assignment due dates (if ``use_canvas_due_dates`` is set to ``True`` in course advanced settings) from Canvas to Open edX
 
 .. IMPORTANT::
 
@@ -125,3 +127,31 @@ Whenever the course is **Published** from the Studio, the **graded subsections**
 """"""""""""""""""""""""""""""
 
 Whenever a learner interacts with a graded question in Open edX, the latest grades are automatically posted to Canvas, if it's a part of a synced assignment.
+
+3. Automatic Syncing of Due Dates
+""""""""""""""""""""""""""""""
+
+This feature allows for periodic syncing of assignment due dates from the linked Canvas course to Open edX.
+
+**Scheduling the Task**
+
+This sync does not happen automatically. Instead, it is triggered by a management command that needs to be scheduled as a periodic task (e.g., via cron).
+
+The management command can be run (in the dev environment) using the following Tutor command:
+
+.. code-block:: bash
+
+    tutor dev exec cms -- python manage.py cms sync_canvas_due_dates --all
+
+
+For Tutor-based installations, you can schedule this using the `grove-config` plugin which is a part
+of `tutor-contrib-grove <https://gitlab.com/opencraft/dev/tutor-contrib-grove#cron-jobs>`_.
+It can be configured using the following Tutor config snippet:
+
+.. code-block:: yaml
+
+    GROVE_CRON_JOBS:
+      - name: canvas-sync-due-dates
+        service: cms
+        script: ./manage.py cms sync_canvas_due_dates --all
+        schedule: "0 * * * *"

src/ol_openedx_canvas_integration/ol_openedx_canvas_integration/api.py

@@ -17,7 +17,10 @@
     update_grade_payload_kv,
 )
 from ol_openedx_canvas_integration.constants import COURSE_KEY_ID_EMPTY
-from ol_openedx_canvas_integration.utils import get_canvas_course_id
+from ol_openedx_canvas_integration.utils import (
+    get_canvas_course_id,
+    get_use_canvas_due_dates,
+)
 
 log = logging.getLogger(__name__)
 
@@ -227,6 +230,7 @@ def push_edx_grades_to_canvas(course):
     if not canvas_course_id:
         msg = f"No canvas_course_id set for course: {course.id}"
         raise Exception(msg)  # noqa: TRY002
+    use_canvas_due_dates = get_use_canvas_due_dates(course)
 
     client = CanvasClient(canvas_course_id=canvas_course_id)
     existing_assignment_dict = client.get_canvas_assignments()
@@ -240,7 +244,7 @@ def push_edx_grades_to_canvas(course):
     )
     created_assignments = {
         subsection_block: client.create_canvas_assignment(
-            create_assignment_payload(subsection_block)
+            create_assignment_payload(subsection_block, use_canvas_due_dates)
         )
         for subsection_block in new_assignment_blocks
     }

src/ol_openedx_canvas_integration/ol_openedx_canvas_integration/client.py

@@ -143,6 +143,7 @@ def get_canvas_assignments(self):
             assignment.get("integration_id"): {
                 "id": assignment["id"],
                 "is_published": assignment.get("published", False),
+                "due_at": assignment.get("due_at"),
             }
             for assignment in assignments
             if assignment.get("integration_id") is not None
@@ -246,32 +247,39 @@ def update_assignment_grades(self, canvas_assignment_id, payload):
         )
 
 
-def create_assignment_payload(subsection_block):
+def create_assignment_payload(subsection_block, use_canvas_dates=False):  # noqa: FBT002
     """
     Create a Canvas assignment dict matching a subsection block on edX
 
     Args:
         subsection_block (openedx.core.djangoapps.content.block_structure.block_structure.BlockData):
             The block data for the graded assignment/exam (in the structure of a course, this unit is a subsection)
+        use_canvas_dates (bool): Whether to use the due dates from canvas instead of Open edX
 
     Returns:
         dict:
             Assignment payload to be sent to Canvas to create or update the assignment
     """  # noqa: E501
+    due_date_dict = {
+        "due_at": (
+            None
+            if not subsection_block.fields.get("due")
+            # The internal API gives us a TZ-naive datetime for the due date, but Studio indicates that  # noqa: E501
+            # the user should enter a UTC datetime for the due date. Coerce this to UTC before creating the  # noqa: E501
+            # string representation.
+            else subsection_block.fields["due"].astimezone(pytz.UTC).isoformat()
+        ),
+    }
+    # If we're using canvas dates, don't set the due dates from Open edX
+    if use_canvas_dates:
+        due_date_dict = {}
     return {
         "assignment": {
             "name": subsection_block.display_name,
             "integration_id": str(subsection_block.location),
             "grading_type": "percent",
             "points_possible": DEFAULT_ASSIGNMENT_POINTS,
-            "due_at": (
-                None
-                if not subsection_block.fields.get("due")
-                # The internal API gives us a TZ-naive datetime for the due date, but Studio indicates that  # noqa: E501
-                # the user should enter a UTC datetime for the due date. Coerce this to UTC before creating the  # noqa: E501
-                # string representation.
-                else subsection_block.fields["due"].astimezone(pytz.UTC).isoformat()
-            ),
+            **due_date_dict,
             "submission_types": ["none"],
             "published": False,
         }

src/ol_openedx_canvas_integration/ol_openedx_canvas_integration/cms_tasks.py

@@ -15,23 +15,39 @@
 
 import requests
 from celery import shared_task
+from django.utils.dateparse import parse_datetime
 from lms.djangoapps.courseware.courses import get_course_by_id
+from opaque_keys import InvalidKeyError
+from opaque_keys.edx.keys import CourseKey, UsageKey
 from opaque_keys.edx.locator import CourseLocator
+from xmodule.modulestore import ModuleStoreEnum
+from xmodule.modulestore.django import modulestore
+from xmodule.modulestore.exceptions import ItemNotFoundError
 
 from ol_openedx_canvas_integration.api import course_graded_items
 from ol_openedx_canvas_integration.client import CanvasClient, create_assignment_payload
-from ol_openedx_canvas_integration.utils import get_canvas_course_id
+from ol_openedx_canvas_integration.utils import (
+    get_canvas_course_id,
+    get_use_canvas_due_dates,
+)
 
 logger = logging.getLogger(__name__)
+TASK_LOG = logging.getLogger("edx.celery.task")
 
 
-def diff_assignments(openedx_assignments, canvas_assignments_map):
+def diff_assignments(
+    openedx_assignments,
+    canvas_assignments_map,
+    use_canvas_dates=False,  # noqa: FBT002
+):
     """Perform a diff between the assignments in Canvas and Open edX.
 
     Args:
         openedx_assignments (list): List of Open edX subsection objects
         canvas_assignments_map (dict): Map of assignment integration IDs to Canvas
                                        assignment IDs
+        use_canvas_dates (bool): Whether to sync the due dates of the assignments
+                                 with the due dates of the subsections
 
     Returns:
         dict: The diff between the assignments with the following structure:
@@ -44,7 +60,9 @@ def diff_assignments(openedx_assignments, canvas_assignments_map):
     assignment_diff = {"add": [], "update": {}, "delete": []}
     for subsection in openedx_assignments:
         integration_id = str(subsection.location)
-        payload = create_assignment_payload(subsection)
+        payload = create_assignment_payload(
+            subsection, use_canvas_dates=use_canvas_dates
+        )
         canvas_assignment = canvas_assignments_map.pop(integration_id, None)
         if canvas_assignment:
             # if the assignment exists in Canvas, remove from the map to indicate
@@ -151,6 +169,7 @@ def sync_course_assignments_with_canvas(course_id):
     course_key = CourseLocator.from_string(course_id)
     course = get_course_by_id(course_key)
     canvas_course_id = get_canvas_course_id(course)
+    use_canvas_due_dates = get_use_canvas_due_dates(course)
 
     if not canvas_course_id:
         logger.info(
@@ -165,7 +184,9 @@ def sync_course_assignments_with_canvas(course_id):
     canvas = CanvasClient(canvas_course_id=canvas_course_id)
     canvas_assignments = canvas.get_canvas_assignments()
 
-    operations_map = diff_assignments(openedx_assignments, canvas_assignments)
+    operations_map = diff_assignments(
+        openedx_assignments, canvas_assignments, use_canvas_due_dates
+    )
     logger.info(
         "Syncing assignments with Canvas. Adding: %d, Updating: %d, Deleting: %d",
         len(operations_map["add"]),
@@ -176,3 +197,84 @@ def sync_course_assignments_with_canvas(course_id):
     add_assignments(canvas, operations_map["add"])
     update_assignments(canvas, operations_map["update"])
     delete_assignments(canvas, operations_map["delete"])
+
+
+@shared_task
+def sync_canvas_due_dates(course_id: str):
+    """
+    Synchronize due dates for the specified course with the Canvas platform.
+
+    This task is a wrapper around the `_sync_canvas_due_dates` function, which
+    performs the actual synchronization of assignment due dates from Canvas to
+    the platform.
+
+    Parameters:
+        course_id (str): The unique identifier of the course whose due
+        dates need to be synchronized.
+    """
+    _sync_canvas_due_dates(course_id)
+
+
+def _sync_canvas_due_dates(course_id: str):
+    """
+    Synchronize assignment due dates from Canvas to a specific course in the platform.
+
+    This function retrieves assignment due dates from Canvas associated with a
+    given course and updates the platform's course content accordingly. The
+    function skips synchronization if the course has no Canvas ID or if using
+    Canvas due dates is disabled for the course.
+
+    Arguments:
+        course_id (str): The unique identifier of the course to be synchronized.
+    """
+    course_key = CourseKey.from_string(course_id)
+    course = get_course_by_id(course_key)
+    canvas_course_id = get_canvas_course_id(course)
+    if not canvas_course_id:
+        TASK_LOG.info(
+            "Due Date Sync: No canvas ID. Skipped for course %s",
+            course_id,
+        )
+        return
+    use_canvas_due_dates = get_use_canvas_due_dates(course)
+    if not use_canvas_due_dates:
+        TASK_LOG.info(
+            "Due Date Sync: Disabled. Skipped for course %s",
+            course_id,
+        )
+        return
+
+    TASK_LOG.info(
+        "Due Date Sync: Starting for course %s with canvas course id: %s",
+        course_id,
+        canvas_course_id,
+    )
+
+    client = CanvasClient(canvas_course_id=canvas_course_id)
+    canvas_assignments = client.get_canvas_assignments()
+
+    with modulestore().bulk_operations(course_key):
+        for usage_id, canvas_assignment in canvas_assignments.items():
+            try:
+                usage_key = UsageKey.from_string(usage_id)
+                due_at = canvas_assignment.get("due_at")
+                block = modulestore().get_item(usage_key)
+                if due_at:
+                    block.due = parse_datetime(due_at)
+                else:
+                    block.due = None
+                modulestore().update_item(block, ModuleStoreEnum.UserID.mgmt_command)
+            except ItemNotFoundError:
+                TASK_LOG.error(
+                    "Due Date Sync: Error updating due date for %s: block not found.",
+                    usage_key,
+                )
+            except InvalidKeyError:
+                TASK_LOG.error(
+                    "Due Date Sync: Error updating due date for %s: invalid key.",
+                    usage_key,
+                )
+            except Exception as e:  # noqa: BLE001
+                TASK_LOG.error(
+                    "Due Date Sync: Error updating due date for %s: %s", usage_key, e
+                )