189 lines
8.3 KiB
Swift
189 lines
8.3 KiB
Swift
// Views/Dashboard/FollowUpRequestsView.swift
|
|
// ------------------------------------------
|
|
// Displays inspections a director/admin flagged as needing a follow-up, pulled
|
|
// read-only from GET /api/v1/inspections?follow_up_required=true by
|
|
// SyncManager.pullFollowUpRequests().
|
|
//
|
|
// Deliberately built as the twin of ScheduledInspectionsView: a follow-up
|
|
// request is assigned work the inspector must recognise and act on, exactly
|
|
// like a scheduled assignment, so it gets the same two surfaces and the same
|
|
// ownership rules.
|
|
//
|
|
// Two consumers share one FollowUpRow:
|
|
// • FollowUpRequestsCard — VStack card for the Dashboard ScrollView.
|
|
// Presentational only; it reports taps via `onStart` and DashboardStatsView
|
|
// owns the .fullScreenCover on its always-present ScrollView.
|
|
// • MyInspectionsView renders its own "Follow-up Requested" List section
|
|
// inline, reusing FollowUpRow, with the start cover on the enclosing Group.
|
|
// Both self-hide when there are none, and present StartInspectionView with the
|
|
// facility + template preselected AND `parentServerId` set, so the submission
|
|
// lands as a linked re-inspection — the same path CompletedInspectionView's
|
|
// "Start Re-inspection" banner has always used.
|
|
// Both cover owners are views that outlive the rows themselves — submitting the
|
|
// last follow-up empties the @Query while the cover is still up, so a cover
|
|
// owned by the self-hiding card would be torn down with it.
|
|
//
|
|
// The lifecycle stays server-driven: the re-inspection carries
|
|
// `parent_inspection_id` and the server clears `follow_up_required` on arrival.
|
|
// ExecuteInspectionView only invalidates the local cache row;
|
|
// pullFollowUpRequests() re-reads the authoritative state.
|
|
|
|
import SwiftUI
|
|
import SwiftData
|
|
|
|
// MARK: - Start target snapshot
|
|
|
|
/// Plain-value snapshot of the tapped request, used as the `.fullScreenCover`
|
|
/// item instead of the `LocalFollowUpRequest` itself.
|
|
///
|
|
/// The model object is unsafe to hold across the presentation: the cached row is
|
|
/// invalidated while the cover is still on screen — by `fulfillFollowUpRequest()`
|
|
/// the instant Submit is tapped, and deleted by `pullFollowUpRequests()` once the
|
|
/// server stops returning it. Reading a deleted `PersistentModel` traps, and a
|
|
/// `@Query` that empties out would also tear the cover down mid-submit. Copying
|
|
/// the values at tap time removes both hazards. (Same reasoning as
|
|
/// `ScheduledStartTarget`.)
|
|
struct FollowUpStartTarget: Identifiable {
|
|
/// Flagged inspection's `serverId` — the identity for `.fullScreenCover(item:)`
|
|
/// and the `parentServerId` the re-inspection is linked to.
|
|
let id: Int
|
|
let templateServerId: Int
|
|
let facilityServerId: Int
|
|
/// The director's note explaining what the follow-up should address.
|
|
let note: String?
|
|
/// The flagged inspection's answers, JSON-encoded, carried so the
|
|
/// re-inspection can pre-fill from them. Snapshotted here for the same
|
|
/// reason as every other field: the row it came from is invalidated while
|
|
/// the start form is still on screen.
|
|
let parentFormDataJSON: String
|
|
|
|
init(_ request: LocalFollowUpRequest) {
|
|
self.id = request.serverId
|
|
self.templateServerId = request.templateServerId
|
|
self.facilityServerId = request.facilityServerId
|
|
self.note = request.note
|
|
self.parentFormDataJSON = request.parentFormDataJSON
|
|
}
|
|
}
|
|
|
|
// MARK: - Shared row
|
|
|
|
struct FollowUpRow: View {
|
|
let request: LocalFollowUpRequest
|
|
|
|
private var inspectedText: String {
|
|
if let d = request.inspectedOn {
|
|
return d.formatted(date: .abbreviated, time: .omitted)
|
|
}
|
|
return request.inspectionDateString.isEmpty ? "—" : request.inspectionDateString
|
|
}
|
|
|
|
var body: some View {
|
|
HStack(alignment: .top, spacing: 12) {
|
|
Image(systemName: "exclamationmark.arrow.circlepath")
|
|
.font(.title3)
|
|
.foregroundStyle(.orange)
|
|
.padding(.top, 2)
|
|
|
|
VStack(alignment: .leading, spacing: 3) {
|
|
Text(request.templateName.isEmpty ? "Inspection" : request.templateName)
|
|
.font(.callout.bold())
|
|
Text(request.facilityName.isEmpty ? "Facility" : request.facilityName)
|
|
.font(.caption)
|
|
.foregroundStyle(.secondary)
|
|
|
|
HStack(spacing: 8) {
|
|
Text("Follow-up")
|
|
.font(.caption2.bold())
|
|
.padding(.horizontal, 6).padding(.vertical, 2)
|
|
.background(Color.orange.opacity(0.15))
|
|
.foregroundStyle(.orange)
|
|
.clipShape(Capsule())
|
|
Text("Inspected \(inspectedText)")
|
|
.font(.caption2)
|
|
.foregroundStyle(.secondary)
|
|
// The score is usually why the follow-up was raised, so it
|
|
// is the one number worth showing before the tap.
|
|
if let score = request.overallScore {
|
|
Text("· \(String(format: "%.1f%%", score))")
|
|
.font(.caption2)
|
|
.foregroundStyle(score >= 80 ? .green : score >= 60 ? .orange : .red)
|
|
}
|
|
}
|
|
|
|
// Note preview — so the inspector can see there is something to
|
|
// read before committing to the tap. Truncated to one line; the
|
|
// full text is shown on the start screen. Mirrors the
|
|
// instructions preview on ScheduledRow.
|
|
if let note = request.note {
|
|
HStack(alignment: .top, spacing: 4) {
|
|
Image(systemName: "info.circle.fill")
|
|
.font(.caption2)
|
|
.foregroundStyle(.orange)
|
|
Text(note)
|
|
.font(.caption2)
|
|
.foregroundStyle(.secondary)
|
|
.lineLimit(1)
|
|
.truncationMode(.tail)
|
|
}
|
|
.padding(.top, 1)
|
|
}
|
|
}
|
|
|
|
Spacer(minLength: 8)
|
|
|
|
Label("Re-inspect", systemImage: "arrow.uturn.right.circle.fill")
|
|
.font(.caption.bold())
|
|
.foregroundStyle(.white)
|
|
.padding(.horizontal, 10).padding(.vertical, 5)
|
|
.background(Color.orange)
|
|
.clipShape(Capsule())
|
|
}
|
|
.contentShape(Rectangle())
|
|
}
|
|
}
|
|
|
|
// MARK: - Dashboard card (VStack)
|
|
|
|
struct FollowUpRequestsCard: View {
|
|
@Query(sort: \LocalFollowUpRequest.inspectionDateString, order: .forward)
|
|
private var requests: [LocalFollowUpRequest]
|
|
|
|
/// Rows still awaiting action. Filtered in Swift rather than in the @Query
|
|
/// predicate, per CLAUDE.md rule 3. `fulfilledLocally` is set at submit and
|
|
/// cleared by the next pull, so a completed follow-up leaves the card at
|
|
/// once and reappears only if the re-inspection never reached the server.
|
|
private var visible: [LocalFollowUpRequest] {
|
|
requests.filter { !$0.fulfilledLocally }
|
|
}
|
|
|
|
/// Tap handler. The `.fullScreenCover` deliberately lives in the PARENT
|
|
/// (`DashboardStatsView`, on its always-present ScrollView) rather than here,
|
|
/// for the same reason as `ScheduledInspectionsCard`: this card self-hides,
|
|
/// and submitting the last follow-up removes the final row while the cover is
|
|
/// still on screen. Keeping the card purely presentational also keeps the
|
|
/// empty case a true `EmptyView`, so the dashboard stack adds no spacing.
|
|
let onStart: (FollowUpStartTarget) -> Void
|
|
|
|
var body: some View {
|
|
if !visible.isEmpty {
|
|
VStack(alignment: .leading, spacing: 10) {
|
|
Text("FOLLOW-UP REQUESTED")
|
|
.font(.caption.bold())
|
|
.foregroundStyle(.orange)
|
|
.tracking(1)
|
|
|
|
ForEach(visible) { r in
|
|
Button { onStart(FollowUpStartTarget(r)) } label: {
|
|
FollowUpRow(request: r)
|
|
.padding(12)
|
|
.background(Color(.secondarySystemBackground))
|
|
.clipShape(RoundedRectangle(cornerRadius: 12))
|
|
}
|
|
.buttonStyle(.plain)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|