716 lines
29 KiB
Python
716 lines
29 KiB
Python
"""Evidence-backed Word/Excel artifacts, independent of the language model runtime."""
|
|
|
|
from datetime import datetime
|
|
from typing import cast
|
|
import json
|
|
from pathlib import Path
|
|
import re
|
|
import threading
|
|
import zipfile
|
|
|
|
from docx import Document
|
|
from docx.enum.table import WD_CELL_VERTICAL_ALIGNMENT
|
|
from docx.oxml import OxmlElement
|
|
from docx.oxml.ns import qn
|
|
from docx.shared import Cm, Pt, RGBColor
|
|
from docx.styles.style import ParagraphStyle
|
|
from openpyxl import Workbook
|
|
from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
|
|
from openpyxl.utils import get_column_letter
|
|
|
|
from artemis.config import IMAGES_DIR, TRACES_PATH, WORKSPACE_ROOT
|
|
from apps.admin_console.database.repositories.session_repository import SessionRepository
|
|
from apps.admin_console.database.repositories.step_repository import StepRepository
|
|
from apps.admin_console.services.automation_store import store, identifier
|
|
from apps.admin_console.services.task_import import case_title
|
|
|
|
EXPORT_ROOT = WORKSPACE_ROOT / "artifacts" / "reports"
|
|
EXPORT_LOCK = threading.RLock()
|
|
STATUS = {
|
|
"completed": "执行完成",
|
|
"success": "执行完成",
|
|
"failed": "执行失败",
|
|
"cancelled": "已取消",
|
|
"interrupted": "执行中断",
|
|
"skipped": "已跳过",
|
|
"pending": "待执行",
|
|
"queued": "已排队",
|
|
"running": "执行中",
|
|
"task_paused": "等待指导",
|
|
"resuming": "等待设备恢复",
|
|
}
|
|
|
|
|
|
def archive_case_name(report: dict) -> str:
|
|
"""Keep case identifiers readable without allowing ZIP paths or Windows-invalid names."""
|
|
fallback = str(report.get("id") or "task")[:8]
|
|
candidate = str(report.get("case_id") or fallback).strip()
|
|
candidate = re.sub(r'[\\/:*?"<>|\x00-\x1f]', "_", candidate).strip(" .")
|
|
return candidate[:80] or fallback
|
|
|
|
|
|
def read_json(path: Path, fallback=None):
|
|
try:
|
|
return json.loads(path.read_text(encoding="utf-8"))
|
|
except (OSError, ValueError):
|
|
return fallback
|
|
|
|
|
|
def text(value) -> str:
|
|
raw = value if isinstance(value, str) else json.dumps(value, ensure_ascii=False, default=str)
|
|
return re.sub(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", "", raw)
|
|
|
|
|
|
def verdict(outcome: dict | None) -> str:
|
|
tests = (outcome or {}).get("tests") or {}
|
|
if tests.get("failed", 0):
|
|
return "验证失败"
|
|
if tests.get("unchecked", 0) or tests.get("inconclusive", 0):
|
|
return "验证不完整"
|
|
if tests.get("passed", 0):
|
|
return "验证通过"
|
|
return "未验证（执行完成不等于测试通过）"
|
|
|
|
|
|
def failure_reason(directory: Path, status: str, recorded: str | None) -> str:
|
|
def redact(value: str) -> str:
|
|
safe = text(value).strip()
|
|
safe = re.sub(r"sk-[A-Za-z0-9_-]{12,}", "[已隐藏密钥]", safe)
|
|
safe = re.sub(
|
|
r"(?i)(\b(?:authorization\s*:\s*bearer|bearer)\s+)[^\s,;]+",
|
|
r"\1[已隐藏密钥]",
|
|
safe,
|
|
)
|
|
safe = re.sub(
|
|
r"(?i)(\b(?:OPENAI_API_KEY|api[_-]?key)\s*[:=]\s*['\"]?)[^\s,'\";]+",
|
|
r"\1[已隐藏密钥]",
|
|
safe,
|
|
)
|
|
return safe[:500]
|
|
|
|
if recorded:
|
|
return redact(recorded)
|
|
if status not in {"failed", "interrupted"}:
|
|
return ""
|
|
state = read_json(directory / "status.json", {})
|
|
if isinstance(state, dict) and state.get("error"):
|
|
return redact(state["error"])
|
|
for name in ("stdout.log", "stderr.log"):
|
|
path = directory / name
|
|
try:
|
|
with path.open("rb") as stream:
|
|
stream.seek(0, 2)
|
|
stream.seek(max(0, stream.tell() - 131072))
|
|
lines = stream.read().decode("utf-8", errors="replace").splitlines()
|
|
except OSError:
|
|
continue
|
|
for line in reversed(lines):
|
|
match = re.search(r"Error running automation:\s*(.+)", line)
|
|
if match:
|
|
return redact(match.group(1))
|
|
if re.search(r"(?i)(?:timeout|timed out|超时|deadline exceeded)", line):
|
|
return redact("模型请求或任务执行超时：" + line.strip())
|
|
return "任务未完成，运行日志中没有可提取的具体异常；请查看执行步骤。"
|
|
|
|
|
|
def session_report(session_id: str, db_path=None) -> dict:
|
|
identifier(session_id)
|
|
meta = store.job(session_id) or {}
|
|
repo = SessionRepository(db_path) if db_path else SessionRepository()
|
|
session = repo.get_session_by_id(session_id) or {}
|
|
if not session and not meta:
|
|
raise ValueError("任务记录不存在")
|
|
steps = StepRepository(db_path).get_session_steps(session_id) if session else []
|
|
steps = [s for s in steps if s.get("step_id") != "pre-planning"]
|
|
directory = TRACES_PATH / session_id
|
|
outcome = read_json(directory / "run_outcome.json", {})
|
|
content = ""
|
|
for name in ("output.md", "output.txt", "output.json"):
|
|
path = directory / "notes" / name
|
|
if path.is_file():
|
|
content = path.read_text(encoding="utf-8")
|
|
break
|
|
result = read_json(directory / "result.json")
|
|
if not content and result is not None:
|
|
content = text(result)
|
|
for step in reversed(steps):
|
|
action = step.get("action_taken") or {}
|
|
if isinstance(action, dict) and action.get("action") == "report_task_status":
|
|
args = action.get("args") or {}
|
|
if not content:
|
|
content = args.get("explanation") or ""
|
|
if not outcome:
|
|
outcome = {"task_status": args.get("status"), "tests": {}}
|
|
break
|
|
case = meta.get("case") or {}
|
|
status = meta.get("terminal_status") or meta.get("status") or session.get("status", "unknown")
|
|
error = failure_reason(directory, status, meta.get("error"))
|
|
verification = verdict(outcome)
|
|
if status in {"failed", "interrupted"} and verification.startswith("未验证"):
|
|
verification = "未验证（任务异常终止）"
|
|
if not content:
|
|
content = (
|
|
"本任务未生成最终结论。请查看异常原因和已记录的执行步骤。"
|
|
if status in {"failed", "interrupted"}
|
|
else "本任务没有保存最终结论。以下内容仅来自已记录的执行状态和证据。"
|
|
)
|
|
return {
|
|
"id": session_id,
|
|
"name": case_title(case) or session.get("initial_goal", session_id)[:120],
|
|
"goal": case.get("goal") or session.get("initial_goal", ""),
|
|
"expected": case.get("expected", ""),
|
|
"status": status,
|
|
"verdict": verification,
|
|
"outcome": outcome,
|
|
"content": content,
|
|
"steps": steps,
|
|
"start": session.get("start_time") or meta.get("started_at"),
|
|
"end": session.get("end_time") or meta.get("ended_at"),
|
|
"error": error,
|
|
"device": meta.get("device_serial") or text(session.get("device_info") or ""),
|
|
"tags": case.get("tags", ""),
|
|
"case_id": case.get("case_id", ""),
|
|
"category": case.get("category", ""),
|
|
"subcategory": case.get("subcategory", ""),
|
|
"preconditions": case.get("preconditions", ""),
|
|
"task_config": case.get("task_config") or {},
|
|
}
|
|
|
|
|
|
def time_text(value) -> str:
|
|
return (
|
|
datetime.fromtimestamp(float(value)).astimezone().strftime("%Y-%m-%d %H:%M:%S")
|
|
if value
|
|
else "—"
|
|
)
|
|
|
|
|
|
def metadata(report: dict) -> list[tuple]:
|
|
return [
|
|
("任务编号", report["id"]),
|
|
("用例编号", report.get("case_id") or "—"),
|
|
("检测项目", report.get("category") or "—"),
|
|
("测试子项", report.get("subcategory") or "—"),
|
|
("前置约束提取", report.get("preconditions") or "—"),
|
|
("任务配置", config_text(report.get("task_config"))),
|
|
("任务目标", report["goal"]),
|
|
("预期结果", report["expected"] or "未指定"),
|
|
("执行状态", STATUS.get(report["status"], report["status"])),
|
|
("验证结论", report["verdict"]),
|
|
("开始时间", time_text(report["start"])),
|
|
("结束时间", time_text(report["end"])),
|
|
("设备", report["device"]),
|
|
("异常原因", report["error"] or "无独立异常记录"),
|
|
]
|
|
|
|
|
|
def config_text(config) -> str:
|
|
if not isinstance(config, dict):
|
|
return text(config or {})
|
|
return json.dumps(
|
|
{key: value for key, value in config.items() if value is not None},
|
|
ensure_ascii=False,
|
|
indent=2,
|
|
)
|
|
|
|
|
|
def image_path(name: str | None) -> Path | None:
|
|
if not name:
|
|
return None
|
|
root = Path(IMAGES_DIR).resolve()
|
|
path = (root / (name if Path(name).suffix else name + ".jpg")).resolve()
|
|
return (
|
|
path
|
|
if path.is_relative_to(root)
|
|
and path.is_file()
|
|
and path.suffix.lower() in {".jpg", ".png", ".jpeg"}
|
|
else None
|
|
)
|
|
|
|
|
|
def markdown_blocks(content: str):
|
|
lines = content.splitlines()
|
|
index = 0
|
|
in_code = False
|
|
while index < len(lines):
|
|
line = lines[index]
|
|
if line.strip().startswith("```"):
|
|
in_code = not in_code
|
|
if (
|
|
not in_code
|
|
and "|" in line
|
|
and index + 1 < len(lines)
|
|
and re.fullmatch(r"[\s|:\-]+", lines[index + 1])
|
|
and "-" in lines[index + 1]
|
|
):
|
|
rows = [[c.strip() for c in line.strip().strip("|").split("|")]]
|
|
index += 2
|
|
while index < len(lines) and "|" in lines[index] and lines[index].strip():
|
|
rows.append([c.strip() for c in lines[index].strip().strip("|").split("|")])
|
|
index += 1
|
|
yield "table", rows
|
|
else:
|
|
yield "text", line
|
|
index += 1
|
|
|
|
|
|
def word_styles(doc, *, landscape: bool = False):
|
|
section = doc.sections[0]
|
|
section.page_width, section.page_height = (
|
|
(Cm(29.7), Cm(21)) if landscape else (Cm(21), Cm(29.7))
|
|
)
|
|
section.left_margin = section.right_margin = Cm(2)
|
|
section.top_margin = section.bottom_margin = Cm(1.9)
|
|
for name, size, color in (
|
|
("Normal", 10.5, "263445"),
|
|
("Title", 20, "0F172A"),
|
|
("Heading 1", 14, "0F172A"),
|
|
("Heading 2", 11.5, "0F172A"),
|
|
("Heading 3", 10.5, "0F172A"),
|
|
("List Bullet", 10.5, "263445"),
|
|
("List Number", 10.5, "263445"),
|
|
("Quote", 10.5, "263445"),
|
|
):
|
|
style = cast(ParagraphStyle, doc.styles[name])
|
|
style.font.name = "Microsoft YaHei"
|
|
style.font.size = Pt(size)
|
|
style.font.color.rgb = RGBColor.from_string(color)
|
|
style.element.get_or_add_rPr().get_or_add_rFonts().set(qn("w:eastAsia"), "微软雅黑")
|
|
style.paragraph_format.space_after = Pt(7 if name == "Normal" else 9)
|
|
if name == "Normal":
|
|
style.paragraph_format.line_spacing = 1.3
|
|
if name == "Title":
|
|
ppr = style.element.get_or_add_pPr()
|
|
border = ppr.find(qn("w:pBdr"))
|
|
if border is not None:
|
|
ppr.remove(border)
|
|
return doc
|
|
|
|
|
|
def shade_cell(cell, fill: str):
|
|
shading = OxmlElement("w:shd")
|
|
shading.set(qn("w:fill"), fill)
|
|
cell._tc.get_or_add_tcPr().append(shading)
|
|
|
|
|
|
def word_table(doc, rows, widths: tuple[float, ...], *, header: bool = False):
|
|
table = doc.add_table(rows=0, cols=len(widths))
|
|
table.autofit = False
|
|
table.style = "Table Grid"
|
|
borders = OxmlElement("w:tblBorders")
|
|
for edge in ("top", "left", "bottom", "right", "insideH", "insideV"):
|
|
line = OxmlElement(f"w:{edge}")
|
|
line.set(qn("w:val"), "single")
|
|
line.set(qn("w:sz"), "4")
|
|
line.set(qn("w:color"), "D9D9D9")
|
|
borders.append(line)
|
|
table._tbl.tblPr.append(borders)
|
|
for column, width in zip(table.columns, widths):
|
|
column.width = Cm(width)
|
|
for index, row in enumerate(rows):
|
|
cells = table.add_row().cells
|
|
if header and index == 0:
|
|
table.rows[-1]._tr.get_or_add_trPr().append(OxmlElement("w:tblHeader"))
|
|
for position, cell in enumerate(cells):
|
|
cell.width = Cm(widths[position])
|
|
cell.vertical_alignment = WD_CELL_VERTICAL_ALIGNMENT.CENTER
|
|
cell.text = text(row[position]) if position < len(row) else ""
|
|
margins = OxmlElement("w:tcMar")
|
|
for edge, size in (("top", "85"), ("bottom", "85"), ("left", "110"), ("right", "110")):
|
|
margin = OxmlElement(f"w:{edge}")
|
|
margin.set(qn("w:w"), size)
|
|
margin.set(qn("w:type"), "dxa")
|
|
margins.append(margin)
|
|
cell._tc.get_or_add_tcPr().append(margins)
|
|
if (header and index == 0) or (not header and position == 0):
|
|
shade_cell(cell, "DDEBF5")
|
|
for run in cell.paragraphs[0].runs:
|
|
run.bold = True
|
|
elif index % 2 == 0:
|
|
shade_cell(cell, "F6F9FC")
|
|
for paragraph in cell.paragraphs:
|
|
paragraph.paragraph_format.space_after = Pt(3)
|
|
for run in paragraph.runs:
|
|
run.font.size = Pt(8.5 if len(widths) > 2 else 9.5)
|
|
doc.add_paragraph().paragraph_format.space_after = Pt(2)
|
|
return table
|
|
|
|
|
|
def add_markdown_inline(paragraph, value: str):
|
|
"""Keep emphasis readable in Word without importing untrusted HTML."""
|
|
pieces = re.split(r"(\*\*[^*]+\*\*|`[^`]+`|\*[^*]+\*)", value)
|
|
for piece in pieces:
|
|
if not piece:
|
|
continue
|
|
run = paragraph.add_run(
|
|
piece.strip("*")
|
|
if piece.startswith("*")
|
|
else piece.strip("`")
|
|
if piece.startswith("`")
|
|
else piece
|
|
)
|
|
run.bold = piece.startswith("**")
|
|
run.italic = piece.startswith("*") and not piece.startswith("**")
|
|
if piece.startswith("`"):
|
|
run.font.name = "Consolas"
|
|
|
|
|
|
def add_markdown_content(doc, content: str):
|
|
in_code = False
|
|
for kind, value in markdown_blocks(text(content)):
|
|
if kind == "table":
|
|
columns = max(map(len, value))
|
|
if columns:
|
|
word_table(doc, value, tuple(16 / columns for _ in range(columns)), header=True)
|
|
continue
|
|
line = str(value)
|
|
if line.strip().startswith("```"):
|
|
in_code = not in_code
|
|
continue
|
|
if in_code:
|
|
paragraph = doc.add_paragraph()
|
|
shade = OxmlElement("w:shd")
|
|
shade.set(qn("w:fill"), "F1F5F9")
|
|
paragraph._p.get_or_add_pPr().append(shade)
|
|
paragraph.add_run(line).font.name = "Consolas"
|
|
elif not line.strip():
|
|
continue
|
|
elif match := re.match(r"^(#{1,3})\s+(.+)$", line):
|
|
doc.add_heading(match.group(2), level=min(len(match.group(1)) + 1, 3))
|
|
elif match := re.match(r"^\s*([-*+] |\d+\. )(.+)$", line):
|
|
paragraph = doc.add_paragraph(
|
|
style="List Number" if match.group(1)[0].isdigit() else "List Bullet"
|
|
)
|
|
add_markdown_inline(paragraph, match.group(2))
|
|
else:
|
|
paragraph = doc.add_paragraph(style="Quote" if line.lstrip().startswith("> ") else None)
|
|
add_markdown_inline(
|
|
paragraph, line.lstrip("> ") if line.lstrip().startswith("> ") else line
|
|
)
|
|
|
|
|
|
def word_report(report: dict, path: Path):
|
|
doc = word_styles(Document())
|
|
doc.add_paragraph(report["name"], style="Title")
|
|
doc.add_paragraph(
|
|
f"执行状态：{STATUS.get(report['status'], report['status'])} 验证结论：{report['verdict']}"
|
|
)
|
|
if report["error"]:
|
|
doc.add_heading("异常原因", 1)
|
|
doc.add_paragraph(text(report["error"]))
|
|
doc.add_heading("任务信息", 1)
|
|
details = [
|
|
(label, value)
|
|
for label, value in metadata(report)
|
|
if label in {"任务编号", "用例编号", "检测项目", "测试子项", "开始时间", "结束时间", "设备"}
|
|
]
|
|
word_table(doc, details, (3.2, 13.3))
|
|
doc.add_heading("任务目标", 2)
|
|
doc.add_paragraph(report["goal"] or "未记录")
|
|
doc.add_heading("预期结果", 2)
|
|
doc.add_paragraph(report["expected"] or "未指定")
|
|
if report.get("preconditions"):
|
|
doc.add_paragraph("前置约束：" + text(report["preconditions"]))
|
|
if report.get("task_config"):
|
|
doc.add_paragraph("任务配置：" + config_text(report["task_config"]))
|
|
doc.add_heading("结论与发现", 1)
|
|
add_markdown_content(doc, report["content"])
|
|
doc.add_heading("执行步骤与证据", 1)
|
|
for step in report["steps"]:
|
|
paragraph = doc.add_paragraph()
|
|
paragraph.paragraph_format.keep_together = True
|
|
paragraph.add_run(
|
|
f"步骤 {step['step_number']} · {time_text(step.get('timestamp'))}\n"
|
|
).bold = True
|
|
paragraph.add_run(step.get("summary") or "已记录操作")
|
|
evidence = report["steps"][:1] + report["steps"][-1:]
|
|
seen: set[str] = set()
|
|
images: list[tuple[Path, int]] = []
|
|
for step in evidence:
|
|
name = step.get("post_image_name") or step.get("pre_image_name")
|
|
photo = image_path(name)
|
|
if photo and name not in seen:
|
|
seen.add(name)
|
|
images.append((photo, step["step_number"]))
|
|
if images:
|
|
doc.add_page_break()
|
|
doc.add_heading("关键截图", 2)
|
|
table = doc.add_table(rows=1, cols=len(images))
|
|
table.autofit = False
|
|
for cell, (photo, step_number) in zip(table.rows[0].cells, images):
|
|
cell.width = Cm(8 if len(images) == 2 else 12)
|
|
cell.paragraphs[0].add_run(f"步骤 {step_number}").bold = True
|
|
cell.add_paragraph().add_run().add_picture(
|
|
str(photo), width=Cm(7.5 if len(images) == 2 else 8.5)
|
|
)
|
|
doc.add_paragraph("其余步骤截图可从任务资料包单独下载。")
|
|
doc.add_paragraph(f"追溯编号：{report['id']}。未观察、未检查的项目不计为验证通过。")
|
|
doc.save(str(path))
|
|
|
|
|
|
def sheet_rows(ws, rows, widths: tuple[int, ...] = ()):
|
|
ws.sheet_view.showGridLines = False
|
|
ws.freeze_panes = "A2"
|
|
ws.sheet_properties.pageSetUpPr.fitToPage = True
|
|
ws.page_setup.fitToWidth = 1
|
|
if len(widths) > 3:
|
|
ws.page_setup.orientation = "landscape"
|
|
ws.page_setup.paperSize = ws.PAPERSIZE_A3
|
|
ws.print_options.horizontalCentered = True
|
|
for index, row in enumerate(rows, 1):
|
|
ws.append([text(value)[:32700] if value is not None else "" for value in row])
|
|
longest = 1
|
|
for column, cell in enumerate(ws[index], 1):
|
|
# Always store text, including leading '=': never export executable formulas.
|
|
cell.data_type = "s"
|
|
cell.alignment = Alignment(wrap_text=True, vertical="center" if index == 1 else "top")
|
|
cell.font = Font(
|
|
name="微软雅黑",
|
|
size=10,
|
|
bold=index == 1,
|
|
color="FFFFFF" if index == 1 else "253244",
|
|
)
|
|
cell.border = Border(bottom=Side(style="hair", color="E2E8F0"))
|
|
if index == 1:
|
|
cell.fill = PatternFill("solid", fgColor="245C78")
|
|
elif index % 2 == 1 or column == 1:
|
|
cell.fill = PatternFill("solid", fgColor="F3F7FA" if column == 1 else "F8FAFC")
|
|
width = widths[column - 1] if column <= len(widths) else 32
|
|
ws.column_dimensions[get_column_letter(column)].width = width
|
|
lines = str(cell.value or "").splitlines() or [""]
|
|
height_lines = sum(
|
|
max(1, (sum(2 if ord(char) > 255 else 1 for char in line) + width - 1) // width)
|
|
for line in lines
|
|
)
|
|
longest = max(longest, height_lines)
|
|
ws.row_dimensions[index].height = 30 if index == 1 else min(300, max(27, longest * 18 + 8))
|
|
if ws.max_row > 1:
|
|
ws.auto_filter.ref = ws.dimensions
|
|
|
|
|
|
def conclusion_rows(content: str):
|
|
rows = [("类型", "结论与发现")]
|
|
table_number = 0
|
|
in_code = False
|
|
for kind, value in markdown_blocks(content):
|
|
if kind == "table":
|
|
table_number += 1
|
|
rows.append(("表格", f"详见「结果表{table_number}」工作表"))
|
|
elif line := str(value).strip():
|
|
if line.startswith("```"):
|
|
in_code = not in_code
|
|
continue
|
|
if in_code:
|
|
rows.append(("代码", line))
|
|
continue
|
|
if match := re.match(r"^#{1,6}\s+(.*)$", line):
|
|
label, body = "小节", match.group(1)
|
|
elif match := re.match(r"^(?:[-*+] |\d+\. )(.*)$", line):
|
|
label, body = "要点", match.group(1)
|
|
else:
|
|
label, body = "正文", line.lstrip("> ")
|
|
rows.append(
|
|
(
|
|
label,
|
|
re.sub(r"\*\*([^*]+)\*\*|`([^`]+)`", lambda m: m.group(1) or m.group(2), body),
|
|
)
|
|
)
|
|
return rows
|
|
|
|
|
|
def execution_result_label(result) -> str:
|
|
if not isinstance(result, dict):
|
|
return text(result or "未记录")[:120]
|
|
status = result.get("status")
|
|
labels = {
|
|
"dispatched": "动作已发出（需核对截图）",
|
|
"success": "动作返回成功",
|
|
"failed": "动作失败",
|
|
}
|
|
label = labels.get(status, text(status or "未记录"))
|
|
if result.get("error"):
|
|
label += "\n" + text(result["error"])[:180]
|
|
return label
|
|
|
|
|
|
def excel_report(report: dict, path: Path):
|
|
wb = Workbook()
|
|
assert wb.active is not None
|
|
wb.active.title = "任务结果"
|
|
sheet_rows(wb.active, [("项目", "内容"), *metadata(report)], (22, 82))
|
|
sheet_rows(wb.create_sheet("结论"), conclusion_rows(report["content"]), (15, 96))
|
|
table_number = 0
|
|
for kind, rows in markdown_blocks(report["content"]):
|
|
if kind == "table":
|
|
table_number += 1
|
|
sheet_rows(wb.create_sheet(f"结果表{table_number}"), rows)
|
|
sheet_rows(
|
|
wb.create_sheet("执行证据"),
|
|
[
|
|
("步骤", "时间", "说明", "结果", "截图引用"),
|
|
*[
|
|
(
|
|
s["step_number"],
|
|
time_text(s.get("timestamp")),
|
|
s.get("summary"),
|
|
execution_result_label(s.get("last_execution_result")),
|
|
"见步骤截图资料包"
|
|
if s.get("post_image_name") or s.get("pre_image_name")
|
|
else "无截图",
|
|
)
|
|
for s in report["steps"]
|
|
],
|
|
],
|
|
(10, 22, 68, 26, 24),
|
|
)
|
|
wb.save(path)
|
|
|
|
|
|
def export_session(session_id: str, formats: list[str] | None = None) -> list[Path]:
|
|
with EXPORT_LOCK:
|
|
report = session_report(session_id)
|
|
directory = EXPORT_ROOT / "sessions" / identifier(session_id)
|
|
directory.mkdir(parents=True, exist_ok=True)
|
|
outputs = []
|
|
for fmt in formats if formats is not None else store.preferences()["formats"]:
|
|
if fmt not in {"docx", "xlsx"}:
|
|
raise ValueError("不支持的报告格式")
|
|
path = directory / f"任务报告.{fmt}"
|
|
temporary = directory / f"生成中.{fmt}"
|
|
(word_report if fmt == "docx" else excel_report)(report, temporary)
|
|
temporary.replace(path)
|
|
outputs.append(path)
|
|
return outputs
|
|
|
|
|
|
def session_screenshots(report: dict) -> list[tuple[Path, str]]:
|
|
"""Ordered, path-checked pre/post observations for each recorded step."""
|
|
screenshots: list[tuple[Path, str]] = []
|
|
for index, step in enumerate(report["steps"], 1):
|
|
for phase, key in (("操作前", "pre_image_name"), ("操作后", "post_image_name")):
|
|
source = image_path(step.get(key))
|
|
if source:
|
|
screenshots.append(
|
|
(
|
|
source,
|
|
f"{index:04d}_步骤{int(step.get('step_number') or index):04d}_{phase}{source.suffix.lower()}",
|
|
)
|
|
)
|
|
return screenshots
|
|
|
|
|
|
def session_videos(report: dict) -> list[tuple[Path, str]]:
|
|
"""Find only verified files attached to this session's recording directory."""
|
|
session = SessionRepository().get_session_by_id(report["id"]) or {}
|
|
recording = SessionRepository().get_video_recording_for_session(report["id"]) or {}
|
|
candidate = recording.get("local_video_path") or session.get("video_filepath")
|
|
if not candidate:
|
|
return []
|
|
source = Path(str(candidate)).resolve()
|
|
session_root = (TRACES_PATH / identifier(report["id"])).resolve()
|
|
if not source.is_relative_to(session_root):
|
|
return []
|
|
# A resumed recording lives under resume_NNNN; the initial recording is
|
|
# in its parent, with any later segments in sibling resume folders.
|
|
directory = source.parent
|
|
if directory.name.startswith("resume_"):
|
|
directory = directory.parent
|
|
if not directory.is_dir() or not directory.is_relative_to(session_root):
|
|
return []
|
|
paths = [
|
|
p
|
|
for p in directory.rglob("*.mp4")
|
|
if p.is_file()
|
|
and p.resolve().is_relative_to(directory.resolve())
|
|
and (p.parent == directory or p.parent.name.startswith("resume_"))
|
|
]
|
|
paths.sort(key=lambda p: (0 if p.parent == directory else 1, p.parent.name, p.name))
|
|
return [(path, f"{i:04d}_{path.parent.name}_{path.name}") for i, path in enumerate(paths, 1)]
|
|
|
|
|
|
def export_session_media(session_id: str, kind: str) -> Path:
|
|
if kind not in {"screenshots", "video", "all"}:
|
|
raise ValueError("不支持的下载类型")
|
|
with EXPORT_LOCK:
|
|
report = session_report(session_id)
|
|
target_dir = EXPORT_ROOT / "sessions" / identifier(session_id)
|
|
target_dir.mkdir(parents=True, exist_ok=True)
|
|
images = session_screenshots(report) if kind in {"screenshots", "all"} else []
|
|
videos = session_videos(report) if kind in {"video", "all"} else []
|
|
if kind == "video" and not videos:
|
|
raise ValueError("此任务没有已保存的录屏")
|
|
if kind == "screenshots" and not images:
|
|
raise ValueError("此任务没有可下载的步骤截图")
|
|
target = target_dir / f"{kind}.zip"
|
|
temporary = target_dir / f".{kind}.tmp"
|
|
manifest = {
|
|
"session_id": session_id,
|
|
"name": report["name"],
|
|
"status": report["status"],
|
|
"verdict": report["verdict"],
|
|
"screenshots": [name for _, name in images],
|
|
"videos": [name for _, name in videos],
|
|
"note": "录屏按时间顺序分段；暂停期间未占用设备，也未录制其他任务。",
|
|
}
|
|
prefix = archive_case_name(report) + "/" if kind == "all" else ""
|
|
with zipfile.ZipFile(temporary, "w", zipfile.ZIP_DEFLATED) as archive:
|
|
if kind == "all":
|
|
for path in export_session(session_id, ["docx", "xlsx"]):
|
|
archive.write(path, prefix + path.name)
|
|
for source, name in images:
|
|
archive.write(source, f"{prefix}步骤截图/{name}")
|
|
for source, name in videos:
|
|
archive.write(source, f"{prefix}任务录屏/{name}")
|
|
archive.writestr(
|
|
prefix + "文件清单.json", json.dumps(manifest, ensure_ascii=False, indent=2)
|
|
)
|
|
temporary.replace(target)
|
|
return target
|
|
|
|
|
|
def export_batch(batch_id: str) -> Path:
|
|
with EXPORT_LOCK:
|
|
batch = store.get("batch", identifier(batch_id))
|
|
if not batch:
|
|
raise ValueError("批次不存在")
|
|
directory = EXPORT_ROOT / "batches" / batch_id
|
|
directory.mkdir(parents=True, exist_ok=True)
|
|
formats = batch["formats"]
|
|
records = [session_report(job["session_id"]) for job in store.jobs(batch_id)]
|
|
rows = [("任务编号", "任务名称", "执行状态", "验证结论", "异常原因")]
|
|
rows += [
|
|
(r["id"], r["name"], STATUS.get(r["status"], r["status"]), r["verdict"], r["error"])
|
|
for r in records
|
|
]
|
|
outputs = []
|
|
if "xlsx" in formats:
|
|
wb = Workbook()
|
|
assert wb.active is not None
|
|
wb.active.title = "批次结果"
|
|
sheet_rows(wb.active, rows, (40, 48, 16, 28, 70))
|
|
path = directory / "批次结果.xlsx"
|
|
wb.save(path)
|
|
outputs.append(path)
|
|
if "docx" in formats:
|
|
doc = word_styles(Document(), landscape=True)
|
|
doc.add_paragraph(batch["name"], style="Title")
|
|
doc.add_paragraph(
|
|
f"批次编号：{batch_id}；共 {len(records)} 个任务。验证通过与执行完成分别统计。"
|
|
)
|
|
word_table(doc, rows, (3.5, 5.4, 2.5, 3.5, 7.3), header=True)
|
|
path = directory / "批次汇总.docx"
|
|
doc.save(str(path))
|
|
outputs.append(path)
|
|
target = directory / "批次报告.zip"
|
|
temporary = directory / "批次报告.tmp"
|
|
with zipfile.ZipFile(temporary, "w", zipfile.ZIP_DEFLATED) as archive:
|
|
for path in outputs:
|
|
archive.write(path, path.name)
|
|
for number, report in enumerate(records, 1):
|
|
for path in export_session(report["id"], formats):
|
|
archive.write(
|
|
path, f"任务报告/{number:04d}_{archive_case_name(report)}/{path.name}"
|
|
)
|
|
temporary.replace(target)
|
|
return target
|