PoC grades sync

lms/js_config_types.py

@@ -118,6 +118,9 @@ class DashboardRoutes(TypedDict):
     students: str
     """Paginated endpoint to fetch students"""
 
+    assignment_grades_sync: str
+    """Sync grades for a given assignment"""
+
 
 class User(TypedDict):
     is_staff: bool

lms/migrations/versions/f68aacfc62c7_migration_for_grading_sync_tables.py

@@ -0,0 +1,51 @@
+"""Migration for grading_sync tables
+
+Revision ID: f68aacfc62c7
+Revises: adc83819c8d8
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+revision = 'f68aacfc62c7'
+down_revision = 'adc83819c8d8'
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('grading_sync',
+    sa.Column('id', sa.Integer(), autoincrement=True, nullable=False),
+    sa.Column('assignment_id', sa.Integer(), nullable=False),
+    sa.Column('status', sa.Enum('scheduled', 'in_progress', 'finished', 'failed', name='autogradingsyncstatus', native_enum=False, length=64), nullable=False),
+    sa.Column('created', sa.DateTime(), server_default=sa.text('now()'), nullable=False),
+    sa.Column('updated', sa.DateTime(), server_default=sa.text('now()'), nullable=False),
+    sa.ForeignKeyConstraint(['assignment_id'], ['assignment.id'], name=op.f('fk__grading_sync__assignment_id__assignment')),
+    sa.PrimaryKeyConstraint('id', name=op.f('pk__grading_sync'))
+    )
+    op.create_index(op.f('ix__grading_sync_assignment_id'), 'grading_sync', ['assignment_id'], unique=False)
+    op.create_table('grading_sync_grade',
+    sa.Column('id', sa.Integer(), autoincrement=True, nullable=False),
+    sa.Column('grading_sync_id', sa.Integer(), nullable=False),
+    sa.Column('lms_user_id', sa.Integer(), nullable=False),
+    sa.Column('grade', sa.Float(), nullable=True),
+    sa.Column('extra', postgresql.JSONB(astext_type=sa.Text()), server_default=sa.text("'{}'::jsonb"), nullable=False),
+    sa.Column('success', sa.Boolean(), nullable=True),
+    sa.Column('created', sa.DateTime(), server_default=sa.text('now()'), nullable=False),
+    sa.Column('updated', sa.DateTime(), server_default=sa.text('now()'), nullable=False),
+    sa.ForeignKeyConstraint(['grading_sync_id'], ['grading_sync.id'], name=op.f('fk__grading_sync_grade__grading_sync_id__grading_sync')),
+    sa.ForeignKeyConstraint(['lms_user_id'], ['lms_user.id'], name=op.f('fk__grading_sync_grade__lms_user_id__lms_user')),
+    sa.PrimaryKeyConstraint('id', name=op.f('pk__grading_sync_grade'))
+    )
+    op.create_index(op.f('ix__grading_sync_grade_grading_sync_id'), 'grading_sync_grade', ['grading_sync_id'], unique=False)
+    op.create_index(op.f('ix__grading_sync_grade_lms_user_id'), 'grading_sync_grade', ['lms_user_id'], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix__grading_sync_grade_lms_user_id'), table_name='grading_sync_grade')
+    op.drop_index(op.f('ix__grading_sync_grade_grading_sync_id'), table_name='grading_sync_grade')
+    op.drop_table('grading_sync_grade')
+    op.drop_index(op.f('ix__grading_sync_assignment_id'), table_name='grading_sync')
+    op.drop_table('grading_sync')
+    # ### end Alembic commands ###

lms/models/__init__.py

@@ -7,6 +7,7 @@
 from lms.models.dashboard_admin import DashboardAdmin
 from lms.models.event import Event, EventData, EventType, EventUser
 from lms.models.exceptions import ReusedConsumerKey
+from lms.models.grading_sync import GradingSync, GradingSyncGrade
 from lms.models.file import File
 from lms.models.grading_info import GradingInfo
 from lms.models.group_info import GroupInfo

lms/models/grading_sync.py

@@ -0,0 +1,49 @@
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from lms.models._mixins import CreatedUpdatedMixin
+
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy import ForeignKey, text
+from enum import StrEnum
+from lms.db import Base, varchar_enum
+from lms.models import Assignment
+
+
+class AutoGradingSyncStatus(StrEnum):
+    SCHEDULED = "scheduled"
+    IN_PROGRESS = "in_progress"
+    FINISHED = "finished"
+    FAILED = "failed"
+
+
+class GradingSync(CreatedUpdatedMixin, Base):
+    __tablename__ = "grading_sync"
+
+    id: Mapped[int] = mapped_column(autoincrement=True, primary_key=True)
+
+    assignment_id: Mapped[int] = mapped_column(ForeignKey("assignment.id"), index=True)
+    assignment: Mapped[Assignment] = relationship()
+
+    status: Mapped[str | None] = varchar_enum(AutoGradingSyncStatus)
+
+
+class GradingSyncGrade(CreatedUpdatedMixin, Base):
+    __tablename__ = "grading_sync_grade"
+
+    id: Mapped[int] = mapped_column(autoincrement=True, primary_key=True)
+
+    grading_sync_id: Mapped[int] = mapped_column(
+        ForeignKey("grading_sync.id"), index=True
+    )
+    grading_sync: Mapped[GradingSync] = relationship(backref="grades")
+
+    lms_user_id: Mapped[int] = mapped_column(ForeignKey("lms_user.id"), index=True)
+    lms_user: Mapped["LMSUser"] = relationship()
+
+    grade: Mapped[float | None] = mapped_column()
+
+    extra: Mapped[JSONB] = mapped_column(
+        JSONB(),
+        server_default=text("'{}'::jsonb"),
+        nullable=False,
+    )
+    success: Mapped[bool | None] = mapped_column()

lms/resources/_js_config/__init__.py

@@ -283,6 +283,9 @@ def enable_dashboard_mode(self, token_lifetime_seconds: int) -> None:
                             "api.dashboard.assignments"
                         ),
                         students=self._to_frontend_template("api.dashboard.students"),
+                        assignment_grades_sync=self._to_frontend_template(
+                            "api.dashboard.assignments.grading.sync"
+                        ),
                     ),
                 ),
             }

lms/routes.py

@@ -284,6 +284,10 @@ def includeme(config):  # noqa: PLR0915
     config.add_route(
         "api.dashboard.assignment", r"/api/dashboard/assignments/{assignment_id}"
     )
+    config.add_route(
+        "api.dashboard.assignments.grading.sync",
+        "/api/dashboard/assignments/{assignment_id}/grading/sync",
+    )
     config.add_route("api.dashboard.assignments", "/api/dashboard/assignments")
     config.add_route(
         "api.dashboard.course.assignments.metrics",

lms/security.py

@@ -363,7 +363,7 @@ def get_lti_user(request) -> LTIUser | None:
     if lti_user:
         # Make a record of the user for analytics so we can map from the
         # LTI users and the corresponding user in H
-        request.find_service(UserService).upsert_user(lti_user, request.lti_params)
+        request.find_service(UserService).upsert_user(lti_user)
 
         # Attach useful information to sentry in case we get an exception further down the line
         sentry_sdk.set_tag("application_instance_id", lti_user.application_instance_id)

lms/services/auto_grading.py

@@ -1,5 +1,6 @@
 from lms.js_config_types import AnnotationMetrics
-from lms.models import AutoGradingConfig
+from sqlalchemy import select
+from lms.models import AutoGradingConfig, GradingSync, GradingSyncGrade, LMSUser
 
 
 def calculate_grade(
@@ -52,3 +53,21 @@ def calculate_grade(
 
     grade = min(100, grade)  # Proportional grades are capped at 100%
     return round(grade, 2)
+
+
+def get_last_synced_grade_for_h_userids(db, h_userids: list[str], assignment_id):
+    result = db.execute(
+        select(LMSUser.h_userid, GradingSyncGrade.grade)
+        .distinct(LMSUser.h_userid)
+        .join(GradingSync)
+        .join(LMSUser)
+        .where(
+            GradingSync.assignment_id == assignment_id,
+            GradingSyncGrade.success == True,
+            LMSUser.h_userid.in_(h_userids),
+        )
+        .order_by(LMSUser.h_userid, GradingSyncGrade.updated.desc())
+    ).all()
+    print(result)
+
+    return {r[0]: r[1] for r in result}

lms/services/dashboard.py

@@ -1,8 +1,8 @@
 from pyramid.httpexceptions import HTTPNotFound, HTTPUnauthorized
 from sqlalchemy import select
 
+from lms.models import Assignment, Organization
 from lms.models.dashboard_admin import DashboardAdmin
-from lms.models.organization import Organization
 from lms.security import Permissions
 from lms.services.organization import OrganizationService
 
@@ -21,7 +21,7 @@ def __init__(
         self._course_service = course_service
         self._organization_service = organization_service
 
-    def get_request_assignment(self, request):
+    def get_request_assignment(self, request) -> Assignment:
         """Get and authorize an assignment for the given request."""
         assigment_id = request.matchdict.get(
             "assignment_id"

lms/services/lti_grading/_v13.py

@@ -83,15 +83,36 @@ def read_result(self, grading_id) -> GradingResult:
     def get_score_maximum(self, resource_link_id) -> float | None:
         return self._read_grading_configuration(resource_link_id).get("scoreMaximum")
 
+    def sync_grade(  # noqa: PLR0913
+        self,
+        lti_registration: LTIRegistration,
+        lis_outcome_service_url: str,
+        grade_timestamp: str,
+        user_grading_id: str,
+        score: float,
+    ):
+        """
+        Send a grade to the LMS.
+
+        This is very similar to `record_result` but not scoped to the request context,
+        taking all the necessary information as parameters.
+        """
+        payload = self._record_score_payload(score, user_grading_id, grade_timestamp)
+        return self._ltia_service.request(
+            lti_registration,
+            "POST",
+            self._service_url(lis_outcome_service_url, "/scores"),
+            scopes=self.LTIA_SCOPES,
+            json=payload,
+            headers={"Content-Type": "application/vnd.ims.lis.v1.score+json"},
+        )
+
     def record_result(self, grading_id, score=None, pre_record_hook=None, comment=None):
-        payload = {
-            "scoreMaximum": 1,
-            "scoreGiven": score,
-            "userId": grading_id,
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "activityProgress": "Completed",
-            "gradingProgress": "FullyGraded",
-        }
+        payload = self._record_score_payload(
+            score,
+            grading_id,
+            datetime.now(timezone.utc).isoformat(),
+        )
         if comment:
             payload["comment"] = self._misc_plugin.format_grading_comment_for_lms(
                 comment
@@ -183,6 +204,19 @@ def _read_grading_configuration(self, resource_link_id) -> dict:
 
         return {}
 
+    @staticmethod
+    def _record_score_payload(
+        score: float | None, user_grading_id: str, timestamp: str
+    ):
+        return {
+            "scoreMaximum": 1,
+            "scoreGiven": score,
+            "userId": user_grading_id,
+            "timestamp": timestamp,
+            "activityProgress": "Completed",
+            "gradingProgress": "FullyGraded",
+        }
+
     @staticmethod
     def _service_url(base_url, endpoint):
         """

