+
+
+
+
+```
+
+**3. 照片上传（饮食表单）**
+
+```html
+
+
+
+```
+
+#### 验收标准
+
+- [ ] 所有 4 个 POST API 可正常工作
+- [ ] 表单校验正确（必填项、数值范围）
+- [ ] 照片上传成功后可在饮食页面查看
+- [ ] 饮食表单留空卡路里时自动估算
+- [ ] 提交成功后页面刷新并显示新记录
+- [ ] 错误提示友好（网络错误、校验失败）
+- [ ] 表单样式与页面整体风格一致
+
+---
+
+### 任务 P1-5：DeepSeek 智能食物识别
+
+**优先级**: ⭐⭐⭐⭐⭐
+**预计工作量**: 6-8 小时
+**依赖**: P1-2 饮食页面
+
+#### 功能概述
+
+在饮食记录时，用户可通过以下两种方式智能识别食物并自动估算卡路里：
+1. **上传照片**：DeepSeek Vision 识别图片中的食物
+2. **文字描述**：DeepSeek 解析自然语言描述（如"一碗米饭加红烧肉"）
+
+系统自动调用 DeepSeek API，返回食物列表和营养估算，用户确认后保存。
+
+#### 实现步骤
+
+**1. 创建 DeepSeek 适配器（`src/vitals/vision/providers/deepseek.py`）**
+
+```python
+"""DeepSeek Vision API 适配器"""
+
+import base64
+import os
+from pathlib import Path
+from typing import Optional
+
+import httpx
+
+from ...core.calories import estimate_meal_calories
+
+
+class DeepSeekVisionAnalyzer:
+ """DeepSeek Vision 食物识别分析器"""
+
+ def __init__(self, api_key: Optional[str] = None):
+ self.api_key = api_key or os.environ.get("DEEPSEEK_API_KEY")
+ self.base_url = "https://api.deepseek.com/v1"
+
+ def analyze_image(self, image_path: Path) -> dict:
+ """
+ 分析食物图片
+
+ 返回:
+ {
+ "description": "米饭、红烧排骨、西兰花",
+ "total_calories": 680,
+ "items": [...]
+ }
+ """
+ if not self.api_key:
+ raise ValueError("需要设置 DEEPSEEK_API_KEY 环境变量")
+
+ # 读取并编码图片
+ image_data = self._encode_image(image_path)
+ media_type = self._get_media_type(image_path)
+
+ # 调用 DeepSeek Vision API
+ headers = {
+ "Authorization": f"Bearer {self.api_key}",
+ "Content-Type": "application/json",
+ }
+
+ payload = {
+ "model": "deepseek-chat", # 使用支持 vision 的模型
+ "messages": [
+ {
+ "role": "user",
+ "content": [
+ {
+ "type": "image_url",
+ "image_url": {
+ "url": f"data:{media_type};base64,{image_data}"
+ }
+ },
+ {
+ "type": "text",
+ "text": """请分析这张食物图片，识别出所有食物。
+
+要求：
+1. 列出所有可识别的食物，用中文名称
+2. 估计每种食物的大致份量（如：一碗米饭、100g红烧肉）
+3. 按照 "食物1+食物2+食物3" 的格式返回
+
+例如返回格式：一碗米饭+红烧排骨+西兰花
+
+只返回食物列表，不需要其他解释。"""
+ }
+ ]
+ }
+ ],
+ "temperature": 0.3,
+ }
+
+ with httpx.Client(timeout=30.0) as client:
+ response = client.post(
+ f"{self.base_url}/chat/completions",
+ headers=headers,
+ json=payload,
+ )
+ response.raise_for_status()
+ result = response.json()
+
+ # 解析响应
+ description = result["choices"][0]["message"]["content"].strip()
+
+ # 使用卡路里计算模块估算营养成分
+ nutrition = estimate_meal_calories(description)
+ nutrition["description"] = description
+ nutrition["provider"] = "deepseek"
+
+ return nutrition
+
+ def analyze_text(self, text_description: str) -> dict:
+ """
+ 分析文字描述的食物
+
+ 输入: "今天吃了一碗米饭、两个鸡蛋还有一杯牛奶"
+ 返回: 结构化的食物列表和营养估算
+ """
+ if not self.api_key:
+ raise ValueError("需要设置 DEEPSEEK_API_KEY 环境变量")
+
+ headers = {
+ "Authorization": f"Bearer {self.api_key}",
+ "Content-Type": "application/json",
+ }
+
+ payload = {
+ "model": "deepseek-chat",
+ "messages": [
+ {
+ "role": "system",
+ "content": """你是专业的营养分析助手。用户会告诉你吃了什么，你需要：
+1. 识别所有食物
+2. 标准化食物名称（如"面"→"面条"，"肉"→"猪肉"）
+3. 提取数量（如"两个"、"一碗"、"100g"）
+4. 按照 "食物1+食物2+食物3" 格式返回
+
+示例：
+用户输入："今天吃了一碗米饭、两个鸡蛋还有一杯牛奶"
+你返回："一碗米饭+两个鸡蛋+一杯牛奶"
+
+只返回标准化后的食物列表，不需要其他解释。"""
+ },
+ {
+ "role": "user",
+ "content": text_description
+ }
+ ],
+ "temperature": 0.3,
+ }
+
+ with httpx.Client(timeout=30.0) as client:
+ response = client.post(
+ f"{self.base_url}/chat/completions",
+ headers=headers,
+ json=payload,
+ )
+ response.raise_for_status()
+ result = response.json()
+
+ # 解析响应
+ standardized = result["choices"][0]["message"]["content"].strip()
+
+ # 使用卡路里计算模块估算营养成分
+ nutrition = estimate_meal_calories(standardized)
+ nutrition["description"] = standardized
+ nutrition["provider"] = "deepseek"
+ nutrition["original_input"] = text_description
+
+ return nutrition
+
+ def _encode_image(self, image_path: Path) -> str:
+ """将图片编码为 base64"""
+ with open(image_path, "rb") as f:
+ return base64.standard_b64encode(f.read()).decode("utf-8")
+
+ def _get_media_type(self, image_path: Path) -> str:
+ """获取图片的 MIME 类型"""
+ suffix = image_path.suffix.lower()
+ media_types = {
+ ".jpg": "image/jpeg",
+ ".jpeg": "image/jpeg",
+ ".png": "image/png",
+ ".gif": "image/gif",
+ ".webp": "image/webp",
+ }
+ return media_types.get(suffix, "image/jpeg")
+
+
+def get_deepseek_analyzer(api_key: Optional[str] = None) -> DeepSeekVisionAnalyzer:
+ """获取 DeepSeek 分析器"""
+ return DeepSeekVisionAnalyzer(api_key)
+```
+
+**2. 更新分析器工厂（`src/vitals/vision/analyzer.py`）**
+
+在现有的 `get_analyzer()` 函数中增加 DeepSeek 选项：
+
+```python
+def get_analyzer(
+ provider: str = "deepseek", # 默认使用 DeepSeek
+ api_key: Optional[str] = None
+) -> FoodAnalyzer:
+ """
+ 获取食物分析器
+
+ provider: "deepseek" | "claude" | "local"
+ """
+ if provider == "deepseek":
+ from .providers.deepseek import get_deepseek_analyzer
+ return get_deepseek_analyzer(api_key)
+ elif provider == "claude":
+ return ClaudeFoodAnalyzer(api_key)
+ else:
+ return LocalFoodAnalyzer()
+```
+
+**3. 后端 API 增强（`src/vitals/web/app.py`）**
+
+新增智能识别接口：
+
+```python
+from pydantic import BaseModel
+
+class FoodRecognitionRequest(BaseModel):
+ """食物识别请求"""
+ text: Optional[str] = None # 文字描述
+ image_base64: Optional[str] = None # 图片 base64（前端传）
+ provider: str = "deepseek" # 默认 DeepSeek
+
+
+@app.post("/api/meal/recognize")
+async def recognize_food(
+ text: Optional[str] = Form(None),
+ image: Optional[UploadFile] = File(None),
+ provider: str = Form("deepseek"),
+):
+ """
+ 智能识别食物（支持照片或文字）
+
+ 返回: {
+ "success": true,
+ "description": "一碗米饭+红烧排骨",
+ "total_calories": 680,
+ "items": [...],
+ "provider": "deepseek"
+ }
+ """
+ try:
+ from ..vision.analyzer import get_analyzer
+
+ # 获取 API Key（优先环境变量，备选配置文件）
+ api_key = os.environ.get("DEEPSEEK_API_KEY")
+ if not api_key:
+ # 从配置文件读取（可选实现）
+ config_path = Path.home() / ".vitals" / "config.json"
+ if config_path.exists():
+ import json
+ config = json.loads(config_path.read_text())
+ api_key = config.get("deepseek_api_key")
+
+ if not api_key:
+ raise HTTPException(
+ status_code=400,
+ detail="未配置 DEEPSEEK_API_KEY，请先设置：vitals config set-api-key --deepseek YOUR_KEY"
+ )
+
+ analyzer = get_analyzer(provider=provider, api_key=api_key)
+
+ # 图片识别
+ if image:
+ # 保存临时文件
+ temp_dir = Path.home() / ".vitals" / "temp"
+ temp_dir.mkdir(parents=True, exist_ok=True)
+ temp_path = temp_dir / f"temp_{datetime.now().strftime('%Y%m%d%H%M%S')}.jpg"
+
+ content = await image.read()
+ temp_path.write_bytes(content)
+
+ try:
+ result = analyzer.analyze_image(temp_path)
+ finally:
+ temp_path.unlink(missing_ok=True) # 清理临时文件
+
+ return {
+ "success": True,
+ "description": result["description"],
+ "total_calories": result["total_calories"],
+ "total_protein": result.get("total_protein", 0),
+ "total_carbs": result.get("total_carbs", 0),
+ "total_fat": result.get("total_fat", 0),
+ "items": result.get("items", []),
+ "provider": provider,
+ }
+
+ # 文字识别
+ elif text:
+ if hasattr(analyzer, 'analyze_text'):
+ result = analyzer.analyze_text(text)
+ else:
+ # Fallback: 直接用 estimate_meal_calories
+ from ..core.calories import estimate_meal_calories
+ result = estimate_meal_calories(text)
+ result["description"] = text
+ result["provider"] = "local"
+
+ return {
+ "success": True,
+ "description": result["description"],
+ "total_calories": result["total_calories"],
+ "total_protein": result.get("total_protein", 0),
+ "total_carbs": result.get("total_carbs", 0),
+ "total_fat": result.get("total_fat", 0),
+ "items": result.get("items", []),
+ "provider": result.get("provider", "local"),
+ }
+
+ else:
+ raise HTTPException(status_code=400, detail="请提供照片或文字描述")
+
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"识别失败: {str(e)}")
+```
+
+**4. 前端表单改进（饮食页面）**
+
+在 `/meal` 的添加表单中增加"智能识别"功能：
+
+```html
+
+
+
+
+
+```
+
+**5. CLI 配置管理（`src/vitals/cli.py`）**
+
+增加 API Key 配置命令：
+
+```python
+@config_app.command("set-api-key")
+def config_set_api_key(
+ deepseek: Optional[str] = typer.Option(None, "--deepseek", help="DeepSeek API Key"),
+ claude: Optional[str] = typer.Option(None, "--claude", help="Claude API Key"),
+):
+ """设置 AI 服务 API Key"""
+ import json
+
+ config_path = Path.home() / ".vitals" / "config.json"
+
+ # 读取现有配置
+ if config_path.exists():
+ config = json.loads(config_path.read_text())
+ else:
+ config = {}
+
+ # 更新
+ if deepseek:
+ config["deepseek_api_key"] = deepseek
+ console.print("[green]✓[/green] DeepSeek API Key 已保存")
+
+ if claude:
+ config["claude_api_key"] = claude
+ console.print("[green]✓[/green] Claude API Key 已保存")
+
+ # 保存
+ config_path.write_text(json.dumps(config, indent=2))
+ console.print(f" 配置文件: {config_path}")
+
+
+@config_app.command("show-api-keys")
+def config_show_api_keys():
+ """显示已配置的 API Keys（仅显示前缀）"""
+ import json
+
+ config_path = Path.home() / ".vitals" / "config.json"
+ if not config_path.exists():
+ console.print("暂无 API Key 配置")
+ return
+
+ config = json.loads(config_path.read_text())
+
+ table = Table(title="API Keys")
+ table.add_column("服务", style="cyan")
+ table.add_column("状态", style="green")
+
+ for service in ["deepseek_api_key", "claude_api_key"]:
+ key = config.get(service)
+ if key:
+ masked = f"{key[:8]}...{key[-4:]}" if len(key) > 12 else "***"
+ table.add_row(service.replace("_api_key", ""), f"✓ 已配置 ({masked})")
+ else:
+ table.add_row(service.replace("_api_key", ""), "✗ 未配置")
+
+ console.print(table)
+```
+
+**6. 依赖更新（`pyproject.toml`）**
+
+在 dependencies 中添加：
+
+```toml
+dependencies = [
+ # ...existing...
+ "httpx>=0.27.0", # DeepSeek API 调用
+]
+```
+
+**7. 测试（`tests/test_deepseek.py`）**
+
+```python
+"""DeepSeek 食物识别测试"""
+
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+import pytest
+
+from src.vitals.vision.providers.deepseek import DeepSeekVisionAnalyzer
+
+
+class TestDeepSeekAnalyzer:
+ """DeepSeek 分析器测试"""
+
+ def test_requires_api_key(self):
+ """测试需要 API Key"""
+ analyzer = DeepSeekVisionAnalyzer(api_key=None)
+ with pytest.raises(ValueError, match="DEEPSEEK_API_KEY"):
+ analyzer.analyze_text("米饭")
+
+ @patch('httpx.Client.post')
+ def test_analyze_text(self, mock_post):
+ """测试文字识别"""
+ # Mock API 响应
+ mock_response = Mock()
+ mock_response.json.return_value = {
+ "choices": [{
+ "message": {
+ "content": "一碗米饭+两个鸡蛋"
+ }
+ }]
+ }
+ mock_post.return_value = mock_response
+
+ analyzer = DeepSeekVisionAnalyzer(api_key="test-key")
+ result = analyzer.analyze_text("今天吃了一碗米饭和两个鸡蛋")
+
+ assert result["description"] is not None
+ assert result["total_calories"] > 0
+ assert result["provider"] == "deepseek"
+
+ @patch('httpx.Client.post')
+ def test_analyze_image(self, mock_post, tmp_path):
+ """测试图片识别"""
+ # 创建测试图片
+ test_image = tmp_path / "test.jpg"
+ test_image.write_bytes(b"fake image data")
+
+ # Mock API 响应
+ mock_response = Mock()
+ mock_response.json.return_value = {
+ "choices": [{
+ "message": {
+ "content": "米饭+红烧肉+青菜"
+ }
+ }]
+ }
+ mock_post.return_value = mock_response
+
+ analyzer = DeepSeekVisionAnalyzer(api_key="test-key")
+ result = analyzer.analyze_image(test_image)
+
+ assert result["description"] is not None
+ assert result["total_calories"] > 0
+```
+
+#### 使用流程
+
+**配置 API Key**：
+```bash
+# 方式 1: 环境变量（推荐）
+export DEEPSEEK_API_KEY="sk-..."
+
+# 方式 2: CLI 配置
+vitals config set-api-key --deepseek sk-...
+
+# 查看配置
+vitals config show-api-keys
+```
+
+**Web 界面使用**：
+1. 访问 `/meal` 页面，点击右下角 "+"
+2. 选择"📷 拍照识别"或"✏️ 文字识别"
+3. 上传照片或输入文字描述
+4. 点击"🔍 识别食物"
+5. 系统调用 DeepSeek API 返回结果
+6. 确认后点"✓ 使用此结果"自动填入表单
+7. 可手动调整后提交保存
+
+#### 验收标准
+
+- [ ] DeepSeek Vision 适配器实现完成
+- [ ] `/api/meal/recognize` 接口可正常工作
+- [ ] 饮食表单新增"智能识别"区域（照片/文字切换）
+- [ ] 照片识别成功返回食物列表和卡路里
+- [ ] 文字识别成功解析自然语言描述
+- [ ] 识别结果可一键填入表单
+- [ ] API Key 可通过 CLI 配置和查看
+- [ ] 未配置 API Key 时有友好提示
+- [ ] 测试覆盖主要流程（使用 mock）
+
+#### 技术细节
+
+**DeepSeek API 文档**: https://platform.deepseek.com/api-docs/
+
+**计费**:
+- DeepSeek-V3 (文字): ¥1/M tokens (输入), ¥2/M tokens (输出)
+- DeepSeek-Vision: 约 ¥0.5-1/次（图片）
+
+**优化建议**:
+- 缓存识别结果（同图片/文字不重复调用）
+- 添加识别历史（用户可复用之前识别的食物）
+- 支持用户修正识别结果（加入个人食物库）
+
+---
+
+## 📦 P2 - 数据管理功能（第二优先级）
+
+> **目标**: 增强数据的可维护性和可移植性
+
+### 任务 P2-1：数据导出功能
+
+**优先级**: ⭐⭐⭐
+**预计工作量**: 3-4 小时
+**依赖**: 无
+
+#### 实现步骤
+
+**1. 创建导出模块（`src/vitals/core/export.py`）**
+
+```python
+"""数据导出模块"""
+
+import csv
+import json
+from datetime import date
+from pathlib import Path
+from typing import Literal, Optional
+
+from . import database as db
+
+
+def export_all_data_json(output_path: Path) -> None:
+ """导出所有数据为 JSON"""
+ data = {
+ "version": "1.0",
+ "export_date": date.today().isoformat(),
+ "exercises": [e.to_dict() for e in db.get_exercises()],
+ "meals": [m.to_dict() for m in db.get_meals()],
+ "sleep": [s.to_dict() for s in db.get_sleep_records()],
+ "weight": [w.to_dict() for w in db.get_weight_records()],
+ "config": db.get_config().to_dict(),
+ }
+
+ output_path.write_text(
+ json.dumps(data, ensure_ascii=False, indent=2),
+ encoding="utf-8"
+ )
+
+
+def export_to_csv(
+ data_type: Literal["exercise", "meal", "sleep", "weight"],
+ output_path: Path,
+ start_date: Optional[date] = None,
+ end_date: Optional[date] = None,
+) -> None:
+ """导出指定类型数据为 CSV"""
+
+ if data_type == "exercise":
+ records = db.get_exercises(start_date, end_date)
+ fieldnames = ["date", "type", "duration", "calories", "distance",
+ "heart_rate_avg", "source", "notes"]
+ elif data_type == "meal":
+ records = db.get_meals(start_date, end_date)
+ fieldnames = ["date", "meal_type", "description", "calories",
+ "protein", "carbs", "fat", "photo_path"]
+ elif data_type == "sleep":
+ records = db.get_sleep_records(start_date, end_date)
+ fieldnames = ["date", "bedtime", "wake_time", "duration",
+ "quality", "deep_sleep_mins", "source", "notes"]
+ elif data_type == "weight":
+ records = db.get_weight_records(start_date, end_date)
+ fieldnames = ["date", "weight_kg", "body_fat_pct", "muscle_mass", "notes"]
+ else:
+ raise ValueError(f"不支持的数据类型: {data_type}")
+
+ with open(output_path, "w", newline="", encoding="utf-8") as f:
+ writer = csv.DictWriter(f, fieldnames=fieldnames)
+ writer.writeheader()
+
+ for record in records:
+ data = record.to_dict()
+ # 只保留 CSV 需要的字段
+ row = {k: data.get(k, "") for k in fieldnames}
+ writer.writerow(row)
+
+
+def import_from_json(input_path: Path) -> dict:
+ """从 JSON 导入数据"""
+ data = json.loads(input_path.read_text(encoding="utf-8"))
+
+ stats = {
+ "exercise": 0,
+ "meal": 0,
+ "sleep": 0,
+ "weight": 0,
+ }
+
+ # 导入运动记录
+ for item in data.get("exercises", []):
+ from .models import Exercise
+ exercise = Exercise(**item)
+ db.add_exercise(exercise)
+ stats["exercise"] += 1
+
+ # 导入饮食记录
+ for item in data.get("meals", []):
+ from .models import Meal
+ meal = Meal(**item)
+ db.add_meal(meal)
+ stats["meal"] += 1
+
+ # 导入睡眠记录
+ for item in data.get("sleep", []):
+ from .models import Sleep
+ sleep = Sleep(**item)
+ db.add_sleep(sleep)
+ stats["sleep"] += 1
+
+ # 导入体重记录
+ for item in data.get("weight", []):
+ from .models import Weight
+ weight = Weight(**item)
+ db.add_weight(weight)
+ stats["weight"] += 1
+
+ return stats
+```
+
+**2. CLI 接入（`src/vitals/cli.py`）**
+
+```python
+# 新增子命令组
+export_app = typer.Typer(help="数据导出")
+app.add_typer(export_app, name="export")
+
+@export_app.command("json")
+def export_json(
+ output: Path = typer.Argument(..., help="输出文件路径"),
+):
+ """导出所有数据为 JSON"""
+ from .core.export import export_all_data_json
+
+ try:
+ export_all_data_json(output)
+ console.print(f"[green]✓[/green] 数据已导出: {output}")
+ except Exception as e:
+ console.print(f"[red]✗[/red] 导出失败: {e}")
+ raise typer.Exit(1)
+
+@export_app.command("csv")
+def export_csv(
+ data_type: str = typer.Option(..., "--type", "-t", help="数据类型 (exercise/meal/sleep/weight)"),
+ output: Path = typer.Argument(..., help="输出文件路径"),
+ start_date: Optional[str] = typer.Option(None, "--start", help="起始日期 (YYYY-MM-DD)"),
+ end_date: Optional[str] = typer.Option(None, "--end", help="结束日期 (YYYY-MM-DD)"),
+):
+ """导出指定类型数据为 CSV"""
+ from .core.export import export_to_csv
+
+ start = date.fromisoformat(start_date) if start_date else None
+ end = date.fromisoformat(end_date) if end_date else None
+
+ try:
+ export_to_csv(data_type, output, start, end)
+ console.print(f"[green]✓[/green] {data_type} 数据已导出: {output}")
+ except Exception as e:
+ console.print(f"[red]✗[/red] 导出失败: {e}")
+ raise typer.Exit(1)
+
+@export_app.command("import-json")
+def import_json_cmd(
+ input_file: Path = typer.Argument(..., help="JSON 文件路径"),
+):
+ """从 JSON 导入数据"""
+ from .core.export import import_from_json
+
+ if not input_file.exists():
+ console.print(f"[red]✗[/red] 文件不存在: {input_file}")
+ raise typer.Exit(1)
+
+ try:
+ stats = import_from_json(input_file)
+ console.print(f"[green]✓[/green] 数据导入完成:")
+ console.print(f" 运动记录: {stats['exercise']} 条")
+ console.print(f" 饮食记录: {stats['meal']} 条")
+ console.print(f" 睡眠记录: {stats['sleep']} 条")
+ console.print(f" 体重记录: {stats['weight']} 条")
+ except Exception as e:
+ console.print(f"[red]✗[/red] 导入失败: {e}")
+ raise typer.Exit(1)
+```
+
+**3. 测试（`tests/test_export.py`）**
+
+```python
+"""数据导出测试"""
+
+from datetime import date
+from pathlib import Path
+
+import pytest
+
+from src.vitals.core import database as db
+from src.vitals.core.models import Exercise, Weight
+from src.vitals.core.export import (
+ export_all_data_json,
+ export_to_csv,
+ import_from_json,
+)
+
+
+def test_export_all_data_json(tmp_path):
+ """测试导出所有数据为 JSON"""
+ # 添加测试数据
+ db.add_exercise(Exercise(date=date(2026, 1, 18), type="跑步", duration=30, calories=240))
+ db.add_weight(Weight(date=date(2026, 1, 18), weight_kg=72.5))
+
+ output_path = tmp_path / "export.json"
+ export_all_data_json(output_path)
+
+ assert output_path.exists()
+ data = json.loads(output_path.read_text())
+ assert "exercises" in data
+ assert "weight" in data
+ assert len(data["exercises"]) > 0
+
+
+def test_export_to_csv(tmp_path):
+ """测试导出 CSV"""
+ db.add_exercise(Exercise(date=date(2026, 1, 18), type="跑步", duration=30, calories=240))
+
+ output_path = tmp_path / "exercise.csv"
+ export_to_csv("exercise", output_path)
+
+ assert output_path.exists()
+ content = output_path.read_text()
+ assert "date,type,duration" in content
+
+
+def test_import_from_json(tmp_path):
+ """测试从 JSON 导入"""
+ # 先导出
+ db.add_exercise(Exercise(date=date(2026, 1, 18), type="跑步", duration=30, calories=240))
+ json_path = tmp_path / "export.json"
+ export_all_data_json(json_path)
+
+ # 清空数据库
+ # （测试环境自动隔离，这里仅验证导入逻辑）
+
+ # 重新导入
+ stats = import_from_json(json_path)
+ assert stats["exercise"] > 0
+```
+
+#### 验收标准
+
+- [ ] `vitals export json ~/backup.json` 成功导出
+- [ ] `vitals export csv --type exercise ~/exercise.csv` 成功导出
+- [ ] JSON 文件可被 `import-json` 重新导入
+- [ ] CSV 格式与 `vitals import csv` 兼容
+- [ ] 测试覆盖导出和导入的往返一致性
+
+---
+
+### 任务 P2-2：自动备份数据库
+
+**优先级**: ⭐⭐⭐
+**预计工作量**: 2-3 小时
+**依赖**: 无
+
+#### 实现步骤
+
+**1. 创建备份模块（`src/vitals/core/backup.py`）**
+
+```python
+"""数据库备份模块"""
+
+import shutil
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Optional
+
+from . import database as db
+
+
+def get_backup_dir() -> Path:
+ """获取备份目录"""
+ backup_dir = Path.home() / ".vitals" / "backups"
+ backup_dir.mkdir(parents=True, exist_ok=True)
+ return backup_dir
+
+
+def backup_database(backup_dir: Optional[Path] = None) -> Path:
+ """
+ 备份数据库
+
+ 返回: 备份文件路径
+ """
+ if not backup_dir:
+ backup_dir = get_backup_dir()
+
+ db_path = db.get_db_path()
+ if not db_path.exists():
+ raise FileNotFoundError("数据库文件不存在")
+
+ # 生成备份文件名（包含时间戳）
+ timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+ backup_path = backup_dir / f"vitals_{timestamp}.db"
+
+ # 复制数据库文件
+ shutil.copy2(db_path, backup_path)
+
+ # 清理旧备份
+ cleanup_old_backups(backup_dir, keep_days=7)
+
+ return backup_path
+
+
+def cleanup_old_backups(backup_dir: Path, keep_days: int = 7) -> int:
+ """
+ 清理旧备份（保留最近 N 天）
+
+ 返回: 删除的文件数量
+ """
+ cutoff_date = datetime.now() - timedelta(days=keep_days)
+ deleted = 0
+
+ for backup_file in backup_dir.glob("vitals_*.db"):
+ try:
+ # 从文件名提取日期
+ timestamp_str = backup_file.stem.replace("vitals_", "")
+ file_date = datetime.strptime(timestamp_str[:8], "%Y%m%d")
+
+ if file_date < cutoff_date:
+ backup_file.unlink()
+ deleted += 1
+ except (ValueError, IndexError):
+ # 文件名格式不对，跳过
+ continue
+
+ return deleted
+
+
+def list_backups(backup_dir: Optional[Path] = None) -> list[dict]:
+ """
+ 列出所有备份
+
+ 返回: [{"path": Path, "date": datetime, "size": int}, ...]
+ """
+ if not backup_dir:
+ backup_dir = get_backup_dir()
+
+ backups = []
+ for backup_file in sorted(backup_dir.glob("vitals_*.db"), reverse=True):
+ try:
+ timestamp_str = backup_file.stem.replace("vitals_", "")
+ file_date = datetime.strptime(timestamp_str, "%Y%m%d_%H%M%S")
+ size = backup_file.stat().st_size
+
+ backups.append({
+ "path": backup_file,
+ "date": file_date,
+ "size": size,
+ })
+ except (ValueError, IndexError):
+ continue
+
+ return backups
+
+
+def restore_database(backup_path: Path) -> bool:
+ """
+ 恢复数据库
+
+ 注意：会覆盖当前数据库！
+ """
+ if not backup_path.exists():
+ raise FileNotFoundError(f"备份文件不存在: {backup_path}")
+
+ # 校验备份文件
+ if backup_path.stat().st_size == 0:
+ raise ValueError("备份文件为空")
+
+ db_path = db.get_db_path()
+
+ # 先备份当前数据库
+ if db_path.exists():
+ current_backup = db_path.parent / f"vitals_before_restore_{datetime.now().strftime('%Y%m%d_%H%M%S')}.db"
+ shutil.copy2(db_path, current_backup)
+
+ # 恢复备份
+ shutil.copy2(backup_path, db_path)
+
+ return True
+```
+
+**2. CLI 接入（`src/vitals/cli.py`）**
+
+```python
+# 新增子命令组
+backup_app = typer.Typer(help="数据备份")
+app.add_typer(backup_app, name="backup")
+
+@backup_app.command("create")
+def backup_create():
+ """创建数据库备份"""
+ from .core.backup import backup_database
+
+ try:
+ backup_path = backup_database()
+ size_mb = backup_path.stat().st_size / 1024 / 1024
+ console.print(f"[green]✓[/green] 备份已创建: {backup_path}")
+ console.print(f" 大小: {size_mb:.2f} MB")
+ except Exception as e:
+ console.print(f"[red]✗[/red] 备份失败: {e}")
+ raise typer.Exit(1)
+
+@backup_app.command("list")
+def backup_list():
+ """列出所有备份"""
+ from .core.backup import list_backups
+
+ backups = list_backups()
+
+ if not backups:
+ console.print("暂无备份")
+ return
+
+ table = Table(title="数据库备份")
+ table.add_column("日期时间", style="cyan")
+ table.add_column("大小", style="green")
+ table.add_column("路径", style="yellow")
+
+ for backup in backups:
+ size_mb = backup["size"] / 1024 / 1024
+ table.add_row(
+ backup["date"].strftime("%Y-%m-%d %H:%M:%S"),
+ f"{size_mb:.2f} MB",
+ str(backup["path"]),
+ )
+
+ console.print(table)
+
+@backup_app.command("restore")
+def backup_restore(
+ backup_file: Path = typer.Argument(..., help="备份文件路径"),
+ force: bool = typer.Option(False, "--force", "-f", help="跳过确认"),
+):
+ """恢复数据库（会覆盖当前数据库！）"""
+ from .core.backup import restore_database
+
+ if not force:
+ confirm = typer.confirm("⚠️ 恢复操作会覆盖当前数据库，是否继续？")
+ if not confirm:
+ console.print("已取消")
+ raise typer.Exit(0)
+
+ try:
+ restore_database(backup_file)
+ console.print(f"[green]✓[/green] 数据库已恢复: {backup_file}")
+ except Exception as e:
+ console.print(f"[red]✗[/red] 恢复失败: {e}")
+ raise typer.Exit(1)
+
+@backup_app.command("cleanup")
+def backup_cleanup(
+ days: int = typer.Option(7, "--days", "-d", help="保留最近多少天的备份"),
+):
+ """清理旧备份"""
+ from .core.backup import cleanup_old_backups, get_backup_dir
+
+ deleted = cleanup_old_backups(get_backup_dir(), keep_days=days)
+ console.print(f"[green]✓[/green] 已清理 {deleted} 个旧备份")
+```
+
+**3. 自动备份策略**
+
+在 `cli.py` 的主回调函数中添加自动备份：
+
+```python
+@app.callback()
+def main(
+ ctx: typer.Context,
+):
+ """Vitals - 本地优先的健康管理应用"""
+ db.init_db()
+
+ # 自动备份（仅在数据写入命令后执行）
+ # 检查是否是写入命令
+ write_commands = ["log", "import"]
+ if ctx.invoked_subcommand in write_commands:
+ # 注册退出时备份
+ import atexit
+ from .core.backup import backup_database, get_backup_dir
+
+ def auto_backup():
+ try:
+ # 检查今天是否已备份
+ backups = list(get_backup_dir().glob(f"vitals_{date.today().strftime('%Y%m%d')}_*.db"))
+ if not backups:
+ backup_database()
+ except Exception:
+ pass # 静默失败，不影响主流程
+
+ atexit.register(auto_backup)
+```
+
+**4. 测试（`tests/test_backup.py`）**
+
+```python
+"""数据库备份测试"""
+
+from datetime import datetime, timedelta
+from pathlib import Path
+
+import pytest
+
+from src.vitals.core.backup import (
+ backup_database,
+ cleanup_old_backups,
+ list_backups,
+ restore_database,
+)
+
+
+def test_backup_database(tmp_path):
+ """测试备份数据库"""
+ backup_path = backup_database(tmp_path)
+
+ assert backup_path.exists()
+ assert backup_path.name.startswith("vitals_")
+ assert backup_path.suffix == ".db"
+
+
+def test_cleanup_old_backups(tmp_path):
+ """测试清理旧备份"""
+ # 创建模拟备份文件
+ old_date = (datetime.now() - timedelta(days=10)).strftime("%Y%m%d")
+ new_date = datetime.now().strftime("%Y%m%d")
+
+ old_backup = tmp_path / f"vitals_{old_date}_120000.db"
+ new_backup = tmp_path / f"vitals_{new_date}_120000.db"
+
+ old_backup.write_text("old")
+ new_backup.write_text("new")
+
+ # 清理 7 天前的备份
+ deleted = cleanup_old_backups(tmp_path, keep_days=7)
+
+ assert deleted == 1
+ assert not old_backup.exists()
+ assert new_backup.exists()
+
+
+def test_list_backups(tmp_path):
+ """测试列出备份"""
+ # 创建测试备份
+ backup_path = backup_database(tmp_path)
+
+ backups = list_backups(tmp_path)
+
+ assert len(backups) > 0
+ assert backups[0]["path"] == backup_path
+
+
+def test_restore_database(tmp_path, test_db):
+ """测试恢复数据库"""
+ # 先备份
+ backup_path = backup_database(tmp_path)
+
+ # 模拟修改数据库
+ # ...
+
+ # 恢复
+ result = restore_database(backup_path)
+ assert result is True
+```
+
+#### 验收标准
+
+- [ ] `vitals backup create` 成功创建备份
+- [ ] `vitals backup list` 正确显示所有备份
+- [ ] `vitals backup restore 起始: {report.weight_start} kg → 结束: {report.weight_end} kg
+变化: {trend} {abs(report.weight_change or 0)} kg
+ """ + else: + weight_html = "暂无记录
" + + balance_html = "" + if report.tdee: + balance_type = "缺口" if report.avg_calorie_balance < 0 else "盈余" + balance_class = "positive" if report.avg_calorie_balance < 0 else "negative" + balance_html = f'平均每日{balance_type}: {abs(report.avg_calorie_balance)} 卡
' + + html = f""" + + + + + +
+
+
+
+
+
+
+
+
+"""
+ return html
+
+
+def export_report(report: WeeklyReport | MonthlyReport, output_path: Path) -> bool:
+ """导出报告到文件"""
+ suffix = output_path.suffix.lower()
+
+ if isinstance(report, WeeklyReport):
+ if suffix == ".md":
+ content = render_weekly_report_markdown(report)
+ output_path.write_text(content, encoding="utf-8")
+ elif suffix == ".html":
+ content = render_weekly_report_html(report)
+ output_path.write_text(content, encoding="utf-8")
+ elif suffix == ".pdf":
+ html_content = render_weekly_report_html(report)
+ _export_pdf(html_content, output_path)
+ elif suffix == ".png":
+ html_content = render_weekly_report_html(report)
+ _export_png(html_content, output_path)
+ else:
+ return False
+ else:
+ # MonthlyReport - 使用类似的渲染逻辑
+ if suffix == ".md":
+ content = _render_monthly_report_markdown(report)
+ output_path.write_text(content, encoding="utf-8")
+ elif suffix == ".html":
+ content = _render_monthly_report_html(report)
+ output_path.write_text(content, encoding="utf-8")
+ elif suffix == ".pdf":
+ html_content = _render_monthly_report_html(report)
+ _export_pdf(html_content, output_path)
+ elif suffix == ".png":
+ html_content = _render_monthly_report_html(report)
+ _export_png(html_content, output_path)
+ else:
+ return False
+
+ return True
+
+
+def _export_pdf(html_content: str, output_path: Path):
+ """导出 PDF"""
+ try:
+ _ensure_weasyprint_env()
+ from weasyprint import HTML
+ HTML(string=html_content).write_pdf(output_path)
+ except ImportError:
+ raise RuntimeError("需要安装 weasyprint: pip install weasyprint")
+
+
+def _export_png(html_content: str, output_path: Path, width: int = 1080):
+ """导出 PNG"""
+ try:
+ _ensure_weasyprint_env()
+ from weasyprint import HTML
+ # WeasyPrint 可以先导出 PDF，再转换为图片
+ # 或者使用 playwright/html2image
+ pdf_bytes = HTML(string=html_content).write_pdf()
+
+ # 尝试使用 pdf2image 转换
+ try:
+ from pdf2image import convert_from_bytes
+ images = convert_from_bytes(pdf_bytes, dpi=150)
+ if images:
+ images[0].save(output_path, "PNG")
+ return
+ except ImportError:
+ pass
+
+ # 备选：直接保存 PDF
+ output_path.with_suffix(".pdf").write_bytes(pdf_bytes)
+ raise RuntimeError(f"PNG 导出需要 pdf2image，已保存为 PDF: {output_path.with_suffix('.pdf')}")
+
+ except ImportError:
+ raise RuntimeError("需要安装 weasyprint: pip install weasyprint")
+
+
+def _ensure_weasyprint_env():
+ """
+ macOS 下 WeasyPrint 依赖需要能找到 Homebrew 库与 poppler 可执行文件。
+ """
+ homebrew_libs = [
+ "/opt/homebrew/lib",
+ "/opt/homebrew/opt/libffi/lib",
+ "/usr/local/lib",
+ ]
+ fallback = os.environ.get("DYLD_FALLBACK_LIBRARY_PATH", "")
+ for lib in homebrew_libs:
+ if lib not in fallback:
+ fallback = f"{lib}:{fallback}" if fallback else lib
+ if fallback:
+ os.environ["DYLD_FALLBACK_LIBRARY_PATH"] = fallback
+
+ path = os.environ.get("PATH", "")
+ for bin_dir in ["/opt/homebrew/bin", "/usr/local/bin"]:
+ if bin_dir not in path:
+ path = f"{bin_dir}:{path}" if path else bin_dir
+ if path:
+ os.environ["PATH"] = path
+
+
+def _render_monthly_report_markdown(report: MonthlyReport) -> str:
+ """渲染月报为 Markdown"""
+ lines = []
+ lines.append(f"# {report.year}年{report.month}月 健康月报")
+ lines.append("")
+
+ lines.append("## 概览")
+ lines.append("")
+ lines.append(f"- **运动**: {report.exercise_count} 次, {report.exercise_duration} 分钟, {report.exercise_days} 天")
+ lines.append(f"- **睡眠**: 平均 {report.avg_sleep_duration} 小时, 质量 {report.avg_sleep_quality}/5")
+ lines.append(f"- **饮食**: 平均每日 {report.avg_calories_intake} 卡")
+ if report.weight_change is not None:
+ trend = "下降" if report.weight_change < 0 else "上升"
+ lines.append(f"- **体重**: {trend} {abs(report.weight_change)} kg ({report.weight_start} → {report.weight_end})")
+ lines.append("")
+
+ if report.best_exercise:
+ lines.append("## 本月最佳")
+ lines.append("")
+ lines.append(f"- **最佳运动**: {report.best_exercise.type} {report.best_exercise.duration}分钟, 消耗 {report.best_exercise.calories} 卡")
+ if report.longest_sleep:
+ lines.append(f"- **最长睡眠**: {report.longest_sleep.duration} 小时 ({report.longest_sleep.date})")
+ lines.append("")
+
+ lines.append("## 周汇总")
+ lines.append("")
+ lines.append("| 周 | 运动 | 摄入 | 睡眠 |")
+ lines.append("|---|------|------|------|")
+ for week in report.weekly_summaries:
+ lines.append(f"| 第{week['week']}周 | {week['exercise_duration']}分钟 | {week['calories_intake']}卡 | {week['avg_sleep']}h |")
+ lines.append("")
+
+ lines.append("---")
+ lines.append("*由 Vitals 生成*")
+
+ return "\n".join(lines)
+
+
+def _render_monthly_report_html(report: MonthlyReport) -> str:
+ """渲染月报为 HTML"""
+ weekly_rows = ""
+ for week in report.weekly_summaries:
+ weekly_rows += f"""
+ 周报 {report.start_date} ~ {report.end_date}
+ +
+
+
+
+
+ 运动
+{report.exercise_duration}分钟
+ {report.exercise_count} 次运动，消耗 {report.exercise_calories} 卡
+
+
+ 睡眠
+{report.avg_sleep_duration}小时/天
+ 平均质量 {report.avg_sleep_quality}/5
+
+
+ 饮食
+{report.avg_calories_intake}卡/天
+ {balance_html}
+
+
+ 体重
+ {weight_html} +每日明细
+| 日期 | +运动 | +摄入 | +睡眠 | +
|---|
最佳运动: {report.best_exercise.type} {report.best_exercise.duration}分钟
" + if report.longest_sleep: + best_html += f"最长睡眠: {report.longest_sleep.duration}小时
" + + return f""" + + + + + +
+
+
+
+
+
+
+
+
+"""
diff --git a/src/vitals/importers/__init__.py b/src/vitals/importers/__init__.py
new file mode 100644
index 0000000..5e8907b
--- /dev/null
+++ b/src/vitals/importers/__init__.py
@@ -0,0 +1 @@
+"""数据导入适配器 - Garmin、咕咚、CSV"""
diff --git a/src/vitals/importers/base.py b/src/vitals/importers/base.py
new file mode 100644
index 0000000..d2f8b90
--- /dev/null
+++ b/src/vitals/importers/base.py
@@ -0,0 +1,52 @@
+"""数据导入适配器基类"""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import TypeVar, Generic
+
+T = TypeVar("T")
+
+
+class BaseImporter(ABC, Generic[T]):
+ """数据导入适配器基类"""
+
+ @abstractmethod
+ def parse(self, file_path: Path) -> list[T]:
+ """解析文件，返回数据列表"""
+ pass
+
+ @abstractmethod
+ def validate(self, file_path: Path) -> bool:
+ """验证文件格式是否正确"""
+ pass
+
+ def import_data(self, file_path: Path) -> tuple[int, int]:
+ """
+ 导入数据
+ 返回: (成功数, 跳过数)
+ """
+ if not self.validate(file_path):
+ raise ValueError(f"无效的文件格式: {file_path}")
+
+ records = self.parse(file_path)
+ success = 0
+ skipped = 0
+
+ for record in records:
+ try:
+ if self._save_record(record):
+ success += 1
+ else:
+ skipped += 1
+ except Exception:
+ skipped += 1
+
+ return success, skipped
+
+ @abstractmethod
+ def _save_record(self, record: T) -> bool:
+ """
+ 保存单条记录
+ 返回: True 表示保存成功，False 表示跳过（如重复）
+ """
+ pass
diff --git a/src/vitals/importers/codoon.py b/src/vitals/importers/codoon.py
new file mode 100644
index 0000000..eecc9dd
--- /dev/null
+++ b/src/vitals/importers/codoon.py
@@ -0,0 +1,126 @@
+"""咕咚 Codoon 数据导入适配器"""
+
+import json
+from datetime import date, datetime
+from pathlib import Path
+from typing import Union
+
+from ..core import database as db
+from ..core.models import Exercise, DataSource
+from .base import BaseImporter
+
+
+class CodoonImporter(BaseImporter[Exercise]):
+ """咕咚数据导入器
+
+ 支持从咕咚 APP 导出的 JSON 文件导入运动数据。
+ """
+
+ def validate(self, file_path: Path) -> bool:
+ if not file_path.exists():
+ return False
+ if file_path.suffix.lower() != ".json":
+ return False
+ try:
+ with open(file_path, "r", encoding="utf-8") as f:
+ data = json.load(f)
+ # 检查是否包含咕咚数据结构
+ return isinstance(data, (list, dict))
+ except (json.JSONDecodeError, UnicodeDecodeError):
+ return False
+
+ def parse(self, file_path: Path) -> list[Exercise]:
+ """解析咕咚 JSON 文件"""
+ exercises = []
+
+ with open(file_path, "r", encoding="utf-8") as f:
+ data = json.load(f)
+
+ # 支持多种数据结构
+ activities = []
+ if isinstance(data, list):
+ activities = data
+ elif isinstance(data, dict):
+ activities = data.get("data", []) or data.get("activities", []) or data.get("records", [])
+ if not activities and "startTime" in data:
+ activities = [data]
+
+ for activity in activities:
+ try:
+ exercise = self._parse_activity(activity)
+ if exercise:
+ exercises.append(exercise)
+ except (KeyError, ValueError, TypeError):
+ continue
+
+ return exercises
+
+ def _parse_activity(self, activity: dict) -> Exercise | None:
+ """解析单条运动记录"""
+ # 解析运动类型
+ sport_type = activity.get("sportType") or activity.get("sports_type") or activity.get("type")
+ type_mapping = {
+ 0: "健走",
+ 1: "跑步",
+ 2: "骑行",
+ 3: "轮滑",
+ "running": "跑步",
+ "walking": "健走",
+ "cycling": "骑行",
+ "outdoor_running": "跑步",
+ "indoor_running": "跑步",
+ "outdoor_walking": "健走",
+ "outdoor_cycling": "骑行",
+ }
+ exercise_type = type_mapping.get(sport_type, "其他")
+
+ # 解析日期
+ start_time = activity.get("startTime") or activity.get("start_time") or activity.get("date")
+ if not start_time:
+ return None
+
+ if isinstance(start_time, str):
+ # 尝试多种日期格式
+ for fmt in ["%Y-%m-%d %H:%M:%S", "%Y-%m-%dT%H:%M:%S", "%Y-%m-%d"]:
+ try:
+ activity_date = datetime.strptime(start_time[:19], fmt).date()
+ break
+ except ValueError:
+ continue
+ else:
+ return None
+ elif isinstance(start_time, (int, float)):
+ # 时间戳（毫秒）
+ activity_date = datetime.fromtimestamp(start_time / 1000).date()
+ else:
+ return None
+
+ # 解析时长（秒转分钟）
+ duration_secs = activity.get("totalTime") or activity.get("total_time") or activity.get("duration") or 0
+ duration_mins = int(duration_secs / 60) if duration_secs > 60 else int(duration_secs)
+
+ # 解析距离（米转公里）
+ distance_m = activity.get("totalLength") or activity.get("total_length") or activity.get("distance") or 0
+ distance_km = distance_m / 1000 if distance_m > 100 else distance_m # 兼容已是 km 的情况
+
+ # 解析卡路里
+ calories = int(activity.get("totalCalories") or activity.get("total_calories") or activity.get("calories") or 0)
+
+ # 解析心率
+ hr = activity.get("averageHeartRate") or activity.get("average_heart_rate") or activity.get("avgHr")
+
+ return Exercise(
+ date=activity_date,
+ type=exercise_type,
+ duration=duration_mins,
+ calories=calories,
+ distance=round(distance_km, 2) if distance_km else None,
+ heart_rate_avg=int(hr) if hr else None,
+ source=DataSource.CODOON.value,
+ raw_data=activity,
+ )
+
+ def _save_record(self, record: Exercise) -> bool:
+ """保存运动记录"""
+ db.add_exercise(record)
+ return True
diff --git a/src/vitals/importers/csv_importer.py b/src/vitals/importers/csv_importer.py
new file mode 100644
index 0000000..462b90e
--- /dev/null
+++ b/src/vitals/importers/csv_importer.py
@@ -0,0 +1,187 @@
+"""CSV 数据导入适配器"""
+
+import csv
+from datetime import date, time
+from pathlib import Path
+from typing import Union
+
+from ..core import database as db
+from ..core.models import Exercise, Meal, Sleep, Weight, DataSource
+from .base import BaseImporter
+
+
+class WeightCSVImporter(BaseImporter[Weight]):
+ """体重 CSV 导入器
+
+ 支持的 CSV 格式:
+ date,weight_kg,body_fat_pct,muscle_mass,notes
+ 2024-01-01,72.5,18.5,,
+ """
+
+ def validate(self, file_path: Path) -> bool:
+ if not file_path.exists():
+ return False
+ if file_path.suffix.lower() != ".csv":
+ return False
+ return True
+
+ def parse(self, file_path: Path) -> list[Weight]:
+ records = []
+ with open(file_path, "r", encoding="utf-8") as f:
+ reader = csv.DictReader(f)
+ for row in reader:
+ try:
+ record = Weight(
+ date=date.fromisoformat(row["date"]),
+ weight_kg=float(row["weight_kg"]),
+ body_fat_pct=float(row["body_fat_pct"]) if row.get("body_fat_pct") else None,
+ muscle_mass=float(row["muscle_mass"]) if row.get("muscle_mass") else None,
+ notes=row.get("notes"),
+ )
+ records.append(record)
+ except (KeyError, ValueError):
+ continue
+ return records
+
+ def _save_record(self, record: Weight) -> bool:
+ # 检查是否已存在同日期记录
+ existing = db.get_weight_records(record.date, record.date)
+ if existing:
+ return False # 跳过重复
+ db.add_weight(record)
+ return True
+
+
+class ExerciseCSVImporter(BaseImporter[Exercise]):
+ """运动 CSV 导入器
+
+ 支持的 CSV 格式:
+ date,type,duration,calories,distance,heart_rate_avg,notes
+ 2024-01-01,跑步,30,240,5.0,145,
+ """
+
+ def validate(self, file_path: Path) -> bool:
+ if not file_path.exists():
+ return False
+ if file_path.suffix.lower() != ".csv":
+ return False
+ return True
+
+ def parse(self, file_path: Path) -> list[Exercise]:
+ records = []
+ with open(file_path, "r", encoding="utf-8") as f:
+ reader = csv.DictReader(f)
+ for row in reader:
+ try:
+ record = Exercise(
+ date=date.fromisoformat(row["date"]),
+ type=row["type"],
+ duration=int(row["duration"]),
+ calories=int(row.get("calories", 0)),
+ distance=float(row["distance"]) if row.get("distance") else None,
+ heart_rate_avg=int(row["heart_rate_avg"]) if row.get("heart_rate_avg") else None,
+ source=DataSource.CSV.value,
+ notes=row.get("notes"),
+ )
+ records.append(record)
+ except (KeyError, ValueError):
+ continue
+ return records
+
+ def _save_record(self, record: Exercise) -> bool:
+ db.add_exercise(record)
+ return True
+
+
+class MealCSVImporter(BaseImporter[Meal]):
+ """饮食 CSV 导入器
+
+ 支持的 CSV 格式:
+ date,meal_type,description,calories,protein,carbs,fat
+ 2024-01-01,午餐,米饭+红烧肉,650,25,80,20
+ """
+
+ def validate(self, file_path: Path) -> bool:
+ if not file_path.exists():
+ return False
+ if file_path.suffix.lower() != ".csv":
+ return False
+ return True
+
+ def parse(self, file_path: Path) -> list[Meal]:
+ records = []
+ with open(file_path, "r", encoding="utf-8") as f:
+ reader = csv.DictReader(f)
+ for row in reader:
+ try:
+ record = Meal(
+ date=date.fromisoformat(row["date"]),
+ meal_type=row["meal_type"],
+ description=row.get("description", ""),
+ calories=int(row.get("calories", 0)),
+ protein=float(row["protein"]) if row.get("protein") else None,
+ carbs=float(row["carbs"]) if row.get("carbs") else None,
+ fat=float(row["fat"]) if row.get("fat") else None,
+ )
+ records.append(record)
+ except (KeyError, ValueError):
+ continue
+ return records
+
+ def _save_record(self, record: Meal) -> bool:
+ db.add_meal(record)
+ return True
+
+
+class SleepCSVImporter(BaseImporter[Sleep]):
+ """睡眠 CSV 导入器
+
+ 支持的 CSV 格式:
+ date,bedtime,wake_time,duration,quality,deep_sleep_mins,notes
+ 2024-01-01,23:30,07:00,7.5,4,90,
+ """
+
+ def validate(self, file_path: Path) -> bool:
+ if not file_path.exists():
+ return False
+ if file_path.suffix.lower() != ".csv":
+ return False
+ return True
+
+ def parse(self, file_path: Path) -> list[Sleep]:
+ records = []
+ with open(file_path, "r", encoding="utf-8") as f:
+ reader = csv.DictReader(f)
+ for row in reader:
+ try:
+ record = Sleep(
+ date=date.fromisoformat(row["date"]),
+ bedtime=time.fromisoformat(row["bedtime"]) if row.get("bedtime") else None,
+ wake_time=time.fromisoformat(row["wake_time"]) if row.get("wake_time") else None,
+ duration=float(row.get("duration", 0)),
+ quality=int(row.get("quality", 3)),
+ deep_sleep_mins=int(row["deep_sleep_mins"]) if row.get("deep_sleep_mins") else None,
+ source=DataSource.CSV.value,
+ notes=row.get("notes"),
+ )
+ records.append(record)
+ except (KeyError, ValueError):
+ continue
+ return records
+
+ def _save_record(self, record: Sleep) -> bool:
+ db.add_sleep(record)
+ return True
+
+
+def get_csv_importer(data_type: str) -> BaseImporter:
+ """获取 CSV 导入器"""
+ importers = {
+ "weight": WeightCSVImporter(),
+ "exercise": ExerciseCSVImporter(),
+ "meal": MealCSVImporter(),
+ "sleep": SleepCSVImporter(),
+ }
+ if data_type not in importers:
+ raise ValueError(f"不支持的数据类型: {data_type}")
+ return importers[data_type]
diff --git a/src/vitals/importers/garmin.py b/src/vitals/importers/garmin.py
new file mode 100644
index 0000000..1ed6dd5
--- /dev/null
+++ b/src/vitals/importers/garmin.py
@@ -0,0 +1,264 @@
+"""Garmin 佳明数据导入适配器"""
+
+import json
+import zipfile
+from datetime import date, datetime
+from pathlib import Path
+from typing import Union
+
+from ..core import database as db
+from ..core.models import Exercise, Sleep, Weight, DataSource
+from .base import BaseImporter
+
+
+class GarminImporter(BaseImporter[Union[Exercise, Sleep, Weight]]):
+ """Garmin 数据导入器
+
+ 支持从 Garmin Connect 导出的 ZIP 文件导入数据。
+ ZIP 文件结构:
+ - DI_CONNECT/
+ - DI-Connect-Fitness/
+ - *_summarizedActivities.json # 运动数据
+ - DI-Connect-Wellness/
+ - *_sleepData.json # 睡眠数据
+ - *_weightData.json # 体重数据
+ """
+
+ def __init__(self):
+ self.exercises: list[Exercise] = []
+ self.sleep_records: list[Sleep] = []
+ self.weight_records: list[Weight] = []
+
+ def validate(self, file_path: Path) -> bool:
+ if not file_path.exists():
+ return False
+ if file_path.suffix.lower() != ".zip":
+ return False
+ try:
+ with zipfile.ZipFile(file_path, "r") as zf:
+ names = zf.namelist()
+ # 检查是否包含 Garmin 数据目录
+ return any("DI_CONNECT" in name or "DI-Connect" in name for name in names)
+ except zipfile.BadZipFile:
+ return False
+
+ def parse(self, file_path: Path) -> list[Union[Exercise, Sleep, Weight]]:
+ """解析 Garmin ZIP 文件"""
+ self.exercises = []
+ self.sleep_records = []
+ self.weight_records = []
+
+ with zipfile.ZipFile(file_path, "r") as zf:
+ for name in zf.namelist():
+ if name.endswith(".json"):
+ try:
+ content = zf.read(name).decode("utf-8")
+ data = json.loads(content)
+
+ if "summarizedActivities" in name.lower() or "activities" in name.lower():
+ self._parse_activities(data)
+ elif "sleep" in name.lower():
+ self._parse_sleep(data)
+ elif "weight" in name.lower():
+ self._parse_weight(data)
+ except (json.JSONDecodeError, UnicodeDecodeError):
+ continue
+
+ return self.exercises + self.sleep_records + self.weight_records
+
+ def _parse_activities(self, data: Union[list, dict]):
+ """解析运动数据"""
+ activities = data if isinstance(data, list) else data.get("activities", [])
+
+ for activity in activities:
+ try:
+ # Garmin 活动类型映射
+ activity_type = activity.get("activityType", {})
+ type_key = activity_type.get("typeKey", "other") if isinstance(activity_type, dict) else "other"
+
+ type_mapping = {
+ "running": "跑步",
+ "cycling": "骑行",
+ "swimming": "游泳",
+ "walking": "健走",
+ "strength_training": "力量训练",
+ "yoga": "瑜伽",
+ }
+ exercise_type = type_mapping.get(type_key, "其他")
+
+ # 解析日期
+ start_time = activity.get("startTimeLocal") or activity.get("startTime")
+ if start_time:
+ activity_date = datetime.fromisoformat(start_time.replace("Z", "+00:00")).date()
+ else:
+ continue
+
+ # 解析时长（秒转分钟）
+ duration_secs = activity.get("duration") or activity.get("movingDuration") or 0
+ duration_mins = int(duration_secs / 60)
+
+ # 解析距离（米转公里）
+ distance_m = activity.get("distance") or 0
+ distance_km = distance_m / 1000 if distance_m else None
+
+ # 解析卡路里
+ calories = int(activity.get("calories") or activity.get("activeCalories") or 0)
+
+ # 解析心率
+ hr = activity.get("averageHR") or activity.get("avgHeartRate")
+
+ exercise = Exercise(
+ date=activity_date,
+ type=exercise_type,
+ duration=duration_mins,
+ calories=calories,
+ distance=distance_km,
+ heart_rate_avg=int(hr) if hr else None,
+ source=DataSource.GARMIN.value,
+ raw_data=activity,
+ )
+ self.exercises.append(exercise)
+
+ except (KeyError, ValueError, TypeError):
+ continue
+
+ def _parse_sleep(self, data: Union[list, dict]):
+ """解析睡眠数据"""
+ sleep_list = data if isinstance(data, list) else [data]
+
+ for sleep_data in sleep_list:
+ try:
+ # 解析日期
+ calendar_date = sleep_data.get("calendarDate") or sleep_data.get("summaryDate")
+ if calendar_date:
+ sleep_date = date.fromisoformat(calendar_date)
+ else:
+ continue
+
+ # 解析时长（秒转小时）
+ duration_secs = sleep_data.get("sleepTimeSeconds") or sleep_data.get("totalSleepTimeInSeconds") or 0
+ duration_hours = round(duration_secs / 3600, 1)
+
+ # 解析深睡时长
+ deep_sleep_secs = sleep_data.get("deepSleepSeconds") or sleep_data.get("deepSleepTimeInSeconds") or 0
+ deep_sleep_mins = int(deep_sleep_secs / 60) if deep_sleep_secs else None
+
+ # 简单质量评估（基于深睡比例）
+ quality = 3
+ if duration_secs > 0 and deep_sleep_secs:
+ deep_ratio = deep_sleep_secs / duration_secs
+ if deep_ratio > 0.25:
+ quality = 5
+ elif deep_ratio > 0.20:
+ quality = 4
+ elif deep_ratio > 0.15:
+ quality = 3
+ else:
+ quality = 2
+
+ sleep = Sleep(
+ date=sleep_date,
+ duration=duration_hours,
+ quality=quality,
+ deep_sleep_mins=deep_sleep_mins,
+ source=DataSource.GARMIN.value,
+ )
+ self.sleep_records.append(sleep)
+
+ except (KeyError, ValueError, TypeError):
+ continue
+
+ def _parse_weight(self, data: Union[list, dict]):
+ """解析体重数据"""
+ weight_list = data if isinstance(data, list) else [data]
+
+ for weight_data in weight_list:
+ try:
+ # 解析日期
+ calendar_date = weight_data.get("calendarDate") or weight_data.get("date")
+ if calendar_date:
+ weight_date = date.fromisoformat(calendar_date[:10])
+ else:
+ continue
+
+ # 解析体重（克转公斤）
+ weight_g = weight_data.get("weight") or 0
+ weight_kg = weight_g / 1000 if weight_g > 1000 else weight_g # 兼容已是 kg 的情况
+
+ if weight_kg < 20 or weight_kg > 300: # 合理性检查
+ continue
+
+ # 解析体脂率
+ body_fat = weight_data.get("bodyFat") or weight_data.get("bodyFatPercentage")
+
+ # 解析肌肉量
+ muscle = weight_data.get("muscleMass")
+ muscle_kg = muscle / 1000 if muscle and muscle > 1000 else muscle
+
+ weight = Weight(
+ date=weight_date,
+ weight_kg=round(weight_kg, 1),
+ body_fat_pct=round(body_fat, 1) if body_fat else None,
+ muscle_mass=round(muscle_kg, 1) if muscle_kg else None,
+ )
+ self.weight_records.append(weight)
+
+ except (KeyError, ValueError, TypeError):
+ continue
+
+ def _save_record(self, record: Union[Exercise, Sleep, Weight]) -> bool:
+ """保存记录"""
+ if isinstance(record, Exercise):
+ db.add_exercise(record)
+ elif isinstance(record, Sleep):
+ db.add_sleep(record)
+ elif isinstance(record, Weight):
+ # 检查重复
+ existing = db.get_weight_records(record.date, record.date)
+ if existing:
+ return False
+ db.add_weight(record)
+ return True
+
+ def import_data(self, file_path: Path) -> dict[str, tuple[int, int]]:
+ """
+ 导入 Garmin 数据
+ 返回: {"exercise": (成功, 跳过), "sleep": (成功, 跳过), "weight": (成功, 跳过)}
+ """
+ if not self.validate(file_path):
+ raise ValueError(f"无效的 Garmin 导出文件: {file_path}")
+
+ self.parse(file_path)
+
+ results = {
+ "exercise": (0, 0),
+ "sleep": (0, 0),
+ "weight": (0, 0),
+ }
+
+ for exercise in self.exercises:
+ try:
+ db.add_exercise(exercise)
+ results["exercise"] = (results["exercise"][0] + 1, results["exercise"][1])
+ except Exception:
+ results["exercise"] = (results["exercise"][0], results["exercise"][1] + 1)
+
+ for sleep in self.sleep_records:
+ try:
+ db.add_sleep(sleep)
+ results["sleep"] = (results["sleep"][0] + 1, results["sleep"][1])
+ except Exception:
+ results["sleep"] = (results["sleep"][0], results["sleep"][1] + 1)
+
+ for weight in self.weight_records:
+ try:
+ existing = db.get_weight_records(weight.date, weight.date)
+ if existing:
+ results["weight"] = (results["weight"][0], results["weight"][1] + 1)
+ else:
+ db.add_weight(weight)
+ results["weight"] = (results["weight"][0] + 1, results["weight"][1])
+ except Exception:
+ results["weight"] = (results["weight"][0], results["weight"][1] + 1)
+
+ return results
diff --git a/src/vitals/vision/__init__.py b/src/vitals/vision/__init__.py
new file mode 100644
index 0000000..6859cf0
--- /dev/null
+++ b/src/vitals/vision/__init__.py
@@ -0,0 +1 @@
+"""食物识别模块"""
diff --git a/src/vitals/vision/__pycache__/__init__.cpython-313.pyc b/src/vitals/vision/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000..9dfb475
Binary files /dev/null and b/src/vitals/vision/__pycache__/__init__.cpython-313.pyc differ
diff --git a/src/vitals/vision/__pycache__/analyzer.cpython-313.pyc b/src/vitals/vision/__pycache__/analyzer.cpython-313.pyc
new file mode 100644
index 0000000..0fa5d45
Binary files /dev/null and b/src/vitals/vision/__pycache__/analyzer.cpython-313.pyc differ
diff --git a/src/vitals/vision/analyzer.py b/src/vitals/vision/analyzer.py
new file mode 100644
index 0000000..c1b679f
--- /dev/null
+++ b/src/vitals/vision/analyzer.py
@@ -0,0 +1,154 @@
+"""食物图片识别分析器"""
+
+import base64
+from pathlib import Path
+from typing import Optional
+
+from ..core.calories import estimate_meal_calories
+
+
+class FoodAnalyzer:
+ """食物分析器基类"""
+
+ def analyze(self, image_path: Path) -> dict:
+ """
+ 分析食物图片
+
+ 返回:
+ {
+ "description": "米饭、红烧排骨、西兰花",
+ "total_calories": 680,
+ "total_protein": 25.0,
+ "total_carbs": 85.0,
+ "total_fat": 20.0,
+ "items": [...]
+ }
+ """
+ raise NotImplementedError
+
+
+class ClaudeFoodAnalyzer(FoodAnalyzer):
+ """使用 Claude Vision API 的食物分析器"""
+
+ def __init__(self, api_key: Optional[str] = None):
+ import os
+ self.api_key = api_key or os.environ.get("ANTHROPIC_API_KEY")
+
+ def analyze(self, image_path: Path) -> dict:
+ """使用 Claude Vision 分析食物图片"""
+ if not self.api_key:
+ raise ValueError("需要设置 ANTHROPIC_API_KEY 环境变量")
+
+ from anthropic import Anthropic
+
+ client = Anthropic(api_key=self.api_key)
+
+ # 读取并编码图片
+ image_data = self._encode_image(image_path)
+ media_type = self._get_media_type(image_path)
+
+ # 调用 Claude Vision API
+ message = client.messages.create(
+ model="claude-sonnet-4-20250514",
+ max_tokens=1024,
+ messages=[
+ {
+ "role": "user",
+ "content": [
+ {
+ "type": "image",
+ "source": {
+ "type": "base64",
+ "media_type": media_type,
+ "data": image_data,
+ },
+ },
+ {
+ "type": "text",
+ "text": """请分析这张食物图片，识别出所有食物。
+
+要求：
+1. 列出所有可识别的食物，用中文名称
+2. 估计每种食物的大致份量
+3. 按照 "食物名称" 的格式返回，多个食物用加号连接
+
+例如返回格式：米饭+红烧排骨+西兰花
+
+只返回食物列表，不需要其他解释。"""
+ },
+ ],
+ }
+ ],
+ )
+
+ # 解析响应
+ description = message.content[0].text.strip()
+
+ # 使用卡路里计算模块估算营养成分
+ result = estimate_meal_calories(description)
+ result["description"] = description
+
+ return result
+
+ def _encode_image(self, image_path: Path) -> str:
+ """将图片编码为 base64"""
+ with open(image_path, "rb") as f:
+ return base64.standard_b64encode(f.read()).decode("utf-8")
+
+ def _get_media_type(self, image_path: Path) -> str:
+ """获取图片的 MIME 类型"""
+ suffix = image_path.suffix.lower()
+ media_types = {
+ ".jpg": "image/jpeg",
+ ".jpeg": "image/jpeg",
+ ".png": "image/png",
+ ".gif": "image/gif",
+ ".webp": "image/webp",
+ }
+ return media_types.get(suffix, "image/jpeg")
+
+
+class LocalFoodAnalyzer(FoodAnalyzer):
+ """本地食物分析器（简单实现，基于文件名）"""
+
+ def analyze(self, image_path: Path) -> dict:
+ """
+ 简单的本地分析器
+ 实际使用时可以替换为本地 AI 模型
+ """
+ # 目前仅返回空结果，提示用户手动输入
+ return {
+ "description": "",
+ "total_calories": 0,
+ "total_protein": 0,
+ "total_carbs": 0,
+ "total_fat": 0,
+ "items": [],
+ "note": "本地分析器暂不支持图片识别，请手动输入食物描述",
+ }
+
+
+def get_analyzer(
+ provider: str = "qwen",
+ api_key: Optional[str] = None,
+ use_claude: bool = False, # 保留向后兼容
+) -> FoodAnalyzer:
+ """
+ 获取食物分析器
+
+ provider: "qwen" | "deepseek" | "claude" | "local"
+ """
+ # 向后兼容: 如果使用旧参数 use_claude=True
+ if use_claude:
+ provider = "claude"
+
+ if provider == "qwen":
+ from .providers.qwen import get_qwen_analyzer
+ return get_qwen_analyzer(api_key)
+ elif provider == "deepseek":
+ from .providers.deepseek import get_deepseek_analyzer
+ return get_deepseek_analyzer(api_key)
+ elif provider == "claude":
+ return ClaudeFoodAnalyzer(api_key)
+ else:
+ return LocalFoodAnalyzer()
diff --git a/src/vitals/vision/providers/__init__.py b/src/vitals/vision/providers/__init__.py
new file mode 100644
index 0000000..53d6b85
--- /dev/null
+++ b/src/vitals/vision/providers/__init__.py
@@ -0,0 +1 @@
+"""食物识别提供者"""
diff --git a/src/vitals/vision/providers/__pycache__/__init__.cpython-313.pyc b/src/vitals/vision/providers/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000..d62800d
Binary files /dev/null and b/src/vitals/vision/providers/__pycache__/__init__.cpython-313.pyc differ
diff --git a/src/vitals/vision/providers/__pycache__/deepseek.cpython-313.pyc b/src/vitals/vision/providers/__pycache__/deepseek.cpython-313.pyc
new file mode 100644
index 0000000..6d70462
Binary files /dev/null and b/src/vitals/vision/providers/__pycache__/deepseek.cpython-313.pyc differ
diff --git a/src/vitals/vision/providers/__pycache__/qwen.cpython-313.pyc b/src/vitals/vision/providers/__pycache__/qwen.cpython-313.pyc
new file mode 100644
index 0000000..8382d1d
Binary files /dev/null and b/src/vitals/vision/providers/__pycache__/qwen.cpython-313.pyc differ
diff --git a/src/vitals/vision/providers/deepseek.py b/src/vitals/vision/providers/deepseek.py
new file mode 100644
index 0000000..92d902b
--- /dev/null
+++ b/src/vitals/vision/providers/deepseek.py
@@ -0,0 +1,175 @@
+"""DeepSeek Vision API 适配器"""
+
+import base64
+import os
+from pathlib import Path
+from typing import Optional
+
+import httpx
+
+from ...core.calories import estimate_meal_calories
+
+
+class DeepSeekVisionAnalyzer:
+ """DeepSeek Vision 食物识别分析器"""
+
+ def __init__(self, api_key: Optional[str] = None):
+ self.api_key = api_key or os.environ.get("DEEPSEEK_API_KEY")
+ self.base_url = "https://api.deepseek.com/v1"
+
+ def analyze_image(self, image_path: Path) -> dict:
+ """
+ 分析食物图片
+
+ 返回:
+ {
+ "description": "米饭、红烧排骨、西兰花",
+ "total_calories": 680,
+ "items": [...]
+ }
+ """
+ if not self.api_key:
+ raise ValueError("需要设置 DEEPSEEK_API_KEY 环境变量")
+
+ # 读取并编码图片
+ image_data = self._encode_image(image_path)
+
+ # 调用 DeepSeek Vision API (专用视觉端点)
+ headers = {
+ "Authorization": f"Bearer {self.api_key}",
+ "Content-Type": "application/json",
+ }
+
+ prompt = """请分析这张食物图片，识别出所有食物。
+
+要求：
+1. 列出所有可识别的食物，用中文名称
+2. 估计每种食物的大致份量（如：一碗米饭、100g红烧肉）
+3. 按照 "食物1+食物2+食物3" 的格式返回
+
+例如返回格式：一碗米饭+红烧排骨+西兰花
+
+只返回食物列表，不需要其他解释。"""
+
+ # 尝试使用 deepseek-vision 端点
+ payload = {
+ "model": "deepseek-vision",
+ "image": image_data,
+ "prompt": prompt,
+ }
+
+ with httpx.Client(timeout=60.0) as client:
+ try:
+ # 首先尝试 vision 端点
+ response = client.post(
+ f"{self.base_url}/vision",
+ headers=headers,
+ json=payload,
+ )
+ response.raise_for_status()
+ result = response.json()
+
+ # 从响应中提取描述
+ if "result" in result:
+ description = result["result"].strip()
+ elif "choices" in result:
+ description = result["choices"][0]["message"]["content"].strip()
+ else:
+ description = str(result.get("text", result.get("content", "")))
+
+ except httpx.HTTPStatusError as e:
+ # 如果 vision 端点不可用，提示用户
+ raise ValueError(
+ f"DeepSeek Vision API 暂不可用 (HTTP {e.response.status_code})。"
+ "建议：1) 在食物描述框中手动输入食物名称，系统会自动估算卡路里；"
+ "2) 或配置 Claude API 使用更强的视觉识别能力。"
+ ) from e
+
+ # 使用卡路里计算模块估算营养成分
+ nutrition = estimate_meal_calories(description)
+ nutrition["description"] = description
+ nutrition["provider"] = "deepseek"
+
+ return nutrition
+
+ def analyze_text(self, text_description: str) -> dict:
+ """
+ 分析文字描述的食物
+
+ 输入: "今天吃了一碗米饭、两个鸡蛋还有一杯牛奶"
+ 返回: 结构化的食物列表和营养估算
+ """
+ if not self.api_key:
+ raise ValueError("需要设置 DEEPSEEK_API_KEY 环境变量")
+
+ headers = {
+ "Authorization": f"Bearer {self.api_key}",
+ "Content-Type": "application/json",
+ }
+
+ payload = {
+ "model": "deepseek-chat",
+ "messages": [
+ {
+ "role": "system",
+ "content": """你是专业的营养分析助手。用户会告诉你吃了什么，你需要：
+1. 识别所有食物
+2. 标准化食物名称（如"面"→"面条"，"肉"→"猪肉"）
+3. 提取数量（如"两个"、"一碗"、"100g"）
+4. 按照 "食物1+食物2+食物3" 格式返回
+
+示例：
+用户输入："今天吃了一碗米饭、两个鸡蛋还有一杯牛奶"
+你返回："一碗米饭+两个鸡蛋+一杯牛奶"
+
+只返回标准化后的食物列表，不需要其他解释。"""
+ },
+ {
+ "role": "user",
+ "content": text_description
+ }
+ ],
+ "temperature": 0.3,
+ }
+
+ with httpx.Client(timeout=30.0) as client:
+ response = client.post(
+ f"{self.base_url}/chat/completions",
+ headers=headers,
+ json=payload,
+ )
+ response.raise_for_status()
+ result = response.json()
+
+ # 解析响应
+ standardized = result["choices"][0]["message"]["content"].strip()
+
+ # 使用卡路里计算模块估算营养成分
+ nutrition = estimate_meal_calories(standardized)
+ nutrition["description"] = standardized
+ nutrition["provider"] = "deepseek"
+ nutrition["original_input"] = text_description
+
+ return nutrition
+
+ def _encode_image(self, image_path: Path) -> str:
+ """将图片编码为 base64"""
+ with open(image_path, "rb") as f:
+ return base64.standard_b64encode(f.read()).decode("utf-8")
+
+ def _get_media_type(self, image_path: Path) -> str:
+ """获取图片的 MIME 类型"""
+ suffix = image_path.suffix.lower()
+ media_types = {
+ ".jpg": "image/jpeg",
+ ".jpeg": "image/jpeg",
+ ".png": "image/png",
+ ".gif": "image/gif",
+ ".webp": "image/webp",
+ }
+ return media_types.get(suffix, "image/jpeg")
+
+
+def get_deepseek_analyzer(api_key: Optional[str] = None) -> DeepSeekVisionAnalyzer:
+ """获取 DeepSeek 分析器"""
+ return DeepSeekVisionAnalyzer(api_key)
diff --git a/src/vitals/vision/providers/qwen.py b/src/vitals/vision/providers/qwen.py
new file mode 100644
index 0000000..0813771
--- /dev/null
+++ b/src/vitals/vision/providers/qwen.py
@@ -0,0 +1,172 @@
+"""Qwen VL (通义千问视觉) API 适配器"""
+
+import base64
+import os
+from pathlib import Path
+from typing import Optional
+
+import httpx
+
+from ...core.calories import estimate_meal_calories
+
+
+class QwenVisionAnalyzer:
+ """Qwen VL 食物识别分析器"""
+
+ def __init__(self, api_key: Optional[str] = None):
+ self.api_key = api_key or os.environ.get("DASHSCOPE_API_KEY")
+ # 阿里云百炼 OpenAI 兼容接口
+ self.base_url = "https://dashscope.aliyuncs.com/compatible-mode/v1"
+
+ def analyze_image(self, image_path: Path) -> dict:
+ """
+ 分析食物图片
+
+ 返回:
+ {
+ "description": "米饭、红烧排骨、西兰花",
+ "total_calories": 680,
+ "items": [...]
+ }
+ """
+ if not self.api_key:
+ raise ValueError("需要设置 DASHSCOPE_API_KEY 环境变量（阿里云百炼 API Key）")
+
+ # 读取并编码图片
+ image_data = self._encode_image(image_path)
+ media_type = self._get_media_type(image_path)
+
+ # 调用 Qwen VL API (OpenAI 兼容格式)
+ headers = {
+ "Authorization": f"Bearer {self.api_key}",
+ "Content-Type": "application/json",
+ }
+
+ payload = {
+ "model": "qwen-vl-max-latest",
+ "messages": [
+ {
+ "role": "user",
+ "content": [
+ {
+ "type": "image_url",
+ "image_url": {
+ "url": f"data:{media_type};base64,{image_data}"
+ }
+ },
+ {
+ "type": "text",
+ "text": """请分析这张食物图片，识别出所有食物。
+
+要求：
+1. 列出所有可识别的食物，用中文名称
+2. 估计每种食物的大致份量（如：一碗米饭、100g红烧肉）
+3. 按照 "食物1+食物2+食物3" 的格式返回
+
+例如返回格式：一碗米饭+红烧排骨+西兰花
+
+只返回食物列表，不需要其他解释。"""
+ }
+ ]
+ }
+ ],
+ "temperature": 0.3,
+ }
+
+ with httpx.Client(timeout=60.0) as client:
+ response = client.post(
+ f"{self.base_url}/chat/completions",
+ headers=headers,
+ json=payload,
+ )
+ response.raise_for_status()
+ result = response.json()
+
+ # 解析响应
+ description = result["choices"][0]["message"]["content"].strip()
+
+ # 使用卡路里计算模块估算营养成分
+ nutrition = estimate_meal_calories(description)
+ nutrition["description"] = description
+ nutrition["provider"] = "qwen"
+
+ return nutrition
+
+ def analyze_text(self, text_description: str) -> dict:
+ """
+ 分析文字描述的食物
+ """
+ if not self.api_key:
+ raise ValueError("需要设置 DASHSCOPE_API_KEY 环境变量")
+
+ headers = {
+ "Authorization": f"Bearer {self.api_key}",
+ "Content-Type": "application/json",
+ }
+
+ payload = {
+ "model": "qwen-vl-max-latest",
+ "messages": [
+ {
+ "role": "system",
+ "content": """你是专业的营养分析助手。用户会告诉你吃了什么，你需要：
+1. 识别所有食物
+2. 标准化食物名称（如"面"→"面条"，"肉"→"猪肉"）
+3. 提取数量（如"两个"、"一碗"、"100g"）
+4. 按照 "食物1+食物2+食物3" 格式返回
+
+示例：
+用户输入："今天吃了一碗米饭、两个鸡蛋还有一杯牛奶"
+你返回："一碗米饭+两个鸡蛋+一杯牛奶"
+
+只返回标准化后的食物列表，不需要其他解释。"""
+ },
+ {
+ "role": "user",
+ "content": text_description
+ }
+ ],
+ "temperature": 0.3,
+ }
+
+ with httpx.Client(timeout=30.0) as client:
+ response = client.post(
+ f"{self.base_url}/chat/completions",
+ headers=headers,
+ json=payload,
+ )
+ response.raise_for_status()
+ result = response.json()
+
+ # 解析响应
+ standardized = result["choices"][0]["message"]["content"].strip()
+
+ # 使用卡路里计算模块估算营养成分
+ nutrition = estimate_meal_calories(standardized)
+ nutrition["description"] = standardized
+ nutrition["provider"] = "qwen"
+ nutrition["original_input"] = text_description
+
+ return nutrition
+
+ def _encode_image(self, image_path: Path) -> str:
+ """将图片编码为 base64"""
+ with open(image_path, "rb") as f:
+ return base64.standard_b64encode(f.read()).decode("utf-8")
+
+ def _get_media_type(self, image_path: Path) -> str:
+ """获取图片的 MIME 类型"""
+ suffix = image_path.suffix.lower()
+ media_types = {
+ ".jpg": "image/jpeg",
+ ".jpeg": "image/jpeg",
+ ".png": "image/png",
+ ".gif": "image/gif",
+ ".webp": "image/webp",
+ }
+ return media_types.get(suffix, "image/jpeg")
+
+
+def get_qwen_analyzer(api_key: Optional[str] = None) -> QwenVisionAnalyzer:
+ """获取 Qwen VL 分析器"""
+ return QwenVisionAnalyzer(api_key)
diff --git a/src/vitals/web/__init__.py b/src/vitals/web/__init__.py
new file mode 100644
index 0000000..fec42ec
--- /dev/null
+++ b/src/vitals/web/__init__.py
@@ -0,0 +1,5 @@
+"""Web 仪表盘模块"""
+
+from .app import app, run_server
+
+__all__ = ["app", "run_server"]
diff --git a/src/vitals/web/__pycache__/__init__.cpython-313.pyc b/src/vitals/web/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000..e569547
Binary files /dev/null and b/src/vitals/web/__pycache__/__init__.cpython-313.pyc differ
diff --git a/src/vitals/web/__pycache__/app.cpython-313.pyc b/src/vitals/web/__pycache__/app.cpython-313.pyc
new file mode 100644
index 0000000..f483c3d
Binary files /dev/null and b/src/vitals/web/__pycache__/app.cpython-313.pyc differ
diff --git a/src/vitals/web/app.py b/src/vitals/web/app.py
new file mode 100644
index 0000000..ba50ede
--- /dev/null
+++ b/src/vitals/web/app.py
@@ -0,0 +1,7184 @@
+"""FastAPI Web 仪表盘"""
+
+import os
+from datetime import date, datetime, time, timedelta
+from pathlib import Path
+from typing import Optional
+
+from fastapi import Depends, FastAPI, File, Form, Header, HTTPException, Query, Request, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, HTMLResponse, RedirectResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel, field_validator
+from uuid import uuid4
+
+from ..core import database as db
+from ..core.models import Exercise, Meal, Sleep, UserConfig, Weight, User, Reading, Invite
+from ..core.auth import hash_password, verify_password, create_token, decode_token, generate_invite_code
+
+# 初始化数据库
+db.init_db()
+db.migrate_auth_fields() # 迁移认证字段
+
+
+def ensure_admin_user():
+ """确保管理员账户存在（从环境变量创建）"""
+ admin_username = os.environ.get("ADMIN_USERNAME")
+ admin_password = os.environ.get("ADMIN_PASSWORD")
+
+ if not admin_username or not admin_password:
+ return # 未配置环境变量，跳过
+
+ # 检查是否已存在该用户名
+ existing = db.get_user_by_name(admin_username)
+ if existing:
+ # 用户已存在，确保是管理员
+ if not existing.is_admin:
+ existing.is_admin = True
+ db.update_user(existing)
+ return
+
+ # 创建管理员账户
+ admin_user = User(
+ name=admin_username,
+ password_hash=hash_password(admin_password),
+ is_admin=True,
+ is_active=True,
+ is_disabled=False,
+ )
+ db.add_user(admin_user)
+ print(f"[Vitals] 管理员账户 '{admin_username}' 已创建")
+
+
+# 启动时创建管理员账户
+ensure_admin_user()
+
+
+app = FastAPI(
+ title="Vitals 健康管理",
+ description="本地优先的综合健康管理应用",
+ version="0.1.0",
+)
+
+# CORS 配置
+app.add_middleware(
+ CORSMiddleware,
+ allow_origins=["*"],
+ allow_credentials=True,
+ allow_methods=["*"],
+ allow_headers=["*"],
+)
+
+# 静态文件
+static_dir = Path(__file__).parent / "static"
+if static_dir.exists():
+ app.mount("/static", StaticFiles(directory=static_dir), name="static")
+
+# 食物照片静态文件
+photos_dir = Path.home() / ".vitals" / "photos"
+if photos_dir.exists():
+ app.mount("/photos", StaticFiles(directory=photos_dir), name="photos")
+
+
+# ===== Pydantic 模型 =====
+
+
+class ExerciseResponse(BaseModel):
+ id: Optional[int]
+ date: str
+ type: str
+ duration: int
+ calories: int
+ distance: Optional[float]
+ heart_rate_avg: Optional[int]
+ source: str
+ notes: Optional[str]
+
+
+class MealResponse(BaseModel):
+ id: Optional[int]
+ date: str
+ meal_type: str
+ description: str
+ calories: int
+ protein: Optional[float]
+ carbs: Optional[float]
+ fat: Optional[float]
+ photo_path: Optional[str]
+
+
+class SleepResponse(BaseModel):
+ id: Optional[int]
+ date: str
+ bedtime: Optional[str]
+ wake_time: Optional[str]
+ duration: float
+ quality: int
+ deep_sleep_mins: Optional[int]
+ source: str
+ notes: Optional[str]
+
+
+class WeightResponse(BaseModel):
+ id: Optional[int]
+ date: str
+ weight_kg: float
+ body_fat_pct: Optional[float]
+ muscle_mass: Optional[float]
+ notes: Optional[str]
+
+
+class ConfigResponse(BaseModel):
+ age: Optional[int]
+ gender: Optional[str]
+ height: Optional[float]
+ weight: Optional[float]
+ activity_level: str
+ goal: str
+ bmr: Optional[int]
+ tdee: Optional[int]
+
+
+class TodaySummary(BaseModel):
+ date: str
+ calories_intake: int
+ calories_burned: int
+ calories_balance: int
+ exercise_count: int
+ exercise_duration: int
+ sleep_duration: Optional[float]
+ sleep_quality: Optional[int]
+ weight: Optional[float]
+ tdee: Optional[int]
+ meals: list[MealResponse]
+ exercises: list[ExerciseResponse]
+
+
+class WeekSummary(BaseModel):
+ start_date: str
+ end_date: str
+ total_exercise_count: int
+ total_exercise_duration: int
+ total_calories_burned: int
+ avg_calories_intake: int
+ avg_sleep_duration: float
+ avg_sleep_quality: float
+ weight_start: Optional[float]
+ weight_end: Optional[float]
+ weight_change: Optional[float]
+ daily_stats: list[dict]
+
+
+# ===== Web 数据录入模型 =====
+
+class ExerciseInput(BaseModel):
+ date: str
+ type: str
+ duration: int
+ calories: Optional[int] = None
+ distance: Optional[float] = None
+ heart_rate_avg: Optional[int] = None
+ notes: Optional[str] = None
+
+ @field_validator("duration")
+ @classmethod
+ def validate_duration(cls, value: int) -> int:
+ if value <= 0 or value > 1440:
+ raise ValueError("时长必须在 1-1440 分钟之间")
+ return value
+
+
+class SleepInput(BaseModel):
+ date: str
+ bedtime: Optional[str] = None
+ wake_time: Optional[str] = None
+ duration: float
+ quality: int
+ notes: Optional[str] = None
+
+ @field_validator("quality")
+ @classmethod
+ def validate_quality(cls, value: int) -> int:
+ if value < 1 or value > 5:
+ raise ValueError("质量评分必须在 1-5 之间")
+ return value
+
+ @field_validator("duration")
+ @classmethod
+ def validate_sleep_duration(cls, value: float) -> float:
+ if value <= 0 or value > 24:
+ raise ValueError("睡眠时长必须在 0-24 小时之间")
+ return value
+
+
+class WeightInput(BaseModel):
+ date: str
+ weight_kg: float
+ body_fat_pct: Optional[float] = None
+ muscle_mass: Optional[float] = None
+ notes: Optional[str] = None
+
+ @field_validator("weight_kg")
+ @classmethod
+ def validate_weight(cls, value: float) -> float:
+ if value < 20 or value > 300:
+ raise ValueError("体重必须在 20-300 kg 之间")
+ return value
+
+
+class UserResponse(BaseModel):
+ id: int
+ name: str
+ created_at: str
+ is_active: bool
+ gender: Optional[str] = None
+ height_cm: Optional[float] = None
+ weight_kg: Optional[float] = None
+ age: Optional[int] = None
+ bmi: Optional[float] = None
+ bmi_status: Optional[str] = None
+
+
+class UserInput(BaseModel):
+ name: str
+ gender: Optional[str] = None
+ height_cm: Optional[float] = None
+ weight_kg: Optional[float] = None
+ age: Optional[int] = None
+
+ @field_validator("name")
+ @classmethod
+ def validate_name(cls, value: str) -> str:
+ if not value or len(value.strip()) == 0:
+ raise ValueError("用户名不能为空")
+ if len(value) > 50:
+ raise ValueError("用户名不能超过 50 个字符")
+ return value.strip()
+
+ @field_validator("gender")
+ @classmethod
+ def validate_gender(cls, value: Optional[str]) -> Optional[str]:
+ if value is not None and value not in ["male", "female"]:
+ raise ValueError("性别必须是 'male' 或 'female'")
+ return value
+
+ @field_validator("height_cm")
+ @classmethod
+ def validate_height(cls, value: Optional[float]) -> Optional[float]:
+ if value is not None and (value < 50 or value > 300):
+ raise ValueError("身高必须在 50-300 cm 之间")
+ return value
+
+ @field_validator("weight_kg")
+ @classmethod
+ def validate_weight(cls, value: Optional[float]) -> Optional[float]:
+ if value is not None and (value < 20 or value > 500):
+ raise ValueError("体重必须在 20-500 kg 之间")
+ return value
+
+ @field_validator("age")
+ @classmethod
+ def validate_age(cls, value: Optional[int]) -> Optional[int]:
+ if value is not None and (value < 1 or value > 150):
+ raise ValueError("年龄必须在 1-150 之间")
+ return value
+
+
+class DataClearInput(BaseModel):
+ user_id: int
+ mode: str # "all" | "range" | "type"
+ date_from: Optional[str] = None
+ date_to: Optional[str] = None
+ data_types: Optional[list[str]] = None
+
+ @field_validator("mode")
+ @classmethod
+ def validate_mode(cls, value: str) -> str:
+ if value not in ["all", "range", "type"]:
+ raise ValueError("mode 必须是 'all', 'range' 或 'type'")
+ return value
+
+
+class ReadingInput(BaseModel):
+ title: str
+ author: Optional[str] = None
+ cover_url: Optional[str] = None
+ duration: int
+ mood: Optional[str] = None
+ notes: Optional[str] = None
+ date: Optional[str] = None
+
+ @field_validator("title")
+ @classmethod
+ def validate_title(cls, value: str) -> str:
+ if not value or len(value.strip()) == 0:
+ raise ValueError("书名不能为空")
+ return value.strip()
+
+ @field_validator("duration")
+ @classmethod
+ def validate_duration(cls, value: int) -> int:
+ if value < 1 or value > 1440:
+ raise ValueError("阅读时长必须在 1-1440 分钟之间")
+ return value
+
+ @field_validator("mood")
+ @classmethod
+ def validate_mood(cls, value: Optional[str]) -> Optional[str]:
+ valid_moods = ["😄", "😊", "😐", "😔", "😢"]
+ if value and value not in valid_moods:
+ raise ValueError("心情必须是 😄😊😐😔😢 之一")
+ return value
+
+
+class ReadingResponse(BaseModel):
+ id: int
+ user_id: int
+ date: str
+ title: str
+ author: Optional[str]
+ cover_url: Optional[str]
+ duration: int
+ mood: Optional[str]
+ notes: Optional[str]
+
+
+# ===== 认证相关模型 =====
+
+class LoginInput(BaseModel):
+ username: str
+ password: str
+
+
+class RegisterInput(BaseModel):
+ username: str
+ password: str
+ invite_code: str
+
+ @field_validator("username")
+ @classmethod
+ def validate_username(cls, value: str) -> str:
+ if not value or len(value.strip()) == 0:
+ raise ValueError("用户名不能为空")
+ if len(value) > 50:
+ raise ValueError("用户名不能超过 50 个字符")
+ return value.strip()
+
+ @field_validator("password")
+ @classmethod
+ def validate_password(cls, value: str) -> str:
+ if len(value) < 6:
+ raise ValueError("密码长度至少 6 位")
+ return value
+
+
+class TokenResponse(BaseModel):
+ token: str
+ user: "AuthUserResponse"
+
+
+class AuthUserResponse(BaseModel):
+ id: int
+ name: str
+ is_admin: bool
+ is_disabled: bool
+
+
+class InviteResponse(BaseModel):
+ id: int
+ code: str
+ created_by: int
+ used_by: Optional[int]
+ created_at: str
+ expires_at: Optional[str]
+ is_used: bool
+ is_expired: bool
+
+
+class InviteInput(BaseModel):
+ expires_days: Optional[int] = None # 可选的过期天数
+
+
+# ===== 认证辅助函数 =====
+
+# 不需要认证的路径
+PUBLIC_PATHS = {
+ "/api/auth/login",
+ "/api/auth/register",
+ "/login",
+ "/register",
+ "/static",
+ "/photos",
+ "/docs",
+ "/openapi.json",
+}
+
+
+def get_token_from_header(authorization: Optional[str] = Header(None)) -> Optional[str]:
+ """从 Header 提取 Token"""
+ if not authorization:
+ return None
+ if authorization.startswith("Bearer "):
+ return authorization[7:]
+ return None
+
+
+def get_current_user(authorization: Optional[str] = Header(None)) -> Optional[User]:
+ """获取当前登录用户（可选，返回 None 表示未登录）"""
+ token = get_token_from_header(authorization)
+ if not token:
+ return None
+ payload = decode_token(token)
+ if not payload:
+ return None
+ user = db.get_user(payload["user_id"])
+ if not user or user.is_disabled:
+ return None
+ return user
+
+
+def require_user(authorization: Optional[str] = Header(None)) -> User:
+ """要求用户登录（必须认证）"""
+ user = get_current_user(authorization)
+ if not user:
+ raise HTTPException(status_code=401, detail="未登录或登录已过期")
+ return user
+
+
+def require_admin(authorization: Optional[str] = Header(None)) -> User:
+ """要求管理员权限"""
+ user = require_user(authorization)
+ if not user.is_admin:
+ raise HTTPException(status_code=403, detail="需要管理员权限")
+ return user
+
+
+def get_current_user_id(authorization: Optional[str] = Header(None)) -> int:
+ """获取当前用户 ID（兼容模式：未登录时使用活跃用户）"""
+ user = get_current_user(authorization)
+ if user:
+ return user.id
+ # 兼容模式：未登录时使用当前活跃用户
+ db.ensure_default_user()
+ active_user = db.get_active_user()
+ return active_user.id if active_user else 1
+
+
+# ===== API 路由 =====
+
+
+# ===== 认证 API =====
+
+@app.post("/api/auth/login", response_model=TokenResponse)
+async def login(data: LoginInput):
+ """用户登录"""
+ user = db.get_user_by_name(data.username)
+ if not user:
+ raise HTTPException(status_code=401, detail="用户名或密码错误")
+ if not user.password_hash:
+ raise HTTPException(status_code=401, detail="用户未设置密码，请联系管理员")
+ if not verify_password(data.password, user.password_hash):
+ raise HTTPException(status_code=401, detail="用户名或密码错误")
+ if user.is_disabled:
+ raise HTTPException(status_code=403, detail="账户已被禁用")
+
+ token = create_token(user.id, user.name, user.is_admin)
+ return TokenResponse(
+ token=token,
+ user=AuthUserResponse(
+ id=user.id,
+ name=user.name,
+ is_admin=user.is_admin,
+ is_disabled=user.is_disabled,
+ )
+ )
+
+
+@app.post("/api/auth/register", response_model=TokenResponse)
+async def register(data: RegisterInput):
+ """用户注册（需要邀请码）"""
+ # 验证邀请码
+ invite = db.get_invite_by_code(data.invite_code)
+ if not invite:
+ raise HTTPException(status_code=400, detail="邀请码无效")
+ if invite.is_used:
+ raise HTTPException(status_code=400, detail="邀请码已被使用")
+ if invite.is_expired:
+ raise HTTPException(status_code=400, detail="邀请码已过期")
+
+ # 检查用户名是否已存在
+ existing = db.get_user_by_name(data.username)
+ if existing:
+ raise HTTPException(status_code=400, detail="用户名已存在")
+
+ # 创建用户
+ password_hash = hash_password(data.password)
+ new_user = User(
+ name=data.username,
+ password_hash=password_hash,
+ is_active=False,
+ is_admin=False,
+ is_disabled=False,
+ )
+ user_id = db.add_user(new_user)
+
+ # 标记邀请码已使用
+ db.mark_invite_used(invite.id, user_id)
+
+ # 获取创建的用户
+ user = db.get_user(user_id)
+
+ # 生成 token
+ token = create_token(user.id, user.name, user.is_admin)
+ return TokenResponse(
+ token=token,
+ user=AuthUserResponse(
+ id=user.id,
+ name=user.name,
+ is_admin=user.is_admin,
+ is_disabled=user.is_disabled,
+ )
+ )
+
+
+@app.get("/api/auth/me", response_model=AuthUserResponse)
+async def get_me(user: User = Depends(require_user)):
+ """获取当前登录用户信息"""
+ return AuthUserResponse(
+ id=user.id,
+ name=user.name,
+ is_admin=user.is_admin,
+ is_disabled=user.is_disabled,
+ )
+
+
+# ===== 管理员 API =====
+
+@app.get("/api/admin/users")
+async def admin_get_users(admin: User = Depends(require_admin)):
+ """获取所有用户（管理员）"""
+ users = db.get_users()
+ return [
+ {
+ "id": u.id,
+ "name": u.name,
+ "email": u.email,
+ "is_admin": u.is_admin,
+ "is_disabled": u.is_disabled,
+ "created_at": u.created_at.isoformat(),
+ }
+ for u in users
+ ]
+
+
+@app.post("/api/admin/users/{user_id}/disable")
+async def admin_disable_user(user_id: int, admin: User = Depends(require_admin)):
+ """禁用用户（管理员）"""
+ if user_id == admin.id:
+ raise HTTPException(status_code=400, detail="不能禁用自己")
+ user = db.get_user(user_id)
+ if not user:
+ raise HTTPException(status_code=404, detail="用户不存在")
+ user.is_disabled = True
+ db.update_user(user)
+ return {"message": "用户已禁用"}
+
+
+@app.post("/api/admin/users/{user_id}/enable")
+async def admin_enable_user(user_id: int, admin: User = Depends(require_admin)):
+ """启用用户（管理员）"""
+ user = db.get_user(user_id)
+ if not user:
+ raise HTTPException(status_code=404, detail="用户不存在")
+ user.is_disabled = False
+ db.update_user(user)
+ return {"message": "用户已启用"}
+
+
+@app.delete("/api/admin/users/{user_id}")
+async def admin_delete_user(user_id: int, admin: User = Depends(require_admin)):
+ """删除用户（管理员）"""
+ if user_id == admin.id:
+ raise HTTPException(status_code=400, detail="不能删除自己")
+ user = db.get_user(user_id)
+ if not user:
+ raise HTTPException(status_code=404, detail="用户不存在")
+ # 删除用户数据
+ db.clear_data(user_id, mode="all")
+ # 删除用户
+ db.delete_user(user_id)
+ return {"message": "用户已删除"}
+
+
+@app.get("/api/admin/invites", response_model=list[InviteResponse])
+async def admin_get_invites(admin: User = Depends(require_admin)):
+ """获取邀请码列表（管理员）"""
+ invites = db.get_invites()
+ return [
+ InviteResponse(
+ id=inv.id,
+ code=inv.code,
+ created_by=inv.created_by,
+ used_by=inv.used_by,
+ created_at=inv.created_at.isoformat(),
+ expires_at=inv.expires_at.isoformat() if inv.expires_at else None,
+ is_used=inv.is_used,
+ is_expired=inv.is_expired,
+ )
+ for inv in invites
+ ]
+
+
+@app.post("/api/admin/invites", response_model=InviteResponse)
+async def admin_create_invite(data: InviteInput, admin: User = Depends(require_admin)):
+ """生成邀请码（管理员）"""
+ code = generate_invite_code()
+ expires_at = None
+ if data.expires_days:
+ expires_at = datetime.now() + timedelta(days=data.expires_days)
+
+ invite = Invite(
+ code=code,
+ created_by=admin.id,
+ expires_at=expires_at,
+ )
+ invite_id = db.add_invite(invite)
+ created_invite = db.get_invite_by_code(code)
+
+ return InviteResponse(
+ id=created_invite.id,
+ code=created_invite.code,
+ created_by=created_invite.created_by,
+ used_by=created_invite.used_by,
+ created_at=created_invite.created_at.isoformat(),
+ expires_at=created_invite.expires_at.isoformat() if created_invite.expires_at else None,
+ is_used=created_invite.is_used,
+ is_expired=created_invite.is_expired,
+ )
+
+
+@app.delete("/api/admin/invites/{invite_id}")
+async def admin_delete_invite(invite_id: int, admin: User = Depends(require_admin)):
+ """删除邀请码（管理员）"""
+ db.delete_invite(invite_id)
+ return {"message": "邀请码已删除"}
+
+
+# ===== 页面路由 =====
+
+
+@app.get("/login")
+async def login_page():
+ """登录页面"""
+ return HTMLResponse(content=get_login_page_html(), status_code=200)
+
+
+@app.get("/register")
+async def register_page():
+ """注册页面"""
+ return HTMLResponse(content=get_register_page_html(), status_code=200)
+
+
+@app.get("/admin")
+async def admin_page():
+ """管理后台页面"""
+ return HTMLResponse(content=get_admin_page_html(), status_code=200)
+
+
+@app.get("/")
+async def root():
+ """首页"""
+ return HTMLResponse(content=get_dashboard_html(), status_code=200)
+
+
+@app.get("/exercise")
+async def exercise_page():
+ """运动页面"""
+ return HTMLResponse(content=get_exercise_page_html(), status_code=200)
+
+
+@app.get("/meal")
+async def meal_page():
+ """饮食页面"""
+ return HTMLResponse(content=get_meal_page_html(), status_code=200)
+
+
+@app.get("/report")
+async def report_page():
+ """报告页面"""
+ return HTMLResponse(content=get_report_page_html(), status_code=200)
+
+
+@app.get("/api/report/week")
+async def download_week_report(format: str = Query(default="pdf")):
+ """生成并下载周报"""
+ from ..core.report import export_report, generate_weekly_report
+
+ report = generate_weekly_report()
+ return _export_report_file(report, format, "weekly", export_report)
+
+
+@app.get("/api/report/month")
+async def download_month_report(
+ year: Optional[int] = Query(default=None),
+ month: Optional[int] = Query(default=None),
+ format: str = Query(default="pdf"),
+):
+ """生成并下载月报"""
+ from ..core.report import export_report, generate_monthly_report
+
+ report = generate_monthly_report(year, month)
+ return _export_report_file(report, format, "monthly", export_report)
+
+
+@app.get("/sleep")
+async def sleep_page():
+ """睡眠页面"""
+ return HTMLResponse(content=get_sleep_page_html(), status_code=200)
+
+
+@app.get("/weight")
+async def weight_page():
+ """体重页面"""
+ return HTMLResponse(content=get_weight_page_html(), status_code=200)
+
+
+@app.get("/settings")
+async def settings_page():
+ """设置页面"""
+ return HTMLResponse(content=get_settings_page_html(), status_code=200)
+
+
+@app.get("/api/config", response_model=ConfigResponse)
+async def get_config():
+ """获取用户配置"""
+ config = db.get_config()
+ return ConfigResponse(
+ age=config.age,
+ gender=config.gender,
+ height=config.height,
+ weight=config.weight,
+ activity_level=config.activity_level,
+ goal=config.goal,
+ bmr=config.bmr,
+ tdee=config.tdee,
+ )
+
+
+@app.get("/api/today", response_model=TodaySummary)
+async def get_today_summary():
+ """获取今日概览"""
+ # 获取激活用户
+ active_user = db.get_active_user()
+ if not active_user:
+ raise HTTPException(status_code=400, detail="没有激活的用户")
+
+ today = date.today()
+ config = db.get_config()
+
+ # 获取今日数据
+ exercises = db.get_exercises(start_date=today, end_date=today, user_id=active_user.id)
+ meals = db.get_meals(start_date=today, end_date=today, user_id=active_user.id)
+ sleep_records = db.get_sleep_records(start_date=today, end_date=today, user_id=active_user.id)
+ weight_records = db.get_weight_records(start_date=today, end_date=today, user_id=active_user.id)
+
+ # 计算卡路里
+ calories_intake = sum(m.calories for m in meals)
+ calories_burned = sum(e.calories for e in exercises)
+
+ # 基础代谢 + 运动消耗
+ tdee = config.tdee or 0
+ total_burned = tdee + calories_burned
+ calories_balance = calories_intake - total_burned
+
+ # 睡眠数据
+ sleep = sleep_records[0] if sleep_records else None
+
+ # 最新体重
+ latest_weight = db.get_latest_weight()
+
+ return TodaySummary(
+ date=today.isoformat(),
+ calories_intake=calories_intake,
+ calories_burned=calories_burned,
+ calories_balance=calories_balance,
+ exercise_count=len(exercises),
+ exercise_duration=sum(e.duration for e in exercises),
+ sleep_duration=sleep.duration if sleep else None,
+ sleep_quality=sleep.quality if sleep else None,
+ weight=latest_weight.weight_kg if latest_weight else None,
+ tdee=config.tdee,
+ meals=[
+ MealResponse(
+ id=m.id,
+ date=m.date.isoformat(),
+ meal_type=m.meal_type,
+ description=m.description,
+ calories=m.calories,
+ protein=m.protein,
+ carbs=m.carbs,
+ fat=m.fat,
+ photo_path=m.photo_path,
+ )
+ for m in meals
+ ],
+ exercises=[
+ ExerciseResponse(
+ id=e.id,
+ date=e.date.isoformat(),
+ type=e.type,
+ duration=e.duration,
+ calories=e.calories,
+ distance=e.distance,
+ heart_rate_avg=e.heart_rate_avg,
+ source=e.source,
+ notes=e.notes,
+ )
+ for e in exercises
+ ],
+ )
+
+
+@app.get("/api/week", response_model=WeekSummary)
+async def get_week_summary():
+ """获取本周汇总"""
+ # 获取激活用户
+ active_user = db.get_active_user()
+ if not active_user:
+ raise HTTPException(status_code=400, detail="没有激活的用户")
+
+ today = date.today()
+ start_of_week = today - timedelta(days=today.weekday())
+ end_of_week = start_of_week + timedelta(days=6)
+
+ # 获取本周数据
+ exercises = db.get_exercises(start_date=start_of_week, end_date=end_of_week, user_id=active_user.id)
+ meals = db.get_meals(start_date=start_of_week, end_date=end_of_week, user_id=active_user.id)
+ sleep_records = db.get_sleep_records(start_date=start_of_week, end_date=end_of_week, user_id=active_user.id)
+ weight_records = db.get_weight_records(start_date=start_of_week, end_date=end_of_week, user_id=active_user.id)
+
+ # 计算统计数据
+ total_exercise_duration = sum(e.duration for e in exercises)
+ total_calories_burned = sum(e.calories for e in exercises)
+ total_calories_intake = sum(m.calories for m in meals)
+
+ # 计算平均值
+ days_with_meals = len(set(m.date for m in meals)) or 1
+ avg_calories_intake = total_calories_intake // days_with_meals
+
+ avg_sleep_duration = (
+ sum(s.duration for s in sleep_records) / len(sleep_records)
+ if sleep_records
+ else 0
+ )
+ avg_sleep_quality = (
+ sum(s.quality for s in sleep_records) / len(sleep_records)
+ if sleep_records
+ else 0
+ )
+
+ # 体重变化
+ weight_records_sorted = sorted(weight_records, key=lambda w: w.date)
+ weight_start = weight_records_sorted[0].weight_kg if weight_records_sorted else None
+ weight_end = weight_records_sorted[-1].weight_kg if weight_records_sorted else None
+ weight_change = (
+ round(weight_end - weight_start, 2)
+ if weight_start and weight_end
+ else None
+ )
+
+ # 每日统计
+ daily_stats = []
+ for i in range(7):
+ day = start_of_week + timedelta(days=i)
+ day_exercises = [e for e in exercises if e.date == day]
+ day_meals = [m for m in meals if m.date == day]
+ day_sleep = next((s for s in sleep_records if s.date == day), None)
+
+ daily_stats.append({
+ "date": day.isoformat(),
+ "weekday": ["周一", "周二", "周三", "周四", "周五", "周六", "周日"][i],
+ "exercise_duration": sum(e.duration for e in day_exercises),
+ "calories_intake": sum(m.calories for m in day_meals),
+ "calories_burned": sum(e.calories for e in day_exercises),
+ "sleep_duration": day_sleep.duration if day_sleep else None,
+ })
+
+ return WeekSummary(
+ start_date=start_of_week.isoformat(),
+ end_date=end_of_week.isoformat(),
+ total_exercise_count=len(exercises),
+ total_exercise_duration=total_exercise_duration,
+ total_calories_burned=total_calories_burned,
+ avg_calories_intake=avg_calories_intake,
+ avg_sleep_duration=round(avg_sleep_duration, 1),
+ avg_sleep_quality=round(avg_sleep_quality, 1),
+ weight_start=weight_start,
+ weight_end=weight_end,
+ weight_change=weight_change,
+ daily_stats=daily_stats,
+ )
+
+
+@app.get("/api/exercises", response_model=list[ExerciseResponse])
+async def get_exercises(
+ days: int = Query(default=30, ge=1, le=365, description="查询天数"),
+):
+ """获取运动记录"""
+ # 获取激活用户
+ active_user = db.get_active_user()
+ if not active_user:
+ raise HTTPException(status_code=400, detail="没有激活的用户")
+
+ end_date = date.today()
+ start_date = end_date - timedelta(days=days)
+ exercises = db.get_exercises(start_date=start_date, end_date=end_date, user_id=active_user.id)
+
+ return [
+ ExerciseResponse(
+ id=e.id,
+ date=e.date.isoformat(),
+ type=e.type,
+ duration=e.duration,
+ calories=e.calories,
+ distance=e.distance,
+ heart_rate_avg=e.heart_rate_avg,
+ source=e.source,
+ notes=e.notes,
+ )
+ for e in exercises
+ ]
+
+
+@app.get("/api/exercises/stats")
+async def get_exercise_stats(
+ days: int = Query(default=30, ge=1, le=365, description="统计天数"),
+):
+ """获取运动统计数据"""
+ # 获取激活用户
+ active_user = db.get_active_user()
+ if not active_user:
+ raise HTTPException(status_code=400, detail="没有激活的用户")
+
+ today = date.today()
+ period_start = today - timedelta(days=days - 1)
+
+ month_start = date(today.year, today.month, 1)
+ month_exercises = db.get_exercises(start_date=month_start, end_date=today, user_id=active_user.id)
+
+ month_count = len(month_exercises)
+ month_duration = sum(e.duration for e in month_exercises)
+ month_calories = sum(e.calories for e in month_exercises)
+
+ month_type_counts: dict[str, int] = {}
+ for e in month_exercises:
+ month_type_counts[e.type] = month_type_counts.get(e.type, 0) + 1
+ top_type = max(month_type_counts, key=month_type_counts.get) if month_type_counts else None
+
+ period_exercises = db.get_exercises(start_date=period_start, end_date=today)
+ type_counts: dict[str, int] = {}
+ type_calories: dict[str, int] = {}
+ for e in period_exercises:
+ type_counts[e.type] = type_counts.get(e.type, 0) + 1
+ type_calories[e.type] = type_calories.get(e.type, 0) + e.calories
+
+ daily_stats = []
+ for i in range(days):
+ day = period_start + timedelta(days=i)
+ day_exercises = [e for e in period_exercises if e.date == day]
+ daily_stats.append({
+ "date": day.isoformat(),
+ "duration": sum(e.duration for e in day_exercises),
+ "calories": sum(e.calories for e in day_exercises),
+ })
+
+ return {
+ "month": {
+ "count": month_count,
+ "duration": month_duration,
+ "calories": month_calories,
+ "top_type": top_type,
+ },
+ "period": {
+ "days": days,
+ "type_counts": type_counts,
+ "type_calories": type_calories,
+ },
+ "daily_stats": daily_stats,
+ }
+
+
+@app.get("/api/meals", response_model=list[MealResponse])
+async def get_meals(
+ days: int = Query(default=30, ge=1, le=365, description="查询天数"),
+):
+ """获取饮食记录"""
+ # 获取激活用户
+ active_user = db.get_active_user()
+ if not active_user:
+ raise HTTPException(status_code=400, detail="没有激活的用户")
+
+ end_date = date.today()
+ start_date = end_date - timedelta(days=days)
+ meals = db.get_meals(start_date=start_date, end_date=end_date, user_id=active_user.id)
+
+ return [
+ MealResponse(
+ id=m.id,
+ date=m.date.isoformat(),
+ meal_type=m.meal_type,
+ description=m.description,
+ calories=m.calories,
+ protein=m.protein,
+ carbs=m.carbs,
+ fat=m.fat,
+ photo_path=m.photo_path,
+ )
+ for m in meals
+ ]
+
+
+@app.post("/api/exercise")
+async def add_exercise_api(data: ExerciseInput):
+ """添加运动记录"""
+ # 获取激活用户
+ active_user = db.get_active_user()
+ if not active_user:
+ raise HTTPException(status_code=400, detail="没有激活的用户")
+
+ try:
+ record_date = date.fromisoformat(data.date)
+ except ValueError as exc:
+ raise HTTPException(status_code=400, detail="日期格式应为 YYYY-MM-DD") from exc
+
+ from ..core.calories import estimate_exercise_calories
+ config = db.get_config()
+ weight_kg = config.weight or 70
+ calories = data.calories if data.calories is not None else estimate_exercise_calories(
+ data.type, data.duration, weight_kg
+ )
+
+ exercise = Exercise(
+ date=record_date,
+ type=data.type,
+ duration=data.duration,
+ calories=calories,
+ distance=data.distance,
+ heart_rate_avg=data.heart_rate_avg,
+ notes=data.notes,
+ source="web",
+ )
+ record_id = db.add_exercise(exercise, user_id=active_user.id)
+ return {"success": True, "id": record_id}
+
+
+@app.delete("/api/exercise/{exercise_id}")
+async def delete_exercise_api(exercise_id: int):
+ """删除运动记录"""
+ try:
+ db.delete_exercise(exercise_id)
+ return {"success": True}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/meal")
+async def add_meal_api(
+ date_str: str = Form(...),
+ meal_type: str = Form(...),
+ description: str = Form(""),
+ calories: Optional[str] = Form(None),
+ protein: Optional[str] = Form(None),
+ carbs: Optional[str] = Form(None),
+ fat: Optional[str] = Form(None),
+ photo: Optional[UploadFile] = File(None),
+):
+ """添加饮食记录（支持照片上传）"""
+ # 获取激活用户
+ active_user = db.get_active_user()
+ if not active_user:
+ raise HTTPException(status_code=400, detail="没有激活的用户")
+
+ def _parse_optional_int(value: Optional[str], field_name: str) -> Optional[int]:
+ if value is None:
+ return None
+ value = value.strip()
+ if value == "":
+ return None
+ try:
+ return int(value)
+ except ValueError as exc:
+ raise HTTPException(status_code=400, detail=f"{field_name} 必须是整数") from exc
+
+ def _parse_optional_float(value: Optional[str], field_name: str) -> Optional[float]:
+ if value is None:
+ return None
+ value = value.strip()
+ if value == "":
+ return None
+ try:
+ return float(value)
+ except ValueError as exc:
+ raise HTTPException(status_code=400, detail=f"{field_name} 必须是数字") from exc
+
+ try:
+ record_date = date.fromisoformat(date_str)
+ except ValueError as exc:
+ raise HTTPException(status_code=400, detail="日期格式应为 YYYY-MM-DD") from exc
+
+ photo_path = None
+ if photo:
+ photos_root = Path.home() / ".vitals" / "photos" / date_str[:7]
+ photos_root.mkdir(parents=True, exist_ok=True)
+ suffix = Path(photo.filename or "").suffix.lower() or ".jpg"
+ safe_type = meal_type.replace(" ", "_")
+ timestamp = datetime.now().strftime("%H%M%S")
+ file_path = photos_root / f"{date_str}_{safe_type}_{timestamp}{suffix}"
+ content = await photo.read()
+ if len(content) > 5 * 1024 * 1024:
+ raise HTTPException(status_code=400, detail="照片不能超过 5MB")
+ file_path.write_bytes(content)
+ photo_path = str(file_path)
+
+ calories_i = _parse_optional_int(calories, "卡路里")
+ protein_f = _parse_optional_float(protein, "蛋白质")
+ carbs_f = _parse_optional_float(carbs, "碳水")
+ fat_f = _parse_optional_float(fat, "脂肪")
+
+ if calories_i is None and description:
+ from ..core.calories import estimate_meal_calories
+ result = estimate_meal_calories(description)
+ calories_i = result["total_calories"]
+ protein_f = result["total_protein"]
+ carbs_f = result["total_carbs"]
+ fat_f = result["total_fat"]
+ else:
+ calories_i = calories_i or 0
+
+ meal = Meal(
+ date=record_date,
+ meal_type=meal_type,
+ description=description,
+ calories=calories_i,
+ protein=protein_f,
+ carbs=carbs_f,
+ fat=fat_f,
+ photo_path=photo_path,
+ food_items=None,
+ )
+ record_id = db.add_meal(meal, user_id=active_user.id)
+ return {"success": True, "id": record_id, "calories": calories_i}
+
+
+@app.delete("/api/meal/{meal_id}")
+async def delete_meal_api(meal_id: int):
+ """删除饮食记录"""
+ try:
+ db.delete_meal(meal_id)
+ return {"success": True}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/meal/recognize")
+async def recognize_food(
+ text: Optional[str] = Form(None),
+ image: Optional[UploadFile] = File(None),
+ provider: str = Form("qwen"),
+):
+ """
+ 智能食物识别
+
+ 支持两种输入方式:
+ - text: 文字描述，如 "今天吃了一碗米饭、两个鸡蛋"
+ - image: 食物图片
+
+ provider: "qwen" | "deepseek" | "claude" | "local"
+ """
+ if not text and not image:
+ raise HTTPException(status_code=400, detail="请提供文字描述或上传图片")
+
+ try:
+ if image:
+ # 图片识别
+ import tempfile
+ from ..vision.analyzer import get_analyzer
+
+ # 保存临时文件
+ suffix = Path(image.filename or "").suffix.lower() or ".jpg"
+ with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+ content = await image.read()
+ if len(content) > 10 * 1024 * 1024:
+ raise HTTPException(status_code=400, detail="图片不能超过 10MB")
+ tmp.write(content)
+ tmp_path = Path(tmp.name)
+
+ try:
+ analyzer = get_analyzer(provider=provider)
+ if hasattr(analyzer, "analyze_image"):
+ result = analyzer.analyze_image(tmp_path)
+ else:
+ result = analyzer.analyze(tmp_path)
+ finally:
+ tmp_path.unlink(missing_ok=True)
+
+ else:
+ # 文字识别
+ if provider == "qwen":
+ from ..vision.providers.qwen import get_qwen_analyzer
+ analyzer = get_qwen_analyzer()
+ result = analyzer.analyze_text(text)
+ elif provider == "deepseek":
+ from ..vision.providers.deepseek import get_deepseek_analyzer
+ analyzer = get_deepseek_analyzer()
+ result = analyzer.analyze_text(text)
+ else:
+ # Claude 和 local 只用本地估算
+ from ..core.calories import estimate_meal_calories
+ result = estimate_meal_calories(text)
+ result["description"] = text
+ result["provider"] = provider
+
+ return {
+ "success": True,
+ "description": result.get("description", ""),
+ "total_calories": result.get("total_calories", 0),
+ "total_protein": result.get("total_protein", 0),
+ "total_carbs": result.get("total_carbs", 0),
+ "total_fat": result.get("total_fat", 0),
+ "items": result.get("items", []),
+ "provider": result.get("provider", provider),
+ }
+
+ except ValueError as e:
+ raise HTTPException(status_code=400, detail=str(e)) from e
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"识别失败: {str(e)}") from e
+
+
+@app.post("/api/sleep")
+async def add_sleep_api(data: SleepInput):
+ """添加睡眠记录"""
+ # 获取激活用户
+ active_user = db.get_active_user()
+ if not active_user:
+ raise HTTPException(status_code=400, detail="没有激活的用户")
+
+ try:
+ record_date = date.fromisoformat(data.date)
+ except ValueError as exc:
+ raise HTTPException(status_code=400, detail="日期格式应为 YYYY-MM-DD") from exc
+
+ bedtime = time.fromisoformat(data.bedtime) if data.bedtime else None
+ wake_time = time.fromisoformat(data.wake_time) if data.wake_time else None
+
+ sleep = Sleep(
+ date=record_date,
+ bedtime=bedtime,
+ wake_time=wake_time,
+ duration=data.duration,
+ quality=data.quality,
+ notes=data.notes,
+ source="web",
+ )
+ record_id = db.add_sleep(sleep, user_id=active_user.id)
+ return {"success": True, "id": record_id}
+
+
+@app.delete("/api/sleep/{sleep_id}")
+async def delete_sleep_api(sleep_id: int):
+ """删除睡眠记录"""
+ try:
+ db.delete_sleep(sleep_id)
+ return {"success": True}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/weight")
+async def add_weight_api(data: WeightInput):
+ """添加体重记录"""
+ # 获取激活用户
+ active_user = db.get_active_user()
+ if not active_user:
+ raise HTTPException(status_code=400, detail="没有激活的用户")
+
+ try:
+ record_date = date.fromisoformat(data.date)
+ except ValueError as exc:
+ raise HTTPException(status_code=400, detail="日期格式应为 YYYY-MM-DD") from exc
+
+ weight = Weight(
+ date=record_date,
+ weight_kg=data.weight_kg,
+ body_fat_pct=data.body_fat_pct,
+ muscle_mass=data.muscle_mass,
+ notes=data.notes,
+ )
+ record_id = db.add_weight(weight, user_id=active_user.id)
+ return {"success": True, "id": record_id}
+
+
+@app.delete("/api/weight/{weight_id}")
+async def delete_weight_api(weight_id: int):
+ """删除体重记录"""
+ try:
+ db.delete_weight(weight_id)
+ return {"success": True}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/meals/nutrition")
+async def get_meal_nutrition_stats(
+ days: int = Query(default=30, ge=1, le=365, description="统计天数"),
+):
+ """获取饮食营养统计"""
+ # 获取激活用户
+ active_user = db.get_active_user()
+ if not active_user:
+ raise HTTPException(status_code=400, detail="没有激活的用户")
+
+ today = date.today()
+ start_date = today - timedelta(days=days - 1)
+ meals = db.get_meals(start_date=start_date, end_date=today, user_id=active_user.id)
+
+ total_calories = sum(m.calories for m in meals)
+ total_protein = sum(m.protein or 0 for m in meals)
+ total_carbs = sum(m.carbs or 0 for m in meals)
+ total_fat = sum(m.fat or 0 for m in meals)
+
+ meal_type_counts: dict[str, int] = {}
+ meal_type_calories: dict[str, int] = {}
+ for m in meals:
+ meal_type_counts[m.meal_type] = meal_type_counts.get(m.meal_type, 0) + 1
+ meal_type_calories[m.meal_type] = meal_type_calories.get(m.meal_type, 0) + m.calories
+
+ recent_days = 7 if days >= 7 else days
+ recent_start = today - timedelta(days=recent_days - 1)
+ daily_stats = []
+ for i in range(recent_days):
+ day = recent_start + timedelta(days=i)
+ day_meals = [m for m in meals if m.date == day]
+ daily_stats.append({
+ "date": day.isoformat(),
+ "calories": sum(m.calories for m in day_meals),
+ "protein": sum(m.protein or 0 for m in day_meals),
+ "carbs": sum(m.carbs or 0 for m in day_meals),
+ "fat": sum(m.fat or 0 for m in day_meals),
+ })
+
+ return {
+ "days": days,
+ "total_calories": total_calories,
+ "macros": {
+ "protein": round(total_protein, 1),
+ "carbs": round(total_carbs, 1),
+ "fat": round(total_fat, 1),
+ },
+ "meal_types": {
+ "counts": meal_type_counts,
+ "calories": meal_type_calories,
+ },
+ "daily_stats": daily_stats,
+ }
+
+
+@app.get("/api/sleep", response_model=list[SleepResponse])
+async def get_sleep_records(
+ days: int = Query(default=30, ge=1, le=365, description="查询天数"),
+):
+ """获取睡眠记录"""
+ # 获取激活用户
+ active_user = db.get_active_user()
+ if not active_user:
+ raise HTTPException(status_code=400, detail="没有激活的用户")
+
+ end_date = date.today()
+ start_date = end_date - timedelta(days=days)
+ records = db.get_sleep_records(start_date=start_date, end_date=end_date, user_id=active_user.id)
+
+ return [
+ SleepResponse(
+ id=s.id,
+ date=s.date.isoformat(),
+ bedtime=s.bedtime.isoformat() if s.bedtime else None,
+ wake_time=s.wake_time.isoformat() if s.wake_time else None,
+ duration=s.duration,
+ quality=s.quality,
+ deep_sleep_mins=s.deep_sleep_mins,
+ source=s.source,
+ notes=s.notes,
+ )
+ for s in records
+ ]
+
+
+@app.get("/api/weight", response_model=list[WeightResponse])
+async def get_weight_records(
+ days: int = Query(default=90, ge=1, le=365, description="查询天数"),
+):
+ """获取体重记录"""
+ # 获取激活用户
+ active_user = db.get_active_user()
+ if not active_user:
+ raise HTTPException(status_code=400, detail="没有激活的用户")
+
+ end_date = date.today()
+ start_date = end_date - timedelta(days=days)
+ records = db.get_weight_records(start_date=start_date, end_date=end_date, user_id=active_user.id)
+
+ return [
+ WeightResponse(
+ id=w.id,
+ date=w.date.isoformat(),
+ weight_kg=w.weight_kg,
+ body_fat_pct=w.body_fat_pct,
+ muscle_mass=w.muscle_mass,
+ notes=w.notes,
+ )
+ for w in records
+ ]
+
+
+@app.get("/api/weight/goal")
+async def get_weight_goal():
+ """获取目标体重（基于用户配置推断）"""
+ config = db.get_config()
+ if not config.weight:
+ return {"goal_weight": None}
+
+ if config.goal == "lose":
+ goal_weight = round(config.weight * 0.95, 1)
+ elif config.goal == "gain":
+ goal_weight = round(config.weight * 1.05, 1)
+ else:
+ goal_weight = round(config.weight, 1)
+
+ return {"goal_weight": goal_weight}
+
+
+# ===== 阅读 API =====
+
+
+@app.get("/reading")
+async def reading_page():
+ """阅读页面"""
+ return HTMLResponse(content=get_reading_page_html(), status_code=200)
+
+
+@app.get("/api/reading", response_model=list[ReadingResponse])
+async def get_readings(days: int = 30):
+ """获取阅读记录"""
+ active_user = db.get_active_user()
+ if not active_user:
+ raise HTTPException(status_code=400, detail="请先设置活跃用户")
+
+ readings = db.get_readings(user_id=active_user.id, days=days)
+ return [
+ ReadingResponse(
+ id=r.id,
+ user_id=r.user_id,
+ date=r.date.isoformat(),
+ title=r.title,
+ author=r.author,
+ cover_url=r.cover_url,
+ duration=r.duration,
+ mood=r.mood,
+ notes=r.notes,
+ )
+ for r in readings
+ ]
+
+
+@app.post("/api/reading", response_model=ReadingResponse)
+async def add_reading(reading_input: ReadingInput):
+ """添加阅读记录"""
+ active_user = db.get_active_user()
+ if not active_user:
+ raise HTTPException(status_code=400, detail="请先设置活跃用户")
+
+ from datetime import date as dt_date
+ reading_date = dt_date.fromisoformat(reading_input.date) if reading_input.date else dt_date.today()
+
+ reading = Reading(
+ date=reading_date,
+ title=reading_input.title,
+ author=reading_input.author,
+ cover_url=reading_input.cover_url,
+ duration=reading_input.duration,
+ mood=reading_input.mood,
+ notes=reading_input.notes,
+ )
+
+ reading_id = db.add_reading(reading, user_id=active_user.id)
+ created = db.get_reading(reading_id)
+
+ return ReadingResponse(
+ id=created.id,
+ user_id=created.user_id,
+ date=created.date.isoformat(),
+ title=created.title,
+ author=created.author,
+ cover_url=created.cover_url,
+ duration=created.duration,
+ mood=created.mood,
+ notes=created.notes,
+ )
+
+
+@app.delete("/api/reading/{reading_id}")
+async def delete_reading(reading_id: int):
+ """删除阅读记录"""
+ reading = db.get_reading(reading_id)
+ if not reading:
+ raise HTTPException(status_code=404, detail="阅读记录不存在")
+
+ db.delete_reading(reading_id)
+ return {"message": "阅读记录已删除"}
+
+
+@app.get("/api/reading/today")
+async def get_today_reading():
+ """获取今日阅读摘要"""
+ active_user = db.get_active_user()
+ if not active_user:
+ return {"duration": 0, "book": None, "mood": None}
+
+ return db.get_today_reading(user_id=active_user.id)
+
+
+@app.get("/api/reading/stats")
+async def get_reading_stats(days: int = 30):
+ """获取阅读统计"""
+ active_user = db.get_active_user()
+ if not active_user:
+ raise HTTPException(status_code=400, detail="请先设置活跃用户")
+
+ return db.get_reading_stats(user_id=active_user.id, days=days)
+
+
+@app.get("/api/books/search")
+async def search_books(q: str):
+ """搜索书籍（OpenLibrary API）"""
+ import urllib.request
+ import urllib.parse
+ import json
+ import ssl
+
+ if not q or len(q.strip()) < 2:
+ return {"books": []}
+
+ try:
+ encoded_q = urllib.parse.quote(q)
+ url = f"https://openlibrary.org/search.json?q={encoded_q}&limit=5"
+
+ # 创建不验证 SSL 的上下文
+ ssl_context = ssl.create_default_context()
+ ssl_context.check_hostname = False
+ ssl_context.verify_mode = ssl.CERT_NONE
+
+ req = urllib.request.Request(url, headers={"User-Agent": "Vitals/1.0"})
+ with urllib.request.urlopen(req, timeout=5, context=ssl_context) as response:
+ data = json.loads(response.read().decode())
+
+ books = []
+ for doc in data.get("docs", [])[:5]:
+ cover_id = doc.get("cover_i")
+ cover_url = f"https://covers.openlibrary.org/b/id/{cover_id}-M.jpg" if cover_id else None
+ books.append({
+ "title": doc.get("title", ""),
+ "author": doc.get("author_name", [""])[0] if doc.get("author_name") else None,
+ "cover_url": cover_url,
+ "isbn": doc.get("isbn", [""])[0] if doc.get("isbn") else None,
+ })
+
+ return {"books": books}
+ except Exception as e:
+ return {"books": [], "error": str(e)}
+
+
+# ===== 用户管理 API =====
+
+
+@app.get("/api/users", response_model=list[UserResponse])
+async def get_users():
+ """获取所有用户"""
+ users = db.get_users()
+ return [
+ UserResponse(
+ id=u.id,
+ name=u.name,
+ created_at=u.created_at.isoformat(),
+ is_active=u.is_active,
+ gender=u.gender,
+ height_cm=u.height_cm,
+ weight_kg=u.weight_kg,
+ age=u.age,
+ bmi=u.bmi,
+ bmi_status=u.bmi_status,
+ )
+ for u in users
+ ]
+
+
+@app.get("/api/users/active", response_model=UserResponse)
+async def get_active_user():
+ """获取当前激活的用户"""
+ user = db.get_active_user()
+ if not user:
+ raise HTTPException(status_code=404, detail="没有激活的用户")
+ return UserResponse(
+ id=user.id,
+ name=user.name,
+ created_at=user.created_at.isoformat(),
+ is_active=user.is_active,
+ gender=user.gender,
+ height_cm=user.height_cm,
+ weight_kg=user.weight_kg,
+ age=user.age,
+ bmi=user.bmi,
+ bmi_status=user.bmi_status,
+ )
+
+
+@app.get("/api/users/{user_id}", response_model=UserResponse)
+async def get_user(user_id: int):
+ """获取指定用户"""
+ user = db.get_user(user_id)
+ if not user:
+ raise HTTPException(status_code=404, detail="用户不存在")
+ return UserResponse(
+ id=user.id,
+ name=user.name,
+ created_at=user.created_at.isoformat(),
+ is_active=user.is_active,
+ gender=user.gender,
+ height_cm=user.height_cm,
+ weight_kg=user.weight_kg,
+ age=user.age,
+ bmi=user.bmi,
+ bmi_status=user.bmi_status,
+ )
+
+
+@app.post("/api/users", response_model=UserResponse)
+async def create_user(user_input: UserInput):
+ """创建新用户"""
+ user = User(
+ name=user_input.name,
+ gender=user_input.gender,
+ height_cm=user_input.height_cm,
+ weight_kg=user_input.weight_kg,
+ age=user_input.age,
+ )
+ user_id = db.add_user(user)
+ created_user = db.get_user(user_id)
+ return UserResponse(
+ id=created_user.id,
+ name=created_user.name,
+ created_at=created_user.created_at.isoformat(),
+ is_active=created_user.is_active,
+ gender=created_user.gender,
+ height_cm=created_user.height_cm,
+ weight_kg=created_user.weight_kg,
+ age=created_user.age,
+ bmi=created_user.bmi,
+ bmi_status=created_user.bmi_status,
+ )
+
+
+@app.put("/api/users/{user_id}", response_model=UserResponse)
+async def update_user(user_id: int, user_input: UserInput):
+ """更新用户信息"""
+ user = db.get_user(user_id)
+ if not user:
+ raise HTTPException(status_code=404, detail="用户不存在")
+
+ user.name = user_input.name
+ user.gender = user_input.gender
+ user.height_cm = user_input.height_cm
+ user.weight_kg = user_input.weight_kg
+ user.age = user_input.age
+ db.update_user(user)
+
+ updated_user = db.get_user(user_id)
+ return UserResponse(
+ id=updated_user.id,
+ name=updated_user.name,
+ created_at=updated_user.created_at.isoformat(),
+ is_active=updated_user.is_active,
+ gender=updated_user.gender,
+ height_cm=updated_user.height_cm,
+ weight_kg=updated_user.weight_kg,
+ age=updated_user.age,
+ bmi=updated_user.bmi,
+ bmi_status=updated_user.bmi_status,
+ )
+
+
+@app.delete("/api/users/{user_id}")
+async def delete_user(user_id: int):
+ """删除用户"""
+ user = db.get_user(user_id)
+ if not user:
+ raise HTTPException(status_code=404, detail="用户不存在")
+
+ if user.is_active:
+ raise HTTPException(status_code=400, detail="无法删除激活中的用户，请先切换到其他用户")
+
+ db.delete_user(user_id)
+ return {"message": "用户已删除"}
+
+
+@app.post("/api/users/{user_id}/activate")
+async def activate_user(user_id: int):
+ """设置激活用户"""
+ user = db.get_user(user_id)
+ if not user:
+ raise HTTPException(status_code=404, detail="用户不存在")
+
+ db.set_active_user(user_id)
+ return {"message": f"已切换到用户: {user.name}"}
+
+
+# ===== 数据清除 API =====
+
+
+@app.post("/api/data/preview-delete")
+async def preview_delete_data(request: DataClearInput):
+ """预览将要删除的数据量"""
+ # 验证用户存在
+ user = db.get_user(request.user_id)
+ if not user:
+ raise HTTPException(status_code=404, detail="用户不存在")
+
+ # 转换日期字符串
+ date_from = date.fromisoformat(request.date_from) if request.date_from else None
+ date_to = date.fromisoformat(request.date_to) if request.date_to else None
+
+ # 获取预览数据
+ counts = db.preview_delete(
+ user_id=request.user_id,
+ mode=request.mode,
+ date_from=date_from,
+ date_to=date_to,
+ data_types=request.data_types,
+ )
+
+ return counts
+
+
+@app.post("/api/data/clear")
+async def clear_data(request: DataClearInput):
+ """清除数据"""
+ # 验证用户存在
+ user = db.get_user(request.user_id)
+ if not user:
+ raise HTTPException(status_code=404, detail="用户不存在")
+
+ # 转换日期字符串
+ date_from = date.fromisoformat(request.date_from) if request.date_from else None
+ date_to = date.fromisoformat(request.date_to) if request.date_to else None
+
+ # 执行清除
+ db.clear_data(
+ user_id=request.user_id,
+ mode=request.mode,
+ date_from=date_from,
+ date_to=date_to,
+ data_types=request.data_types,
+ )
+
+ return {"message": "数据已清除"}
+
+
+# ===== 认证页面 HTML =====
+
+
+def get_login_page_html() -> str:
+ """生成登录页面 HTML"""
+ return """
+
+
+
+
+
+ {report.year}年{report.month}月 健康月报
+ +
+
+
+
+
+ 运动
+{report.exercise_duration}分钟
+ {report.exercise_count} 次, {report.exercise_days} 天运动
+
+
+ 睡眠
+{report.avg_sleep_duration}小时/天
+ 平均质量 {report.avg_sleep_quality}/5
+
+
+ 饮食
+{report.avg_calories_intake}卡/天
+
+
+ 体重
+{weight_html}
+
+
+
+ 本月最佳
+ {best_html} +周汇总
+| 周 | 运动 | 摄入 | 睡眠 |
|---|
+
+
+
+
+
+"""
+
+
+def get_register_page_html() -> str:
+ """生成注册页面 HTML"""
+ return """
+
+
+
+
+
+
+
+
+
+ Vitals
+健康管理，从登录开始
+
+
+ 没有账号？立即注册
+
+
+
+
+
+
+"""
+
+
+def get_admin_page_html() -> str:
+ """生成管理后台页面 HTML"""
+ return """
+
+
+
+
+
+
+
+
+
+ Vitals
+创建账号，开始健康管理
+
+
+ 已有账号？立即登录
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+"""
+
+
+def get_dashboard_html() -> str:
+ """生成仪表盘 HTML"""
+ return """
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+"""
+
+
+def get_exercise_page_html() -> str:
+ """生成运动页面 HTML"""
+ return """
+
+
+
+
+
+ Vitals 健康管理
+ +
+
+
+
+
+ 今日摄入
+--卡
+
+
+ 今日消耗
+--卡
+
+
+
+ 运动时长
+--分钟
+
+
+ 睡眠时长
+--小时
+
+
+ 今日阅读
+--分钟
+
+
+
+
+ 本周卡路里趋势
+ +
+
+
+
+
+
+ 今日饮食
+-
+
- 暂无记录 +
+
+ 体重趋势 (近30天)
+ +
+
+
+
+
+
+
+
+
+ 运动概览
+本月运动统计与趋势
+
+
+
+
+
+ 本月运动次数
+--
+
+
+ 本月总时长
+--分钟
+
+
+ 本月消耗卡路里
+--卡
+
+
+ 最常运动类型
+--
+
+
+
+ 近 30 天运动时长趋势
+ +
+
+
+
+
+ 运动类型分布
+ +
+
+ 卡路里消耗分布
+ +
+
+
+
+
+ 最近 50 条运动记录
+| 日期 | +类型 | +时长 | +卡路里 | +距离 | +操作 | +
|---|---|---|---|---|---|
| 加载中... | |||||
+
+
+
+
+
+
+"""
+
+
+def get_meal_page_html() -> str:
+ """生成饮食页面 HTML"""
+ return """
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 饮食概览
+卡路里与营养摄入趋势
+
+
+
+
+
+ 近 30 天摄入
+--卡
+
+
+ 平均每日摄入
+--卡
+
+
+ 蛋白质总量
+--g
+
+
+ 碳水/脂肪总量
+--
+
+
+
+ 本月饮食日历
+
+
+ 加载中...
+
+
+
+
+
+ 营养成分分布
+ +
+
+ 餐次分布（卡路里）
+ +
+
+
+ 近 7 天摄入趋势
+ +
+
+
+ 食物照片墙
+
+
+ 暂无照片
+
+
+
+
+
+ 最近 50 条饮食记录
+| 日期 | +餐次 | +食物 | +卡路里 | +蛋白质 | +操作 | +
|---|---|---|---|---|---|
| 加载中... | |||||
+
+
+
+
+
+
+"""
+
+
+def get_sleep_page_html() -> str:
+ """生成睡眠页面 HTML"""
+ return """
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 睡眠概览
+睡眠时长与质量趋势
+
+
+
+
+
+ 近 30 天平均时长
+--小时
+
+
+ 近 30 天平均质量
+--
+
+
+ 最短/最长睡眠
+--
+
+
+ 有记录天数
+--
+
+
+
+ 近 30 天睡眠时长趋势
+ +
+
+
+
+
+ 睡眠质量趋势
+ +
+
+ 入睡/起床时间（小时）
+ +
+
+
+
+
+ 最近 30 条睡眠记录
+| 日期 | +时长 | +质量 | +入睡 | +起床 | +操作 | +
|---|---|---|---|---|---|
| 加载中... | |||||
+
+
+
+
+
+
+"""
+
+
+def get_weight_page_html() -> str:
+ """生成体重页面 HTML"""
+ return """
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 体重趋势
+体重与体脂变化
+
+
+
+
+
+ 当前体重
+--kg
+
+
+ 体重变化
+--
+
+
+ BMI
+--
+
+
+ 目标体重
+--
+
+
+
+ 体重曲线（近 90 天）
+ +
+
+
+ 体脂率曲线（近 90 天）
+ +
+
+
+
+
+ 最近 30 条体重记录
+| 日期 | +体重 | +体脂率 | +肌肉量 | +操作 | +
|---|---|---|---|---|
| 加载中... | ||||
+
+
+
+
+
+
+"""
+
+
+def get_report_page_html() -> str:
+ """生成报告页面 HTML"""
+ return """
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+"""
+
+
+def get_reading_page_html() -> str:
+ """生成阅读页面 HTML"""
+ return """
+
+
+
+
+
+ 健康报告
+周报 / 月报导出与查看
+
+
+
+
+
+
+ 使用说明
+报告支持一键生成并下载 PDF/PNG：
+周报 PDF/PNG 与 月报 PDF/PNG
+
+
+
+
+
+
+
+
+
+
+
+ 我的阅读
+加载中...
+
+
+
+
+ 阅读统计
+
+
+
+
+ 近30天阅读时长
+
+
+
+
+
+ 心情分布
+
+
+
+
+
+
+ 我的书库
+
+
+ 加载中...
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+"""
+
+
+def get_settings_page_html() -> str:
+ """生成设置页面 HTML"""
+ return """
+
+
+
+
+
+
+
+
+
+ 书籍详情
+
+ ![]()
+
+
+
+ 作者：
+总阅读时长：-
+阅读次数：-
+阅读记录
+ + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+ """
+
+
+def _export_report_file(report, format: str, prefix: str, exporter):
+ """导出报告并返回下载响应"""
+ fmt = format.lower().strip(".")
+ if fmt not in {"pdf", "png"}:
+ raise HTTPException(status_code=400, detail="不支持的格式")
+
+ reports_dir = Path.home() / ".vitals" / "reports"
+ reports_dir.mkdir(parents=True, exist_ok=True)
+ filename = f"{prefix}_{uuid4().hex}.{fmt}"
+ output_path = reports_dir / filename
+
+ ok = exporter(report, output_path)
+ if not ok:
+ raise HTTPException(status_code=400, detail="导出失败")
+
+ media_types = {
+ "pdf": "application/pdf",
+ "png": "image/png",
+ }
+
+ return FileResponse(
+ output_path,
+ media_type=media_types[fmt],
+ filename=filename,
+ )
+
+
+def run_server(host: str = "127.0.0.1", port: int = 8080):
+ """启动 Web 服务器"""
+ import uvicorn
+ uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+ run_server()
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 0000000..56816ad
--- /dev/null
+++ b/tests/__init__.py
@@ -0,0 +1 @@
+"""Vitals 测试套件"""
diff --git a/tests/__pycache__/__init__.cpython-313.pyc b/tests/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000..2d07d11
Binary files /dev/null and b/tests/__pycache__/__init__.cpython-313.pyc differ
diff --git a/tests/__pycache__/conftest.cpython-313-pytest-9.0.2.pyc b/tests/__pycache__/conftest.cpython-313-pytest-9.0.2.pyc
new file mode 100644
index 0000000..53686e6
Binary files /dev/null and b/tests/__pycache__/conftest.cpython-313-pytest-9.0.2.pyc differ
diff --git a/tests/__pycache__/test_backup.cpython-313-pytest-9.0.2.pyc b/tests/__pycache__/test_backup.cpython-313-pytest-9.0.2.pyc
new file mode 100644
index 0000000..551228e
Binary files /dev/null and b/tests/__pycache__/test_backup.cpython-313-pytest-9.0.2.pyc differ
diff --git a/tests/__pycache__/test_calories.cpython-313-pytest-9.0.2.pyc b/tests/__pycache__/test_calories.cpython-313-pytest-9.0.2.pyc
new file mode 100644
index 0000000..a7fcbec
Binary files /dev/null and b/tests/__pycache__/test_calories.cpython-313-pytest-9.0.2.pyc differ
diff --git a/tests/__pycache__/test_database.cpython-313-pytest-9.0.2.pyc b/tests/__pycache__/test_database.cpython-313-pytest-9.0.2.pyc
new file mode 100644
index 0000000..17e7b6d
Binary files /dev/null and b/tests/__pycache__/test_database.cpython-313-pytest-9.0.2.pyc differ
diff --git a/tests/__pycache__/test_deepseek.cpython-313-pytest-9.0.2.pyc b/tests/__pycache__/test_deepseek.cpython-313-pytest-9.0.2.pyc
new file mode 100644
index 0000000..b0c279d
Binary files /dev/null and b/tests/__pycache__/test_deepseek.cpython-313-pytest-9.0.2.pyc differ
diff --git a/tests/__pycache__/test_export.cpython-313-pytest-9.0.2.pyc b/tests/__pycache__/test_export.cpython-313-pytest-9.0.2.pyc
new file mode 100644
index 0000000..fd869ed
Binary files /dev/null and b/tests/__pycache__/test_export.cpython-313-pytest-9.0.2.pyc differ
diff --git a/tests/__pycache__/test_models.cpython-313-pytest-9.0.2.pyc b/tests/__pycache__/test_models.cpython-313-pytest-9.0.2.pyc
new file mode 100644
index 0000000..88ba28e
Binary files /dev/null and b/tests/__pycache__/test_models.cpython-313-pytest-9.0.2.pyc differ
diff --git a/tests/__pycache__/test_report.cpython-313-pytest-9.0.2.pyc b/tests/__pycache__/test_report.cpython-313-pytest-9.0.2.pyc
new file mode 100644
index 0000000..e223a3e
Binary files /dev/null and b/tests/__pycache__/test_report.cpython-313-pytest-9.0.2.pyc differ
diff --git a/tests/__pycache__/test_web.cpython-313-pytest-9.0.2.pyc b/tests/__pycache__/test_web.cpython-313-pytest-9.0.2.pyc
new file mode 100644
index 0000000..dfe21cc
Binary files /dev/null and b/tests/__pycache__/test_web.cpython-313-pytest-9.0.2.pyc differ
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 0000000..ff15541
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,97 @@
+"""Pytest 配置和共享 fixtures"""
+
+import os
+import tempfile
+from datetime import date, time
+from pathlib import Path
+
+import pytest
+
+# 设置测试数据库路径
+@pytest.fixture(autouse=True)
+def test_db(tmp_path, monkeypatch):
+ """使用临时数据库进行测试"""
+ db_path = tmp_path / "test_vitals.db"
+
+ # 覆盖 get_db_path 函数
+ def mock_get_db_path():
+ return db_path
+
+ from src.vitals.core import database
+ monkeypatch.setattr(database, "get_db_path", mock_get_db_path)
+
+ # 初始化数据库
+ database.init_db()
+
+ yield db_path
+
+
+@pytest.fixture
+def sample_exercise():
+ """示例运动记录"""
+ from src.vitals.core.models import Exercise
+ return Exercise(
+ date=date(2026, 1, 18),
+ type="跑步",
+ duration=30,
+ calories=240,
+ distance=5.0,
+ heart_rate_avg=145,
+ source="手动",
+ notes="晨跑",
+ )
+
+
+@pytest.fixture
+def sample_meal():
+ """示例饮食记录"""
+ from src.vitals.core.models import Meal
+ return Meal(
+ date=date(2026, 1, 18),
+ meal_type="午餐",
+ description="米饭+红烧肉+青菜",
+ calories=650,
+ protein=25.0,
+ carbs=80.0,
+ fat=20.0,
+ )
+
+
+@pytest.fixture
+def sample_sleep():
+ """示例睡眠记录"""
+ from src.vitals.core.models import Sleep
+ return Sleep(
+ date=date(2026, 1, 18),
+ bedtime=time(23, 30),
+ wake_time=time(7, 0),
+ duration=7.5,
+ quality=4,
+ source="手动",
+ )
+
+
+@pytest.fixture
+def sample_weight():
+ """示例体重记录"""
+ from src.vitals.core.models import Weight
+ return Weight(
+ date=date(2026, 1, 18),
+ weight_kg=72.5,
+ body_fat_pct=18.5,
+ muscle_mass=35.0,
+ )
+
+
+@pytest.fixture
+def sample_config():
+ """示例用户配置"""
+ from src.vitals.core.models import UserConfig
+ return UserConfig(
+ age=28,
+ gender="male",
+ height=175.0,
+ weight=72.0,
+ activity_level="moderate",
+ goal="lose",
+ )
diff --git a/tests/test_backup.py b/tests/test_backup.py
new file mode 100644
index 0000000..eb3250a
--- /dev/null
+++ b/tests/test_backup.py
@@ -0,0 +1,45 @@
+"""数据库备份测试"""
+
+from datetime import datetime, timedelta
+
+from src.vitals.core.backup import (
+ backup_database,
+ cleanup_old_backups,
+ list_backups,
+ restore_database,
+)
+
+
+def test_backup_database(tmp_path):
+ backup_path = backup_database(tmp_path)
+ assert backup_path.exists()
+ assert backup_path.name.startswith("vitals_")
+ assert backup_path.suffix == ".db"
+
+
+def test_cleanup_old_backups(tmp_path):
+ old_date = (datetime.now() - timedelta(days=10)).strftime("%Y%m%d")
+ new_date = datetime.now().strftime("%Y%m%d")
+
+ old_backup = tmp_path / f"vitals_{old_date}_120000.db"
+ new_backup = tmp_path / f"vitals_{new_date}_120000.db"
+ old_backup.write_text("old")
+ new_backup.write_text("new")
+
+ deleted = cleanup_old_backups(tmp_path, keep_days=7)
+ assert deleted == 1
+ assert not old_backup.exists()
+ assert new_backup.exists()
+
+
+def test_list_backups(tmp_path):
+ backup_path = backup_database(tmp_path)
+ backups = list_backups(tmp_path)
+ assert len(backups) > 0
+ assert backups[0]["path"] == backup_path
+
+
+def test_restore_database(tmp_path, test_db):
+ backup_path = backup_database(tmp_path)
+ result = restore_database(backup_path)
+ assert result is True
diff --git a/tests/test_calories.py b/tests/test_calories.py
new file mode 100644
index 0000000..1d0cc8f
--- /dev/null
+++ b/tests/test_calories.py
@@ -0,0 +1,188 @@
+"""卡路里计算测试"""
+
+import pytest
+
+from src.vitals.core.calories import (
+ parse_food_description,
+ estimate_meal_calories,
+ estimate_exercise_calories,
+ FOOD_DATABASE,
+)
+
+
+class TestFoodDatabase:
+ """食物数据库测试"""
+
+ def test_database_not_empty(self):
+ """测试数据库不为空"""
+ assert len(FOOD_DATABASE) > 0
+
+ def test_common_foods_exist(self):
+ """测试常见食物存在"""
+ common_foods = ["米饭", "鸡蛋", "牛奶", "苹果", "鸡胸肉"]
+ for food in common_foods:
+ assert food in FOOD_DATABASE
+
+ def test_food_has_required_fields(self):
+ """测试食物有必需字段"""
+ for name, data in FOOD_DATABASE.items():
+ assert "calories" in data
+ assert "protein" in data
+ assert "carbs" in data
+ assert "fat" in data
+ assert "serving" in data
+
+
+class TestParseFoodDescription:
+ """食物描述解析测试"""
+
+ def test_parse_plus_separated(self):
+ """测试加号分隔"""
+ items = parse_food_description("燕麦+鸡蛋+牛奶")
+ assert len(items) == 3
+
+ def test_parse_comma_separated(self):
+ """测试逗号分隔"""
+ items = parse_food_description("米饭,红烧肉,青菜")
+ assert len(items) == 3
+
+ def test_parse_chinese_comma(self):
+ """测试中文逗号分隔"""
+ items = parse_food_description("米饭，红烧肉，青菜")
+ assert len(items) == 3
+
+ def test_parse_with_quantity(self):
+ """测试带数量"""
+ items = parse_food_description("2个鸡蛋")
+ assert len(items) == 1
+ assert items[0]["quantity"] == 2
+
+ def test_parse_chinese_quantity(self):
+ """测试中文数量"""
+ items = parse_food_description("一碗米饭")
+ assert len(items) == 1
+ assert items[0]["quantity"] == 1
+
+ def test_parse_half_quantity(self):
+ """测试半份"""
+ items = parse_food_description("半碗米饭")
+ assert len(items) == 1
+ assert items[0]["quantity"] == 0.5
+
+ def test_parse_unknown_food(self):
+ """测试未知食物"""
+ items = parse_food_description("神秘食物")
+ assert len(items) == 1
+ assert items[0]["calories"] == 0
+ assert items[0]["estimated"] == False
+
+ def test_parse_fuzzy_match(self):
+ """测试模糊匹配"""
+ items = parse_food_description("炒青菜")
+ assert len(items) == 1
+ assert items[0]["calories"] > 0
+
+
+class TestEstimateMealCalories:
+ """餐食卡路里估算测试"""
+
+ def test_single_food(self):
+ """测试单个食物"""
+ result = estimate_meal_calories("米饭")
+ assert result["total_calories"] > 0
+ assert len(result["items"]) == 1
+
+ def test_multiple_foods(self):
+ """测试多个食物"""
+ result = estimate_meal_calories("米饭+红烧肉+青菜")
+ assert result["total_calories"] > 0
+ assert len(result["items"]) == 3
+
+ def test_total_is_sum_of_items(self):
+ """测试总量等于各项之和"""
+ result = estimate_meal_calories("鸡蛋+牛奶")
+ items_sum = sum(item["calories"] for item in result["items"])
+ assert result["total_calories"] == items_sum
+
+ def test_macros_calculated(self):
+ """测试营养素计算"""
+ result = estimate_meal_calories("鸡胸肉")
+ assert result["total_protein"] > 0
+ assert result["total_carbs"] >= 0
+ assert result["total_fat"] >= 0
+
+ def test_empty_description(self):
+ """测试空描述"""
+ result = estimate_meal_calories("")
+ assert result["total_calories"] == 0
+ assert len(result["items"]) == 0
+
+
+class TestEstimateExerciseCalories:
+ """运动卡路里估算测试"""
+
+ def test_running(self):
+ """测试跑步"""
+ calories = estimate_exercise_calories("跑步", 30, 70)
+ assert calories > 0
+
+ def test_swimming(self):
+ """测试游泳"""
+ calories = estimate_exercise_calories("游泳", 30, 70)
+ assert calories > 0
+
+ def test_longer_duration_more_calories(self):
+ """测试时长越长卡路里越多"""
+ cal_30 = estimate_exercise_calories("跑步", 30, 70)
+ cal_60 = estimate_exercise_calories("跑步", 60, 70)
+ assert cal_60 > cal_30
+
+ def test_heavier_person_more_calories(self):
+ """测试体重越大卡路里越多"""
+ cal_60kg = estimate_exercise_calories("跑步", 30, 60)
+ cal_80kg = estimate_exercise_calories("跑步", 30, 80)
+ assert cal_80kg > cal_60kg
+
+ def test_unknown_exercise_uses_default(self):
+ """测试未知运动使用默认值"""
+ calories = estimate_exercise_calories("未知运动", 30, 70)
+ assert calories > 0
+
+ def test_zero_duration(self):
+ """测试零时长"""
+ calories = estimate_exercise_calories("跑步", 0, 70)
+ assert calories == 0
+
+ def test_different_exercises_different_calories(self):
+ """测试不同运动不同卡路里"""
+ running = estimate_exercise_calories("跑步", 30, 70)
+ yoga = estimate_exercise_calories("瑜伽", 30, 70)
+ assert running > yoga # 跑步消耗更多
+
+
+class TestCalorieAccuracy:
+ """卡路里准确性测试"""
+
+ def test_rice_calories_reasonable(self):
+ """测试米饭卡路里合理"""
+ result = estimate_meal_calories("一碗米饭")
+ # 一碗米饭约 200-250 卡
+ assert 150 < result["total_calories"] < 300
+
+ def test_egg_calories_reasonable(self):
+ """测试鸡蛋卡路里合理"""
+ result = estimate_meal_calories("一个鸡蛋")
+ # 一个鸡蛋约 70-90 卡
+ assert 50 < result["total_calories"] < 120
+
+ def test_milk_calories_reasonable(self):
+ """测试牛奶卡路里合理"""
+ result = estimate_meal_calories("一杯牛奶")
+ # 一杯牛奶 250ml 约 130-150 卡
+ assert 100 < result["total_calories"] < 200
+
+ def test_running_calories_reasonable(self):
+ """测试跑步卡路里合理"""
+ # 70kg 的人跑步 30 分钟约消耗 300-400 卡
+ calories = estimate_exercise_calories("跑步", 30, 70)
+ assert 200 < calories < 500
diff --git a/tests/test_database.py b/tests/test_database.py
new file mode 100644
index 0000000..0673228
--- /dev/null
+++ b/tests/test_database.py
@@ -0,0 +1,417 @@
+"""数据库操作测试"""
+
+from datetime import date, timedelta
+
+import pytest
+
+from src.vitals.core import database as db
+from src.vitals.core.models import Exercise, Meal, Sleep, Weight, UserConfig, User
+
+
+class TestExerciseDB:
+ """运动记录数据库测试"""
+
+ def test_add_exercise(self, sample_exercise):
+ """测试添加运动记录"""
+ record_id = db.add_exercise(sample_exercise)
+ assert record_id > 0
+
+ def test_get_exercises(self, sample_exercise):
+ """测试查询运动记录"""
+ db.add_exercise(sample_exercise)
+ exercises = db.get_exercises()
+ assert len(exercises) == 1
+ assert exercises[0].type == "跑步"
+
+ def test_get_exercises_by_date_range(self, sample_exercise):
+ """测试按日期范围查询"""
+ db.add_exercise(sample_exercise)
+
+ # 查询包含该日期的范围
+ exercises = db.get_exercises(
+ start_date=date(2026, 1, 1),
+ end_date=date(2026, 1, 31),
+ )
+ assert len(exercises) == 1
+
+ # 查询不包含该日期的范围
+ exercises = db.get_exercises(
+ start_date=date(2026, 2, 1),
+ end_date=date(2026, 2, 28),
+ )
+ assert len(exercises) == 0
+
+ def test_multiple_exercises(self):
+ """测试多条记录"""
+ for i in range(3):
+ exercise = Exercise(
+ date=date(2026, 1, 15 + i),
+ type="跑步",
+ duration=30 + i * 10,
+ calories=200 + i * 50,
+ )
+ db.add_exercise(exercise)
+
+ exercises = db.get_exercises()
+ assert len(exercises) == 3
+ # 按日期降序
+ assert exercises[0].date > exercises[1].date
+
+
+class TestMealDB:
+ """饮食记录数据库测试"""
+
+ def test_add_meal(self, sample_meal):
+ """测试添加饮食记录"""
+ record_id = db.add_meal(sample_meal)
+ assert record_id > 0
+
+ def test_get_meals(self, sample_meal):
+ """测试查询饮食记录"""
+ db.add_meal(sample_meal)
+ meals = db.get_meals()
+ assert len(meals) == 1
+ assert meals[0].meal_type == "午餐"
+
+ def test_get_meals_by_date(self, sample_meal):
+ """测试按日期查询"""
+ db.add_meal(sample_meal)
+ meals = db.get_meals(
+ start_date=date(2026, 1, 18),
+ end_date=date(2026, 1, 18),
+ )
+ assert len(meals) == 1
+
+ def test_meal_with_food_items(self):
+ """测试带食物条目的记录"""
+ meal = Meal(
+ date=date(2026, 1, 18),
+ meal_type="午餐",
+ description="测试",
+ calories=500,
+ food_items=[
+ {"name": "米饭", "calories": 200},
+ {"name": "红烧肉", "calories": 300},
+ ],
+ )
+ db.add_meal(meal)
+
+ meals = db.get_meals()
+ assert len(meals) == 1
+ assert meals[0].food_items is not None
+ assert len(meals[0].food_items) == 2
+
+
+class TestSleepDB:
+ """睡眠记录数据库测试"""
+
+ def test_add_sleep(self, sample_sleep):
+ """测试添加睡眠记录"""
+ record_id = db.add_sleep(sample_sleep)
+ assert record_id > 0
+
+ def test_get_sleep_records(self, sample_sleep):
+ """测试查询睡眠记录"""
+ db.add_sleep(sample_sleep)
+ records = db.get_sleep_records()
+ assert len(records) == 1
+ assert records[0].duration == 7.5
+
+ def test_sleep_quality_range(self):
+ """测试不同质量评分"""
+ for quality in range(1, 6):
+ sleep = Sleep(
+ date=date(2026, 1, 10 + quality),
+ duration=7.0,
+ quality=quality,
+ )
+ db.add_sleep(sleep)
+
+ records = db.get_sleep_records()
+ assert len(records) == 5
+
+
+class TestWeightDB:
+ """体重记录数据库测试"""
+
+ def test_add_weight(self, sample_weight):
+ """测试添加体重记录"""
+ record_id = db.add_weight(sample_weight)
+ assert record_id > 0
+
+ def test_get_weight_records(self, sample_weight):
+ """测试查询体重记录"""
+ db.add_weight(sample_weight)
+ records = db.get_weight_records()
+ assert len(records) == 1
+ assert records[0].weight_kg == 72.5
+
+ def test_get_latest_weight(self, sample_weight):
+ """测试获取最新体重"""
+ db.add_weight(sample_weight)
+
+ # 添加更早的记录
+ older = Weight(
+ date=date(2026, 1, 10),
+ weight_kg=73.0,
+ )
+ db.add_weight(older)
+
+ latest = db.get_latest_weight()
+ assert latest.weight_kg == 72.5 # 最新的是 1月18日
+
+ def test_get_latest_weight_empty(self):
+ """测试无记录时获取最新体重"""
+ latest = db.get_latest_weight()
+ assert latest is None
+
+
+class TestConfigDB:
+ """用户配置数据库测试"""
+
+ def test_save_and_get_config(self, sample_config):
+ """测试保存和获取配置"""
+ db.save_config(sample_config)
+ config = db.get_config()
+
+ assert config.age == 28
+ assert config.gender == "male"
+ assert config.height == 175.0
+ assert config.weight == 72.0
+
+ def test_update_config(self):
+ """测试更新配置"""
+ config1 = UserConfig(age=28, gender="male")
+ db.save_config(config1)
+
+ config2 = UserConfig(age=29, gender="male", height=175.0)
+ db.save_config(config2)
+
+ config = db.get_config()
+ assert config.age == 29
+ assert config.height == 175.0
+
+ def test_get_config_default(self):
+ """测试获取默认配置"""
+ config = db.get_config()
+ assert config.activity_level == "moderate"
+ assert config.goal == "maintain"
+
+
+class TestDatabaseInit:
+ """数据库初始化测试"""
+
+ def test_init_creates_tables(self, test_db):
+ """测试初始化创建表"""
+ import sqlite3
+
+ conn = sqlite3.connect(test_db)
+ cursor = conn.cursor()
+
+ # 检查表是否存在
+ cursor.execute(
+ "SELECT name FROM sqlite_master WHERE type='table'"
+ )
+ tables = {row[0] for row in cursor.fetchall()}
+
+ assert "exercise" in tables
+ assert "meal" in tables
+ assert "sleep" in tables
+ assert "weight" in tables
+ assert "config" in tables
+
+ conn.close()
+
+ def test_init_creates_indexes(self, test_db):
+ """测试初始化创建索引"""
+ import sqlite3
+
+ conn = sqlite3.connect(test_db)
+ cursor = conn.cursor()
+
+ cursor.execute(
+ "SELECT name FROM sqlite_master WHERE type='index'"
+ )
+ indexes = {row[0] for row in cursor.fetchall()}
+
+ assert "idx_exercise_date" in indexes
+ assert "idx_meal_date" in indexes
+ assert "idx_sleep_date" in indexes
+ assert "idx_weight_date" in indexes
+
+ conn.close()
+
+
+class TestUserDB:
+ """用户数据库测试"""
+
+ def test_add_user(self):
+ """测试添加用户"""
+ user = User(name="测试用户")
+ user_id = db.add_user(user)
+ assert user_id > 0
+
+ def test_get_users(self):
+ """测试获取用户列表"""
+ db.add_user(User(name="用户1"))
+ db.add_user(User(name="用户2"))
+ users = db.get_users()
+ assert len(users) == 2
+
+ def test_get_user_by_id(self):
+ """测试按 ID 获取用户"""
+ user = User(name="小明")
+ user_id = db.add_user(user)
+ fetched = db.get_user(user_id)
+ assert fetched is not None
+ assert fetched.name == "小明"
+
+ def test_update_user(self):
+ """测试更新用户"""
+ user = User(name="原名")
+ user_id = db.add_user(user)
+ user.id = user_id
+ user.name = "新名"
+ db.update_user(user)
+ fetched = db.get_user(user_id)
+ assert fetched.name == "新名"
+
+ def test_delete_user(self):
+ """测试删除用户"""
+ user_id = db.add_user(User(name="待删除"))
+ db.delete_user(user_id)
+ fetched = db.get_user(user_id)
+ assert fetched is None
+
+ def test_set_active_user(self):
+ """测试设置激活用户"""
+ id1 = db.add_user(User(name="用户1"))
+ id2 = db.add_user(User(name="用户2"))
+ db.set_active_user(id1)
+ user1 = db.get_user(id1)
+ user2 = db.get_user(id2)
+ assert user1.is_active == True
+ assert user2.is_active == False
+ # 切换激活用户
+ db.set_active_user(id2)
+ user1 = db.get_user(id1)
+ user2 = db.get_user(id2)
+ assert user1.is_active == False
+ assert user2.is_active == True
+
+ def test_get_active_user(self):
+ """测试获取激活用户"""
+ id1 = db.add_user(User(name="用户1"))
+ db.set_active_user(id1)
+ active = db.get_active_user()
+ assert active is not None
+ assert active.id == id1
+
+
+class TestUserIdMigration:
+ """user_id 迁移测试"""
+
+ def test_ensure_default_user_creates_user(self):
+ """测试 ensure_default_user 创建默认用户"""
+ db.ensure_default_user()
+ users = db.get_users()
+ assert len(users) >= 1
+ # 应有一个激活用户
+ active = db.get_active_user()
+ assert active is not None
+
+ def test_existing_data_gets_default_user_id(self):
+ """测试现有数据关联到默认用户"""
+ # 先添加一条运动记录（无 user_id）
+ exercise = Exercise(
+ date=date(2026, 1, 18),
+ type="跑步",
+ duration=30,
+ calories=200,
+ )
+ db.add_exercise(exercise)
+
+ # 运行迁移
+ db.ensure_default_user()
+
+ # 获取默认用户的数据
+ active = db.get_active_user()
+ exercises = db.get_exercises(user_id=active.id)
+ assert len(exercises) >= 1
+
+
+class TestDataClear:
+ """数据清除测试"""
+
+ def test_preview_delete_all(self):
+ """测试预览删除全部"""
+ # 创建用户和数据
+ user_id = db.add_user(User(name="测试用户"))
+ db.add_exercise(Exercise(date=date(2026, 1, 10), type="跑步", duration=30, calories=200), user_id)
+ db.add_exercise(Exercise(date=date(2026, 1, 11), type="游泳", duration=45, calories=300), user_id)
+ db.add_meal(Meal(date=date(2026, 1, 10), meal_type="午餐", description="米饭", calories=500), user_id)
+
+ counts = db.preview_delete(user_id, mode="all")
+ assert counts["exercise"] == 2
+ assert counts["meal"] == 1
+ assert counts["sleep"] == 0
+ assert counts["weight"] == 0
+ assert counts["total"] == 3
+
+ def test_preview_delete_by_range(self):
+ """测试预览按时间范围删除"""
+ user_id = db.add_user(User(name="测试用户"))
+ db.add_exercise(Exercise(date=date(2026, 1, 5), type="跑步", duration=30, calories=200), user_id)
+ db.add_exercise(Exercise(date=date(2026, 1, 10), type="跑步", duration=30, calories=200), user_id)
+ db.add_exercise(Exercise(date=date(2026, 1, 15), type="跑步", duration=30, calories=200), user_id)
+
+ counts = db.preview_delete(user_id, mode="range", date_from=date(2026, 1, 8), date_to=date(2026, 1, 12))
+ assert counts["exercise"] == 1
+ assert counts["total"] == 1
+
+ def test_preview_delete_by_type(self):
+ """测试预览按类型删除"""
+ user_id = db.add_user(User(name="测试用户"))
+ db.add_exercise(Exercise(date=date(2026, 1, 10), type="跑步", duration=30, calories=200), user_id)
+ db.add_meal(Meal(date=date(2026, 1, 10), meal_type="午餐", description="米饭", calories=500), user_id)
+
+ counts = db.preview_delete(user_id, mode="type", data_types=["exercise"])
+ assert counts["exercise"] == 1
+ assert counts["meal"] == 0
+ assert counts["total"] == 1
+
+ def test_clear_data_all(self):
+ """测试清除全部数据"""
+ user_id = db.add_user(User(name="测试用户"))
+ db.add_exercise(Exercise(date=date(2026, 1, 10), type="跑步", duration=30, calories=200), user_id)
+ db.add_meal(Meal(date=date(2026, 1, 10), meal_type="午餐", description="米饭", calories=500), user_id)
+
+ db.clear_data(user_id, mode="all")
+
+ assert len(db.get_exercises(user_id=user_id)) == 0
+ assert len(db.get_meals(user_id=user_id)) == 0
+
+ def test_clear_data_by_range(self):
+ """测试按时间范围清除"""
+ user_id = db.add_user(User(name="测试用户"))
+ db.add_exercise(Exercise(date=date(2026, 1, 5), type="跑步", duration=30, calories=200), user_id)
+ db.add_exercise(Exercise(date=date(2026, 1, 10), type="跑步", duration=30, calories=200), user_id)
+ db.add_exercise(Exercise(date=date(2026, 1, 15), type="跑步", duration=30, calories=200), user_id)
+
+ db.clear_data(user_id, mode="range", date_from=date(2026, 1, 8), date_to=date(2026, 1, 12))
+
+ exercises = db.get_exercises(user_id=user_id)
+ assert len(exercises) == 2
+ dates = [e.date for e in exercises]
+ assert date(2026, 1, 10) not in dates
+
+ def test_clear_data_by_type(self):
+ """测试按类型清除"""
+ user_id = db.add_user(User(name="测试用户"))
+ db.add_exercise(Exercise(date=date(2026, 1, 10), type="跑步", duration=30, calories=200), user_id)
+ db.add_meal(Meal(date=date(2026, 1, 10), meal_type="午餐", description="米饭", calories=500), user_id)
+
+ db.clear_data(user_id, mode="type", data_types=["exercise"])
+
+ assert len(db.get_exercises(user_id=user_id)) == 0
+ assert len(db.get_meals(user_id=user_id)) == 1
diff --git a/tests/test_deepseek.py b/tests/test_deepseek.py
new file mode 100644
index 0000000..9c72daa
--- /dev/null
+++ b/tests/test_deepseek.py
@@ -0,0 +1,196 @@
+"""DeepSeek Vision API 分析器测试"""
+
+import tempfile
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from vitals.vision.providers.deepseek import DeepSeekVisionAnalyzer, get_deepseek_analyzer
+from vitals.vision.analyzer import get_analyzer, FoodAnalyzer
+
+
+class TestDeepSeekVisionAnalyzer:
+ """DeepSeek Vision 分析器测试"""
+
+ def test_init_with_api_key(self):
+ """测试使用 API Key 初始化"""
+ analyzer = DeepSeekVisionAnalyzer(api_key="test-key")
+ assert analyzer.api_key == "test-key"
+ assert analyzer.base_url == "https://api.deepseek.com/v1"
+
+ def test_init_from_env(self):
+ """测试从环境变量读取 API Key"""
+ with patch.dict("os.environ", {"DEEPSEEK_API_KEY": "env-key"}):
+ analyzer = DeepSeekVisionAnalyzer()
+ assert analyzer.api_key == "env-key"
+
+ def test_init_no_key(self):
+ """测试没有 API Key 时的情况"""
+ with patch.dict("os.environ", {}, clear=True):
+ analyzer = DeepSeekVisionAnalyzer()
+ assert analyzer.api_key is None
+
+ def test_analyze_image_no_api_key(self):
+ """测试没有 API Key 时分析图片应该抛出异常"""
+ with patch.dict("os.environ", {}, clear=True):
+ analyzer = DeepSeekVisionAnalyzer()
+ with pytest.raises(ValueError, match="DEEPSEEK_API_KEY"):
+ analyzer.analyze_image(Path("/fake/image.jpg"))
+
+ def test_analyze_text_no_api_key(self):
+ """测试没有 API Key 时分析文字应该抛出异常"""
+ with patch.dict("os.environ", {}, clear=True):
+ analyzer = DeepSeekVisionAnalyzer()
+ with pytest.raises(ValueError, match="DEEPSEEK_API_KEY"):
+ analyzer.analyze_text("一碗米饭")
+
+ @patch("httpx.Client")
+ def test_analyze_text_success(self, mock_client_class):
+ """测试文字分析成功"""
+ # 模拟 API 响应
+ mock_response = MagicMock()
+ mock_response.json.return_value = {
+ "choices": [
+ {
+ "message": {
+ "content": "一碗米饭+两个鸡蛋"
+ }
+ }
+ ]
+ }
+ mock_response.raise_for_status = MagicMock()
+
+ mock_client = MagicMock()
+ mock_client.post.return_value = mock_response
+ mock_client.__enter__ = MagicMock(return_value=mock_client)
+ mock_client.__exit__ = MagicMock(return_value=False)
+ mock_client_class.return_value = mock_client
+
+ analyzer = DeepSeekVisionAnalyzer(api_key="test-key")
+ result = analyzer.analyze_text("今天吃了一碗米饭和两个鸡蛋")
+
+ assert "description" in result
+ assert "total_calories" in result
+ assert result["provider"] == "deepseek"
+ assert result["original_input"] == "今天吃了一碗米饭和两个鸡蛋"
+
+ @patch("httpx.Client")
+ def test_analyze_image_success(self, mock_client_class):
+ """测试图片分析成功"""
+ # 模拟 API 响应
+ mock_response = MagicMock()
+ mock_response.json.return_value = {
+ "choices": [
+ {
+ "message": {
+ "content": "米饭+红烧肉+西兰花"
+ }
+ }
+ ]
+ }
+ mock_response.raise_for_status = MagicMock()
+
+ mock_client = MagicMock()
+ mock_client.post.return_value = mock_response
+ mock_client.__enter__ = MagicMock(return_value=mock_client)
+ mock_client.__exit__ = MagicMock(return_value=False)
+ mock_client_class.return_value = mock_client
+
+ # 创建临时图片文件
+ with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as f:
+ f.write(b"fake image data")
+ tmp_path = Path(f.name)
+
+ try:
+ analyzer = DeepSeekVisionAnalyzer(api_key="test-key")
+ result = analyzer.analyze_image(tmp_path)
+
+ assert "description" in result
+ assert "total_calories" in result
+ assert result["provider"] == "deepseek"
+ finally:
+ tmp_path.unlink(missing_ok=True)
+
+ def test_encode_image(self):
+ """测试图片编码"""
+ with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as f:
+ f.write(b"test data")
+ tmp_path = Path(f.name)
+
+ try:
+ analyzer = DeepSeekVisionAnalyzer(api_key="test-key")
+ encoded = analyzer._encode_image(tmp_path)
+ assert encoded == "dGVzdCBkYXRh" # base64 of "test data"
+ finally:
+ tmp_path.unlink(missing_ok=True)
+
+ def test_get_media_type(self):
+ """测试 MIME 类型获取"""
+ analyzer = DeepSeekVisionAnalyzer(api_key="test-key")
+
+ assert analyzer._get_media_type(Path("test.jpg")) == "image/jpeg"
+ assert analyzer._get_media_type(Path("test.jpeg")) == "image/jpeg"
+ assert analyzer._get_media_type(Path("test.png")) == "image/png"
+ assert analyzer._get_media_type(Path("test.gif")) == "image/gif"
+ assert analyzer._get_media_type(Path("test.webp")) == "image/webp"
+ assert analyzer._get_media_type(Path("test.unknown")) == "image/jpeg"
+
+
+class TestGetDeepSeekAnalyzer:
+ """测试 get_deepseek_analyzer 工厂函数"""
+
+ def test_get_analyzer(self):
+ """测试获取分析器"""
+ analyzer = get_deepseek_analyzer(api_key="test-key")
+ assert isinstance(analyzer, DeepSeekVisionAnalyzer)
+ assert analyzer.api_key == "test-key"
+
+
+class TestGetAnalyzerFactory:
+ """测试 analyzer.py 中的 get_analyzer 工厂函数"""
+
+ def test_get_deepseek_analyzer(self):
+ """测试获取 DeepSeek 分析器"""
+ with patch.dict("os.environ", {"DEEPSEEK_API_KEY": "test-key"}):
+ analyzer = get_analyzer(provider="deepseek")
+ assert isinstance(analyzer, DeepSeekVisionAnalyzer)
+
+ def test_get_claude_analyzer(self):
+ """测试获取 Claude 分析器"""
+ from vitals.vision.analyzer import ClaudeFoodAnalyzer
+ analyzer = get_analyzer(provider="claude", api_key="test-key")
+ assert isinstance(analyzer, ClaudeFoodAnalyzer)
+
+ def test_get_local_analyzer(self):
+ """测试获取本地分析器"""
+ from vitals.vision.analyzer import LocalFoodAnalyzer
+ analyzer = get_analyzer(provider="local")
+ assert isinstance(analyzer, LocalFoodAnalyzer)
+
+ def test_backward_compatibility(self):
+ """测试向后兼容 use_claude 参数"""
+ from vitals.vision.analyzer import ClaudeFoodAnalyzer
+ analyzer = get_analyzer(use_claude=True, api_key="test-key")
+ assert isinstance(analyzer, ClaudeFoodAnalyzer)
+
+ def test_default_provider(self):
+ """测试默认使用 DeepSeek"""
+ with patch.dict("os.environ", {"DEEPSEEK_API_KEY": "test-key"}):
+ analyzer = get_analyzer()
+ assert isinstance(analyzer, DeepSeekVisionAnalyzer)
+
+
+class TestLocalFoodAnalyzer:
+ """测试本地分析器"""
+
+ def test_analyze_returns_empty(self):
+ """测试本地分析器返回空结果"""
+ from vitals.vision.analyzer import LocalFoodAnalyzer
+
+ analyzer = LocalFoodAnalyzer()
+ result = analyzer.analyze(Path("/fake/image.jpg"))
+
+ assert result["description"] == ""
+ assert result["total_calories"] == 0
+ assert "note" in result
diff --git a/tests/test_export.py b/tests/test_export.py
new file mode 100644
index 0000000..cfbd814
--- /dev/null
+++ b/tests/test_export.py
@@ -0,0 +1,56 @@
+"""数据导出/导入测试"""
+
+from datetime import date
+import json
+
+from src.vitals.core import database as db
+from src.vitals.core.export import export_all_data_json, export_to_csv, import_from_json
+from src.vitals.core.models import Exercise, Meal, Sleep, Weight, UserConfig
+
+
+def test_export_all_data_json(tmp_path):
+ db.save_config(UserConfig(age=28, gender="male", height=175.0, weight=72.0))
+ db.add_exercise(Exercise(date=date(2026, 1, 18), type="跑步", duration=30, calories=240))
+ db.add_meal(Meal(date=date(2026, 1, 18), meal_type="午餐", description="米饭+鸡蛋", calories=400))
+ db.add_sleep(Sleep(date=date(2026, 1, 18), duration=7.5, quality=4))
+ db.add_weight(Weight(date=date(2026, 1, 18), weight_kg=72.5))
+
+ out = tmp_path / "export.json"
+ export_all_data_json(out)
+
+ assert out.exists()
+ data = json.loads(out.read_text(encoding="utf-8"))
+ assert data["version"] == "1.0"
+ assert "exercises" in data and len(data["exercises"]) == 1
+ assert "meals" in data and len(data["meals"]) == 1
+ assert "sleep" in data and len(data["sleep"]) == 1
+ assert "weight" in data and len(data["weight"]) == 1
+ assert data["config"]["age"] == 28
+
+
+def test_export_to_csv_exercise(tmp_path):
+ db.add_exercise(Exercise(date=date(2026, 1, 18), type="跑步", duration=30, calories=240))
+
+ out = tmp_path / "exercise.csv"
+ export_to_csv("exercise", out)
+
+ assert out.exists()
+ content = out.read_text(encoding="utf-8")
+ assert "date,type,duration,calories" in content
+ assert "2026-01-18" in content
+
+
+def test_import_from_json_roundtrip(tmp_path):
+ # 先写入数据并导出
+ db.save_config(UserConfig(age=28, gender="male", height=175.0, weight=72.0))
+ db.add_exercise(Exercise(date=date(2026, 1, 18), type="跑步", duration=30, calories=240))
+ db.add_weight(Weight(date=date(2026, 1, 18), weight_kg=72.5))
+
+ out = tmp_path / "export.json"
+ export_all_data_json(out)
+
+ # 新的临时 DB 会在 conftest.py 中自动创建，这里直接导入并验证统计
+ stats = import_from_json(out)
+ assert stats["exercise"] >= 1
+ assert stats["weight"] >= 1
+
diff --git a/tests/test_models.py b/tests/test_models.py
new file mode 100644
index 0000000..2b3923e
--- /dev/null
+++ b/tests/test_models.py
@@ -0,0 +1,267 @@
+"""数据模型测试"""
+
+from datetime import date, time
+
+import pytest
+
+from src.vitals.core.models import (
+ Exercise,
+ Meal,
+ Sleep,
+ Weight,
+ UserConfig,
+ MealType,
+ ExerciseType,
+ ActivityLevel,
+ Goal,
+ User,
+ DataClearRequest,
+)
+
+
+class TestExercise:
+ """运动记录模型测试"""
+
+ def test_create_exercise(self):
+ """测试创建运动记录"""
+ exercise = Exercise(
+ date=date(2026, 1, 18),
+ type="跑步",
+ duration=30,
+ calories=240,
+ )
+ assert exercise.type == "跑步"
+ assert exercise.duration == 30
+ assert exercise.calories == 240
+
+ def test_exercise_to_dict(self, sample_exercise):
+ """测试转换为字典"""
+ data = sample_exercise.to_dict()
+ assert data["type"] == "跑步"
+ assert data["duration"] == 30
+ assert data["distance"] == 5.0
+ assert data["date"] == "2026-01-18"
+
+ def test_exercise_default_values(self):
+ """测试默认值"""
+ exercise = Exercise()
+ assert exercise.duration == 0
+ assert exercise.calories == 0
+ assert exercise.source == "手动"
+
+
+class TestMeal:
+ """饮食记录模型测试"""
+
+ def test_create_meal(self):
+ """测试创建饮食记录"""
+ meal = Meal(
+ meal_type="早餐",
+ description="燕麦+鸡蛋",
+ calories=350,
+ )
+ assert meal.meal_type == "早餐"
+ assert meal.calories == 350
+
+ def test_meal_to_dict(self, sample_meal):
+ """测试转换为字典"""
+ data = sample_meal.to_dict()
+ assert data["meal_type"] == "午餐"
+ assert data["calories"] == 650
+ assert data["protein"] == 25.0
+
+ def test_meal_with_food_items(self):
+ """测试带食物条目的饮食记录"""
+ meal = Meal(
+ meal_type="午餐",
+ description="测试",
+ food_items=[{"name": "米饭", "calories": 200}],
+ )
+ data = meal.to_dict()
+ assert "米饭" in data["food_items"]
+
+
+class TestSleep:
+ """睡眠记录模型测试"""
+
+ def test_create_sleep(self):
+ """测试创建睡眠记录"""
+ sleep = Sleep(
+ bedtime=time(23, 0),
+ wake_time=time(7, 0),
+ duration=8.0,
+ quality=4,
+ )
+ assert sleep.duration == 8.0
+ assert sleep.quality == 4
+
+ def test_sleep_to_dict(self, sample_sleep):
+ """测试转换为字典"""
+ data = sample_sleep.to_dict()
+ assert data["duration"] == 7.5
+ assert data["quality"] == 4
+ assert data["bedtime"] == "23:30:00"
+
+
+class TestWeight:
+ """体重记录模型测试"""
+
+ def test_create_weight(self):
+ """测试创建体重记录"""
+ weight = Weight(weight_kg=72.5)
+ assert weight.weight_kg == 72.5
+
+ def test_weight_to_dict(self, sample_weight):
+ """测试转换为字典"""
+ data = sample_weight.to_dict()
+ assert data["weight_kg"] == 72.5
+ assert data["body_fat_pct"] == 18.5
+
+
+class TestUserConfig:
+ """用户配置模型测试"""
+
+ def test_bmr_calculation_male(self):
+ """测试男性 BMR 计算"""
+ config = UserConfig(
+ age=28,
+ gender="male",
+ height=175.0,
+ weight=72.0,
+ )
+ # Mifflin-St Jeor: 10 * 72 + 6.25 * 175 - 5 * 28 + 5 = 1678
+ assert config.bmr == 1678
+
+ def test_bmr_calculation_female(self):
+ """测试女性 BMR 计算"""
+ config = UserConfig(
+ age=25,
+ gender="female",
+ height=165.0,
+ weight=55.0,
+ )
+ # Mifflin-St Jeor: 10 * 55 + 6.25 * 165 - 5 * 25 - 161 = 1295
+ assert config.bmr == 1295
+
+ def test_bmr_none_when_incomplete(self):
+ """测试不完整时 BMR 为 None"""
+ config = UserConfig(age=28)
+ assert config.bmr is None
+
+ def test_tdee_calculation(self, sample_config):
+ """测试 TDEE 计算"""
+ # BMR * 1.55 (moderate)
+ expected_tdee = int(sample_config.bmr * 1.55)
+ assert sample_config.tdee == expected_tdee
+
+ def test_tdee_different_activity_levels(self):
+ """测试不同活动水平的 TDEE"""
+ base_config = {
+ "age": 30,
+ "gender": "male",
+ "height": 175.0,
+ "weight": 70.0,
+ }
+
+ sedentary = UserConfig(**base_config, activity_level="sedentary")
+ active = UserConfig(**base_config, activity_level="active")
+
+ assert sedentary.tdee < active.tdee
+
+ def test_config_to_dict(self, sample_config):
+ """测试转换为字典"""
+ data = sample_config.to_dict()
+ assert data["age"] == 28
+ assert data["gender"] == "male"
+ assert data["bmr"] is not None
+ assert data["tdee"] is not None
+
+
+class TestEnums:
+ """枚举类型测试"""
+
+ def test_meal_type_values(self):
+ """测试餐次类型"""
+ assert MealType.BREAKFAST.value == "早餐"
+ assert MealType.LUNCH.value == "午餐"
+ assert MealType.DINNER.value == "晚餐"
+ assert MealType.SNACK.value == "加餐"
+
+ def test_exercise_type_values(self):
+ """测试运动类型"""
+ assert ExerciseType.RUNNING.value == "跑步"
+ assert ExerciseType.SWIMMING.value == "游泳"
+
+ def test_activity_level_values(self):
+ """测试活动水平"""
+ assert ActivityLevel.SEDENTARY.value == "sedentary"
+ assert ActivityLevel.MODERATE.value == "moderate"
+
+ def test_goal_values(self):
+ """测试目标"""
+ assert Goal.LOSE.value == "lose"
+ assert Goal.MAINTAIN.value == "maintain"
+ assert Goal.GAIN.value == "gain"
+
+
+class TestUser:
+ """用户模型测试"""
+
+ def test_user_creation(self):
+ """测试创建用户"""
+ from datetime import datetime
+ user = User(
+ name="小明",
+ created_at=datetime.now(),
+ )
+ assert user.name == "小明"
+ assert user.is_active == False
+ assert user.id is None
+
+ def test_user_to_dict(self):
+ """测试用户转换为字典"""
+ from datetime import datetime
+ user = User(
+ id=1,
+ name="小红",
+ created_at=datetime(2026, 1, 19, 10, 0, 0),
+ is_active=True,
+ )
+ d = user.to_dict()
+ assert d["id"] == 1
+ assert d["name"] == "小红"
+ assert d["is_active"] == True
+ assert "created_at" in d
+
+
+class TestDataClearRequest:
+ """数据清除请求模型测试"""
+
+ def test_clear_by_range(self):
+ """测试按时间范围清除"""
+ req = DataClearRequest(
+ user_id=1,
+ mode="range",
+ date_from=date(2026, 1, 1),
+ date_to=date(2026, 1, 15),
+ )
+ assert req.mode == "range"
+ assert req.date_from == date(2026, 1, 1)
+
+ def test_clear_by_type(self):
+ """测试按类型清除"""
+ req = DataClearRequest(
+ user_id=1,
+ mode="type",
+ data_types=["exercise", "meal"],
+ )
+ assert req.mode == "type"
+ assert "exercise" in req.data_types
+
+ def test_clear_all(self):
+ """测试清除全部"""
+ req = DataClearRequest(
+ user_id=1,
+ mode="all",
+ )
+ assert req.mode == "all"
diff --git a/tests/test_report.py b/tests/test_report.py
new file mode 100644
index 0000000..0072dc7
--- /dev/null
+++ b/tests/test_report.py
@@ -0,0 +1,298 @@
+"""报告生成测试"""
+
+from datetime import date, time, timedelta
+from pathlib import Path
+
+import pytest
+
+from src.vitals.core import database as db
+from src.vitals.core.models import Exercise, Meal, Sleep, Weight, UserConfig
+from src.vitals.core.report import (
+ generate_weekly_report,
+ generate_monthly_report,
+ render_weekly_report_terminal,
+ render_weekly_report_markdown,
+ render_weekly_report_html,
+ export_report,
+)
+
+
+@pytest.fixture
+def populated_db():
+ """填充测试数据"""
+ today = date.today()
+
+ # 添加用户配置
+ config = UserConfig(
+ age=28, gender="male", height=175.0, weight=72.0,
+ activity_level="moderate", goal="lose",
+ )
+ db.save_config(config)
+
+ # 添加本周数据
+ for i in range(7):
+ day = today - timedelta(days=today.weekday()) + timedelta(days=i)
+
+ # 运动
+ if i % 2 == 0:
+ db.add_exercise(Exercise(
+ date=day, type="跑步", duration=30, calories=240,
+ ))
+
+ # 饮食
+ db.add_meal(Meal(
+ date=day, meal_type="午餐",
+ description="米饭+鸡肉", calories=500,
+ ))
+
+ # 睡眠
+ db.add_sleep(Sleep(
+ date=day, duration=7.0 + i * 0.1, quality=3 + (i % 3),
+ ))
+
+ # 体重
+ db.add_weight(Weight(
+ date=day, weight_kg=72.0 - i * 0.1,
+ ))
+
+ return today
+
+
+class TestGenerateWeeklyReport:
+ """周报生成测试"""
+
+ def test_generate_report(self, populated_db):
+ """测试生成周报"""
+ report = generate_weekly_report()
+
+ assert report is not None
+ assert report.exercise_count > 0
+ assert report.exercise_duration > 0
+
+ def test_report_date_range(self, populated_db):
+ """测试日期范围"""
+ report = generate_weekly_report()
+
+ # 本周应该是周一到周日
+ assert report.end_date - report.start_date == timedelta(days=6)
+ assert report.start_date.weekday() == 0 # 周一
+
+ def test_report_exercise_stats(self, populated_db):
+ """测试运动统计"""
+ report = generate_weekly_report()
+
+ assert report.exercise_count > 0
+ assert report.exercise_duration > 0
+ assert report.exercise_calories > 0
+ assert "跑步" in report.exercise_types
+
+ def test_report_sleep_stats(self, populated_db):
+ """测试睡眠统计"""
+ report = generate_weekly_report()
+
+ assert report.avg_sleep_duration > 0
+ assert 1 <= report.avg_sleep_quality <= 5
+
+ def test_report_weight_stats(self, populated_db):
+ """测试体重统计"""
+ report = generate_weekly_report()
+
+ assert report.weight_start is not None
+ assert report.weight_end is not None
+ assert report.weight_change is not None
+
+ def test_report_daily_stats(self, populated_db):
+ """测试每日统计"""
+ report = generate_weekly_report()
+
+ assert len(report.daily_stats) == 7
+ for stat in report.daily_stats:
+ assert stat.weekday in ["周一", "周二", "周三", "周四", "周五", "周六", "周日"]
+
+ def test_report_with_custom_date(self, populated_db):
+ """测试指定日期"""
+ report = generate_weekly_report(date(2026, 1, 15))
+
+ # 2026-01-15 是周四, 那周的周一是 01-12
+ assert report.start_date == date(2026, 1, 12)
+ assert report.end_date == date(2026, 1, 18)
+
+
+class TestGenerateMonthlyReport:
+ """月报生成测试"""
+
+ def test_generate_report(self, populated_db):
+ """测试生成月报"""
+ report = generate_monthly_report()
+
+ assert report is not None
+ assert report.year > 0
+ assert 1 <= report.month <= 12
+
+ def test_report_date_range(self, populated_db):
+ """测试日期范围"""
+ report = generate_monthly_report(2026, 1)
+
+ assert report.start_date == date(2026, 1, 1)
+ assert report.end_date == date(2026, 1, 31)
+
+ def test_report_exercise_stats(self, populated_db):
+ """测试运动统计"""
+ report = generate_monthly_report()
+
+ assert report.exercise_count >= 0
+ assert report.exercise_days >= 0
+
+ def test_report_weekly_summaries(self, populated_db):
+ """测试周汇总"""
+ report = generate_monthly_report()
+
+ assert len(report.weekly_summaries) > 0
+ for week in report.weekly_summaries:
+ assert "week" in week
+ assert "exercise_duration" in week
+
+ def test_report_with_custom_month(self):
+ """测试指定月份"""
+ report = generate_monthly_report(2025, 6)
+
+ assert report.year == 2025
+ assert report.month == 6
+
+
+class TestRenderWeeklyReportTerminal:
+ """终端渲染测试"""
+
+ def test_render_contains_sections(self, populated_db):
+ """测试包含各部分"""
+ report = generate_weekly_report()
+ output = render_weekly_report_terminal(report)
+
+ assert "运动" in output
+ assert "睡眠" in output
+ assert "饮食" in output
+ assert "体重" in output
+ assert "每日明细" in output
+
+ def test_render_contains_stats(self, populated_db):
+ """测试包含统计数据"""
+ report = generate_weekly_report()
+ output = render_weekly_report_terminal(report)
+
+ assert "分钟" in output
+ assert "卡" in output
+
+
+class TestRenderWeeklyReportMarkdown:
+ """Markdown 渲染测试"""
+
+ def test_render_is_valid_markdown(self, populated_db):
+ """测试是有效的 Markdown"""
+ report = generate_weekly_report()
+ output = render_weekly_report_markdown(report)
+
+ assert output.startswith("# ")
+ assert "## " in output
+ assert "| " in output # 表格
+
+ def test_render_contains_sections(self, populated_db):
+ """测试包含各部分"""
+ report = generate_weekly_report()
+ output = render_weekly_report_markdown(report)
+
+ assert "## 运动" in output
+ assert "## 睡眠" in output
+ assert "## 饮食" in output
+ assert "## 体重" in output
+
+
+class TestRenderWeeklyReportHtml:
+ """HTML 渲染测试"""
+
+ def test_render_is_valid_html(self, populated_db):
+ """测试是有效的 HTML"""
+ report = generate_weekly_report()
+ output = render_weekly_report_html(report)
+
+ assert "" in output
+ assert "系统设置
+管理用户档案和数据
+
+
+
+
+ 个人信息
+编辑当前激活用户的基本信息，BMI 将根据身高和体重自动计算
+ + +
+
+
+
+ 用户管理
+ +
+
+
+
+ 加载中...
+
+
+
+
+
+
+
+
+ 数据管理
+ + +
+
+
+
+
+
+
+
+