480 lines
16 KiB
Swift
480 lines
16 KiB
Swift
import Foundation
|
|
import SwiftUI
|
|
|
|
private let watchAccent = AppTheme.accent
|
|
private let watchGold = AppTheme.warmAccent
|
|
|
|
struct WatchRootView: View {
|
|
@ObservedObject var model: AppViewModel
|
|
|
|
var body: some View {
|
|
NavigationStack {
|
|
Group {
|
|
if model.session == nil {
|
|
WatchPairingView(model: model)
|
|
} else {
|
|
WatchDashboardView(model: model)
|
|
}
|
|
}
|
|
.navigationBarTitleDisplayMode(.inline)
|
|
}
|
|
.tint(watchAccent)
|
|
}
|
|
}
|
|
|
|
private struct WatchPairingView: View {
|
|
@ObservedObject var model: AppViewModel
|
|
|
|
var body: some View {
|
|
ScrollView {
|
|
VStack(alignment: .leading, spacing: 12) {
|
|
AppPanel(compactLayout: true, radius: 22) {
|
|
AppBadge(title: "Preview passport", tone: watchAccent)
|
|
|
|
Text("Prove identity from your wrist")
|
|
.font(.title3.weight(.semibold))
|
|
|
|
Text("This preview connects directly to the mock service today.")
|
|
.font(.footnote)
|
|
.foregroundStyle(.secondary)
|
|
|
|
HStack(spacing: 8) {
|
|
AppStatusTag(title: "Wrist-ready", tone: watchAccent)
|
|
AppStatusTag(title: "Preview sync", tone: watchGold)
|
|
}
|
|
}
|
|
|
|
if model.isBootstrapping {
|
|
ProgressView("Preparing preview passport...")
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
|
|
Button {
|
|
Task {
|
|
await model.signInWithSuggestedPayload()
|
|
}
|
|
} label: {
|
|
if model.isAuthenticating {
|
|
ProgressView()
|
|
.frame(maxWidth: .infinity)
|
|
} else {
|
|
Label("Use Preview Passport", systemImage: "qrcode")
|
|
.frame(maxWidth: .infinity)
|
|
}
|
|
}
|
|
.buttonStyle(.borderedProminent)
|
|
.disabled(model.isBootstrapping || model.suggestedPairingPayload.isEmpty || model.isAuthenticating)
|
|
|
|
AppPanel(compactLayout: true, radius: 18) {
|
|
Text("What works today")
|
|
.font(.headline)
|
|
|
|
Text("The watch shows pending identity checks, recent alerts, and quick actions.")
|
|
.font(.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
.padding(.horizontal, 8)
|
|
.padding(.bottom, 20)
|
|
}
|
|
.navigationTitle("Set Up Watch")
|
|
}
|
|
}
|
|
|
|
private struct WatchInfoPill: View {
|
|
let title: String
|
|
let value: String
|
|
let tone: Color
|
|
|
|
var body: some View {
|
|
VStack(alignment: .leading, spacing: 2) {
|
|
Text(title)
|
|
.font(.caption2)
|
|
.foregroundStyle(.secondary)
|
|
Text(value)
|
|
.font(.caption.weight(.semibold))
|
|
.foregroundStyle(.primary)
|
|
}
|
|
.padding(.horizontal, 10)
|
|
.padding(.vertical, 8)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.background(tone.opacity(0.10), in: RoundedRectangle(cornerRadius: 16, style: .continuous))
|
|
}
|
|
}
|
|
|
|
private struct WatchDashboardView: View {
|
|
@ObservedObject var model: AppViewModel
|
|
|
|
var body: some View {
|
|
List {
|
|
Section {
|
|
WatchPassportCard(model: model)
|
|
}
|
|
|
|
Section("Pending") {
|
|
if model.pendingRequests.isEmpty {
|
|
Text("No checks waiting.")
|
|
.foregroundStyle(.secondary)
|
|
|
|
Button("Seed Identity Check") {
|
|
Task {
|
|
await model.simulateIncomingRequest()
|
|
}
|
|
}
|
|
} else {
|
|
ForEach(model.pendingRequests) { request in
|
|
NavigationLink {
|
|
WatchRequestDetailView(model: model, requestID: request.id)
|
|
} label: {
|
|
WatchRequestRow(request: request)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Section("Recent Activity") {
|
|
if model.notifications.isEmpty {
|
|
Text("No recent alerts.")
|
|
.foregroundStyle(.secondary)
|
|
} else {
|
|
ForEach(model.notifications.prefix(3)) { notification in
|
|
NavigationLink {
|
|
WatchNotificationDetailView(model: model, notificationID: notification.id)
|
|
} label: {
|
|
WatchNotificationRow(notification: notification)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Section("Actions") {
|
|
Button("Refresh") {
|
|
Task {
|
|
await model.refreshDashboard()
|
|
}
|
|
}
|
|
.disabled(model.isRefreshing)
|
|
|
|
Button("Send Test Alert") {
|
|
Task {
|
|
await model.sendTestNotification()
|
|
}
|
|
}
|
|
|
|
if model.notificationPermission == .unknown || model.notificationPermission == .denied {
|
|
Button("Enable Alerts") {
|
|
Task {
|
|
await model.requestNotificationAccess()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Section("Account") {
|
|
if let profile = model.profile {
|
|
VStack(alignment: .leading, spacing: 4) {
|
|
Text(profile.handle)
|
|
.font(.headline)
|
|
Text(profile.organization)
|
|
.font(.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
|
|
VStack(alignment: .leading, spacing: 4) {
|
|
Text("Notifications")
|
|
.font(.headline)
|
|
Text(model.notificationPermission.title)
|
|
.font(.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
|
|
Button("Sign Out", role: .destructive) {
|
|
model.signOut()
|
|
}
|
|
}
|
|
}
|
|
.navigationTitle("Passport")
|
|
.refreshable {
|
|
await model.refreshDashboard()
|
|
}
|
|
}
|
|
}
|
|
|
|
private struct WatchPassportCard: View {
|
|
@ObservedObject var model: AppViewModel
|
|
|
|
var body: some View {
|
|
VStack(alignment: .leading, spacing: 10) {
|
|
VStack(alignment: .leading, spacing: 2) {
|
|
Text(model.profile?.name ?? "Preview Session")
|
|
.font(.headline)
|
|
Text(model.pairedDeviceSummary)
|
|
.font(.footnote)
|
|
.foregroundStyle(.secondary)
|
|
if let session = model.session {
|
|
Text("Via \(session.pairingTransport.title)")
|
|
.font(.caption2)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
|
|
HStack(spacing: 8) {
|
|
WatchMetricPill(title: "Pending", value: "\(model.pendingRequests.count)", accent: watchAccent)
|
|
WatchMetricPill(title: "Unread", value: "\(model.unreadNotificationCount)", accent: watchGold)
|
|
}
|
|
}
|
|
.padding(.vertical, 6)
|
|
}
|
|
}
|
|
|
|
private struct WatchMetricPill: View {
|
|
let title: String
|
|
let value: String
|
|
let accent: Color
|
|
|
|
var body: some View {
|
|
VStack(alignment: .leading, spacing: 2) {
|
|
Text(value)
|
|
.font(.headline.monospacedDigit())
|
|
Text(title)
|
|
.font(.caption2)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
.padding(.horizontal, 10)
|
|
.padding(.vertical, 8)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.background(accent.opacity(0.14), in: RoundedRectangle(cornerRadius: 14, style: .continuous))
|
|
}
|
|
}
|
|
|
|
private struct WatchRequestRow: View {
|
|
let request: ApprovalRequest
|
|
|
|
var body: some View {
|
|
VStack(alignment: .leading, spacing: 4) {
|
|
HStack(alignment: .top, spacing: 6) {
|
|
Text(request.title)
|
|
.font(.headline)
|
|
.lineLimit(2)
|
|
|
|
Spacer(minLength: 6)
|
|
|
|
Image(systemName: request.risk == .elevated ? "exclamationmark.shield.fill" : "checkmark.shield.fill")
|
|
.foregroundStyle(request.risk == .elevated ? .orange : watchAccent)
|
|
}
|
|
|
|
Text(request.source)
|
|
.font(.footnote)
|
|
.foregroundStyle(.secondary)
|
|
|
|
Text(request.createdAt.watchRelativeString)
|
|
.font(.caption2)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
.padding(.vertical, 2)
|
|
}
|
|
}
|
|
|
|
private struct WatchNotificationRow: View {
|
|
let notification: AppNotification
|
|
|
|
var body: some View {
|
|
VStack(alignment: .leading, spacing: 4) {
|
|
HStack(alignment: .top, spacing: 6) {
|
|
Text(notification.title)
|
|
.font(.headline)
|
|
.lineLimit(2)
|
|
|
|
Spacer(minLength: 6)
|
|
|
|
if notification.isUnread {
|
|
Circle()
|
|
.fill(watchAccent)
|
|
.frame(width: 8, height: 8)
|
|
}
|
|
}
|
|
|
|
Text(notification.message)
|
|
.font(.footnote)
|
|
.foregroundStyle(.secondary)
|
|
.lineLimit(2)
|
|
|
|
Text(notification.sentAt.watchRelativeString)
|
|
.font(.caption2)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
.padding(.vertical, 2)
|
|
}
|
|
}
|
|
|
|
private struct WatchRequestDetailView: View {
|
|
@ObservedObject var model: AppViewModel
|
|
let requestID: ApprovalRequest.ID
|
|
|
|
private var request: ApprovalRequest? {
|
|
model.requests.first(where: { $0.id == requestID })
|
|
}
|
|
|
|
var body: some View {
|
|
Group {
|
|
if let request {
|
|
ScrollView {
|
|
VStack(alignment: .leading, spacing: 12) {
|
|
detailHeader(
|
|
title: request.title,
|
|
subtitle: request.source,
|
|
badge: request.status.title
|
|
)
|
|
|
|
Text(request.subtitle)
|
|
.font(.footnote)
|
|
.foregroundStyle(.secondary)
|
|
|
|
VStack(alignment: .leading, spacing: 6) {
|
|
Text("Trust Summary")
|
|
.font(.headline)
|
|
Text(request.trustHeadline)
|
|
.font(.subheadline.weight(.semibold))
|
|
Text(request.trustDetail)
|
|
.font(.footnote)
|
|
.foregroundStyle(.secondary)
|
|
Text(request.risk.guidance)
|
|
.font(.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
.padding(10)
|
|
.background(.thinMaterial, in: RoundedRectangle(cornerRadius: 18, style: .continuous))
|
|
|
|
if !request.scopes.isEmpty {
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text("Scopes")
|
|
.font(.headline)
|
|
|
|
ForEach(request.scopes, id: \.self) { scope in
|
|
Label(scope, systemImage: "checkmark.seal.fill")
|
|
.font(.footnote)
|
|
}
|
|
}
|
|
}
|
|
|
|
if request.status == .pending {
|
|
if model.activeRequestID == request.id {
|
|
ProgressView("Updating proof...")
|
|
} else {
|
|
Button("Verify") {
|
|
Task {
|
|
await model.approve(request)
|
|
}
|
|
}
|
|
.buttonStyle(.borderedProminent)
|
|
|
|
Button("Decline", role: .destructive) {
|
|
Task {
|
|
await model.reject(request)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.padding(.horizontal, 8)
|
|
.padding(.bottom, 20)
|
|
}
|
|
} else {
|
|
Text("This request is no longer available.")
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
.navigationTitle("Identity Check")
|
|
}
|
|
|
|
private func detailHeader(title: String, subtitle: String, badge: String) -> some View {
|
|
VStack(alignment: .leading, spacing: 6) {
|
|
Text(title)
|
|
.font(.headline)
|
|
|
|
Text(subtitle)
|
|
.font(.footnote)
|
|
.foregroundStyle(.secondary)
|
|
|
|
Text(badge)
|
|
.font(.caption.weight(.semibold))
|
|
.padding(.horizontal, 8)
|
|
.padding(.vertical, 4)
|
|
.background(watchAccent.opacity(0.14), in: Capsule())
|
|
}
|
|
}
|
|
}
|
|
|
|
private struct WatchNotificationDetailView: View {
|
|
@ObservedObject var model: AppViewModel
|
|
let notificationID: AppNotification.ID
|
|
|
|
private var notification: AppNotification? {
|
|
model.notifications.first(where: { $0.id == notificationID })
|
|
}
|
|
|
|
var body: some View {
|
|
Group {
|
|
if let notification {
|
|
ScrollView {
|
|
VStack(alignment: .leading, spacing: 12) {
|
|
VStack(alignment: .leading, spacing: 6) {
|
|
Text(notification.title)
|
|
.font(.headline)
|
|
Text(notification.kind.title)
|
|
.font(.footnote.weight(.semibold))
|
|
.foregroundStyle(watchAccent)
|
|
Text(notification.sentAt.watchRelativeString)
|
|
.font(.caption2)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
|
|
Text(notification.message)
|
|
.font(.footnote)
|
|
.foregroundStyle(.secondary)
|
|
|
|
VStack(alignment: .leading, spacing: 6) {
|
|
Text("Alert posture")
|
|
.font(.headline)
|
|
Text(model.notificationPermission.summary)
|
|
.font(.footnote)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
.padding(10)
|
|
.background(.thinMaterial, in: RoundedRectangle(cornerRadius: 18, style: .continuous))
|
|
|
|
if notification.isUnread {
|
|
Button("Mark Read") {
|
|
Task {
|
|
await model.markNotificationRead(notification)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.padding(.horizontal, 8)
|
|
.padding(.bottom, 20)
|
|
}
|
|
} else {
|
|
Text("This activity item has already been cleared.")
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
}
|
|
.navigationTitle("Activity")
|
|
}
|
|
}
|
|
|
|
private extension Date {
|
|
var watchRelativeString: String {
|
|
WatchFormatters.relative.localizedString(for: self, relativeTo: .now)
|
|
}
|
|
}
|
|
|
|
private enum WatchFormatters {
|
|
static let relative: RelativeDateTimeFormatter = {
|
|
let formatter = RelativeDateTimeFormatter()
|
|
formatter.unitsStyle = .abbreviated
|
|
return formatter
|
|
}()
|
|
}
|