Add assignment creation flow

Author: karenrasmussen

lms/models/assignment.py

@@ -146,6 +146,10 @@ class Assignment(CreatedUpdatedMixin, Base):
     )
     auto_grading_config = relationship("AutoGradingConfig")
 
+    checkpoint = relationship(
+        "AssignmentCheckpoint", uselist=False, back_populates="assignment"
+    )
+
     __table_args__ = (
         sa.UniqueConstraint("resource_link_id", "tool_consumer_instance_guid"),
         sa.Index(

lms/models/assignment_checkpoint.py

@@ -29,7 +29,7 @@ class AssignmentCheckpoint(CreatedUpdatedMixin, Base):
     assignment_id: Mapped[int] = mapped_column(
         sa.ForeignKey("assignment.id", ondelete="cascade"), index=True
     )
-    assignment = relationship("Assignment")
+    assignment = relationship("Assignment", back_populates="checkpoint")
 
     reveal_date: Mapped[datetime | None] = mapped_column()
     """When the instructor revealed the assignment; NULL until revealed."""

lms/product/canvas/_plugin/misc.py

@@ -59,14 +59,17 @@ def get_assignment_configuration(
             group_set_id=request.params.get("group_set"),
         )
 
-        if auto_grading_config := self.get_deep_linked_assignment_configuration(
-            request
-        ).get("auto_grading_config"):
+        deep_linked_config = self.get_deep_linked_assignment_configuration(request)
+
+        if auto_grading_config := deep_linked_config.get("auto_grading_config"):
             # Auto grading is a complex structure, deserialize it beforehand
             assignment_config["auto_grading_config"] = cast(
                 "AutoGradingConfig", json.loads(auto_grading_config)
             )
 
+        if deep_linked_config.get("checkpoint_enabled") in ("true", True):
+            assignment_config["checkpoint_enabled"] = True
+
         return assignment_config
 
     @lru_cache(1)  # noqa: B019
@@ -150,6 +153,7 @@ def get_deep_linked_assignment_configuration(self, request) -> dict:
         possible_parameters = [
             "group_set",
             "auto_grading_config",
+            "checkpoint_enabled",
             # VS, legacy method
             "vitalsource_book",
             "book_id",

lms/product/plugin/misc.py

@@ -15,6 +15,7 @@ class AssignmentConfig(TypedDict):
     document_url: str | None
     group_set_id: str | None
     auto_grading_config: NotRequired[AutoGradingConfig | None]
+    checkpoint_enabled: NotRequired[bool]
 
 
 class DeepLinkingPromptForGradableMixin:
@@ -125,6 +126,7 @@ def get_deep_linked_assignment_configuration(self, request) -> dict:
             "group_set",
             "deep_linking_uuid",
             "auto_grading_config",
+            "checkpoint_enabled",
         ]
 
         for param in possible_parameters:
@@ -148,6 +150,9 @@ def _assignment_config_from_assignment(assignment: Assignment) -> AssignmentConf
         if auto_grading_config := assignment.auto_grading_config:
             config["auto_grading_config"] = auto_grading_config.asdict()
 
+        if assignment.checkpoint:
+            config["checkpoint_enabled"] = True
+
         return config
 
     @staticmethod
@@ -163,4 +168,7 @@ def _assignment_config_from_deep_linked_config(
         if auto_grading_config := deep_linked_config.get("auto_grading_config"):
             config["auto_grading_config"] = json.loads(auto_grading_config)
 
+        if deep_linked_config.get("checkpoint_enabled") in ("true", True):
+            config["checkpoint_enabled"] = True
+
         return config

lms/services/assignment.py

@@ -6,6 +6,7 @@
 
 from lms.models import (
     Assignment,
+    AssignmentCheckpoint,
     AssignmentGrouping,
     AssignmentMembership,
     AutoGradingConfig,
@@ -62,6 +63,7 @@ def update_assignment(  # noqa: PLR0913
         group_set_id,
         course: Course,
         auto_grading_config: dict | None = None,
+        checkpoint_enabled: bool = False,
     ):
         """Update an existing assignment."""
         if self._misc_plugin.is_speed_grader_launch(request):
@@ -96,6 +98,7 @@ def update_assignment(  # noqa: PLR0913
 
         assignment.course_id = course.id
         self._update_auto_grading_config(assignment, auto_grading_config)
+        self._update_checkpoint(assignment, checkpoint_enabled)
 
         return assignment
 
@@ -151,6 +154,7 @@ def get_assignment_for_launch(self, request, course: Course) -> Assignment | Non
         document_url = assignment_config.get("document_url")
         group_set_id = assignment_config.get("group_set_id")
         auto_grading_config = assignment_config.get("auto_grading_config")
+        checkpoint_enabled = assignment_config.get("checkpoint_enabled", False)
 
         if not document_url:
             # We can't find a document_url, we shouldn't try to create an
@@ -181,7 +185,13 @@ def get_assignment_for_launch(self, request, course: Course) -> Assignment | Non
         # It often will be the same one while launching the assignment again but
         # it might for example be an updated deep linked URL or similar.
         return self.update_assignment(
-            request, assignment, document_url, group_set_id, course, auto_grading_config
+            request,
+            assignment,
+            document_url,
+            group_set_id,
+            course,
+            auto_grading_config,
+            checkpoint_enabled=checkpoint_enabled,
         )
 
     def upsert_assignment_membership(
@@ -373,6 +383,21 @@ def get_assignment_sections(self, assignment) -> Sequence[Grouping]:
             .order_by(Grouping.lms_name.asc())
         ).all()
 
+    def _update_checkpoint(
+        self, assignment: Assignment, checkpoint_enabled: bool
+    ) -> None:
+        """Create a checkpoint for an assignment if enabled and not already present.
+
+        Checkpoints can only be set at creation time -- once created they
+        are never removed by an edit, and calling this with
+        checkpoint_enabled=False on an assignment that already has a
+        checkpoint is a no-op.
+        """
+        if checkpoint_enabled and not assignment.checkpoint:
+            checkpoint = AssignmentCheckpoint(assignment=assignment)
+            self._db.add(checkpoint)
+            assignment.checkpoint = checkpoint
+
     def _update_auto_grading_config(
         self, assignment: Assignment, auto_grading_config: dict | None
     ) -> None:

lms/services/h_api.py

@@ -217,6 +217,39 @@ def get_annotation_counts(
         )
         return response.json()
 
+    def sync_checkpoints(
+        self,
+        authority: str,
+        checkpoints: list[dict],
+        instructor_username: str | None = None,
+    ) -> None:
+        """Sync checkpoint data to h via the bulk checkpoint endpoint.
+
+        :param authority: The h authority
+        :param checkpoints: List of dicts with group_authority_provided_id,
+            document_uri, and optionally reveal_date
+        :param instructor_username: Optional username of an instructor to set
+            their lms_role in the group memberships
+        """
+        if not checkpoints:
+            return
+
+        payload = {
+            "authority": authority,
+            "checkpoints": checkpoints,
+        }
+        if instructor_username:
+            payload["instructor_username"] = instructor_username
+
+        self._api_request(
+            "POST",
+            path="bulk/checkpoint",
+            body=json.dumps(payload),
+            headers={
+                "Content-Type": "application/json",
+            },
+        )
+
     def _api_request(self, method, path, body=None, headers=None, stream=False):  # noqa: FBT002
         """
         Send any kind of HTTP request to the h API and return the response.

lms/services/lti_h.py

@@ -25,7 +25,12 @@ def __init__(self, _context, request) -> None:
         self._h_api: HAPI = request.find_service(HAPI)
         self._group_info_service = request.find_service(name="group_info")
 
-    def sync(self, groupings: list[Grouping], group_info_params: dict):
+    def sync(
+        self,
+        groupings: list[Grouping],
+        group_info_params: dict,
+        checkpoint_data: dict | None = None,
+    ):
         """
         Sync standard data to h for an LTI launch with the provided groups.
 
@@ -34,6 +39,8 @@ def sync(self, groupings: list[Grouping], group_info_params: dict):
 
         :param groupings: groupings to sync to H
         :param group_info_params: params to add for each in `GroupInfo`
+        :param checkpoint_data: optional dict with document_uri and reveal_date
+            to sync a checkpoint for each grouping
 
         :raise HTTPInternalServerError: if we can't sync to h for any reason
         :raise ApplicationInstanceNotFound: if
@@ -47,6 +54,9 @@ def sync(self, groupings: list[Grouping], group_info_params: dict):
                 grouping=grouping, params=group_info_params
             )
 
+        if checkpoint_data:
+            self._sync_checkpoints(groupings, checkpoint_data)
+
     def _yield_commands(self, groupings):
         # Note! - Syncing a user to `h` currently has an implication for
         # reporting and so billing and will as long as our billing metric is
@@ -77,6 +87,22 @@ def _user_upsert(self, h_user, ref="user_0"):
             ref,
         )
 
+    def _sync_checkpoints(self, groupings: list[Grouping], checkpoint_data: dict):
+        checkpoints = [
+            {
+                "group_authority_provided_id": grouping.authority_provided_id,
+                "document_uri": checkpoint_data["document_uri"],
+                "reveal_date": checkpoint_data.get("reveal_date"),
+            }
+            for grouping in groupings
+        ]
+
+        self._h_api.sync_checkpoints(
+            authority=self._authority,
+            checkpoints=checkpoints,
+            instructor_username=checkpoint_data.get("instructor_username"),
+        )
+
     def _group_upsert(self, grouping, ref):
         return CommandBuilder.group.upsert(
             {

lms/static/scripts/frontend_apps/components/FilePickerApp.tsx

@@ -226,6 +226,9 @@ export default function FilePickerApp({ onSubmit }: FilePickerAppProps) {
     return autoGradingEnabled && enabled ? rest : null;
   }, [autoGradingConfig, autoGradingEnabled]);
 
+  // Whether this assignment should have a checkpoint.
+  const [checkpointEnabled, setCheckpointEnabled] = useState(false);
+
   // Flag indicating if we are editing content that was previously selected.
   const [editingContent, setEditingContent] = useState(false);
   // True if we are editing an existing assignment configuration.
@@ -237,7 +240,8 @@ export default function FilePickerApp({ onSubmit }: FilePickerAppProps) {
     enableGroupConfig ||
     promptForTitle ||
     promptForGradable ||
-    autoGradingEnabled;
+    autoGradingEnabled ||
+    !isEditing; // Always show details for new assignments (checkpoint option)
 
   let currentStep: PickerStep;
   if (editingContent) {
@@ -301,6 +305,7 @@ export default function FilePickerApp({ onSubmit }: FilePickerAppProps) {
         const data: DeepLinkingAPIData = {
           ...deepLinkingAPI.data,
           auto_grading_config: autoGradingConfigToSave,
+          checkpoint_enabled: checkpointEnabled,
           content,
           group_set: groupConfig.useGroupSet ? groupConfig.groupSet : null,
           title,
@@ -328,6 +333,7 @@ export default function FilePickerApp({ onSubmit }: FilePickerAppProps) {
     },
     [
       authToken,
+      checkpointEnabled,
       deepLinkingFields,
       deepLinkingAPI,
       groupConfig.groupSet,
@@ -549,6 +555,27 @@ export default function FilePickerApp({ onSubmit }: FilePickerAppProps) {
                         />
                       </>
                     )}
+                    {!isEditing && (
+                      <>
+                        <div className="sm:col-span-2 border-b" />
+                        <PanelLabel isCurrentStep verticalAlign="center">
+                          Hide &amp; Reveal
+                        </PanelLabel>
+                        <label className="flex items-center gap-x-2">
+                          <input
+                            type="checkbox"
+                            data-testid="checkpoint-enabled"
+                            checked={checkpointEnabled}
+                            onChange={event =>
+                              setCheckpointEnabled(
+                                (event.target as HTMLInputElement).checked,
+                              )
+                            }
+                          />
+                          Enable checkpoint
+                        </label>
+                      </>
+                    )}
                     {enableGroupConfig && (
                       <>
                         <div className="sm:col-span-2 border-b" />
@@ -610,6 +637,7 @@ export default function FilePickerApp({ onSubmit }: FilePickerAppProps) {
                 formFields={formFields}
                 groupSet={groupConfig.useGroupSet ? groupConfig.groupSet : null}
                 autoGradingConfig={autoGradingConfigToSave}
+                checkpointEnabled={checkpointEnabled}
               />
             )
           }

lms/static/scripts/frontend_apps/components/FilePickerFormFields.tsx

@@ -24,6 +24,9 @@ export type FilePickerFormFieldsProps = {
 
   /** Auto-grading configuration for assignments where it is enabled */
   autoGradingConfig: AutoGradingConfig | null;
+
+  /** Whether hide & reveal checkpoint is enabled for this assignment */
+  checkpointEnabled: boolean;
 };
 
 /**
@@ -38,6 +41,7 @@ export default function FilePickerFormFields({
   formFields,
   groupSet,
   autoGradingConfig,
+  checkpointEnabled,
 }: FilePickerFormFieldsProps) {
   return (
     <>
@@ -58,6 +62,9 @@ export default function FilePickerFormFields({
           value={JSON.stringify(autoGradingConfig)}
         />
       )}
+      {checkpointEnabled && (
+        <input type="hidden" name="checkpoint_enabled" value="true" />
+      )}
     </>
   );
 }

lms/validation/_lti_launch_params.py

@@ -185,6 +185,9 @@ class ConfigureAssignmentSchema(_CommonLTILaunchSchema):
     auto_grading_config = fields.Nested(
         AutoGradingConfigSchema, required=False, allow_none=True
     )
+    checkpoint_enabled = fields.Bool(
+        required=False, load_default=False, truthy={"true", "1"}, falsy={"false", "0", ""}
+    )
 
     @pre_load
     def _load_auto_grading_config(self, data, **_kwargs):