[MBL-19374][S] Add mark as done to To-do screen

Core/Core/Common/CommonUI/InstUI/Utils/SwipeToRemove.swift

@@ -0,0 +1,227 @@
+//
+// This file is part of Canvas.
+// Copyright (C) 2025-present  Instructure, Inc.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+//
+
+import SwiftUI
+
+public extension View {
+
+    /// Adds a swipe-to-remove gesture that reveals an action view when swiping left.
+    ///
+    /// The gesture requires swiping past a threshold to trigger the action.
+    /// Visual and haptic feedback is provided when the threshold is crossed.
+    /// Once the action is triggered, the view remains in the fully revealed position
+    /// and it's the caller's responsibility to remove the cell from the view hierarcy.
+    ///
+    /// - Parameters:
+    ///   - backgroundColor: The background color revealed behind the content during the swipe.
+    ///   - isSwiping: Optional binding that tracks whether a swipe gesture is currently active. Use this to disable scrolling or other gestures while swiping.
+    ///   - onSwipe: Closure called when the swipe action is completed.
+    ///   - label: The view displayed in the revealed area during the swipe.
+    func swipeToRemove<Label: View>(
+        backgroundColor: Color,
+        isSwiping: Binding<Bool>? = nil,
+        onSwipe: @escaping () -> Void,
+        @ViewBuilder label: @escaping () -> Label
+    ) -> some View {
+        modifier(SwipeToRemoveModifier(
+            backgroundColor: backgroundColor,
+            isSwiping: isSwiping,
+            onSwipe: onSwipe,
+            label: label
+        ))
+    }
+}
+
+private struct SwipeToRemoveModifier<Label: View>: ViewModifier {
+    let backgroundColor: Color
+    let isSwiping: Binding<Bool>?
+    let onSwipe: () -> Void
+    let label: () -> Label
+
+    // MARK: - Gesture Properties
+    /// The ratio of cell width that must be swiped to trigger the action (0.8 = 80% of cell width).
+    private let actionThresholdRatio: CGFloat = 0.8
+
+    // MARK: - Layout & Sizing
+    @State private var cellContentOffset: CGFloat = 0
+    @State private var cellWidth: CGFloat = 0
+    @State private var actionViewWidth: CGFloat = 0
+    /// The point based horizontal offset that must be reached by the drag gesture to trigger the action.
+    @State private var actionThreshold: CGFloat = 0
+    @State private var actionViewOffset: CGFloat = 0
+
+    // MARK: - Internal Logic States
+    /// Becomes true, if dragging goes beyond `actionThreshold`. If grad is ended while this is true the swipe action will be performed.
+    @State private var isActionThresholdReached = false
+    /// Becomes true after the action has been invoked to disable further drag gestures
+    @State private var isActionInvoked = false
+    /// Set on first gesture update to determine if we should process this gesture
+    @State private var isStartedAsHorizontalGesture: Bool?
+
+    private let hapticGenerator = UIImpactFeedbackGenerator(style: .medium)
+
+    func body(content: Content) -> some View {
+        ZStack(alignment: .trailing) {
+            swipeBackground
+            content.offset(x: cellContentOffset).clipped()
+        }
+        .onWidthChange { width in
+            cellWidth = width
+            actionThreshold = cellWidth * actionThresholdRatio
+        }
+        .contentShape(Rectangle())
+        // If this is a simple gesture and the cell is a button then swiping won't work
+        .simultaneousGesture(
+            DragGesture()
+                .onChanged(handleDragChanged)
+                .onEnded(handleDragEnded),
+            isEnabled: !isActionInvoked
+        )
+    }
+
+    private var swipeBackground: some View {
+        backgroundColor
+            .overlay(alignment: .trailing) {
+                label()
+                    .onWidthChange { width in
+                        actionViewWidth = width
+                        actionViewOffset = width
+                    }
+                    .offset(x: actionViewOffset)
+            }
+            .animation(.smooth, value: actionViewOffset)
+            .accessibilityHidden(true)
+    }
+
+    // MARK: - Drag In Progress
+
+    private func handleDragChanged(_ value: DragGesture.Value) {
+        if isStartedAsHorizontalGesture == nil {
+            isStartedAsHorizontalGesture = value.translation.isHorizontalSwipe
+        }
+
+        guard isStartedAsHorizontalGesture == true,
+              value.translation.isSwipingLeft
+        else { return }
+
+        isSwiping?.wrappedValue = true
+
+        hapticGenerator.prepare()
+        cellContentOffset = max(value.translation.width, -cellWidth)
+
+        handleActionThresholdCrossing()
+        updateActionViewPosition()
+    }
+
+    private func handleActionThresholdCrossing() {
+        let newIsActionThresholdReached = abs(cellContentOffset) >= actionThreshold
+
+        if newIsActionThresholdReached && !isActionThresholdReached {
+            hapticGenerator.impactOccurred()
+            isActionThresholdReached = true
+            actionViewOffset = cellContentOffset + actionViewWidth
+        } else if !newIsActionThresholdReached && isActionThresholdReached {
+            hapticGenerator.impactOccurred()
+            isActionThresholdReached = false
+            actionViewOffset = 0
+        }
+    }
+
+    private func updateActionViewPosition() {
+        let revealedWidth = abs(cellContentOffset)
+
+        if isActionThresholdReached {
+            actionViewOffset = cellContentOffset + actionViewWidth
+        } else {
+            var transaction = Transaction()
+            transaction.disablesAnimations = true
+            withTransaction(transaction) {
+                if revealedWidth < actionViewWidth {
+                    actionViewOffset = actionViewWidth + cellContentOffset
+                } else {
+                    actionViewOffset = 0
+                }
+            }
+        }
+    }
+
+    // MARK: - Drag Finish
+
+    private func handleDragEnded(_: DragGesture.Value) {
+        defer { isStartedAsHorizontalGesture = nil }
+        guard isStartedAsHorizontalGesture == true else { return }
+
+        isSwiping?.wrappedValue = false
+
+        if isActionThresholdReached {
+            animateToOpenedState()
+            isActionInvoked = true
+            onSwipe()
+        } else {
+            animateToClosedState()
+        }
+    }
+
+    private func animateToOpenedState() {
+        withAnimation(.smooth) {
+            cellContentOffset = -cellWidth
+            actionViewOffset = -cellWidth + actionViewWidth
+        }
+    }
+
+    private func animateToClosedState() {
+        isActionThresholdReached = false
+        withAnimation(.smooth) {
+            cellContentOffset = 0
+            actionViewOffset = actionViewWidth
+        }
+    }
+}
+
+#if DEBUG
+
+#Preview {
+    ScrollView {
+        VStack(spacing: 0) {
+            ForEach(0..<5) { index in
+                VStack(alignment: .leading, spacing: 4) {
+                    Text(verbatim: "Todo Item \(index + 1)")
+                        .font(.headline)
+                    Text(verbatim: "Swipe left to mark as done")
+                        .font(.subheadline)
+                        .foregroundStyle(.secondary)
+                }
+                .frame(maxWidth: .infinity, alignment: .leading)
+                .padding()
+                .background(.backgroundLightest)
+                .swipeToRemove(
+                    backgroundColor: .backgroundSuccess,
+                    onSwipe: {},
+                    label: {
+                        Image(systemName: "checkmark.circle.fill")
+                            .font(.title)
+                            .foregroundStyle(.textLightest)
+                            .paddingStyle(.horizontal, .standard)
+                    }
+                )
+            }
+        }
+    }
+}
+
+#endif

