From dac7e6c597c954e3bd5f5208ff8f33ba245b8c70 Mon Sep 17 00:00:00 2001 From: Nguyen Ngo Date: Thu, 30 Jul 2026 16:16:15 -0400 Subject: [PATCH] Jul 30 - Update iPad - inspector can re-inspect and create follow-up --- JanitorialQC/API/APIClient.swift | 50 +++++ JanitorialQC/API/APIModels.swift | 22 ++ JanitorialQC/CLAUDE.md | 25 ++- JanitorialQC/Info.plist | 5 + JanitorialQC/JanitorialQCApp.swift | 1 + .../Models/LocalFollowUpRequest.swift | 181 ++++++++++++++++ .../Models/LocalScheduledInspection.swift | 12 ++ JanitorialQC/Sync/SyncManager.swift | 60 ++++++ JanitorialQC/Utils/Constants.swift | 2 +- .../Views/Dashboard/DashboardView.swift | 54 ++++- .../Dashboard/ExecuteInspectionView.swift | 29 +++ .../Dashboard/FollowUpRequestsView.swift | 188 ++++++++++++++++ .../Views/Dashboard/MyInspectionsView.swift | 47 +++- .../Dashboard/ScheduledInspectionsView.swift | 6 + .../Views/Dashboard/StartInspectionView.swift | 95 +++++++- .../Inspection/InspectionHistoryView.swift | 203 +++++++++++++++++- 16 files changed, 961 insertions(+), 19 deletions(-) create mode 100644 JanitorialQC/Models/LocalFollowUpRequest.swift create mode 100644 JanitorialQC/Views/Dashboard/FollowUpRequestsView.swift diff --git a/JanitorialQC/API/APIClient.swift b/JanitorialQC/API/APIClient.swift index da1ebbe..c0807b9 100644 --- a/JanitorialQC/API/APIClient.swift +++ b/JanitorialQC/API/APIClient.swift @@ -429,6 +429,56 @@ actor APIClient { return result.scheduled } + /// Plan a follow-up re-inspection of `parentInspectionId` for `dueDate` + /// (phase45) — the deferred twin of "Re-inspect Now" in history detail. + /// + /// Only the parent and the date are sent: the server derives facility, + /// template and assignee from the parent inspection, so a follow-up can + /// only ever target the thing it is a follow-up of. The schedule it creates + /// carries `parent_inspection_id`, which the inspection started from it + /// inherits — that is what makes the eventual run a linked re-inspection. + /// + /// Idempotent server-side: retrying re-dates the existing active follow-up + /// for this parent instead of creating a second one. + /// + /// `dueDate` must be formatted `yyyy-MM-dd`; the server rejects a past date. + func createScheduledFollowUp( + parentInspectionId: Int, + dueDate: String, + notes: String? + ) async throws -> APIScheduledInspection { + var body: [String: Any] = [ + "parent_inspection_id": parentInspectionId, + "due_date": dueDate, + ] + // Raw snake_case body keys — JSONSerialization applies no key strategy + // (rule 65). + if let n = notes?.trimmingCharacters(in: .whitespacesAndNewlines), !n.isEmpty { + body["notes"] = n + } + let result: APIScheduledFollowUpResponseData = try await post( + "/api/v1/scheduled-inspections/follow-up", body: body + ) + return result.scheduled + } + + // ── Follow-up Requests ──────────────────────────────────────────────── + + /// Inspections a director/admin has flagged as needing a follow-up. + /// + /// Same endpoint and response shape as `fetchInspectionHistory`, but with + /// the `follow_up_required` filter so the server returns the complete + /// outstanding set rather than the recent page history shows. The limit is + /// the endpoint's maximum for the same reason — this list drives actionable + /// work, and a follow-up raised on a months-old inspection must still + /// appear. Inspector-scoped server-side. + func fetchFollowUpRequests() async throws -> [APIInspectionSummary] { + let result: InspectionHistoryResponseData = try await request( + "/api/v1/inspections?follow_up_required=true&limit=200" + ) + return result.inspections + } + // ── Issue Handler ("Handled By") ────────────────────────────────────── /// Set who handles an issue. `details` carries any of the optional diff --git a/JanitorialQC/API/APIModels.swift b/JanitorialQC/API/APIModels.swift index 8b3b194..c86dcec 100644 --- a/JanitorialQC/API/APIModels.swift +++ b/JanitorialQC/API/APIModels.swift @@ -658,6 +658,11 @@ struct APIScheduledInspection: Decodable, Identifiable, Sendable { let nextDueDate: String? // ISO date "YYYY-MM-DD" let isOverdue: Bool let notes: String? + /// Set when this schedule is a planned follow-up of a specific inspection + /// (phase45, "Schedule Follow-up"). Carried onto the inspection started + /// from it so the run lands as a linked re-inspection. Nil for an ordinary + /// schedule, and on servers older than phase45. + let parentInspectionId: Int? nonisolated init(from decoder: any Decoder) throws { let c = try decoder.container(keyedBy: CodingKeys.self) @@ -672,10 +677,12 @@ struct APIScheduledInspection: Decodable, Identifiable, Sendable { nextDueDate = try? c.decode(String.self, forKey: .nextDueDate) isOverdue = (try? c.decode(Bool.self, forKey: .isOverdue)) ?? false notes = try? c.decode(String.self, forKey: .notes) + parentInspectionId = try? c.decode(Int.self, forKey: .parentInspectionId) } private enum CodingKeys: String, CodingKey { case id, facilityId, facilityName, templateId, templateName case inspectorId, frequency, frequencyLabel, nextDueDate, isOverdue, notes + case parentInspectionId } } @@ -695,6 +702,21 @@ struct APIScheduledInspectionsResponseData: Decodable, Sendable { private enum CodingKeys: String, CodingKey { case scheduled, total, limit, offset } } +/// Response of `POST /api/v1/scheduled-inspections/follow-up` (phase45). +/// `created` is false when the server re-dated an existing follow-up for the +/// same parent instead of adding a second one. +struct APIScheduledFollowUpResponseData: Decodable, Sendable { + let scheduled: APIScheduledInspection + let created: Bool + + nonisolated init(from decoder: any Decoder) throws { + let c = try decoder.container(keyedBy: CodingKeys.self) + scheduled = try c.decode(APIScheduledInspection.self, forKey: .scheduled) + created = (try? c.decode(Bool.self, forKey: .created)) ?? true + } + private enum CodingKeys: String, CodingKey { case scheduled, created } +} + // ── Dashboard Stats (Phase B) ───────────────────────────────────────────────── struct APIDashboardStats: Decodable, Sendable { diff --git a/JanitorialQC/CLAUDE.md b/JanitorialQC/CLAUDE.md index 41491b7..62b1fe9 100644 --- a/JanitorialQC/CLAUDE.md +++ b/JanitorialQC/CLAUDE.md @@ -195,7 +195,8 @@ PendingPhoto.self, SyncQueueEntry.self | `LocalTemplate` | Cached template + raw JSON schema | `serverId`, `formSchemaJSON`, `formSchema` (computed) | | `LocalInspection` | Inspector-authored inspection record | `localId` (UUID, unique), `serverId`, `status`, `syncStatus`, `formDataJSON`, `followUpRequired`, `parentLocalId`, `parentServerId`, `scheduledInspectionServerId` (Int?, inline default — links the submission to the schedule it fulfils), `submitLatitude` (Double?), `submitLongitude` (Double?) | | `LocalIssue` | Issue record | `localId` (UUID, unique), `serverId`, `inspectionLocalId` (`""` for standalone/server-pulled), `facilityServerId`, `severity`, `syncStatus`, `photoLocalPathsJSON`, `photoServerPathsJSON`, **handler fields** (`handlerType`, `handlerLabel`, `facilityHandler*`, `vendor*` — all optional, synced from server, inspector-editable) | -| `LocalScheduledInspection` | Read-only cached scheduled/recurring assignment (phase36) | `serverId` (`@Attribute(.unique)`, **no default** — rule 63), `facilityServerId`, `facilityName`, `templateServerId`, `templateName`, `inspectorId`, `frequency`, `frequencyLabel`, `dueDateString` (sort key), `isOverdue`, `nextDue` (computed). Pulled by `pullScheduledInspections()`; `init(from:)`/`update(from:)` like `LocalFacility` | +| `LocalScheduledInspection` | Read-only cached scheduled/recurring assignment (phase36) | `serverId` (`@Attribute(.unique)`, **no default** — rule 63), `facilityServerId`, `facilityName`, `templateServerId`, `templateName`, `inspectorId`, `frequency`, `frequencyLabel`, `dueDateString` (sort key), `isOverdue`, `nextDue` (computed), `parentInspectionServerId` (`Int?`, phase45 — set when the schedule is a planned follow-up; becomes the run's `parentServerId`). Pulled by `pullScheduledInspections()`; `init(from:)`/`update(from:)` like `LocalFacility` | +| `LocalFollowUpRequest` | Read-only cached follow-up request raised on the web (July 2026) | `serverId` (`@Attribute(.unique)`, **no default** — rule 63; this is the *flagged parent* inspection's id and the `parentServerId` the re-inspection links to), `facilityServerId`, `facilityName`, `templateServerId`, `templateName`, `overallScore`, `inspectionDateString` (sort key), `followUpNote`, `note` (computed, trimmed/nil-ed), `inspectedOn` (computed, parses the `yyyy-MM-dd` prefix only — see the file comment), `fulfilledLocally` (`= false`, rule 71), `parentFormDataJSON` (`= "{}"`, the parent's answers cached for re-inspection prefill — rule 79), `parentFormData` (computed). Pulled by `pullFollowUpRequests()` | | `PendingPhoto` | Photo awaiting upload | `localId`, `localFilePath`, `serverPath`, `uploadStatus`, `entityType` (`"issue"` or `"inspection"`), `fieldId` | | `SyncQueueEntry` | Outbox entry (informational) | `entityType`, `localId`, `syncStatus`, `payloadJSON` | @@ -252,7 +253,9 @@ guard isOnline, let context = modelContext, AuthManager.shared.isAuthenticated e 5. **`pullAssignedIssues`** — fetches `GET /api/v1/issues`. Merges `api.photoPath` + `api.mobilePhotoPaths` into `photoServerPaths`. **Does NOT include `api.resultPhotos`** — resolution photos are web-only. Deletion pass runs always (not short-circuited on empty response). -6. **`pollNotifications`** — fetches new notifications since `lastNotificationFetch` cursor. +6. **`pullFollowUpRequests`** — fetches `GET /api/v1/inspections?follow_up_required=true`. Upserts `LocalFollowUpRequest` by `serverId`, deletes rows the server no longer returns, and mirrors `followUpRequired`/`followUpNote` onto the matching `LocalInspection` so the history badge agrees with the card. Best-effort — never blocks the pipeline. Runs after `processInspectionQueue`, so the section clears on the same sync that submits the re-inspection. + +7. **`pollNotifications`** — fetches new notifications since `lastNotificationFetch` cursor. ### Server-pulled issue identification @@ -310,6 +313,8 @@ All server URLs built as: `ServerConfig.current + endpoint` — **`Constants.bas | `fetchNotifications` | `GET /api/v1/notifications` | Optional `since: Date` cursor | | `markNotificationsRead` | `PATCH /api/v1/notifications/mark-read` | Marks IDs read on server | | `fetchScheduledInspections` | `GET /api/v1/scheduled-inspections` | Active scheduled assignments; inspector-scoped server-side. Pulled into `LocalScheduledInspection` | +| `createScheduledFollowUp` | `POST /api/v1/scheduled-inspections/follow-up` | Plans a follow-up re-inspection for a later date (phase45). Body is only `parent_inspection_id` + `due_date` (`yyyy-MM-dd`) + optional `notes` — the server derives facility/template/assignee from the parent. Idempotent: a retry re-dates the existing active follow-up. Inspector-writable (deliberate divergence — the web is `@project_manager_required`). Online-only; see rule 80 | +| `fetchFollowUpRequests` | `GET /api/v1/inspections?follow_up_required=true&limit=200` | Outstanding follow-up requests; same response shape as `fetchInspectionHistory`. Limit is the endpoint max on purpose — a follow-up raised on a months-old inspection must still appear. Pulled into `LocalFollowUpRequest`. See rule 78 for what the server-side filter must mean | | `updateIssueHandler` | `PATCH /api/v1/issues//handler` | Sets "Handled By". Body `["handler_type": …]` + optional snake_case detail keys (rule 65). Inspector-writable (server scopes by facility) | ### `APIAssignedIssue` fields @@ -467,6 +472,19 @@ else { continue } `CompletedInspectionView` shows orange banner with **Start Re-inspection** when `followUpRequired == true`. Opens `StartInspectionView` with `preFillTemplateId`, `preFillFacilityId`, `parentServerId`, `parentLocalId`. +The **Follow-up Requested** card / section (July 2026) is the second trigger, and reaches the same view with `parentServerId` plus `preFillFollowUpNote` and `preFillParentFormDataJSON`. + +**History detail** (`HistoryDetailView`) is the third and fourth: a **Re-inspect Now** toolbar button (immediate, passing this response's own answers as `preFillParentFormDataJSON` — history is served from the API, so the parent is usually not local) and **Schedule Follow-up**, which plans it for a later date via `createScheduledFollowUp`. The scheduled row then starts as a linked re-inspection because it carries `parentInspectionServerId`. See rule 80. + +### Parent pre-fill — two sources + +`StartInspectionView.startInspection()` copies the parent's answers forward, excluding `rating`, `pass_fail`, `image`, `signature` so every scoreable item is re-evaluated fresh and the parent's photos stay with the parent. This mirrors the web's `inspections.execute` prefill. + +`resolvedParentFormData()` resolves the source in order: + +1. The local `LocalInspection` with a matching `serverId` — the `CompletedInspectionView` path, where the inspector just finished it on this iPad. Used only when it actually holds values, so an empty local shell can't shadow source 2. +2. `preFillParentFormDataJSON` — snapshotted from the server onto `LocalFollowUpRequest.parentFormDataJSON` at pull time. This is the follow-up-request path. See rule 79. + ### followUpRequired clearing — three points 1. Immediately on Submit in `ExecuteInspectionView.submitInspection()` via `clearParentFollowUpFlag()`. @@ -706,6 +724,9 @@ Deletes `LocalIssue` where `serverId != nil`. Preserves `serverId == nil` record | 75 | **A background launch has no ContentView and may have no ModelContainer** | `restoreSession()` runs from `ContentView.task{}` and the container comes from the `.modelContainer` scene modifier — neither happens on a cold BGTaskScheduler launch, so `triggerSync()`'s `isAuthenticated` / `modelContext` guards silently no-op. `handleBackgroundSync()` now restores the session itself and logs-and-returns when there is no context. Background sync therefore covers the *suspended-but-resident* case; cold relaunch needs the container hoisted out of the scene modifier. | | 76 | **A collapsed `NavigationSplitView` shows only its sidebar — Button-driven rows navigate nowhere on iPhone** | On compact width the split view collapses to a stack rooted at the sidebar, and the `detail:` column is presented only when something *pushes* it. Rule 2 forbids a `selection:` binding, so the rows are plain `Button`s that mutate `@State` — and a state change alone cannot push the detail column. The app installs on iPhone (`TARGETED_DEVICE_FAMILY = "1,2"`), so every inspector on a phone got a list where tapping highlighted the row and opened nothing: Dashboard, Inspections, Issues, Settings were all unreachable. Verified in the simulator: setting `selectedTab` programmatically still rendered only the sidebar. `DashboardView` now branches on `horizontalSizeClass` and gives compact width a real `NavigationStack` with `NavigationLink` rows. Never "fix" this by adding a `selection:` binding — that breaks iPadOS 17 (rule 2). | | 77 | **The 12-column form grid is unusable below ~600 pt — reflow to one field per line, don't shrink it** | `GridFormView` positions cells absolutely from `cellW = (W - 32 - 88) / 12`. At 375 pt (iPhone SE/6/7/8) that is a 21 pt column and a 15 pt row, so an ordinary 6x2 field renders ~167x35 pt — less than the label needs. Cells are deliberately unclipped (matching the web's `overflow: visible`), so the excess draws *on top of* the row below and the form becomes an unreadable pile of overlapping controls. Below `GridFormView.minGridWidth` (600 pt, keeping a column at >=40 pt) the view switches to `stackedLayout`: fields sorted by `(row, col)` (rule 62), one per line, full width, natural height. Widgets with no intrinsic height (`textarea`, `signature`, `table`, `image`) get floors from `stackedMinH` or they collapse to nothing. In the stacked branch the card must be a `.background` modifier, **not** a `ZStack` sibling — as a sibling the flexible `RoundedRectangle` competes with the `VStack` for the container's size and the card ends up shorter than its own content, cutting off the last fields. `ReadOnlyGridFormView` (history detail) has the same 12-column assumption and the same compact branch, keyed off `horizontalSizeClass`. | +| 78 | **"Outstanding follow-up" is three conditions, not one — `follow_up_required` alone is not the definition** | Every web surface (`inspections.list` / `reports` `status_filter == 'follow_up'`, `stats.pending_followups`) means **flagged AND `status == 'completed'` AND `~follow_ups.any()`**. The reason the third clause exists: the **web execute route never clears `follow_up_required` on the parent** — it only stops *listing* the parent once a child re-inspection exists. (The mobile POST path *does* clear the parent flag, `app/api/inspections.py`, so only web-completed re-inspections leave a stale flag.) The first cut of the API's `?follow_up_required=true` filter matched the flag alone, which would have returned follow-ups already satisfied on the web — and on the iPad those rows are **undismissable**: `pullFollowUpRequests()` keeps receiving them, `update(from:)` deliberately resets `fulfilledLocally = false` (the server is authoritative), so FOLLOW-UP REQUESTED would never clear and the only way out is a duplicate re-inspection. Fixed server-side so one definition serves every client. Never re-narrow this filter to the bare flag, and never "fix" a stuck row on the client — `fulfilledLocally` is a display flag, not state. | +| 79 | **A re-inspection's parent is usually NOT on the device — prefill must fall back to the cached snapshot, and never prefill without the template schema** | `startInspection()`'s prefill originally matched only a local `LocalInspection` by `serverId`. That works for `CompletedInspectionView` (the inspector just finished it here) but **not for a follow-up raised on the web**: that parent synced long ago and is routinely absent (reinstall, second iPad, follow-up raised weeks later — the same premise `LocalFollowUpRequest` exists for). The lookup found nothing, the whole block silently no-opped, and the form opened blank where the web pre-fills it. Fix: `LocalFollowUpRequest.parentFormDataJSON` caches the parent's answers at pull time — free, because `GET /api/v1/inspections` already returns `form_data` on every row via `_inspection_payload`, so there is no extra request and prefill works offline. Store `formDataRaw.mapValues(\.anyValue)`, **not** `formValues`: the latter joins arrays into `"a, b"`, which would be written back as one bogus string. Second trap, only reachable once prefill actually runs: the exclude set is derived from the template schema, so an unresolved schema (`?? []`) yields **no exclusions and copies everything** — including the parent's `image` paths, attaching its photos as this inspection's evidence. Guard on `!schema.isEmpty` and copy nothing instead. | +| 80 | **"Schedule Follow-up" is a server-side plan — it is the one action in the app that cannot work offline, and its link must survive the client forgetting it** | History detail (`HistoryDetailView`) carries three toolbar actions: **Re-inspect Now** (immediate, opens the linked re-inspection), **Schedule Follow-up** (deferred), and the existing email button. Starting an inspection writes locally and syncs later, but scheduling writes a `ScheduledInspection` row that only the server can create — there is no local record to queue, so the button is `.disabled(!sync.isOnline)` and failures report inline instead of dismissing as though they worked. Do not "fix" this by faking a local schedule: `pullScheduledInspections()` deletes any row the server doesn't return, so it would vanish on the next sync. The link itself is `scheduled_inspections.parent_inspection_id` (phase45): both start paths inherit it onto the inspection (`ScheduledStartTarget.parentServerId` on iPad, the web's `scheduled_inspections.start`), **and** the API's create-inspection endpoint re-derives it from the schedule when the client sends none — a belt-and-braces step that matters because an older build or a resumed draft would otherwise submit a plain inspection and leave the parent flagged forever. Creation is inspector-writable, a deliberate divergence from the web's `@project_manager_required`, and the endpoint is deliberately narrow: it takes only a parent + date and derives facility/template/assignee, so a follow-up can only ever target the thing it follows up on. | --- diff --git a/JanitorialQC/Info.plist b/JanitorialQC/Info.plist index b9ecf73..ba2eaea 100644 --- a/JanitorialQC/Info.plist +++ b/JanitorialQC/Info.plist @@ -17,6 +17,11 @@ com.jqc.sync + NSAppTransportSecurity + + NSAllowsArbitraryLoads + + UIBackgroundModes processing diff --git a/JanitorialQC/JanitorialQCApp.swift b/JanitorialQC/JanitorialQCApp.swift index ebd886b..972da88 100644 --- a/JanitorialQC/JanitorialQCApp.swift +++ b/JanitorialQC/JanitorialQCApp.swift @@ -101,6 +101,7 @@ struct JanitorialQCApp: App { LocalInspection.self, LocalIssue.self, LocalScheduledInspection.self, + LocalFollowUpRequest.self, PendingPhoto.self, SyncQueueEntry.self, ], isUndoEnabled: false) { result in diff --git a/JanitorialQC/Models/LocalFollowUpRequest.swift b/JanitorialQC/Models/LocalFollowUpRequest.swift new file mode 100644 index 0000000..c31c9e9 --- /dev/null +++ b/JanitorialQC/Models/LocalFollowUpRequest.swift @@ -0,0 +1,181 @@ +// Models/LocalFollowUpRequest.swift +// --------------------------------- +// SwiftData model for follow-up requests raised by a director/admin on the web +// app against an inspection this inspector already completed. +// +// Read-only reference data pulled from the server +// (GET /api/v1/inspections?follow_up_required=true) and refreshed by +// SyncManager.pullFollowUpRequests() — never created or mutated on device. +// Surfaced in the "Follow-up Requested" section on the Dashboard and My +// Inspections. Tapping "Re-inspect" opens the normal new-inspection flow with +// the facility + template preselected and `parentServerId` set, so the +// submission lands as a linked re-inspection. +// +// WHY THIS EXISTS AS ITS OWN CACHE, rather than reading followUpRequired off +// LocalInspection: the flag is set on the WEB, after the inspection has already +// synced. By then the local copy either shows `status == "synced"` (filtered out +// of every My Inspections @Query) or is not on this device at all — a reinstall, +// a second iPad, or a follow-up raised weeks later all leave nothing to badge. +// The request has to be pulled as its own work item to be actionable. +// +// Follows LocalScheduledInspection field-for-field: a `.unique` serverId WITHOUT +// an inline default (a default on the unique key breaks @Model's PersistentModel +// conformance) and a full init(from:)/update(from:) pair. + +import Foundation +import SwiftData + +@Model +final class LocalFollowUpRequest { + + /// Server ID of the flagged (parent) Inspection — stable unique identity, + /// and the value passed as `parentServerId` when the re-inspection starts. + @Attribute(.unique) var serverId: Int + + var facilityServerId: Int + var facilityName: String + var templateServerId: Int + var templateName: String + + /// Score the flagged inspection came back with, when it has one. Shown on + /// the row: the reason a follow-up was raised is usually the low score. + var overallScore: Double? + + /// Raw server date string of the original inspection — sortable (ISO strings + /// sort chronologically) and the source for the parsed `inspectedOn`. + var inspectionDateString: String + + /// The director's note explaining what the follow-up should address. + /// Stored raw; read through `note` for the normalised form. + var followUpNote: String? + + /// Set on device the moment a re-inspection of this request is submitted, so + /// the FOLLOW-UP REQUESTED lists hide the row immediately — online or + /// offline — without waiting for the round trip. + /// + /// Purely a display flag, and the exact counterpart of + /// `LocalScheduledInspection.fulfilledLocally` (see that file for the full + /// rationale). The lifecycle stays server-driven: the server clears + /// `follow_up_required` when the linked re-inspection arrives, the next pull + /// stops returning the row, and it is deleted. If the submission never + /// lands, the server still reports the flag and the row comes back — + /// self-healing. + /// + /// Non-optional with an inline default, so SwiftData migrates lightweight + /// (CLAUDE.md rule 12): existing rows read as `false`, no app reinstall. + var fulfilledLocally: Bool = false + + /// The flagged inspection's answers, JSON-encoded `[String: String]`, cached + /// so the re-inspection can pre-fill from them. + /// + /// WHY CACHED HERE rather than read from the parent at start time: the + /// parent `LocalInspection` is usually **not on this device**. A follow-up is + /// raised on the web after the inspection already synced, so by then the + /// local copy may be long gone (reinstall, a second iPad, a follow-up raised + /// weeks later) — the same reason this model exists at all. The prefill in + /// `StartInspectionView` matched on a local parent only, found nothing, and + /// silently produced a blank form, unlike the web. + /// + /// Free to carry: `GET /api/v1/inspections` already returns `form_data` on + /// every row (`_inspection_payload`), so this costs no extra request and the + /// prefill works offline — the values are captured at pull time. + /// + /// Non-optional with an inline default so SwiftData migrates lightweight + /// (CLAUDE.md rule 12); `"{}"` decodes to an empty dictionary. + var parentFormDataJSON: String = "{}" + + /// Last time this row was refreshed from the server pull. + var updatedAt: Date + + /// The follow-up note, normalised: nil for nil, empty, or whitespace-only + /// text so callers can guard with a single `if let` instead of repeating the + /// emptiness check. Computed, not stored — no SwiftData schema change. + var note: String? { + guard let t = followUpNote?.trimmingCharacters(in: .whitespacesAndNewlines), + !t.isEmpty + else { return nil } + return t + } + + /// Parsed inspection date for display. Computed properties are not persisted + /// by SwiftData; sort on `inspectionDateString` (not this) in @Query. + /// + /// Parses the leading `yyyy-MM-dd` rather than the whole timestamp on + /// purpose. `SyncManager.isoFormatter` is fixed at `yyyy-MM-dd'T'HH:mm:ss` + /// and returns nil the moment the server includes fractional seconds — + /// which it does whenever the column carries microseconds (SQLite keeps + /// them; MySQL truncates by default), so the same field parses on one + /// deployment and not another. Only the day is displayed here, so taking the + /// date prefix sidesteps the whole variation. + var inspectedOn: Date? { + guard inspectionDateString.count >= 10 else { return nil } + return Self.dateOnlyFormatter.date(from: String(inspectionDateString.prefix(10))) + } + + private static let dateOnlyFormatter: DateFormatter = { + let f = DateFormatter() + f.locale = Locale(identifier: "en_US_POSIX") + f.dateFormat = "yyyy-MM-dd" + return f + }() + + init(from api: APIInspectionSummary) { + self.serverId = api.id + self.facilityServerId = api.facilityId + self.facilityName = api.facilityName + self.templateServerId = api.templateId + self.templateName = api.templateName + self.overallScore = api.overallScore + self.inspectionDateString = api.inspectionDate ?? "" + self.followUpNote = api.followUpNote + self.fulfilledLocally = false + self.parentFormDataJSON = Self.encode(api) + self.updatedAt = Date() + } + + /// Serialise the parent's answers for storage. + /// + /// Uses the raw `formDataRaw` values rather than the flattened `formValues` + /// so the structure survives the round trip exactly as the web's prefill + /// copies it — an array field stays an array instead of being joined into + /// `"a, b"`, which would be written back as a single bogus string. + /// `JSONValue.anyValue` yields only JSON-serialisable types (NSNull for + /// null), so `JSONSerialization` accepts the result. + /// + /// Returns `"{}"` on failure so the property is always valid JSON and + /// `parentFormData` can decode it without a special case. + private static func encode(_ api: APIInspectionSummary) -> String { + let raw = api.formDataRaw.mapValues(\.anyValue) + guard JSONSerialization.isValidJSONObject(raw), + let data = try? JSONSerialization.data(withJSONObject: raw), + let str = String(data: data, encoding: .utf8) + else { return "{}" } + return str + } + + /// The flagged inspection's answers, decoded for prefill. Typed `[String: Any]` + /// to match `LocalInspection.formData`, which is what the value is copied into. + var parentFormData: [String: Any] { + guard let data = parentFormDataJSON.data(using: .utf8), + let dict = try? JSONSerialization.jsonObject(with: data) as? [String: Any] + else { return [:] } + return dict + } + + func update(from api: APIInspectionSummary) { + self.facilityServerId = api.facilityId + self.facilityName = api.facilityName + self.templateServerId = api.templateId + self.templateName = api.templateName + self.overallScore = api.overallScore + self.inspectionDateString = api.inspectionDate ?? "" + self.followUpNote = api.followUpNote + self.parentFormDataJSON = Self.encode(api) + // The server is authoritative. Being returned by the pull at all means + // the follow-up is still outstanding, so any local "just did it" flag is + // stale by definition — a re-inspection that never synced, or one the + // server rejected. + self.fulfilledLocally = false + self.updatedAt = Date() + } +} diff --git a/JanitorialQC/Models/LocalScheduledInspection.swift b/JanitorialQC/Models/LocalScheduledInspection.swift index 38f6d39..82ca14c 100644 --- a/JanitorialQC/Models/LocalScheduledInspection.swift +++ b/JanitorialQC/Models/LocalScheduledInspection.swift @@ -38,6 +38,16 @@ final class LocalScheduledInspection { var isOverdue: Bool var notes: String? + /// Server ID of the inspection this schedule is a planned follow-up of + /// (phase45). Carried onto the `LocalInspection` as `parentServerId` when + /// the inspector starts it, so the run lands as a linked re-inspection + /// rather than an ordinary scheduled one. + /// + /// Optional, so SwiftData migrates lightweight without a plan (rule 46); + /// nil for an ordinary schedule and for every row pulled from a + /// pre-phase45 server. + var parentInspectionServerId: Int? + /// Set on device the moment an inspection fulfilling this schedule is /// submitted, so the SCHEDULED lists hide the row immediately — online or /// offline — without waiting for the round trip. @@ -105,6 +115,7 @@ final class LocalScheduledInspection { self.dueDateString = api.nextDueDate ?? "" self.isOverdue = api.isOverdue self.notes = api.notes + self.parentInspectionServerId = api.parentInspectionId self.fulfilledLocally = false self.updatedAt = Date() } @@ -120,6 +131,7 @@ final class LocalScheduledInspection { self.dueDateString = api.nextDueDate ?? "" self.isOverdue = api.isOverdue self.notes = api.notes + self.parentInspectionServerId = api.parentInspectionId // The server is authoritative. Being returned by the pull at all means // this schedule is live again — for a recurring one, on its NEXT // occurrence — so any local "just did it" flag is stale by definition. diff --git a/JanitorialQC/Sync/SyncManager.swift b/JanitorialQC/Sync/SyncManager.swift index f959269..7484bb2 100644 --- a/JanitorialQC/Sync/SyncManager.swift +++ b/JanitorialQC/Sync/SyncManager.swift @@ -278,6 +278,7 @@ class SyncManager: ObservableObject { await pullReferenceData() await pullAssignedIssues(context: context) await pullScheduledInspections(context: context) + await pullFollowUpRequests(context: context) // Poll notifications immediately on every sync rather than waiting // for the 60-second timer — ensures the inspector sees assignments @@ -918,6 +919,65 @@ class SyncManager: ObservableObject { } } + // ── Follow-up Requests ──────────────────────────────────────────────── + // Read-only pull of inspections a director flagged for follow-up, for the + // Dashboard and My Inspections "Follow-up Requested" section. Upsert by + // serverId, then delete rows the server no longer returns (the follow-up was + // fulfilled by a linked re-inspection, or the director cleared the flag). + // Best-effort — never blocks the pipeline. + + func pullFollowUpRequests(context: ModelContext) async { + guard isOnline, AuthManager.shared.isAuthenticated else { return } + do { + let apiRows = try await APIClient.shared.fetchFollowUpRequests() + + // Fetch-all + filter/map in Swift — no #Predicate (CLAUDE.md rule 3). + let allLocal = (try? context.fetch(FetchDescriptor())) ?? [] + var byServerId: [Int: LocalFollowUpRequest] = [:] + for row in allLocal { byServerId[row.serverId] = row } + + for api in apiRows { + if let existing = byServerId[api.id] { + existing.update(from: api) + } else { + context.insert(LocalFollowUpRequest(from: api)) + } + } + + // Delete rows the server no longer returns. + let returnedIds = Set(apiRows.map { $0.id }) + for row in allLocal where !returnedIds.contains(row.serverId) { + context.delete(row) + } + + // Keep the local copy of the flagged inspection in step, so the + // follow-up badge in My Inspections / history detail agrees with the + // card without waiting for the inspector to open that detail view + // (which was previously the only thing that wrote these fields). + var noteByServerId: [Int: String] = [:] + for api in apiRows { + if let note = api.followUpNote { noteByServerId[api.id] = note } + } + for local in (try? context.fetch(FetchDescriptor())) ?? [] { + guard let sid = local.serverId else { continue } + if returnedIds.contains(sid) { + local.followUpRequired = true + local.followUpNote = noteByServerId[sid] + } else if local.followUpRequired { + local.followUpRequired = false + local.followUpNote = nil + } + } + + try? context.save() + + } catch APIError.notAuthenticated { + // Let AuthManager handle session expiry + } catch { + // Non-fatal — stale follow-up rows stay visible until next pull + } + } + // ── Dashboard Stats ─────────────────────────────────────────────────── // Best-effort fetch — a network failure silently leaves dashboardStats nil // so the UI falls back to a placeholder card. Never blocks the sync pipeline. diff --git a/JanitorialQC/Utils/Constants.swift b/JanitorialQC/Utils/Constants.swift index 371d0fc..529d711 100644 --- a/JanitorialQC/Utils/Constants.swift +++ b/JanitorialQC/Utils/Constants.swift @@ -8,7 +8,7 @@ import Foundation /// The two known JQC servers the inspector can connect to. nonisolated enum ServerOption: String, CaseIterable, Sendable { - case primary = "https://jqc.ltservicesinc.com" + case primary = "http://127.0.0.1:5055" case secondary = "https://jqc1.ltservicesinc.com" var displayName: String { diff --git a/JanitorialQC/Views/Dashboard/DashboardView.swift b/JanitorialQC/Views/Dashboard/DashboardView.swift index ef16b1d..cda6f8b 100644 --- a/JanitorialQC/Views/Dashboard/DashboardView.swift +++ b/JanitorialQC/Views/Dashboard/DashboardView.swift @@ -42,6 +42,19 @@ struct DashboardView: View { order: .reverse ) private var myInspections: [LocalInspection] + /// Outstanding follow-up requests, counted into the My Inspections badge so + /// the inspector sees there is work waiting from any tab — the same reason + /// in-progress inspections are counted there. + @Query private var followUpRequests: [LocalFollowUpRequest] + + /// Badge count for My Inspections: in-progress work plus outstanding + /// follow-ups. `fulfilledLocally` rows are excluded in Swift, not in the + /// @Query predicate (CLAUDE.md rule 3), so the badge drops the instant a + /// re-inspection is submitted. + private var myInspectionsBadgeCount: Int { + myInspections.count + followUpRequests.filter { !$0.fulfilledLocally }.count + } + @State private var selectedTab: SidebarTab = .dashboard /// Each sidebar tap refreshes the UUID for that tab, forcing its /// NavigationStack to be destroyed and recreated — even when the tab @@ -181,8 +194,8 @@ struct DashboardView: View { Label("My Inspections", systemImage: "checklist") .foregroundStyle(tint) Spacer() - if !myInspections.isEmpty { - Text("\(myInspections.count)") + if myInspectionsBadgeCount > 0 { + Text("\(myInspectionsBadgeCount)") .font(.caption2) .padding(.horizontal, 6).padding(.vertical, 2) .background(Color.blue.opacity(0.15)) @@ -332,6 +345,10 @@ struct DashboardStatsView: View { /// inspection empties its @Query while the start form is still presented. @State private var scheduledStartTarget: ScheduledStartTarget? = nil + /// The follow-up request tapped in FollowUpRequestsCard. Held here for the + /// same reason as `scheduledStartTarget` — see the covers at the bottom. + @State private var followUpStartTarget: FollowUpStartTarget? = nil + var body: some View { ScrollView { VStack(alignment: .leading, spacing: 20) { @@ -341,6 +358,15 @@ struct DashboardStatsView: View { DraftResumeBanner(drafts: draftInspections, context: context) } + // ── Follow-up Requests ───────────────────────────────────── + // Re-inspections a director asked for. Ranked above SCHEDULED: + // a follow-up is remedial work on a facility that already failed + // once, so it is the more urgent of the two. Self-hides when + // there are none. Tap a row to start the linked re-inspection. + FollowUpRequestsCard(onStart: { target in + followUpStartTarget = target + }) + // ── Scheduled Inspections (phase36) ──────────────────────── // Planned/recurring assignments for this inspector. Self-hides // when there are none. Tap a row to start it (facility + @@ -484,10 +510,34 @@ struct DashboardStatsView: View { StartInspectionView( preFillTemplateId: t.templateServerId, preFillFacilityId: t.facilityServerId, + // phase45 — nil for an ordinary schedule; set when this row is a + // planned follow-up, which makes the run a linked re-inspection. + // Must precede preFillScheduleId: argument order follows the + // property declaration order in StartInspectionView. + parentServerId: t.parentServerId, preFillScheduleId: t.id, preFillScheduleInstructions: t.instructions ) } + // Start cover for a tapped follow-up request. Owned here for the same + // reason as the scheduled cover above: FollowUpRequestsCard self-hides + // the instant its last row is invalidated at submit, which is exactly + // when this cover is on screen. + // + // `parentServerId` is what makes this a re-inspection rather than a + // fresh one — the server reads it to clear follow_up_required on the + // flagged inspection. `parentLocalId` stays nil: the parent synced long + // ago (that is how it got flagged), so serverId is the reliable handle, + // and clearParentFollowUpFlag()'s fallback-1 matches on it. + .fullScreenCover(item: $followUpStartTarget) { t in + StartInspectionView( + preFillTemplateId: t.templateServerId, + preFillFacilityId: t.facilityServerId, + parentServerId: t.id, + preFillFollowUpNote: t.note, + preFillParentFormDataJSON: t.parentFormDataJSON + ) + } } // ── Helpers ──────────────────────────────────────────────────────────── diff --git a/JanitorialQC/Views/Dashboard/ExecuteInspectionView.swift b/JanitorialQC/Views/Dashboard/ExecuteInspectionView.swift index be25f0e..24ea0bb 100644 --- a/JanitorialQC/Views/Dashboard/ExecuteInspectionView.swift +++ b/JanitorialQC/Views/Dashboard/ExecuteInspectionView.swift @@ -648,6 +648,13 @@ struct ExecuteInspectionView: View { // regardless of connectivity or sync timing. clearParentFollowUpFlag() + // ── Drop the cached follow-up request row ───────────────────────── + // Same immediacy as above, for the other surface: the FOLLOW-UP + // REQUESTED card on the Dashboard and My Inspections reads its own + // pulled cache, not LocalInspection, so clearing the flag above is not + // enough to make the row disappear. + fulfillFollowUpRequest() + // ── Fulfil the originating scheduled inspection ─────────────────── // Two jobs, both mirroring the web app's execute route: // 1. Make sure the submission carries scheduled_inspection_id, even @@ -719,6 +726,28 @@ struct ExecuteInspectionView: View { } } + /// Invalidate the cached follow-up request this submission satisfies, so the + /// FOLLOW-UP REQUESTED card and section clear the moment Submit is tapped — + /// online or offline — rather than waiting for the round trip. + /// + /// Matches on `parentServerId` alone. Unlike the schedule fallback there is + /// no facility+template guess here: a request is keyed by the exact + /// inspection it was raised against, and that id is set whenever the run was + /// launched from a follow-up row or from CompletedInspectionView's banner. + /// An ad-hoc inspection of the same facility is genuinely not the follow-up + /// the director asked for, and must not clear it. + /// + /// The row is flagged, not deleted, for the same reason as + /// `LocalScheduledInspection.fulfilledLocally`: the server is authoritative, + /// and `pullFollowUpRequests()` deletes the row once the flag actually + /// clears — or brings it back if the submission never landed. + private func fulfillFollowUpRequest() { + guard let sid = inspection.parentServerId else { return } + // Fetch-all then filter in Swift — no #Predicate (CLAUDE.md rule 3). + let all = (try? context.fetch(FetchDescriptor())) ?? [] + all.first { $0.serverId == sid }?.fulfilledLocally = true + } + // ── Scheduled inspection fulfilment ─────────────────────────────────── /// Link this submission to the schedule it satisfies, then drop the cached diff --git a/JanitorialQC/Views/Dashboard/FollowUpRequestsView.swift b/JanitorialQC/Views/Dashboard/FollowUpRequestsView.swift new file mode 100644 index 0000000..bc47ef7 --- /dev/null +++ b/JanitorialQC/Views/Dashboard/FollowUpRequestsView.swift @@ -0,0 +1,188 @@ +// 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) + } + } + } + } +} diff --git a/JanitorialQC/Views/Dashboard/MyInspectionsView.swift b/JanitorialQC/Views/Dashboard/MyInspectionsView.swift index 14079fc..3c49a67 100644 --- a/JanitorialQC/Views/Dashboard/MyInspectionsView.swift +++ b/JanitorialQC/Views/Dashboard/MyInspectionsView.swift @@ -24,10 +24,23 @@ struct MyInspectionsView: View { scheduledAll.filter { !$0.fulfilledLocally } } + /// Follow-up requests raised on the web — rendered as the top section, above + /// Scheduled, and counted in the empty-state decision. Sorted by the flagged + /// inspection's date (ISO strings sort chronologically), oldest first: the + /// longest-outstanding request is the one to clear next. + @Query(sort: \LocalFollowUpRequest.inspectionDateString, order: .forward) + private var followUpsAll: [LocalFollowUpRequest] + + /// Rows still awaiting action — see FollowUpRequestsCard.visible. + private var followUpsVisible: [LocalFollowUpRequest] { + followUpsAll.filter { !$0.fulfilledLocally } + } + @Environment(\.modelContext) private var context @State private var showNewInspection = false @State private var scheduledStartTarget: ScheduledStartTarget? + @State private var followUpStartTarget: FollowUpStartTarget? // Deletion confirmation state @State private var pendingDelete: LocalInspection? @@ -35,7 +48,7 @@ struct MyInspectionsView: View { var body: some View { Group { - if inspections.isEmpty && scheduledVisible.isEmpty { + if inspections.isEmpty && scheduledVisible.isEmpty && followUpsVisible.isEmpty { ContentUnavailableView( "No Inspections", systemImage: "checklist", @@ -43,6 +56,20 @@ struct MyInspectionsView: View { ) } else { List { + // Follow-up requests — self-hides when empty. First section: + // remedial work on a facility that already failed once + // outranks a routine scheduled visit. + if !followUpsVisible.isEmpty { + Section("Follow-up Requested") { + ForEach(followUpsVisible) { r in + Button { followUpStartTarget = FollowUpStartTarget(r) } label: { + FollowUpRow(request: r) + } + .buttonStyle(.plain) + } + } + } + // Scheduled assignments (phase36) — self-hides when empty. if !scheduledVisible.isEmpty { Section("Scheduled") { @@ -87,10 +114,28 @@ struct MyInspectionsView: View { StartInspectionView( preFillTemplateId: t.templateServerId, preFillFacilityId: t.facilityServerId, + // phase45 — nil for an ordinary schedule; set when this row is a + // planned follow-up, which makes the run a linked re-inspection. + // Must precede preFillScheduleId: argument order follows the + // property declaration order in StartInspectionView. + parentServerId: t.parentServerId, preFillScheduleId: t.id, preFillScheduleInstructions: t.instructions ) } + // Also on the Group, not the List — see the comment above. Submitting the + // last follow-up can flip this view to ContentUnavailableView while the + // cover is still presented. `parentServerId` is what links the run back + // to the flagged inspection; see the twin cover in DashboardStatsView. + .fullScreenCover(item: $followUpStartTarget) { t in + StartInspectionView( + preFillTemplateId: t.templateServerId, + preFillFacilityId: t.facilityServerId, + parentServerId: t.id, + preFillFollowUpNote: t.note, + preFillParentFormDataJSON: t.parentFormDataJSON + ) + } .navigationTitle("My Inspections") // Confirmation before deletion — destructive action cannot be undone .alert("Delete Draft?", isPresented: $showDeleteAlert, presenting: pendingDelete) { inspection in diff --git a/JanitorialQC/Views/Dashboard/ScheduledInspectionsView.swift b/JanitorialQC/Views/Dashboard/ScheduledInspectionsView.swift index e7c38de..b4fb2e0 100644 --- a/JanitorialQC/Views/Dashboard/ScheduledInspectionsView.swift +++ b/JanitorialQC/Views/Dashboard/ScheduledInspectionsView.swift @@ -44,12 +44,18 @@ struct ScheduledStartTarget: Identifiable { /// `notes` (API key `notes`, column `scheduled_inspections.notes`); only the /// user-facing wording is "Instructions". let instructions: String? + /// Inspection this schedule is a planned follow-up of (phase45), or nil for + /// an ordinary schedule. Passed to `StartInspectionView` as `parentServerId` + /// so the run lands as a linked re-inspection — the whole point of + /// "Schedule Follow-up". + let parentServerId: Int? init(_ schedule: LocalScheduledInspection) { self.id = schedule.serverId self.templateServerId = schedule.templateServerId self.facilityServerId = schedule.facilityServerId self.instructions = schedule.instructions + self.parentServerId = schedule.parentInspectionServerId } } diff --git a/JanitorialQC/Views/Dashboard/StartInspectionView.swift b/JanitorialQC/Views/Dashboard/StartInspectionView.swift index d356377..915b4a1 100644 --- a/JanitorialQC/Views/Dashboard/StartInspectionView.swift +++ b/JanitorialQC/Views/Dashboard/StartInspectionView.swift @@ -37,6 +37,27 @@ struct StartInspectionView: View { var parentServerId: Int? = nil var parentLocalId: String? = nil + /// The director's note explaining what the follow-up should address, set when + /// the inspector taps a row in the FOLLOW-UP REQUESTED card. Passed as a plain + /// String rather than read from SwiftData here, for the same reason + /// FollowUpStartTarget exists — the cached request row is invalidated at + /// submit while this flow is still on screen. Nil for a re-inspection the + /// inspector started themselves from CompletedInspectionView. + var preFillFollowUpNote: String? = nil + + /// The flagged inspection's answers, JSON-encoded, used to pre-fill this + /// re-inspection when the parent `LocalInspection` is not on this device. + /// + /// The local-parent lookup in `startInspection()` covers the + /// CompletedInspectionView path, where the inspector is re-inspecting + /// something they just finished on this iPad. It does **not** cover a + /// follow-up raised on the web: that parent synced long ago and is often + /// absent locally, so the lookup found nothing and the form came up blank — + /// where the web pre-fills it. Cached at pull time on + /// `LocalFollowUpRequest`, so this works offline too. Nil for every other + /// start path. + var preFillParentFormDataJSON: String? = nil + // ── Scheduled inspection launch ─────────────────────────────────────── /// Server ID of the ScheduledInspection this run fulfils, passed when the /// inspector taps Start on a scheduled row. Carried onto the LocalInspection @@ -123,6 +144,16 @@ struct StartInspectionView: View { Text("This will be linked to inspection #\(parentServerId!).") .font(.caption) .foregroundStyle(.secondary) + // What the director actually asked for. Shown + // here rather than in its own section so it + // reads as part of the request, and repeated in + // full because the card truncates it to a line. + if let note = preFillFollowUpNote, !note.isEmpty { + Text(note) + .font(.callout) + .fixedSize(horizontal: false, vertical: true) + .padding(.top, 4) + } } } .padding(.vertical, 4) @@ -307,17 +338,30 @@ struct StartInspectionView: View { // inspector doesn't re-enter static data. Scoring fields (rating, // pass_fail) and media fields (image, signature) are always left blank // so every scoreable item must be re-evaluated fresh. - if let parentId = parentServerId { - let allInspections = (try? context.fetch(FetchDescriptor())) ?? [] - if let parent = allInspections.first(where: { $0.serverId == parentId }), - !parent.formData.isEmpty { + if parentServerId != nil { + // Prefer the local parent (the CompletedInspectionView path, where + // the inspector just finished it on this iPad); otherwise fall back + // to the snapshot cached on the follow-up request. A follow-up + // raised on the web has usually synced and been dropped locally, so + // without the fallback this whole block silently no-opped and the + // form came up blank — the bug this fixes. + let parentData = resolvedParentFormData() - // Fetch the template schema to identify field types. - // Split into two statements — avoids Xcode 26 #Predicate - // ambiguity under SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor. - let allTemplates = (try? context.fetch(FetchDescriptor())) ?? [] - let tid = templateId - let schema = allTemplates.first(where: { $0.serverId == tid })?.formSchema ?? [] + // Fetch the template schema to identify field types. + // Split into two statements — avoids Xcode 26 #Predicate + // ambiguity under SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor. + let allTemplates = (try? context.fetch(FetchDescriptor())) ?? [] + let tid = templateId + let schema = allTemplates.first(where: { $0.serverId == tid })?.formSchema ?? [] + + // The schema is what identifies which fields must NOT be carried + // over, so without it there is no safe prefill: an empty exclude set + // would copy *everything*, including the parent's `image` paths and + // its ratings — attaching the previous inspection's photos as this + // one's evidence and pre-answering the scoreable items. Copy nothing + // instead. (Unreachable in practice: the template was chosen from + // the local picker, so it is cached — this is a guard, not a case.) + if !parentData.isEmpty, !schema.isEmpty { // Build the set of field IDs that must NOT be carried over let excludeTypes: Set = ["rating", "pass_fail", "image", "signature"] @@ -330,7 +374,6 @@ struct StartInspectionView: View { } // Copy all parent values except excluded fields - let parentData = parent.formData var prefilled: [String: Any] = [:] for (key, value) in parentData { if !excludeIds.contains(key) { @@ -349,4 +392,34 @@ struct StartInspectionView: View { createdInspection = inspection navigateToExecution = true } + + /// The parent inspection's answers to pre-fill from, or `[:]` when there are + /// none to carry. + /// + /// Two sources, in order: + /// 1. The local `LocalInspection` with a matching `serverId` — the + /// re-inspection-from-history path, where the parent is on this device + /// and is the freshest copy. + /// 2. `preFillParentFormDataJSON`, snapshotted from the server at pull + /// time — the follow-up-request path, where the parent has synced and + /// is typically no longer local. + /// + /// Source 1 is checked first but only wins when it actually holds values, so + /// a stray empty local shell can't shadow a good server snapshot. + private func resolvedParentFormData() -> [String: Any] { + if let parentId = parentServerId { + // Fetch-all then filter in Swift — no #Predicate (CLAUDE.md rule 3). + let allInspections = (try? context.fetch(FetchDescriptor())) ?? [] + if let parent = allInspections.first(where: { $0.serverId == parentId }) { + let localData = parent.formData + if !localData.isEmpty { return localData } + } + } + + guard let json = preFillParentFormDataJSON, + let data = json.data(using: .utf8), + let dict = try? JSONSerialization.jsonObject(with: data) as? [String: Any] + else { return [:] } + return dict + } } diff --git a/JanitorialQC/Views/Inspection/InspectionHistoryView.swift b/JanitorialQC/Views/Inspection/InspectionHistoryView.swift index b552a84..c470b6b 100644 --- a/JanitorialQC/Views/Inspection/InspectionHistoryView.swift +++ b/JanitorialQC/Views/Inspection/InspectionHistoryView.swift @@ -350,11 +350,32 @@ struct HistoryDetailView: View { let inspection: APIInspectionSummary @Environment(\.modelContext) private var context + @EnvironmentObject private var auth: AuthManager + @EnvironmentObject private var sync: SyncManager @State private var showReInspect = false @State private var showMailCompose = false @State private var isGeneratingPDF = false @State private var generatedPDFData: Data? = nil + // ── Schedule Follow-up (phase45) ────────────────────────────────────── + @State private var showScheduleSheet = false + /// Defaults to tomorrow: the point of this action is to plan the follow-up + /// for another day. Today is still selectable — the server allows it. + @State private var followUpDate = Calendar.current.date( + byAdding: .day, value: 1, to: Date() + ) ?? Date() + @State private var followUpNotes = "" + @State private var isSchedulingFollowUp = false + @State private var scheduleError: String? = nil + @State private var scheduleConfirmation: String? = nil + + /// Auditors are read-only everywhere else and the API rejects them (403), + /// so the two action buttons are hidden rather than shown failing. + private var canStartFollowUp: Bool { + ["admin", "director", "inspector", "project_manager"] + .contains(auth.currentUserRole) + } + // Local SwiftData copy — used only for follow-up sync-back. // Form data and schema come from the server response directly so // History works even after app reinstall or on a different device. @@ -463,6 +484,34 @@ struct HistoryDetailView: View { .navigationTitle(inspection.templateName) .navigationBarTitleDisplayMode(.inline) .toolbar { + // ── Re-inspect now ──────────────────────────────────────────── + // The immediate half of the follow-up pair. Opens the same linked + // re-inspection flow the follow-up banner has always used, but + // without waiting to be asked for one. + if canStartFollowUp { + ToolbarItem(placement: .primaryAction) { + Button { + showReInspect = true + } label: { + Label("Re-inspect Now", systemImage: "arrow.uturn.right.circle") + } + } + + // ── Schedule follow-up ──────────────────────────────────── + // The deferred half. Needs the network: it creates a schedule + // server-side rather than a local record, so unlike starting an + // inspection it cannot be queued offline. + ToolbarItem(placement: .primaryAction) { + Button { + scheduleError = nil + showScheduleSheet = true + } label: { + Label("Schedule Follow-up", systemImage: "calendar.badge.plus") + } + .disabled(!sync.isOnline) + } + } + ToolbarItem(placement: .primaryAction) { Button { Task { await prepareAndShowMail() } @@ -476,16 +525,34 @@ struct HistoryDetailView: View { .disabled(!MFMailComposeViewController.canSendMail() || isGeneratingPDF) } } + .sheet(isPresented: $showScheduleSheet) { scheduleFollowUpSheet } + // Confirmation of a successful schedule. An alert rather than an inline + // banner because the sheet has already dismissed by this point. + .alert("Follow-up Scheduled", + isPresented: Binding(get: { scheduleConfirmation != nil }, + set: { if !$0 { scheduleConfirmation = nil } })) { + Button("OK") { scheduleConfirmation = nil } + } message: { + Text(scheduleConfirmation ?? "") + } .onAppear { loadLocalData() syncFollowUpToLocalCopy() } - .sheet(isPresented: $showReInspect) { + // Full-screen, not a sheet: every inspection-start flow is full-screen + // (rule 66), and this one is now reachable from the toolbar on any + // completed inspection rather than only the follow-up banner. + .fullScreenCover(isPresented: $showReInspect) { StartInspectionView( preFillTemplateId: inspection.templateId, preFillFacilityId: inspection.facilityId, parentServerId: inspection.id, - parentLocalId: inspection.mobileLocalId + parentLocalId: inspection.mobileLocalId, + // History is served from the API, so this inspection is often + // not on this device at all and the local-parent lookup finds + // nothing — the form would open blank (rule 79). The answers are + // already in this very response, so pass them straight through. + preFillParentFormDataJSON: parentFormDataJSON ) } .sheet(isPresented: $showMailCompose) { @@ -501,6 +568,138 @@ struct HistoryDetailView: View { } } + /// This inspection's answers, JSON-encoded for `StartInspectionView`'s + /// parent prefill. Raw values, not the flattened `formValues`, so an array + /// field survives as an array (rule 79). + private var parentFormDataJSON: String { + let raw = inspection.formDataRaw.mapValues(\.anyValue) + guard JSONSerialization.isValidJSONObject(raw), + let data = try? JSONSerialization.data(withJSONObject: raw), + let str = String(data: data, encoding: .utf8) + else { return "{}" } + return str + } + + // ── Schedule Follow-up sheet (phase45) ──────────────────────────────── + + /// Date + note picker for planning a follow-up re-inspection. + /// + /// Only the date and an optional note are collected: the server derives + /// facility, template and assignee from the parent inspection, so there is + /// nothing else for the inspector to get wrong. + private var scheduleFollowUpSheet: some View { + NavigationStack { + Form { + Section { + Text(inspection.templateName) + .font(.callout.bold()) + Text(inspection.facilityName) + .font(.caption) + .foregroundStyle(.secondary) + } header: { + Text("Follow-up of Inspection #\(inspection.id)") + } + + Section { + DatePicker( + "Due Date", + selection: $followUpDate, + in: Date()..., // the server rejects a past date + displayedComponents: .date + ) + .datePickerStyle(.graphical) + } header: { + Text("When") + } footer: { + Text("The follow-up appears in Scheduled on this date, " + + "assigned to the inspector who did the original.") + } + + Section { + TextField( + "What should the follow-up address?", + text: $followUpNotes, + axis: .vertical + ) + .lineLimit(3...6) + } header: { + Text("Instructions (optional)") + } + + if let err = scheduleError { + Section { + Label(err, systemImage: "exclamationmark.triangle") + .font(.callout) + .foregroundStyle(.red) + } + } + } + .navigationTitle("Schedule Follow-up") + .navigationBarTitleDisplayMode(.inline) + .toolbar { + ToolbarItem(placement: .cancellationAction) { + Button("Cancel") { showScheduleSheet = false } + .disabled(isSchedulingFollowUp) + } + ToolbarItem(placement: .confirmationAction) { + Button { + Task { await submitScheduledFollowUp() } + } label: { + if isSchedulingFollowUp { + ProgressView() + } else { + Text("Schedule") + } + } + .disabled(isSchedulingFollowUp) + } + } + } + } + + /// Create the follow-up schedule on the server, then refresh so it appears + /// in the Scheduled lists without waiting for the next timed sync. + /// + /// Online-only by nature: this writes a server-side plan, not a local + /// record, so there is nothing meaningful to queue offline — the button is + /// disabled when offline and this reports any failure inline rather than + /// dismissing as if it had worked. + private func submitScheduledFollowUp() async { + isSchedulingFollowUp = true + scheduleError = nil + + let due = Self.dueDateFormatter.string(from: followUpDate) + do { + _ = try await APIClient.shared.createScheduledFollowUp( + parentInspectionId: inspection.id, + dueDate: due, + notes: followUpNotes + ) + // Pull the new schedule straight into the Scheduled section. + await sync.pullScheduledInspections(context: context) + + isSchedulingFollowUp = false + showScheduleSheet = false + followUpNotes = "" + scheduleConfirmation = + "A follow-up re-inspection of \(inspection.facilityName) is scheduled for " + + followUpDate.formatted(date: .abbreviated, time: .omitted) + "." + } catch { + isSchedulingFollowUp = false + scheduleError = (error as? APIError)?.localizedDescription + ?? "Could not schedule the follow-up. Check your connection and try again." + } + } + + /// `yyyy-MM-dd` for the API's `due_date`. Fixed POSIX locale so a non- + /// Gregorian device calendar cannot emit a date the server can't parse. + private static let dueDateFormatter: DateFormatter = { + let f = DateFormatter() + f.locale = Locale(identifier: "en_US_POSIX") + f.dateFormat = "yyyy-MM-dd" + return f + }() + /// Generates the PDF (fetching any server photos over the network), /// then presents the mail compose sheet with it attached. /// Photo fetches happen here, off the synchronous PDF drawing pass.