feat: sync Canvas due date extensions for students

- Added `sync_canvas_due_date_extensions` to handle due date extensions for specific students in Canvas.
- Extended `_sync_canvas_due_dates` to update due dates with overrides.
- Added `get_emails_by_student_ids` method in `client.py` to fetch student emails by ID from Canvas.
- Updated `list_canvas_assignments` to support fetching overrides with assignments.

Author: xitij2000

src/ol_openedx_canvas_integration/ol_openedx_canvas_integration/client.py

@@ -85,7 +85,7 @@ def list_canvas_enrollments(self):
             for enrollment in enrollments
         }
 
-    def list_canvas_assignments(self):
+    def list_canvas_assignments(self, *args, **kwargs):
         """
         List Canvas assignments
 
@@ -96,7 +96,7 @@ def list_canvas_assignments(self):
             settings.CANVAS_BASE_URL,
             f"/api/v1/courses/{self.canvas_course_id}/assignments",
         )
-        return self._paginate(url)
+        return self._paginate(url, *args, **kwargs)
 
     def get_student_id_by_email(self, email: str):
         """
@@ -129,6 +129,24 @@ def get_student_id_by_email(self, email: str):
             cache.set(key, student_id)
         return student_id
 
+    def get_emails_by_student_ids(self, student_ids: list[int]):
+        """
+        Retrieve emails for a list of student IDs from Canvas.
+
+        Args:
+            student_ids (list[int]): List of student IDs.
+
+        Returns:
+            list[str]: List of student emails.
+        """
+        url = urljoin(
+            settings.CANVAS_BASE_URL,
+            f"/api/v1/courses/{self.canvas_course_id}/users",
+        )
+        results = self._paginate(url, params={"user_ids[]": student_ids})
+
+        return [user["login_id"].lower() for user in results if "login_id" in user]
+
     def get_canvas_assignments(self):
         """
         Get Canvas assignments organized by integration_id.
@@ -138,12 +156,15 @@ def get_canvas_assignments(self):
                   'id' and 'is_published' fields. Only includes assignments with
                   integration_id set.
         """