lms/services/user.py

@@ -35,7 +35,7 @@ def __init__(self, db, h_authority: str):
         self._db = db
         self._h_authority = h_authority
 
-    def upsert_user(self, lti_user: LTIUser, lti_params: LTIParams) -> User:
+    def upsert_user(self, lti_user: LTIUser) -> User:
         """Store a record of having seen a particular user."""
 
         # Note! - Storing a user in our DB currently has an implication for
@@ -65,12 +65,14 @@ def upsert_user(self, lti_user: LTIUser, lti_params: LTIParams) -> User:
             # We are only storing emails for teachers now.
             user.email = lti_user.email
 
-        self._upsert_lms_user(user, lti_params)
         return user
 
-    def _upsert_lms_user(self, user: User, lti_params: LTIParams) -> LMSUser:
+    def upsert_lms_user(self, user: User, lti_params: LTIParams) -> LMSUser:
         """Upsert LMSUser based on a User object."""
         self._db.flush()  # Make sure User has hit the DB on the current transaction
+        print(user)
+        print(lti_params.v13.get("sub"))
+        print(lti_params)
 
         lms_user = bulk_upsert(
             self._db,
@@ -195,8 +197,7 @@ def get_users(  # noqa: PLR0913, PLR0917
             query = query.where(User.h_userid.in_(h_userids))
 
         return (
-            select(User)
-            .where(User.id.in_(query))
+            select(User).where(User.id.in_(query))
             # We can sort these again without affecting deduplication
             .order_by(User.display_name, User.id)
         )