forked from sagnik/Project_Velocity
sayan
7ee51543d9
Co-authored-by: Sayan Datta <sayan@Sayans-MacBook-Air.local> Reviewed-on: sagnik/Project_Velocity#41
1224 lines
50 KiB
Swift
1224 lines
50 KiB
Swift
import Combine
|
|
import SwiftUI
|
|
|
|
enum OracleMode: String, CaseIterable {
|
|
case pipeline = "Pipeline"
|
|
case deals = "Deals"
|
|
case accountTimeline = "Account Timeline"
|
|
case calendarTasks = "Calendar & Tasks"
|
|
case teamPerformance = "Team Performance"
|
|
case leadMap = "Lead Map"
|
|
|
|
var icon: String {
|
|
switch self {
|
|
case .pipeline:
|
|
return "square.grid.3x1.below.line.grid.1x2"
|
|
case .deals:
|
|
return "target"
|
|
case .accountTimeline:
|
|
return "clock.arrow.circlepath"
|
|
case .calendarTasks:
|
|
return "calendar"
|
|
case .teamPerformance:
|
|
return "person.3"
|
|
case .leadMap:
|
|
return "map"
|
|
}
|
|
}
|
|
}
|
|
|
|
struct OracleView: View {
|
|
@State private var store = AppStore.shared
|
|
@State private var selectedMode: OracleMode = OracleModeAvailability.sanitizedProductionSelection(.pipeline)
|
|
@State private var selectedClient360: VelocityClient360DTO?
|
|
@State private var selectedClient360PersonID: String?
|
|
@State private var isClient360Loading = false
|
|
@State private var client360Error: String?
|
|
@State private var actionError: String?
|
|
@State private var actionMessage: String?
|
|
@State private var activeTaskMutationID: String?
|
|
@State private var activeLeadMutationID: String?
|
|
@State private var activeOpportunityMutationID: String?
|
|
private let refreshTimer = Timer.publish(every: 20, on: .main, in: .common).autoconnect()
|
|
|
|
var body: some View {
|
|
VStack(alignment: .leading, spacing: 0) {
|
|
header
|
|
.padding(.horizontal, 24)
|
|
.padding(.top, 24)
|
|
.padding(.bottom, 16)
|
|
|
|
modePicker
|
|
.padding(.horizontal, 24)
|
|
.padding(.bottom, 14)
|
|
|
|
if let error = store.errorMessage {
|
|
errorBanner(error)
|
|
.padding(.horizontal, 24)
|
|
.padding(.bottom, 14)
|
|
}
|
|
|
|
if let actionError {
|
|
errorBanner(actionError)
|
|
.padding(.horizontal, 24)
|
|
.padding(.bottom, 14)
|
|
}
|
|
|
|
if let actionMessage {
|
|
successBanner(actionMessage)
|
|
.padding(.horizontal, 24)
|
|
.padding(.bottom, 14)
|
|
}
|
|
|
|
ScrollView {
|
|
canvas
|
|
.padding(.horizontal, 24)
|
|
.padding(.bottom, 24)
|
|
}
|
|
}
|
|
.background(VelocityTheme.background)
|
|
.task { await store.refresh() }
|
|
.refreshable { await store.refresh() }
|
|
.onAppear {
|
|
selectedMode = OracleModeAvailability.sanitizedProductionSelection(selectedMode)
|
|
}
|
|
.onReceive(refreshTimer) { _ in
|
|
Task { await store.refresh(silent: true) }
|
|
}
|
|
.sheet(isPresented: client360PresentationBinding) {
|
|
client360Sheet
|
|
}
|
|
}
|
|
|
|
private var header: some View {
|
|
HStack {
|
|
VStack(alignment: .leading, spacing: 3) {
|
|
Text("Oracle")
|
|
.font(.system(size: 28, weight: .bold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Text("Live sales intelligence assembled from canonical CRM, communication events, and calendar data.")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
Spacer()
|
|
Text(store.lastRefreshAt?.relativeShort ?? "Awaiting sync")
|
|
.font(.system(size: 11, weight: .medium))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
}
|
|
|
|
private var modePicker: some View {
|
|
ScrollView(.horizontal, showsIndicators: false) {
|
|
HStack(spacing: 10) {
|
|
ForEach(OracleModeAvailability.productionVisibleModes, id: \.self) { mode in
|
|
Button {
|
|
selectedMode = mode
|
|
} label: {
|
|
HStack(spacing: 6) {
|
|
Image(systemName: mode.icon)
|
|
Text(mode.rawValue)
|
|
}
|
|
.font(.system(size: 12, weight: .semibold))
|
|
.foregroundStyle(selectedMode == mode ? VelocityTheme.foreground : VelocityTheme.mutedFg)
|
|
.padding(.horizontal, 14)
|
|
.padding(.vertical, 10)
|
|
.background(
|
|
Capsule()
|
|
.fill(selectedMode == mode ? VelocityTheme.accent.opacity(0.16) : VelocityTheme.surface)
|
|
.overlay(
|
|
Capsule()
|
|
.stroke(selectedMode == mode ? VelocityTheme.borderAccent : VelocityTheme.borderSubtle, lineWidth: 1)
|
|
)
|
|
)
|
|
}
|
|
.buttonStyle(.plain)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@ViewBuilder
|
|
private var canvas: some View {
|
|
switch OracleModeAvailability.sanitizedProductionSelection(selectedMode) {
|
|
case .pipeline:
|
|
pipelineCanvas
|
|
case .deals:
|
|
dealsCanvas
|
|
case .accountTimeline:
|
|
timelineCanvas
|
|
case .calendarTasks:
|
|
calendarCanvas
|
|
case .teamPerformance, .leadMap:
|
|
unavailableCanvas(
|
|
title: "Oracle mode unavailable",
|
|
message: "This Oracle mode is intentionally hidden from the production iPad scope until a real backend contract exists."
|
|
)
|
|
}
|
|
}
|
|
|
|
private var pipelineCanvas: some View {
|
|
return VStack(alignment: .leading, spacing: 16) {
|
|
productionScopeNote
|
|
|
|
summaryCard(
|
|
title: "Pipeline Summary",
|
|
body: "This view reads the canonical `/api/crm/kanban` board directly, so the iPad pipeline reflects the real backend stage model and lane counts."
|
|
)
|
|
|
|
if store.kanbanColumns.allSatisfy({ $0.count == 0 }) {
|
|
emptyCard("No live canonical pipeline rows are available yet.")
|
|
} else {
|
|
ForEach(store.kanbanColumns) { column in
|
|
VStack(alignment: .leading, spacing: 12) {
|
|
HStack {
|
|
Text(column.label)
|
|
.font(.system(size: 16, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Spacer()
|
|
Text("\(column.count)")
|
|
.font(.system(size: 11, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.accent)
|
|
.padding(.horizontal, 10)
|
|
.padding(.vertical, 6)
|
|
.background(
|
|
Capsule()
|
|
.fill(VelocityTheme.accent.opacity(0.12))
|
|
.overlay(
|
|
Capsule()
|
|
.stroke(VelocityTheme.borderAccent, lineWidth: 1)
|
|
)
|
|
)
|
|
}
|
|
|
|
if column.items.isEmpty {
|
|
Text("No canonical leads are currently in this lane.")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
|
|
ForEach(column.items) { lead in
|
|
HStack(alignment: .top, spacing: 12) {
|
|
Button {
|
|
openClient360(for: lead.personId)
|
|
} label: {
|
|
VStack(alignment: .leading, spacing: 6) {
|
|
Text(lead.clientName)
|
|
.font(.system(size: 14, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Text("\(lead.buyerTypeLabel) · \(lead.budgetSummary)")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
Text("\(lead.urgencyLabel) urgency · \(lead.clientPhone ?? "No phone")")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
.buttonStyle(.plain)
|
|
|
|
VStack(alignment: .trailing, spacing: 8) {
|
|
Text("\(lead.displayIntentScore)")
|
|
.font(.system(size: 12, weight: .bold))
|
|
.foregroundStyle(VelocityTheme.accent)
|
|
|
|
if activeLeadMutationID == lead.leadId {
|
|
ProgressView()
|
|
.progressViewStyle(CircularProgressViewStyle(tint: VelocityTheme.accent))
|
|
} else {
|
|
leadStageMenu(
|
|
leadId: lead.leadId,
|
|
personId: lead.personId,
|
|
currentStatus: column.status
|
|
)
|
|
}
|
|
}
|
|
}
|
|
.padding(14)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 14)
|
|
.fill(VelocityTheme.surface)
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: 14)
|
|
.stroke(VelocityTheme.borderSubtle, lineWidth: 1)
|
|
)
|
|
)
|
|
}
|
|
}
|
|
.padding(18)
|
|
.glassCard(cornerRadius: 18)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private var timelineCanvas: some View {
|
|
VStack(alignment: .leading, spacing: 16) {
|
|
productionScopeNote
|
|
|
|
summaryCard(
|
|
title: "Account Timeline",
|
|
body: "Recent communication events are pulled from the mobile-edge event stream for the highest-priority leads."
|
|
)
|
|
|
|
if store.timelineEvents.isEmpty {
|
|
emptyCard("No live communication events were returned for the current lead set.")
|
|
} else {
|
|
ForEach(store.timelineEvents.prefix(10)) { item in
|
|
Button {
|
|
openClient360(
|
|
personId: store.leads.first(where: { $0.id == item.leadId })?.personId,
|
|
missingContextMessage: "This timeline event is missing a client person_id, so Client 360 cannot be opened."
|
|
)
|
|
} label: {
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
HStack {
|
|
Text(item.leadName)
|
|
.font(.system(size: 14, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Spacer()
|
|
Text(item.event.channel.replacingOccurrences(of: "_", with: " ").capitalized)
|
|
.font(.system(size: 10, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.accent)
|
|
}
|
|
Text(item.event.summary ?? "No summary available.")
|
|
.font(.system(size: 13))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Text(item.event.timestampDate?.relativeShort ?? item.event.timestamp)
|
|
.font(.system(size: 11))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
.padding(16)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.glassCard(cornerRadius: 16)
|
|
}
|
|
.buttonStyle(.plain)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private var dealsCanvas: some View {
|
|
VStack(alignment: .leading, spacing: 16) {
|
|
productionScopeNote
|
|
|
|
summaryCard(
|
|
title: "Deals",
|
|
body: "This view reads canonical `/api/crm/opportunities` directly so the iPad can verify real opportunity rows from the backend."
|
|
)
|
|
|
|
if store.opportunities.isEmpty {
|
|
emptyCard("No live canonical opportunities are available yet for this operator scope.")
|
|
} else {
|
|
ForEach(store.opportunities.prefix(20)) { opportunity in
|
|
HStack(alignment: .top, spacing: 12) {
|
|
Button {
|
|
openClient360(
|
|
personId: opportunity.personId,
|
|
missingContextMessage: "This opportunity is missing a client person_id, so Client 360 cannot be opened."
|
|
)
|
|
} label: {
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text(opportunity.clientName ?? "Canonical opportunity")
|
|
.font(.system(size: 14, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Text("\(opportunity.formattedValue) · \(opportunity.projectName ?? "Project pending")")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Text("\(opportunity.nextAction ?? "Next action pending") · \(opportunity.clientPhone ?? "No phone")")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
Text(opportunity.probabilityLabel)
|
|
.font(.system(size: 11))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
.buttonStyle(.plain)
|
|
|
|
VStack(alignment: .trailing, spacing: 8) {
|
|
Text(opportunity.stage.replacingOccurrences(of: "_", with: " ").capitalized)
|
|
.font(.system(size: 10, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.accent)
|
|
|
|
if activeOpportunityMutationID == opportunity.opportunityId {
|
|
ProgressView()
|
|
.progressViewStyle(CircularProgressViewStyle(tint: VelocityTheme.accent))
|
|
} else {
|
|
opportunityActionsMenu(opportunity)
|
|
}
|
|
}
|
|
}
|
|
.padding(16)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.glassCard(cornerRadius: 16)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private var calendarCanvas: some View {
|
|
VStack(alignment: .leading, spacing: 16) {
|
|
productionScopeNote
|
|
|
|
summaryCard(
|
|
title: "Calendar & Tasks",
|
|
body: "Confirmed operator calendar events and canonical CRM reminder tasks are shown here without synthetic filler."
|
|
)
|
|
|
|
if store.calendarEvents.isEmpty && store.prioritizedTasks.isEmpty {
|
|
emptyCard("No live calendar events or canonical CRM tasks are scheduled yet for this operator.")
|
|
} else {
|
|
if !store.calendarEvents.isEmpty {
|
|
VStack(alignment: .leading, spacing: 12) {
|
|
Text("Calendar Events")
|
|
.font(.system(size: 15, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
|
|
ForEach(store.calendarEvents.prefix(10)) { event in
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
HStack {
|
|
Text(event.title)
|
|
.font(.system(size: 14, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Spacer()
|
|
Text(event.status.capitalized)
|
|
.font(.system(size: 10, weight: .semibold))
|
|
.foregroundStyle(color(for: event.status))
|
|
}
|
|
Text(formattedDateRange(event))
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Text(event.location ?? "No location")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
.padding(16)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.glassCard(cornerRadius: 16)
|
|
}
|
|
}
|
|
}
|
|
|
|
if !store.prioritizedTasks.isEmpty {
|
|
VStack(alignment: .leading, spacing: 12) {
|
|
Text("Pending Follow-Up Tasks")
|
|
.font(.system(size: 15, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
|
|
ForEach(store.prioritizedTasks.prefix(8)) { task in
|
|
HStack(alignment: .top, spacing: 12) {
|
|
Button {
|
|
openClient360(
|
|
personId: task.personId,
|
|
missingContextMessage: "This task is missing a client person_id, so Client 360 cannot be opened."
|
|
)
|
|
} label: {
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text(task.title)
|
|
.font(.system(size: 14, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Text(task.dueLabel)
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Text("\(task.ownerLabel) · \(task.clientPhone ?? "No phone")")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
Text(taskNote(task))
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
.lineLimit(2)
|
|
}
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
.buttonStyle(.plain)
|
|
|
|
VStack(alignment: .trailing, spacing: 8) {
|
|
Text(task.priorityLabel)
|
|
.font(.system(size: 10, weight: .semibold))
|
|
.foregroundStyle(taskColor(for: task.priority))
|
|
|
|
if activeTaskMutationID == task.reminderId {
|
|
ProgressView()
|
|
.progressViewStyle(CircularProgressViewStyle(tint: VelocityTheme.accent))
|
|
} else {
|
|
taskActionsMenu(task)
|
|
}
|
|
}
|
|
}
|
|
.padding(16)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.glassCard(cornerRadius: 16)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private var productionScopeNote: some View {
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text("Mobile Oracle Scope")
|
|
.font(.system(size: 13, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Text("This production iPad build shows only live-backed Oracle views. Team Performance and Lead Map stay hidden until the backend exposes real mobile contracts.")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
.padding(16)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.glassCard(cornerRadius: 16)
|
|
}
|
|
|
|
private func unavailableCanvas(title: String, message: String) -> some View {
|
|
VStack(alignment: .leading, spacing: 16) {
|
|
summaryCard(title: title, body: message)
|
|
}
|
|
}
|
|
|
|
private func summaryCard(title: String, body: String) -> some View {
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text(title)
|
|
.font(.system(size: 16, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Text(body)
|
|
.font(.system(size: 13))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
.padding(18)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.glassCard(cornerRadius: 18)
|
|
}
|
|
|
|
private func emptyCard(_ message: String) -> some View {
|
|
Text(message)
|
|
.font(.system(size: 13))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
.padding(18)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.glassCard(cornerRadius: 18)
|
|
}
|
|
|
|
private func color(for status: String) -> Color {
|
|
switch status.lowercased() {
|
|
case "confirmed":
|
|
return VelocityTheme.success
|
|
case "tentative":
|
|
return VelocityTheme.warning
|
|
default:
|
|
return VelocityTheme.accent
|
|
}
|
|
}
|
|
|
|
private func taskColor(for priority: String) -> Color {
|
|
switch priority.lowercased() {
|
|
case "urgent":
|
|
return VelocityTheme.danger
|
|
case "high":
|
|
return VelocityTheme.warning
|
|
default:
|
|
return VelocityTheme.accent
|
|
}
|
|
}
|
|
|
|
private func taskNote(_ task: VelocityTaskDTO) -> String {
|
|
let note = task.notes?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
|
|
return note.isEmpty ? "No reminder note provided." : note
|
|
}
|
|
|
|
private func formattedDateRange(_ event: VelocityCalendarEventDTO) -> String {
|
|
guard let start = event.startDate else { return event.startAt }
|
|
let formatter = DateFormatter()
|
|
formatter.dateFormat = "EEE, MMM d · h:mm a"
|
|
return formatter.string(from: start)
|
|
}
|
|
|
|
private func opportunityActionsMenu(_ opportunity: VelocityOpportunityDTO) -> some View {
|
|
Menu {
|
|
Menu("Move Stage") {
|
|
ForEach(canonicalOpportunityStages.filter { $0 != opportunity.stage.lowercased() }, id: \.self) { stage in
|
|
Button {
|
|
mutateOpportunity(
|
|
opportunity,
|
|
stage: stage,
|
|
probability: nil,
|
|
nextAction: opportunity.nextAction,
|
|
notes: "Moved from the iPad Oracle deal workspace."
|
|
)
|
|
} label: {
|
|
Text(stageLabel(stage))
|
|
}
|
|
}
|
|
}
|
|
|
|
Menu("Set Probability") {
|
|
ForEach([25, 50, 75, 90], id: \.self) { probability in
|
|
Button {
|
|
mutateOpportunity(
|
|
opportunity,
|
|
stage: nil,
|
|
probability: probability,
|
|
nextAction: opportunity.nextAction,
|
|
notes: "Probability updated from the iPad Oracle deal workspace."
|
|
)
|
|
} label: {
|
|
Text("\(probability)%")
|
|
}
|
|
}
|
|
}
|
|
|
|
Button {
|
|
mutateOpportunity(
|
|
opportunity,
|
|
stage: nil,
|
|
probability: nil,
|
|
nextAction: "Schedule commercial follow-up",
|
|
notes: "Next action updated from the iPad Oracle deal workspace."
|
|
)
|
|
} label: {
|
|
Label("Set Follow-Up Action", systemImage: "phone.arrow.up.right")
|
|
}
|
|
|
|
Button {
|
|
mutateOpportunity(
|
|
opportunity,
|
|
stage: "closed_won",
|
|
probability: 100,
|
|
nextAction: "Complete booking documentation",
|
|
notes: "Marked closed won from the iPad Oracle deal workspace."
|
|
)
|
|
} label: {
|
|
Label("Close Won", systemImage: "checkmark.seal")
|
|
}
|
|
|
|
Button(role: .destructive) {
|
|
mutateOpportunity(
|
|
opportunity,
|
|
stage: "closed_lost",
|
|
probability: 0,
|
|
nextAction: "Capture loss reason",
|
|
notes: "Marked closed lost from the iPad Oracle deal workspace."
|
|
)
|
|
} label: {
|
|
Label("Close Lost", systemImage: "xmark.seal")
|
|
}
|
|
} label: {
|
|
menuIcon("ellipsis.circle")
|
|
}
|
|
}
|
|
|
|
private func taskActionsMenu(_ task: VelocityTaskDTO) -> some View {
|
|
Menu {
|
|
if task.status.lowercased() != "done" {
|
|
Button {
|
|
mutateTask(task, status: "done", dueAt: nil, notes: "Marked done from the iPad Oracle workspace.")
|
|
} label: {
|
|
Label("Mark Done", systemImage: "checkmark.circle")
|
|
}
|
|
}
|
|
|
|
if task.status.lowercased() != "pending" {
|
|
Button {
|
|
mutateTask(task, status: "pending", dueAt: task.dueAt, notes: "Reopened from the iPad Oracle workspace.")
|
|
} label: {
|
|
Label("Reopen", systemImage: "arrow.counterclockwise")
|
|
}
|
|
}
|
|
|
|
if !["done", "cancelled"].contains(task.status.lowercased()) {
|
|
Button {
|
|
let snoozeDate = task.nextSnoozeDate(adding: 2 * 60 * 60)
|
|
mutateTask(
|
|
task,
|
|
status: "snoozed",
|
|
dueAt: iso8601Timestamp(snoozeDate),
|
|
notes: "Snoozed by 2 hours from the iPad Oracle workspace."
|
|
)
|
|
} label: {
|
|
Label("Snooze 2h", systemImage: "clock.badge")
|
|
}
|
|
|
|
Button {
|
|
let snoozeDate = task.nextSnoozeDate(adding: 24 * 60 * 60)
|
|
mutateTask(
|
|
task,
|
|
status: "snoozed",
|
|
dueAt: iso8601Timestamp(snoozeDate),
|
|
notes: "Snoozed by 1 day from the iPad Oracle workspace."
|
|
)
|
|
} label: {
|
|
Label("Snooze 1 Day", systemImage: "moon")
|
|
}
|
|
}
|
|
|
|
if task.status.lowercased() != "cancelled" {
|
|
Button(role: .destructive) {
|
|
mutateTask(task, status: "cancelled", dueAt: nil, notes: "Cancelled from the iPad Oracle workspace.")
|
|
} label: {
|
|
Label("Cancel Task", systemImage: "xmark.circle")
|
|
}
|
|
}
|
|
} label: {
|
|
menuIcon("ellipsis.circle")
|
|
}
|
|
}
|
|
|
|
private func leadStageMenu(
|
|
leadId: String,
|
|
personId: String,
|
|
currentStatus: String
|
|
) -> some View {
|
|
Menu {
|
|
ForEach(canonicalLeadStages.filter { $0 != currentStatus.lowercased() }, id: \.self) { status in
|
|
Button {
|
|
mutateLeadStage(
|
|
leadId: leadId,
|
|
personId: personId,
|
|
status: status,
|
|
notes: "Moved from the iPad Oracle pipeline."
|
|
)
|
|
} label: {
|
|
Text(stageLabel(status))
|
|
}
|
|
}
|
|
} label: {
|
|
menuIcon("arrow.triangle.swap")
|
|
}
|
|
}
|
|
|
|
private func mutateTask(
|
|
_ task: VelocityTaskDTO,
|
|
status: String,
|
|
dueAt: String?,
|
|
notes: String
|
|
) {
|
|
actionError = nil
|
|
actionMessage = nil
|
|
activeTaskMutationID = task.reminderId
|
|
|
|
Task {
|
|
do {
|
|
_ = try await store.updateTaskStatus(
|
|
reminderId: task.reminderId,
|
|
status: status,
|
|
dueAt: dueAt,
|
|
notes: notes
|
|
)
|
|
await refreshClient360IfNeeded(for: task.personId ?? selectedClient360PersonID)
|
|
await MainActor.run {
|
|
activeTaskMutationID = nil
|
|
actionMessage = taskActionMessage(status: status)
|
|
}
|
|
} catch {
|
|
await MainActor.run {
|
|
activeTaskMutationID = nil
|
|
actionError = error.localizedDescription
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private func mutateLeadStage(
|
|
leadId: String,
|
|
personId: String,
|
|
status: String,
|
|
notes: String
|
|
) {
|
|
actionError = nil
|
|
actionMessage = nil
|
|
activeLeadMutationID = leadId
|
|
|
|
Task {
|
|
do {
|
|
_ = try await store.updateLeadStage(
|
|
leadId: leadId,
|
|
status: status,
|
|
notes: notes
|
|
)
|
|
await refreshClient360IfNeeded(for: personId)
|
|
await MainActor.run {
|
|
activeLeadMutationID = nil
|
|
actionMessage = "Lead moved to \(stageLabel(status))."
|
|
}
|
|
} catch {
|
|
await MainActor.run {
|
|
activeLeadMutationID = nil
|
|
actionError = error.localizedDescription
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private func mutateOpportunity(
|
|
_ opportunity: VelocityOpportunityDTO,
|
|
stage: String?,
|
|
probability: Int?,
|
|
nextAction: String?,
|
|
notes: String
|
|
) {
|
|
actionError = nil
|
|
actionMessage = nil
|
|
activeOpportunityMutationID = opportunity.opportunityId
|
|
|
|
Task {
|
|
do {
|
|
_ = try await store.updateOpportunity(
|
|
opportunityId: opportunity.opportunityId,
|
|
stage: stage,
|
|
probability: probability,
|
|
nextAction: nextAction,
|
|
notes: notes
|
|
)
|
|
await refreshClient360IfNeeded(for: opportunity.personId ?? selectedClient360PersonID)
|
|
await MainActor.run {
|
|
activeOpportunityMutationID = nil
|
|
actionMessage = opportunityActionMessage(stage: stage, probability: probability, nextAction: nextAction)
|
|
}
|
|
} catch {
|
|
await MainActor.run {
|
|
activeOpportunityMutationID = nil
|
|
actionError = error.localizedDescription
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private func refreshClient360IfNeeded(for personId: String?) async {
|
|
guard let personId, selectedClient360PersonID == personId else {
|
|
return
|
|
}
|
|
|
|
do {
|
|
let snapshot = try await VelocityAPIClient.shared.fetchClient360(personId: personId)
|
|
await MainActor.run {
|
|
selectedClient360 = snapshot
|
|
client360Error = nil
|
|
}
|
|
} catch {
|
|
await MainActor.run {
|
|
client360Error = error.localizedDescription
|
|
}
|
|
}
|
|
}
|
|
|
|
private var canonicalLeadStages: [String] {
|
|
[
|
|
"new",
|
|
"contacted",
|
|
"qualified",
|
|
"site_visit_scheduled",
|
|
"site_visited",
|
|
"negotiation",
|
|
"booking_initiated",
|
|
"booked",
|
|
"lost",
|
|
"dormant",
|
|
]
|
|
}
|
|
|
|
private var canonicalOpportunityStages: [String] {
|
|
[
|
|
"prospect",
|
|
"qualified",
|
|
"proposal",
|
|
"site_visit",
|
|
"negotiation",
|
|
"booking",
|
|
"agreement",
|
|
"closed_won",
|
|
"closed_lost",
|
|
]
|
|
}
|
|
|
|
private func stageLabel(_ status: String) -> String {
|
|
status.replacingOccurrences(of: "_", with: " ").capitalized
|
|
}
|
|
|
|
private func iso8601Timestamp(_ date: Date) -> String {
|
|
ISO8601DateFormatter().string(from: date)
|
|
}
|
|
|
|
private var client360PresentationBinding: Binding<Bool> {
|
|
Binding(
|
|
get: { selectedClient360PersonID != nil },
|
|
set: { isPresented in
|
|
if !isPresented {
|
|
selectedClient360PersonID = nil
|
|
selectedClient360 = nil
|
|
client360Error = nil
|
|
actionMessage = nil
|
|
isClient360Loading = false
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
@ViewBuilder
|
|
private var client360Sheet: some View {
|
|
NavigationStack {
|
|
ScrollView {
|
|
VStack(alignment: .leading, spacing: 18) {
|
|
if isClient360Loading {
|
|
ProgressView()
|
|
.progressViewStyle(CircularProgressViewStyle(tint: VelocityTheme.accent))
|
|
.frame(maxWidth: .infinity, alignment: .center)
|
|
.padding(.top, 40)
|
|
} else {
|
|
if let client360Error {
|
|
errorBanner(client360Error)
|
|
}
|
|
if let actionError {
|
|
errorBanner(actionError)
|
|
}
|
|
if let actionMessage {
|
|
successBanner(actionMessage)
|
|
}
|
|
if let snapshot = selectedClient360 {
|
|
client360IdentityCard(snapshot)
|
|
client360LeadCard(snapshot)
|
|
client360OpportunitiesCard(snapshot)
|
|
client360TasksCard(snapshot)
|
|
client360InteractionsCard(snapshot)
|
|
client360SignalsCard(snapshot)
|
|
}
|
|
}
|
|
}
|
|
.padding(20)
|
|
}
|
|
.background(VelocityTheme.background)
|
|
.navigationTitle("Client 360")
|
|
.toolbar {
|
|
ToolbarItem(placement: .topBarTrailing) {
|
|
Button("Done") {
|
|
selectedClient360PersonID = nil
|
|
selectedClient360 = nil
|
|
client360Error = nil
|
|
actionMessage = nil
|
|
isClient360Loading = false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private func openClient360(for personId: String) {
|
|
selectedClient360PersonID = personId
|
|
selectedClient360 = nil
|
|
client360Error = nil
|
|
actionError = nil
|
|
actionMessage = nil
|
|
isClient360Loading = true
|
|
|
|
Task {
|
|
do {
|
|
let snapshot = try await VelocityAPIClient.shared.fetchClient360(personId: personId)
|
|
await MainActor.run {
|
|
selectedClient360 = snapshot
|
|
client360Error = nil
|
|
isClient360Loading = false
|
|
}
|
|
} catch {
|
|
await MainActor.run {
|
|
selectedClient360 = nil
|
|
client360Error = error.localizedDescription
|
|
isClient360Loading = false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private func openClient360(personId: String?, missingContextMessage: String) {
|
|
guard let personId, !personId.isEmpty else {
|
|
actionError = missingContextMessage
|
|
actionMessage = nil
|
|
return
|
|
}
|
|
openClient360(for: personId)
|
|
}
|
|
|
|
private func client360IdentityCard(_ snapshot: VelocityClient360DTO) -> some View {
|
|
VStack(alignment: .leading, spacing: 10) {
|
|
Text(snapshot.identity.fullName)
|
|
.font(.system(size: 24, weight: .bold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Text("\(snapshot.identity.buyerType.map { $0.replacingOccurrences(of: "_", with: " ").capitalized } ?? "CRM contact") · \(snapshot.identity.primaryPhone ?? "No phone")")
|
|
.font(.system(size: 13))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
if let email = snapshot.identity.primaryEmail {
|
|
Text(email)
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
if !snapshot.identity.personaLabels.isEmpty {
|
|
Text(snapshot.identity.personaLabels.joined(separator: " · "))
|
|
.font(.system(size: 12, weight: .medium))
|
|
.foregroundStyle(VelocityTheme.accent)
|
|
}
|
|
}
|
|
.padding(18)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.glassCard(cornerRadius: 18)
|
|
}
|
|
|
|
private func client360LeadCard(_ snapshot: VelocityClient360DTO) -> some View {
|
|
VStack(alignment: .leading, spacing: 10) {
|
|
HStack {
|
|
Text("Lead Posture")
|
|
.font(.system(size: 16, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Spacer()
|
|
if let lead = snapshot.currentLead {
|
|
if activeLeadMutationID == lead.leadId {
|
|
ProgressView()
|
|
.progressViewStyle(CircularProgressViewStyle(tint: VelocityTheme.accent))
|
|
} else {
|
|
leadStageMenu(
|
|
leadId: lead.leadId,
|
|
personId: snapshot.identity.personId,
|
|
currentStatus: lead.status
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
if let lead = snapshot.currentLead {
|
|
Text("\(lead.status.replacingOccurrences(of: "_", with: " ").capitalized) · \(lead.urgency?.capitalized ?? "Normal") urgency")
|
|
.font(.system(size: 13))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Text(lead.budgetBand ?? "Budget pending")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
if !lead.motivations.isEmpty {
|
|
Text("Motivations: \(lead.motivations.joined(separator: ", "))")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
if !lead.objections.isEmpty {
|
|
Text("Objections: \(lead.objections.joined(separator: ", "))")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
} else {
|
|
Text("No active canonical lead context was returned for this client.")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
}
|
|
.padding(18)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.glassCard(cornerRadius: 18)
|
|
}
|
|
|
|
private func client360OpportunitiesCard(_ snapshot: VelocityClient360DTO) -> some View {
|
|
VStack(alignment: .leading, spacing: 10) {
|
|
Text("Active Opportunities")
|
|
.font(.system(size: 16, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
|
|
if snapshot.activeOpportunities.isEmpty {
|
|
Text("No active opportunities are currently attached to this client.")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
} else {
|
|
ForEach(snapshot.activeOpportunities) { opportunity in
|
|
HStack(alignment: .top, spacing: 12) {
|
|
VStack(alignment: .leading, spacing: 6) {
|
|
Text(opportunity.stage.replacingOccurrences(of: "_", with: " ").capitalized)
|
|
.font(.system(size: 13, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Text("\(opportunity.formattedValue) · \(opportunity.nextAction ?? "Next action pending")")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
Text(opportunity.probabilityLabel)
|
|
.font(.system(size: 11))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
Spacer()
|
|
if activeOpportunityMutationID == opportunity.opportunityId {
|
|
ProgressView()
|
|
.progressViewStyle(CircularProgressViewStyle(tint: VelocityTheme.accent))
|
|
} else {
|
|
opportunityActionsMenu(opportunity)
|
|
}
|
|
}
|
|
.padding(.vertical, 4)
|
|
}
|
|
}
|
|
}
|
|
.padding(18)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.glassCard(cornerRadius: 18)
|
|
}
|
|
|
|
private func client360TasksCard(_ snapshot: VelocityClient360DTO) -> some View {
|
|
VStack(alignment: .leading, spacing: 10) {
|
|
Text("Follow-Up Tasks")
|
|
.font(.system(size: 16, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
|
|
if snapshot.tasks.isEmpty {
|
|
Text("No pending or snoozed tasks were returned for this client.")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
} else {
|
|
ForEach(snapshot.tasks) { task in
|
|
HStack(alignment: .top, spacing: 12) {
|
|
VStack(alignment: .leading, spacing: 6) {
|
|
Text(task.title)
|
|
.font(.system(size: 13, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Text("\(task.priorityLabel) · \(task.dueLabel)")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
Spacer()
|
|
if activeTaskMutationID == task.reminderId {
|
|
ProgressView()
|
|
.progressViewStyle(CircularProgressViewStyle(tint: VelocityTheme.accent))
|
|
} else {
|
|
taskActionsMenu(task)
|
|
}
|
|
}
|
|
.padding(.vertical, 4)
|
|
}
|
|
}
|
|
}
|
|
.padding(18)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.glassCard(cornerRadius: 18)
|
|
}
|
|
|
|
private func client360InteractionsCard(_ snapshot: VelocityClient360DTO) -> some View {
|
|
VStack(alignment: .leading, spacing: 10) {
|
|
Text("Recent Interactions")
|
|
.font(.system(size: 16, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
|
|
if snapshot.recentInteractions.isEmpty {
|
|
Text("No recent canonical interactions were returned for this client.")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
} else {
|
|
ForEach(snapshot.recentInteractions.prefix(5)) { interaction in
|
|
VStack(alignment: .leading, spacing: 6) {
|
|
Text(interaction.channel.replacingOccurrences(of: "_", with: " ").capitalized)
|
|
.font(.system(size: 13, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
Text(interaction.summary ?? interaction.interactionType.replacingOccurrences(of: "_", with: " ").capitalized)
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
.padding(.vertical, 4)
|
|
}
|
|
}
|
|
}
|
|
.padding(18)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.glassCard(cornerRadius: 18)
|
|
}
|
|
|
|
private func client360SignalsCard(_ snapshot: VelocityClient360DTO) -> some View {
|
|
VStack(alignment: .leading, spacing: 10) {
|
|
Text("Signals And Actions")
|
|
.font(.system(size: 16, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
|
|
if let score = snapshot.primaryQDScore {
|
|
Text("\(score.scoreType.replacingOccurrences(of: "_", with: " ").capitalized) score: \(score.displayScore)")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.foreground)
|
|
}
|
|
if !snapshot.riskFlags.isEmpty {
|
|
Text("Risk flags: \(snapshot.riskFlags.joined(separator: ", "))")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
if !snapshot.recommendedNextActions.isEmpty {
|
|
Text("Next actions: \(snapshot.recommendedNextActions.joined(separator: " · "))")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
if !snapshot.propertyInterests.isEmpty {
|
|
Text("Primary interest: \(snapshot.propertyInterests[0].projectName)")
|
|
.font(.system(size: 12))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
}
|
|
}
|
|
.padding(18)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.glassCard(cornerRadius: 18)
|
|
}
|
|
|
|
private func errorBanner(_ message: String) -> some View {
|
|
Text(message)
|
|
.font(.system(size: 13, weight: .medium))
|
|
.foregroundStyle(VelocityTheme.danger)
|
|
.padding(14)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 14)
|
|
.fill(VelocityTheme.danger.opacity(0.10))
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: 14)
|
|
.stroke(VelocityTheme.danger.opacity(0.22), lineWidth: 1)
|
|
)
|
|
)
|
|
}
|
|
|
|
private func successBanner(_ message: String) -> some View {
|
|
Text(message)
|
|
.font(.system(size: 13, weight: .medium))
|
|
.foregroundStyle(VelocityTheme.success)
|
|
.padding(14)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
.background(
|
|
RoundedRectangle(cornerRadius: 14)
|
|
.fill(VelocityTheme.success.opacity(0.10))
|
|
.overlay(
|
|
RoundedRectangle(cornerRadius: 14)
|
|
.stroke(VelocityTheme.success.opacity(0.22), lineWidth: 1)
|
|
)
|
|
)
|
|
}
|
|
|
|
private func taskActionMessage(status: String) -> String {
|
|
switch status {
|
|
case "done":
|
|
return "Task marked done."
|
|
case "pending":
|
|
return "Task reopened."
|
|
case "snoozed":
|
|
return "Task snoozed."
|
|
case "cancelled":
|
|
return "Task cancelled."
|
|
default:
|
|
return "Task updated."
|
|
}
|
|
}
|
|
|
|
private func opportunityActionMessage(stage: String?, probability: Int?, nextAction: String?) -> String {
|
|
if let stage {
|
|
return "Opportunity moved to \(stageLabel(stage))."
|
|
}
|
|
if let probability {
|
|
return "Opportunity probability set to \(probability)%."
|
|
}
|
|
if nextAction != nil {
|
|
return "Opportunity follow-up action updated."
|
|
}
|
|
return "Opportunity updated."
|
|
}
|
|
|
|
private func menuIcon(_ systemName: String) -> some View {
|
|
Image(systemName: systemName)
|
|
.font(.system(size: 17, weight: .semibold))
|
|
.foregroundStyle(VelocityTheme.mutedFg)
|
|
.frame(width: 44, height: 44)
|
|
.contentShape(Rectangle())
|
|
}
|
|
}
|
|
|
|
#Preview {
|
|
OracleView()
|
|
}
|