-        assignments = self.list_canvas_assignments()
+        # This query param makes canvas return all overrides for each assignment
+        query = {"include[]": ["overrides"]}
+        assignments = self.list_canvas_assignments(params=query)
         assignments_dict = {
             assignment.get("integration_id"): {
                 "id": assignment["id"],
                 "is_published": assignment.get("published", False),
                 "due_at": assignment.get("due_at"),
+                "overrides": assignment.get("overrides", []),
             }
             for assignment in assignments
             if assignment.get("integration_id") is not None
@@ -297,4 +318,4 @@ def update_grade_payload_kv(user_id, grade_percent):
     Returns:
         (tuple): A key/value pair that will be used in the body of a bulk grade update request
     """  # noqa: D401, E501
-    return (f"grade_data[{user_id}][posted_grade]", f"{grade_percent * 100}%")
+    return f"grade_data[{user_id}][posted_grade]", f"{grade_percent * 100}%"

src/ol_openedx_canvas_integration/ol_openedx_canvas_integration/cms_tasks.py

@@ -15,8 +15,10 @@
 
 import requests
 from celery import shared_task
+from django.contrib.auth import get_user_model
 from django.utils.dateparse import parse_datetime
 from lms.djangoapps.courseware.courses import get_course_by_id
+from lms.djangoapps.instructor.views.tools import set_due_date_extension
 from opaque_keys import InvalidKeyError
 from opaque_keys.edx.keys import CourseKey, UsageKey
 from opaque_keys.edx.locator import CourseLocator
@@ -33,6 +35,7 @@
 
 logger = logging.getLogger(__name__)
 TASK_LOG = logging.getLogger("edx.celery.task")
+User = get_user_model()
 
 
 def diff_assignments(
@@ -215,6 +218,38 @@ def sync_canvas_due_dates(course_id: str):
     _sync_canvas_due_dates(course_id)
 
 
+def sync_canvas_due_date_extensions(client, course, block, overrides):
+    """
+    Synchronize due date extensions for students in Canvas with the platform.
+
+    Parameters:
+        client (CanvasAPIClient): The Canvas API client for making requests.
+        course (Course): Course object for which due date extensions are being synced.
+        block (Block): Block object for which due date extensions are being synced.
+        overrides (list): List of due date overrides from Canvas.
+    """
+    if not overrides:
+        return
+    canvas_course_id = get_canvas_course_id(course)
+    for override in overrides:
+        if "student_ids" in override:
+            emails = client.get_emails_by_student_ids(override["student_ids"])
+            students = User.objects.filter(email__in=emails)
+            for student in students:
+                TASK_LOG.info(
+                    "Due Date Sync: Syncing due date for student %s in course %s",
+                    student.id,
+                    course.id,
+                )
+                set_due_date_extension(
+                    course,
+                    block,
+                    student,
+                    override["due_at"],
+                    reason=f"Synced from canvas course: {canvas_course_id}",
+                )
+
+
 def _sync_canvas_due_dates(course_id: str):
     """
     Synchronize assignment due dates from Canvas to a specific course in the platform.
@@ -259,6 +294,9 @@ def _sync_canvas_due_dates(course_id: str):
                 usage_key = UsageKey.from_string(usage_id)
                 due_at = canvas_assignment.get("due_at")
                 block = modulestore().get_item(usage_key)
+                sync_canvas_due_date_extensions(
+                    client, course, block, canvas_assignment.get("overrides")
+                )
                 if due_at:
                     block.due = parse_datetime(due_at)
                 else:

src/ol_openedx_canvas_integration/ol_openedx_canvas_integration/tasks.py

@@ -2,7 +2,7 @@
 
 import hashlib
 import logging
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from functools import partial
 
 import requests
@@ -122,7 +122,7 @@ def _sync_user_grade_with_canvas(grade_id):
     due_date = parse_datetime(
         existing_assignments_map[str(grade_instance.usage_key)]["due_at"]
     )
-    if due_date and due_date < datetime.now(tz=timezone.utc):
+    if due_date and due_date < datetime.now(tz=UTC):
         TASK_LOG.warning(
             "The assignment %s is past its due date. Skipping grade sync.",
             grade_instance.usage_key,

src/ol_openedx_canvas_integration/tests/test_cms_tasks.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
-from unittest.mock import MagicMock, patch
+from unittest.mock import ANY, MagicMock, patch
 
 import ddt
 import pytest
+from django.contrib.auth.models import User
 from django.test import override_settings
 from django.utils.dateparse import parse_datetime
 from ol_openedx_canvas_integration.api import create_assignment_payload
@@ -211,3 +212,71 @@ def test_sync_canvas_due_dates_updates_due_dates(self):
                 due_at = data.get("due_at", None)
                 due_at = parse_datetime(due_at) if due_at else None
                 assert self.store.get_item(seq_key).due == due_at
+
+    def test_sync_canvas_due_date_extensions(self):
+        for uid in [1, 4, 9, 11, 14, 37]:
+            User.objects.create_user(f"user{uid}", f"user{uid}@abc.xyz", "password")
+        course, sequentials = self.create_course(
+            {"canvas_id": 11, "use_canvas_due_dates": True}
+        )
+
+        sequential_0_student_ids = [11, 37, 4]
+        sequential_1_student_ids = [1, 9, 14]
+
+        mock_canvas_assignments = {
+            str(sequentials[0].location): {
+                "due_at": "2026-06-01T00:00:00Z",
+                "overrides": [
+                    {
+                        "due_at": "2026-06-02T00:00:00Z",
+                        "student_ids": sequential_0_student_ids,
+                    }
+                ],
+            },
+            str(sequentials[1].location): {
+                "due_at": None,
+                "overrides": [
+                    {
+                        "due_at": "2026-06-04T00:00:00Z",
+                        "student_ids": sequential_1_student_ids,
+                    }
+                ],
+            },
+        }
+
+        canvas_client_mock = MagicMock()
+        canvas_client_mock.get_canvas_assignments.return_value = mock_canvas_assignments
+        canvas_client_mock.get_emails_by_student_ids.side_effect = lambda ids: [
+            f"user{uid}@abc.xyz" for uid in ids
+        ]
+
+        with (
+            patch(
+                "ol_openedx_canvas_integration.cms_tasks.CanvasClient",
+                return_value=canvas_client_mock,
+            ),
+            patch(
+                "ol_openedx_canvas_integration.cms_tasks.set_due_date_extension"
+            ) as set_due_date_extension_mock,
+        ):
+            _sync_canvas_due_dates(str(course.id))
+            # 3 student extensions each for 2 assignments
+            assert set_due_date_extension_mock.call_count == (
+                len(sequential_0_student_ids) + len(sequential_1_student_ids)
+            )
+            for call_args, _ in set_due_date_extension_mock.call_args_list:
+                assert call_args[0].id == course.id
+                assert call_args[1].location in (
+                    sequentials[0].location,
+                    sequentials[1].location,
+                )
+
+            for student_id in sequential_0_student_ids:
+                for _ in sequentials:
+                    set_due_date_extension_mock.assert_any_call(
+                        ANY,
+                        ANY,
+                        User.objects.get(email=f"user{student_id}@abc.xyz"),
+                        "2026-06-02T00:00:00Z",
+                        reason="Synced from canvas course: 11",
+                    )

src/ol_openedx_canvas_integration/tests/test_tasks.py

@@ -5,12 +5,12 @@
 
 import requests
 from django.contrib.auth import get_user_model
-from django.test import override_settings, TestCase
-from opaque_keys.edx.keys import UsageKey, CourseKey
-
-from ol_openedx_canvas_integration.tasks import _sync_user_grade_with_canvas
+from django.test import TestCase, override_settings
 from lms.djangoapps.grades.models import PersistentSubsectionGrade
+from ol_openedx_canvas_integration.tasks import _sync_user_grade_with_canvas
+from opaque_keys.edx.keys import CourseKey, UsageKey
 from openedx.core.djangolib.testing.utils import skip_unless_lms
+from pytz import UTC
 
 USER_MODEL = get_user_model()
 
@@ -37,7 +37,9 @@ def setUp(self):
         self.canvas_user_id = 456
         self.canvas_assignment_id = 789
         self.user = USER_MODEL.objects.create_user(
-            username="student", email="student@example.com", password="password"
+            username="student",
+            email="student@example.com",
+            password="password",  # noqa: S106 # pragma: allowlist secret
         )
         self.grade_instance = PersistentSubsectionGrade.update_or_create_grade(
             user_id=self.user.id,
@@ -49,7 +51,7 @@ def setUp(self):
             earned_graded=6.0,
             possible_graded=8.0,
             visible_blocks=[],
-            first_attempted=datetime.now(),
+            first_attempted=datetime.now(tz=UTC),
         )
         # Mock Course
         self.course = MagicMock()
@@ -138,7 +140,7 @@ def test_assignment_past_due_date(
         mock_client.get_canvas_assignments.return_value = {
             "dummy-key": {
                 "id": self.canvas_assignment_id,
-                "due_at": str(datetime.now() - timedelta(days=1)),
+                "due_at": str(datetime.now(tz=UTC) - timedelta(days=1)),
             }
         }