Canvas Commits (#223)

* Sync canvas enrollments

* Added instructor dashboard button to push edX grades to Canvas

* Fixed canvas grade syncing JS

* Changed 'edX' reference to 'MITx'

* Use EDIT_COURSE_ACCESS permission instead of is_staff

* Use OVERRIDE_GRADES rule instead

* Use instructor_tasks for canvas work (#183)

* Add per_page to paginated requests

* Static method

* Fix email lowercase mismatch

* Use instructor_tasks to handle canvas work

* Fix transaction error

* Decorator needs to be at the top

* Attempt to fix polling of tasks

* More task bug fixes

* Fix typo

* Fix course key bug

* Update message for push edx grades command

* Use course_key so sync_canvas_enrollments uses the same message

* Format the submitted time

* Don't return output to prevent task output max size error (#189)

Co-authored-by: George Schneeloch <[email protected]>
Co-authored-by: Gavin Sidebottom <[email protected]>

Author: 3 people

common/lib/xmodule/xmodule/course_module.py

@@ -490,6 +490,13 @@ class CourseFields(object):
         ),
         scope=Scope.settings
     )
+    canvas_course_id = Integer(
+        display_name=_("Canvas Course Id"),
+        help=_(
+            "The id for the corresponding course on Canvas"
+        ),
+        scope=Scope.settings
+    )
     enable_ccx = Boolean(
         # Translators: Custom Courses for edX (CCX) is an edX feature for re-using course content. CCX Coach is
         # a role created by a course Instructor to enable a person (the "Coach") to manage the custom course for

lms/djangoapps/canvas_integration/__init__.py

@@ -0,0 +1,171 @@
+"""Utility functions for canvas integration"""
+import logging
+from collections import defaultdict
+
+from opaque_keys.edx.locator import CourseLocator
+
+from courseware.courses import get_course_by_id
+from lms.djangoapps.grades.course_grade_factory import CourseGradeFactory
+from remote_gradebook.api import enroll_emails_in_course, get_enrolled_non_staff_users, course_graded_items
+from student.models import CourseEnrollment
+from canvas_integration.client import CanvasClient, create_assignment_payload, update_grade_payload_kv
+
+log = logging.getLogger(__name__)
+
+
+def first_or_none(iterable):
+    """Returns the first item in the given iterable, or None if the iterable is empty"""
+    return next((x for x in iterable), None)
+
+
+def get_subsection_user_grades(course):
+    """
+    Builds a dict of user grades grouped by block locator. Only returns grades if the assignment has been attempted
+    by the given user.
+
+    Args:
+        course: The course object (of the type returned by courseware.courses.get_course_by_id)
+
+    Returns:
+        dict: Block locators for graded items (assignments, exams, etc.) mapped to a dict of users
+            and their grades for those assignments.
+            Example: {
+                <BlockUsageLocator for graded item>: {
+                    <User object for student 1>: <grades.subsection_grade.CreateSubsectionGrade object>,
+                    <User object for student 2>: <grades.subsection_grade.CreateSubsectionGrade object>,
+                }
+            }
+    """
+    enrolled_students = CourseEnrollment.objects.users_enrolled_in(course.id)
+    subsection_grade_dict = defaultdict(dict)
+    for student, course_grade, error in CourseGradeFactory().iter(users=enrolled_students, course=course):
+        for graded_item_type, subsection_dict in course_grade.graded_subsections_by_format.items():
+            for subsection_block_locator, subsection_grade in subsection_dict.items():
+                subsection_grade_dict[subsection_block_locator].update(
+                    # Only include grades if the assignment/exam/etc. has been attempted
+                    {student: subsection_grade}
+                    if subsection_grade.graded_total.first_attempted
+                    else {}
+                )
+    return subsection_grade_dict
+
+
+def get_subsection_block_user_grades(course):
+    """
+    Builds a dict of user grades grouped by the subsection XBlock representing each graded item.
+    Only returns grades if the assignment has been attempted by the given user.
+
+    Args:
+        course: The course object (of the type returned by courseware.courses.get_course_by_id)
+
+    Returns:
+        dict: Block objects representing graded items (assignments, exams, etc.) mapped to a dict of users
+            and their grades for those assignments.
+            Example: {
+                <content.block_structure.block_structure.BlockData object for graded item>: {
+                    <User object for student 1>: <grades.subsection_grade.CreateSubsectionGrade object>,
+                    <User object for student 2>: <grades.subsection_grade.CreateSubsectionGrade object>,
+                }
+            }
+    """
+    subsection_user_grades = get_subsection_user_grades(course)
+    graded_subsection_blocks = [
+        graded_item.get("subsection_block")
+        for graded_item_type, graded_item, graded_item_index in course_graded_items(course)
+    ]
+    locator_block_dict = {
+        block_locator: first_or_none((block for block in graded_subsection_blocks if block.location == block_locator))
+        for block_locator in subsection_user_grades.keys()
+    }
+    return {
+        block: subsection_user_grades[block_locator]
+        for block_locator, block in locator_block_dict.items()
+        if block is not None
+    }
+
+
+def sync_canvas_enrollments(course_key, canvas_course_id, unenroll_current):
+    """
+    Fetch enrollments from canvas and update
+
+    Args:
+        course_key (str): The edX course key
+        canvas_course_id (int): The canvas course id
+        unenroll_current (bool): If true, unenroll existing students if not staff
+    """
+    client = CanvasClient(canvas_course_id)
+    emails_to_enroll = client.list_canvas_enrollments()
+    users_to_unenroll = []
+
+    course_key = CourseLocator.from_string(course_key)
+    course = get_course_by_id(course_key)
+
+    if unenroll_current:
+        enrolled_user_dict = {user.email: user for user in get_enrolled_non_staff_users(course)}
+        emails_to_enroll_set = set(emails_to_enroll)
+        already_enrolled_email_set = set(enrolled_user_dict.keys())
+        emails_to_enroll = emails_to_enroll_set - already_enrolled_email_set
+        users_to_unenroll = [enrolled_user_dict[email] for email in (already_enrolled_email_set - emails_to_enroll)]
+
+    enrolled = enroll_emails_in_course(emails=emails_to_enroll, course_key=course_key)
+    log.info("Enrolled users in course %s: %s", course_key, enrolled)
+
+    if users_to_unenroll:
+        for user_to_unenroll in users_to_unenroll:
+            CourseEnrollment.unenroll(user_to_unenroll, course.id)
+        log.info("Unenrolled non-staff users in course %s: %s", course_key, users_to_unenroll)
+
+
+def push_edx_grades_to_canvas(course):
+    """
+    Gathers all student grades for each assignment in the given course, creates equivalent assignment in Canvas
+    if they don't exist already, and adds/updates the student grades for those assignments in Canvas.
+
+    Args:
+        course: The course object (of the type returned by courseware.courses.get_course_by_id)
+
+    Returns:
+        dict: A dictionary with some information about the success/failure of the updates
+    """
+    canvas_course_id = course.canvas_course_id
+    client = CanvasClient(canvas_course_id=canvas_course_id)
+    existing_assignment_dict = client.get_assignments_by_int_id()
+    subsection_block_user_grades = get_subsection_block_user_grades(course)
+
+    # Populate missing assignments
+    new_assignment_blocks = (
+        subsection_block for subsection_block in subsection_block_user_grades.keys()
+        if str(subsection_block.location) not in existing_assignment_dict
+    )
+    created_assignments = {
+        subsection_block: client.create_canvas_assignment(
+            create_assignment_payload(subsection_block)
+        )
+        for subsection_block in new_assignment_blocks
+    }
+
+    # Build request payloads for updating grades in each assignment
+    enrolled_user_dict = client.list_canvas_enrollments()
+    grade_update_payloads = {}
+    for subsection_block, user_grade_dict in subsection_block_user_grades.items():
+        grade_update_payloads[subsection_block] = dict(
+            update_grade_payload_kv(
+                enrolled_user_dict[student_user.email.lower()],
+                grade.percent_graded
+            )
+            for student_user, grade in user_grade_dict.items()
+            # Only add the grade if the user exists in Canvas
+            if student_user.email.lower() in enrolled_user_dict
+        )
+
+    # Send requests to update grades in each relevant course
+    assignment_grades_updated = {
+        subsection_block: client.update_assignment_grades(
+            canvas_assignment_id=existing_assignment_dict[str(subsection_block.location)],
+            payload=grade_request_payload,
+        )
+        for subsection_block, grade_request_payload in grade_update_payloads.items()
+        if grade_request_payload and str(subsection_block.location) in existing_assignment_dict
+    }
+
+    return assignment_grades_updated, created_assignments

lms/djangoapps/canvas_integration/api.py

@@ -0,0 +1,30 @@
+"""
+Canvas Integration Application Configuration
+"""
+
+from django.apps import AppConfig
+from openedx.core.constants import COURSE_ID_PATTERN
+from openedx.core.djangoapps.plugins.constants import ProjectType, SettingsType, PluginURLs, PluginSettings
+
+
+class CanvasIntegrationConfig(AppConfig):
+    """
+    Configuration class for Canvas integration app
+    """
+    name = u'canvas_integration'
+
+    plugin_app = {
+        PluginURLs.CONFIG: {
+            ProjectType.LMS: {
+                PluginURLs.NAMESPACE: u'',
+                PluginURLs.REGEX: u'courses/{}/canvas/api/'.format(COURSE_ID_PATTERN),
+                PluginURLs.RELATIVE_PATH: u'urls',
+            }
+        },
+        PluginSettings.CONFIG: {
+            ProjectType.LMS: {
+                SettingsType.PRODUCTION: {PluginSettings.RELATIVE_PATH: u'settings.production'},
+                SettingsType.COMMON: {PluginSettings.RELATIVE_PATH: u'settings.common'},
+            }
+        }
+    }