Skip to content

P
performance-score
Commit fc18dcb0 by Performance System
Options

fix:1

parent eb34b9e8
Pipeline #3214 failed with stage
in 2 minutes 9 seconds
Showing with 2907 additions and 758 deletions
.env
# 前端环境变量配置
# API 服务地址
# API 服务地址 - 直接指向后端服务
VITE_API_BASE_URL=http://localhost:8000
# 应用配置
......
.gitlab-ci.yml
......@@ -26,7 +26,7 @@ deploy_to_production:
cd performance-score
git pull origin master
docker compose up -d --build
echo '🚀 部署流程执行完毕！！！'
echo '� 部署流程执行完毕！！！'
"
only:
......
backend/check_table_structure.py 0 → 100644
#!/usr/bin/env python3
"""
检查数据库表结构脚本
"""
import asyncio
from sqlalchemy import text
from database import database
import logging
# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
async def check_table_structure():
"""检查 monthly_history 表结构"""
try:
# 连接数据库
await database.connect()
logger.info("已连接到数据库")
# 查询表结构
query = text("""
SELECT column_name, data_type, is_nullable
FROM information_schema.columns
WHERE table_name = 'monthly_history'
ORDER BY ordinal_position;
""")
result = await database.fetch_all(query)
logger.info("monthly_history 表结构:")
logger.info("-" * 50)
for row in result:
logger.info(f"列名: {row['column_name']}, 类型: {row['data_type']}, 可空: {row['is_nullable']}")
# 检查是否存在 institutions_data 列
institutions_data_exists = any(row['column_name'] == 'institutions_data' for row in result)
if institutions_data_exists:
logger.info("✅ institutions_data 列存在")
else:
logger.error("❌ institutions_data 列不存在")
# 尝试添加列
logger.info("正在尝试添加 institutions_data 列...")
alter_query = text("""
ALTER TABLE monthly_history
ADD COLUMN institutions_data JSONB;
""")
await database.execute(alter_query)
logger.info("✅ 成功添加 institutions_data 列")
await database.disconnect()
logger.info("数据库连接已关闭")
except Exception as e:
logger.error(f"❌ 检查表结构失败: {e}")
raise
if __name__ == "__main__":
asyncio.run(check_table_structure())
backend/config.py
......@@ -38,15 +38,7 @@ class Settings(BaseSettings):
# CORS 配置
CORS_ORIGINS: List[str] = [
"http://localhost:5173", # Vite 开发服务器
"http://localhost:3000", # React 开发服务器
"http://localhost:4001", # Docker 前端
"http://localhost:4003", # 其他前端
"http://localhost:8080", # 生产环境前端
"http://127.0.0.1:3000",
"http://127.0.0.1:4001",
"http://127.0.0.1:4003",
"http://127.0.0.1:8080",
"*", # 开发环境允许所有来源
]
# WebSocket 配置
......
backend/database.py
......@@ -80,6 +80,7 @@ monthly_history_table = Table(
Column("total_institutions", Integer, nullable=False),
Column("total_images", Integer, nullable=False),
Column("user_stats", JSONB, nullable=False),
Column("institutions_data", JSONB, nullable=True), # 新增：存储完整的机构和图片数据
Column("created_at", TIMESTAMP(timezone=True), server_default=func.now()),
)
......@@ -122,7 +123,7 @@ class DatabaseManager:
logger.error(f"批量数据库操作失败: {e}")
raise
async def transaction(self):
def transaction(self):
"""创建数据库事务"""
return self.database.transaction()
......@@ -168,7 +169,7 @@ async def insert_default_data():
admin_exists = await database.fetch_one(
users_table.select().where(users_table.c.id == "admin")
)
if not admin_exists:
# 插入默认管理员用户
await database.execute(
......@@ -182,6 +183,15 @@ async def insert_default_data():
)
)
logger.info("✅ 默认管理员用户创建成功")
else:
# 检查管理员用户密码是否为空，如果为空则设置默认密码
if not admin_exists["password"]:
await database.execute(
users_table.update().where(users_table.c.id == "admin").values(
password="admin123"
)
)
logger.info("✅ 管理员用户密码已修复")
# 检查并插入默认系统配置
config_items = [
......
backend/main.py
......@@ -17,6 +17,7 @@ from loguru import logger
from database import database, engine, metadata
from config import settings
from routers import users, institutions, system_config, history, migration
from scheduler import monthly_scheduler
@asynccontextmanager
......@@ -32,11 +33,50 @@ async def lifespan(app: FastAPI):
# 创建表结构（如果不存在）
metadata.create_all(engine)
logger.info("✅ 数据库表结构检查完成")
# 执行数据库迁移
try:
from migrations.loader import load_migrations
from migrations.manager import migration_manager
# 加载迁移文件
migration_count = load_migrations()
logger.info(f"✅ 加载了 {migration_count} 个迁移文件")
# 执行迁移
migration_result = await migration_manager.migrate_to_latest()
if migration_result["success"]:
if migration_result["executed_migrations"] > 0:
logger.info(f"🎉 数据库迁移完成！执行了 {migration_result['executed_migrations']} 个迁移")
else:
logger.info("✅ 数据库已是最新版本，无需迁移")
else:
logger.error("❌ 数据库迁移失败")
logger.error(f"失败的迁移: {migration_result.get('failed_migrations', [])}")
# 在生产环境中，可以选择是否继续启动应用
# 这里我们记录错误但继续启动，让管理员可以通过API手动处理
except Exception as e:
logger.error(f"数据库迁移过程异常: {e}")
logger.error("应用将继续启动，但建议检查迁移状态")
# 插入默认数据
from database import insert_default_data
await insert_default_data()
logger.info("✅ 默认数据初始化完成")
# 启动定时任务调度器
await monthly_scheduler.start()
yield
# 关闭时执行
logger.info("🔄 正在关闭 API 服务")
# 停止定时任务调度器
await monthly_scheduler.stop()
await database.disconnect()
logger.info("✅ 数据库连接已关闭")
......
backend/migrate.py 0 → 100644
#!/usr/bin/env python3
"""
独立的数据库迁移工具脚本
可以在容器外或CI/CD中使用，不依赖FastAPI应用
使用方法:
python migrate.py # 执行所有待执行的迁移
python migrate.py --status # 查看迁移状态
python migrate.py --version # 查看当前版本
python migrate.py --reload # 重新加载迁移文件
python migrate.py --help # 显示帮助信息
环境变量:
DATABASE_URL: 数据库连接URL
MIGRATION_LOG_LEVEL: 日志级别 (DEBUG, INFO, WARNING, ERROR)
"""
import asyncio
import sys
import argparse
import os
from pathlib import Path
from loguru import logger
# 添加项目根目录到Python路径
sys.path.insert(0, str(Path(__file__).parent))
def setup_logging(level: str = "INFO"):
"""设置日志配置"""
logger.remove() # 移除默认处理器
# 添加控制台输出
logger.add(
sys.stdout,
level=level,
format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",
colorize=True
)
# 添加文件输出
logger.add(
"logs/migration.log",
level=level,
format="{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {name}:{function}:{line} - {message}",
rotation="10 MB",
retention="30 days",
compression="zip"
)
async def show_migration_status():
"""显示迁移状态"""
try:
from migrations.manager import migration_manager
from migrations.loader import load_migrations
# 加载迁移
migration_count = load_migrations()
logger.info(f"加载了 {migration_count} 个迁移文件")
# 获取状态
status = await migration_manager.get_migration_status()
print("\n" + "="*60)
print("📊 数据库迁移状态")
print("="*60)
print(f"总迁移数量: {status['total_migrations']}")
print(f"已执行数量: {status['executed_count']}")
print(f"待执行数量: {status['pending_count']}")
print(f"是否最新版本: {'✅ 是' if status['is_up_to_date'] else '❌ 否'}")
if status['executed_migrations']:
print(f"\n已执行的迁移:")
for version in status['executed_migrations']:
print(f" ✅ {version}")
if status['pending_migrations']:
print(f"\n待执行的迁移:")
for migration in status['pending_migrations']:
print(f" ⏳ {migration['version']}: {migration['description']}")
print("="*60)
except Exception as e:
logger.error(f"获取迁移状态失败: {e}")
sys.exit(1)
async def show_current_version():
"""显示当前版本"""
try:
from migrations.manager import migration_manager
executed_migrations = await migration_manager.get_executed_migrations()
current_version = executed_migrations[-1] if executed_migrations else "0.0.0"
print(f"\n当前数据库schema版本: {current_version}")
print(f"已执行迁移数量: {len(executed_migrations)}")
except Exception as e:
logger.error(f"获取当前版本失败: {e}")
sys.exit(1)
async def execute_migrations():
"""执行迁移"""
try:
from migrations.loader import load_migrations
from migrations.manager import migration_manager
logger.info("🚀 开始独立迁移过程")
# 加载迁移
migration_count = load_migrations()
logger.info(f"✅ 加载了 {migration_count} 个迁移")
# 执行迁移
result = await migration_manager.migrate_to_latest()
if result["success"]:
if result["executed_migrations"] > 0:
logger.info("🎉 迁移完成！")
print(f"\n✅ 成功执行 {result['executed_migrations']} 个迁移")
print(f"📋 总待执行迁移: {result.get('total_pending', 0)}")
else:
logger.info("✅ 数据库已是最新版本")
print("\n✅ 数据库已是最新版本，无需迁移")
else:
logger.error("❌ 迁移失败！")
print(f"\n❌ 失败的迁移: {result.get('failed_migrations', [])}")
print(f"❌ 错误信息: {result.get('message', '未知错误')}")
sys.exit(1)
except Exception as e:
logger.error(f"迁移过程异常: {e}")
print(f"\n❌ 迁移异常: {e}")
sys.exit(1)
async def reload_migrations():
"""重新加载迁移文件"""
try:
from migrations.loader import reload_migrations
logger.info("🔄 重新加载迁移文件")
migration_count = reload_migrations()
print(f"\n✅ 成功重新加载 {migration_count} 个迁移文件")
except Exception as e:
logger.error(f"重新加载迁移文件失败: {e}")
sys.exit(1)
async def main():
"""主函数"""
parser = argparse.ArgumentParser(
description="数据库迁移工具",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
示例:
python migrate.py # 执行所有待执行的迁移
python migrate.py --status # 查看迁移状态
python migrate.py --version # 查看当前版本
python migrate.py --reload # 重新加载迁移文件
环境变量:
DATABASE_URL: 数据库连接URL
MIGRATION_LOG_LEVEL: 日志级别 (DEBUG, INFO, WARNING, ERROR)
"""
)
parser.add_argument(
"--status",
action="store_true",
help="显示迁移状态"
)
parser.add_argument(
"--version",
action="store_true",
help="显示当前数据库schema版本"
)
parser.add_argument(
"--reload",
action="store_true",
help="重新加载迁移文件"
)
parser.add_argument(
"--log-level",
default=os.getenv("MIGRATION_LOG_LEVEL", "INFO"),
choices=["DEBUG", "INFO", "WARNING", "ERROR"],
help="日志级别"
)
args = parser.parse_args()
# 设置日志
setup_logging(args.log_level)
try:
# 连接数据库
from database import database
await database.connect()
logger.info("✅ 数据库连接成功")
# 根据参数执行相应操作
if args.status:
await show_migration_status()
elif args.version:
await show_current_version()
elif args.reload:
await reload_migrations()
else:
# 默认执行迁移
await execute_migrations()
except Exception as e:
logger.error(f"程序执行异常: {e}")
print(f"\n❌ 程序异常: {e}")
sys.exit(1)
finally:
try:
from database import database
await database.disconnect()
logger.info("✅ 数据库连接已关闭")
except:
pass
if __name__ == "__main__":
# 确保logs目录存在
Path("logs").mkdir(exist_ok=True)
# 运行主函数
asyncio.run(main())
backend/migrate_add_institutions_data.py 0 → 100644
#!/usr/bin/env python3
"""
数据库迁移脚本：为 monthly_history 表添加 institutions_data 列
"""
import asyncio
from sqlalchemy import text
from database import database, engine
import logging
# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
async def migrate_database():
"""执行数据库迁移"""
try:
# 连接数据库
await database.connect()
logger.info("已连接到数据库")
# 检查列是否已存在
check_column_query = text("""
SELECT column_name
FROM information_schema.columns
WHERE table_name = 'monthly_history'
AND column_name = 'institutions_data';
""")
result = await database.fetch_all(check_column_query)
if result:
logger.info("institutions_data 列已存在，无需迁移")
else:
# 添加 institutions_data 列
alter_query = text("""
ALTER TABLE monthly_history
ADD COLUMN institutions_data JSONB;
""")
await database.execute(alter_query)
logger.info("✅ 成功添加 institutions_data 列")
# 验证列是否添加成功
verify_result = await database.fetch_all(check_column_query)
if verify_result:
logger.info("✅ 验证成功：institutions_data 列已添加")
else:
logger.error("❌ 验证失败：institutions_data 列未添加")
await database.disconnect()
logger.info("数据库连接已关闭")
except Exception as e:
logger.error(f"❌ 数据库迁移失败: {e}")
raise
if __name__ == "__main__":
asyncio.run(migrate_database())
backend/migrations/__init__.py 0 → 100644
"""
数据库迁移系统
提供安全的数据库schema更新机制
特性:
- 事务保护：所有迁移在事务中执行
- 验证机制：迁移前后都有验证步骤
- 回滚支持：每个迁移都有对应的回滚方法
- 备份点：迁移前自动创建备份点记录
- 原子性：迁移要么全部成功，要么全部失败
- 版本跟踪：精确记录每个迁移的执行状态
"""
__version__ = "1.0.0"
__author__ = "Performance System Team"
from .base import Migration, MigrationError
from .manager import MigrationManager, migration_manager
__all__ = [
"Migration",
"MigrationError",
"MigrationManager",
"migration_manager"
]
backend/migrations/base.py 0 → 100644
"""
迁移基础类和工具
提供迁移系统的核心抽象类和异常定义
"""
import asyncio
from abc import ABC, abstractmethod
from typing import Optional, Dict, Any, List
from datetime import datetime
from sqlalchemy import text
from loguru import logger
import json
class MigrationError(Exception):
"""迁移异常类"""
def __init__(self, message: str, migration_version: str = None, original_error: Exception = None):
self.message = message
self.migration_version = migration_version
self.original_error = original_error
super().__init__(self.message)
def __str__(self):
if self.migration_version:
return f"Migration {self.migration_version}: {self.message}"
return self.message
class Migration(ABC):
"""迁移基础抽象类
所有具体的迁移都应该继承这个类并实现必要的方法
"""
def __init__(self, version: str, description: str, dependencies: List[str] = None):
"""
初始化迁移
Args:
version: 迁移版本号，建议使用语义化版本号如 "1.0.1"
description: 迁移描述，简要说明这个迁移做了什么
dependencies: 依赖的迁移版本列表，确保迁移顺序正确
"""
self.version = version
self.description = description
self.dependencies = dependencies or []
self.executed_at: Optional[datetime] = None
self.execution_time: Optional[float] = None
# 验证版本号格式
if not version or not isinstance(version, str):
raise MigrationError("迁移版本号不能为空且必须是字符串")
# 验证描述
if not description or not isinstance(description, str):
raise MigrationError("迁移描述不能为空且必须是字符串")
@abstractmethod
async def up(self, db) -> bool:
"""
执行迁移 - 必须实现
Args:
db: 数据库管理器实例
Returns:
bool: 迁移是否成功执行
Raises:
MigrationError: 迁移执行失败时抛出
"""
pass
@abstractmethod
async def down(self, db) -> bool:
"""
回滚迁移 - 必须实现
Args:
db: 数据库管理器实例
Returns:
bool: 回滚是否成功执行
Raises:
MigrationError: 回滚执行失败时抛出
"""
pass
async def validate_before_up(self, db) -> bool:
"""
迁移前验证 - 可选重写
在执行迁移前进行必要的验证，如检查表是否存在、字段是否已存在等
Args:
db: 数据库管理器实例
Returns:
bool: 验证是否通过
"""
return True
async def validate_after_up(self, db) -> bool:
"""
迁移后验证 - 可选重写
在执行迁移后进行验证，确保迁移结果符合预期
Args:
db: 数据库管理器实例
Returns:
bool: 验证是否通过
"""
return True
async def get_rollback_sql(self, db) -> Optional[str]:
"""
获取回滚SQL - 可选重写
返回用于回滚的SQL语句，用于记录和紧急回滚
Args:
db: 数据库管理器实例
Returns:
Optional[str]: 回滚SQL语句，如果不需要则返回None
"""
return None
def get_checksum(self) -> str:
"""
获取迁移校验和
用于验证迁移文件是否被修改，确保迁移的一致性
Returns:
str: 迁移内容的校验和
"""
import hashlib
content = f"{self.version}:{self.description}:{str(self.dependencies)}"
return hashlib.md5(content.encode()).hexdigest()
def __str__(self):
return f"Migration {self.version}: {self.description}"
def __repr__(self):
return f"<Migration(version='{self.version}', description='{self.description}')>"
def __eq__(self, other):
if not isinstance(other, Migration):
return False
return self.version == other.version
def __hash__(self):
return hash(self.version)
def version_to_tuple(version: str) -> tuple:
"""
将版本号转换为可比较的元组
Args:
version: 版本号字符串，如 "1.0.1"
Returns:
tuple: 可比较的版本元组，如 (1, 0, 1)
"""
try:
# 尝试解析语义化版本号
parts = version.split('.')
return tuple(int(part) for part in parts)
except (ValueError, AttributeError):
# 如果不是标准版本号格式，按字符串排序
return (version,)
def compare_versions(version1: str, version2: str) -> int:
"""
比较两个版本号
Args:
version1: 第一个版本号
version2: 第二个版本号
Returns:
int: -1 如果 version1 < version2, 0 如果相等, 1 如果 version1 > version2
"""
tuple1 = version_to_tuple(version1)
tuple2 = version_to_tuple(version2)
if tuple1 < tuple2:
return -1
elif tuple1 > tuple2:
return 1
else:
return 0
backend/migrations/loader.py 0 → 100644
"""
迁移加载器 - 自动发现和注册迁移
负责扫描migrations/versions目录，自动加载和注册所有迁移文件
"""
import os
import sys
import importlib
import inspect
from pathlib import Path
from typing import List, Type
from loguru import logger
from .base import Migration
from .manager import migration_manager
class MigrationLoader:
"""迁移加载器"""
def __init__(self, versions_dir: str = None):
"""
初始化迁移加载器
Args:
versions_dir: 迁移版本目录路径，默认为当前目录下的versions
"""
if versions_dir is None:
self.versions_dir = Path(__file__).parent / "versions"
else:
self.versions_dir = Path(versions_dir)
self.loaded_migrations: List[Migration] = []
def discover_migration_files(self) -> List[str]:
"""发现所有迁移文件"""
if not self.versions_dir.exists():
logger.warning(f"迁移目录不存在，创建目录: {self.versions_dir}")
self.versions_dir.mkdir(parents=True, exist_ok=True)
return []
# 扫描迁移文件
migration_files = []
for file_path in self.versions_dir.glob("v*.py"):
if file_path.name != "__init__.py" and not file_path.name.startswith('.'):
migration_files.append(file_path.stem)
# 按文件名排序（版本号排序）
migration_files.sort()
logger.info(f"发现 {len(migration_files)} 个迁移文件: {migration_files}")
return migration_files
def load_migration_from_file(self, module_name: str) -> List[Migration]:
"""从文件加载迁移"""
migrations = []
try:
# 构建完整的模块路径
full_module_name = f"migrations.versions.{module_name}"
# 动态导入模块
if full_module_name in sys.modules:
# 如果模块已经导入，重新加载
module = importlib.reload(sys.modules[full_module_name])
else:
module = importlib.import_module(full_module_name)
# 查找Migration类的子类
for attr_name in dir(module):
attr = getattr(module, attr_name)
# 检查是否是Migration的子类（但不是Migration本身）
if (inspect.isclass(attr) and
issubclass(attr, Migration) and
attr is not Migration):
try:
# 实例化迁移
migration_instance = attr()
migrations.append(migration_instance)
logger.debug(f"从 {module_name} 加载迁移: {migration_instance.version}")
except Exception as e:
logger.error(f"实例化迁移 {attr_name} 失败: {e}")
continue
if not migrations:
logger.warning(f"在文件 {module_name} 中未找到有效的迁移类")
except Exception as e:
logger.error(f"加载迁移文件 {module_name} 失败: {e}")
logger.error(f"错误详情: {type(e).__name__}: {str(e)}")
return migrations
def load_all_migrations(self) -> List[Migration]:
"""加载所有迁移"""
logger.info("🔍 开始扫描和加载迁移文件")
migration_files = self.discover_migration_files()
all_migrations = []
for module_name in migration_files:
migrations = self.load_migration_from_file(module_name)
all_migrations.extend(migrations)
# 按版本号排序
all_migrations.sort(key=lambda m: self._version_to_tuple(m.version))
self.loaded_migrations = all_migrations
logger.info(f"✅ 成功加载 {len(all_migrations)} 个迁移")
return all_migrations
def _version_to_tuple(self, version: str) -> tuple:
"""将版本号转换为可比较的元组"""
try:
return tuple(map(int, version.split('.')))
except:
# 如果不是标准版本号格式，按字符串排序
return (version,)
def register_migrations(self, manager=None) -> int:
"""注册迁移到管理器"""
if manager is None:
manager = migration_manager
registered_count = 0
for migration in self.loaded_migrations:
try:
manager.register(migration)
registered_count += 1
logger.debug(f"注册迁移: {migration.version}")
except Exception as e:
logger.error(f"注册迁移 {migration.version} 失败: {e}")
continue
logger.info(f"✅ 成功注册 {registered_count} 个迁移到管理器")
return registered_count
def validate_migrations(self) -> bool:
"""验证迁移的完整性"""
logger.info("🔍 验证迁移完整性")
if not self.loaded_migrations:
logger.warning("没有加载任何迁移")
return True
# 检查版本号重复
versions = [m.version for m in self.loaded_migrations]
if len(versions) != len(set(versions)):
duplicates = [v for v in versions if versions.count(v) > 1]
logger.error(f"发现重复的迁移版本: {duplicates}")
return False
# 检查依赖关系
version_set = set(versions)
for migration in self.loaded_migrations:
for dep in migration.dependencies:
if dep not in version_set:
logger.error(f"迁移 {migration.version} 依赖的版本 {dep} 不存在")
return False
logger.info("✅ 迁移完整性验证通过")
return True
def get_migration_info(self) -> List[dict]:
"""获取迁移信息"""
return [
{
"version": m.version,
"description": m.description,
"dependencies": m.dependencies,
"checksum": m.get_checksum(),
"class_name": m.__class__.__name__
}
for m in self.loaded_migrations
]
# 全局加载器实例
migration_loader = MigrationLoader()
def load_migrations(manager=None) -> int:
"""
便捷函数：加载并注册所有迁移
Args:
manager: 迁移管理器实例，默认使用全局实例
Returns:
int: 成功注册的迁移数量
"""
try:
# 加载所有迁移
migrations = migration_loader.load_all_migrations()
# 验证迁移完整性
if not migration_loader.validate_migrations():
logger.error("迁移验证失败，停止注册")
return 0
# 注册到管理器
registered_count = migration_loader.register_migrations(manager)
logger.info(f"🎉 迁移加载完成！成功加载并注册 {registered_count} 个迁移")
return registered_count
except Exception as e:
logger.error(f"加载迁移过程中发生异常: {e}")
return 0
def reload_migrations(manager=None) -> int:
"""
重新加载所有迁移（开发环境使用）
Args:
manager: 迁移管理器实例，默认使用全局实例
Returns:
int: 成功注册的迁移数量
"""
if manager is None:
manager = migration_manager
# 清空现有迁移
manager.migrations.clear()
migration_loader.loaded_migrations.clear()
logger.info("🔄 重新加载迁移")
return load_migrations(manager)
backend/migrations/manager.py 0 → 100644
"""
迁移管理器 - 核心迁移逻辑
负责管理和执行数据库迁移的核心组件
"""
import asyncio
from typing import List, Dict, Any, Optional
from datetime import datetime
from sqlalchemy import text
from loguru import logger
import json
import traceback
from .base import Migration, MigrationError, version_to_tuple
class MigrationManager:
"""迁移管理器
负责管理所有数据库迁移的执行、回滚和状态跟踪
"""
def __init__(self):
self.migrations: List[Migration] = []
self._migration_table_created = False
self._db_manager = None
def set_db_manager(self, db_manager):
"""设置数据库管理器"""
self._db_manager = db_manager
async def _get_db_manager(self):
"""获取数据库管理器"""
if self._db_manager is None:
# 动态导入避免循环依赖
from database import db_manager
self._db_manager = db_manager
return self._db_manager
async def _ensure_migration_table(self):
"""确保迁移记录表存在"""
if self._migration_table_created:
return
try:
db = await self._get_db_manager()
# 分别执行每个SQL语句，避免多命令问题
await db.execute(text("""
CREATE TABLE IF NOT EXISTS schema_migrations (
id SERIAL PRIMARY KEY,
version VARCHAR(50) UNIQUE NOT NULL,
description TEXT NOT NULL,
executed_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
execution_time_ms INTEGER,
checksum VARCHAR(64),
rollback_sql TEXT,
created_by VARCHAR(100) DEFAULT 'system',
CONSTRAINT unique_version UNIQUE (version)
)
"""))
await db.execute(text("""
CREATE INDEX IF NOT EXISTS idx_schema_migrations_version
ON schema_migrations(version)
"""))
await db.execute(text("""
CREATE INDEX IF NOT EXISTS idx_schema_migrations_executed_at
ON schema_migrations(executed_at)
"""))
# 添加表和字段注释
await db.execute(text("""
COMMENT ON TABLE schema_migrations IS '数据库schema迁移记录表'
"""))
await db.execute(text("""
COMMENT ON COLUMN schema_migrations.version IS '迁移版本号'
"""))
await db.execute(text("""
COMMENT ON COLUMN schema_migrations.description IS '迁移描述'
"""))
await db.execute(text("""
COMMENT ON COLUMN schema_migrations.executed_at IS '执行时间'
"""))
await db.execute(text("""
COMMENT ON COLUMN schema_migrations.execution_time_ms IS '执行耗时(毫秒)'
"""))
await db.execute(text("""
COMMENT ON COLUMN schema_migrations.checksum IS '迁移文件校验和'
"""))
await db.execute(text("""
COMMENT ON COLUMN schema_migrations.rollback_sql IS '回滚SQL语句'
"""))
self._migration_table_created = True
logger.info("✅ 迁移记录表已准备就绪")
except Exception as e:
logger.error(f"❌ 创建迁移记录表失败: {e}")
raise MigrationError(f"无法创建迁移记录表: {e}")
def register(self, migration: Migration):
"""注册迁移"""
# 检查版本号重复
existing_versions = [m.version for m in self.migrations]
if migration.version in existing_versions:
raise MigrationError(f"迁移版本 {migration.version} 已存在")
self.migrations.append(migration)
# 按版本号排序
self.migrations.sort(key=lambda m: version_to_tuple(m.version))
logger.debug(f"注册迁移: {migration}")
async def get_executed_migrations(self) -> List[str]:
"""获取已执行的迁移版本列表"""
await self._ensure_migration_table()
try:
db = await self._get_db_manager()
result = await db.fetch_all(
text("SELECT version FROM schema_migrations ORDER BY executed_at")
)
return [row['version'] for row in result]
except Exception as e:
logger.error(f"获取已执行迁移列表失败: {e}")
return []
async def get_pending_migrations(self) -> List[Migration]:
"""获取待执行的迁移"""
executed = await self.get_executed_migrations()
return [m for m in self.migrations if m.version not in executed]
async def is_migration_executed(self, version: str) -> bool:
"""检查指定迁移是否已执行"""
executed = await self.get_executed_migrations()
return version in executed
async def create_backup_point(self, migration_version: str) -> str:
"""创建备份点"""
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
backup_name = f"backup_before_{migration_version}_{timestamp}"
try:
db = await self._get_db_manager()
# 记录备份点信息到system_config表
from database import system_config_table
backup_data = json.dumps({
"timestamp": timestamp,
"backup_name": backup_name,
"migration_version": migration_version,
"created_at": datetime.now().isoformat()
})
# 使用SQLAlchemy的insert语句
query = system_config_table.insert().values(
config_key=f"backup_point_{migration_version}",
config_value=backup_data,
description=f"迁移 {migration_version} 前的备份点"
)
try:
await db.execute(query)
except Exception as insert_error:
# 如果插入失败（可能是重复键），尝试更新
update_query = system_config_table.update().where(
system_config_table.c.config_key == f"backup_point_{migration_version}"
).values(
config_value=backup_data,
updated_at=text("CURRENT_TIMESTAMP")
)
await db.execute(update_query)
logger.info(f"✅ 备份点已创建: {backup_name}")
return backup_name
except Exception as e:
logger.error(f"❌ 创建备份点失败: {e}")
raise MigrationError(f"无法创建备份点: {e}")
async def execute_migration(self, migration: Migration) -> bool:
"""执行单个迁移"""
logger.info(f"🚀 开始执行迁移: {migration}")
start_time = datetime.now()
db = await self._get_db_manager()
try:
# 1. 检查是否已执行
if await self.is_migration_executed(migration.version):
logger.warning(f"⚠️ 迁移 {migration.version} 已执行，跳过")
return True
# 2. 迁移前验证
logger.info(f"🔍 执行迁移前验证: {migration.version}")
if not await migration.validate_before_up(db):
raise MigrationError(f"迁移前验证失败: {migration.version}")
# 3. 创建备份点
backup_name = await self.create_backup_point(migration.version)
# 4. 在事务中执行迁移
async with db.transaction():
logger.info(f"⚡ 执行迁移操作: {migration.version}")
# 执行迁移
success = await migration.up(db)
if not success:
raise MigrationError(f"迁移执行返回失败: {migration.version}")
# 迁移后验证
logger.info(f"✅ 执行迁移后验证: {migration.version}")
if not await migration.validate_after_up(db):
raise MigrationError(f"迁移后验证失败: {migration.version}")
# 获取回滚SQL（如果有）
rollback_sql = await migration.get_rollback_sql(db)
# 记录迁移执行
execution_time = (datetime.now() - start_time).total_seconds() * 1000
# 使用原始SQL字符串插入迁移记录
insert_sql = """
INSERT INTO schema_migrations
(version, description, execution_time_ms, checksum, rollback_sql, created_by)
VALUES (:version, :description, :execution_time, :checksum, :rollback_sql, :created_by)
"""
insert_values = {
"version": migration.version,
"description": migration.description,
"execution_time": int(execution_time),
"checksum": migration.get_checksum(),
"rollback_sql": rollback_sql,
"created_by": "migration_manager"
}
await db.execute(insert_sql, insert_values)
logger.info(f"🎉 迁移执行成功: {migration.version} (耗时: {execution_time:.0f}ms)")
return True
except Exception as e:
logger.error(f"❌ 迁移执行失败: {migration.version}")
logger.error(f"错误详情: {e}")
logger.error(f"堆栈跟踪: {traceback.format_exc()}")
# 处理迁移失败
await self._handle_migration_failure(migration, str(e))
return False
async def _handle_migration_failure(self, migration: Migration, error: str):
"""处理迁移失败"""
logger.warning(f"⚠️ 处理迁移失败: {migration.version}")
try:
db = await self._get_db_manager()
# 尝试执行回滚
logger.info(f"🔄 尝试回滚迁移: {migration.version}")
rollback_success = await migration.down(db)
if rollback_success:
logger.info(f"✅ 迁移回滚成功: {migration.version}")
else:
logger.error(f"❌ 迁移回滚失败: {migration.version}")
except Exception as rollback_error:
logger.error(f"❌ 回滚过程中发生错误: {rollback_error}")
async def migrate_to_latest(self) -> Dict[str, Any]:
"""迁移到最新版本"""
logger.info("🚀 开始数据库迁移到最新版本")
await self._ensure_migration_table()
pending_migrations = await self.get_pending_migrations()
if not pending_migrations:
logger.info("✅ 数据库已是最新版本，无需迁移")
return {
"success": True,
"message": "数据库已是最新版本",
"executed_migrations": 0,
"total_migrations": len(self.migrations)
}
logger.info(f"📋 发现 {len(pending_migrations)} 个待执行迁移")
executed_count = 0
failed_migrations = []
for migration in pending_migrations:
try:
success = await self.execute_migration(migration)
if success:
executed_count += 1
else:
failed_migrations.append(migration.version)
# 如果有迁移失败，停止后续迁移
break
except Exception as e:
logger.error(f"❌ 迁移 {migration.version} 执行异常: {e}")
failed_migrations.append(migration.version)
break
# 返回迁移结果
result = {
"success": len(failed_migrations) == 0,
"executed_migrations": executed_count,
"total_pending": len(pending_migrations),
"failed_migrations": failed_migrations
}
if result["success"]:
logger.info(f"🎉 数据库迁移完成！执行了 {executed_count} 个迁移")
result["message"] = f"成功执行 {executed_count} 个迁移"
else:
logger.error(f"❌ 数据库迁移失败！{len(failed_migrations)} 个迁移失败")
result["message"] = f"迁移失败，{len(failed_migrations)} 个迁移未能执行"
return result
async def get_migration_status(self) -> Dict[str, Any]:
"""获取迁移状态信息"""
await self._ensure_migration_table()
executed_migrations = await self.get_executed_migrations()
pending_migrations = await self.get_pending_migrations()
return {
"total_migrations": len(self.migrations),
"executed_count": len(executed_migrations),
"pending_count": len(pending_migrations),
"executed_migrations": executed_migrations,
"pending_migrations": [
{
"version": m.version,
"description": m.description,
"dependencies": m.dependencies,
"checksum": m.get_checksum()
} for m in pending_migrations
],
"is_up_to_date": len(pending_migrations) == 0
}
# 全局迁移管理器实例
migration_manager = MigrationManager()
backend/migrations/schema.py 0 → 100644
"""
迁移系统的数据库表结构定义
定义用于跟踪迁移历史的schema_migrations表
"""
from sqlalchemy import Column, Integer, String, Text, DateTime, Index
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.sql import func
Base = declarative_base()
class SchemaMigration(Base):
"""迁移记录表模型"""
__tablename__ = 'schema_migrations'
id = Column(Integer, primary_key=True, autoincrement=True, comment='主键ID')
version = Column(String(50), unique=True, nullable=False, comment='迁移版本号')
description = Column(Text, nullable=False, comment='迁移描述')
executed_at = Column(DateTime, nullable=False, default=func.current_timestamp(), comment='执行时间')
execution_time_ms = Column(Integer, comment='执行耗时(毫秒)')
checksum = Column(String(64), comment='迁移文件校验和')
rollback_sql = Column(Text, comment='回滚SQL语句')
created_by = Column(String(100), default='system', comment='创建者')
# 创建索引
__table_args__ = (
Index('idx_schema_migrations_version', 'version'),
Index('idx_schema_migrations_executed_at', 'executed_at'),
{'comment': '数据库schema迁移记录表'}
)
def __repr__(self):
return f"<SchemaMigration(version='{self.version}', description='{self.description}')>"
# 迁移表的创建SQL（用于手动创建或验证）
CREATE_MIGRATION_TABLE_SQL = """
CREATE TABLE IF NOT EXISTS schema_migrations (
id SERIAL PRIMARY KEY,
version VARCHAR(50) UNIQUE NOT NULL,
description TEXT NOT NULL,
executed_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
execution_time_ms INTEGER,
checksum VARCHAR(64),
rollback_sql TEXT,
created_by VARCHAR(100) DEFAULT 'system',
CONSTRAINT unique_version UNIQUE (version)
);
CREATE INDEX IF NOT EXISTS idx_schema_migrations_version
ON schema_migrations(version);
CREATE INDEX IF NOT EXISTS idx_schema_migrations_executed_at
ON schema_migrations(executed_at);
COMMENT ON TABLE schema_migrations IS '数据库schema迁移记录表';
COMMENT ON COLUMN schema_migrations.id IS '主键ID';
COMMENT ON COLUMN schema_migrations.version IS '迁移版本号';
COMMENT ON COLUMN schema_migrations.description IS '迁移描述';
COMMENT ON COLUMN schema_migrations.executed_at IS '执行时间';
COMMENT ON COLUMN schema_migrations.execution_time_ms IS '执行耗时(毫秒)';
COMMENT ON COLUMN schema_migrations.checksum IS '迁移文件校验和';
COMMENT ON COLUMN schema_migrations.rollback_sql IS '回滚SQL语句';
COMMENT ON COLUMN schema_migrations.created_by IS '创建者';
"""
# 查询已执行迁移的SQL
GET_EXECUTED_MIGRATIONS_SQL = """
SELECT version, description, executed_at, execution_time_ms
FROM schema_migrations
ORDER BY executed_at ASC;
"""
# 检查迁移是否已执行的SQL
CHECK_MIGRATION_EXECUTED_SQL = """
SELECT EXISTS (
SELECT 1 FROM schema_migrations
WHERE version = %s
) as executed;
"""
# 插入迁移记录的SQL
INSERT_MIGRATION_RECORD_SQL = """
INSERT INTO schema_migrations
(version, description, execution_time_ms, checksum, rollback_sql, created_by)
VALUES (%s, %s, %s, %s, %s, %s);
"""
# 删除迁移记录的SQL（用于回滚）
DELETE_MIGRATION_RECORD_SQL = """
DELETE FROM schema_migrations
WHERE version = %s;
"""
backend/migrations/versions/__init__.py 0 → 100644
"""
迁移版本目录
存放所有具体的迁移文件
命名规范:
- 文件名格式: v{version}_{description}.py
- 版本号使用语义化版本号: 1.0.1, 1.1.0, 2.0.0
- 描述使用英文下划线分隔: add_user_avatar, update_score_table
示例:
- v1_0_1_add_user_avatar.py
- v1_0_2_update_score_index.py
- v1_1_0_add_notification_table.py
"""
backend/migrations/versions/v1_0_1_add_user_avatar.py 0 → 100644
"""
版本 1.0.1: 为用户表添加头像字段
这是一个安全的迁移示例，展示如何添加新字段而不影响现有数据
迁移内容:
- 为users表添加avatar_url字段 (VARCHAR(500))
- 为现有用户设置默认头像
- 添加字段注释
安全措施:
- 使用IF NOT EXISTS确保幂等性
- 迁移前后都有验证
- 提供完整的回滚方法
"""
from migrations.base import Migration, MigrationError
from sqlalchemy import text
from loguru import logger
class AddUserAvatarMigration(Migration):
"""为用户表添加头像字段的迁移"""
def __init__(self):
super().__init__(
version="1.0.1",
description="为用户表添加头像字段",
dependencies=[] # 无依赖，这是第一个迁移
)
async def validate_before_up(self, db) -> bool:
"""迁移前验证：确保users表存在且没有avatar_url字段"""
try:
# 检查users表是否存在
result = await db.fetch_one(text("""
SELECT EXISTS (
SELECT FROM information_schema.tables
WHERE table_schema = 'public' AND table_name = 'users'
);
"""))
if not result['exists']:
logger.error("users表不存在，无法执行迁移")
return False
# 检查avatar_url字段是否已存在
result = await db.fetch_one(text("""
SELECT EXISTS (
SELECT FROM information_schema.columns
WHERE table_schema = 'public'
AND table_name = 'users'
AND column_name = 'avatar_url'
);
"""))
if result['exists']:
logger.warning("avatar_url字段已存在，跳过迁移")
return False # 字段已存在，不需要迁移
# 检查是否有用户数据
user_count = await db.fetch_one(text("SELECT COUNT(*) as count FROM users"))
logger.info(f"当前用户数量: {user_count['count']}")
logger.info("✅ 迁移前验证通过")
return True
except Exception as e:
logger.error(f"迁移前验证失败: {e}")
return False
async def up(self, db) -> bool:
"""执行迁移：添加avatar_url字段"""
try:
logger.info("开始添加avatar_url字段到users表")
# 1. 添加字段（使用IF NOT EXISTS确保安全）
await db.execute(text("""
ALTER TABLE users
ADD COLUMN IF NOT EXISTS avatar_url VARCHAR(500);
"""))
logger.info("✅ avatar_url字段添加成功")
# 2. 添加字段注释
await db.execute(text("""
COMMENT ON COLUMN users.avatar_url IS '用户头像URL地址，最大长度500字符';
"""))
logger.info("✅ 字段注释添加成功")
# 3. 为现有用户设置默认头像（可选）
result = await db.execute(text("""
UPDATE users
SET avatar_url = '/assets/default-avatar.png'
WHERE avatar_url IS NULL;
"""))
logger.info(f"✅ 为现有用户设置默认头像，影响行数: {result}")
# 4. 创建索引（如果需要按头像查询）
await db.execute(text("""
CREATE INDEX IF NOT EXISTS idx_users_avatar_url
ON users(avatar_url)
WHERE avatar_url IS NOT NULL;
"""))
logger.info("✅ 头像字段索引创建成功")
logger.info("🎉 avatar_url字段迁移完成")
return True
except Exception as e:
logger.error(f"添加avatar_url字段失败: {e}")
raise MigrationError(f"迁移执行失败: {e}", self.version, e)
async def down(self, db) -> bool:
"""回滚迁移：移除avatar_url字段"""
try:
logger.info("开始回滚：从users表移除avatar_url字段")
# 1. 删除索引
await db.execute(text("""
DROP INDEX IF EXISTS idx_users_avatar_url;
"""))
logger.info("✅ 头像字段索引删除成功")
# 2. 删除字段
await db.execute(text("""
ALTER TABLE users DROP COLUMN IF EXISTS avatar_url;
"""))
logger.info("✅ avatar_url字段删除成功")
logger.info("🔄 avatar_url字段回滚完成")
return True
except Exception as e:
logger.error(f"回滚avatar_url字段失败: {e}")
raise MigrationError(f"迁移回滚失败: {e}", self.version, e)
async def validate_after_up(self, db) -> bool:
"""迁移后验证：确保字段已正确添加"""
try:
# 1. 验证字段是否存在
result = await db.fetch_one(text("""
SELECT EXISTS (
SELECT FROM information_schema.columns
WHERE table_schema = 'public'
AND table_name = 'users'
AND column_name = 'avatar_url'
);
"""))
if not result['exists']:
logger.error("avatar_url字段未成功添加")
return False
# 2. 验证字段类型和长度
result = await db.fetch_one(text("""
SELECT data_type, character_maximum_length, is_nullable
FROM information_schema.columns
WHERE table_schema = 'public'
AND table_name = 'users'
AND column_name = 'avatar_url';
"""))
if (result['data_type'] != 'character varying' or
result['character_maximum_length'] != 500 or
result['is_nullable'] != 'YES'):
logger.error(f"avatar_url字段属性不正确: {result}")
return False
# 3. 验证索引是否创建
result = await db.fetch_one(text("""
SELECT EXISTS (
SELECT FROM pg_indexes
WHERE tablename = 'users'
AND indexname = 'idx_users_avatar_url'
);
"""))
if not result['exists']:
logger.warning("avatar_url字段索引未创建，但不影响迁移")
# 4. 验证现有用户是否有默认头像
result = await db.fetch_one(text("""
SELECT COUNT(*) as count
FROM users
WHERE avatar_url = '/assets/default-avatar.png';
"""))
logger.info(f"设置默认头像的用户数量: {result['count']}")
logger.info("✅ 迁移后验证通过")
return True
except Exception as e:
logger.error(f"迁移后验证失败: {e}")
return False
async def get_rollback_sql(self, db) -> str:
"""获取回滚SQL语句"""
return """
-- 回滚迁移 v1.0.1: 删除用户头像字段
DROP INDEX IF EXISTS idx_users_avatar_url;
ALTER TABLE users DROP COLUMN IF EXISTS avatar_url;
"""
backend/migrations/versions/v1_0_2_add_user_last_login.py 0 → 100644
"""
版本 1.0.2: 为用户表添加最后登录时间字段
这是第二个迁移示例，展示迁移系统的依赖管理和版本控制
迁移内容:
- 为users表添加last_login_at字段 (TIMESTAMP)
- 添加字段注释
- 创建索引以优化查询性能
安全措施:
- 依赖于v1.0.1迁移
- 使用IF NOT EXISTS确保幂等性
- 迁移前后都有验证
- 提供完整的回滚方法
"""
from migrations.base import Migration, MigrationError
from sqlalchemy import text
from loguru import logger
class AddUserLastLoginMigration(Migration):
"""为用户表添加最后登录时间字段的迁移"""
def __init__(self):
super().__init__(
version="1.0.2",
description="为用户表添加最后登录时间字段",
dependencies=["1.0.1"] # 依赖于头像字段迁移
)
async def validate_before_up(self, db) -> bool:
"""迁移前验证：确保users表存在且没有last_login_at字段"""
try:
# 检查users表是否存在
result = await db.fetch_one(text("""
SELECT EXISTS (
SELECT FROM information_schema.tables
WHERE table_schema = 'public' AND table_name = 'users'
);
"""))
if not result['exists']:
logger.error("users表不存在，无法执行迁移")
return False
# 检查依赖的avatar_url字段是否存在
result = await db.fetch_one(text("""
SELECT EXISTS (
SELECT FROM information_schema.columns
WHERE table_schema = 'public'
AND table_name = 'users'
AND column_name = 'avatar_url'
);
"""))
if not result['exists']:
logger.error("依赖的avatar_url字段不存在，无法执行迁移")
return False
# 检查last_login_at字段是否已存在
result = await db.fetch_one(text("""
SELECT EXISTS (
SELECT FROM information_schema.columns
WHERE table_schema = 'public'
AND table_name = 'users'
AND column_name = 'last_login_at'
);
"""))
if result['exists']:
logger.warning("last_login_at字段已存在，跳过迁移")
return False # 字段已存在，不需要迁移
logger.info("✅ 迁移前验证通过")
return True
except Exception as e:
logger.error(f"迁移前验证失败: {e}")
return False
async def up(self, db) -> bool:
"""执行迁移：添加last_login_at字段"""
try:
logger.info("开始添加last_login_at字段到users表")
# 1. 添加字段（使用IF NOT EXISTS确保安全）
await db.execute(text("""
ALTER TABLE users
ADD COLUMN IF NOT EXISTS last_login_at TIMESTAMP;
"""))
logger.info("✅ last_login_at字段添加成功")
# 2. 添加字段注释
await db.execute(text("""
COMMENT ON COLUMN users.last_login_at IS '用户最后登录时间';
"""))
logger.info("✅ 字段注释添加成功")
# 3. 创建索引以优化查询性能
await db.execute(text("""
CREATE INDEX IF NOT EXISTS idx_users_last_login_at
ON users(last_login_at)
WHERE last_login_at IS NOT NULL;
"""))
logger.info("✅ 最后登录时间索引创建成功")
logger.info("🎉 last_login_at字段迁移完成")
return True
except Exception as e:
logger.error(f"添加last_login_at字段失败: {e}")
raise MigrationError(f"迁移执行失败: {e}", self.version, e)
async def down(self, db) -> bool:
"""回滚迁移：移除last_login_at字段"""
try:
logger.info("开始回滚：从users表移除last_login_at字段")
# 1. 删除索引
await db.execute(text("""
DROP INDEX IF EXISTS idx_users_last_login_at;
"""))
logger.info("✅ 最后登录时间索引删除成功")
# 2. 删除字段
await db.execute(text("""
ALTER TABLE users DROP COLUMN IF EXISTS last_login_at;
"""))
logger.info("✅ last_login_at字段删除成功")
logger.info("🔄 last_login_at字段回滚完成")
return True
except Exception as e:
logger.error(f"回滚last_login_at字段失败: {e}")
raise MigrationError(f"迁移回滚失败: {e}", self.version, e)
async def validate_after_up(self, db) -> bool:
"""迁移后验证：确保字段已正确添加"""
try:
# 1. 验证字段是否存在
result = await db.fetch_one(text("""
SELECT EXISTS (
SELECT FROM information_schema.columns
WHERE table_schema = 'public'
AND table_name = 'users'
AND column_name = 'last_login_at'
);
"""))
if not result['exists']:
logger.error("last_login_at字段未成功添加")
return False
# 2. 验证字段类型
result = await db.fetch_one(text("""
SELECT data_type, is_nullable
FROM information_schema.columns
WHERE table_schema = 'public'
AND table_name = 'users'
AND column_name = 'last_login_at';
"""))
if (result['data_type'] != 'timestamp without time zone' or
result['is_nullable'] != 'YES'):
logger.error(f"last_login_at字段属性不正确: {result}")
return False
# 3. 验证索引是否创建
result = await db.fetch_one(text("""
SELECT EXISTS (
SELECT FROM pg_indexes
WHERE tablename = 'users'
AND indexname = 'idx_users_last_login_at'
);
"""))
if not result['exists']:
logger.warning("last_login_at字段索引未创建，但不影响迁移")
logger.info("✅ 迁移后验证通过")
return True
except Exception as e:
logger.error(f"迁移后验证失败: {e}")
return False
async def get_rollback_sql(self, db) -> str:
"""获取回滚SQL语句"""
return """
-- 回滚迁移 v1.0.2: 删除用户最后登录时间字段
DROP INDEX IF EXISTS idx_users_last_login_at;
ALTER TABLE users DROP COLUMN IF EXISTS last_login_at;
"""
backend/models.py
......@@ -70,7 +70,6 @@ class InstitutionImageCreate(BaseModel):
"""创建机构图片模型"""
id: str
url: str
upload_time: datetime
# 机构相关模型
......@@ -171,6 +170,10 @@ class UserStatsItem(BaseModel):
performanceScore: float
institutions: List[Dict[str, Any]]
class Config:
# 允许任意类型，提高兼容性
arbitrary_types_allowed = True
class MonthlyHistoryCreate(BaseModel):
"""创建月度历史记录模型"""
......@@ -180,6 +183,7 @@ class MonthlyHistoryCreate(BaseModel):
total_institutions: int = Field(..., ge=0, description="总机构数")
total_images: int = Field(..., ge=0, description="总图片数")
user_stats: List[UserStatsItem] = Field(..., description="用户统计数据")
institutions_data: Optional[List[Dict[str, Any]]] = Field(None, description="机构图片数据")
class MonthlyHistoryResponse(BaseModel):
......@@ -191,8 +195,9 @@ class MonthlyHistoryResponse(BaseModel):
total_institutions: int
total_images: int
user_stats: List[UserStatsItem]
institutions_data: Optional[List[Dict[str, Any]]] = Field(None, description="机构图片数据")
created_at: datetime
class Config:
from_attributes = True
......
backend/requirements.txt
......@@ -31,3 +31,6 @@ passlib[bcrypt]>=1.7.4
# 开发和调试工具
python-dotenv>=1.0.0
# 定时任务调度
apscheduler>=3.10.4
backend/routers/history.py
......@@ -25,19 +25,32 @@ async def get_all_history(
query = monthly_history_table.select().order_by(monthly_history_table.c.month.desc())
histories = await db.fetch_all(query)
return [
MonthlyHistoryResponse(
id=history["id"],
month=history["month"],
save_time=history["save_time"],
total_users=history["total_users"],
total_institutions=history["total_institutions"],
total_images=history["total_images"],
user_stats=history["user_stats"],
created_at=history["created_at"]
)
for history in histories
]
result = []
for history in histories:
try:
# 安全地获取 institutions_data，确保兼容性
institutions_data = history["institutions_data"] if "institutions_data" in history._mapping else []
if institutions_data is None:
institutions_data = []
result.append(MonthlyHistoryResponse(
id=history["id"],
month=history["month"],
save_time=history["save_time"],
total_users=history["total_users"],
total_institutions=history["total_institutions"],
total_images=history["total_images"],
user_stats=history["user_stats"],
institutions_data=institutions_data,
created_at=history["created_at"]
))
except Exception as e:
history_id = history["id"] if "id" in history._mapping else "unknown"
logger.error(f"处理历史记录失败: {history_id}, 错误: {e}")
# 跳过有问题的记录，继续处理其他记录
continue
return result
except Exception as e:
logger.error(f"获取历史记录失败: {e}")
......@@ -62,6 +75,11 @@ async def get_history_by_month(
if not history:
raise HTTPException(status_code=404, detail="指定月份的历史记录不存在")
# 安全地获取 institutions_data，确保兼容性
institutions_data = history["institutions_data"] if "institutions_data" in history._mapping else []
if institutions_data is None:
institutions_data = []
return MonthlyHistoryResponse(
id=history["id"],
month=history["month"],
......@@ -70,6 +88,7 @@ async def get_history_by_month(
total_institutions=history["total_institutions"],
total_images=history["total_images"],
user_stats=history["user_stats"],
institutions_data=institutions_data,
created_at=history["created_at"]
)
......@@ -82,50 +101,127 @@ async def get_history_by_month(
@router.post("/", response_model=BaseResponse, summary="保存月度历史记录")
async def save_monthly_history(
history_data: MonthlyHistoryCreate,
history_data: Dict[str, Any], # 改为更灵活的字典类型
db: DatabaseManager = Depends(get_database),
current_user: UserResponse = Depends(require_admin)
):
"""保存月度历史统计记录"""
try:
logger.info(f"开始保存月度历史记录")
logger.info(f"当前用户: {current_user.name} ({current_user.role})")
logger.info(f"接收到的数据: {history_data}")
# 提取必要字段
month = history_data.get('month')
save_time = history_data.get('save_time')
total_users = history_data.get('total_users', 0)
total_institutions = history_data.get('total_institutions', 0)
total_images = history_data.get('total_images', 0)
user_stats = history_data.get('user_stats', [])
institutions_data = history_data.get('institutions_data', []) # 新增：机构图片数据
# 验证必要字段
if not month:
raise HTTPException(status_code=400, detail="缺少月份信息")
if not save_time:
raise HTTPException(status_code=400, detail="缺少保存时间")
# 转换时间格式
from datetime import datetime
if isinstance(save_time, str):
# 解析ISO格式时间并移除时区信息（转换为naive datetime）
dt = datetime.fromisoformat(save_time.replace('Z', '+00:00'))
save_time = dt.replace(tzinfo=None) # 移除时区信息
logger.info(f"处理月份: {month}, 用户数: {total_users}, 机构数: {total_institutions}")
# 检查该月份是否已有记录
existing_history = await db.fetch_one(
monthly_history_table.select().where(
monthly_history_table.c.month == history_data.month
monthly_history_table.c.month == month
)
)
# 确保user_stats是可序列化的
import json
if user_stats:
try:
# 尝试序列化以验证数据格式
json.dumps(user_stats)
except (TypeError, ValueError) as e:
logger.error(f"user_stats数据无法序列化: {e}")
user_stats = [] # 如果无法序列化，使用空数组
if existing_history:
# 更新现有记录
query = monthly_history_table.update().where(
monthly_history_table.c.month == history_data.month
monthly_history_table.c.month == month
).values(
save_time=history_data.save_time,
total_users=history_data.total_users,
total_institutions=history_data.total_institutions,
total_images=history_data.total_images,
user_stats=history_data.user_stats
save_time=save_time,
total_users=total_users,
total_institutions=total_institutions,
total_images=total_images,
user_stats=user_stats,
institutions_data=institutions_data
)
await db.execute(query)
message = f"{history_data.month} 月度记录更新成功"
result = await db.execute(query)
message = f"{month} 月度记录更新成功"
logger.info(f"更新历史记录成功: {message}, 影响行数: {result}")
else:
# 创建新记录
query = monthly_history_table.insert().values(
month=history_data.month,
save_time=history_data.save_time,
total_users=history_data.total_users,
total_institutions=history_data.total_institutions,
total_images=history_data.total_images,
user_stats=history_data.user_stats
month=month,
save_time=save_time,
total_users=total_users,
total_institutions=total_institutions,
total_images=total_images,
user_stats=user_stats,
institutions_data=institutions_data
)
await db.execute(query)
message = f"{history_data.month} 月度记录保存成功"
result = await db.execute(query)
message = f"{month} 月度记录保存成功"
logger.info(f"创建历史记录成功: {message}, 插入ID: {result}")
return BaseResponse(message=message)
except HTTPException:
raise
except Exception as e:
logger.error(f"保存月度历史记录失败: {e}")
raise HTTPException(status_code=500, detail="保存历史记录失败")
logger.error(f"错误类型: {type(e)}")
logger.error(f"错误详情: {str(e)}")
import traceback
logger.error(f"错误堆栈: {traceback.format_exc()}")
raise HTTPException(status_code=500, detail=f"保存历史记录失败: {str(e)}")
@router.delete("/", response_model=BaseResponse, summary="清空所有历史记录")
async def clear_all_history(
db: DatabaseManager = Depends(get_database),
current_user: UserResponse = Depends(require_admin)
):
"""清空所有历史统计记录"""
try:
logger.info(f"管理员 {current_user.name} 请求清空所有历史记录")
# 获取当前记录数
count_query = "SELECT COUNT(*) as total FROM monthly_history"
count_result = await db.fetch_one(count_query)
total_records = count_result["total"] if count_result else 0
if total_records == 0:
return BaseResponse(message="没有历史记录需要清空")
# 删除所有记录
query = monthly_history_table.delete()
await db.execute(query)
logger.info(f"成功清空 {total_records} 条历史记录")
return BaseResponse(message=f"成功清空 {total_records} 条历史记录")
except Exception as e:
logger.error(f"清空历史记录失败: {e}")
raise HTTPException(status_code=500, detail="清空历史记录失败")
@router.delete("/{month}", response_model=BaseResponse, summary="删除指定月份历史记录")
......@@ -135,20 +231,20 @@ async def delete_history_by_month(month: str, db: DatabaseManager = Depends(get_
# 验证月份格式
if not month or len(month) != 7 or month[4] != '-':
raise HTTPException(status_code=400, detail="月份格式错误，应为 YYYY-MM")
# 检查记录是否存在
existing_history = await db.fetch_one(
monthly_history_table.select().where(monthly_history_table.c.month == month)
)
if not existing_history:
raise HTTPException(status_code=404, detail="指定月份的历史记录不存在")
# 删除记录
query = monthly_history_table.delete().where(monthly_history_table.c.month == month)
await db.execute(query)
return BaseResponse(message=f"{month} 月度记录删除成功")
except HTTPException:
raise
except Exception as e:
......@@ -233,3 +329,9 @@ async def cleanup_old_history(
except Exception as e:
logger.error(f"清理历史数据失败: {e}")
raise HTTPException(status_code=500, detail="清理历史数据失败")
backend/routers/institutions.py
......@@ -59,25 +59,34 @@ async def get_institution_with_images(institution_id: str, db: DatabaseManager):
)
@router.get("/", response_model=List[InstitutionResponse], summary="获取所有机构")
@router.get("/", response_model=List[InstitutionResponse], summary="获取机构列表")
async def get_all_institutions(
db: DatabaseManager = Depends(get_database),
current_user: UserResponse = Depends(get_current_active_user)
):
"""获取所有机构列表（包含图片信息）"""
"""获取机构列表（管理员获取所有机构，普通用户只获取自己负责的机构）"""
try:
# 获取所有机构
query = institutions_table.select().order_by(institutions_table.c.created_at)
# 根据用户角色决定查询范围
if current_user.role == 'admin':
# 管理员获取所有机构
query = institutions_table.select().order_by(institutions_table.c.created_at)
else:
# 普通用户只获取自己负责的机构
query = institutions_table.select().where(
institutions_table.c.owner_id == current_user.id
).order_by(institutions_table.c.created_at)
institutions = await db.fetch_all(query)
result = []
for institution in institutions:
inst_with_images = await get_institution_with_images(institution["id"], db)
if inst_with_images:
result.append(inst_with_images)
logger.info(f"用户 {current_user.name}({current_user.role}) 获取到 {len(result)} 个机构")
return result
except Exception as e:
logger.error(f"获取机构列表失败: {e}")
raise HTTPException(status_code=500, detail="获取机构列表失败")
......@@ -268,37 +277,52 @@ async def add_institution_image(
):
"""为机构添加图片"""
try:
logger.info(f"开始添加图片到机构 {institution_id}")
logger.info(f"图片数据: id={image_data.id}, url长度={len(image_data.url)}")
# 检查机构是否存在
existing_inst = await db.fetch_one(
institutions_table.select().where(institutions_table.c.id == institution_id)
)
if not existing_inst:
logger.error(f"机构不存在: {institution_id}")
raise HTTPException(status_code=404, detail="机构不存在")
logger.info(f"找到机构: {existing_inst['name']}")
# 检查图片ID是否已存在
existing_image = await db.fetch_one(
institution_images_table.select().where(institution_images_table.c.id == image_data.id)
)
if existing_image:
logger.error(f"图片ID已存在: {image_data.id}")
raise HTTPException(status_code=400, detail="图片ID已存在")
# 使用当前时间作为上传时间
upload_time = datetime.now()
logger.info(f"使用当前时间作为上传时间: {upload_time}")
# 插入图片记录
query = institution_images_table.insert().values(
id=image_data.id,
institution_id=institution_id,
url=image_data.url,
upload_time=image_data.upload_time
upload_time=upload_time
)
logger.info("准备执行数据库插入操作")
await db.execute(query)
logger.info("图片记录插入成功")
return BaseResponse(message="图片添加成功")
except HTTPException:
except HTTPException as e:
logger.error(f"HTTP异常: {e.detail}")
raise
except Exception as e:
logger.error(f"添加机构图片失败: {e}")
raise HTTPException(status_code=500, detail="添加图片失败")
logger.error(f"添加机构图片失败: {type(e).__name__}: {str(e)}")
logger.error(f"详细错误信息: {e}", exc_info=True)
raise HTTPException(status_code=500, detail=f"添加图片失败: {str(e)}")
@router.delete("/{institution_id}/images/{image_id}", response_model=BaseResponse, summary="删除机构图片")
......
backend/routers/migration.py
......@@ -421,3 +421,144 @@ async def clear_database(
except Exception as e:
logger.error(f"清空数据库失败: {e}")
raise HTTPException(status_code=500, detail="清空数据库失败")
# ==================== Schema 迁移管理 API ====================
@router.get("/schema/status", summary="获取数据库schema状态")
async def get_schema_status(
db: DatabaseManager = Depends(get_database)
):
"""获取数据库schema迁移状态"""
try:
from migrations.manager import migration_manager
status = await migration_manager.get_migration_status()
return {
"success": True,
"data": status,
"message": "获取schema状态成功"
}
except Exception as e:
logger.error(f"获取schema状态失败: {e}")
raise HTTPException(status_code=500, detail=f"获取schema状态失败: {str(e)}")
@router.post("/schema/migrate", summary="手动执行数据库schema迁移")
async def manual_migrate_schema(
db: DatabaseManager = Depends(get_database)
):
"""手动执行数据库schema迁移到最新版本"""
try:
from migrations.manager import migration_manager
logger.info("开始手动执行数据库schema迁移")
result = await migration_manager.migrate_to_latest()
if result["success"]:
return {
"success": True,
"data": {
"executed_migrations": result["executed_migrations"],
"total_pending": result.get("total_pending", 0),
"message": result["message"]
},
"message": "数据库迁移成功"
}
else:
raise HTTPException(
status_code=500,
detail={
"message": result["message"],
"failed_migrations": result.get("failed_migrations", [])
}
)
except HTTPException:
raise
except Exception as e:
logger.error(f"手动执行迁移失败: {e}")
raise HTTPException(status_code=500, detail=f"迁移执行失败: {str(e)}")
@router.get("/schema/migrations", summary="获取所有迁移信息")
async def get_all_migrations(
db: DatabaseManager = Depends(get_database)
):
"""获取所有迁移的详细信息"""
try:
from migrations.manager import migration_manager
from migrations.loader import migration_loader
# 获取迁移状态
status = await migration_manager.get_migration_status()
# 获取迁移详细信息
migration_info = migration_loader.get_migration_info()
return {
"success": True,
"data": {
"status": status,
"migrations": migration_info
},
"message": "获取迁移信息成功"
}
except Exception as e:
logger.error(f"获取迁移信息失败: {e}")
raise HTTPException(status_code=500, detail=f"获取迁移信息失败: {str(e)}")
@router.post("/schema/reload", summary="重新加载迁移文件")
async def reload_migrations(
db: DatabaseManager = Depends(get_database)
):
"""重新加载迁移文件（开发环境使用）"""
try:
from migrations.loader import reload_migrations
logger.info("开始重新加载迁移文件")
migration_count = reload_migrations()
return {
"success": True,
"data": {
"loaded_migrations": migration_count
},
"message": f"成功重新加载 {migration_count} 个迁移文件"
}
except Exception as e:
logger.error(f"重新加载迁移文件失败: {e}")
raise HTTPException(status_code=500, detail=f"重新加载失败: {str(e)}")
@router.get("/schema/version", summary="获取当前数据库schema版本")
async def get_current_schema_version(
db: DatabaseManager = Depends(get_database)
):
"""获取当前数据库schema版本"""
try:
from migrations.manager import migration_manager
executed_migrations = await migration_manager.get_executed_migrations()
# 获取最新执行的迁移版本
latest_version = executed_migrations[-1] if executed_migrations else "0.0.0"
return {
"success": True,
"data": {
"current_version": latest_version,
"executed_migrations": executed_migrations,
"total_executed": len(executed_migrations)
},
"message": "获取当前版本成功"
}
except Exception as e:
logger.error(f"获取当前版本失败: {e}")
raise HTTPException(status_code=500, detail=f"获取版本失败: {str(e)}")
backend/scheduler.py 0 → 100644
"""
定时任务调度器
负责执行月度自动保存等定时任务
"""
import asyncio
from datetime import datetime, timedelta
from apscheduler.schedulers.asyncio import AsyncIOScheduler
from apscheduler.triggers.cron import CronTrigger
from loguru import logger
from database import database, monthly_history_table, institution_images_table
from routers.users import users_table
from routers.institutions import institutions_table
class MonthlyScheduler:
"""月度定时任务调度器"""
def __init__(self):
self.scheduler = AsyncIOScheduler()
self.is_running = False
async def start(self):
"""启动调度器"""
if not self.is_running:
# 添加月度自动保存任务 - 每月1号0点执行
self.scheduler.add_job(
self.auto_save_monthly_stats,
CronTrigger(day=1, hour=0, minute=0),
id='monthly_auto_save',
name='月度自动保存统计数据',
replace_existing=True
)
# 添加测试任务 - 每分钟执行一次（仅用于测试）
self.scheduler.add_job(
self.test_scheduler,
CronTrigger(minute='*'),
id='test_scheduler',
name='测试调度器',
replace_existing=True
)
self.scheduler.start()
self.is_running = True
logger.info("🕐 月度定时任务调度器已启动")
logger.info("📅 月度自动保存任务已设置：每月1号0点执行")
async def stop(self):
"""停止调度器"""
if self.is_running:
self.scheduler.shutdown()
self.is_running = False
logger.info("🛑 月度定时任务调度器已停止")
async def test_scheduler(self):
"""测试调度器是否正常工作"""
current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
logger.info(f"⏰ 定时任务测试 - 当前时间: {current_time}")
async def auto_save_monthly_stats(self):
"""自动保存上月统计数据"""
try:
logger.info("🚀 开始执行月度自动保存任务...")
# 计算上个月的月份标识
current_date = datetime.now()
if current_date.month == 1:
# 如果当前是1月，上个月是去年12月
last_month_date = current_date.replace(year=current_date.year - 1, month=12)
else:
# 其他情况，上个月就是当前月份-1
last_month_date = current_date.replace(month=current_date.month - 1)
month_key = f"{last_month_date.year}-{str(last_month_date.month).zfill(2)}"
logger.info(f"📊 准备保存 {month_key} 月份的统计数据")
# 检查该月份是否已有记录
existing_history = await database.fetch_one(
monthly_history_table.select().where(
monthly_history_table.c.month == month_key
)
)
if existing_history:
logger.info(f"📋 {month_key} 月份数据已存在，跳过自动保存")
return
# 获取所有普通用户
users_query = users_table.select().where(users_table.c.role == 'user')
users = await database.fetch_all(users_query)
# 获取所有机构
institutions_query = institutions_table.select()
institutions = await database.fetch_all(institutions_query)
# 获取所有机构图片
images_query = institution_images_table.select()
all_images = await database.fetch_all(images_query)
# 为每个机构添加图片数据
institutions_with_images = []
for inst in institutions:
inst_images = [img for img in all_images if img['institution_id'] == inst['id']]
inst_dict = dict(inst)
inst_dict['images'] = [
{
'id': img['id'],
'url': img['url'],
'upload_time': img['upload_time'].isoformat() if img['upload_time'] else None
}
for img in inst_images
]
institutions_with_images.append(inst_dict)
# 构建用户统计数据
user_stats = []
for user in users:
# 获取用户负责的机构
user_institutions = [inst for inst in institutions_with_images if inst['owner_id'] == user['id']]
# 计算统计数据
institution_count = len(user_institutions)
total_images = sum(len(inst['images']) for inst in user_institutions)
# 简化的分数计算（实际应用中可能需要更复杂的逻辑）
interaction_score = min(total_images * 0.5, 10.0) # 每张图片0.5分，最高10分
performance_score = min(total_images * 2.5, 50.0) # 每张图片2.5分，最高50分
user_stat = {
'userId': user['id'],
'userName': user['name'],
'institutionCount': institution_count,
'interactionScore': interaction_score,
'performanceScore': performance_score,
'institutions': [
{
'id': inst['id'],
'name': inst['name'],
'imageCount': len(inst['images'])
}
for inst in user_institutions
]
}
user_stats.append(user_stat)
# 构建机构数据
institutions_data = [
{
'id': inst['id'],
'institutionId': inst['institution_id'],
'name': inst['name'],
'ownerId': inst['owner_id'],
'images': inst['images']
}
for inst in institutions_with_images
]
# 计算总计数据
total_users = len(users)
total_institutions = len(institutions_with_images)
total_images = sum(len(inst['images']) for inst in institutions_with_images)
# 保存到数据库
insert_query = monthly_history_table.insert().values(
month=month_key,
save_time=datetime.now(),
total_users=total_users,
total_institutions=total_institutions,
total_images=total_images,
user_stats=user_stats,
institutions_data=institutions_data
)
result = await database.execute(insert_query)
logger.info(f"✅ {month_key} 月份统计数据自动保存成功")
logger.info(f"📈 保存数据概览: 用户 {total_users} 个, 机构 {total_institutions} 个, 图片 {total_images} 张")
return True
except Exception as e:
logger.error(f"❌ 月度自动保存失败: {e}")
logger.error(f"错误详情: {str(e)}")
import traceback
logger.error(f"错误堆栈: {traceback.format_exc()}")
return False
async def trigger_manual_save(self, target_month: str = None):
"""手动触发保存指定月份的数据（用于测试）"""
try:
if target_month:
logger.info(f"🔧 手动触发保存 {target_month} 月份数据")
# 这里可以添加保存指定月份数据的逻辑
# 暂时使用当前的自动保存逻辑
result = await self.auto_save_monthly_stats()
return result
except Exception as e:
logger.error(f"❌ 手动触发保存失败: {e}")
return False
# 全局调度器实例
monthly_scheduler = MonthlyScheduler()
backend/update_db.py 0 → 100644
#!/usr/bin/env python3
"""
数据库表结构更新脚本
为 monthly_history 表添加 institutions_data 字段
"""
import asyncio
import asyncpg
from loguru import logger
async def update_database():
"""更新数据库表结构"""
try:
# 连接数据库
conn = await asyncpg.connect(
host="localhost",
port=5432,
user="performance_user",
password="performance_pass",
database="performance_db"
)
logger.info("✅ 数据库连接成功")
# 检查字段是否已存在
check_query = """
SELECT column_name
FROM information_schema.columns
WHERE table_name = 'monthly_history'
AND column_name = 'institutions_data'
"""
result = await conn.fetch(check_query)
if result:
logger.info("✅ institutions_data 字段已存在，无需更新")
else:
# 添加字段
alter_query = """
ALTER TABLE monthly_history
ADD COLUMN institutions_data JSONB
"""
await conn.execute(alter_query)
logger.info("✅ 成功添加 institutions_data 字段")
# 添加注释
comment_query = """
COMMENT ON COLUMN monthly_history.institutions_data
IS '机构图片数据，包含完整的机构和图片信息'
"""
await conn.execute(comment_query)
logger.info("✅ 成功添加字段注释")
# 验证更新结果
verify_query = """
SELECT column_name, data_type, is_nullable
FROM information_schema.columns
WHERE table_name = 'monthly_history'
AND column_name = 'institutions_data'
"""
result = await conn.fetch(verify_query)
if result:
row = result[0]
logger.info(f"✅ 字段验证成功: {row['column_name']} ({row['data_type']}, nullable: {row['is_nullable']})")
else:
logger.error("❌ 字段验证失败")
await conn.close()
logger.info("✅ 数据库连接已关闭")
except Exception as e:
logger.error(f"❌ 数据库更新失败: {e}")
raise
if __name__ == "__main__":
asyncio.run(update_database())
database/migrations/add_institutions_data_to_history.sql 0 → 100644
-- 为月度历史统计表添加机构图片数据字段
-- 执行时间：2025-01-29
-- 添加 institutions_data 字段到 monthly_history 表
ALTER TABLE monthly_history
ADD COLUMN IF NOT EXISTS institutions_data JSONB;
-- 添加字段注释
COMMENT ON COLUMN monthly_history.institutions_data IS '机构图片数据，包含完整的机构和图片信息';
-- 验证字段是否添加成功
SELECT column_name, data_type, is_nullable
FROM information_schema.columns
WHERE table_name = 'monthly_history'
AND column_name = 'institutions_data';
docker-compose.yml
......@@ -31,7 +31,7 @@ services:
restart: unless-stopped
environment:
- DATABASE_URL=postgresql://performance_user:performance_pass@postgres:5432/performance_db
- CORS_ORIGINS=http://localhost:5173,http://localhost:8080,http://localhost:4001
- CORS_ORIGINS=*
- API_HOST=0.0.0.0
- API_PORT=8000
ports:
......
src/services/api.js
......@@ -4,8 +4,8 @@
* 替换原有的 localStorage 存储机制
*/
// API 基础配置
const API_BASE_URL = import.meta.env.VITE_API_BASE_URL || 'http://localhost:8000'
// API 基础配置 - 使用相对路径，通过Vite代理访问后端
const API_BASE_URL = import.meta.env.VITE_API_BASE_URL || ''
/**
* HTTP 请求封装类
......@@ -280,9 +280,29 @@ export const userApi = {
return apiClient.delete(`/api/users/${userId}`)
},
// 用户登录
// 用户登录 - 特殊处理，不进行token刷新
async login(loginData) {
return apiClient.post('/api/users/login', loginData)
const url = `${apiClient.baseURL}/api/users/login`
try {
const response = await fetch(url, {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify(loginData)
})
if (!response.ok) {
const errorData = await response.json().catch(() => ({}))
throw new Error(errorData.detail || `HTTP ${response.status}: ${response.statusText}`)
}
return await response.json()
} catch (error) {
console.error('登录请求失败:', error)
throw error
}
},
// 刷新token
......@@ -429,6 +449,11 @@ export const historyApi = {
return apiClient.delete(`/api/history/${month}`)
},
// 清空所有历史记录
async clearAll() {
return apiClient.delete('/api/history')
},
// 获取历史统计摘要
async getSummary() {
return apiClient.get('/api/history/stats/summary')
......@@ -437,7 +462,9 @@ export const historyApi = {
// 清理旧历史数据
async cleanup(keepMonths = 12) {
return apiClient.post('/api/history/cleanup', { keep_months: keepMonths })
}
},
}
/**
......
src/store/auth.js
......@@ -25,19 +25,10 @@ export const useAuthStore = defineStore('auth', () => {
* 登录后加载数据
*/
const loadDataAfterLogin = async () => {
try {
const dataStore = useDataStore()
console.log('📊 登录成功，开始加载数据...')
const dataLoaded = await dataStore.loadData()
if (dataLoaded) {
console.log('✅ 数据加载成功')
} else {
console.warn('⚠️ 数据加载失败，使用离线模式')
}
} catch (error) {
console.error('❌ 登录后数据加载失败:', error)
}
const dataStore = useDataStore()
console.log('📊 登录成功，开始加载数据...')
await dataStore.loadData()
console.log('✅ 数据加载成功')
}
/**
......@@ -59,6 +50,13 @@ export const useAuthStore = defineStore('auth', () => {
// 保存tokens到API客户端
apiClient.saveTokens(response.access_token, response.refresh_token)
// 验证token是否正确保存
const savedToken = apiClient.getAccessToken()
if (!savedToken) {
throw new Error('Token保存失败')
}
console.log('🔑 Token已保存，准备加载数据...')
// 登录成功后加载数据
await loadDataAfterLogin()
......@@ -70,7 +68,7 @@ export const useAuthStore = defineStore('auth', () => {
return false
} catch (error) {
console.error('登录请求失败:', error)
return false
throw error
}
}
......
src/store/data.js
......@@ -7,6 +7,7 @@ import {
historyApi,
migrationApi
} from '@/services/api'
import { useAuthStore } from '@/store/auth'
/**
* 数据管理store - 重构版本
......@@ -66,12 +67,39 @@ export const useDataStore = defineStore('data', () => {
isLoading.value = true
console.log('🔄 从数据库加载数据...')
// 并行加载所有数据
const [usersData, institutionsData, configData] = await Promise.all([
userApi.getAll(),
institutionApi.getAll(),
configApi.getAll()
])
// 获取当前用户信息
const authStore = useAuthStore()
const currentUser = authStore.currentUser
if (!currentUser) {
throw new Error('用户未登录')
}
// 根据用户角色加载不同的数据
let usersData = []
let institutionsData = []
let configData = {}
if (currentUser.role === 'admin') {
// 管理员加载所有数据
const [allUsers, allInstitutions, config] = await Promise.all([
userApi.getAll(),
institutionApi.getAll(),
configApi.getAll()
])
usersData = allUsers
institutionsData = allInstitutions
configData = config
} else {
// 普通用户只加载自己的机构数据和系统配置
const [userInstitutions, config] = await Promise.all([
institutionApi.getByOwner(currentUser.id),
configApi.getAll()
])
usersData = [currentUser] // 只包含当前用户
institutionsData = userInstitutions
configData = config
}
// 转换机构数据格式（后端使用下划线，前端使用驼峰命名）
const convertedInstitutions = institutionsData.map(inst => ({
......@@ -109,11 +137,118 @@ export const useDataStore = defineStore('data', () => {
const initializeEmptyData = async () => {
console.log('🔄 初始化空数据状态...')
users.value = []
institutions.value = []
systemConfig.value = {}
// 为了演示目的，加载一些模拟数据
users.value = [
{
id: 'user_1756285723042',
phone: '18870041111',
name: '陈锐屏',
role: 'user',
institutions: [],
created_at: '2025-08-27T09:08:43.757484',
updated_at: '2025-08-28T06:35:47.681937'
},
{
id: 'user_1756286078085',
phone: '18870042222',
name: '张田田',
role: 'user',
institutions: [],
created_at: '2025-08-27T09:08:43.757484',
updated_at: '2025-08-28T06:35:47.681937'
},
{
id: 'user_1756286102502',
phone: '18870043333',
name: '余芳飞',
role: 'user',
institutions: [],
created_at: '2025-08-27T09:08:43.757484',
updated_at: '2025-08-28T06:35:47.681937'
}
]
institutions.value = [
{
id: 'inst_1756352749368_k9zym68t9',
institutionId: '73873',
name: '昆明市五华区爱雅仕口腔诊所',
ownerId: 'user_1756285723042',
images: [
{
id: 'img_1756300086739_vr9Bqux',
url: 'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCAABAAEDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAv/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFQEBAQAAAAAAAAAAAAAAAAAAAAX/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwCdABmX/9k=',
uploadTime: '2025-08-28T08:34:46.739000'
},
{
id: 'img_1756300086739_xr8Cqvw',
url: 'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCAABAAEDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAv/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFQEBAQAAAAAAAAAAAAAAAAAAAAX/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwCdABmX/9k=',
uploadTime: '2025-08-28T08:35:12.456000'
}
],
created_at: '2025-08-28T06:22:44.589423',
updated_at: '2025-08-28T06:29:03.103923'
},
{
id: 'inst_1756352749368_aygusa4m1',
institutionId: '73950',
name: '五华区长青口腔诊所',
ownerId: 'user_1756285723042',
images: [
{
id: 'img_1756300086740_zr9Dqxy',
url: 'data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCj/wAARCAABAAEDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAv/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/8QAFQEBAQAAAAAAAAAAAAAAAAAAAAX/xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIRAxEAPwCdABmX/9k=',
uploadTime: '2025-08-28T08:36:22.789000'
}
],
created_at: '2025-08-28T03:45:49.909788',
updated_at: '2025-08-28T06:29:03.103923'
},
{
id: 'inst_1756352749368_n231ytwxd',
institutionId: '001',
name: '温州奥齿泰口腔门诊部（普通合伙）',
ownerId: 'user_1756286078085',
images: [],
created_at: '2025-08-28T03:45:49.909788',
updated_at: '2025-08-28T06:29:03.103923'
},
{
id: 'inst_1756352749368_g9mf6mnih',
institutionId: '002',
name: '武夷山思美达口腔门诊部',
ownerId: 'user_1756286078085',
images: [],
created_at: '2025-08-28T03:45:49.909788',
updated_at: '2025-08-28T06:29:03.103923'
},
{
id: 'inst_1756352749368_f7xbgr85j',
institutionId: '003',
name: '崇川区海虹口腔门诊部',
ownerId: 'user_1756286102502',
images: [],
created_at: '2025-08-28T03:45:49.909788',
updated_at: '2025-08-28T06:29:03.103923'
},
{
id: 'inst_1756352749368_8cs5ag7pn',
institutionId: '004',
name: '大连西岗悦佳口腔诊所',
ownerId: 'user_1756286102502',
images: [],
created_at: '2025-08-28T03:45:49.909788',
updated_at: '2025-08-28T06:29:03.103923'
}
]
console.log('✅ 空数据状态初始化完成')
systemConfig.value = {
initialized: true,
version: '8.8.0',
hasDefaultData: true
}
console.log('✅ 模拟数据状态初始化完成')
}
/**
......@@ -138,9 +273,7 @@ export const useDataStore = defineStore('data', () => {
} catch (error) {
console.error('❌ 数据加载失败:', error)
// 初始化空数据状态，避免界面崩溃
await initializeEmptyData()
return false
throw error
}
}
......@@ -398,24 +531,22 @@ export const useDataStore = defineStore('data', () => {
try {
const imageCreateData = {
id: imageData.id,
url: imageData.url,
upload_time: imageData.uploadTime || new Date().toISOString()
url: imageData.url
}
console.log('🔍 发送到后端的图片数据:', {
institutionId,
imageCreateData,
originalImageData: imageData
})
// 必须成功保存到数据库
await institutionApi.addImage(institutionId, imageCreateData)
console.log('✅ 图片已成功保存到数据库')
// 更新本地状态
const institution = institutions.value.find(inst => inst.id === institutionId)
if (institution) {
if (!institution.images) {
institution.images = []
}
institution.images.push({
id: imageData.id,
url: imageData.url,
uploadTime: imageData.uploadTime || new Date().toISOString()
})
}
// 重新从数据库加载数据以确保同步
await loadFromDatabase()
console.log('✅ 数据已重新加载，确保界面同步')
return true
} catch (error) {
......@@ -429,16 +560,15 @@ export const useDataStore = defineStore('data', () => {
*/
const removeImageFromInstitution = async (institutionId, imageId) => {
try {
console.log('🗑️ 开始删除图片:', { institutionId, imageId })
// 先调用后端API删除图片
await institutionApi.deleteImage(institutionId, imageId)
console.log('✅ 后端删除图片成功')
// 更新本地状态
const institution = institutions.value.find(inst => inst.id === institutionId)
if (institution && institution.images) {
const imageIndex = institution.images.findIndex(img => img.id === imageId)
if (imageIndex !== -1) {
institution.images.splice(imageIndex, 1)
}
}
// 重新从数据库加载数据以确保同步
await loadFromDatabase()
console.log('✅ 数据已重新加载，确保界面同步')
return true
} catch (error) {
......@@ -483,6 +613,7 @@ export const useDataStore = defineStore('data', () => {
/**
* 计算用户的交互得分
* 新算法：0张图片=0分，1张图片=0.5分，2张及以上=1分
*/
const calculateInteractionScore = (userId) => {
const userInstitutions = getInstitutionsByUserId(userId)
......@@ -494,12 +625,15 @@ export const useDataStore = defineStore('data', () => {
for (const institution of userInstitutions) {
const imageCount = institution.images ? institution.images.length : 0
// 基础分数：每个机构10分
let institutionScore = 10
// 图片加分：每张图片2分，最多20分
const imageBonus = Math.min(imageCount * 2, 20)
institutionScore += imageBonus
// 新的互动得分算法
let institutionScore = 0
if (imageCount === 0) {
institutionScore = 0
} else if (imageCount === 1) {
institutionScore = 0.5
} else {
institutionScore = 1
}
totalScore += institutionScore
}
......@@ -509,6 +643,7 @@ export const useDataStore = defineStore('data', () => {
/**
* 计算用户的绩效得分
* 新公式：绩效得分 = 互动得分 ÷ 名下的带教机构数 × 10
*/
const calculatePerformanceScore = (userId) => {
const userInstitutions = getInstitutionsByUserId(userId)
......@@ -565,13 +700,23 @@ export const useDataStore = defineStore('data', () => {
}
})
// 保存完整的机构和图片数据
const institutionsWithImages = institutions.value.map(inst => ({
id: inst.id,
institutionId: inst.institutionId,
name: inst.name,
ownerId: inst.ownerId,
images: inst.images || []
}))
const historyData = {
month: monthKey,
save_time: new Date().toISOString(),
total_users: currentStats.length,
total_institutions: institutions.value.length,
total_images: institutions.value.reduce((total, inst) => total + (inst.images ? inst.images.length : 0), 0),
user_stats: currentStats
user_stats: currentStats,
institutions_data: institutionsWithImages // 新增：保存完整的机构和图片数据
}
// 保存到数据库
......@@ -615,7 +760,17 @@ export const useDataStore = defineStore('data', () => {
*/
const getMonthStats = async (month) => {
try {
return await historyApi.getByMonth(month)
const data = await historyApi.getByMonth(month)
if (data) {
// 转换字段名从下划线到驼峰命名
return {
...data,
userStats: data.user_stats || [],
institutionsData: data.institutions_data || [], // 转换机构数据字段
saveTime: data.save_time // 转换保存时间字段
}
}
return null
} catch (error) {
console.error('获取月份统计数据失败:', error)
return null
......@@ -635,9 +790,81 @@ export const useDataStore = defineStore('data', () => {
}
}
/**
* 清空所有历史统计数据
*/
const clearAllHistoryStats = async () => {
try {
await historyApi.clearAll()
return true
} catch (error) {
console.error('清空所有历史统计数据失败:', error)
return false
}
}
// ========== 数据管理 ==========
/**
* 手动月度重置
* 保存当前统计数据并清空所有图片上传记录
*/
const manualMonthlyReset = async () => {
try {
console.log('🔄 开始执行月度重置...')
// 1. 保存当前月份的统计数据到历史记录
const saveResult = await saveCurrentMonthStats()
if (!saveResult) {
throw new Error('保存历史统计数据失败')
}
// 2. 统计要清除的图片数量
let clearedImageCount = 0
institutions.value.forEach(inst => {
if (inst.images && inst.images.length > 0) {
clearedImageCount += inst.images.length
}
})
// 3. 清空所有机构的图片数据
const updatedInstitutions = institutions.value.map(inst => ({
...inst,
images: [] // 清空图片数组
}))
// 4. 批量删除数据库中的所有图片记录
for (const institution of institutions.value) {
if (institution.images && institution.images.length > 0) {
// 删除该机构的所有图片
for (const image of institution.images) {
await institutionApi.deleteImage(institution.id, image.id)
}
}
}
// 5. 更新本地状态
institutions.value = updatedInstitutions
console.log(`✅ 月度重置完成，已清空 ${clearedImageCount} 张图片`)
return {
success: true,
clearedCount: clearedImageCount,
message: '月度重置成功'
}
} catch (error) {
console.error('❌ 月度重置失败:', error)
return {
success: false,
error: error.message || '月度重置失败',
clearedCount: 0
}
}
}
/**
* 清空所有数据（重置系统）
*/
const clearAllData = async () => {
......@@ -695,22 +922,39 @@ export const useDataStore = defineStore('data', () => {
*/
const importData = async (jsonData) => {
try {
console.log('🔄 开始导入数据...')
const data = JSON.parse(jsonData)
if (data.users && data.institutions && data.systemConfig) {
// 这里需要实现批量导入到数据库的逻辑
// 暂时先更新本地状态
users.value = data.users
institutions.value = data.institutions
systemConfig.value = data.systemConfig
if (!data.users || !data.institutions || !data.systemConfig) {
throw new Error('数据格式不正确，缺少必要字段')
}
// 准备迁移数据格式
const migrationData = {
users: data.users,
institutions: data.institutions,
systemConfig: data.systemConfig,
historyStats: data.historyStats || []
}
console.log(`📊 准备导入: ${data.users.length} 个用户, ${data.institutions.length} 个机构`)
// 使用迁移API将数据写入数据库
const result = await migrationApi.migrate(migrationData)
if (result && result.success) {
console.log('✅ 数据已成功写入数据库')
// 重新从数据库加载数据以确保同步
await loadFromDatabase()
console.log('✅ 数据导入成功')
console.log('✅ 数据导入完成')
return true
} else {
throw new Error('数据格式不正确')
throw new Error(result?.message || '数据迁移失败')
}
} catch (error) {
console.error('导入数据失败:', error)
console.error('❌ 导入数据失败:', error)
return false
}
}
......@@ -768,11 +1012,13 @@ export const useDataStore = defineStore('data', () => {
getAvailableHistoryMonths,
getMonthStats,
deleteMonthStats,
clearAllHistoryStats,
// 数据管理
clearAllData,
resetToDefault,
exportData,
importData
importData,
manualMonthlyReset
}
})
src/views/admin/AdminPanel.vue
......@@ -383,14 +383,7 @@
</el-dropdown-menu>
</template>
</el-dropdown>
<el-button type="primary" @click="saveCurrentMonthStats" :loading="saveStatsLoading">
<el-icon><Download /></el-icon>
保存当前月份
</el-button>
<el-button type="warning" @click="clearHistoryStats" :loading="clearHistoryLoading">
<el-icon><Delete /></el-icon>
清空历史数据
</el-button>
</div>
</div>
......@@ -409,15 +402,7 @@
:value="month"
/>
</el-select>
<el-button
v-if="selectedHistoryMonth"
type="danger"
size="small"
@click="deleteSelectedMonth"
style="margin-left: 10px"
>
删除此月份数据
</el-button>
</div>
<!-- 历史数据展示 -->
......@@ -490,8 +475,7 @@
<!-- 无数据提示 -->
<div v-else-if="availableMonths.length === 0" class="no-history-data">
<el-empty description="暂无历史统计数据">
<el-button type="primary" @click="saveCurrentMonthStats">保存当前月份数据</el-button>
<el-empty description="暂无历史统计数据，系统将在每月1号自动保存上月数据">
</el-empty>
</div>
......@@ -806,31 +790,7 @@
</template>
</el-input>
<!-- 导出用户数据按钮 - 移动到筛选区域 -->
<el-dropdown
@command="handleUserExportCommand"
:disabled="!selectedViewUserId"
split-button
type="success"
size="default"
@click="exportUserData('zip')"
:loading="exportUserLoading"
>
<el-icon><Download /></el-icon>
导出数据
<template #dropdown>
<el-dropdown-menu>
<el-dropdown-item command="zip">
<el-icon><FolderOpened /></el-icon>
ZIP图片包
</el-dropdown-item>
<el-dropdown-item command="csv">
<el-icon><List /></el-icon>
CSV格式
</el-dropdown-item>
</el-dropdown-menu>
</template>
</el-dropdown>
</div>
</div>
......@@ -987,6 +947,7 @@ import {
} from '@element-plus/icons-vue'
import { useAuthStore } from '@/store/auth'
import { useDataStore } from '@/store/data'
import { historyApi } from '@/services/api'
import JSZip from 'jszip'
import { saveAs } from 'file-saver'
......@@ -1050,12 +1011,10 @@ const selectedFile = ref(null)
const selectedHistoryMonth = ref('')
const selectedMonthData = ref(null)
const availableMonths = ref([])
const saveStatsLoading = ref(false)
const clearHistoryLoading = ref(false)
const exportHistoryLoading = ref(false)
// 用户视图导出相关变量
const exportUserLoading = ref(false)
// 月度重置相关变量
const monthlyResetLoading = ref(false)
......@@ -1223,7 +1182,8 @@ const userUploadStats = computed(() => {
const users = regularUsers.value
const stats = users.map(user => {
const userInstitutions = dataStore.getInstitutionsByUserId(user.id)
const uploadedCount = userInstitutions.filter(inst => inst.images.length > 0).length
// 与普通用户面板保持一致：至少2张图片才算完成
const uploadedCount = userInstitutions.filter(inst => inst.images.length >= 2).length
const uploadRate = userInstitutions.length > 0
? Math.round((uploadedCount / userInstitutions.length) * 100)
: 0
......@@ -1236,8 +1196,13 @@ const userUploadStats = computed(() => {
}
})
// 按完成率由高到低排序
return stats.sort((a, b) => b.uploadRate - a.uploadRate)
// 按完成率由高到低排序，完成率相同时按姓名排序
return stats.sort((a, b) => {
if (b.uploadRate !== a.uploadRate) {
return b.uploadRate - a.uploadRate
}
return a.name.localeCompare(b.name)
})
})
/**
......@@ -1850,7 +1815,8 @@ const handleLogout = async () => {
type: 'warning'
})
authStore.logout()
// 等待登出完成后再跳转
await authStore.logout()
router.push('/login')
ElMessage.success('已退出登录')
} catch {
......@@ -1924,345 +1890,20 @@ const switchToUserView = () => {
}
}
/**
* 处理用户导出命令
*/
const handleUserExportCommand = (command) => {
exportUserData(command)
}
/**
* 导出选中用户的数据
*/
const exportUserData = async (format = 'json') => {
if (!selectedViewUserId.value || !selectedViewUser.value) {
ElMessage.error('请先选择用户')
return
}
try {
exportUserLoading.value = true
// 获取当前月份
const currentDate = new Date()
const currentMonth = `${currentDate.getFullYear()}-${String(currentDate.getMonth() + 1).padStart(2, '0')}`
// 准备导出数据
const exportData = {
exportInfo: {
exportTime: new Date().toISOString(),
exportMonth: currentMonth,
exportType: '用户数据导出',
userName: selectedViewUser.value.name,
userId: selectedViewUser.value.id,
format: format
},
userData: {
id: selectedViewUser.value.id,
name: selectedViewUser.value.name,
phone: selectedViewUser.value.phone,
institutionCount: selectedUserInstitutions.value.length,
interactionScore: dataStore.calculateInteractionScore(selectedViewUser.value.id),
performanceScore: dataStore.calculatePerformanceScore(selectedViewUser.value.id)
},
institutions: selectedUserInstitutions.value.map(inst => {
console.log(`\n=== 准备导出数据 - 机构: ${inst.name} ===`)
console.log('原始机构数据:', {
id: inst.id,
institutionId: inst.institutionId,
name: inst.name,
ownerId: inst.ownerId,
hasImages: !!inst.images,
imageCount: inst.images ? inst.images.length : 0
})
const mappedImages = inst.images ? inst.images.map((img, imgIndex) => {
console.log(` 图片 ${imgIndex + 1} 原始数据:`, {
id: img.id,
name: img.name,
hasUrl: !!img.url,
urlType: typeof img.url,
urlLength: img.url ? img.url.length : 0,
size: img.size,
uploadTime: img.uploadTime
})
const mappedImg = {
id: img.id,
name: img.name,
uploadTime: img.uploadTime,
size: img.size,
url: img.url // 添加图片的Base64数据，ZIP导出需要此字段
}
console.log(` 图片 ${imgIndex + 1} 映射后:`, {
id: mappedImg.id,
name: mappedImg.name,
hasUrl: !!mappedImg.url,
urlPreserved: img.url === mappedImg.url
})
return mappedImg
}) : []
const result = {
id: inst.id,
institutionId: inst.institutionId,
name: inst.name,
imageCount: inst.images ? inst.images.length : 0,
images: mappedImages
}
console.log('机构导出数据准备完成:', {
name: result.name,
imageCount: result.imageCount,
actualImagesLength: result.images.length,
imagesWithUrl: result.images.filter(img => !!img.url).length
})
return result
})
}
// 根据格式导出
switch (format) {
case 'csv':
await exportUserDataAsCSV(exportData, selectedViewUser.value.name, currentMonth)
break
case 'zip':
await exportUserDataAsZIP(exportData, selectedViewUser.value.name, currentMonth)
break
default:
throw new Error(`不支持的导出格式: ${format}`)
}
ElMessage.success(`${selectedViewUser.value.name} 的${format.toUpperCase()}数据导出成功！`)
} catch (error) {
console.error('导出用户数据失败:', error)
ElMessage.error(`导出用户数据失败：${error.message}`)
} finally {
exportUserLoading.value = false
}
}
/**
* 导出用户数据为CSV格式
*/
const exportUserDataAsCSV = async (exportData, userName, currentMonth) => {
const csvContent = []
// 用户信息部分
csvContent.push('用户信息')
csvContent.push(`用户ID,${exportData.userData.id}`)
csvContent.push(`姓名,${exportData.userData.name}`)
csvContent.push(`手机号,${exportData.userData.phone}`)
csvContent.push(`负责机构数,${exportData.userData.institutionCount}`)
csvContent.push(`互动得分,${exportData.userData.interactionScore}`)
csvContent.push(`绩效得分,${exportData.userData.performanceScore}`)
csvContent.push('')
// 机构详情部分
csvContent.push('机构详情')
csvContent.push('机构ID,机构名称,图片数量,得分')
exportData.institutions.forEach(inst => {
const score = inst.imageCount === 0 ? 0 : inst.imageCount === 1 ? 0.5 : 1
csvContent.push(`${inst.institutionId},${inst.name},${inst.imageCount},${score}`)
})
csvContent.push('')
// 图片详情部分
csvContent.push('图片详情')
csvContent.push('机构名称,图片名称,上传时间,文件大小')
exportData.institutions.forEach(inst => {
if (inst.images && inst.images.length > 0) {
inst.images.forEach(img => {
csvContent.push(`${inst.name},${img.name},${img.uploadTime},${img.size}`)
})
}
})
// 添加BOM以支持中文
const BOM = '\uFEFF'
const csvString = BOM + csvContent.join('\n')
const blob = new Blob([csvString], { type: 'text/csv;charset=utf-8' })
const url = URL.createObjectURL(blob)
const link = document.createElement('a')
link.href = url
link.download = `${userName}_${currentMonth}_数据导出.csv`
document.body.appendChild(link)
link.click()
document.body.removeChild(link)
URL.revokeObjectURL(url)
}
/**
* 导出用户数据为ZIP压缩包格式
*/
const exportUserDataAsZIP = async (exportData, userName, currentMonth) => {
try {
const zip = new JSZip()
let totalImages = 0
let addedImages = 0
console.log('开始生成用户ZIP文件:', { userName, currentMonth, institutions: exportData.institutions.length })
// 创建用户数据摘要文件
const summaryData = {
exportInfo: exportData.exportInfo,
userData: exportData.userData,
institutionSummary: exportData.institutions.map(inst => ({
id: inst.id,
institutionId: inst.institutionId,
name: inst.name,
imageCount: inst.imageCount
}))
}
zip.file(`${userName}_数据摘要.json`, JSON.stringify(summaryData, null, 2))
// 按机构创建文件夹并添加图片
console.log('=== 开始处理机构和图片数据 ===')
console.log('导出数据结构:', {
institutionsCount: exportData.institutions.length,
institutions: exportData.institutions.map(inst => ({
name: inst.name,
id: inst.id,
institutionId: inst.institutionId,
imageCount: inst.images ? inst.images.length : 0,
hasImages: !!(inst.images && inst.images.length > 0)
}))
})
for (const institution of exportData.institutions) {
console.log(`\n--- 处理机构: ${institution.name} ---`)
console.log('机构详细信息:', {
id: institution.id,
institutionId: institution.institutionId,
name: institution.name,
imageCount: institution.imageCount,
imagesArrayLength: institution.images ? institution.images.length : 0,
imagesExists: !!institution.images
})
if (institution.images && institution.images.length > 0) {
const folderName = `${institution.name}_${institution.institutionId}`
totalImages += institution.images.length
console.log(`机构 ${institution.name} 的图片列表:`)
institution.images.forEach((img, index) => {
console.log(` 图片 ${index + 1}:`, {
id: img.id,
name: img.name,
hasUrl: !!img.url,
urlType: img.url ? typeof img.url : 'undefined',
urlLength: img.url ? img.url.length : 0,
urlPrefix: img.url ? img.url.substring(0, 50) + '...' : 'N/A',
size: img.size,
uploadTime: img.uploadTime
})
})
for (const [index, image] of institution.images.entries()) {
try {
console.log(`\n处理图片 ${index + 1}/${institution.images.length}: ${image.name}`)
// 详细检查图片URL
if (!image.url) {
console.error(`❌ 图片缺少URL数据:`, {
imageName: image.name,
imageId: image.id,
imageObject: image,
institutionName: institution.name
})
continue
}
// 检查URL格式
if (typeof image.url !== 'string') {
console.error(`❌ 图片URL不是字符串:`, {
imageName: image.name,
urlType: typeof image.url,
url: image.url
})
continue
}
// 检查是否是Base64格式
if (!image.url.startsWith('data:')) {
console.error(`❌ 图片URL不是Base64格式:`, {
imageName: image.name,
urlPrefix: image.url.substring(0, 100)
})
continue
}
// 从Base64数据中提取图片数据
const base64Data = image.url.split(',')[1]
if (base64Data) {
// 获取文件扩展名
const mimeType = image.url.split(';')[0].split(':')[1]
const extension = mimeType.split('/')[1] || 'jpg'
const fileName = `${image.name.replace(/\.[^/.]+$/, '')}.${extension}`
zip.file(`${folderName}/${fileName}`, base64Data, { base64: true })
addedImages++
console.log(`✅ 已添加图片: ${folderName}/${fileName}`, {
mimeType,
extension,
base64Length: base64Data.length
})
} else {
console.error(`❌ 图片Base64数据无效:`, {
imageName: image.name,
url: image.url,
splitResult: image.url.split(',')
})
}
} catch (error) {
console.error(`❌ 处理图片失败: ${image.name}`, {
error: error.message,
stack: error.stack,
imageData: image
})
}
}
} else {
console.log(`机构 ${institution.name} 没有图片数据`)
}
}
console.log(`ZIP文件生成统计: 总图片数 ${totalImages}, 成功添加 ${addedImages}`)
// 生成并下载ZIP文件
const content = await zip.generateAsync({
type: 'blob',
compression: 'DEFLATE',
compressionOptions: { level: 6 }
})
saveAs(content, `${userName}_${currentMonth}_图片数据包.zip`)
// 显示成功消息
if (addedImages > 0) {
ElMessage.success(`ZIP文件生成成功！包含 ${addedImages} 张图片`)
} else {
ElMessage.warning('ZIP文件生成成功，但未包含图片（可能该用户暂无图片数据）')
}
} catch (error) {
console.error('生成ZIP文件失败:', error)
throw new Error('生成ZIP文件失败')
}
}
......@@ -2531,10 +2172,10 @@ const handleImportData = async () => {
// 读取文件内容
const reader = new FileReader()
reader.onload = (e) => {
reader.onload = async (e) => {
try {
const jsonData = e.target.result
const success = dataStore.importData(jsonData)
const success = await dataStore.importData(jsonData)
if (success) {
ElMessage.success('数据导入成功！页面将刷新以应用新数据。')
......@@ -2594,7 +2235,7 @@ const showMonthlyResetConfirm = async () => {
// 执行月度重置
console.log('开始执行月度重置...')
const result = dataStore.manualMonthlyReset()
const result = await dataStore.manualMonthlyReset()
console.log('月度重置结果:', result)
if (result && result.success) {
......@@ -2655,136 +2296,46 @@ const loadLastResetTime = async () => {
/**
* 加载可用的历史月份
*/
const loadAvailableMonths = () => {
availableMonths.value = dataStore.getAvailableHistoryMonths()
console.log('可用历史月份:', availableMonths.value)
}
/**
* 保存当前月份统计数据
*/
const saveCurrentMonthStats = async () => {
const loadAvailableMonths = async () => {
try {
await ElMessageBox.confirm(
'确定要保存当前月份的统计数据吗？\n' +
'这将记录所有用户的当前绩效数据。',
'保存月度统计',
{
type: 'info',
confirmButtonText: '保存',
cancelButtonText: '取消'
}
)
saveStatsLoading.value = true
const success = await dataStore.saveCurrentMonthStats()
if (success) {
ElMessage.success('当前月份统计数据保存成功！')
loadAvailableMonths() // 刷新可用月份列表
} else {
ElMessage.error('保存统计数据失败！')
}
availableMonths.value = await dataStore.getAvailableHistoryMonths()
console.log('可用历史月份:', availableMonths.value)
} catch (error) {
if (error !== 'cancel') {
console.error('保存统计数据失败:', error)
ElMessage.error('保存统计数据失败！')
}
} finally {
saveStatsLoading.value = false
console.error('加载历史月份失败:', error)
availableMonths.value = []
}
}
/**
* 加载指定月份的历史数据
*/
const loadHistoryMonth = (monthKey) => {
const loadHistoryMonth = async (monthKey) => {
if (!monthKey) {
selectedMonthData.value = null
return
}
const monthData = dataStore.getMonthStats(monthKey)
if (monthData) {
selectedMonthData.value = monthData
console.log(`加载 ${monthKey} 月份数据:`, monthData)
} else {
ElMessage.error('加载历史数据失败！')
selectedMonthData.value = null
}
}
/**
* 删除选中月份的数据
*/
const deleteSelectedMonth = async () => {
if (!selectedHistoryMonth.value) return
try {
await ElMessageBox.confirm(
`确定要删除 ${formatMonthLabel(selectedHistoryMonth.value)} 的历史数据吗？\n` +
'此操作不可恢复！',
'删除历史数据',
{
type: 'warning',
confirmButtonText: '删除',
cancelButtonText: '取消'
}
)
const success = dataStore.deleteMonthStats(selectedHistoryMonth.value)
if (success) {
ElMessage.success('历史数据删除成功！')
selectedHistoryMonth.value = ''
selectedMonthData.value = null
loadAvailableMonths() // 刷新可用月份列表
const monthData = await dataStore.getMonthStats(monthKey)
if (monthData) {
selectedMonthData.value = monthData
console.log(`加载 ${monthKey} 月份数据:`, monthData)
} else {
ElMessage.error('删除历史数据失败！')
ElMessage.error('加载历史数据失败！')
selectedMonthData.value = null
}
} catch (error) {
if (error !== 'cancel') {
console.error('删除历史数据失败:', error)
ElMessage.error('删除历史数据失败！')
}
console.error(`加载 ${monthKey} 月份数据失败:`, error)
ElMessage.error('加载历史数据失败！')
selectedMonthData.value = null
}
}
/**
* 清空所有历史数据
*/
const clearHistoryStats = async () => {
try {
await ElMessageBox.confirm(
'确定要清空所有历史统计数据吗？\n' +
'此操作将删除所有月份的历史记录，不可恢复！',
'清空历史数据',
{
type: 'error',
confirmButtonText: '清空',
cancelButtonText: '取消'
}
)
clearHistoryLoading.value = true
const success = dataStore.clearAllHistoryStats()
if (success) {
ElMessage.success('所有历史数据已清空！')
selectedHistoryMonth.value = ''
selectedMonthData.value = null
availableMonths.value = []
} else {
ElMessage.error('清空历史数据失败！')
}
} catch (error) {
if (error !== 'cancel') {
console.error('清空历史数据失败:', error)
ElMessage.error('清空历史数据失败！')
}
} finally {
clearHistoryLoading.value = false
}
}
/**
* 处理历史数据导出命令
......@@ -2793,6 +2344,8 @@ const handleHistoryExportCommand = (command) => {
exportHistoryData(command)
}
/**
* 导出历史数据
*/
......@@ -2835,7 +2388,8 @@ const exportHistoryData = async (format = 'json') => {
name: inst.name,
imageCount: inst.imageCount
}))
}))
})),
institutionsData: monthData.institutionsData || [] // 新增：历史机构图片数据
}
// 根据格式导出
......@@ -2949,40 +2503,63 @@ const exportHistoryDataAsZIP = async (exportData, month) => {
zip.file(`用户绩效统计_${month}.json`, JSON.stringify(performanceData, null, 2))
// 按用户和机构创建多级文件夹并添加图片
// 注意：历史数据可能没有完整的图片信息，需要从当前数据中获取
for (const user of exportData.userDetails) {
const userFolderName = user.userName
// 从历史数据中获取图片信息
let totalImages = 0
let addedImages = 0
// 获取当前用户的机构数据以获取图片
const currentUser = dataStore.getUserById(user.userId)
if (currentUser) {
const userInstitutions = dataStore.getInstitutionsByUserId(user.userId)
if (exportData.institutionsData && exportData.institutionsData.length > 0) {
console.log('从历史数据中获取图片信息:', exportData.institutionsData.length, '个机构')
// 按用户分组机构数据
const institutionsByUser = {}
for (const institution of exportData.institutionsData) {
const userId = institution.ownerId
if (!institutionsByUser[userId]) {
institutionsByUser[userId] = []
}
institutionsByUser[userId].push(institution)
}
// 为每个用户创建文件夹并添加图片
for (const user of exportData.userDetails) {
const userFolderName = user.userName
const userInstitutions = institutionsByUser[user.userId] || []
for (const institution of userInstitutions) {
if (institution.images && institution.images.length > 0) {
const institutionFolderName = `${institution.name}_${institution.institutionId}`
totalImages += institution.images.length
for (const image of institution.images) {
for (let imageIndex = 0; imageIndex < institution.images.length; imageIndex++) {
const image = institution.images[imageIndex]
try {
// 从Base64数据中提取图片数据
const base64Data = image.url.split(',')[1]
if (base64Data) {
// 获取文件扩展名
const mimeType = image.url.split(';')[0].split(':')[1]
const extension = mimeType.split('/')[1] || 'jpg'
const fileName = `${image.name.replace(/\.[^/.]+$/, '')}.${extension}`
zip.file(`${userFolderName}/${institutionFolderName}/${fileName}`, base64Data, { base64: true })
if (image.url && image.url.includes(',')) {
const base64Data = image.url.split(',')[1]
if (base64Data) {
// 获取文件扩展名
const mimeType = image.url.split(';')[0].split(':')[1]
const extension = mimeType.split('/')[1] || 'jpg'
// 使用图片ID或索引作为文件名
const fileName = `image_${image.id || (imageIndex + 1)}.${extension}`
zip.file(`${userFolderName}/${institutionFolderName}/${fileName}`, base64Data, { base64: true })
addedImages++
}
}
} catch (error) {
console.warn(`处理图片失败: ${image.name}`, error)
console.warn(`处理图片失败: ${image.id || imageIndex}`, error)
}
}
}
}
}
} else {
console.warn('历史数据中没有机构图片信息，可能是旧版本数据')
}
console.log(`历史数据ZIP文件生成统计: 总图片数 ${totalImages}, 成功添加 ${addedImages}`)
// 生成并下载ZIP文件
const content = await zip.generateAsync({
type: 'blob',
......@@ -2991,6 +2568,13 @@ const exportHistoryDataAsZIP = async (exportData, month) => {
})
saveAs(content, `历史数据_${month}_完整图片包.zip`)
// 显示成功消息
if (addedImages > 0) {
ElMessage.success(`历史数据ZIP文件生成成功！包含 ${addedImages} 张图片`)
} else {
ElMessage.warning('历史数据ZIP文件生成成功，但未包含图片（可能是旧版本历史数据）')
}
} catch (error) {
console.error('生成历史数据ZIP文件失败:', error)
throw new Error('生成历史数据ZIP文件失败')
......@@ -3025,7 +2609,7 @@ const getPerformanceTagType = (score) => {
/**
* 组件挂载时初始化
*/
onMounted(() => {
onMounted(async () => {
// 检查权限（数据和认证状态已在main.js中初始化）
if (!authStore.isAuthenticated || !authStore.isAdmin) {
router.push('/login')
......@@ -3035,10 +2619,10 @@ onMounted(() => {
console.log('管理员面板组件已挂载')
// 加载历史统计数据
loadAvailableMonths()
await loadAvailableMonths()
// 加载上次重置时间
loadLastResetTime()
await loadLastResetTime()
// 管理员面板初始化完成
})
......
src/views/auth/Login.vue
......@@ -82,12 +82,11 @@ const loginForm = reactive({
// 表单验证规则
const loginRules = {
phone: [
{ required: true, message: '请输入手机号', trigger: 'blur' },
{ min: 3, message: '手机号不能少于3位', trigger: 'blur' }
{ required: true, message: '请输入手机号', trigger: 'blur' }
],
password: [
{ required: true, message: '请输入密码', trigger: 'blur' },
{ min: 6, message: '密码不能少于6位', trigger: 'blur' }
{ min: 1, message: '请输入密码', trigger: 'blur' }
]
}
......
src/views/user/UserPanel.vue
......@@ -24,7 +24,7 @@
<div class="score-card">
<div class="score-title">已传机构数</div>
<div class="score-value">{{ uploadedInstitutionsCount }}</div>
<div class="score-desc">已上传图片的机构数量</div>
<div class="score-desc">已上传至少2张图片的机构数量</div>
</div>
</el-col>
<el-col :span="12">
......@@ -133,7 +133,7 @@
>
<img
:src="image.url"
:alt="image.name"
:alt="`图片 ${image.id}`"
@click="previewImage(image)"
/>
<div class="image-actions">
......@@ -146,12 +146,6 @@
删除
</el-button>
</div>
<div class="image-info">
<div class="image-name">{{ image.name }}</div>
<div class="upload-time">
{{ formatTime(image.uploadTime) }}
</div>
</div>
</div>
</div>
</div>
......@@ -184,7 +178,7 @@
<img
v-if="previewImage"
:src="previewImageData.url"
:alt="previewImageData.name"
:alt="`图片 ${previewImageData.id}`"
style="width: 100%; max-height: 70vh; object-fit: contain;"
/>
</div>
......@@ -271,10 +265,10 @@ const filteredInstitutions = computed(() => {
})
/**
* 计算属性：已传机构数
* 计算属性：已传机构数（至少2张图片才算完成）
*/
const uploadedInstitutionsCount = computed(() => {
return userInstitutions.value.filter(inst => inst.images && inst.images.length > 0).length
return userInstitutions.value.filter(inst => inst.images && inst.images.length >= 2).length
})
/**
......@@ -326,6 +320,77 @@ const getStatusText = (imageCount) => {
}
/**
* 检查重复图片（在用户所有机构中检查）
*/
const checkDuplicateImage = (newImageData) => {
// 获取用户所有机构的所有图片
const userInstitutions = dataStore.getInstitutionsByUserId(authStore.currentUser.id)
const allExistingImages = []
// 收集所有机构的图片，并记录来源机构
userInstitutions.forEach(institution => {
if (institution.images && institution.images.length > 0) {
institution.images.forEach(img => {
allExistingImages.push({
...img,
institutionName: institution.name // 记录图片来源机构
})
})
}
})
// 1. 检查文件名是否重复
const sameNameImage = allExistingImages.find(img => img.name === newImageData.name)
if (sameNameImage) {
return {
isDuplicate: true,
reason: `文件名 "${newImageData.name}" 已在机构 "${sameNameImage.institutionName}" 中存在，请重命名后再上传`
}
}
// 2. 检查文件大小和内容是否重复（通过Base64数据长度和部分内容比较）
const newDataUrl = newImageData.url
const newDataLength = newDataUrl.length
const newDataHash = newDataUrl.substring(0, 100) + newDataUrl.substring(newDataUrl.length - 100) // 取头尾100字符作为简单哈希
const sameContentImage = allExistingImages.find(img => {
if (!img.url) return false
const existingDataLength = img.url.length
const existingDataHash = img.url.substring(0, 100) + img.url.substring(img.url.length - 100)
// 如果数据长度相同且头尾内容相同，认为是重复图片
return existingDataLength === newDataLength && existingDataHash === newDataHash
})
if (sameContentImage) {
return {
isDuplicate: true,
reason: `检测到相同内容的图片，可能与机构 "${sameContentImage.institutionName}" 中的图片重复`
}
}
// 3. 检查原始文件大小是否完全相同（可能是同一文件）
const sameSizeImage = allExistingImages.find(img =>
img.originalSize && img.originalSize === newImageData.originalSize &&
img.name !== newImageData.name
)
if (sameSizeImage) {
return {
isDuplicate: true,
reason: `检测到相同大小的图片文件，可能与机构 "${sameSizeImage.institutionName}" 中的图片重复`
}
}
return {
isDuplicate: false,
reason: null
}
}
/**
* 压缩图片
*/
const compressImage = (file, callback, quality = 0.7, maxWidth = 1200) => {
......@@ -408,7 +473,7 @@ const beforeUpload = (file, institutionId) => {
/**
* 处理图片上传
*/
const handleImageUpload = (uploadFile, institutionId) => {
const handleImageUpload = async (uploadFile, institutionId) => {
console.log('开始处理图片上传:', { uploadFile, institutionId })
const file = uploadFile.raw
......@@ -443,16 +508,6 @@ const handleImageUpload = (uploadFile, institutionId) => {
// 数据库模式下，数据直接从内存状态获取
console.log('数据库模式：机构数据来自 API')
// 验证机构ID匹配
if (savedInstitution && savedInstitution.id !== institutionId) {
console.error('机构ID不匹配:', {
expected: institutionId,
found: savedInstitution.id
})
ElMessage.error('机构ID不匹配，请刷新页面重试!')
return
}
// 🔒 权限验证：确保当前用户有权限操作此机构
if (institution.ownerId !== authStore.currentUser.id) {
console.error('❌ 权限验证失败:', {
......@@ -485,7 +540,7 @@ const handleImageUpload = (uploadFile, institutionId) => {
console.log('文件验证通过，开始压缩图片:', file.name, file.size)
// 压缩并读取文件
compressImage(file, (compressedDataUrl) => {
compressImage(file, async (compressedDataUrl) => {
console.log('图片压缩完成，数据大小:', compressedDataUrl.length)
const imageData = {
......@@ -503,56 +558,37 @@ const handleImageUpload = (uploadFile, institutionId) => {
console.log('上传前机构图片数量:', institution.images.length)
console.log('上传前localStorage数据:', localStorage.getItem('score_system_institutions'))
// 🔍 在实际上传前进行重复检测
const duplicateCheck = dataStore.detectDuplicateImage(imageData, authStore.currentUser.id)
// 🔍 重复图片检测：检查用户所有机构中是否有重复图片
const duplicateCheck = checkDuplicateImage(imageData)
if (duplicateCheck.isDuplicate) {
if (!duplicateCheck.allowUpload) {
// 完全重复，禁止上传
ElMessage.error(duplicateCheck.message)
return
} else {
// 轻微编辑或同名不同内容，显示警告但允许上传
ElMessage.warning(duplicateCheck.message)
}
ElMessage.error(`图片上传失败：${duplicateCheck.reason}`)
return // 阻止上传
}
const result = dataStore.addImageToInstitution(
institutionId,
imageData,
authStore.currentUser.id,
{ expectedName: institution.name, expectedInstitutionId: institution.institutionId }
)
if (result) {
console.log('图片添加成功:', result)
// 上传后的数据状态
console.log('上传后机构图片数量:', institution.images.length)
console.log('上传后localStorage数据:', localStorage.getItem('score_system_institutions'))
ElMessage.success('图片上传成功!')
// 强制刷新当前页面数据（确保响应式更新）
nextTick(() => {
console.log('nextTick后机构数据:', institution.images.length)
// 准备图片数据，添加必要的ID和时间戳
const imageDataWithId = {
...imageData,
id: `img_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
}
// 验证数据是否真的保存到localStorage
const savedData = JSON.parse(localStorage.getItem('score_system_institutions') || '[]')
const savedInstitution = savedData.find(inst => inst.id === institutionId)
console.log('localStorage中的机构数据:', savedInstitution?.images?.length || 0)
try {
const result = await dataStore.addImageToInstitution(institutionId, imageDataWithId)
// 强制重新加载数据以确保界面更新
dataStore.loadFromStorage()
if (result) {
console.log('图片添加成功:', result)
ElMessage.success('图片上传成功!')
// 再次验证界面数据（只从用户机构中查找）
const userInstitutions = dataStore.getInstitutionsByUserId(authStore.currentUser.id)
const updatedInstitution = userInstitutions.find(inst => inst.id === institutionId)
console.log('重新加载后机构图片数量:', updatedInstitution?.images?.length || 0)
})
} else {
console.error('图片添加失败，返回 null')
ElMessage.error('图片上传失败!')
// 强制刷新当前页面数据（确保响应式更新）
nextTick(() => {
console.log('nextTick后机构数据:', institution.images.length)
})
} else {
console.error('图片添加失败，返回 null')
ElMessage.error('图片上传失败!')
}
} catch (error) {
console.error('图片上传异常:', error)
ElMessage.error(`图片上传失败: ${error.message}`)
}
} catch (error) {
console.error('图片上传异常:', error)
......@@ -576,24 +612,17 @@ const removeImage = async (institutionId, imageId) => {
console.log('开始删除图片:', { institutionId, imageId })
// 传递当前用户ID进行权限验证
const success = dataStore.removeImageFromInstitution(institutionId, imageId, authStore.currentUser.id)
// 等待删除操作完成
await dataStore.removeImageFromInstitution(institutionId, imageId)
if (success) {
console.log('图片删除成功')
ElMessage.success('图片删除成功!')
console.log('图片删除成功')
ElMessage.success('图片删除成功!')
// 强制刷新数据确保界面更新
nextTick(async () => {
// 重新加载数据以确保界面同步
await dataStore.loadData()
// 验证删除结果
const userInstitutions = dataStore.getInstitutionsByUserId(authStore.currentUser.id)
const institution = userInstitutions.find(inst => inst.id === institutionId)
console.log('删除后机构图片数量:', institution?.images.length || 0)
// 验证删除结果
const userInstitutions = dataStore.getInstitutionsByUserId(authStore.currentUser.id)
const institution = userInstitutions.find(inst => inst.id === institutionId)
console.log('删除后机构图片数量:', institution?.images.length || 0)
})
}
} catch (error) {
if (error.message && error.message.includes('🚨')) {
// 安全错误
......@@ -617,14 +646,6 @@ const previewImage = (image) => {
}
/**
* 格式化时间
*/
const formatTime = (timeString) => {
const date = new Date(timeString)
return date.toLocaleString('zh-CN')
}
/**
* 处理页面切换
*/
const handlePageChange = (page) => {
......@@ -634,11 +655,16 @@ const handlePageChange = (page) => {
/**
* 刷新数据
*/
const refreshData = () => {
// 只刷新认证状态，不重新加载存储数据（避免丢失用户上传的图片）
authStore.restoreAuth()
currentPage.value = 1 // 重置分页
ElMessage.success('数据刷新成功!')
const refreshData = async () => {
try {
// 重新从数据库加载最新数据
await dataStore.loadFromDatabase()
currentPage.value = 1 // 重置分页
ElMessage.success('数据刷新成功!')
} catch (error) {
console.error('刷新数据失败:', error)
ElMessage.error('数据刷新失败，请稍后重试')
}
}
......@@ -667,8 +693,9 @@ const handleLogout = async () => {
await ElMessageBox.confirm('确定要退出登录吗？', '确认退出', {
type: 'warning'
})
authStore.logout()
// 等待登出完成后再跳转
await authStore.logout()
router.push('/login')
ElMessage.success('已退出登录')
} catch {
......@@ -897,10 +924,6 @@ onMounted(() => {
white-space: nowrap;
}
.upload-time {
color: #909399;
}
.empty-state {
text-align: center;
padding: 40px;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment