2066 lines
85 KiB
Swift
2066 lines
85 KiB
Swift
import SwiftUI
|
||
import UniformTypeIdentifiers
|
||
import AppKit
|
||
|
||
struct ContentView: View {
|
||
@EnvironmentObject private var model: AppModel
|
||
@State private var selectedRequirementID: String?
|
||
@State private var isImportingRequirement = false
|
||
@State private var statusDismissTask: Task<Void, Never>?
|
||
|
||
private var selectedRequirement: RequirementItem? {
|
||
guard let selectedRequirementID else { return nil }
|
||
return model.dashboard.requirements.first { $0.id == selectedRequirementID }
|
||
}
|
||
|
||
private var processingMessage: String {
|
||
if let workflowAction = model.workflowAction { return workflowAction }
|
||
if model.isInitializingComplexDemo { return "正在生成 100 万笔交易并计算复杂指标…" }
|
||
if let caseID = model.analyzingCaseID { return "Codex 正在调查 \(caseID)…" }
|
||
if let caseID = model.runningCaseID { return "正在重跑 \(caseID)…" }
|
||
if let runID = model.generatingReportRunID { return "正在生成 \(runID) 的报告…" }
|
||
return "正在处理…"
|
||
}
|
||
|
||
var body: some View {
|
||
NavigationSplitView {
|
||
List(selection: $selectedRequirementID) {
|
||
Section("需求") {
|
||
ForEach(model.dashboard.requirements) { requirement in
|
||
RequirementSidebarRow(requirement: requirement)
|
||
.tag(requirement.id)
|
||
}
|
||
}
|
||
}
|
||
.navigationTitle("需求中心")
|
||
.overlay {
|
||
if model.dashboard.requirements.isEmpty {
|
||
ContentUnavailableView(
|
||
"尚无需求",
|
||
systemImage: "doc.badge.plus",
|
||
description: Text("导入需求文档，或初始化演示需求。")
|
||
)
|
||
}
|
||
}
|
||
.safeAreaInset(edge: .bottom) {
|
||
Button {
|
||
isImportingRequirement = true
|
||
} label: {
|
||
Label("导入需求", systemImage: "doc.badge.plus")
|
||
.frame(maxWidth: .infinity)
|
||
}
|
||
.buttonStyle(.borderedProminent)
|
||
.padding(12)
|
||
.background(.bar)
|
||
}
|
||
.navigationSplitViewColumnWidth(min: 190, ideal: 220, max: 260)
|
||
} detail: {
|
||
if let requirement = selectedRequirement {
|
||
RequirementWorkspaceView(requirement: requirement)
|
||
.id(requirement.id)
|
||
} else {
|
||
RequirementLandingView()
|
||
}
|
||
}
|
||
.toolbar {
|
||
ToolbarItemGroup {
|
||
Button {
|
||
isImportingRequirement = true
|
||
} label: {
|
||
Label("导入需求", systemImage: "doc.badge.plus")
|
||
}
|
||
Menu {
|
||
Button {
|
||
model.initializeComplexDemo()
|
||
} label: {
|
||
Label("复杂大数据体验（含故意错误）", systemImage: "cylinder.split.1x2.fill")
|
||
}
|
||
Button {
|
||
model.initializeDemo()
|
||
} label: {
|
||
Label("基础 SQLite 演示", systemImage: "shippingbox")
|
||
}
|
||
} label: {
|
||
Label("初始化演示", systemImage: "shippingbox")
|
||
}
|
||
.disabled(model.isLoading)
|
||
Button {
|
||
model.refresh()
|
||
} label: {
|
||
Label("刷新", systemImage: "arrow.clockwise")
|
||
}
|
||
.disabled(model.isLoading)
|
||
}
|
||
}
|
||
.overlay {
|
||
if model.isLoading && !model.isGeneratingCases && !model.isRunningTests {
|
||
ProgressView(processingMessage)
|
||
.padding(24)
|
||
.background(.regularMaterial, in: RoundedRectangle(cornerRadius: 14))
|
||
}
|
||
}
|
||
.overlay(alignment: .bottom) {
|
||
if let message = model.message {
|
||
StatusToast(message: message) {
|
||
model.clearMessage()
|
||
}
|
||
.padding(.horizontal, 24)
|
||
.padding(.bottom, 16)
|
||
.transition(.move(edge: .bottom).combined(with: .opacity))
|
||
}
|
||
}
|
||
.animation(.easeInOut(duration: 0.2), value: model.message)
|
||
.fileImporter(
|
||
isPresented: $isImportingRequirement,
|
||
allowedContentTypes: [.plainText, .text, UTType(filenameExtension: "md") ?? .plainText],
|
||
allowsMultipleSelection: false
|
||
) { result in
|
||
switch result {
|
||
case .success(let urls):
|
||
if let url = urls.first { model.importRequirement(from: url) }
|
||
case .failure(let error):
|
||
model.message = "导入需求失败：\(error.localizedDescription)"
|
||
}
|
||
}
|
||
.onChange(of: model.dashboard.requirements.map(\.id)) { _, ids in
|
||
if let selectedRequirementID, ids.contains(selectedRequirementID) {
|
||
return
|
||
} else {
|
||
selectedRequirementID = ids.first
|
||
}
|
||
}
|
||
.onChange(of: model.lastImportedRequirementID) { _, requirementID in
|
||
if let requirementID { selectedRequirementID = requirementID }
|
||
}
|
||
.onChange(of: model.message) { _, message in
|
||
statusDismissTask?.cancel()
|
||
guard let message else {
|
||
statusDismissTask = nil
|
||
return
|
||
}
|
||
statusDismissTask = Task { @MainActor in
|
||
do {
|
||
try await Task.sleep(for: .seconds(5))
|
||
} catch {
|
||
return
|
||
}
|
||
guard model.message == message else { return }
|
||
model.clearMessage()
|
||
}
|
||
}
|
||
.onDisappear {
|
||
statusDismissTask?.cancel()
|
||
statusDismissTask = nil
|
||
}
|
||
.task { model.refresh() }
|
||
}
|
||
}
|
||
|
||
struct RequirementSidebarRow: View {
|
||
let requirement: RequirementItem
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading, spacing: 5) {
|
||
Text(requirement.name).font(.headline).lineLimit(2)
|
||
HStack(spacing: 6) {
|
||
Text(requirement.id).font(.caption.monospaced())
|
||
Text("v\(requirement.current_version)").font(.caption)
|
||
Spacer()
|
||
StatusBadge(status: requirement.status)
|
||
}
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
.padding(.vertical, 6)
|
||
}
|
||
}
|
||
|
||
struct RequirementLandingView: View {
|
||
@EnvironmentObject private var model: AppModel
|
||
|
||
var body: some View {
|
||
if model.dashboard.requirements.isEmpty {
|
||
VStack(spacing: 18) {
|
||
ContentUnavailableView(
|
||
"从一个复杂需求开始",
|
||
systemImage: "point.3.connected.trianglepath.dotted",
|
||
description: Text("创建包含多表关联、全量/增量加工、V2 新增字段、复杂指标和故意错误的大数据体验。")
|
||
)
|
||
Button {
|
||
model.initializeComplexDemo()
|
||
} label: {
|
||
Label("创建复杂大数据体验", systemImage: "sparkles.rectangle.stack.fill")
|
||
}
|
||
.buttonStyle(.borderedProminent)
|
||
.controlSize(.large)
|
||
.disabled(model.isLoading)
|
||
Text("规模：10 万客户 · 20 万账户 · 100 万笔交易 · 30 个增量分区")
|
||
.font(.caption)
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
.padding(32)
|
||
} else {
|
||
ContentUnavailableView(
|
||
"选择一个需求",
|
||
systemImage: "arrow.left.circle",
|
||
description: Text("从左侧选择需求，查看其 Metadata、案例和运行结果。")
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
enum RequirementSection: String, CaseIterable, Identifiable {
|
||
case overview = "概览"
|
||
case metadata = "Metadata"
|
||
case cases = "测试案例"
|
||
case collaboration = "Codex 协作"
|
||
case runs = "运行记录"
|
||
case reports = "测试报告"
|
||
case metrics = "指标趋势"
|
||
|
||
var id: String { rawValue }
|
||
}
|
||
|
||
struct RequirementWorkspaceView: View {
|
||
@EnvironmentObject private var model: AppModel
|
||
let requirement: RequirementItem
|
||
@State private var section: RequirementSection = .overview
|
||
|
||
private var metadata: [MetadataTableItem] {
|
||
model.dashboard.metadata.filter { $0.requirement_id == requirement.id }
|
||
}
|
||
|
||
private var cases: [TestCaseItem] {
|
||
model.dashboard.case_items.filter { $0.requirement_id == requirement.id }
|
||
}
|
||
|
||
private var runs: [RunItem] {
|
||
model.dashboard.runs.filter { $0.requirement_id == requirement.id }
|
||
}
|
||
|
||
private var metrics: [MetricItem] {
|
||
model.dashboard.metrics.filter { $0.requirement_id == requirement.id }
|
||
}
|
||
|
||
private var reports: [ReportItem] {
|
||
model.dashboard.reports.filter { $0.requirement_id == requirement.id }
|
||
}
|
||
|
||
private var results: [CaseResultItem] {
|
||
model.dashboard.result_items.filter { $0.requirement_id == requirement.id }
|
||
}
|
||
|
||
private var analyses: [FailureAnalysisItem] {
|
||
model.dashboard.failure_analyses.filter { $0.requirement_id == requirement.id }
|
||
}
|
||
|
||
private var agentMessages: [CaseAgentMessageItem] {
|
||
model.dashboard.case_agent_messages.filter { $0.requirement_id == requirement.id }
|
||
}
|
||
|
||
private var reviewEvents: [CaseReviewEventItem] {
|
||
model.dashboard.case_review_events.filter { $0.requirement_id == requirement.id }
|
||
}
|
||
|
||
var body: some View {
|
||
VStack(spacing: 0) {
|
||
RequirementHeader(requirement: requirement, section: $section)
|
||
Divider()
|
||
Group {
|
||
switch section {
|
||
case .overview:
|
||
RequirementOverviewView(
|
||
requirement: requirement,
|
||
metadata: metadata,
|
||
cases: cases,
|
||
runs: runs
|
||
)
|
||
case .metadata:
|
||
RequirementMetadataView(requirement: requirement, tables: metadata)
|
||
case .cases:
|
||
RequirementCasesView(
|
||
requirement: requirement,
|
||
cases: cases,
|
||
results: results,
|
||
analyses: analyses,
|
||
reviewEvents: reviewEvents
|
||
)
|
||
case .collaboration:
|
||
CaseAgentConversationView(
|
||
requirement: requirement,
|
||
cases: cases,
|
||
messages: agentMessages
|
||
)
|
||
case .runs:
|
||
RequirementRunsView(requirement: requirement, runs: runs)
|
||
case .reports:
|
||
RequirementReportsView(requirement: requirement, runs: runs, reports: reports)
|
||
case .metrics:
|
||
RequirementMetricsView(requirement: requirement, metrics: metrics)
|
||
}
|
||
}
|
||
.frame(maxWidth: .infinity, maxHeight: .infinity)
|
||
}
|
||
.navigationTitle(requirement.name)
|
||
}
|
||
}
|
||
|
||
struct RequirementHeader: View {
|
||
@EnvironmentObject private var model: AppModel
|
||
let requirement: RequirementItem
|
||
@Binding var section: RequirementSection
|
||
|
||
private var hasCases: Bool {
|
||
model.dashboard.case_items.contains { $0.requirement_id == requirement.id }
|
||
}
|
||
|
||
private var scopeConfirmed: Bool {
|
||
requirement.status != "imported" && requirement.status != "pending_confirmation"
|
||
}
|
||
|
||
private var generateCaseHelp: String {
|
||
if !scopeConfirmed {
|
||
return "请先审核 Agent 探索出的数据库范围并锁定 Metadata"
|
||
}
|
||
if !requirement.metadata_complete {
|
||
return "请先确认需求范围并获取完整 Metadata"
|
||
}
|
||
if hasCases {
|
||
return "重新调用 Codex 生成候选案例；现有未审核草稿会被历史化，新案例仍需人工审核"
|
||
}
|
||
return "根据当前需求版本和真实 Metadata 生成待审核案例草稿"
|
||
}
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading, spacing: 14) {
|
||
HStack(alignment: .firstTextBaseline) {
|
||
VStack(alignment: .leading, spacing: 4) {
|
||
Text(requirement.name).font(.title2.bold())
|
||
Text("\(requirement.id) · 需求版本 v\(requirement.current_version)")
|
||
.font(.callout.monospaced()).foregroundStyle(.secondary)
|
||
}
|
||
Spacer()
|
||
Button {
|
||
model.generateCases(requirementID: requirement.id)
|
||
} label: {
|
||
Label("生成案例", systemImage: "wand.and.stars")
|
||
}
|
||
.buttonStyle(.borderedProminent)
|
||
.disabled(
|
||
!scopeConfirmed
|
||
|| !requirement.metadata_complete
|
||
|| model.isLoading
|
||
|| model.isChattingAboutCases
|
||
)
|
||
.help(generateCaseHelp)
|
||
StatusBadge(status: requirement.status)
|
||
}
|
||
Picker("需求视图", selection: $section) {
|
||
ForEach(RequirementSection.allCases) { item in
|
||
Text(item.rawValue).tag(item)
|
||
}
|
||
}
|
||
.pickerStyle(.segmented)
|
||
}
|
||
.padding(.horizontal, 24)
|
||
.padding(.top, 18)
|
||
.padding(.bottom, 16)
|
||
.background(.bar)
|
||
}
|
||
}
|
||
|
||
struct StatusBadge: View {
|
||
let status: String
|
||
|
||
private var color: Color {
|
||
switch status {
|
||
case "confirmed", "metadata_ready", "ready", "approved", "PASS": .green
|
||
case "FAIL", "invalid", "metadata_missing": .red
|
||
case "ERROR", "reviewing": .orange
|
||
case "rejected", "reviewed": .secondary
|
||
default: .blue
|
||
}
|
||
}
|
||
|
||
var body: some View {
|
||
Text(status)
|
||
.font(.caption.bold())
|
||
.padding(.horizontal, 9)
|
||
.padding(.vertical, 4)
|
||
.foregroundStyle(color)
|
||
.background(color.opacity(0.12), in: Capsule())
|
||
}
|
||
}
|
||
|
||
struct StatusToast: View {
|
||
let message: String
|
||
let dismiss: () -> Void
|
||
|
||
var body: some View {
|
||
HStack(spacing: 10) {
|
||
Image(systemName: "info.circle.fill")
|
||
.foregroundStyle(.tint)
|
||
Text(message)
|
||
.font(.callout)
|
||
.lineLimit(3)
|
||
.textSelection(.enabled)
|
||
Spacer(minLength: 12)
|
||
Button(action: dismiss) {
|
||
Image(systemName: "xmark")
|
||
.font(.caption.bold())
|
||
}
|
||
.buttonStyle(.plain)
|
||
.help("关闭通知")
|
||
}
|
||
.padding(.horizontal, 14)
|
||
.padding(.vertical, 11)
|
||
.frame(maxWidth: 720)
|
||
.background(.regularMaterial, in: RoundedRectangle(cornerRadius: 12))
|
||
.overlay {
|
||
RoundedRectangle(cornerRadius: 12)
|
||
.stroke(Color(nsColor: .separatorColor).opacity(0.55), lineWidth: 1)
|
||
}
|
||
.shadow(color: .black.opacity(0.16), radius: 12, y: 5)
|
||
}
|
||
}
|
||
|
||
struct RequirementOverviewView: View {
|
||
@EnvironmentObject private var model: AppModel
|
||
let requirement: RequirementItem
|
||
let metadata: [MetadataTableItem]
|
||
let cases: [TestCaseItem]
|
||
let runs: [RunItem]
|
||
@State private var supplementalContext = ""
|
||
|
||
private var sourceURL: URL {
|
||
URL(fileURLWithPath: requirement.source_path)
|
||
}
|
||
|
||
private var sourceFileExists: Bool {
|
||
FileManager.default.fileExists(atPath: requirement.source_path)
|
||
}
|
||
|
||
var body: some View {
|
||
ScrollView {
|
||
VStack(alignment: .leading, spacing: 22) {
|
||
HStack(spacing: 14) {
|
||
Image(systemName: "doc.text.fill")
|
||
.font(.title2)
|
||
.foregroundStyle(.tint)
|
||
VStack(alignment: .leading, spacing: 3) {
|
||
Text("需求文件").font(.headline)
|
||
Text(sourceURL.lastPathComponent)
|
||
.font(.callout)
|
||
Text("当前版本 v\(requirement.current_version)")
|
||
.font(.caption)
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
Spacer()
|
||
Button {
|
||
guard sourceFileExists else {
|
||
model.message = "需求文件不存在：\(requirement.source_path)"
|
||
return
|
||
}
|
||
if !NSWorkspace.shared.open(sourceURL) {
|
||
model.message = "无法打开需求文件：\(requirement.source_path)"
|
||
}
|
||
} label: {
|
||
Label("打开需求文件", systemImage: "arrow.up.forward.app")
|
||
}
|
||
.buttonStyle(.borderedProminent)
|
||
.disabled(!sourceFileExists)
|
||
.help(sourceFileExists ? requirement.source_path : "原始需求文件已不存在")
|
||
}
|
||
.padding(16)
|
||
.background(.quaternary.opacity(0.45), in: RoundedRectangle(cornerRadius: 12))
|
||
|
||
HStack(spacing: 14) {
|
||
SummaryCard(title: "Metadata 表", value: metadata.count, icon: "cylinder.split.1x2")
|
||
SummaryCard(title: "测试案例", value: cases.count, icon: "checklist")
|
||
SummaryCard(title: "已审核", value: cases.filter { $0.status == "approved" }.count, icon: "checkmark.seal")
|
||
SummaryCard(title: "运行批次", value: runs.count, icon: "play.circle")
|
||
}
|
||
|
||
GroupBox("需求测试流程") {
|
||
HStack(spacing: 8) {
|
||
FlowStep(title: "需求", ready: true)
|
||
FlowArrow()
|
||
FlowStep(
|
||
title: "范围确认",
|
||
ready: requirement.status != "imported"
|
||
&& requirement.status != "pending_confirmation"
|
||
)
|
||
FlowArrow()
|
||
FlowStep(
|
||
title: "Metadata",
|
||
ready: requirement.metadata_complete
|
||
&& requirement.status != "pending_confirmation"
|
||
)
|
||
FlowArrow()
|
||
FlowStep(title: "测试案例", ready: !cases.isEmpty)
|
||
FlowArrow()
|
||
FlowStep(title: "人工审核", ready: !cases.isEmpty && cases.allSatisfy { $0.status != "draft" && $0.status != "invalid" })
|
||
FlowArrow()
|
||
FlowStep(title: "执行", ready: !runs.isEmpty)
|
||
}
|
||
.padding(16)
|
||
}
|
||
|
||
RequirementWorkflowActionView(
|
||
requirement: requirement,
|
||
metadata: metadata,
|
||
cases: cases,
|
||
supplementalContext: $supplementalContext
|
||
)
|
||
|
||
if requirement.id == "REQ-RISK-002" {
|
||
HStack(alignment: .top, spacing: 12) {
|
||
Image(systemName: "exclamationmark.triangle.fill")
|
||
.foregroundStyle(.orange)
|
||
.font(.title3)
|
||
VStack(alignment: .leading, spacing: 5) {
|
||
Text("失败诊断体验已准备").font(.headline)
|
||
Text("数据中故意保留 1 条风险评分错误。运行全部案例后，进入“测试案例”，选择红色 FAIL 案例并点击“Codex 调查根因”。")
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
Spacer()
|
||
}
|
||
.padding(16)
|
||
.background(Color.orange.opacity(0.08), in: RoundedRectangle(cornerRadius: 12))
|
||
}
|
||
|
||
HStack {
|
||
VStack(alignment: .leading, spacing: 4) {
|
||
Text("运行该需求").font(.headline)
|
||
Text("只执行该需求下状态为 approved 的案例。")
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
Spacer()
|
||
Button {
|
||
model.runTests(requirementID: requirement.id)
|
||
} label: {
|
||
Label("运行全部已审核案例", systemImage: "play.fill")
|
||
}
|
||
.buttonStyle(.borderedProminent)
|
||
.disabled(cases.allSatisfy { $0.status != "approved" } || model.isLoading)
|
||
}
|
||
.padding(18)
|
||
.background(.quaternary.opacity(0.45), in: RoundedRectangle(cornerRadius: 14))
|
||
}
|
||
.padding(24)
|
||
}
|
||
}
|
||
}
|
||
|
||
struct RequirementWorkflowActionView: View {
|
||
@EnvironmentObject private var model: AppModel
|
||
let requirement: RequirementItem
|
||
let metadata: [MetadataTableItem]
|
||
let cases: [TestCaseItem]
|
||
@Binding var supplementalContext: String
|
||
@State private var isConfirmedScopeExpanded = false
|
||
|
||
private var pendingCases: Int {
|
||
cases.filter { $0.status == "draft" || $0.status == "invalid" }.count
|
||
}
|
||
|
||
private var scopeConfirmed: Bool {
|
||
requirement.status != "imported" && requirement.status != "pending_confirmation"
|
||
}
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading, spacing: 16) {
|
||
if let extraction = requirement.extraction, scopeConfirmed {
|
||
confirmedScopeDisclosure(extraction: extraction)
|
||
}
|
||
|
||
GroupBox("当前步骤") {
|
||
VStack(alignment: .leading, spacing: 14) {
|
||
if requirement.extraction == nil && cases.isEmpty {
|
||
workflowRow(
|
||
title: "1. Agent 探索数据库并解析需求",
|
||
detail: "只读探索本地 SQLite 的表、DDL、字段、索引、行数和样例，再提取精确测试范围并形成候选 Metadata。",
|
||
button: "探索数据库并解析",
|
||
icon: "sparkles"
|
||
) {
|
||
model.parseRequirement(requirementID: requirement.id)
|
||
}
|
||
} else if let extraction = requirement.extraction,
|
||
requirement.status == "pending_confirmation"
|
||
|| !requirement.metadata_ready {
|
||
ExtractionScopeView(extraction: extraction)
|
||
if extraction.open_questions.isEmpty
|
||
&& requirement.metadata_missing_tables.isEmpty {
|
||
workflowRow(
|
||
title: "2. 人工审核 Agent 探索结果",
|
||
detail: "候选 Metadata 已形成。确认库、表、字段映射和规则后，建立 ETL 任务并重新采集、锁定正式 Metadata。",
|
||
button: "确认范围并锁定 Metadata",
|
||
icon: "checkmark.seal.fill"
|
||
) {
|
||
model.confirmRequirement(requirementID: requirement.id)
|
||
}
|
||
} else {
|
||
Text("探索结果仍有待确认项，请补充说明后让 Agent 重新探索。")
|
||
.font(.callout.bold())
|
||
.foregroundStyle(.orange)
|
||
if !requirement.metadata_missing_tables.isEmpty {
|
||
Text("数据库中未找到：\(requirement.metadata_missing_tables.joined(separator: ", "))")
|
||
.font(.callout)
|
||
.foregroundStyle(.red)
|
||
}
|
||
TextEditor(text: $supplementalContext)
|
||
.font(.body)
|
||
.frame(minHeight: 72)
|
||
.padding(6)
|
||
.background(.quaternary.opacity(0.4), in: RoundedRectangle(cornerRadius: 8))
|
||
Button {
|
||
model.parseRequirement(
|
||
requirementID: requirement.id,
|
||
context: supplementalContext
|
||
)
|
||
} label: {
|
||
Label("提交补充并重新探索", systemImage: "arrow.triangle.2.circlepath")
|
||
}
|
||
.buttonStyle(.borderedProminent)
|
||
.disabled(supplementalContext.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty || model.isLoading)
|
||
}
|
||
} else if requirement.metadata_ready && !requirement.metadata_complete {
|
||
workflowRow(
|
||
title: "Metadata 未覆盖需求表",
|
||
detail: "缺少：\(requirement.metadata_missing_tables.joined(separator: ", "))。请先在本地 SQLite 准备这些表，再刷新 Metadata。",
|
||
button: "刷新 Metadata",
|
||
icon: "arrow.clockwise"
|
||
) {
|
||
model.refreshMetadata(requirementID: requirement.id)
|
||
}
|
||
} else if cases.isEmpty {
|
||
workflowRow(
|
||
title: "3. 根据 Metadata 生成案例草稿",
|
||
detail: "Codex 只能引用当前需求 Metadata 中存在的库、表和字段；生成结果不会自动批准。",
|
||
button: "生成测试案例",
|
||
icon: "wand.and.stars"
|
||
) {
|
||
model.generateCases(requirementID: requirement.id)
|
||
}
|
||
} else if pendingCases > 0 {
|
||
HStack(alignment: .top, spacing: 12) {
|
||
Image(systemName: "person.crop.circle.badge.checkmark")
|
||
.font(.title2).foregroundStyle(.orange)
|
||
VStack(alignment: .leading, spacing: 5) {
|
||
Text("4. 等待人工审核").font(.headline)
|
||
Text("还有 \(pendingCases) 条草稿或无效案例。可在“测试案例”逐条审核，或在“Codex 协作”中继续调整和补充。")
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
Spacer()
|
||
}
|
||
} else {
|
||
HStack(alignment: .top, spacing: 12) {
|
||
Image(systemName: "checkmark.seal.fill")
|
||
.font(.title2).foregroundStyle(.green)
|
||
VStack(alignment: .leading, spacing: 5) {
|
||
Text("审核完成，可以执行").font(.headline)
|
||
Text("确定性执行器只会运行状态为 approved 的案例。")
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
Spacer()
|
||
}
|
||
}
|
||
}
|
||
.padding(14)
|
||
}
|
||
|
||
if model.caseGenerationRequirementID == requirement.id
|
||
&& (model.isGeneratingCases || !model.caseGenerationProgress.isEmpty) {
|
||
CaseChatProgressCard(
|
||
events: model.caseGenerationProgress,
|
||
startedAt: model.caseGenerationStartedAt,
|
||
finishedAt: model.caseGenerationFinishedAt,
|
||
isRunning: model.isGeneratingCases,
|
||
error: model.caseGenerationError,
|
||
contextPhaseTitle: "读取需求与正式 Metadata",
|
||
codexPhaseTitle: "Codex 设计并生成测试案例",
|
||
runningHeadline: "Codex 正在生成测试案例",
|
||
completedHeadline: "测试案例生成完成",
|
||
completedDetail: "案例已保存为草稿，请进入测试案例页面进行人工审核"
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
private func confirmedScopeDisclosure(extraction: RequirementExtraction) -> some View {
|
||
DisclosureGroup(isExpanded: $isConfirmedScopeExpanded) {
|
||
ExtractionScopeView(extraction: extraction)
|
||
.padding(.top, 14)
|
||
} label: {
|
||
HStack(spacing: 11) {
|
||
Image(systemName: "checkmark.seal.fill")
|
||
.font(.title3)
|
||
.foregroundStyle(.green)
|
||
VStack(alignment: .leading, spacing: 3) {
|
||
Text("已确认需求范围")
|
||
.font(.headline)
|
||
Text("\(extraction.tasks.count) 个 ETL 任务 · \(metadata.count) 张 Metadata 表 · 点击展开查看库、表、字段和规则")
|
||
.font(.caption)
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
}
|
||
}
|
||
.padding(16)
|
||
.background(Color.green.opacity(0.06), in: RoundedRectangle(cornerRadius: 12))
|
||
.overlay {
|
||
RoundedRectangle(cornerRadius: 12)
|
||
.stroke(Color.green.opacity(0.20), lineWidth: 1)
|
||
}
|
||
.animation(.easeInOut(duration: 0.2), value: isConfirmedScopeExpanded)
|
||
}
|
||
|
||
@ViewBuilder
|
||
private func workflowRow(
|
||
title: String,
|
||
detail: String,
|
||
button: String,
|
||
icon: String,
|
||
action: @escaping () -> Void
|
||
) -> some View {
|
||
HStack(alignment: .center, spacing: 14) {
|
||
VStack(alignment: .leading, spacing: 5) {
|
||
Text(title).font(.headline)
|
||
Text(detail).foregroundStyle(.secondary)
|
||
}
|
||
Spacer()
|
||
Button(action: action) {
|
||
Label(button, systemImage: icon)
|
||
}
|
||
.buttonStyle(.borderedProminent)
|
||
.disabled(model.isLoading)
|
||
}
|
||
}
|
||
}
|
||
|
||
struct ExtractionScopeView: View {
|
||
let extraction: RequirementExtraction
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading, spacing: 14) {
|
||
HStack(alignment: .firstTextBaseline) {
|
||
VStack(alignment: .leading, spacing: 3) {
|
||
Text("Agent 提取的需求范围").font(.headline)
|
||
Text(extraction.requirement_name)
|
||
.font(.callout)
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
Spacer()
|
||
Text("\(extraction.tasks.count) 个 ETL 任务")
|
||
.font(.caption.bold())
|
||
.padding(.horizontal, 9)
|
||
.padding(.vertical, 4)
|
||
.background(Color.accentColor.opacity(0.10), in: Capsule())
|
||
}
|
||
|
||
ForEach(Array(extraction.tasks.enumerated()), id: \.offset) { index, task in
|
||
ExtractedTaskScopeCard(index: index + 1, task: task)
|
||
}
|
||
|
||
if !extraction.open_questions.isEmpty {
|
||
VStack(alignment: .leading, spacing: 9) {
|
||
Label("待确认问题", systemImage: "exclamationmark.bubble.fill")
|
||
.font(.subheadline.bold())
|
||
.foregroundStyle(.orange)
|
||
ForEach(Array(extraction.open_questions.enumerated()), id: \.offset) { index, question in
|
||
HStack(alignment: .top, spacing: 8) {
|
||
Text("\(index + 1).")
|
||
.font(.callout.bold().monospacedDigit())
|
||
.foregroundStyle(.orange)
|
||
Text(question).font(.callout)
|
||
}
|
||
}
|
||
}
|
||
.padding(12)
|
||
.frame(maxWidth: .infinity, alignment: .leading)
|
||
.background(Color.orange.opacity(0.08), in: RoundedRectangle(cornerRadius: 10))
|
||
.overlay {
|
||
RoundedRectangle(cornerRadius: 10)
|
||
.stroke(Color.orange.opacity(0.20), lineWidth: 1)
|
||
}
|
||
}
|
||
}
|
||
.textSelection(.enabled)
|
||
}
|
||
}
|
||
|
||
private struct ScopeMappingRow: Identifiable {
|
||
let id: Int
|
||
let source: String
|
||
let transformation: String
|
||
let target: String
|
||
}
|
||
|
||
private extension ExtractedTask {
|
||
var scopeMappingRows: [ScopeMappingRow] {
|
||
field_mappings.enumerated().map { index, value in
|
||
guard case .object(let mapping) = value else {
|
||
return ScopeMappingRow(
|
||
id: index, source: value.description,
|
||
transformation: "—", target: "—"
|
||
)
|
||
}
|
||
let source = mapping["source_field"]?.description ?? "—"
|
||
let target = mapping["target_field"]?.description ?? "—"
|
||
let rawTransformation = mapping["transformation"]?.description ?? ""
|
||
let transformation = rawTransformation == "null" || rawTransformation.isEmpty
|
||
? "直接映射" : rawTransformation
|
||
return ScopeMappingRow(
|
||
id: index, source: source,
|
||
transformation: transformation, target: target
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
struct ExtractedTaskScopeCard: View {
|
||
let index: Int
|
||
let task: ExtractedTask
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading, spacing: 14) {
|
||
HStack(spacing: 10) {
|
||
Text(String(format: "%02d", index))
|
||
.font(.caption.bold().monospacedDigit())
|
||
.foregroundStyle(.white)
|
||
.frame(width: 28, height: 28)
|
||
.background(Color.accentColor, in: Circle())
|
||
VStack(alignment: .leading, spacing: 2) {
|
||
Text("ETL 任务").font(.caption).foregroundStyle(.secondary)
|
||
Text(task.name).font(.headline)
|
||
}
|
||
Spacer()
|
||
}
|
||
|
||
Divider()
|
||
|
||
VStack(alignment: .leading, spacing: 8) {
|
||
ScopeSectionTitle(title: "数据血缘", icon: "point.3.connected.trianglepath.dotted")
|
||
Grid(alignment: .topLeading, horizontalSpacing: 18, verticalSpacing: 6) {
|
||
GridRow {
|
||
Text("源表 SOURCE").font(.caption.bold()).foregroundStyle(.secondary)
|
||
Color.clear.frame(width: 24, height: 1)
|
||
Text("目标表 TARGET").font(.caption.bold()).foregroundStyle(.secondary)
|
||
}
|
||
GridRow {
|
||
ScopeReferenceList(values: task.sources, color: .blue)
|
||
Image(systemName: "arrow.right")
|
||
.foregroundStyle(.secondary)
|
||
.frame(width: 24)
|
||
ScopeReferenceList(values: task.targets, color: .purple)
|
||
}
|
||
}
|
||
}
|
||
|
||
if !task.scopeMappingRows.isEmpty {
|
||
VStack(alignment: .leading, spacing: 8) {
|
||
ScopeSectionTitle(title: "字段映射", icon: "arrow.left.arrow.right")
|
||
Grid(alignment: .leading, horizontalSpacing: 16, verticalSpacing: 8) {
|
||
GridRow {
|
||
Text("源字段").font(.caption.bold()).foregroundStyle(.secondary)
|
||
Text("转换逻辑").font(.caption.bold()).foregroundStyle(.secondary)
|
||
Text("目标字段").font(.caption.bold()).foregroundStyle(.secondary)
|
||
}
|
||
Divider().gridCellColumns(3)
|
||
ForEach(task.scopeMappingRows) { mapping in
|
||
GridRow {
|
||
Text(mapping.source).font(.system(.callout, design: .monospaced))
|
||
Text(mapping.transformation)
|
||
.font(.callout)
|
||
.foregroundStyle(.secondary)
|
||
Text(mapping.target).font(.system(.callout, design: .monospaced))
|
||
}
|
||
}
|
||
}
|
||
.padding(10)
|
||
.frame(maxWidth: .infinity, alignment: .leading)
|
||
.background(.quaternary.opacity(0.28), in: RoundedRectangle(cornerRadius: 8))
|
||
}
|
||
}
|
||
|
||
if !task.rules.isEmpty {
|
||
VStack(alignment: .leading, spacing: 8) {
|
||
ScopeSectionTitle(title: "加工与校验规则", icon: "list.number")
|
||
ForEach(Array(task.rules.enumerated()), id: \.offset) { ruleIndex, rule in
|
||
HStack(alignment: .top, spacing: 9) {
|
||
Text("R\(ruleIndex + 1)")
|
||
.font(.caption.bold().monospaced())
|
||
.foregroundStyle(.tint)
|
||
.frame(width: 30, alignment: .leading)
|
||
Text(rule).font(.callout)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
.padding(16)
|
||
.frame(maxWidth: .infinity, alignment: .leading)
|
||
.background(.quaternary.opacity(0.28), in: RoundedRectangle(cornerRadius: 12))
|
||
.overlay {
|
||
RoundedRectangle(cornerRadius: 12)
|
||
.stroke(Color(nsColor: .separatorColor).opacity(0.45), lineWidth: 1)
|
||
}
|
||
}
|
||
}
|
||
|
||
struct ScopeReferenceList: View {
|
||
let values: [String]
|
||
let color: Color
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading, spacing: 6) {
|
||
ForEach(values, id: \.self) { value in
|
||
Text(value)
|
||
.font(.system(.callout, design: .monospaced).weight(.medium))
|
||
.foregroundStyle(color)
|
||
.padding(.horizontal, 8)
|
||
.padding(.vertical, 5)
|
||
.background(color.opacity(0.09), in: RoundedRectangle(cornerRadius: 6))
|
||
}
|
||
if values.isEmpty {
|
||
Text("未识别").font(.callout).foregroundStyle(.secondary)
|
||
}
|
||
}
|
||
.frame(maxWidth: .infinity, alignment: .leading)
|
||
}
|
||
}
|
||
|
||
struct ScopeSectionTitle: View {
|
||
let title: String
|
||
let icon: String
|
||
|
||
var body: some View {
|
||
Label(title, systemImage: icon)
|
||
.font(.subheadline.bold())
|
||
.foregroundStyle(.primary)
|
||
}
|
||
}
|
||
|
||
struct SummaryCard: View {
|
||
let title: String
|
||
let value: Int
|
||
let icon: String
|
||
|
||
var body: some View {
|
||
HStack(spacing: 12) {
|
||
Image(systemName: icon).font(.title2).foregroundStyle(.tint)
|
||
VStack(alignment: .leading, spacing: 2) {
|
||
Text("\(value)").font(.title2.bold().monospacedDigit())
|
||
Text(title).font(.caption).foregroundStyle(.secondary)
|
||
}
|
||
Spacer()
|
||
}
|
||
.padding(16)
|
||
.frame(maxWidth: .infinity)
|
||
.background(.quaternary.opacity(0.5), in: RoundedRectangle(cornerRadius: 12))
|
||
}
|
||
}
|
||
|
||
struct FlowStep: View {
|
||
let title: String
|
||
let ready: Bool
|
||
|
||
var body: some View {
|
||
Label(title, systemImage: ready ? "checkmark.circle.fill" : "circle.dashed")
|
||
.foregroundStyle(ready ? .green : .secondary)
|
||
.frame(maxWidth: .infinity)
|
||
}
|
||
}
|
||
|
||
struct FlowArrow: View {
|
||
var body: some View {
|
||
Image(systemName: "chevron.right").foregroundStyle(.tertiary)
|
||
}
|
||
}
|
||
|
||
struct RequirementMetadataView: View {
|
||
@EnvironmentObject private var model: AppModel
|
||
let requirement: RequirementItem
|
||
let tables: [MetadataTableItem]
|
||
@State private var selectedTableID: String?
|
||
|
||
private var selectedTable: MetadataTableItem? {
|
||
tables.first { $0.id == selectedTableID } ?? tables.first
|
||
}
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading, spacing: 16) {
|
||
if requirement.status == "pending_confirmation" && !tables.isEmpty {
|
||
HStack(alignment: .top, spacing: 10) {
|
||
Image(systemName: "sparkles")
|
||
.foregroundStyle(.tint)
|
||
VStack(alignment: .leading, spacing: 3) {
|
||
Text("Agent 探索形成的候选 Metadata").font(.headline)
|
||
Text("来自真实 SQLite 的只读探查结果。人工确认范围后会再次采集并锁定为正式 Metadata。")
|
||
.font(.callout)
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
Spacer()
|
||
StatusBadge(status: "待范围确认")
|
||
}
|
||
.padding(12)
|
||
.background(Color.accentColor.opacity(0.08), in: RoundedRectangle(cornerRadius: 10))
|
||
}
|
||
if let table = selectedTable {
|
||
HStack(alignment: .bottom, spacing: 18) {
|
||
VStack(alignment: .leading, spacing: 6) {
|
||
Text("当前需求的表").font(.caption).foregroundStyle(.secondary)
|
||
Picker("数据表", selection: $selectedTableID) {
|
||
ForEach(tables) { item in
|
||
Text("\(item.database_name).\(item.name)").tag(Optional(item.id))
|
||
}
|
||
}
|
||
.labelsHidden()
|
||
.frame(minWidth: 300)
|
||
}
|
||
Spacer()
|
||
Text("\(table.columns.count) 个字段").foregroundStyle(.secondary)
|
||
Text("\(table.row_count) 行").foregroundStyle(.secondary)
|
||
Button {
|
||
model.refreshMetadata(requirementID: requirement.id)
|
||
} label: {
|
||
Label("刷新", systemImage: "arrow.clockwise")
|
||
}
|
||
.disabled(model.isLoading)
|
||
}
|
||
Text("\(requirement.name) / \(table.database_name).\(table.name)")
|
||
.font(.title3.bold())
|
||
Table(table.columns) {
|
||
TableColumn("#", value: \.ordinalText).width(42)
|
||
TableColumn("字段名", value: \.name).width(min: 180, ideal: 260)
|
||
TableColumn("数据类型", value: \.type).width(min: 110, ideal: 150)
|
||
TableColumn("可为空", value: \.nullableText).width(75)
|
||
TableColumn("默认值", value: \.defaultText).width(min: 90, ideal: 120)
|
||
TableColumn("主键", value: \.primaryKeyText).width(55)
|
||
}
|
||
} else {
|
||
ContentUnavailableView(
|
||
"该需求尚无 Metadata",
|
||
systemImage: "cylinder",
|
||
description: Text("必须先获取当前需求关联表的 Metadata，才能生成案例。")
|
||
)
|
||
}
|
||
}
|
||
.padding(22)
|
||
.onAppear { selectFirstTable() }
|
||
.onChange(of: tables.map(\.id)) { _, _ in selectFirstTable() }
|
||
}
|
||
|
||
private func selectFirstTable() {
|
||
guard !tables.contains(where: { $0.id == selectedTableID }) else { return }
|
||
selectedTableID = tables.first?.id
|
||
}
|
||
}
|
||
|
||
struct RequirementCasesView: View {
|
||
@EnvironmentObject private var model: AppModel
|
||
let requirement: RequirementItem
|
||
let cases: [TestCaseItem]
|
||
let results: [CaseResultItem]
|
||
let analyses: [FailureAnalysisItem]
|
||
let reviewEvents: [CaseReviewEventItem]
|
||
@State private var selectedCaseID: String?
|
||
@State private var showAgentConfirmation = false
|
||
|
||
private var selectedCase: TestCaseItem? {
|
||
if let selectedCaseID { return cases.first { $0.id == selectedCaseID } }
|
||
return cases.first
|
||
}
|
||
|
||
private var latestResult: CaseResultItem? {
|
||
guard let caseID = selectedCase?.id else { return nil }
|
||
return results.first { $0.case_id == caseID }
|
||
}
|
||
|
||
private var latestAnalysis: FailureAnalysisItem? {
|
||
guard let resultID = latestResult?.id else { return nil }
|
||
return analyses.first { $0.result_id == resultID }
|
||
}
|
||
|
||
private func latestResult(for caseID: String) -> CaseResultItem? {
|
||
results.first { $0.case_id == caseID }
|
||
}
|
||
|
||
private func canAnalyze(_ result: CaseResultItem) -> Bool {
|
||
result.status == "FAIL" || result.status == "ERROR"
|
||
}
|
||
|
||
private var pendingCount: Int {
|
||
cases.filter { $0.status == "draft" || $0.status == "invalid" }.count
|
||
}
|
||
|
||
private var approvedCount: Int {
|
||
cases.filter { $0.status == "approved" }.count
|
||
}
|
||
|
||
private var runProgressByCase: [String: TestRunProgressEvent] {
|
||
guard model.testRunRequirementID == requirement.id else { return [:] }
|
||
var latest: [String: TestRunProgressEvent] = [:]
|
||
for event in model.testRunProgress {
|
||
if let caseID = event.case_id { latest[caseID] = event }
|
||
}
|
||
return latest
|
||
}
|
||
|
||
private var hasRunProgress: Bool {
|
||
model.testRunRequirementID == requirement.id
|
||
&& (model.isRunningTests || !model.testRunProgress.isEmpty)
|
||
}
|
||
|
||
private var runCompletedCount: Int {
|
||
runProgressByCase.values.filter {
|
||
["PASS", "FAIL", "ERROR"].contains($0.status)
|
||
}.count
|
||
}
|
||
|
||
private var runTotal: Int {
|
||
model.testRunProgress.compactMap(\.total).max()
|
||
?? (model.runningCaseID == nil ? approvedCount : 1)
|
||
}
|
||
|
||
private var runFinalStatus: String? {
|
||
model.testRunProgress.last(where: {
|
||
$0.event == "run_completed" || $0.type == "result"
|
||
})?.status
|
||
}
|
||
|
||
private func isActiveRunTarget(_ caseID: String) -> Bool {
|
||
model.isRunningTests
|
||
&& model.testRunRequirementID == requirement.id
|
||
&& (model.runningCaseID == nil || model.runningCaseID == caseID)
|
||
}
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading, spacing: 12) {
|
||
HStack {
|
||
Label("\(cases.count) 个案例", systemImage: "checklist")
|
||
Label("已通过 \(approvedCount)", systemImage: "checkmark.circle.fill")
|
||
.foregroundStyle(.green)
|
||
if pendingCount > 0 {
|
||
Label("待审核 \(pendingCount)", systemImage: "person.crop.circle.badge.questionmark")
|
||
.foregroundStyle(.orange)
|
||
}
|
||
if hasRunProgress {
|
||
Divider().frame(height: 18)
|
||
if model.isRunningTests {
|
||
ProgressView().controlSize(.small)
|
||
Text("执行中 \(runCompletedCount)/\(runTotal)")
|
||
.font(.callout.bold().monospacedDigit())
|
||
.foregroundStyle(.tint)
|
||
} else {
|
||
Text("最近执行 \(runCompletedCount)/\(runTotal)")
|
||
.font(.callout.monospacedDigit())
|
||
.foregroundStyle(.secondary)
|
||
if let runFinalStatus { StatusBadge(status: runFinalStatus) }
|
||
}
|
||
}
|
||
Spacer()
|
||
Button {
|
||
model.approveAllCases(requirementID: requirement.id)
|
||
} label: {
|
||
Label("批量审核通过", systemImage: "checkmark.seal")
|
||
}
|
||
.disabled(pendingCount == 0 || cases.contains { $0.status == "invalid" } || model.isLoading)
|
||
Button {
|
||
model.runTests(requirementID: requirement.id)
|
||
} label: {
|
||
Label("运行该需求", systemImage: "play.fill")
|
||
}
|
||
.disabled(cases.allSatisfy { $0.status != "approved" } || model.isLoading)
|
||
}
|
||
HSplitView {
|
||
List(cases, selection: $selectedCaseID) { item in
|
||
TestCaseNavigatorRow(
|
||
item: item,
|
||
result: latestResult(for: item.id),
|
||
progress: runProgressByCase[item.id],
|
||
isActiveRunTarget: isActiveRunTarget(item.id)
|
||
)
|
||
.tag(item.id)
|
||
}
|
||
.listStyle(.inset)
|
||
.frame(minWidth: 260, idealWidth: 300, maxWidth: 340)
|
||
|
||
Group {
|
||
if let item = selectedCase {
|
||
ScrollView {
|
||
VStack(alignment: .leading, spacing: 18) {
|
||
VStack(alignment: .leading, spacing: 10) {
|
||
HStack(spacing: 8) {
|
||
Text(item.id)
|
||
.font(.caption.bold().monospaced())
|
||
.foregroundStyle(.secondary)
|
||
StatusBadge(status: item.status)
|
||
if let result = latestResult {
|
||
StatusBadge(status: result.status)
|
||
}
|
||
Spacer()
|
||
}
|
||
Text(item.name)
|
||
.font(.title3.bold())
|
||
.fixedSize(horizontal: false, vertical: true)
|
||
Text("\(item.table_name) · \(item.category) · 案例 v\(item.version)")
|
||
.font(.caption.monospaced())
|
||
.foregroundStyle(.secondary)
|
||
.fixedSize(horizontal: false, vertical: true)
|
||
HStack(spacing: 8) {
|
||
if item.status != "approved" && item.status != "invalid" {
|
||
Button {
|
||
model.approveCase(caseID: item.id)
|
||
} label: {
|
||
Label("审核通过", systemImage: "checkmark.seal.fill")
|
||
}
|
||
.buttonStyle(.borderedProminent)
|
||
.disabled(model.isLoading)
|
||
}
|
||
if item.status != "rejected" {
|
||
Button(role: .destructive) {
|
||
model.rejectCase(caseID: item.id)
|
||
} label: {
|
||
Label(item.status == "approved" ? "撤回批准" : "驳回", systemImage: "xmark.circle")
|
||
}
|
||
.disabled(model.isLoading)
|
||
}
|
||
Button {
|
||
model.runSingleCase(requirementID: requirement.id, caseID: item.id)
|
||
} label: {
|
||
Label("单独重跑", systemImage: "arrow.clockwise.circle.fill")
|
||
}
|
||
.buttonStyle(.borderedProminent)
|
||
.disabled(item.status != "approved" || model.isLoading)
|
||
Spacer(minLength: 0)
|
||
}
|
||
}
|
||
.padding(16)
|
||
.frame(maxWidth: .infinity, alignment: .leading)
|
||
.background(.quaternary.opacity(0.45), in: RoundedRectangle(cornerRadius: 12))
|
||
|
||
if let result = latestResult {
|
||
LatestCaseResultView(
|
||
result: result,
|
||
canAnalyze: canAnalyze(result),
|
||
isAnalyzing: model.analyzingCaseID == item.id
|
||
) {
|
||
showAgentConfirmation = true
|
||
}
|
||
}
|
||
if !item.validation_errors.isEmpty {
|
||
VStack(alignment: .leading, spacing: 5) {
|
||
Label("案例未通过确定性校验", systemImage: "exclamationmark.triangle.fill")
|
||
.font(.subheadline.bold())
|
||
.foregroundStyle(.red)
|
||
ForEach(item.validation_errors, id: \.self) { error in
|
||
Text("• \(error)").font(.callout)
|
||
}
|
||
}
|
||
.padding(12)
|
||
.frame(maxWidth: .infinity, alignment: .leading)
|
||
.background(Color.red.opacity(0.08), in: RoundedRectangle(cornerRadius: 8))
|
||
}
|
||
|
||
VStack(alignment: .leading, spacing: 7) {
|
||
Label("字段范围", systemImage: "text.line.first.and.arrowtriangle.forward")
|
||
.font(.subheadline.bold())
|
||
Text(item.fields.isEmpty ? "表级" : item.fields.joined(separator: ", "))
|
||
.font(.callout.monospaced())
|
||
.foregroundStyle(.secondary)
|
||
.textSelection(.enabled)
|
||
}
|
||
|
||
VStack(alignment: .leading, spacing: 8) {
|
||
Label("执行 SQL", systemImage: "terminal")
|
||
.font(.subheadline.bold())
|
||
SQLCodeView(sql: item.sql)
|
||
}
|
||
|
||
VStack(alignment: .leading, spacing: 8) {
|
||
Label("确定性断言", systemImage: "checkmark.shield")
|
||
.font(.subheadline.bold())
|
||
ForEach(Array(item.assertions.enumerated()), id: \.offset) { _, assertion in
|
||
Text(assertionText(assertion))
|
||
.font(.system(.callout, design: .monospaced))
|
||
.textSelection(.enabled)
|
||
}
|
||
}
|
||
|
||
let itemReviews = reviewEvents.filter { $0.case_id == item.id }
|
||
if !itemReviews.isEmpty {
|
||
VStack(alignment: .leading, spacing: 8) {
|
||
Label("人工审核记录", systemImage: "person.crop.circle.badge.checkmark")
|
||
.font(.subheadline.bold())
|
||
ForEach(itemReviews.prefix(5)) { review in
|
||
VStack(alignment: .leading, spacing: 4) {
|
||
HStack {
|
||
StatusBadge(status: review.decision)
|
||
Text("案例 v\(review.case_version)")
|
||
.font(.caption.bold().monospaced())
|
||
}
|
||
Text(review.created_at)
|
||
.font(.caption2.monospaced())
|
||
.foregroundStyle(.secondary)
|
||
if let comment = review.comment {
|
||
Text(comment).font(.caption)
|
||
}
|
||
}
|
||
.padding(10)
|
||
.frame(maxWidth: .infinity, alignment: .leading)
|
||
.background(.quaternary.opacity(0.35), in: RoundedRectangle(cornerRadius: 8))
|
||
}
|
||
}
|
||
}
|
||
if let latestAnalysis {
|
||
FailureAnalysisView(item: latestAnalysis)
|
||
}
|
||
}
|
||
.padding(18)
|
||
.frame(maxWidth: .infinity, alignment: .leading)
|
||
}
|
||
} else {
|
||
ContentUnavailableView("选择一个测试案例", systemImage: "checklist")
|
||
}
|
||
}
|
||
.frame(minWidth: 360, maxWidth: .infinity, maxHeight: .infinity)
|
||
}
|
||
.background(.quaternary.opacity(0.16), in: RoundedRectangle(cornerRadius: 12))
|
||
.clipShape(RoundedRectangle(cornerRadius: 12))
|
||
}
|
||
.padding(16)
|
||
.overlay {
|
||
if cases.isEmpty {
|
||
ContentUnavailableView(
|
||
"该需求尚无测试案例",
|
||
systemImage: "checklist",
|
||
description: Text("确认 Metadata 和测试范围后再生成案例。")
|
||
)
|
||
}
|
||
}
|
||
.onAppear { selectedCaseID = cases.first?.id }
|
||
.onChange(of: cases.map(\.id)) { _, ids in
|
||
if let selectedCaseID, ids.contains(selectedCaseID) { return }
|
||
selectedCaseID = ids.first
|
||
}
|
||
.confirmationDialog(
|
||
"允许 Codex 调查失败根因？",
|
||
isPresented: $showAgentConfirmation
|
||
) {
|
||
Button("继续调查") {
|
||
guard let item = selectedCase, let result = latestResult, canAnalyze(result) else { return }
|
||
model.analyzeFailure(runID: result.run_id, caseID: item.id)
|
||
}
|
||
Button("取消", role: .cancel) {}
|
||
} message: {
|
||
Text("将该需求版本、Metadata、测试 SQL、断言和失败样例交给当前 Codex CLI 配置的模型服务分析。只调查并保存结论，不会自动修改数据。")
|
||
}
|
||
}
|
||
|
||
private func assertionText(_ assertion: CaseAssertion) -> String {
|
||
let actual = assertion.actual ?? "result"
|
||
if let expected = assertion.expected {
|
||
return "\(assertion.type): \(actual) → \(expected.description)"
|
||
}
|
||
if let minimum = assertion.minimum, let maximum = assertion.maximum {
|
||
return "\(assertion.type): \(minimum) ≤ \(actual) ≤ \(maximum)"
|
||
}
|
||
return "\(assertion.type): \(actual)"
|
||
}
|
||
}
|
||
|
||
struct TestCaseNavigatorRow: View {
|
||
let item: TestCaseItem
|
||
let result: CaseResultItem?
|
||
let progress: TestRunProgressEvent?
|
||
let isActiveRunTarget: Bool
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading, spacing: 7) {
|
||
HStack(spacing: 7) {
|
||
Text(item.id)
|
||
.font(.caption.bold().monospaced())
|
||
Spacer()
|
||
if let progress {
|
||
CaseExecutionStatus(
|
||
status: progress.status,
|
||
durationMS: progress.duration_ms
|
||
)
|
||
} else if isActiveRunTarget {
|
||
CaseExecutionStatus(status: "PENDING", durationMS: nil)
|
||
} else if let result {
|
||
CaseExecutionStatus(status: result.status, durationMS: result.duration_ms)
|
||
} else {
|
||
StatusBadge(status: item.status)
|
||
}
|
||
}
|
||
Text(item.name)
|
||
.font(.callout.weight(.semibold))
|
||
.lineLimit(2)
|
||
.fixedSize(horizontal: false, vertical: true)
|
||
Text(item.table_name)
|
||
.font(.caption.monospaced())
|
||
.foregroundStyle(.secondary)
|
||
.lineLimit(1)
|
||
Text(item.category)
|
||
.font(.caption2)
|
||
.foregroundStyle(.tertiary)
|
||
.lineLimit(1)
|
||
}
|
||
.padding(.vertical, 6)
|
||
.frame(maxWidth: .infinity, alignment: .leading)
|
||
}
|
||
}
|
||
|
||
struct CaseExecutionStatus: View {
|
||
let status: String
|
||
let durationMS: Int?
|
||
|
||
private var color: Color {
|
||
switch status {
|
||
case "PASS": return .green
|
||
case "FAIL": return .red
|
||
case "ERROR": return .orange
|
||
case "RUNNING": return .accentColor
|
||
default: return .secondary
|
||
}
|
||
}
|
||
|
||
private var title: String {
|
||
switch status {
|
||
case "PENDING": return "等待"
|
||
case "RUNNING": return "执行中"
|
||
default: return status
|
||
}
|
||
}
|
||
|
||
var body: some View {
|
||
HStack(spacing: 5) {
|
||
if status == "RUNNING" {
|
||
ProgressView().controlSize(.mini)
|
||
} else {
|
||
Image(systemName: iconName)
|
||
.font(.caption)
|
||
}
|
||
Text(title)
|
||
.font(.caption.bold().monospacedDigit())
|
||
if let durationMS {
|
||
Text(durationMS >= 1_000
|
||
? String(format: "%.2fs", Double(durationMS) / 1_000)
|
||
: "\(durationMS)ms")
|
||
.font(.caption2.monospacedDigit())
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
}
|
||
.foregroundStyle(color)
|
||
}
|
||
|
||
private var iconName: String {
|
||
switch status {
|
||
case "PASS": return "checkmark.circle.fill"
|
||
case "FAIL": return "xmark.circle.fill"
|
||
case "ERROR": return "exclamationmark.triangle.fill"
|
||
default: return "circle.dotted"
|
||
}
|
||
}
|
||
}
|
||
|
||
struct CaseAgentConversationView: View {
|
||
@EnvironmentObject private var model: AppModel
|
||
let requirement: RequirementItem
|
||
let cases: [TestCaseItem]
|
||
let messages: [CaseAgentMessageItem]
|
||
@State private var draftMessage = ""
|
||
|
||
private var canSend: Bool {
|
||
!cases.isEmpty
|
||
&& requirement.metadata_complete
|
||
&& !draftMessage.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
|
||
&& !model.isLoading
|
||
&& !model.isChattingAboutCases
|
||
}
|
||
|
||
var body: some View {
|
||
VStack(spacing: 0) {
|
||
HStack(alignment: .top, spacing: 12) {
|
||
Image(systemName: "sparkles")
|
||
.font(.title2)
|
||
.foregroundStyle(.tint)
|
||
VStack(alignment: .leading, spacing: 4) {
|
||
Text("与 Codex 协作调整测试案例").font(.headline)
|
||
Text("可要求修改 SQL、断言、字段范围，或补充边界、分布、波动、全量与增量案例。新增或修改内容一律保存为草稿，必须重新人工审核。")
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
Spacer()
|
||
}
|
||
.padding(18)
|
||
.background(.bar)
|
||
|
||
ScrollViewReader { proxy in
|
||
ScrollView {
|
||
LazyVStack(spacing: 12) {
|
||
if messages.isEmpty
|
||
&& model.pendingCaseChatMessage == nil
|
||
&& !model.isChattingAboutCases
|
||
&& model.caseChatProgress.isEmpty {
|
||
ContentUnavailableView(
|
||
"尚无沟通记录",
|
||
systemImage: "bubble.left.and.bubble.right",
|
||
description: Text(cases.isEmpty ? "请先生成测试案例。" : "描述你希望调整或补充的案例。")
|
||
)
|
||
.frame(minHeight: 260)
|
||
}
|
||
ForEach(messages) { message in
|
||
CaseAgentMessageBubble(message: message)
|
||
.id(message.id)
|
||
}
|
||
if let pendingMessage = model.pendingCaseChatMessage {
|
||
PendingCaseChatMessageBubble(content: pendingMessage)
|
||
.id("pending-case-chat-message")
|
||
}
|
||
if model.isChattingAboutCases || !model.caseChatProgress.isEmpty {
|
||
CaseChatProgressCard(
|
||
events: model.caseChatProgress,
|
||
startedAt: model.caseChatStartedAt,
|
||
finishedAt: model.caseChatFinishedAt,
|
||
isRunning: model.isChattingAboutCases,
|
||
error: model.caseChatError
|
||
)
|
||
.id("case-chat-progress")
|
||
}
|
||
}
|
||
.padding(20)
|
||
}
|
||
.onChange(of: messages.map(\.id)) { _, ids in
|
||
if let last = ids.last { proxy.scrollTo(last, anchor: .bottom) }
|
||
}
|
||
.onChange(of: model.caseChatProgress.count) { _, _ in
|
||
withAnimation { proxy.scrollTo("case-chat-progress", anchor: .bottom) }
|
||
}
|
||
}
|
||
|
||
Divider()
|
||
VStack(alignment: .leading, spacing: 10) {
|
||
TextEditor(text: $draftMessage)
|
||
.font(.body)
|
||
.frame(minHeight: 74, maxHeight: 130)
|
||
.padding(6)
|
||
.background(.quaternary.opacity(0.45), in: RoundedRectangle(cornerRadius: 10))
|
||
HStack {
|
||
Label("发送时会向本机 Codex CLI 提供需求版本、Metadata、当前案例和本需求沟通历史。", systemImage: "lock.shield")
|
||
.font(.caption)
|
||
.foregroundStyle(.secondary)
|
||
Spacer()
|
||
Button {
|
||
let message = draftMessage.trimmingCharacters(in: .whitespacesAndNewlines)
|
||
guard !message.isEmpty else { return }
|
||
draftMessage = ""
|
||
model.chatAboutCases(requirementID: requirement.id, message: message)
|
||
} label: {
|
||
Label(
|
||
model.isChattingAboutCases ? "处理中" : "发送给 Codex",
|
||
systemImage: model.isChattingAboutCases ? "sparkles" : "paperplane.fill"
|
||
)
|
||
}
|
||
.buttonStyle(.borderedProminent)
|
||
.disabled(!canSend)
|
||
}
|
||
}
|
||
.padding(16)
|
||
.background(.bar)
|
||
}
|
||
}
|
||
}
|
||
|
||
struct PendingCaseChatMessageBubble: View {
|
||
let content: String
|
||
|
||
var body: some View {
|
||
HStack {
|
||
Spacer(minLength: 80)
|
||
VStack(alignment: .leading, spacing: 6) {
|
||
Label("你", systemImage: "person.fill")
|
||
.font(.caption.bold())
|
||
Text(content).textSelection(.enabled)
|
||
Text("已发送")
|
||
.font(.caption2)
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
.padding(12)
|
||
.background(Color.accentColor.opacity(0.13), in: RoundedRectangle(cornerRadius: 12))
|
||
}
|
||
}
|
||
}
|
||
|
||
enum CaseChatPhaseState {
|
||
case pending, running, completed, failed
|
||
}
|
||
|
||
struct CaseChatProgressCard: View {
|
||
let events: [CaseChatProgressEvent]
|
||
let startedAt: Date?
|
||
let finishedAt: Date?
|
||
let isRunning: Bool
|
||
let error: String?
|
||
let contextPhaseTitle: String
|
||
let codexPhaseTitle: String
|
||
let runningHeadline: String
|
||
let completedHeadline: String
|
||
let completedDetail: String
|
||
@State private var showsActivity = true
|
||
|
||
init(
|
||
events: [CaseChatProgressEvent],
|
||
startedAt: Date?,
|
||
finishedAt: Date?,
|
||
isRunning: Bool,
|
||
error: String?,
|
||
contextPhaseTitle: String = "读取需求、Metadata 与案例历史",
|
||
codexPhaseTitle: String = "Codex 分析并生成案例变更",
|
||
runningHeadline: String = "Codex 正在处理",
|
||
completedHeadline: String = "案例调整已完成",
|
||
completedDetail: String = "所有变更均以草稿保存，等待人工审核"
|
||
) {
|
||
self.events = events
|
||
self.startedAt = startedAt
|
||
self.finishedAt = finishedAt
|
||
self.isRunning = isRunning
|
||
self.error = error
|
||
self.contextPhaseTitle = contextPhaseTitle
|
||
self.codexPhaseTitle = codexPhaseTitle
|
||
self.runningHeadline = runningHeadline
|
||
self.completedHeadline = completedHeadline
|
||
self.completedDetail = completedDetail
|
||
}
|
||
|
||
private var phases: [(id: String, title: String, icon: String)] {
|
||
[
|
||
("context", contextPhaseTitle, "doc.text.magnifyingglass"),
|
||
("codex", codexPhaseTitle, "sparkles"),
|
||
("validation", "确定性校验 SQL、字段与断言", "checkmark.shield"),
|
||
("persistence", "版本化保存待审核草稿", "tray.and.arrow.down"),
|
||
]
|
||
}
|
||
|
||
private var completedPhaseCount: Int {
|
||
phases.filter { phaseState(for: $0.id) == .completed }.count
|
||
}
|
||
|
||
private var headline: String {
|
||
if error != nil { return "处理失败" }
|
||
if isRunning { return runningHeadline }
|
||
return completedHeadline
|
||
}
|
||
|
||
private var headlineColor: Color {
|
||
if error != nil { return .red }
|
||
return isRunning ? .accentColor : .green
|
||
}
|
||
|
||
private func phaseState(for phase: String) -> CaseChatPhaseState {
|
||
let phaseEvents = events.filter { $0.phase == phase }
|
||
if phaseEvents.contains(where: { $0.status == "failed" }) { return .failed }
|
||
if phaseEvents.contains(where: { $0.status == "completed" }) { return .completed }
|
||
if !phaseEvents.isEmpty { return .running }
|
||
return .pending
|
||
}
|
||
|
||
private func elapsedText(at date: Date) -> String {
|
||
guard let startedAt else { return "0:00" }
|
||
let end = finishedAt ?? date
|
||
let seconds = max(0, Int(end.timeIntervalSince(startedAt)))
|
||
return String(format: "%d:%02d", seconds / 60, seconds % 60)
|
||
}
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading, spacing: 14) {
|
||
HStack(spacing: 12) {
|
||
ZStack {
|
||
RoundedRectangle(cornerRadius: 10)
|
||
.fill(headlineColor.opacity(0.12))
|
||
Image(systemName: error != nil ? "exclamationmark.triangle.fill" : "sparkles")
|
||
.font(.title3)
|
||
.foregroundStyle(headlineColor)
|
||
}
|
||
.frame(width: 38, height: 38)
|
||
VStack(alignment: .leading, spacing: 3) {
|
||
Text(headline).font(.headline)
|
||
Text(isRunning ? "页面可继续浏览，任务会在此处实时更新" : (error ?? completedDetail))
|
||
.font(.caption)
|
||
.foregroundStyle(error == nil ? Color.secondary : Color.red)
|
||
}
|
||
Spacer()
|
||
TimelineView(.periodic(from: .now, by: 1)) { context in
|
||
Label(elapsedText(at: context.date), systemImage: "clock")
|
||
.font(.caption.monospacedDigit())
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
}
|
||
|
||
ProgressView(value: Double(completedPhaseCount), total: Double(phases.count))
|
||
.tint(headlineColor)
|
||
|
||
VStack(alignment: .leading, spacing: 11) {
|
||
ForEach(phases, id: \.id) { phase in
|
||
CaseChatPhaseRow(
|
||
title: phase.title,
|
||
icon: phase.icon,
|
||
state: phaseState(for: phase.id)
|
||
)
|
||
}
|
||
}
|
||
|
||
if !events.isEmpty {
|
||
Divider()
|
||
DisclosureGroup(isExpanded: $showsActivity) {
|
||
VStack(alignment: .leading, spacing: 9) {
|
||
ForEach(Array(events.suffix(8))) { event in
|
||
HStack(alignment: .top, spacing: 8) {
|
||
Circle()
|
||
.fill(event.status == "failed" ? Color.red : Color.secondary.opacity(0.55))
|
||
.frame(width: 5, height: 5)
|
||
.padding(.top, 6)
|
||
VStack(alignment: .leading, spacing: 2) {
|
||
Text(event.title).font(.caption.bold())
|
||
Text(event.detail)
|
||
.font(.caption)
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
.padding(.top, 10)
|
||
} label: {
|
||
Label("实时活动 · (events.count)", systemImage: "waveform.path.ecg")
|
||
.font(.caption.bold())
|
||
}
|
||
}
|
||
}
|
||
.padding(16)
|
||
.background(.regularMaterial, in: RoundedRectangle(cornerRadius: 14))
|
||
.overlay {
|
||
RoundedRectangle(cornerRadius: 14)
|
||
.stroke(headlineColor.opacity(0.22), lineWidth: 1)
|
||
}
|
||
}
|
||
}
|
||
|
||
struct CaseChatPhaseRow: View {
|
||
let title: String
|
||
let icon: String
|
||
let state: CaseChatPhaseState
|
||
|
||
private var color: Color {
|
||
switch state {
|
||
case .pending: return .secondary
|
||
case .running: return .accentColor
|
||
case .completed: return .green
|
||
case .failed: return .red
|
||
}
|
||
}
|
||
|
||
var body: some View {
|
||
HStack(spacing: 10) {
|
||
Group {
|
||
switch state {
|
||
case .running:
|
||
ProgressView().controlSize(.small)
|
||
case .completed:
|
||
Image(systemName: "checkmark.circle.fill")
|
||
case .failed:
|
||
Image(systemName: "xmark.circle.fill")
|
||
case .pending:
|
||
Image(systemName: "circle")
|
||
}
|
||
}
|
||
.frame(width: 18, height: 18)
|
||
.foregroundStyle(color)
|
||
Image(systemName: icon)
|
||
.frame(width: 18)
|
||
.foregroundStyle(color)
|
||
Text(title)
|
||
.font(.subheadline)
|
||
.foregroundStyle(state == .pending ? .secondary : .primary)
|
||
Spacer()
|
||
if state == .running {
|
||
Text("进行中").font(.caption).foregroundStyle(color)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
struct CaseAgentMessageBubble: View {
|
||
let message: CaseAgentMessageItem
|
||
|
||
var body: some View {
|
||
HStack {
|
||
if message.role == "user" { Spacer(minLength: 80) }
|
||
VStack(alignment: .leading, spacing: 6) {
|
||
Label(
|
||
message.role == "user" ? "你" : "Codex",
|
||
systemImage: message.role == "user" ? "person.fill" : "sparkles"
|
||
)
|
||
.font(.caption.bold())
|
||
Text(message.content)
|
||
.textSelection(.enabled)
|
||
Text(message.created_at)
|
||
.font(.caption2.monospaced())
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
.padding(12)
|
||
.background(
|
||
message.role == "user" ? Color.accentColor.opacity(0.13) : Color.secondary.opacity(0.10),
|
||
in: RoundedRectangle(cornerRadius: 12)
|
||
)
|
||
if message.role != "user" { Spacer(minLength: 80) }
|
||
}
|
||
}
|
||
}
|
||
|
||
struct LatestCaseResultView: View {
|
||
let result: CaseResultItem
|
||
let canAnalyze: Bool
|
||
let isAnalyzing: Bool
|
||
let analyze: () -> Void
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading, spacing: 10) {
|
||
HStack(spacing: 8) {
|
||
Text("最近结果").font(.subheadline.bold())
|
||
StatusBadge(status: result.status)
|
||
Spacer()
|
||
}
|
||
Text("运行 \(result.run_id) · \(result.duration_ms) ms")
|
||
.font(.caption.monospaced())
|
||
.foregroundStyle(.secondary)
|
||
.textSelection(.enabled)
|
||
Text(result.created_at)
|
||
.font(.caption2.monospaced())
|
||
.foregroundStyle(.tertiary)
|
||
if let error = result.error_message, !error.isEmpty {
|
||
Text(error)
|
||
.font(.caption)
|
||
.foregroundStyle(.orange)
|
||
.lineLimit(4)
|
||
}
|
||
if canAnalyze {
|
||
Button(action: analyze) {
|
||
Label(isAnalyzing ? "正在调查" : "Codex 调查根因", systemImage: "sparkles")
|
||
}
|
||
.buttonStyle(.borderedProminent)
|
||
.disabled(isAnalyzing)
|
||
}
|
||
}
|
||
.padding(14)
|
||
.background(result.status == "FAIL" ? Color.red.opacity(0.07) : Color.orange.opacity(0.07), in: RoundedRectangle(cornerRadius: 10))
|
||
}
|
||
}
|
||
|
||
struct FailureAnalysisView: View {
|
||
let item: FailureAnalysisItem
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading, spacing: 14) {
|
||
Divider()
|
||
HStack {
|
||
Label("Codex 根因分析", systemImage: "sparkles")
|
||
.font(.headline)
|
||
Spacer()
|
||
Text("\(item.analysis.suspected_layer) · 置信度 \(item.analysis.confidence)")
|
||
.font(.caption.monospaced())
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
Text(item.analysis.summary).font(.subheadline.bold())
|
||
AnalysisSection(title: "根因判断", items: [item.analysis.root_cause])
|
||
AnalysisSection(title: "证据", items: item.analysis.evidence)
|
||
AnalysisSection(title: "建议", items: item.analysis.recommendations)
|
||
|
||
if !item.analysis.validation_sql.isEmpty {
|
||
Text("只读验证 SQL").font(.subheadline.bold())
|
||
ForEach(Array(item.analysis.validation_sql.enumerated()), id: \.offset) { _, sql in
|
||
Text(sql)
|
||
.font(.system(.callout, design: .monospaced))
|
||
.textSelection(.enabled)
|
||
.frame(maxWidth: .infinity, alignment: .leading)
|
||
.padding(10)
|
||
.background(.quaternary.opacity(0.5), in: RoundedRectangle(cornerRadius: 8))
|
||
}
|
||
}
|
||
Text("分析时间 \(item.created_at)")
|
||
.font(.caption)
|
||
.foregroundStyle(.tertiary)
|
||
}
|
||
.padding(14)
|
||
.background(Color.accentColor.opacity(0.06), in: RoundedRectangle(cornerRadius: 10))
|
||
}
|
||
}
|
||
|
||
struct AnalysisSection: View {
|
||
let title: String
|
||
let items: [String]
|
||
|
||
var body: some View {
|
||
if !items.isEmpty {
|
||
VStack(alignment: .leading, spacing: 6) {
|
||
Text(title).font(.subheadline.bold())
|
||
ForEach(Array(items.enumerated()), id: \.offset) { _, item in
|
||
HStack(alignment: .top, spacing: 7) {
|
||
Text("•").foregroundStyle(.secondary)
|
||
Text(item).textSelection(.enabled)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
struct RequirementRunsView: View {
|
||
let requirement: RequirementItem
|
||
let runs: [RunItem]
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading, spacing: 12) {
|
||
Text("\(requirement.name) 的运行记录").font(.headline)
|
||
Table(runs) {
|
||
TableColumn("运行 ID", value: \.id).width(min: 150)
|
||
TableColumn("批次", value: \.batch_id).width(min: 120)
|
||
TableColumn("状态", value: \.status).width(90)
|
||
TableColumn("开始时间", value: \.started_at).width(min: 190)
|
||
}
|
||
}
|
||
.padding(20)
|
||
.overlay {
|
||
if runs.isEmpty {
|
||
ContentUnavailableView("该需求尚无运行记录", systemImage: "play.circle")
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
struct RequirementMetricsView: View {
|
||
let requirement: RequirementItem
|
||
let metrics: [MetricItem]
|
||
|
||
var body: some View {
|
||
List(metrics) { metric in
|
||
HStack {
|
||
VStack(alignment: .leading, spacing: 4) {
|
||
Text("\(metric.table_name) · \(metric.metric_type)")
|
||
Text("需求 \(requirement.id) · 批次 \(metric.batch_id)")
|
||
.font(.caption).foregroundStyle(.secondary)
|
||
}
|
||
Spacer()
|
||
Text(metric.metric_value.map { String(format: "%.0f", $0) } ?? "—")
|
||
.font(.title3.monospacedDigit())
|
||
}
|
||
.padding(.vertical, 5)
|
||
}
|
||
.overlay {
|
||
if metrics.isEmpty {
|
||
ContentUnavailableView("该需求尚无历史指标", systemImage: "chart.xyaxis.line")
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
struct RequirementReportsView: View {
|
||
@EnvironmentObject private var model: AppModel
|
||
let requirement: RequirementItem
|
||
let runs: [RunItem]
|
||
let reports: [ReportItem]
|
||
@State private var selectedRunID: String?
|
||
|
||
private var selectedRun: RunItem? {
|
||
if let selectedRunID { return runs.first { $0.id == selectedRunID } }
|
||
return runs.first
|
||
}
|
||
|
||
private var selectedReport: ReportItem? {
|
||
guard let runID = selectedRun?.id else { return nil }
|
||
return reports.first { $0.run_id == runID }
|
||
}
|
||
|
||
var body: some View {
|
||
VStack(alignment: .leading, spacing: 14) {
|
||
if let run = selectedRun {
|
||
HStack(alignment: .bottom, spacing: 16) {
|
||
VStack(alignment: .leading, spacing: 5) {
|
||
Text("测试报告").font(.title2.bold())
|
||
Text(requirement.name).foregroundStyle(.secondary)
|
||
}
|
||
Spacer(minLength: 20)
|
||
VStack(alignment: .leading, spacing: 5) {
|
||
Text("运行批次").font(.caption).foregroundStyle(.secondary)
|
||
Picker("运行批次", selection: $selectedRunID) {
|
||
ForEach(runs) { item in
|
||
Text("\(item.batch_id) · \(item.id) · \(item.status)").tag(Optional(item.id))
|
||
}
|
||
}
|
||
.labelsHidden()
|
||
.frame(minWidth: 280, idealWidth: 380, maxWidth: 460)
|
||
}
|
||
}
|
||
|
||
HStack(spacing: 10) {
|
||
StatusBadge(status: run.status)
|
||
Text(run.id).font(.caption.monospaced()).foregroundStyle(.secondary)
|
||
if let report = selectedReport {
|
||
Label("已生成报告", systemImage: "doc.text.fill")
|
||
.font(.caption).foregroundStyle(.green)
|
||
Text(report.created_at).font(.caption).foregroundStyle(.secondary)
|
||
} else {
|
||
Text("尚未生成报告").font(.caption).foregroundStyle(.secondary)
|
||
}
|
||
Spacer()
|
||
if let report = selectedReport {
|
||
Button {
|
||
NSWorkspace.shared.activateFileViewerSelecting([
|
||
URL(fileURLWithPath: report.file_path)
|
||
])
|
||
} label: {
|
||
Label("Finder", systemImage: "folder")
|
||
}
|
||
}
|
||
Button {
|
||
model.generateReport(runID: run.id)
|
||
} label: {
|
||
Label(selectedReport == nil ? "生成报告" : "重新生成", systemImage: "doc.badge.gearshape")
|
||
}
|
||
.buttonStyle(.borderedProminent)
|
||
.disabled(model.isLoading)
|
||
}
|
||
Divider()
|
||
|
||
if let report = selectedReport {
|
||
ScrollView {
|
||
Text(report.content)
|
||
.font(.system(.body, design: .monospaced))
|
||
.textSelection(.enabled)
|
||
.frame(maxWidth: .infinity, alignment: .leading)
|
||
.padding(16)
|
||
.background(.quaternary.opacity(0.35), in: RoundedRectangle(cornerRadius: 10))
|
||
}
|
||
} else {
|
||
ContentUnavailableView(
|
||
"该运行尚未生成报告",
|
||
systemImage: "doc.text",
|
||
description: Text("报告将汇总案例状态、断言、失败证据和可追溯信息。")
|
||
)
|
||
}
|
||
} else {
|
||
ContentUnavailableView(
|
||
"该需求尚无运行结果",
|
||
systemImage: "play.slash",
|
||
description: Text("先运行测试案例，再生成报告。")
|
||
)
|
||
}
|
||
}
|
||
.padding(22)
|
||
.frame(maxWidth: .infinity, maxHeight: .infinity)
|
||
.onAppear { selectedRunID = runs.first?.id }
|
||
.onChange(of: runs.map(\.id)) { _, ids in
|
||
if let selectedRunID, ids.contains(selectedRunID) { return }
|
||
self.selectedRunID = ids.first
|
||
}
|
||
}
|
||
}
|