Core/Core/Common/CommonUI/SwiftUIViews/View+MeasuringSize.swift

@@ -82,4 +82,21 @@ extension View {
             binding.wrappedValue = height
         }
     }
+
+    public func onWidthChange(_ perform: @escaping (CGFloat) -> Void) -> some View {
+        onGeometryChange(for: CGFloat.self) { geometry in
+            geometry.size.width
+        } action: { height in
+            perform(height)
+        }
+    }
+
+    public func onWidthChange(update binding: Binding<CGFloat>) -> some View {
+        onGeometryChange(for: CGFloat.self) { geometry in
+            geometry.size.width
+        } action: { height in
+            binding.wrappedValue = height
+        }
+    }
+
 }

Core/Core/Common/Extensions/Foundation/CGSizeExtensions.swift

@@ -18,6 +18,8 @@
 
 import Foundation
 
-public extension CGSize {
-    var isZero: Bool { self == .zero }
+extension CGSize {
+    public var isZero: Bool { self == .zero }
+    public var isSwipingLeft: Bool { width < 0 }
+    public var isHorizontalSwipe: Bool { abs(width) > abs(height) }
 }

Core/Core/Features/Planner/MarkPlannableItemDone.swift

@@ -0,0 +1,89 @@
+//
+// This file is part of Canvas.
+// Copyright (C) 2025-present  Instructure, Inc.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+//
+
+import Foundation
+import CoreData
+
+public struct MarkPlannableItemDone: UseCase {
+    public typealias Model = Plannable
+    public typealias Response = APIPlannerOverride
+
+    public let cacheKey: String? = nil
+    public let scope: Scope
+
+    public let plannableId: String
+    public let plannableType: String
+    public let overrideId: String?
+    public let done: Bool
+
+    public init(
+        plannableId: String,
+        plannableType: String,
+        overrideId: String?,
+        done: Bool
+    ) {
+        self.plannableId = plannableId
+        self.plannableType = plannableType
+        self.overrideId = overrideId
+        self.done = done
+        self.scope = .plannable(id: plannableId)
+    }
+
+    public func makeRequest(environment: AppEnvironment, completionHandler: @escaping RequestCallback) {
+        if let overrideId = overrideId {
+            updateExistingOverride(overrideId: overrideId, environment: environment, completionHandler: completionHandler)
+        } else {
+            createNewOverride(environment: environment, completionHandler: completionHandler)
+        }
+    }
+
+    public func write(response: APIPlannerOverride?, urlResponse: URLResponse?, to client: NSManagedObjectContext) {
+        guard let response = response,
+              let plannable: Plannable = client.fetch(scope: scope).first
+        else {
+            return
+        }
+
+        plannable.plannerOverrideId = response.id.value
+        plannable.isMarkedComplete = done
+    }
+
+    public func reset(context: NSManagedObjectContext) {
+    }
+
+    // MARK: - Private Methods
+
+    private func createNewOverride(environment: AppEnvironment, completionHandler: @escaping RequestCallback) {
+        let request = CreatePlannerOverrideRequest(
+            body: .init(
+                plannable_type: plannableType,
+                plannable_id: plannableId,
+                marked_complete: done
+            )
+        )
+        environment.api.makeRequest(request, callback: completionHandler)
+    }
+
+    private func updateExistingOverride(overrideId: String, environment: AppEnvironment, completionHandler: @escaping RequestCallback) {
+        let request = UpdatePlannerOverrideRequest(
+            overrideId: overrideId,
+            body: .init(marked_complete: done)
+        )
+        environment.api.makeRequest(request, callback: completionHandler)
+    }
+}

Core/Core/Features/Planner/Model/API/APIPlannable.swift

@@ -267,7 +267,7 @@ public struct GetPlannablesRequest: APIRequestable {
 
 // https://canvas.instructure.com/doc/api/planner.html#method.planner_overrides.update
 public struct UpdatePlannerOverrideRequest: APIRequestable {
-    public typealias Response = APINoContent
+    public typealias Response = APIPlannerOverride
     public struct Body: Codable, Equatable {
         let marked_complete: Bool
     }

Core/Core/Features/Planner/Model/CoreData/Plannable.swift

@@ -44,6 +44,14 @@ public final class Plannable: NSManagedObject {
     @NSManaged public var pointsPossibleRaw: NSNumber?
     @NSManaged public var userID: String?
     @NSManaged public var details: String?
+    // MARK: - Planner Override Fields
+    @NSManaged public var plannerOverrideId: String?
+    /// Default value is `false`.
+    @NSManaged public var isMarkedComplete: Bool
+    /// Default value is `false`.
+    @NSManaged public var isSubmitted: Bool
+    // MARK: -
+
     @NSManaged private var discussionCheckpointStepRaw: DiscussionCheckpointStepWrapper?
     public var discussionCheckpointStep: DiscussionCheckpointStep? {
         get { return discussionCheckpointStepRaw?.value } set { discussionCheckpointStepRaw = .init(value: newValue) }
@@ -88,6 +96,9 @@ public final class Plannable: NSManagedObject {
             tag: item.plannable?.sub_assignment_tag,
             requiredReplyCount: item.details?.reply_to_entry_required_count
         )
+        model.plannerOverrideId = item.planner_override?.id.value
+        model.isMarkedComplete = item.planner_override?.marked_complete ?? false
+        model.isSubmitted = item.submissions?.value1?.submitted ?? false
         return model
     }