v1.2.100 - 性能优化与小程序兼容

- 修复藏品列表N+1查询问题(图片预加载)
- Stats API改用SQL聚合查询
- 新增成交行情分类汇总API
- Cookie登录支持(小程序webview兼容)
- 寻配号网络匹配扩展到所有藏品
This commit is contained in:
龙大 2026-04-16 14:27:41 +08:00
commit 4c92f4e070
78 changed files with 17589 additions and 0 deletions

1
VERSION Normal file
View File

@ -0,0 +1 @@
1.2.100

9
backend/.dockerignore Normal file
View File

@ -0,0 +1,9 @@
__pycache__/
*.pyc
*.pyo
.git
.env
uploads/*
!uploads/.gitkeep
logs/*
*.log

26
backend/.env.example Normal file
View File

@ -0,0 +1,26 @@
# 数据库配置
DATABASE_URL=postgresql://postgres:postgres@localhost:5432/zodiac
# JWT配置
SECRET_KEY=your-production-secret-key-change-this
ACCESS_TOKEN_EXPIRE_MINUTES=60
# 阿里云 DashScope OCR API必须配置
DASHSCOPE_API_KEY=sk-9389024a37da4f7bb455ac9a6b28776f
# 阿里云 OSS配置
OSS_ACCESS_KEY_ID=LTAI5t6HUnpFBLEK9194kPVG
OSS_ACCESS_KEY_SECRET=LEr4Q8yRxb8D5b24cKfCwlt4MMoke1
OSS_BUCKET_NAME=jiachenlong-oss
OSS_ENDPOINT=oss-cn-hangzhou.aliyuncs.com
OSS_PUBLIC_URL=https://jiachenlong-oss.oss-cn-hangzhou.aliyuncs.com
# 阿里云短信配置(必须配置!)
SMS_ACCESS_KEY_ID=LTAI5tQAx5niD7JQVqGE5acE
SMS_ACCESS_KEY_SECRET=QsQFAEKBkaNynIoKyvdIi3BUyWVZu1
SMS_SIGN_NAME=苏州算力
SMS_TEMPLATE_CODE=SMS_501590956
# 服务配置
PORT=3000
HOST=0.0.0.0

25
backend/Dockerfile Normal file
View File

@ -0,0 +1,25 @@
# FastAPI 后端 Docker 镜像
FROM python:3.12-slim
WORKDIR /app
# 安装系统依赖
RUN apt-get update && apt-get install -y \
curl \
&& rm -rf /var/lib/apt/lists/*
# 安装 Python 依赖
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# 复制应用代码
COPY . .
# 创建上传目录
RUN mkdir -p uploads
# 暴露端口
EXPOSE 3000
# 启动命令
CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "3000"]

42
backend/README.md Normal file
View File

@ -0,0 +1,42 @@
# 后端服务 - FastAPI
## 启动方式
### 开发环境
```bash
# 安装依赖
pip install -r requirements.txt
# 启动服务
python -m uvicorn app.main:app --port 3000 --host 0.0.0.0 --reload
```
### 生产环境
```bash
# 后台运行
nohup python -m uvicorn app.main:app --port 3000 --host 0.0.0.0 > /tmp/uvicorn.log 2>&1 &
# 或使用 systemd
sudo systemctl start zodiac-backend
```
## 配置说明
编辑 `.env` 文件:
```ini
# 数据库
DATABASE_URL=postgresql://postgres:密码@localhost:5432/zodiac
# JWT
SECRET_KEY=你的密钥
# OCR API
DASHSCOPE_API_KEY=sk-你的密钥
```
## API 文档
启动后访问http://localhost:3000/docs

1
backend/VERSION Normal file
View File

@ -0,0 +1 @@
1.2.100

View File

89
backend/app/core/auth.py Normal file
View File

@ -0,0 +1,89 @@
# 认证模块
import os
import bcrypt
from datetime import datetime, timedelta
from typing import Optional
from fastapi import Depends, HTTPException, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from jose import JWTError, jwt
from sqlalchemy.orm import Session
from app.core.database import SessionLocal
from app.models.models import User
# 配置
SECRET_KEY = os.getenv("SECRET_KEY")
if not SECRET_KEY:
raise ValueError("SECRET_KEY environment variable is not set. Please configure it in production!")
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = int(os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES", "10080")) # 7天
# HTTP Bearer 认证
security = HTTPBearer(auto_error=False)
def verify_password(plain_password: str, hashed_password: str) -> bool:
"""验证密码"""
try:
return bcrypt.checkpw(plain_password.encode('utf-8'), hashed_password.encode('utf-8'))
except Exception:
return False
def get_password_hash(password: str) -> str:
"""生成密码哈希"""
return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
def create_access_token(data: dict, expires_delta: Optional[timedelta] = None) -> str:
"""创建访问令牌"""
to_encode = data.copy()
if expires_delta:
expire = datetime.utcnow() + expires_delta
else:
expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
to_encode.update({"exp": expire})
encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
return encoded_jwt
def decode_access_token(token: str) -> Optional[dict]:
"""解码访问令牌"""
try:
payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
return payload
except JWTError:
return None
def get_current_user(
credentials: Optional[HTTPAuthorizationCredentials] = Depends(security),
db: Session = Depends(lambda: SessionLocal())
) -> Optional[User]:
"""获取当前用户可返回None"""
if not credentials:
return None
token = credentials.credentials
payload = decode_access_token(token)
if not payload:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="无效的令牌",
headers={"WWW-Authenticate": "Bearer"},
)
user_id: str = payload.get("sub")
if not user_id:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="无效的令牌",
headers={"WWW-Authenticate": "Bearer"},
)
user = db.query(User).filter(User.f99_90_id == user_id).first()
if not user:
return None
return user

View File

@ -0,0 +1,37 @@
import os
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.pool import QueuePool
COOLBOT_DB_URL = os.getenv(
"COOLBOT_DB_URL",
"postgresql://coolbot:Coolbot123@pgm-bp1t1008h019ez6cno.pg.rds.aliyuncs.com:5432/coolbot_data"
)
coolbot_engine = create_engine(
COOLBOT_DB_URL,
poolclass=QueuePool,
pool_size=10,
max_overflow=20,
pool_timeout=30,
pool_recycle=1800,
pool_pre_ping=True,
echo=False,
connect_args={
"connect_timeout": 10,
"application_name": "zodiac-coolbot"
}
)
CoolbotSession = sessionmaker(autocommit=False, autoflush=False, bind=coolbot_engine)
def get_coolbot_db():
"""获取coolbot数据库会话"""
db = CoolbotSession()
try:
yield db
except Exception:
db.rollback()
raise
finally:
db.close()

View File

@ -0,0 +1,69 @@
import os
import time
from sqlalchemy import create_engine, event
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from sqlalchemy.pool import QueuePool
from typing import Generator
import logging
logger = logging.getLogger(__name__)
DATABASE_URL = os.getenv(
"DATABASE_URL",
"postgresql://postgres:postgres@127.0.0.1:5432/zodiac"
)
# 增强版数据库引擎配置
engine = create_engine(
DATABASE_URL,
# 连接池配置
poolclass=QueuePool,
pool_size=20, # 常规连接数
max_overflow=40, # 允许超出的连接数(高并发时)
pool_timeout=30, # 获取连接超时时间(秒)
pool_recycle=1800, # 连接回收时间30分钟避免连接过期
pool_pre_ping=True, # 每次获取连接前检查连接是否有效
echo=False,
# 连接参数优化
connect_args={
"connect_timeout": 10,
"application_name": "zodiac-api",
"options": "-c statement_timeout=30000" # 查询超时30秒
}
)
# 添加连接事件监听器
@event.listens_for(engine, "connect")
def set_connect_timeout(dbapi_conn, connection_record):
"""设置连接参数"""
cursor = dbapi_conn.cursor()
cursor.execute("SET statement_timeout = 30000")
cursor.close()
@event.listens_for(engine, "checkout")
def check_connection(dbapi_conn, connection_record, connection_proxy):
"""检出连接时检查"""
try:
cursor = dbapi_conn.cursor()
cursor.execute("SELECT 1")
cursor.close()
except Exception as e:
logger.warning(f"连接检查失败: {e}")
raise Exception("数据库连接无效")
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()
def get_db() -> Generator:
"""获取数据库会话,带错误处理"""
db = SessionLocal(expire_on_commit=False)
try:
yield db
except Exception as e:
logger.error(f"数据库会话错误: {e}")
db.rollback()
raise
finally:
db.close()

View File

@ -0,0 +1,174 @@
# 统一错误处理
from fastapi import FastAPI, Request, HTTPException, status
from fastapi.responses import JSONResponse
from fastapi.exceptions import RequestValidationError
from pydantic import ValidationError
from app.core.logging_config import logger
# 错误码定义
ERROR_CODES = {
# 认证错误 (10-19)
401: "E00010", # 未授权
403: "E00014", # 禁止访问
# 验证错误 (20-29)
400: "E00000", # 请求错误
422: "E00000", # 验证错误
# 资源错误 (30-39)
404: "E00033", # 资源不存在
# 服务器错误 (50-59)
500: "E00003", # 服务器内部错误
}
# 错误信息映射
ERROR_MESSAGES = {
"E00010": "未登录或登录已过期",
"E00011": "用户名或密码错误",
"E00012": "验证码错误",
"E00014": "无权访问此资源",
"E00015": "令牌无效或已过期",
"E00020": "请输入用户名和密码",
"E00021": "用户名至少 3 个字符",
"E00022": "密码至少 6 个字符",
"E00023": "用户名已存在",
"E00024": "邮箱已被注册",
"E00030": "藏品名称不能为空",
"E00031": "藏品名称至少 2 个字符",
"E00032": "藏品分类不能为空",
"E00033": "藏品不存在",
"E00034": "禁止重复:此冠字号已存在",
"E00035": "成本价格必须>=0",
"E00036": "目标价格必须>=0",
"E00037": "发行年份必须是 4 位数字",
"E00040": "请选择图片文件",
"E00041": "图片尺寸太小,无法识别",
"E00042": "OCR 识别失败,请重试",
"E00050": "仅管理员可访问",
"E00051": "用户不存在",
"E00000": "请求失败",
"E00001": "网络连接失败",
"E00003": "服务器内部错误",
}
def setup_error_handlers(app: FastAPI):
"""设置全局错误处理器"""
@app.exception_handler(HTTPException)
async def http_exception_handler(request: Request, exc: HTTPException):
"""处理 HTTP 异常"""
# 从 detail 中提取错误码
detail = exc.detail
error_code = ERROR_CODES.get(exc.status_code, "E00000")
# 如果 detail 已经包含错误码,直接使用
if isinstance(detail, str) and detail.startswith("E"):
parts = detail.split(":", 1)
error_code = parts[0]
message = parts[1].strip() if len(parts) > 1 else ERROR_MESSAGES.get(error_code, detail)
else:
message = ERROR_MESSAGES.get(error_code, detail if isinstance(detail, str) else "请求失败")
return JSONResponse(
status_code=exc.status_code,
content={
"error": {
"code": error_code,
"message": message,
"status": exc.status_code
}
}
)
@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
"""处理请求验证错误"""
errors = exc.errors()
if errors:
error = errors[0]
field = ".".join(str(x) for x in error.get("loc", []))
msg = error.get("msg", "验证失败")
# 根据字段和消息匹配错误码
# 先检查请求路径,区分用户接口和藏品接口
path = request.url.path
if "cost_price" in field or "价格" in msg:
error_code = "E00035"
message = "成本价格必须>=0"
elif "target_price" in field:
error_code = "E00036"
message = "目标价格必须>=0"
elif "issue_year" in field or "年份" in msg:
error_code = "E00037"
message = "发行年份必须是 4 位数字"
elif "name" in field:
# 根据路径区分用户 name 和藏品 name
if "/auth/" in path or "/users/" in path or "/admin/users/" in path:
error_code = "E00021"
message = "用户名至少 3 个字符"
else:
error_code = "E00031"
message = "藏品名称至少 2 个字符"
elif "category" in field:
error_code = "E00032"
message = "藏品分类不能为空"
else:
error_code = "E00000"
message = f"{field}: {msg}"
return JSONResponse(
status_code=422,
content={
"error": {
"code": error_code,
"message": message,
"status": 422,
"field": field
}
}
)
return JSONResponse(
status_code=422,
content={
"error": {
"code": "E00000",
"message": "验证失败",
"status": 422
}
}
)
@app.exception_handler(404)
async def not_found_handler(request: Request, exc: Exception):
"""处理 404 错误"""
return JSONResponse(
status_code=404,
content={
"error": {
"code": "E00033",
"message": "接口不存在",
"status": 404
}
}
)
@app.exception_handler(Exception)
async def general_exception_handler(request: Request, exc: Exception):
"""处理未捕获的异常"""
import traceback
error_trace = traceback.format_exc()
logger.error(f"未捕获异常:{str(exc)}\n{error_trace}")
return JSONResponse(
status_code=500,
content={
"error": {
"code": "E00003",
"message": "服务器内部错误",
"status": 500
}
}
)

View File

@ -0,0 +1,113 @@
# 日志系统配置
import logging
import json
import os
from datetime import datetime
from typing import Optional
import uuid
from logging.handlers import RotatingFileHandler
class JSONFormatter(logging.Formatter):
"""JSON 格式日志处理器"""
def format(self, record):
log_data = {
'timestamp': datetime.utcnow().isoformat() + 'Z',
'level': record.levelname,
'logger': record.name,
'message': record.getMessage(),
'trace_id': getattr(record, 'trace_id', str(uuid.uuid4())),
'user_id': getattr(record, 'user_id', None),
'request_id': getattr(record, 'request_id', str(uuid.uuid4())),
'ip_address': getattr(record, 'ip_address', None),
'duration_ms': getattr(record, 'duration_ms', None),
}
# 添加额外字段
if hasattr(record, 'data'):
log_data['data'] = record.data
# 添加异常信息
if record.exc_info:
log_data['exception'] = self.formatException(record.exc_info)
return json.dumps(log_data, ensure_ascii=False, default=str)
def setup_logging(
log_file: str = 'logs/app.log',
level: str = 'INFO',
max_bytes: int = 10*1024*1024, # 10MB
backup_count: int = 5
):
"""配置日志系统"""
# 创建日志目录
os.makedirs(os.path.dirname(log_file), exist_ok=True)
# 根日志器
logger = logging.getLogger()
logger.setLevel(level)
# 清空现有处理器
logger.handlers.clear()
# 文件处理器(带轮转)
file_handler = RotatingFileHandler(
log_file,
maxBytes=max_bytes,
backupCount=backup_count,
encoding='utf-8'
)
file_handler.setFormatter(JSONFormatter())
logger.addHandler(file_handler)
# 控制台处理器(仅开发环境)
if os.getenv('ENV', 'development') == 'development':
console_handler = logging.StreamHandler()
console_handler.setFormatter(JSONFormatter())
logger.addHandler(console_handler)
return logger
# 创建日志器实例
logger = setup_logging()
# 日志装饰器
def log_operation(operation_name: str):
"""记录操作日志的装饰器"""
def decorator(func):
import functools
@functools.wraps(func)
def wrapper(*args, **kwargs):
import time
start_time = time.time()
try:
result = func(*args, **kwargs)
duration = (time.time() - start_time) * 1000
logger.info(
f"{operation_name} 成功",
extra={
'duration_ms': duration,
'data': {'function': func.__name__}
}
)
return result
except Exception as e:
duration = (time.time() - start_time) * 1000
logger.error(
f"{operation_name} 失败:{str(e)}",
extra={
'duration_ms': duration,
'data': {'function': func.__name__, 'error': str(e)}
},
exc_info=True
)
raise
return wrapper
return decorator

115
backend/app/main.py Normal file
View File

@ -0,0 +1,115 @@
# FastAPI 应用入口
import os
from pathlib import Path
from dotenv import load_dotenv
load_dotenv()
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from fastapi.staticfiles import StaticFiles
from app.core.database import engine, Base
from app.core.logging_config import logger, setup_logging
from app.core.error_handler import setup_error_handlers
from app.middleware.logging import logging_middleware
from app.routers import auth, collections, operations
from app.routers import ocr as ocr_router
from app.routers import users as users_router
from app.routers import information as information_router
from app.routers import yichens as yichens_router
from app.routers import seek as seek_router
from app.routers import deal as deal_router
# 版本信息 - 从 config/VERSION 文件读取
def get_version():
"""从 config/VERSION 文件读取版本号"""
try:
version_file = Path(__file__).parent.parent.parent / "config" / "VERSION"
if version_file.exists():
with open(version_file, 'r', encoding='utf-8') as f:
for line in f:
if line.startswith('VERSION='):
return line.strip().split('=', 1)[1]
except Exception as e:
logger.error(f"读取 VERSION 文件失败:{e}")
return "0.0.0" # 默认版本号
__version__ = get_version()
__app_name__ = "甲辰收藏系统 FastAPI 后端"
# 启动时创建数据库表
Base.metadata.create_all(bind=engine)
# 初始化日志系统
setup_logging()
logger.info(f"{__app_name__} v{__version__} 启动成功")
# 创建 FastAPI 应用
app = FastAPI(
title=__app_name__,
version=__version__,
description="生肖纪念钞收藏管理系统后端 API"
)
# 设置全局错误处理器
setup_error_handlers(app)
# CORS 配置 - 生产环境限制域名
ALLOWED_ORIGINS = os.getenv("ALLOWED_ORIGINS", "http://47.103.29.111,http://120.55.81.21,https://socoolbot.com").split(",")
app.add_middleware(
CORSMiddleware,
allow_origins=ALLOWED_ORIGINS,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
# 挂载静态文件目录(图片上传和项目静态资源)
uploads_dir = "uploads"
os.makedirs(uploads_dir, exist_ok=True)
app.mount("/uploads", StaticFiles(directory=uploads_dir), name="uploads")
# 挂载项目静态资源目录
static_dir = Path(__file__).parent.parent / "static"
if static_dir.exists():
app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
# 添加日志中间件
app.middleware("http")(logging_middleware)
# 注册路由
app.include_router(auth.router)
app.include_router(collections.router)
app.include_router(operations.router)
app.include_router(ocr_router.router) # OCR 识别
app.include_router(users_router.router) # 当前用户接口
app.include_router(users_router.admin_router) # 管理员用户管理
app.include_router(information_router.router)
app.include_router(yichens_router.router) # 一尘看板
app.include_router(seek_router.router) # 寻配号
app.include_router(deal_router.router) # 成交行情
@app.get("/")
def root():
"""根路径"""
return {
"name": __app_name__,
"version": __version__,
"status": "running"
}
@app.get("/health")
def health_check():
"""健康检查"""
return {"status": "healthy"}
if __name__ == "__main__":
import uvicorn
port = int(os.getenv("PORT", "3000"))
uvicorn.run(app, host="0.0.0.0", port=port)
from app.routers import seek as seek_router
from app.routers import deal as deal_router

View File

@ -0,0 +1,88 @@
# 请求日志中间件 - 优化版
import time
import uuid
from fastapi import Request, Response
from app.core.logging_config import logger
async def logging_middleware(request: Request, call_next):
"""记录所有 API 请求的日志 - 优化版"""
# 生成请求 ID
request_id = str(uuid.uuid4())
start_time = time.time()
# 获取用户信息(如果已登录)
user_id = None
try:
auth_header = request.headers.get('Authorization', '')
if auth_header.startswith('Bearer '):
user_id = "authenticated"
except Exception as e:
# 静默失败,不影响主流程
pass
# 执行请求
response_status = 500
try:
response = await call_next(request)
response_status = response.status_code
except Exception as e:
duration = (time.time() - start_time) * 1000
try:
logger.error(
f"API 请求异常:{request.method} {request.url.path}",
extra={
'request_id': request_id,
'user_id': user_id,
'ip_address': request.client.host if request.client else None,
'duration_ms': duration,
'data': {
'method': request.method,
'path': request.url.path,
'query': str(request.query_params),
'error': str(e)
}
},
exc_info=True
)
except:
pass # 日志记录失败不影响主流程
raise
# 记录响应
duration = (time.time() - start_time) * 1000
try:
log_level = 'INFO'
if response_status >= 500:
log_level = 'ERROR'
elif response_status >= 400:
log_level = 'WARNING'
getattr(logger, log_level)(
f"API 请求完成:{request.method} {request.url.path}",
extra={
'request_id': request_id,
'user_id': user_id,
'ip_address': request.client.host if request.client else None,
'duration_ms': duration,
'data': {
'method': request.method,
'path': request.url.path,
'query': str(request.query_params),
'status_code': response_status
}
}
)
except Exception as e:
# 日志记录失败不影响主流程
pass
# 在响应头中添加请求 ID
try:
response.headers['X-Request-ID'] = request_id
except:
pass
return response

View File

View File

@ -0,0 +1,54 @@
from sqlalchemy import Column, String, Text, Float, Date, Boolean, Integer, DateTime
from sqlalchemy.sql import func
from app.core.database import Base
import uuid
def generate_uuid():
return str(uuid.uuid4())
class DealInfo(Base):
__tablename__ = "deal_info"
id = Column(String(36), primary_key=True, default=generate_uuid)
user_id = Column(String(36), nullable=True, index=True)
# 标题和内容
title = Column(String(255), nullable=False)
content = Column(Text, nullable=True)
# 成交信息
deal_price = Column(Float, nullable=True) # 成交价格
deal_date = Column(Date, nullable=True) # 成交日期
deal_no = Column(String(20), nullable=True, index=True) # 行情编号从A000001开始递增
# 包装和分类
packaging = Column(String(50), nullable=True) # 包装(标百/标十/单张)
category = Column(String(100), nullable=True) # 分类
# 评级相关
is_graded = Column(Boolean, default=False) # 是否评级
grading_company = Column(String(100), nullable=True) # 评级机构
grading_score = Column(String(50), nullable=True) # 评级分数
# 号码特征
tail_number = Column(String(10), nullable=True) # 尾号
size_type = Column(String(20), nullable=True) # 大小号
# 版别
version = Column(String(50), nullable=True) # 版别
# 交易信息
platform = Column(String(50), nullable=True) # 成交平台
seller = Column(String(100), nullable=True) # 出售者
buyer = Column(String(100), nullable=True) # 购买者
# 状态
status = Column(String(20), default="active")
# 统计
view_count = Column(Integer, default=0)
contact_count = Column(Integer, default=0)
# 时间
created_at = Column(DateTime(timezone=True), server_default=func.now())
updated_at = Column(DateTime(timezone=True), onupdate=func.now())

View File

@ -0,0 +1,268 @@
# 数据库模型 - 使用字段编码
from sqlalchemy import Column, String, Float, Boolean, DateTime, Integer, Text, ForeignKey, Date, UniqueConstraint
from sqlalchemy.orm import relationship
from sqlalchemy.sql import func
from app.core.database import Base
import uuid
def generate_uuid():
"""生成 UUID 字符串"""
return str(uuid.uuid4())
class User(Base):
__tablename__ = "users"
# f99 系统字段
f99_90_id = Column(String(36), primary_key=True, default=generate_uuid)
user_code = Column(String(10), unique=True, nullable=True, index=True) # 用户编码
f99_91_user_id = Column(String(36), unique=True, nullable=False, index=True)
f01_01_name = Column(String(255), unique=True, nullable=False, index=True) # username
email = Column(String(255), unique=True, nullable=True, index=True)
phone = Column(String(50), nullable=True)
avatar = Column(String(500), nullable=True)
address = Column(String(500), nullable=True)
bio = Column(Text, nullable=True)
password = Column(String(255), nullable=False)
role = Column(String(50), default="user")
# 时间字段
f99_92_created_at = Column(DateTime(timezone=True), server_default=func.now())
f99_93_updated_at = Column(DateTime(timezone=True), onupdate=func.now())
# 新增字段
f99_94_level = Column(String(20), default="青铜") # 会员等级
f99_95_ai_count = Column(Integer, default=0) # ai识别次数
f99_96_search_count = Column(Integer, default=0) # 寻号使用次数
f99_97_collection_count = Column(Integer, default=0) # 藏品数量
f01_06_phone_verified = Column(Boolean, default=False) # 手机号已核验
f99_98_login_count = Column(Integer, default=0) # 登录次数
f99_99_last_login = Column(DateTime(timezone=True), nullable=True) # 最后登录时间
f01_07_gender = Column(String(10), nullable=True) # 性别
f01_08_birthday = Column(Date, nullable=True) # 生日
f01_09_region = Column(String(100), nullable=True) # 地区
f01_10_realname_verified = Column(Boolean, default=False) # 实名认证
f99_100_points = Column(Integer, default=0) # 积分
f01_11_balance = Column(Float, default=0) # 余额
f01_12_total_amount = Column(Float, default=0) # 累计金额
f01_13_invite_code = Column(String(20), nullable=True) # 邀请码(自己的邀请码)
f99_101_invited_count = Column(Integer, default=0) # 通过自己邀请码注册的用户数量
collections = relationship("Collection", back_populates="user", cascade="all, delete-orphan")
operations = relationship("Operation", back_populates="user", cascade="all, delete-orphan")
custom_fields = relationship("CustomField", back_populates="user", cascade="all, delete-orphan")
class Collection(Base):
__tablename__ = "collections"
# f99 系统字段
f99_90_id = Column(String(36), primary_key=True, default=generate_uuid)
f99_91_user_id = Column(String(36), ForeignKey("users.f99_90_id", ondelete="CASCADE"), nullable=False, index=True)
f99_92_created_at = Column(DateTime(timezone=True), server_default=func.now(), index=True)
f99_93_updated_at = Column(DateTime(timezone=True), onupdate=func.now())
# f01 基本信息
f01_01_name = Column(String(255), nullable=False)
f01_02_code = Column(String(50), nullable=True, index=True)
f01_03_category = Column(String(100), nullable=False, index=True)
f01_04_status = Column(String(50), default="in_collection", index=True)
f01_05_remark = Column(Text, nullable=True)
# f02 详细字段
f02_10_prefix_serial = Column(String(50), nullable=True, index=True)
f02_11_version = Column(String(100), nullable=True, index=True)
f02_12_packaging = Column(String(100), nullable=True, index=True)
f02_13_rarity = Column(String(50), nullable=True, index=True) # 珍惜度
f02_14_number_category = Column(String(20), nullable=True, index=True) # 号码分类
# f03 评级信息
f03_20_is_graded = Column(Boolean, default=False, index=True)
f03_21_grading_company = Column(String(100), nullable=True, index=True)
f03_22_grading_score = Column(String(20), nullable=True, index=True)
f03_23_three_star = Column(Boolean, default=False, index=True)
# f04 特殊信息
f04_30_special_mark = Column(String(200), nullable=True, index=True)
f04_31_serial_feature = Column(String(100), nullable=True, index=True)
f04_32_issuer = Column(String(100), nullable=True, index=True)
f04_33_issue_year = Column(String(20), nullable=True, index=True)
f04_34_material = Column(String(50), nullable=True)
f04_35_denomination = Column(String(20), nullable=True)
f04_36_issue_quantity = Column(String(50), nullable=True)
# f05 价格信息
f05_40_cost_price = Column(Float, nullable=True, index=True)
f05_41_target_price = Column(Float, nullable=True, index=True)
f05_42_goal_price = Column(Float, nullable=True)
f05_43_repair_fee = Column(Float, nullable=True)
f05_44_grading_fee = Column(Float, nullable=True)
# f06 其他信息
f06_50_purpose = Column(String(100), nullable=True)
user = relationship("User", back_populates="collections")
images = relationship("CollectionImage", back_populates="collection", cascade="all, delete-orphan")
operations = relationship("Operation", back_populates="collection", cascade="all, delete-orphan")
class CollectionImage(Base):
__tablename__ = "collection_images"
id = Column(String(36), primary_key=True, default=generate_uuid)
collection_id = Column(String(36), ForeignKey("collections.f99_90_id", ondelete="CASCADE"), nullable=False, index=True)
filename = Column(String(255), nullable=False)
original_name = Column(String(255), nullable=True)
path = Column(String(500), nullable=True)
created_at = Column(DateTime(timezone=True), server_default=func.now())
collection = relationship("Collection", back_populates="images")
class Operation(Base):
__tablename__ = "operations"
f99_90_id = Column(String(36), primary_key=True, default=generate_uuid)
f99_91_user_id = Column(String(36), ForeignKey("collections.f99_90_id", ondelete="CASCADE"), nullable=False, index=True)
f99_92_user_id = Column(String(36), ForeignKey("users.f99_90_id", ondelete="CASCADE"), nullable=False, index=True)
type = Column(String(50), nullable=False, index=True)
price = Column(Float, nullable=True)
note = Column(Text, nullable=True)
f99_93_created_at = Column(DateTime(timezone=True), server_default=func.now(), index=True)
collection = relationship("Collection", back_populates="operations")
user = relationship("User", back_populates="operations")
class CustomField(Base):
__tablename__ = "custom_fields"
id = Column(String(36), primary_key=True, default=generate_uuid)
user_id = Column(String(36), ForeignKey("users.f99_90_id", ondelete="CASCADE"), nullable=False, index=True)
name = Column(String(100), nullable=False)
field_type = Column(String(50), default="text")
options = Column(Text, nullable=True)
required = Column(Boolean, default=False)
visible = Column(Boolean, default=True)
sort_order = Column(Integer, default=0)
created_at = Column(DateTime(timezone=True), server_default=func.now())
user = relationship("User", back_populates="custom_fields")
# 资讯模型
class Information(Base):
__tablename__ = "information"
id = Column(String(36), primary_key=True, default=generate_uuid)
user_id = Column(String(36), ForeignKey("users.f99_90_id", ondelete="CASCADE"), nullable=False, index=True)
# 信息类型: seek-寻配号, deal-成交数据, publish-发布
info_type = Column(String(20), nullable=False, index=True)
# 标题
title = Column(String(255), nullable=False)
# 内容描述
content = Column(Text, nullable=True)
# 关联藏品ID
collection_id = Column(String(36), ForeignKey("collections.f99_90_id", ondelete="SET NULL"), nullable=True)
# 期望条件 (寻配号用)
expect_category = Column(String(100), nullable=True) # 期望类别
expect_version = Column(String(100), nullable=True) # 期望版别
expect_packaging = Column(String(100), nullable=True) # 期望包装
expect_number = Column(String(50), nullable=True) # 期望号码
expect_price_min = Column(Float, nullable=True) # 期望价格区间
expect_price_max = Column(Float, nullable=True)
# 成交价格 (成交数据用)
deal_price = Column(Float, nullable=True)
deal_date = Column(Date, nullable=True)
# 评级相关字段
packaging = Column(String(50), nullable=True)
is_graded = Column(Boolean, default=False)
grading_company = Column(String(100), nullable=True)
grading_score = Column(String(50), nullable=True)
category = Column(String(100), nullable=True)
# 行情编号
deal_no = Column(String(50), nullable=True, index=True)
# 状态: active-有效, closed-已关闭, expired-已过期
status = Column(String(20), default="active", index=True)
# 匹配状态: pending-尚未匹配, matched-已经匹配
is_matched = Column(String(20), default="pending", index=True)
# 匹配的用户ID当用户愿意交换联系方式时
matched_user_id = Column(String(36), ForeignKey("users.f99_90_id", ondelete="SET NULL"), nullable=True)
# 匹配者的联系方式(只有发布者和匹配者可见)
matched_contact = Column(String(100), nullable=True)
# 浏览/联系次数
view_count = Column(Integer, default=0)
contact_count = Column(Integer, default=0)
created_at = Column(DateTime(timezone=True), server_default=func.now(), index=True)
updated_at = Column(DateTime(timezone=True), onupdate=func.now())
user = relationship("User", foreign_keys=[user_id])
collection = relationship("Collection")
# 资讯评论/留言
class InformationComment(Base):
__tablename__ = "information_comments"
id = Column(String(36), primary_key=True, default=generate_uuid)
information_id = Column(String(36), ForeignKey("information.id", ondelete="CASCADE"), nullable=False, index=True)
user_id = Column(String(36), ForeignKey("users.f99_90_id", ondelete="CASCADE"), nullable=False, index=True)
content = Column(Text, nullable=False)
created_at = Column(DateTime(timezone=True), server_default=func.now())
user = relationship("User", foreign_keys=[user_id])
# 资讯联系方式查看记录
class InformationContactView(Base):
__tablename__ = "information_contact_views"
id = Column(String(36), primary_key=True, default=generate_uuid)
information_id = Column(String(36), ForeignKey("information.id", ondelete="CASCADE"), nullable=False, index=True)
viewer_id = Column(String(36), ForeignKey("users.f99_90_id", ondelete="CASCADE"), nullable=False, index=True)
created_at = Column(DateTime(timezone=True), server_default=func.now())
viewer = relationship("User", foreign_keys=[viewer_id])
# 资讯关联用户 (收藏/点赞)
class InformationLike(Base):
__tablename__ = "information_likes"
id = Column(String(36), primary_key=True, default=generate_uuid)
information_id = Column(String(36), ForeignKey("information.id", ondelete="CASCADE"), nullable=False, index=True)
user_id = Column(String(36), ForeignKey("users.f99_90_id", ondelete="CASCADE"), nullable=False, index=True)
created_at = Column(DateTime(timezone=True), server_default=func.now())
__table_args__ = (
UniqueConstraint('information_id', 'user_id', name='uq_information_user'),
)
# 角色常量
class UserRole:
ADMIN = "admin" # 管理员:全部权限
EDITOR = "editor" # 信息员:可发布信息、管理资讯
USER = "user" # 普通用户:基本功能
@classmethod
def get_role_name(cls, role):
names = {
cls.ADMIN: "管理员",
cls.EDITOR: "信息员",
cls.USER: "用户"
}
return names.get(role, "用户")

View File

@ -0,0 +1,39 @@
from sqlalchemy import Column, String, Text, Float, Date, Boolean, Integer, DateTime
from sqlalchemy.sql import func
from app.core.database import Base
import uuid
def generate_uuid():
return str(uuid.uuid4())
class SeekInfo(Base):
__tablename__ = "seek_info"
id = Column(String(36), primary_key=True, default=generate_uuid)
user_id = Column(String(36), nullable=False, index=True)
# 标题和内容
title = Column(String(255), nullable=False)
content = Column(Text, nullable=True)
# 期望条件(求购条件)
expect_category = Column(String(100), nullable=True) # 期望类别
expect_version = Column(String(100), nullable=True) # 期望版别
expect_packaging = Column(String(100), nullable=True) # 期望包装
expect_number = Column(String(50), nullable=True) # 期望号码
expect_price_min = Column(Float, nullable=True) # 期望最低价
expect_price_max = Column(Float, nullable=True) # 期望最高价
# 匹配状态
status = Column(String(20), default="active") # active/closed/expired
is_matched = Column(String(10), default="false") # 是否已匹配
matched_user_id = Column(String(36), nullable=True) # 匹配的用户ID
matched_contact = Column(String(100), nullable=True) # 匹配的联系方式
# 统计
view_count = Column(Integer, default=0)
contact_count = Column(Integer, default=0)
# 时间
created_at = Column(DateTime(timezone=True), server_default=func.now())
updated_at = Column(DateTime(timezone=True), onupdate=func.now())

View File

254
backend/app/routers/auth.py Normal file
View File

@ -0,0 +1,254 @@
# 认证路由 - 使用字段编码
from fastapi import APIRouter, Depends, HTTPException, status, Body, Response
from fastapi.security import OAuth2PasswordRequestForm
from sqlalchemy.orm import Session
from app.core.database import get_db
from app.core.auth import verify_password, create_access_token, get_password_hash, get_current_user
from app.models.models import User
from app.schemas.schemas import Token, UserCreate, UserResponse
router = APIRouter(prefix="/api/auth", tags=["认证"])
def generate_user_code(db):
"""生成用户编码从201开始按自然数顺序递增跳过已存在的"""
# 查找最大的user_code
max_code = db.query(User.user_code).filter(User.user_code != None).order_by(User.user_code.desc()).first()
if max_code and max_code[0]:
try:
num = int(max_code[0]) + 1
if num < 201:
num = 201
# 检查是否已存在,如果存在则继续递增
while db.query(User).filter(User.user_code == str(num)).first():
num += 1
return str(num)
except:
pass
return "201"
@router.post("/register", response_model=UserResponse)
def register(user_data: UserCreate, db: Session = Depends(get_db)):
"""用户注册"""
# 检查用户名是否已存在
existing_user = db.query(User).filter(User.f01_01_name == user_data.f01_01_name).first()
if existing_user:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="f01_01_name: 用户名已存在"
)
# 检查邮箱是否已存在
# 检查手机号是否已存在
if user_data.phone:
existing_phone = db.query(User).filter(User.phone == user_data.phone).first()
if existing_phone:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="E00040:该手机号已被注册,请更换手机号"
)
if user_data.email:
existing_email = db.query(User).filter(User.email == user_data.email).first()
if existing_email:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="E00041:该邮箱已被注册,请更换邮箱"
)
# 处理邀请码
invited_by_user = None
if user_data.invite_code:
# 查找邀请人
invited_by_user = db.query(User).filter(User.user_code == user_data.invite_code).first()
if not invited_by_user:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="E00042:邀请码无效"
)
# 创建用户
import uuid
hashed_password = get_password_hash(user_data.password)
generated_code = generate_user_code(db)
user = User(
f99_90_id=str(uuid.uuid4()),
f99_91_user_id=str(uuid.uuid4()),
user_code=generated_code,
f01_01_name=user_data.f01_01_name,
email=user_data.email,
phone=user_data.phone,
avatar=user_data.avatar,
address=user_data.address,
bio=user_data.bio,
password=hashed_password,
role="user"
)
db.add(user)
db.flush() # 确保获取user ID
# 更新邀请人、被邀请人的关联关系
if invited_by_user:
# 记录是被谁邀请的
user.f01_13_invite_code = invited_by_user.user_code
# 增加邀请人的邀请计数
invited_by_user.f99_101_invited_count = (invited_by_user.f99_101_invited_count or 0) + 1
# 生成自己的邀请码用自己的user_code
user.f01_13_invite_code = generated_code
db.commit()
db.refresh(user)
# 返回用户信息避免Pydantic序列化问题
return {
"id": user.f99_90_id,
"username": user.f01_01_name,
"user_code": user.user_code,
"email": user.email,
"phone": user.phone,
"avatar": user.avatar,
"role": user.role,
"level": user.f99_94_level,
"aiCount": user.f99_95_ai_count or 0,
"searchCount": user.f99_96_search_count or 0,
"collectionCount": user.f99_97_collection_count or 0
}
@router.post("/login")
def login(
form_data: OAuth2PasswordRequestForm = Depends(),
db: Session = Depends(get_db),
response: Response = None
):
"""用户登录 - 支持用户名或用户编码登录返回Token并设置Cookie"""
# 先尝试用户名登录
user = db.query(User).filter(User.f01_01_name == form_data.username).first()
# 如果用户名不存在,尝试用户编码登录
if not user:
user = db.query(User).filter(User.user_code == form_data.username).first()
if not user:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="E00011: 用户名或密码错误",
headers={"WWW-Authenticate": "Bearer"},
)
# 验证密码
if not verify_password(form_data.password, user.password):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="E00011: 用户名或密码错误",
headers={"WWW-Authenticate": "Bearer"},
)
# 更新登录次数和最后登录时间
from datetime import datetime
user.f99_98_login_count = (user.f99_98_login_count or 0) + 1
user.f99_99_last_login = datetime.now()
db.commit()
# 生成 token
access_token = create_access_token(data={"sub": user.f99_90_id})
# 设置Cookie有效期7天
if response:
response.set_cookie(
key="token",
value=access_token,
httponly=False, # 允许JS读取小程序需要
max_age=7 * 24 * 60 * 60, # 7天
samesite="lax",
path="/"
)
return {
"access_token": access_token,
"token_type": "bearer"
}
@router.get("/me", response_model=UserResponse)
def get_current_user_info(
current_user: User = Depends(lambda: None)
):
"""获取当前用户信息"""
raise HTTPException(
status_code=status.HTTP_501_NOT_IMPLEMENTED,
detail="请使用正确的依赖注入"
)
@router.post("/change-password")
def change_password(
old_password: str = Body(...),
new_password: str = Body(...),
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""修改当前用户密码"""
from app.core.auth import verify_password, get_password_hash
# 在当前session中重新查询用户
user = db.query(User).filter(User.f99_90_id == current_user.f99_90_id).first()
if not user:
raise HTTPException(status_code=404, detail="用户不存在")
# 验证旧密码
if not verify_password(old_password, user.password):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="当前密码错误"
)
# 更新密码
user.password = get_password_hash(new_password)
db.commit()
return {"message": "密码修改成功"}
# ============ 短信验证码接口 ============
@router.post("/send-verification-code")
def send_verification_code(
phone: str = Body(..., min_length=11, max_length=11),
purpose: str = Body("register") # register | login | reset_password
):
"""发送短信验证码"""
from app.services.sms import send_verification_code as send_sms
# 验证手机号格式
if not phone.startswith("1") or len(phone) != 11:
return {"success": False, "message": "手机号格式不正确"}
result = send_sms(phone)
if result["success"]:
return {
"success": True,
"message": f"验证码已发送到 {phone[:3]}****{phone[7:]}",
"expire": result.get("expire", 300)
}
else:
return result
@router.post("/verify-code")
def verify_code(
phone: str = Body(...),
code: str = Body(..., min_length=6, max_length=6)
):
"""验证短信验证码(仅验证,不执行后续操作)"""
from app.services.sms import verify_code as check_code
is_valid = check_code(phone, code)
if is_valid:
return {"success": True, "message": "验证成功"}
else:
return {"success": False, "message": "验证码错误或已过期"}

View File

@ -0,0 +1,887 @@
# 藏品路由 - 使用字段编码
import os
import uuid
import re
from typing import Optional, List
from fastapi import APIRouter, Depends, HTTPException, status, Query, UploadFile, File
from sqlalchemy import func, text
from sqlalchemy.orm import Session, joinedload
from app.core.database import get_db
from app.core.auth import get_current_user
from app.core.logging_config import logger
from app.models.models import User, Collection, CollectionImage, Operation
from app.schemas.schemas import (
CollectionCreate, CollectionUpdate, CollectionResponse,
CollectionListResponse, CollectionImageResponse
)
from app.services.oss import upload_to_oss, get_oss_path, delete_from_oss, get_public_url
router = APIRouter(prefix="/api/collections", tags=["藏品"])
def to_camel_case(data: dict) -> dict:
"""将字段编码转换为 camelCase 格式"""
if not data:
return data
mapping = {
'f99_90_id': 'id',
'f99_91_user_id': 'userId',
'f99_92_created_at': 'createdAt',
'f99_93_updated_at': 'updatedAt',
'f01_01_name': 'name',
'f01_02_code': 'code',
'f01_03_category': 'category',
'f01_04_status': 'status',
'f01_05_remark': 'remark',
'f02_10_prefix_serial': 'prefixSerial',
'f02_11_version': 'version',
'f02_12_packaging': 'packaging',
'f02_13_rarity': 'rarity',
'f02_14_number_category': 'numberCategory',
'f03_20_is_graded': 'isGraded',
'f03_21_grading_company': 'gradingCompany',
'f03_22_grading_score': 'gradingScore',
'f03_23_three_star': 'threeStar',
'f04_30_special_mark': 'specialMark',
'f04_31_serial_feature': 'serialFeature',
'f04_32_issuer': 'issuer',
'f04_33_issue_year': 'issueYear',
'f04_34_material': 'material',
'f04_35_denomination': 'denomination',
'f04_36_issue_quantity': 'issueQuantity',
'f05_40_cost_price': 'costPrice',
'f05_41_target_price': 'targetPrice',
'f05_42_goal_price': 'goalPrice',
'f05_43_repair_fee': 'repairFee',
'f05_44_grading_fee': 'gradingFee',
'f06_50_purpose': 'purpose',
'images': 'images',
}
return {mapping.get(k, k): v for k, v in data.items()}
# 编码生成函数
def generate_code(version: str, user_id: str, db: Session) -> str:
"""自动生成藏品编号 - 按用户独立编码"""
import re
# 查询当前用户的非空编码(不与其他用户混算)- 使用行锁防止并发
user_codes = db.query(Collection.f01_02_code).filter(
Collection.f01_02_code.isnot(None),
Collection.f99_91_user_id == user_id
).with_for_update().all()
max_num = 0
for (code,) in user_codes:
# 处理纯数字编码支持4位和5位
if re.match(r'^\d{4,5}$', code):
try:
num = int(code)
if num > max_num:
max_num = num
except (ValueError, TypeError):
pass
# 当前用户最大号 +1
next_num = max_num + 1
# 如果超过9999使用5位否则使用4位
if next_num > 9999:
return str(next_num).zfill(5)
else:
return str(next_num).zfill(4)
@router.get("/next-code")
def get_next_code(
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""获取下一个藏品编号"""
next_code = generate_code("2024 龙", current_user.f99_90_id, db)
return {"code": 200, "data": {"nextCode": next_code}}
@router.get("")
def get_collections(
id: str = Query(None, description="filter by collection id"),
category: Optional[str] = None,
status: Optional[str] = None,
search: Optional[str] = None,
specialMark: Optional[str] = Query(None, description="special mark filter"),
numberCategory: Optional[str] = Query(None, description="number category filter"),
gradingCompany: Optional[str] = Query(None, description="grading company filter"),
gradingScore: Optional[str] = Query(None, description="grading score filter"),
packaging: Optional[str] = Query(None, description="packaging filter"),
rarity: Optional[str] = Query(None, description="rarity filter"),
version: Optional[str] = Query(None, description="version filter"),
profitLoss: Optional[str] = Query(None, description="profit loss filter: profit or loss"),
page: int = Query(1, ge=1),
limit: int = Query(20, ge=1, le=500),
sortBy: str = Query('createdAt'),
sortOrder: str = Query('desc'),
all_users: bool = Query(False, description="return all users data for admin"),
user_id: str = Query(None, description="filter by user id"),
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""获取藏品列表"""
# admin 用户可以看到所有藏品,普通用户只能看到自己的
# 如果指定 all_users=true则返回所有用户藏品
from sqlalchemy.orm import joinedload
# 管理员默认查看全库,普通用户只看自己,未登录返回空列表
if current_user is None or current_user.role != "admin":
# 非管理员或未登录用户只能查看自己的藏品(如果没有登录则返回空)
if current_user is None:
return {"data": [], "total": 0, "page": 1, "limit": 20}
query = db.query(Collection).filter(Collection.f99_91_user_id == current_user.f99_90_id)
else:
# 管理员查看所有藏品
query = db.query(Collection, User.f01_01_name.label('owner_name')).join(
User, Collection.f99_91_user_id == User.f99_90_id, isouter=True
)
# 如果指定了user_id参数则只返回该用户的藏品
if user_id:
query = query.filter(Collection.f99_91_user_id == user_id)
# 按ID精确筛选
if id:
query = query.filter(Collection.f99_90_id == id)
if category:
query = query.filter(Collection.f01_03_category == category)
if status:
query = query.filter(Collection.f01_04_status == status)
if specialMark:
query = query.filter(Collection.f04_30_special_mark == specialMark)
if gradingCompany:
query = query.filter(Collection.f03_21_grading_company.contains(gradingCompany))
if gradingScore:
query = query.filter(Collection.f03_22_grading_score.contains(gradingScore))
if numberCategory:
query = query.filter(Collection.f02_14_number_category.contains(numberCategory))
if packaging:
query = query.filter(Collection.f02_12_packaging== packaging)
if rarity:
query = query.filter(Collection.f02_13_rarity.contains(rarity))
if version:
query = query.filter(Collection.f02_11_version.contains(version))
# 盈亏筛选(只对已售藏品有效)
if profitLoss:
if profitLoss == 'profit':
# 盈利:售价 > 成本价
query = query.filter(
Collection.f01_04_status == 'sold',
Collection.f05_42_goal_price > Collection.f05_40_cost_price
)
elif profitLoss == 'loss':
# 亏损:售价 <= 成本价
query = query.filter(
Collection.f01_04_status == 'sold',
Collection.f05_42_goal_price <= Collection.f05_40_cost_price
)
if search:
query = query.filter(
(Collection.f01_01_name.contains(search)) |
(Collection.f01_05_remark.contains(search))
)
# 总数(应用筛选条件后的数量)
total = query.count()
# 使用joinedload预加载图片避免N+1查询问题
query = query.options(joinedload(Collection.images))
# 分页
data = query.order_by(Collection.f99_92_created_at.desc()) \
.offset((page - 1) * limit) \
.limit(limit) \
.all()
# 转换为字典列表并转为 camelCase
data_list = []
for item in data:
# 处理联表查询结果
if current_user is not None and current_user.role == "admin":
collection_item, owner_name = item
else:
collection_item = item
owner_name = None
item_dict = {
'f99_90_id': collection_item.f99_90_id,
'f99_91_user_id': collection_item.f99_91_user_id,
'owner_name': owner_name, # 所属用户名(仅管理员可见)
'f01_01_name': collection_item.f01_01_name,
'f01_02_code': collection_item.f01_02_code,
'f01_03_category': collection_item.f01_03_category,
'f01_04_status': collection_item.f01_04_status,
'f01_05_remark': collection_item.f01_05_remark,
'f02_10_prefix_serial': collection_item.f02_10_prefix_serial,
'f02_11_version': collection_item.f02_11_version,
'f02_12_packaging': collection_item.f02_12_packaging,
'f02_13_rarity': collection_item.f02_13_rarity,
'f02_14_number_category': collection_item.f02_14_number_category,
'f03_20_is_graded': collection_item.f03_20_is_graded,
'f03_21_grading_company': collection_item.f03_21_grading_company,
'f03_22_grading_score': collection_item.f03_22_grading_score,
'f03_23_three_star': collection_item.f03_23_three_star,
'f04_30_special_mark': collection_item.f04_30_special_mark,
'f04_31_serial_feature': collection_item.f04_31_serial_feature,
'f04_32_issuer': collection_item.f04_32_issuer,
'f04_33_issue_year': collection_item.f04_33_issue_year,
'f04_34_material': collection_item.f04_34_material,
'f04_35_denomination': collection_item.f04_35_denomination,
'f04_36_issue_quantity': collection_item.f04_36_issue_quantity,
'f05_40_cost_price': float(collection_item.f05_40_cost_price) if collection_item.f05_40_cost_price else None,
'f05_41_target_price': float(collection_item.f05_41_target_price) if collection_item.f05_41_target_price else None,
'f05_42_goal_price': float(collection_item.f05_42_goal_price) if collection_item.f05_42_goal_price else None,
'f05_43_repair_fee': float(collection_item.f05_43_repair_fee) if collection_item.f05_43_repair_fee else None,
'f05_44_grading_fee': float(collection_item.f05_44_grading_fee) if collection_item.f05_44_grading_fee else None,
'f06_50_purpose': collection_item.f06_50_purpose,
'f99_92_created_at': collection_item.f99_92_created_at.isoformat() if collection_item.f99_92_created_at else None,
'images': []
}
# 直接使用预加载的图片数据,无需再查询
for img in collection_item.images:
item_dict['images'].append({
'id': img.id,
'filename': img.filename,
'original_name': img.original_name,
'path': img.path,
'created_at': img.created_at.isoformat() if img.created_at else None
})
data_list.append(to_camel_case(item_dict))
return {
"data": data_list,
"pagination": {
"page": page,
"limit": limit,
"total": total,
"pages": (total + limit - 1) // limit
}
}
@router.get("/stats")
def get_stats(
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""获取藏品统计 - 使用SQL聚合查询优化性能"""
# 非管理员或未登录用户只能查看自己的藏品
if current_user is None:
return {
"totalCount": 0,
"byCategory": [],
"byStatus": [],
"byGrading": [],
"byPackaging": [],
"byRarity": [],
"byVersion": [],
"byGradingCompany": [],
"byGradingScore": [],
"bySpecialMark": [],
"byNumberCategory": [],
"byProfitLoss": [],
"totalCost": 0,
"totalTarget": 0,
"expectedProfit": 0,
"totalRevenue": 0,
"totalProfit": 0
}
# 构建基础查询条件
is_admin = current_user.role == "admin"
if not is_admin:
base_filter = Collection.f99_91_user_id == current_user.f99_90_id
else:
base_filter = None
# 总数 - 使用SQL COUNT
total_count = db.query(func.count(Collection.f99_90_id)).filter(
base_filter if base_filter is not True else True
).scalar()
if base_filter is not True:
total_count = db.query(func.count(Collection.f99_90_id)).filter(base_filter).scalar()
else:
total_count = db.query(func.count(Collection.f99_90_id)).scalar()
# 按分类统计 - 使用SQL GROUP BY
if base_filter is not True:
by_category = db.query(
Collection.f01_03_category,
func.count(Collection.f99_90_id)
).filter(base_filter).group_by(Collection.f01_03_category).all()
by_status = db.query(
Collection.f01_04_status,
func.count(Collection.f99_90_id)
).filter(base_filter).group_by(Collection.f01_04_status).all()
by_graded = db.query(
Collection.f03_20_is_graded,
func.count(Collection.f99_90_id)
).filter(base_filter).group_by(Collection.f03_20_is_graded).all()
by_packaging = db.query(
Collection.f02_12_packaging,
func.count(Collection.f99_90_id)
).filter(base_filter, Collection.f02_12_packaging.isnot(None)).group_by(Collection.f02_12_packaging).all()
by_rarity = db.query(
Collection.f02_13_rarity,
func.count(Collection.f99_90_id)
).filter(base_filter, Collection.f02_13_rarity.isnot(None)).group_by(Collection.f02_13_rarity).all()
by_version = db.query(
Collection.f02_11_version,
func.count(Collection.f99_90_id)
).filter(base_filter, Collection.f02_11_version.isnot(None)).group_by(Collection.f02_11_version).all()
by_grading_company = db.query(
Collection.f03_21_grading_company,
func.count(Collection.f99_90_id)
).filter(base_filter, Collection.f03_20_is_graded == True, Collection.f03_21_grading_company.isnot(None)).group_by(Collection.f03_21_grading_company).all()
by_grading_score = db.query(
Collection.f03_22_grading_score,
func.count(Collection.f99_90_id)
).filter(base_filter, Collection.f03_20_is_graded == True, Collection.f03_22_grading_score.isnot(None)).group_by(Collection.f03_22_grading_score).all()
by_special_mark = db.query(
Collection.f04_30_special_mark,
func.count(Collection.f99_90_id)
).filter(base_filter, Collection.f04_30_special_mark.isnot(None)).group_by(Collection.f04_30_special_mark).all()
by_number_category = db.query(
Collection.f02_14_number_category,
func.count(Collection.f99_90_id)
).filter(base_filter, Collection.f02_14_number_category.isnot(None)).group_by(Collection.f02_14_number_category).all()
# 成本相关统计 - 使用SQL SUM
cost_result = db.query(
func.coalesce(func.sum(Collection.f05_40_cost_price), 0) +
func.coalesce(func.sum(Collection.f05_43_repair_fee), 0) +
func.coalesce(func.sum(Collection.f05_44_grading_fee), 0)
).filter(base_filter).first()
total_cost = cost_result[0] if cost_result else 0
# 预期利润
expected_profit_result = db.query(
func.coalesce(func.sum(Collection.f05_41_target_price - Collection.f05_40_cost_price), 0)
).filter(base_filter, Collection.f05_41_target_price.isnot(None), Collection.f05_41_target_price > 0).first()
expected_profit = expected_profit_result[0] if expected_profit_result else 0
# 已售藏品统计
sold_collections = db.query(Collection).filter(
base_filter,
Collection.f01_04_status == 'sold',
Collection.f05_42_goal_price.isnot(None),
Collection.f05_42_goal_price > 0
).all()
else:
# 管理员查看所有数据
by_category = db.query(
Collection.f01_03_category,
func.count(Collection.f99_90_id)
).group_by(Collection.f01_03_category).all()
by_status = db.query(
Collection.f01_04_status,
func.count(Collection.f99_90_id)
).group_by(Collection.f01_04_status).all()
by_graded = db.query(
Collection.f03_20_is_graded,
func.count(Collection.f99_90_id)
).group_by(Collection.f03_20_is_graded).all()
by_packaging = db.query(
Collection.f02_12_packaging,
func.count(Collection.f99_90_id)
).filter(Collection.f02_12_packaging.isnot(None)).group_by(Collection.f02_12_packaging).all()
by_rarity = db.query(
Collection.f02_13_rarity,
func.count(Collection.f99_90_id)
).filter(Collection.f02_13_rarity.isnot(None)).group_by(Collection.f02_13_rarity).all()
by_version = db.query(
Collection.f02_11_version,
func.count(Collection.f99_90_id)
).filter(Collection.f02_11_version.isnot(None)).group_by(Collection.f02_11_version).all()
by_grading_company = db.query(
Collection.f03_21_grading_company,
func.count(Collection.f99_90_id)
).filter(Collection.f03_20_is_graded == True, Collection.f03_21_grading_company.isnot(None)).group_by(Collection.f03_21_grading_company).all()
by_grading_score = db.query(
Collection.f03_22_grading_score,
func.count(Collection.f99_90_id)
).filter(Collection.f03_20_is_graded == True, Collection.f03_22_grading_score.isnot(None)).group_by(Collection.f03_22_grading_score).all()
by_special_mark = db.query(
Collection.f04_30_special_mark,
func.count(Collection.f99_90_id)
).filter(Collection.f04_30_special_mark.isnot(None)).group_by(Collection.f04_30_special_mark).all()
by_number_category = db.query(
Collection.f02_14_number_category,
func.count(Collection.f99_90_id)
).filter(Collection.f02_14_number_category.isnot(None)).group_by(Collection.f02_14_number_category).all()
# 总成本
cost_result = db.query(
func.coalesce(func.sum(Collection.f05_40_cost_price), 0) +
func.coalesce(func.sum(Collection.f05_43_repair_fee), 0) +
func.coalesce(func.sum(Collection.f05_44_grading_fee), 0)
).first()
total_cost = cost_result[0] if cost_result else 0
# 预期利润
expected_profit_result = db.query(
func.coalesce(func.sum(Collection.f05_41_target_price - Collection.f05_40_cost_price), 0)
).filter(Collection.f05_41_target_price.isnot(None), Collection.f05_41_target_price > 0).first()
expected_profit = expected_profit_result[0] if expected_profit_result else 0
# 已售藏品
sold_collections = db.query(Collection).filter(
Collection.f01_04_status == 'sold',
Collection.f05_42_goal_price.isnot(None),
Collection.f05_42_goal_price > 0
).all()
# 总收入和总利润(已售藏品)
total_revenue = sum(c.f05_42_goal_price or 0 for c in sold_collections)
total_profit = sum(
(c.f05_42_goal_price or 0) - (c.f05_40_cost_price or 0) - (c.f05_43_repair_fee or 0) - (c.f05_44_grading_fee or 0)
for c in sold_collections
)
# 盈亏统计
profit_count = sum(1 for c in sold_collections if c.f05_42_goal_price and c.f05_40_cost_price and c.f05_42_goal_price > c.f05_40_cost_price)
loss_count = sum(1 for c in sold_collections if c.f05_42_goal_price and c.f05_40_cost_price and c.f05_42_goal_price <= c.f05_40_cost_price)
# 目标价格总和
total_target_result = db.query(func.coalesce(func.sum(Collection.f05_41_target_price), 0)).filter(
base_filter if base_filter is not True else True
).first()
if base_filter is not True:
total_target_result = db.query(func.coalesce(func.sum(Collection.f05_41_target_price), 0)).filter(base_filter).first()
else:
total_target_result = db.query(func.coalesce(func.sum(Collection.f05_41_target_price), 0)).first()
total_target = total_target_result[0] if total_target_result else 0
return {
"totalCount": total_count,
"byCategory": [{"category": c, "count": n} for c, n in by_category],
"byStatus": [{"status": s, "count": n} for s, n in by_status],
"byGrading": [{"isGraded": g, "count": n} for g, n in by_graded],
"byPackaging": [{"packaging": p, "count": n} for p, n in by_packaging],
"byRarity": [{"rarity": r, "count": n} for r, n in by_rarity],
"byVersion": [{"version": v, "count": n} for v, n in by_version],
"byGradingCompany": [{"company": c, "count": n} for c, n in by_grading_company],
"byGradingScore": [{"score": s, "count": n} for s, n in by_grading_score],
"bySpecialMark": [{"mark": m, "count": n} for m, n in by_special_mark],
"byNumberCategory": [{"numberCategory": n, "count": c} for n, c in by_number_category],
"byProfitLoss": [
{"type": "profit", "label": "盈利", "count": profit_count},
{"type": "loss", "label": "亏损", "count": loss_count}
],
"totalCost": total_cost,
"totalTarget": total_target,
"expectedProfit": expected_profit,
"totalRevenue": total_revenue,
"totalProfit": total_profit
}
@router.get("/{collection_id}")
def get_collection(
collection_id: str,
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""获取单个藏品详情"""
result = db.execute(
text("SELECT * FROM collections WHERE f99_90_id = :id"),
{"id": collection_id}
).fetchone()
if not result:
raise HTTPException(status_code=404, detail="E00033: 藏品不存在")
collection = dict(result._mapping)
# 非管理员只能查看自己的藏品
if (current_user is None or current_user.role != "admin") and collection.get('f99_91_user_id') != current_user.f99_90_id:
raise HTTPException(status_code=403, detail="无权访问")
result_dict = {
'f99_90_id': collection.get('f99_90_id'),
'f99_91_user_id': collection.get('f99_91_user_id'),
'f01_01_name': collection.get('f01_01_name'),
'f01_02_code': collection.get('f01_02_code'),
'f01_03_category': collection.get('f01_03_category'),
'f01_04_status': collection.get('f01_04_status'),
'f01_05_remark': collection.get('f01_05_remark'),
'f02_10_prefix_serial': collection.get('f02_10_prefix_serial'),
'f02_11_version': collection.get('f02_11_version'),
'f02_12_packaging': collection.get('f02_12_packaging'),
'f02_13_rarity': collection.get('f02_13_rarity'),
'f02_14_number_category': collection.get('f02_14_number_category'),
'f03_20_is_graded': collection.get('f03_20_is_graded'),
'f03_21_grading_company': collection.get('f03_21_grading_company'),
'f03_22_grading_score': collection.get('f03_22_grading_score'),
'f03_23_three_star': collection.get('f03_23_three_star'),
'f04_30_special_mark': collection.get('f04_30_special_mark'),
'f04_31_serial_feature': collection.get('f04_31_serial_feature'),
'f04_32_issuer': collection.get('f04_32_issuer'),
'f04_33_issue_year': collection.get('f04_33_issue_year'),
'f04_34_material': collection.get('f04_34_material'),
'f04_35_denomination': collection.get('f04_35_denomination'),
'f04_36_issue_quantity': collection.get('f04_36_issue_quantity'),
'f05_40_cost_price': float(collection.get('f05_40_cost_price')) if collection.get('f05_40_cost_price') else None,
'f05_41_target_price': float(collection.get('f05_41_target_price')) if collection.get('f05_41_target_price') else None,
'f05_42_goal_price': float(collection.get('f05_42_goal_price')) if collection.get('f05_42_goal_price') else None,
'f05_43_repair_fee': float(collection.get('f05_43_repair_fee')) if collection.get('f05_43_repair_fee') else None,
'f05_44_grading_fee': float(collection.get('f05_44_grading_fee')) if collection.get('f05_44_grading_fee') else None,
'f06_50_purpose': collection.get('f06_50_purpose'),
'f99_92_created_at': collection.get('f99_92_created_at').isoformat() if collection.get('f99_92_created_at') else None,
'images': []
}
# 加载图片数据
images = db.query(CollectionImage).filter(
CollectionImage.collection_id == collection_id
).all()
for img in images:
result_dict['images'].append({
'id': img.id,
'filename': img.filename,
'original_name': img.original_name,
'path': img.path,
'created_at': img.created_at.isoformat() if img.created_at else None
})
return to_camel_case(result_dict)
@router.post("")
def create_collection(
collection_data: CollectionCreate,
force: bool = False, # 是否强制保存(忽略重复警告)
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""创建藏品 - 支持冠字号查重"""
from app.core.logging_config import logger
# 自动生成编码
final_code = collection_data.f01_02_code or generate_code(
collection_data.f02_11_version or '2024 龙',
current_user.f99_90_id,
db
)
# 编号查重(如果提供了编号且不是强制保存)
if not force and final_code:
existing_code = db.query(Collection).filter(
Collection.f01_02_code == final_code,
Collection.f99_91_user_id == current_user.f99_90_id
).first()
if existing_code:
logger.warning(f"发现重复编号:{final_code}, 已存在藏品 ID: {existing_code.f99_90_id}")
return {
"error": {
"code": "DUPLICATE_CODE",
"message": f"藏品编号 {final_code} 已存在,请使用其他编号"
}
}
# 冠字号查重(如果提供了冠字号且不是强制保存)
if not force and collection_data.f02_10_prefix_serial:
# 查询当前用户是否有相同冠字号的藏品
existing = db.query(Collection).filter(
Collection.f02_10_prefix_serial == collection_data.f02_10_prefix_serial,
Collection.f99_91_user_id == current_user.f99_90_id
).first()
if existing:
logger.warning(f"发现重复冠字号:{collection_data.f02_10_prefix_serial}, 已存在藏品 ID: {existing.f99_90_id}")
# 返回警告信息,让前端询问用户是否继续
return {
"warning": {
"code": "DUPLICATE_SERIAL",
"message": f"发现重复冠字号:{collection_data.f02_10_prefix_serial}",
"existing_collection": {
"id": existing.f99_90_id,
"name": existing.f01_01_name,
"code": existing.f01_02_code,
"prefix_serial": existing.f02_10_prefix_serial
}
},
"data": {
"ask_continue": True
}
}
# 自动分类:如果未提供号码分类,则根据冠字号自动分类
if not collection_data.f02_14_number_category and collection_data.f02_10_prefix_serial:
from app.utils.number_category import get_number_category
collection_data.f02_14_number_category = get_number_category(collection_data.f02_10_prefix_serial)
collection = Collection(
f99_91_user_id=current_user.f99_90_id,
f01_01_name=collection_data.f01_01_name,
f01_02_code=final_code,
f01_03_category=collection_data.f01_03_category,
f01_04_status=collection_data.f01_04_status or "in_collection",
f01_05_remark=collection_data.f01_05_remark,
f02_10_prefix_serial=collection_data.f02_10_prefix_serial,
f02_11_version=collection_data.f02_11_version,
f02_12_packaging=collection_data.f02_12_packaging,
f02_13_rarity=collection_data.f02_13_rarity,
f02_14_number_category=collection_data.f02_14_number_category,
f03_20_is_graded=collection_data.f03_20_is_graded or False,
f03_21_grading_company=collection_data.f03_21_grading_company,
f03_22_grading_score=collection_data.f03_22_grading_score,
f03_23_three_star=collection_data.f03_23_three_star or False,
f04_30_special_mark=collection_data.f04_30_special_mark,
f04_31_serial_feature=collection_data.f04_31_serial_feature,
f04_32_issuer=collection_data.f04_32_issuer,
f04_33_issue_year=collection_data.f04_33_issue_year,
f04_34_material=collection_data.f04_34_material,
f04_35_denomination=collection_data.f04_35_denomination,
f04_36_issue_quantity=collection_data.f04_36_issue_quantity,
f05_40_cost_price=collection_data.f05_40_cost_price,
f05_41_target_price=collection_data.f05_41_target_price,
f05_42_goal_price=collection_data.f05_42_goal_price,
f05_43_repair_fee=collection_data.f05_43_repair_fee,
f05_44_grading_fee=collection_data.f05_44_grading_fee,
f06_50_purpose=collection_data.f06_50_purpose
)
db.add(collection)
db.commit()
db.refresh(collection)
return {
'f99_90_id': collection.f99_90_id,
'f99_91_user_id': collection.f99_91_user_id,
'f01_01_name': collection.f01_01_name,
'f01_02_code': collection.f01_02_code,
'f01_03_category': collection.f01_03_category,
'f01_04_status': collection.f01_04_status,
'f01_05_remark': collection.f01_05_remark,
'f99_92_created_at': collection.f99_92_created_at.isoformat() if collection.f99_92_created_at else None,
'message': '创建成功'
}
@router.put("/{collection_id}")
def update_collection(
collection_id: str,
collection_data: CollectionUpdate,
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""更新藏品"""
collection = db.query(Collection).filter(
Collection.f99_90_id == collection_id,
Collection.f99_91_user_id == current_user.f99_90_id
).first()
if not collection:
raise HTTPException(status_code=404, detail="E00033: 藏品不存在")
# 更新字段 - 使用 model_fields_set 检查哪些字段被设置
for field_name in collection_data.model_fields_set:
value = getattr(collection_data, field_name)
if value is not None:
setattr(collection, field_name, value)
db.commit()
db.refresh(collection)
return {
"f99_90_id": collection.f99_90_id,
"message": "更新成功"
}
@router.delete("/{collection_id}")
def delete_collection(
collection_id: str,
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""删除藏品"""
# 验证权限并检查是否存在
collection = db.query(Collection).filter(
Collection.f99_90_id == collection_id,
Collection.f99_91_user_id == current_user.f99_90_id
).first()
if not collection:
raise HTTPException(status_code=404, detail="E00033: 藏品不存在")
# 使用原生 SQL 删除(避免 ORM 级联查询字段不匹配问题)
from sqlalchemy import text
# 1. 删除关联的 operationsf99_91_user_id 关联到 collections.f99_90_id
db.execute(text("DELETE FROM operations WHERE f99_91_user_id = :id"), {"id": collection_id})
# 2. 删除关联的图片
db.execute(text("DELETE FROM collection_images WHERE collection_id = :id"), {"id": collection_id})
# 3. 删除藏品本身
db.execute(text("DELETE FROM collections WHERE f99_90_id = :id"), {"id": collection_id})
db.commit()
return {"message": "删除成功"}
@router.post("/upload-image")
async def upload_image(
collection_id: str = None,
file: UploadFile = File(...),
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""上传藏品图片 - 文件名格式:用户名 - 藏品编号 - 冠字号"""
try:
# 验证藏品是否存在
collection = db.query(Collection).filter(
Collection.f99_90_id == collection_id
).first()
if not collection:
raise HTTPException(status_code=404, detail="E00033: 藏品不存在")
# 获取用户信息(用于文件名)
owner = db.query(User).filter(User.f99_90_id == collection.f99_91_user_id).first()
username = owner.f01_01_name if owner else "unknown"
# 获取藏品信息(用于文件名)
code = collection.f01_02_code or "0000"
prefix_serial = collection.f02_10_prefix_serial or ""
# 检查文件类型
if not file.content_type.startswith('image/'):
raise HTTPException(status_code=400, detail="E00038: 只能上传图片文件")
# 检查文件大小(限制 10MB
file_size = 0
content = await file.read()
file_size = len(content)
if file_size > 10 * 1024 * 1024: # 10MB
raise HTTPException(status_code=400, detail=f"E00039: 图片大小不能超过 10MB当前{file_size // 1024 // 1024}MB")
# 生成OSS存储路径
user_id = collection.f99_91_user_id
file_extension = file.filename.split('.')[-1] if '.' in file.filename else 'jpg'
# 清理特殊字符
clean_username = re.sub(r'[^\w\u4e00-\u9fff\-]', '', username)
clean_serial = re.sub(r'[^\w\u4e00-\u9fff\-]', '', prefix_serial)
# 文件名格式:用户名-藏品编号-冠字号.jpg
if clean_serial:
filename = f"{clean_username}-{code}-{clean_serial}.{file_extension}"
else:
filename = f"{clean_username}-{code}.{file_extension}"
# 生成OSS key
oss_key, unique_name = get_oss_path("collections", user_id=user_id, filename=filename)
# 上传到OSS
image_url = upload_to_oss(content, oss_key)
# 创建图片记录保存OSS URL
image = CollectionImage(
id=str(uuid.uuid4()),
collection_id=collection_id,
filename=unique_name,
original_name=file.filename,
path=image_url # 保存OSS URL
)
db.add(image)
db.commit()
db.refresh(image)
logger.info(f"图片上传成功:{image_url}, collection_id={collection_id}")
return {
"message": "上传成功",
"image_id": image.id,
"filename": unique_name,
"url": image_url
}
except HTTPException:
raise
except Exception as e:
logger.error(f"图片上传失败:{str(e)}")
raise HTTPException(status_code=500, detail="上传失败")
@router.delete("/images/{image_id}")
async def delete_image(
image_id: str,
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""删除藏品图片"""
try:
# 查找图片记录
image = db.query(CollectionImage).filter(
CollectionImage.id == image_id
).first()
if not image:
raise HTTPException(status_code=404, detail="E00033: 图片不存在")
# 检查权限
collection = db.query(Collection).filter(
Collection.f99_90_id == image.collection_id
).first()
if collection and (current_user is None or current_user.role != "admin") and collection.f99_91_user_id != current_user.f99_90_id:
raise HTTPException(status_code=403, detail="E00014: 无权删除此图片")
# 删除OSS文件如果path是OSS URL
if image.path and image.path.startswith("https://"):
# 从OSS URL提取key
try:
oss_key = image.path.replace("https://jiachenlong-oss.oss-cn-hangzhou.aliyuncs.com/", "")
delete_from_oss(oss_key)
except Exception as e:
logger.warning(f"OSS文件删除失败: {e}")
elif image.path and os.path.exists(image.path):
# 兼容旧的本地上传
os.remove(image.path)
# 删除数据库记录
db.delete(image)
db.commit()
return {"message": "删除成功"}
except HTTPException:
raise
except Exception as e:
logger.error(f"图片删除失败:{str(e)}")
raise HTTPException(status_code=500, detail="删除失败")

302
backend/app/routers/deal.py Normal file
View File

@ -0,0 +1,302 @@
from fastapi import APIRouter, Depends, Query, HTTPException
from sqlalchemy.orm import Session
from pydantic import BaseModel
from typing import Optional
from datetime import datetime, date
from app.core.database import get_db
from app.core.auth import get_current_user
from app.models.deal_info import DealInfo
router = APIRouter(prefix="/api/deal", tags=["成交行情"])
# ============ Schema ============
class DealInfoCreate(BaseModel):
title: str
content: Optional[str] = None
deal_price: Optional[float] = None
deal_date: Optional[str] = None # YYYY-MM-DD
packaging: Optional[str] = None
category: Optional[str] = None
is_graded: Optional[bool] = False
grading_company: Optional[str] = None
grading_score: Optional[str] = None
tail_number: Optional[str] = None
size_type: Optional[str] = None
version: Optional[str] = None
platform: Optional[str] = None
seller: Optional[str] = None
buyer: Optional[str] = None
class DealInfoUpdate(BaseModel):
title: Optional[str] = None
content: Optional[str] = None
deal_price: Optional[float] = None
deal_date: Optional[str] = None
packaging: Optional[str] = None
category: Optional[str] = None
is_graded: Optional[bool] = None
grading_company: Optional[str] = None
grading_score: Optional[str] = None
tail_number: Optional[str] = None
size_type: Optional[str] = None
version: Optional[str] = None
platform: Optional[str] = None
seller: Optional[str] = None
buyer: Optional[str] = None
status: Optional[str] = None
class DealInfoResponse(BaseModel):
id: str
user_id: Optional[str]
title: str
content: Optional[str]
deal_price: Optional[float]
deal_date: Optional[date]
deal_no: Optional[str]
packaging: Optional[str]
category: Optional[str]
is_graded: Optional[bool]
grading_company: Optional[str]
grading_score: Optional[str]
tail_number: Optional[str]
size_type: Optional[str]
version: Optional[str]
platform: Optional[str]
seller: Optional[str]
buyer: Optional[str]
status: str
view_count: int
contact_count: int
created_at: Optional[datetime]
updated_at: Optional[datetime]
class Config:
from_attributes = True
# 生成行情编号
def generate_deal_no(db: Session):
"""生成行情编号从A000001开始递增"""
last = db.query(DealInfo).order_by(DealInfo.deal_no.desc()).first()
if last and last.deal_no:
# 例如 A000001 -> 2 -> A000002
num = int(last.deal_no[1:]) + 1
return f"A{num:06d}"
return "A000001"
# ============ API ============
@router.get("/list", response_model=list[DealInfoResponse])
def get_deal_list(
status: str = Query("active"),
deal_date: Optional[str] = Query(None),
page: int = Query(1, ge=1),
page_size: int = Query(20, ge=1, le=1000),
user_only: bool = Query(False), # 是否只查看自己的
current_user: Optional = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""获取成交行情列表"""
query = db.query(DealInfo).filter(DealInfo.status == status)
# 我的行情:只查看自己的(管理员也只看自己的)
if user_only and current_user:
query = query.filter(DealInfo.user_id == current_user.f99_90_id)
# 成交日期过滤
if deal_date:
query = query.filter(DealInfo.deal_date == deal_date)
# 排序:优先成交日期倒序,同日按编号倒序
query = query.order_by(DealInfo.deal_date.desc().nullslast(), DealInfo.deal_no.desc().nullslast())
# 分页
offset = (page - 1) * page_size
items = query.offset(offset).limit(page_size).all()
return items
@router.get("/stats")
def get_deal_stats(
db: Session = Depends(get_db)
):
"""获取成交行情统计"""
total = db.query(DealInfo).filter(DealInfo.status == "active").count()
# 按日期统计
from sqlalchemy import func
date_stats = db.query(
DealInfo.deal_date,
func.count(DealInfo.id).label('count')
).filter(
DealInfo.status == "active",
DealInfo.deal_date.isnot(None)
).group_by(DealInfo.deal_date).order_by(DealInfo.deal_date.desc()).limit(10).all()
return {
"total": total,
"by_date": [{"date": str(d.deal_date), "count": d.count} for d in date_stats]
}
@router.post("", response_model=DealInfoResponse)
def create_deal(
data: DealInfoCreate,
current_user = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""创建成交行情"""
if not current_user:
raise HTTPException(status_code=401, detail="请先登录")
# 生成行情编号
deal_no = generate_deal_no(db)
# 解析日期
deal_date = None
if data.deal_date:
try:
deal_date = datetime.strptime(data.deal_date, "%Y-%m-%d").date()
except:
pass
deal = DealInfo(
user_id=current_user.f99_90_id if current_user else None,
title=data.title,
content=data.content,
deal_price=data.deal_price,
deal_date=deal_date,
deal_no=deal_no,
packaging=data.packaging,
category=data.category,
is_graded=data.is_graded or False,
grading_company=data.grading_company,
grading_score=data.grading_score,
tail_number=data.tail_number,
size_type=data.size_type,
version=data.version,
platform=data.platform,
seller=data.seller,
buyer=data.buyer,
status="active"
)
db.add(deal)
db.commit()
db.refresh(deal)
return deal
@router.get("/category-stats")
def get_deal_category_stats(
version: str = Query("龙钞", description="版本筛选:龙钞、马钞、蛇钞、其他"),
db: Session = Depends(get_db)
):
"""获取成交行情分类汇总统计数据 - 后端计算优化版"""
from collections import defaultdict
# 定义版本前缀映射
version_prefix_map = {"龙钞": "J0", "马钞": "J1", "蛇钞": "J3"}
packagings = ["标百", "标十", "单张"]
category_map = {"通货": "带4号", "无4": "带7号", "永恒": "永恒号", "钻石": "钻石号"}
# 构建查询
query = db.query(DealInfo).filter(
DealInfo.status == "active", DealInfo.deal_price.isnot(None), DealInfo.deal_price > 0
)
if version != "其他" and version in version_prefix_map:
query = query.filter(DealInfo.title.startswith(version_prefix_map[version]))
deals = query.all()
stats = defaultdict(lambda: defaultdict(lambda: {"count": 0, "total": 0}))
for deal in deals:
content = deal.content or ""
packaging = deal.packaging
if not packaging and "包装:" in content:
packaging = content.split("包装:")[1].split("\n")[0].strip()
category = deal.category
if not category and "分类:" in content:
category = content.split("分类:")[1].split("\n")[0].strip()
if category in category_map:
category = category_map[category]
packaging = packaging or "单张"
category = category or "带4号"
stats[packaging][category]["count"] += 1
stats[packaging][category]["total"] += deal.deal_price
result = []
category_order = ['带4号', '带7号', '永恒号', '天马号', '天马王', '金山号', '金山王', '钻石号', '朦胧号', '朦胧王', '金马号', '金马王', '倒置号', '圆圆号']
for cat in category_order:
row = {"category": cat}
has_data = False
for pkg in packagings:
data = stats[pkg][cat]
if data["count"] > 0:
row[pkg] = {"avg": round(data["total"] / data["count"]), "count": data["count"]}
has_data = True
else:
row[pkg] = None
if has_data:
result.append(row)
return {"version": version, "data": result}
@router.get("/{deal_id}", response_model=DealInfoResponse)
def get_deal(
deal_id: str,
current_user = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""获取成交行情详情"""
deal = db.query(DealInfo).filter(DealInfo.id == deal_id).first()
if not deal:
raise HTTPException(status_code=404, detail="成交行情不存在")
# 增加浏览数
deal.view_count += 1
db.commit()
return deal
@router.put("/{deal_id}", response_model=DealInfoResponse)
def update_deal(
deal_id: str,
data: DealInfoUpdate,
current_user = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""更新成交行情"""
if not current_user:
raise HTTPException(status_code=401, detail="请先登录")
deal = db.query(DealInfo).filter(DealInfo.id == deal_id).first()
if not deal:
raise HTTPException(status_code=404, detail="成交行情不存在")
# 处理日期
if data.deal_date:
try:
data.deal_date = datetime.strptime(data.deal_date, "%Y-%m-%d").date()
except:
data.deal_date = None
for key, value in data.model_dump(exclude_unset=True).items():
setattr(deal, key, value)
db.commit()
db.refresh(deal)
return deal
@router.delete("/{deal_id}")
def delete_deal(
deal_id: str,
current_user = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""删除成交行情"""
if not current_user:
raise HTTPException(status_code=401, detail="请先登录")
deal = db.query(DealInfo).filter(DealInfo.id == deal_id).first()
if not deal:
raise HTTPException(status_code=404, detail="成交行情不存在")
deal.status = "deleted"
db.commit()
return {"message": "删除成功"}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

128
backend/app/routers/news.py Normal file
View File

@ -0,0 +1,128 @@
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy import Table, MetaData
from sqlalchemy.orm import Session
from pydantic import BaseModel
from typing import Optional, List
from datetime import datetime, date
from app.core.database import get_db, engine
from app.models.models import User
from app.routers.auth import get_current_user
router = APIRouter(prefix="/api/news", tags=["资讯"])
metadata = MetaData()
# 分类表
categories_table = Table('news_categories', metadata, autoload_with=engine)
news_table = Table('news', metadata, autoload_with=engine)
user_posts_table = Table('user_posts', metadata, autoload_with=engine)
users_table = Table('users', metadata, autoload_with=engine)
deals_table = Table('deals', metadata, autoload_with=engine)
notifications_table = Table('notifications', metadata, autoload_with=engine)
# ============ 获取分类 ============
@router.get("/categories")
def get_categories(db: Session = Depends(get_db)):
results = db.query(categories_table).order_by(categories_table.c.sort_order).all()
return [dict(r._mapping) for r in results]
# ============ 获取资讯 ============
@router.get("")
def get_news(
category_id: Optional[int] = None,
page: int = 1,
limit: int = 20,
db: Session = Depends(get_db)
):
query = db.query(news_table)
if category_id:
query = query.filter(news_table.c.category_id == category_id)
offset = (page - 1) * limit
results = query.order_by(news_table.c.created_at.desc()).offset(offset).limit(limit).all()
return [dict(r._mapping) for r in results]
# ============ 获取用户发布 ============
@router.get("/posts")
def get_posts(
post_type: Optional[str] = None,
status: str = "active",
page: int = 1,
limit: int = 20,
db: Session = Depends(get_db)
):
query = db.query(user_posts_table).filter(user_posts_table.c.status == status)
if post_type:
query = query.filter(user_posts_table.c.post_type == post_type)
offset = (page - 1) * limit
results = query.order_by(user_posts_table.c.created_at.desc()).offset(offset).limit(limit).all()
return [dict(r._mapping) for r in results]
# ============ 创建发布 ============
class PostCreate(BaseModel):
post_type: str
title: str
content: Optional[str] = None
zodiac_type: Optional[str] = None
packaging: Optional[str] = None
@router.post("/posts")
def create_post(
post: PostCreate,
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
result = db.execute(user_posts_table.insert().values(
user_id=current_user.f99_90_id,
post_type=post.post_type,
title=post.title,
content=post.content,
zodiac_type=post.zodiac_type,
packaging=post.packaging,
status="pending"
))
db.commit()
return {"success": True, "id": result.inserted_primary_key[0]}
# ============ 成交数据 ============
@router.get("/deals")
def get_deals(
zodiac_type: Optional[str] = None,
limit: int = 20,
db: Session = Depends(get_db)
):
query = db.query(deals_table)
if zodiac_type:
query = query.filter(deals_table.c.zodiac_type == zodiac_type)
results = query.order_by(deals_table.c.deal_date.desc()).limit(limit).all()
return [dict(r._mapping) for r in results]
# ============ 通知 ============
@router.get("/notifications")
def get_notifications(limit: int = 10, db: Session = Depends(get_db)):
results = db.query(notifications_table).filter(
notifications_table.c.is_published == True
).order_by(notifications_table.c.created_at.desc()).limit(limit).all()
return [dict(r._mapping) for r in results]
# ============ 首页数据 ============
@router.get("/home")
def get_home(db: Session = Depends(get_db)):
# 推荐发布
posts = db.query(user_posts_table).filter(
user_posts_table.c.status == "active"
).order_by(user_posts_table.c.created_at.desc()).limit(10).all()
# 成交
deals = db.query(deals_table).order_by(
deals_table.c.deal_date.desc()
).limit(10).all()
# 通知
notices = db.query(notifications_table).filter(
notifications_table.c.is_published == True
).order_by(notifications_table.c.created_at.desc()).limit(5).all()
return {
"posts": [dict(p._mapping) for p in posts],
"deals": [dict(d._mapping) for d in deals],
"notices": [dict(n._mapping) for n in notices]
}

384
backend/app/routers/ocr.py Normal file
View File

@ -0,0 +1,384 @@
# OCR 识别路由 - 专业人民币生肖纪念钞鉴定
import os
import uuid
import base64
import httpx
from fastapi import APIRouter, Depends, HTTPException, UploadFile, File
from sqlalchemy.orm import Session
from app.core.database import get_db
from app.core.auth import get_current_user
from app.models.models import User
router = APIRouter(prefix="/api/ocr", tags=["OCR 识别"])
# 阿里云 DashScope API 配置
DASHSCOPE_API_KEY = os.getenv("DASHSCOPE_API_KEY", "sk-9389024a37da4f7bb455ac9a6b28776f")
# 阿里云 OSS 配置
OSS_CONFIG = {
"access_key_id": os.getenv("OSS_ACCESS_KEY_ID", "LTAI5t6HUnpFBLEK9194kPVG"),
"access_key_secret": os.getenv("OSS_ACCESS_KEY_SECRET", "LEr4Q8yRxb8D5b24cKfCwlt4MMoke1"),
"bucket_name": "jiachenlong-oss",
"endpoint": "oss-cn-hangzhou.aliyuncs.com",
"public_url": "https://jiachenlong-oss.oss-cn-hangzhou.aliyuncs.com"
}
# 临时上传目录用于OCR识别本地备选
UPLOAD_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "uploads", "temp")
os.makedirs(UPLOAD_DIR, exist_ok=True)
def get_oss_path(file_type: str, user_id: str = None, collection_id: str = None, filename: str = None):
"""生成OSS路径 - 按年/月/日分类"""
from datetime import datetime
now = datetime.now()
year = now.strftime("%Y")
month = now.strftime("%m")
day = now.strftime("%d")
if file_type == "temp":
# 临时文件: temp/{year}/{month}/{day}/{uuid}.{ext}
import uuid
unique_id = str(uuid.uuid4())
ext = filename.split('.')[-1] if filename and '.' in filename else 'jpg'
return f"temp/{year}/{month}/{day}/{unique_id}.{ext}", unique_id
elif file_type == "collection":
# 藏品文件: collections/{user_id}/{year}/{collection_id}/{filename}
if not user_id or not collection_id:
raise ValueError("user_id and collection_id required for collection")
return f"collections/{user_id}/{year}/{collection_id}/{filename}"
elif file_type == "avatar":
# 头像: avatars/{user_id}/avatar.{ext}
if not user_id:
raise ValueError("user_id required for avatar")
ext = filename.split('.')[-1] if filename and '.' in filename else 'jpg'
return f"avatars/{user_id}/avatar.{ext}"
return None
# 上传图片到OSS - 使用服务层(带压缩)
from app.services.oss import upload_to_oss as oss_upload
def upload_to_oss(file_data, oss_key):
"""上传文件到阿里云OSS带自动压缩"""
return oss_upload(file_data, oss_key)
# 专业提示词
PROFESSIONAL_PROMPT = """你是一名专业的人民币生肖纪念钞鉴定专家。请严格按照以下步骤分析这张图片,并提取准确信息。
识别流程
1. 判断类型是否评级钞首先确认是否为裸钞还是评级钞有封装盒和标签
2. 验证纪念钞特征对照生肖纪念钞特征进行确认
3. 验证评级类型'标十'字眼的为标十'百连'字眼的为标百其他为单张
4. 提取信息仔细阅读标签上的所有文字内容
版别格式要求
只需要年份 + 属相例如
- 2024
- 2025
- 2026
输出要求
严格按照以下格式输出每个字段必须填写具体值
1 发行机构中国人民银行
2 发行版别2024
3 面额贰拾圆
4 是否评级/
5 封装类型裸钞/单张/标十/标百
6 冠字序号J0xxxxxxxx
7 评级机构ACG/PCGS/PMG
8 评级分数67/68/69
9 是否三星/
10 特殊标识金山标/天马标/红绳版等
11 号码特征金山号 2 天马号 3 张等
现在请仔细分析提供的图片按上述格式输出结果"""
@router.post("/recognize")
async def recognize_image(
image: UploadFile = File(...),
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""OCR 图片识别 - 识别后自动保存图片到OSS临时目录"""
try:
# 读取图片数据
image_data = await image.read()
image_base64 = base64.b64encode(image_data).decode('utf-8')
# 生成OSS临时路径: temp/{year}/{month}/{day}/{uuid}.{ext}
oss_key, temp_id = get_oss_path("temp", filename=image.filename)
# 初始化temp_path为空
temp_path = None
# 上传到OSS
try:
image_url = upload_to_oss(image_data, oss_key)
except Exception as oss_err:
# OSS失败时保存到本地作为备选
temp_path = os.path.join(UPLOAD_DIR, oss_key.split('/')[-1])
os.makedirs(os.path.dirname(temp_path), exist_ok=True)
with open(temp_path, 'wb') as f:
f.write(image_data)
image_url = f"/uploads/temp/{oss_key.split('/')[-1]}"
headers = {
"Authorization": f"Bearer {DASHSCOPE_API_KEY}",
"Content-Type": "application/json"
}
# 阿里云 DashScope API 格式 (qwen-vl-plus 视觉模型)
payload = {
"model": "qwen-vl-plus",
"input": {
"messages": [{
"role": "user",
"content": [
{
"image": f"data:{image.content_type};base64,{image_base64}"
},
{
"text": PROFESSIONAL_PROMPT
}
]
}]
},
"parameters": {
"max_tokens": 1000
}
}
async with httpx.AsyncClient(timeout=60.0) as client:
response = await client.post(
"https://dashscope.aliyuncs.com/api/v1/services/aigc/multimodal-generation/generation",
json=payload,
headers=headers
)
if response.status_code != 200:
# 识别失败,删除临时文件
if temp_path and os.path.exists(temp_path):
os.remove(temp_path)
raise HTTPException(status_code=500, detail=f"OCR API 调用失败:{response.text[:200]}")
ocr_result = response.json()
text_content = ""
# 新版API返回格式
if "output" in ocr_result and "choices" in ocr_result["output"]:
choices = ocr_result["output"]["choices"]
if choices and len(choices) > 0:
content = choices[0].get("message", {}).get("content", [])
if content and len(content) > 0:
text_content = content[0].get("text", "")
fields = extract_fields(text_content)
# 更新用户AI识别次数
current_user.f99_95_ai_count = (current_user.f99_95_ai_count or 0) + 1
db.commit()
# 返回识别结果和临时图片路径
return {
"success": True,
"text": text_content,
"fields": fields,
"aiCount": current_user.f99_95_ai_count,
"temp_image": {
"id": temp_id,
"filename": oss_key.split('/')[-1],
"path": image_url,
"original_name": image.filename,
"is_oss": image_url.startswith("https://")
}
}
except Exception as e:
import traceback
error_detail = f"识别失败:{str(e)}\n{traceback.format_exc()}"
raise HTTPException(status_code=500, detail=error_detail)
def extract_fields(text: str) -> dict:
"""从 OCR 文本中提取字段 - 直接返回 AI 识别结果"""
import re
fields = {}
# 解析结构化输出
patterns = {
'issuer': r'✅.*?1.*?发行机构.*?[:]\s*(.+?)(?:\n|$)',
'version': r'✅.*?2.*?发行版别.*?[:]\s*(.+?)(?:\n|$)',
'denomination': r'✅.*?3.*?面额.*?[:]\s*(.+?)(?:\n|$)',
'is_graded_text': r'✅.*?4.*?是否评级.*?[:]\s*(.+?)(?:\n|$)',
'packaging': r'✅.*?5.*?封装类型.*?[:]\s*(.+?)(?:\n|$)',
'prefix_serial': r'✅.*?6.*?冠字序号.*?[:]\s*(.+?)(?:\n|$)',
'grading_company': r'✅.*?7.*?评级机构.*?[:]\s*(.+?)(?:\n|$)',
'grading_score': r'✅.*?8.*?评级分数.*?[:]\s*(.+?)(?:\n|$)',
'three_star_text': r'✅.*?9.*?是否三星.*?[:]\s*(.+?)(?:\n|$)',
'special_mark': r'✅.*?10.*?特殊标识.*?[:]\s*(.+?)(?:\n|$)',
'serial_feature': r'✅.*?11.*?号码特征.*?[:]\s*(.+?)(?:\n|$)'
}
for field, pattern in patterns.items():
match = re.search(pattern, text, re.IGNORECASE | re.DOTALL)
if match:
value = match.group(1).strip()
# 保留所有值,包括"无"和"未识别",让前端处理
fields[field] = value
# 处理是否评级
if 'is_graded_text' in fields:
fields['is_graded'] = '' in fields.pop('is_graded_text')
# 处理是否三星
if 'three_star_text' in fields:
fields['three_star'] = '' in fields.pop('three_star_text')
# 简化版别字段2024 龙年贺岁纪念钞(标十) → 2024 龙)
if 'version' in fields:
version = fields['version']
# 提取年份和生肖
year_match = re.search(r'(20\d{2})', version)
animal = ''
if '' in version:
animal = ''
elif '' in version:
animal = ''
elif '' in version:
animal = ''
elif '' in version:
animal = ''
elif '' in version:
animal = ''
elif '' in version:
animal = ''
elif '' in version:
animal = ''
elif '' in version:
animal = ''
elif '' in version:
animal = ''
elif '' in version:
animal = ''
elif '' in version:
animal = ''
elif '' in version:
animal = ''
if year_match and animal:
fields['version'] = f"{year_match.group(1)}{animal}"
return fields
@router.post("/claim-temp-image")
async def claim_temp_image(
temp_id: str,
collection_id: str,
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""将临时图片移动到正式藏品目录 - 按用户/年/藏品ID分类"""
from app.models.models import Collection, CollectionImage
from datetime import datetime
# 验证藏品是否存在
collection = db.query(Collection).filter(
Collection.f99_90_id == collection_id,
Collection.f99_91_user_id == current_user.f99_90_id
).first()
if not collection:
raise HTTPException(status_code=404, detail="藏品不存在")
# 生成正式文件名和OSS路径: collections/{user_id}/{year}/{collection_id}/{filename}
code = collection.f01_02_code or "0000"
prefix = collection.f02_10_prefix_serial or ""
username = current_user.f01_01_name
import time
final_filename = f"{username}-{code}-{prefix}-{int(time.time())}.jpg"
oss_key = get_oss_path("collection", user_id=current_user.f99_90_id, collection_id=collection_id, filename=final_filename)
# 尝试从OSS获取临时图片 - 尝试多种扩展名和日期路径
temp_extensions = ['jpg', 'jpeg', 'png', 'gif', 'JPG', 'JPEG', 'PNG', 'GIF']
temp_content = None
found_key = None
# 尝试最近7天的路径
from datetime import timedelta
for i in range(7):
date = datetime.now() - timedelta(days=i)
year = date.strftime("%Y")
month = date.strftime("%m")
day = date.strftime("%d")
for ext in temp_extensions:
try:
temp_oss_key = f"temp/{year}/{month}/{day}/{temp_id}.{ext}"
import oss2
auth = oss2.Auth(OSS_CONFIG["access_key_id"], OSS_CONFIG["access_key_secret"])
bucket = oss2.Bucket(auth, OSS_CONFIG["endpoint"], OSS_CONFIG["bucket_name"])
temp_content = bucket.get_object(temp_oss_key).read()
found_key = temp_oss_key
break
except:
continue
if temp_content:
break
if temp_content:
# 上传到正式目录
bucket.put_object(oss_key, temp_content)
# 删除临时图片
try:
bucket.delete_object(found_key)
except:
pass
# OSS URL
image_path = f"{OSS_CONFIG['public_url']}/{oss_key}"
else:
# OSS失败使用本地文件
temp_path = None
for ext in temp_extensions:
temp_path = os.path.join(UPLOAD_DIR, f"{temp_id}.{ext}")
if os.path.exists(temp_path):
break
if not temp_path or not os.path.exists(temp_path):
raise HTTPException(status_code=404, detail="临时图片不存在或已过期")
# 保存到本地
collection_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "uploads", "collections")
os.makedirs(collection_dir, exist_ok=True)
new_path = os.path.join(collection_dir, final_filename)
import shutil
shutil.move(temp_path, new_path)
image_path = f"uploads/collections/{final_filename}"
# 创建图片记录
image_record = CollectionImage(
id=str(uuid.uuid4()),
collection_id=collection.f99_90_id,
filename=final_filename,
original_name=temp_id,
path=image_path
)
db.add(image_record)
db.commit()
return {
"success": True,
"image": {
"id": image_record.id,
"filename": image_record.filename,
"path": image_record.path
}
}

View File

@ -0,0 +1,104 @@
# 操作路由
from typing import List, Optional
from fastapi import APIRouter, Depends, HTTPException, status, Query
from sqlalchemy.orm import Session
from app.core.database import get_db
from app.core.auth import get_current_user
from app.models.models import User, Collection, Operation
from app.schemas.schemas import OperationCreate, OperationResponse
router = APIRouter(prefix="/api", tags=["操作"])
@router.get("/operations", response_model=List[OperationResponse])
def get_operations(
collection_id: Optional[str] = None,
page: int = Query(1, ge=1),
limit: int = Query(50, ge=1, le=100),
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""获取操作历史"""
query = db.query(Operation).filter(Operation.user_id == current_user.id)
if collection_id:
query = query.filter(Operation.collection_id == collection_id)
operations = query.order_by(Operation.created_at.desc()) \
.offset((page - 1) * limit) \
.limit(limit) \
.all()
return operations
@router.get("/operations/history")
def get_operation_history(
collection_id: Optional[str] = None,
type: Optional[str] = None,
start_date: Optional[str] = None,
end_date: Optional[str] = None,
page: int = Query(1, ge=1),
limit: int = Query(50, ge=1, le=100),
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""获取操作历史(带统计)"""
query = db.query(Operation).filter(Operation.user_id == current_user.id)
if collection_id:
query = query.filter(Operation.collection_id == collection_id)
if type:
query = query.filter(Operation.type == type)
if start_date:
query = query.filter(Operation.created_at >= start_date)
if end_date:
query = query.filter(Operation.created_at <= end_date)
total = query.count()
data = query.order_by(Operation.created_at.desc()) \
.offset((page - 1) * limit) \
.limit(limit) \
.all()
return {
"data": data,
"pagination": {
"page": page,
"limit": limit,
"total": total,
"pages": (total + limit - 1) // limit
}
}
@router.post("/operations", response_model=OperationResponse)
def create_operation(
operation_data: OperationCreate,
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""创建操作记录"""
# 验证藏品存在
collection = db.query(Collection).filter(
Collection.id == operation_data.collection_id,
Collection.user_id == current_user.id
).first()
if not collection:
raise HTTPException(status_code=404, detail="藏品不存在")
operation = Operation(
collection_id=operation_data.collection_id,
user_id=current_user.id,
type=operation_data.type,
price=operation_data.price,
note=operation_data.note
)
db.add(operation)
db.commit()
db.refresh(operation)
return operation

189
backend/app/routers/seek.py Normal file
View File

@ -0,0 +1,189 @@
from fastapi import APIRouter, Depends, Query, HTTPException
from sqlalchemy.orm import Session
from pydantic import BaseModel
from typing import Optional
from datetime import datetime
from app.core.database import get_db
from app.core.auth import get_current_user
from app.models.seek_info import SeekInfo
router = APIRouter(prefix="/api/seek", tags=["寻配号"])
# ============ Schema ============
class SeekInfoCreate(BaseModel):
title: str
content: Optional[str] = None
expect_category: Optional[str] = None
expect_version: Optional[str] = None
expect_packaging: Optional[str] = None
expect_number: Optional[str] = None
expect_price_min: Optional[float] = None
expect_price_max: Optional[float] = None
class SeekInfoUpdate(BaseModel):
title: Optional[str] = None
content: Optional[str] = None
expect_category: Optional[str] = None
expect_version: Optional[str] = None
expect_packaging: Optional[str] = None
expect_number: Optional[str] = None
expect_price_min: Optional[float] = None
expect_price_max: Optional[float] = None
status: Optional[str] = None
class SeekInfoResponse(BaseModel):
id: str
user_id: str
title: str
content: Optional[str]
expect_category: Optional[str]
expect_version: Optional[str]
expect_packaging: Optional[str]
expect_number: Optional[str]
expect_price_min: Optional[float]
expect_price_max: Optional[float]
status: str
is_matched: Optional[str]
matched_user_id: Optional[str]
matched_contact: Optional[str]
view_count: int
contact_count: int
created_at: Optional[datetime]
updated_at: Optional[datetime]
class Config:
from_attributes = True
# ============ API ============
@router.get("/list", response_model=list[SeekInfoResponse])
def get_seek_list(
status: str = Query("active"),
page: int = Query(1, ge=1),
page_size: int = Query(20, ge=1, le=1000),
user_only: bool = Query(False),
current_user: Optional = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""获取寻配号列表"""
query = db.query(SeekInfo).filter(SeekInfo.status == status)
# 我的寻配号:只查看自己的
if user_only and current_user:
query = query.filter(SeekInfo.user_id == current_user.f99_90_id)
# 排序
query = query.order_by(SeekInfo.created_at.desc())
# 分页
offset = (page - 1) * page_size
items = query.offset(offset).limit(page_size).all()
return items
@router.get("/stats")
def get_seek_stats(
current_user = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""获取寻配号统计"""
total = db.query(SeekInfo).filter(SeekInfo.status == "active").count()
matched = db.query(SeekInfo).filter(SeekInfo.is_matched == "true").count()
return {
"total": total,
"matched": matched,
"unmatched": total - matched
}
@router.post("", response_model=SeekInfoResponse)
def create_seek(
data: SeekInfoCreate,
current_user = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""创建寻配号"""
if not current_user:
raise HTTPException(status_code=401, detail="请先登录")
seek = SeekInfo(
user_id=current_user.f99_90_id,
title=data.title,
content=data.content,
expect_category=data.expect_category,
expect_version=data.expect_version,
expect_packaging=data.expect_packaging,
expect_number=data.expect_number,
expect_price_min=data.expect_price_min,
expect_price_max=data.expect_price_max,
status="active"
)
db.add(seek)
db.commit()
db.refresh(seek)
return seek
@router.get("/{seek_id}", response_model=SeekInfoResponse)
def get_seek(
seek_id: str,
current_user = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""获取寻配号详情"""
seek = db.query(SeekInfo).filter(SeekInfo.id == seek_id).first()
if not seek:
raise HTTPException(status_code=404, detail="寻配号不存在")
# 增加浏览数
seek.view_count += 1
db.commit()
return seek
@router.put("/{seek_id}", response_model=SeekInfoResponse)
def update_seek(
seek_id: str,
data: SeekInfoUpdate,
current_user = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""更新寻配号"""
if not current_user:
raise HTTPException(status_code=401, detail="请先登录")
seek = db.query(SeekInfo).filter(
SeekInfo.id == seek_id,
SeekInfo.user_id == current_user.f99_90_id
).first()
if not seek:
raise HTTPException(status_code=404, detail="寻配号不存在")
for key, value in data.model_dump(exclude_unset=True).items():
setattr(seek, key, value)
db.commit()
db.refresh(seek)
return seek
@router.delete("/{seek_id}")
def delete_seek(
seek_id: str,
current_user = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""删除寻配号"""
if not current_user:
raise HTTPException(status_code=401, detail="请先登录")
seek = db.query(SeekInfo).filter(
SeekInfo.id == seek_id,
SeekInfo.user_id == current_user.f99_90_id
).first()
if not seek:
raise HTTPException(status_code=404, detail="寻配号不存在")
seek.status = "deleted"
db.commit()
return {"message": "删除成功"}

View File

@ -0,0 +1,305 @@
# 用户管理路由
from typing import Optional
from fastapi import APIRouter, Depends, HTTPException, status, Query, Body
from sqlalchemy.orm import Session
from app.core.database import get_db
from app.core.auth import get_current_user
from app.models.models import User, Collection
from app.schemas.schemas import UserResponse, UserUpdate
router = APIRouter(prefix="/api", tags=["用户"])
# ============ 当前用户接口 ============
@router.get("/users/me") # 无 response_model避免 Pydantic 序列化问题
def get_current_user_info(
current_user: User = Depends(get_current_user)
):
"""获取当前登录用户信息"""
return {
"id": current_user.f99_90_id,
"username": current_user.f01_01_name,
"f99_90_id": current_user.f99_90_id,
"f01_01_name": current_user.f01_01_name,
"email": current_user.email,
"phone": current_user.phone,
"avatar": current_user.avatar,
"address": current_user.address,
"bio": current_user.bio,
"role": current_user.role,
"level": current_user.f99_94_level,
"aiCount": current_user.f99_95_ai_count or 0,
"searchCount": current_user.f99_96_search_count or 0,
"collectionCount": current_user.f99_97_collection_count or 0,
"phoneVerified": current_user.f01_06_phone_verified or False,
"loginCount": current_user.f99_98_login_count or 0,
"lastLogin": current_user.f99_99_last_login.isoformat() if current_user.f99_99_last_login else None,
"gender": current_user.f01_07_gender,
"birthday": current_user.f01_08_birthday.isoformat() if current_user.f01_08_birthday else None,
"region": current_user.f01_09_region,
"realnameVerified": current_user.f01_10_realname_verified or False,
"points": current_user.f99_100_points or 0,
"balance": float(current_user.f01_11_balance) if current_user.f01_11_balance else 0,
"totalAmount": float(current_user.f01_12_total_amount) if current_user.f01_12_total_amount else 0,
"inviteCode": current_user.f01_13_invite_code,
"user_code": current_user.user_code,
"f99_92_created_at": current_user.f99_92_created_at.isoformat() if current_user.f99_92_created_at else None,
"f99_93_updated_at": current_user.f99_93_updated_at.isoformat() if current_user.f99_93_updated_at else None
}
@router.put("/users/me") # 无 response_model避免 Pydantic 序列化问题
def update_current_user(
user_update: UserUpdate,
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""更新当前用户信息"""
import logging
logger = logging.getLogger(__name__)
# 获取用户ID
user_id = current_user.f99_90_id
logger.info(f"Updating user {user_id}, data={user_update.model_dump()}")
# 在当前session中重新查询用户
user = db.query(User).filter(User.f99_90_id == user_id).first()
if not user:
raise HTTPException(status_code=404, detail="用户不存在")
# 更新字段
update_data = user_update.model_dump(exclude_unset=True)
for field, value in update_data.items():
if field == 'f01_01_name':
user.f01_01_name = value
elif field == 'username':
pass # skip, already handled as f01_01_name
elif hasattr(user, field):
setattr(user, field, value)
# 强制刷新以确保更新被提交
db.flush()
db.commit()
db.refresh(user)
logger.info(f"After commit, user email={user.email}")
return user
# ============ 管理员用户管理 ============
admin_router = APIRouter(prefix="/api/admin/users", tags=["用户管理"])
@admin_router.get("")
def get_users(
page: int = Query(1, ge=1),
limit: int = Query(20, ge=1, le=100),
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""获取用户列表(仅管理员)"""
if current_user.role not in ["admin", "editor"]:
raise HTTPException(status_code=403, detail="无权访问")
total = db.query(User).count()
from sqlalchemy import case
users = db.query(User).order_by(
case(
(User.user_code == None, 1),
else_=0
),
User.user_code.asc()
).offset((page-1)*limit).limit(limit).all()
user_list = []
for u in users:
# 统计每个用户的藏品数量
count = db.query(Collection).filter(Collection.f99_91_user_id == u.f99_90_id).count()
user_list.append({
"id": u.f99_90_id,
"username": u.f01_01_name,
"email": u.email,
"phone": u.phone,
"role": u.role,
"user_code": u.user_code,
"created_at": u.f99_92_created_at.isoformat() if u.f99_92_created_at else None,
"collectionCount": count,
"level": u.f99_94_level,
"aiCount": u.f99_95_ai_count,
"searchCount": u.f99_96_search_count,
"loginCount": u.f99_98_login_count,
"points": u.f99_100_points,
"balance": float(u.f01_11_balance) if u.f01_11_balance else 0,
"totalAmount": float(u.f01_12_total_amount) if u.f01_12_total_amount else 0,
"phoneVerified": u.f01_06_phone_verified,
})
return user_list
@admin_router.get("/{user_id}")
def get_user(
user_id: str,
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""获取单个用户信息"""
if current_user.role not in ["admin", "editor"]:
raise HTTPException(status_code=403, detail="无权访问")
user = db.query(User).filter(User.id == user_id).first()
if not user:
raise HTTPException(status_code=404, detail="用户不存在")
return {
"id": user.id,
"username": user.username,
"email": user.email,
"phone": user.phone,
"role": user.role,
"created_at": user.created_at.isoformat() if user.created_at else None
}
@admin_router.get("/{user_id}/collections")
def get_user_collections(
user_id: str,
limit: int = Query(100, ge=1, le=100),
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""获取指定用户的藏品列表"""
if current_user.role not in ["admin", "editor"]:
raise HTTPException(status_code=403, detail="无权访问")
collections = db.query(Collection).filter(
Collection.user_id == user_id
).limit(limit).all()
return [c.code for c in collections]
@admin_router.get("/{user_id}/count")
def get_user_collection_count(
user_id: str,
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""获取指定用户的藏品数量"""
if current_user.role not in ["admin", "editor"]:
raise HTTPException(status_code=403, detail="E00050: 仅管理员可访问")
count = db.query(Collection).filter(Collection.user_id == user_id).count()
return {"count": count}
@admin_router.put("/{user_id}")
def update_user(
user_id: str,
username: Optional[str] = Body(None),
email: Optional[str] = Body(None),
role: Optional[str] = Body(None),
password: Optional[str] = Body(None),
user_code: Optional[str] = Body(None),
level: Optional[str] = Body(None),
points: Optional[int] = Body(None),
balance: Optional[float] = Body(None),
totalAmount: Optional[float] = Body(None),
aiCount: Optional[int] = Body(None),
searchCount: Optional[int] = Body(None),
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""更新用户信息(仅管理员)"""
if current_user.role not in ["admin", "editor"]:
raise HTTPException(status_code=403, detail="E00050: 仅管理员可访问")
user = db.query(User).filter(User.f99_90_id == user_id).first()
if not user:
raise HTTPException(status_code=404, detail="E00051: 用户不存在")
# 更新基本信息
if username:
user.f01_01_name = username
if email:
user.email = email
if role is not None:
user.role = role
# 更新会员等级
if level is not None:
user.f99_94_level = level
# 更新积分
if points is not None:
user.f99_100_points = points
# 更新余额
if balance is not None:
user.f01_11_balance = balance
# 更新累计金额
if totalAmount is not None:
user.f01_12_total_amount = totalAmount
# 更新AI识别次数
if aiCount is not None:
user.f99_95_ai_count = aiCount
# 更新寻号次数
if searchCount is not None:
user.f99_96_search_count = searchCount
# 更新用户编码
if user_code is not None:
# 只有非空字符串才检查唯一性
user_code_str = user_code.strip() if user_code else ''
if user_code_str:
existing = db.query(User).filter(
User.user_code == user_code_str,
User.f99_90_id != user_id
).first()
if existing:
raise HTTPException(status_code=400, detail="E00052: 该用户编码已被其他用户使用")
user.user_code = user_code_str
else:
user.user_code = None
# 更新密码
if password and password.strip():
from app.core.auth import get_password_hash
user.password = get_password_hash(password)
db.commit()
db.refresh(user)
return {
"id": user.f99_90_id,
"username": user.f01_01_name,
"email": user.email,
"role": user.role,
"message": "更新成功"
}
@admin_router.delete("/{user_id}")
def delete_user(
user_id: str,
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""删除用户(仅管理员)"""
if current_user.role not in ["admin", "editor"]:
raise HTTPException(status_code=403, detail="E00050: 仅管理员可访问")
# 不能删除自己
if user_id == str(current_user.f99_90_id):
raise HTTPException(status_code=400, detail="E00052: 不能删除自己")
user = db.query(User).filter(User.f99_90_id == user_id).first()
if not user:
raise HTTPException(status_code=404, detail="E00051: 用户不存在")
db.delete(user)
db.commit()
return {"message": "删除成功"}

View File

@ -0,0 +1,377 @@
from fastapi import APIRouter, Depends, Query
from sqlalchemy import func, text
from sqlalchemy.orm import Session
from pydantic import BaseModel
from typing import Optional, List
from datetime import datetime, date
from app.core.coolbot_db import get_coolbot_db
router = APIRouter(prefix="/api/yichens", tags=["一尘看板"])
# ============ 数据模型 ============
class YichensPostStats(BaseModel):
total_posts: int
total_deals: int # 出售
total_wants: int # 求购
total_replies: int
total_views: int
avg_price: Optional[float]
class CategoryStat(BaseModel):
category: str
count: int
class PostItem(BaseModel):
post_id: str
title: str
category: Optional[str]
post_type: str
price: Optional[float]
author_username: str
post_time: str
reply_count: int
view_count: int
url: Optional[str]
content: Optional[str]
class UserStat(BaseModel):
total_users: int
new_users_today: int
sellers: int
class UserItem(BaseModel):
user_id: str
username: str
avatar_url: Optional[str]
content: Optional[str]
credit_level: Optional[str]
credit_score: Optional[int]
post_count: int
is_seller: bool
registration_date: Optional[str]
# ============ 统计接口 ============
@router.get("/stats/posts", response_model=YichensPostStats)
def get_post_stats(days: int = Query(30, ge=1, le=365), db: Session = Depends(get_coolbot_db)):
"""获取帖子统计"""
result = db.execute(text("""
SELECT
COUNT(*) as total_posts,
COUNT(*) FILTER (WHERE post_type = 'deal') as total_deals,
COUNT(*) FILTER (WHERE post_type = 'want') as total_wants,
COALESCE(SUM(reply_count), 0) as total_replies,
COALESCE(SUM(view_count), 0) as total_views,
AVG(price) as avg_price
FROM yichens_posts
WHERE post_time >= NOW() - INTERVAL '1 day' * :days
"""), {"days": days}).fetchone()
return YichensPostStats(
total_posts=result[0] or 0,
total_deals=result[1] or 0,
total_wants=result[2] or 0,
total_replies=result[3] or 0,
total_views=result[4] or 0,
avg_price=float(result[5]) if result[5] else None
)
@router.get("/stats/categories", response_model=List[CategoryStat])
def get_category_stats(days: int = Query(30, ge=1, le=365), db: Session = Depends(get_coolbot_db)):
"""按分类统计帖子数量"""
results = db.execute(text("""
SELECT category, COUNT(*) as count
FROM yichens_posts
WHERE post_time >= NOW() - INTERVAL '1 day' * :days
GROUP BY category
ORDER BY count DESC
"""), {"days": days}).fetchall()
return [CategoryStat(category=r[0] or "未知", count=r[1]) for r in results]
@router.get("/stats/users", response_model=UserStat)
def get_user_stats(db: Session = Depends(get_coolbot_db)):
"""获取用户统计"""
result = db.execute(text("""
SELECT
COUNT(*) as total_users,
COUNT(*) FILTER (WHERE created_at::date = CURRENT_DATE) as new_users_today,
COUNT(*) FILTER (WHERE is_seller = true) as sellers
FROM yichens_users
""")).fetchone()
return UserStat(
total_users=result[0] or 0,
new_users_today=result[1] or 0,
sellers=result[2] or 0
)
@router.get("/posts")
def get_posts(
limit: int = Query(20, ge=1, le=500),
offset: int = Query(0, ge=0),
category: Optional[str] = None,
post_type: Optional[str] = None,
keyword: Optional[str] = None,
db: Session = Depends(get_coolbot_db)
):
"""获取帖子列表 - 支持全局搜索,返回总数和分页信息"""
# 构建WHERE条件
where_clauses = ["1=1"]
params = {"limit": limit, "offset": offset}
if category:
where_clauses.append("category = :category")
params["category"] = category
if post_type:
where_clauses.append("post_type = :post_type")
params["post_type"] = post_type
# 全局搜索
if keyword:
where_clauses.append("(title ILIKE :keyword OR content ILIKE :keyword OR category ILIKE :keyword OR author_username ILIKE :keyword)")
params["keyword"] = f"%{keyword}%"
where_sql = " AND ".join(where_clauses)
# 查询总数
count_query = f"SELECT COUNT(*) FROM yichens_posts WHERE {where_sql}"
total_count = db.execute(text(count_query), {k: v for k, v in params.items() if k not in ['limit', 'offset']}).scalar() or 0
# 查询数据
data_query = f"""
SELECT post_id, title, content, category, post_type, price,
author_username, post_time, reply_count, view_count, url
FROM yichens_posts
WHERE {where_sql}
ORDER BY post_time DESC LIMIT :limit OFFSET :offset
"""
results = db.execute(text(data_query), params).fetchall()
posts = [PostItem(
post_id=r[0],
title=r[1] or "",
content=r[2] or "",
category=r[3],
post_type=r[4] or "",
price=float(r[5]) if r[5] else None,
author_username=r[6] or "",
post_time=str(r[7]) if r[7] else "",
reply_count=r[8] or 0,
view_count=r[9] or 0,
url=r[10]
) for r in results]
return {
"posts": posts,
"total": total_count,
"page": offset // limit + 1,
"page_size": limit
}
@router.get("/users", response_model=List[UserItem])
def get_users(
limit: int = Query(20, ge=1, le=500),
offset: int = Query(0, ge=0),
is_seller: Optional[bool] = None,
db: Session = Depends(get_coolbot_db)
):
"""获取用户列表"""
query = """
SELECT user_id, username, avatar_url, credit_level, credit_score,
post_count, is_seller, registration_date
FROM yichens_users
WHERE 1=1
"""
params = {"limit": limit, "offset": offset}
if is_seller is not None:
query += " AND is_seller = :is_seller"
params["is_seller"] = is_seller
query += " ORDER BY post_count DESC LIMIT :limit OFFSET :offset"
results = db.execute(text(query), params).fetchall()
return [UserItem(
user_id=r[0],
username=r[1] or "",
avatar_url=r[2],
credit_level=r[3],
credit_score=r[4],
post_count=r[5] or 0,
is_seller=r[6] or False,
registration_date=str(r[7]) if r[7] else None
) for r in results]
@router.get("/stats/today")
async def get_today_stats(db: Session = Depends(get_coolbot_db)):
"""获取今日新增帖子统计"""
query = """
SELECT
COUNT(*) as total,
SUM(CASE WHEN post_type = 'deal' THEN 1 ELSE 0 END) as deals,
SUM(CASE WHEN post_type = 'want' THEN 1 ELSE 0 END) as wants,
SUM(CASE WHEN post_type = 'normal' THEN 1 ELSE 0 END) as others,
SUM(CASE WHEN category LIKE '%%' THEN 1 ELSE 0 END) as dragons,
SUM(CASE WHEN category LIKE '%%' THEN 1 ELSE 0 END) as horses,
SUM(CASE WHEN category LIKE '%%' THEN 1 ELSE 0 END) as snakes,
SUM(CASE WHEN title LIKE '%天马%' OR content LIKE '%天马%' THEN 1 ELSE 0 END) as tianma
FROM yichens_posts
WHERE post_time >= CURRENT_DATE
"""
result = db.execute(text(query)).fetchone()
return {
"total": result[0] or 0,
"deals": result[1] or 0,
"wants": result[2] or 0,
"others": result[3] or 0,
"dragons": result[4] or 0,
"horses": result[5] or 0,
"snakes": result[6] or 0,
"tianma": result[7] or 0
}
@router.get("/stats/hour")
async def get_hour_stats(db: Session = Depends(get_coolbot_db)):
"""获取近一个小时新增帖子统计"""
query = """
SELECT
COUNT(*) as total,
SUM(CASE WHEN post_type = 'deal' THEN 1 ELSE 0 END) as deals,
SUM(CASE WHEN post_type = 'want' THEN 1 ELSE 0 END) as wants,
SUM(CASE WHEN post_type = 'normal' THEN 1 ELSE 0 END) as others,
SUM(CASE WHEN category LIKE '%%' THEN 1 ELSE 0 END) as dragons,
SUM(CASE WHEN category LIKE '%%' THEN 1 ELSE 0 END) as horses,
SUM(CASE WHEN category LIKE '%%' THEN 1 ELSE 0 END) as snakes
FROM yichens_posts
WHERE post_time >= NOW() - INTERVAL '1 hour'
"""
result = db.execute(text(query)).fetchone()
return {
"total": result[0] or 0,
"deals": result[1] or 0,
"wants": result[2] or 0,
"others": result[3] or 0,
"dragons": result[3] or 0,
"horses": result[4] or 0,
"snakes": result[5] or 0
}
@router.get("/stats/today-category")
async def get_today_category_stats(db: Session = Depends(get_coolbot_db)):
"""获取今日帖子分类统计"""
query = """
SELECT category, COUNT(*) as count
FROM yichens_posts
WHERE post_time >= CURRENT_DATE
GROUP BY category
ORDER BY count DESC
"""
results = db.execute(text(query)).fetchall()
return [{"category": r[0] or "未分类", "count": r[1]} for r in results]
@router.get("/stats/dragons-today")
def get_dragons_stats_today(
db: Session = Depends(get_coolbot_db)
):
"""获取今日龙钞详细统计数据(按号码分类)- 就高不就低"""
from sqlalchemy import text
# 1. 带4包含"带4"、"带四"、"通货"
dai4 = db.execute(text("""
SELECT
COUNT(*) as total,
SUM(CASE WHEN post_type = 'deal' THEN 1 ELSE 0 END) as deals,
SUM(CASE WHEN post_type = 'want' THEN 1 ELSE 0 END) as wants
FROM yichens_posts
WHERE post_time >= CURRENT_DATE
AND category LIKE '%%'
AND (
content LIKE '%带4%' OR title LIKE '%带4%'
OR content LIKE '%带四%' OR title LIKE '%带四%'
OR content LIKE '%通货%' OR title LIKE '%通货%'
)
""")).fetchone()
# 2. 无4包含"无4"、"无四",排除"无47"、"无247"、"无四七"、"永恒"
wu4 = db.execute(text("""
SELECT
COUNT(*) as total,
SUM(CASE WHEN post_type = 'deal' THEN 1 ELSE 0 END) as deals,
SUM(CASE WHEN post_type = 'want' THEN 1 ELSE 0 END) as wants
FROM yichens_posts
WHERE post_time >= CURRENT_DATE
AND category LIKE '%%'
AND (
content LIKE '%无4%' OR title LIKE '%无4%'
OR content LIKE '%无四%' OR title LIKE '%无四%'
)
AND content NOT LIKE '%无47%' AND title NOT LIKE '%无47%'
AND content NOT LIKE '%无247%' AND title NOT LIKE '%无247%'
AND content NOT LIKE '%永恒%' AND title NOT LIKE '%永恒%'
AND content NOT LIKE '%无四七%' AND title NOT LIKE '%无四七%'
""")).fetchone()
# 3. 无47包含"无47"、"永恒"、"无四七",排除"无247"
wu47 = db.execute(text("""
SELECT
COUNT(*) as total,
SUM(CASE WHEN post_type = 'deal' THEN 1 ELSE 0 END) as deals,
SUM(CASE WHEN post_type = 'want' THEN 1 ELSE 0 END) as wants
FROM yichens_posts
WHERE post_time >= CURRENT_DATE
AND category LIKE '%%'
AND (
content LIKE '%无47%' OR title LIKE '%无47%'
OR content LIKE '%永恒%' OR title LIKE '%永恒%'
OR content LIKE '%无四七%' OR title LIKE '%无四七%'
)
AND content NOT LIKE '%无247%' AND title NOT LIKE '%无247%'
""")).fetchone()
# 4. 无247包含"无247"、"天马"、"金山",排除"无347"
wu247 = db.execute(text("""
SELECT
COUNT(*) as total,
SUM(CASE WHEN post_type = 'deal' THEN 1 ELSE 0 END) as deals,
SUM(CASE WHEN post_type = 'want' THEN 1 ELSE 0 END) as wants
FROM yichens_posts
WHERE post_time >= CURRENT_DATE
AND category LIKE '%%'
AND (
content LIKE '%无247%' OR title LIKE '%无247%'
OR content LIKE '%天马%' OR title LIKE '%天马%'
OR content LIKE '%金山%' OR title LIKE '%金山%'
)
AND content NOT LIKE '%无347%' AND title NOT LIKE '%无347%'
""")).fetchone()
# 5. 无347包含"无347"、"钻石"、"金马"、"魅力"、"朦胧"
wu347 = db.execute(text("""
SELECT
COUNT(*) as total,
SUM(CASE WHEN post_type = 'deal' THEN 1 ELSE 0 END) as deals,
SUM(CASE WHEN post_type = 'want' THEN 1 ELSE 0 END) as wants
FROM yichens_posts
WHERE post_time >= CURRENT_DATE
AND category LIKE '%%'
AND (
content LIKE '%无347%' OR title LIKE '%无347%'
OR content LIKE '%钻石%' OR title LIKE '%钻石%'
OR content LIKE '%金马%' OR title LIKE '%金马%'
OR content LIKE '%魅力%' OR title LIKE '%魅力%'
OR content LIKE '%朦胧%' OR title LIKE '%朦胧%'
)
""")).fetchone()
return {
"dai4": {"total": dai4[0] or 0, "deals": dai4[1] or 0, "wants": dai4[2] or 0},
"wu4": {"total": wu4[0] or 0, "deals": wu4[1] or 0, "wants": wu4[2] or 0},
"wu47": {"total": wu47[0] or 0, "deals": wu47[1] or 0, "wants": wu47[2] or 0},
"wu247": {"total": wu247[0] or 0, "deals": wu247[1] or 0, "wants": wu247[2] or 0},
"wu347": {"total": wu347[0] or 0, "deals": wu347[1] or 0, "wants": wu347[2] or 0}
}

View File

View File

@ -0,0 +1,231 @@
# Pydantic Schema - 使用字段编码并支持 camelCase
from typing import Optional, List
from pydantic import BaseModel, EmailStr, Field, ConfigDict
from datetime import datetime
# ============ 用户相关 ============
class UserBase(BaseModel):
f01_01_name: str = Field(..., min_length=3, max_length=255, alias="username")
email: Optional[EmailStr] = None
phone: Optional[str] = None
avatar: Optional[str] = None
address: Optional[str] = None
bio: Optional[str] = None
model_config = ConfigDict(from_attributes=True, populate_by_name=True)
class UserCreate(UserBase):
password: str = Field(..., min_length=6)
invite_code: Optional[str] = Field(None, alias="inviteCode") # 填写的邀请码(选填)
class UserUpdate(BaseModel):
f01_01_name: Optional[str] = Field(None, alias="username")
email: Optional[EmailStr] = None
phone: Optional[str] = None
avatar: Optional[str] = None
address: Optional[str] = None
bio: Optional[str] = None
password: Optional[str] = None
model_config = ConfigDict(from_attributes=True, populate_by_name=True)
class UserResponse(UserBase):
# 新增字段
f99_94_level: Optional[str] = Field(None, alias="level")
f99_95_ai_count: Optional[int] = Field(0, alias="aiCount")
f99_96_search_count: Optional[int] = Field(0, alias="searchCount")
f99_97_collection_count: Optional[int] = Field(0, alias="collectionCount")
f01_06_phone_verified: Optional[bool] = Field(False, alias="phoneVerified")
f99_98_login_count: Optional[int] = Field(0, alias="loginCount")
f99_99_last_login: Optional[datetime] = Field(None, alias="lastLogin")
f01_07_gender: Optional[str] = Field(None, alias="gender")
f01_08_birthday: Optional[datetime] = Field(None, alias="birthday")
f01_09_region: Optional[str] = Field(None, alias="region")
f01_10_realname_verified: Optional[bool] = Field(False, alias="realnameVerified")
f99_100_points: Optional[int] = Field(0, alias="points")
f01_11_balance: Optional[float] = Field(0, alias="balance")
f01_12_total_amount: Optional[float] = Field(0, alias="totalAmount")
f01_13_invite_code: Optional[str] = Field(None, alias="inviteCode")
f99_101_invited_count: Optional[int] = Field(0, alias="invitedCount")
f99_90_id: str = Field(..., alias="id")
f01_01_name: str = Field(..., alias="username")
role: str
user_code: Optional[str] = None
f99_92_created_at: Optional[datetime] = Field(None, alias="created_at")
f99_93_updated_at: Optional[datetime] = Field(None, alias="updated_at")
model_config = ConfigDict(from_attributes=True, populate_by_name=True)
# ============ 藏品相关 ============
class CollectionBase(BaseModel):
# f01 基本信息
f01_01_name: str = Field(..., min_length=2, max_length=255, alias="name")
f01_02_code: Optional[str] = Field(None, max_length=50, alias="code")
f01_03_category: str = Field(..., max_length=100, alias="category")
f01_04_status: Optional[str] = Field("in_collection", alias="status")
f01_05_remark: Optional[str] = Field(None, alias="remark")
# f02 详细字段
f02_10_prefix_serial: Optional[str] = Field(None, alias="prefixSerial")
f02_11_version: Optional[str] = Field(None, alias="version")
f02_12_packaging: Optional[str] = Field(None, alias="packaging")
f02_13_rarity: Optional[str] = Field(None, alias="rarity")
f02_14_number_category: Optional[str] = Field(None, alias="numberCategory")
# f03 评级信息
f03_20_is_graded: Optional[bool] = Field(False, alias="isGraded")
f03_21_grading_company: Optional[str] = Field(None, alias="gradingCompany")
f03_22_grading_score: Optional[str] = Field(None, alias="gradingScore")
f03_23_three_star: Optional[bool] = Field(False, alias="threeStar")
# f04 特殊信息
f04_30_special_mark: Optional[str] = Field(None, alias="specialMark")
f04_31_serial_feature: Optional[str] = Field(None, alias="serialFeature")
f04_32_issuer: Optional[str] = Field(None, alias="issuer")
f04_33_issue_year: Optional[str] = Field(None, alias="issueYear")
f04_34_material: Optional[str] = Field(None, alias="material")
f04_35_denomination: Optional[str] = Field(None, alias="denomination")
f04_36_issue_quantity: Optional[str] = Field(None, alias="issueQuantity")
# f05 价格信息
f05_40_cost_price: Optional[float] = Field(None, ge=0, alias="costPrice")
f05_41_target_price: Optional[float] = Field(None, ge=0, alias="targetPrice")
f05_42_goal_price: Optional[float] = Field(None, ge=0, alias="goalPrice")
f05_43_repair_fee: Optional[float] = Field(None, ge=0, alias="repairFee")
f05_44_grading_fee: Optional[float] = Field(None, ge=0, alias="gradingFee")
# f06 其他信息
f06_50_purpose: Optional[str] = Field(None, alias="purpose")
model_config = ConfigDict(from_attributes=True, populate_by_name=True)
class CollectionCreate(CollectionBase):
pass
class CollectionUpdate(BaseModel):
# f01 基本信息
f01_01_name: Optional[str] = Field(None, alias="name")
f01_02_code: Optional[str] = Field(None, alias="code")
f01_03_category: Optional[str] = Field(None, alias="category")
f01_04_status: Optional[str] = Field(None, alias="status")
f01_05_remark: Optional[str] = Field(None, alias="remark")
# f02 详细字段
f02_10_prefix_serial: Optional[str] = Field(None, alias="prefixSerial")
f02_11_version: Optional[str] = Field(None, alias="version")
f02_12_packaging: Optional[str] = Field(None, alias="packaging")
f02_13_rarity: Optional[str] = Field(None, alias="rarity")
f02_14_number_category: Optional[str] = Field(None, alias="numberCategory")
# f03 评级信息
f03_20_is_graded: Optional[bool] = Field(None, alias="isGraded")
f03_21_grading_company: Optional[str] = Field(None, alias="gradingCompany")
f03_22_grading_score: Optional[str] = Field(None, alias="gradingScore")
f03_23_three_star: Optional[bool] = Field(None, alias="threeStar")
# f04 特殊信息
f04_30_special_mark: Optional[str] = Field(None, alias="specialMark")
f04_31_serial_feature: Optional[str] = Field(None, alias="serialFeature")
f04_32_issuer: Optional[str] = Field(None, alias="issuer")
f04_33_issue_year: Optional[str] = Field(None, alias="issueYear")
f04_34_material: Optional[str] = Field(None, alias="material")
f04_35_denomination: Optional[str] = Field(None, alias="denomination")
f04_36_issue_quantity: Optional[str] = Field(None, alias="issueQuantity")
# f05 价格信息
f05_40_cost_price: Optional[float] = Field(None, ge=0, alias="costPrice")
f05_41_target_price: Optional[float] = Field(None, ge=0, alias="targetPrice")
f05_42_goal_price: Optional[float] = Field(None, ge=0, alias="goalPrice")
f05_43_repair_fee: Optional[float] = Field(None, ge=0, alias="repairFee")
f05_44_grading_fee: Optional[float] = Field(None, ge=0, alias="gradingFee")
# f06 其他信息
f06_50_purpose: Optional[str] = Field(None, alias="purpose")
model_config = ConfigDict(from_attributes=True, populate_by_name=True)
class CollectionImageResponse(BaseModel):
f99_90_id: str
filename: str
original_name: Optional[str] = None
path: Optional[str] = None
f99_92_created_at: Optional[datetime] = None
model_config = ConfigDict(from_attributes=True)
class CollectionResponse(CollectionBase):
f99_90_id: str = Field(..., alias="id")
f99_91_user_id: str = Field(..., alias="userId")
f99_92_created_at: Optional[datetime] = Field(None, alias="createdAt")
f99_93_updated_at: Optional[datetime] = Field(None, alias="updatedAt")
images: List[CollectionImageResponse] = []
model_config = ConfigDict(from_attributes=True, populate_by_name=True)
class CollectionListResponse(BaseModel):
data: List[CollectionResponse]
pagination: dict
# ============ 操作日志相关 ============
class OperationBase(BaseModel):
type: str = Field(..., max_length=50)
price: Optional[float] = None
note: Optional[str] = None
class OperationCreate(OperationBase):
f99_91_user_id: str
class OperationResponse(OperationBase):
f99_90_id: str
f99_91_user_id: str
f99_93_created_at: Optional[datetime] = None
model_config = ConfigDict(from_attributes=True)
# ============ OCR 相关 ============
class OCRRequest(BaseModel):
image: str
ocr_provider: Optional[str] = "aliyun"
class OCRResponse(BaseModel):
text: str
confidence: float
fields: Optional[dict] = None
# ============ 通用响应 ============
class Token(BaseModel):
access_token: str
token_type: str = "bearer"
class TokenData(BaseModel):
f99_90_user_id: Optional[str] = None
class MessageResponse(BaseModel):
message: str
class ErrorResponse(BaseModel):
detail: str

126
backend/app/services/oss.py Normal file
View File

@ -0,0 +1,126 @@
# 阿里云OSS服务
import os
import uuid
import datetime
from typing import Optional
import oss2
from PIL import Image
import io
# OSS配置
OSS_CONFIG = {
"access_key_id": os.getenv("OSS_ACCESS_KEY_ID", "LTAI5t6HUnpFBLEK9194kPVG"),
"access_key_secret": os.getenv("OSS_ACCESS_KEY_SECRET", "LEr4Q8yRxb8D5b24cKfCwlt4MMoke1"),
"bucket_name": "jiachenlong-oss",
"endpoint": "oss-cn-hangzhou.aliyuncs.com",
"public_url": "https://jiachenlong-oss.oss-cn-hangzhou.aliyuncs.com"
}
# 图片压缩配置
IMAGE_CONFIG = {
"max_size": 1024 * 1024, # 1MB
"max_width": 2048,
"max_height": 2048,
"quality": 85,
"format": "JPEG"
}
# 初始化OSS
auth = oss2.Auth(OSS_CONFIG["access_key_id"], OSS_CONFIG["access_key_secret"])
bucket = oss2.Bucket(auth, OSS_CONFIG["endpoint"], OSS_CONFIG["bucket_name"])
def get_oss_path(prefix: str, user_id: str = None, filename: str = None) -> str:
"""生成OSS存储路径"""
now = datetime.datetime.now()
year = now.strftime("%Y")
month = now.strftime("%m")
day = now.strftime("%d")
if filename:
ext = filename.split('.')[-1] if '.' in filename else 'jpg'
unique_name = f"{uuid.uuid4().hex}.{ext}"
else:
unique_name = f"{uuid.uuid4().hex}.jpg"
if user_id:
path = f"{prefix}/{user_id}/{year}/{month}/{unique_name}"
else:
path = f"{prefix}/{year}/{month}/{day}/{unique_name}"
return path, unique_name
def upload_to_oss(file_data: bytes, oss_key: str, compress: bool = True) -> str:
"""上传文件到OSS返回公网URL"""
try:
# 如果是图片,进行压缩
if compress and any(oss_key.lower().endswith(ext) for ext in ['.jpg', '.jpeg', '.png', '.webp']):
file_data = compress_image(file_data)
# 上传文件
result = bucket.put_object(oss_key, file_data)
if result.status == 200:
# 返回公网URL
return f"{OSS_CONFIG['public_url']}/{oss_key}"
else:
raise Exception(f"OSS上传失败: {result.status}")
except Exception as e:
raise Exception(f"OSS上传失败: {str(e)}")
def delete_from_oss(oss_key: str) -> bool:
"""从OSS删除文件"""
try:
result = bucket.delete_object(oss_key)
return result.status == 204
except Exception as e:
print(f"OSS删除失败: {str(e)}")
return False
def get_public_url(oss_key: str) -> str:
"""获取公网URL"""
return f"{OSS_CONFIG['public_url']}/{oss_key}"
def compress_image(image_data: bytes, max_size: int = None) -> bytes:
"""压缩图片到指定大小以内"""
if max_size is None:
max_size = IMAGE_CONFIG["max_size"]
# 如果已经小于限制,直接返回
if len(image_data) <= max_size:
return image_data
# 打开图片
img = Image.open(io.BytesIO(image_data))
# 如果是PNG且有透明通道转换为RGB
if img.mode in ('RGBA', 'P'):
img = img.convert('RGB')
# 逐步降低质量直到达到目标大小
quality = 95
compressed_data = image_data
while quality > 30 and len(compressed_data) > max_size:
output = io.BytesIO()
img.save(output, format=IMAGE_CONFIG["format"], quality=quality, optimize=True)
compressed_data = output.getvalue()
quality -= 10
# 如果还是太大,缩小尺寸
if len(compressed_data) > max_size:
width, height = img.size
while len(compressed_data) > max_size and width > 400:
width = int(width * 0.8)
height = int(height * 0.8)
img_resized = img.resize((width, height), Image.Resampling.LANCZOS)
output = io.BytesIO()
img_resized.save(output, format=IMAGE_CONFIG["format"], quality=80, optimize=True)
compressed_data = output.getvalue()
return compressed_data

106
backend/app/services/sms.py Normal file
View File

@ -0,0 +1,106 @@
# 阿里云短信服务
import os
import random
import string
import time
from datetime import datetime, timedelta
from typing import Optional
# 阿里云短信配置
SMS_CONFIG = {
"access_key_id": os.getenv("SMS_ACCESS_KEY_ID", "LTAI5tQAx5niD7JQVqGE5acE"),
"access_key_secret": os.getenv("SMS_ACCESS_KEY_SECRET", "QsQFAEKBkaNynIoKyvdIi3BUyWVZu1"),
"sign_name": os.getenv("SMS_SIGN_NAME", "苏州算力"),
"template_code": os.getenv("SMS_TEMPLATE_CODE", "SMS_501590956"),
}
# 验证码缓存生产环境建议用Redis
# 格式: { phone: { code: "123456", expire: 1234567890 } }
VERIFICATION_CODES = {}
def generate_code(length: int = 6) -> str:
"""生成6位数字验证码"""
return ''.join(random.choices(string.digits, k=length))
def send_verification_code(phone: str) -> dict:
"""发送短信验证码"""
from alibabacloud_dysmsapi20170525 import models
from alibabacloud_dysmsapi20170525.client import Client
from alibabacloud_tea_openapi import models as open_models
try:
# 生成验证码
code = generate_code(6)
# 配置客户端
config = open_models.Config(
access_key_id=SMS_CONFIG["access_key_id"],
access_key_secret=SMS_CONFIG["access_key_secret"],
)
config.endpoint = "dysmsapi.aliyuncs.com"
config.region_id = "cn-hangzhou"
client = Client(config)
# 构造请求
request = models.SendSmsRequest(
phone_numbers=phone,
sign_name=SMS_CONFIG["sign_name"],
template_code=SMS_CONFIG["template_code"],
template_param=f'{{"code":"{code}"}}'
)
# 发送
response = client.send_sms(request)
# 检查结果
if response.body.code == "OK":
# 保存验证码
VERIFICATION_CODES[phone] = {
"code": code,
"expire": int(time.time()) + 300 # 5分钟有效
}
return {
"success": True,
"message": "验证码已发送",
"expire": 300
}
else:
return {
"success": False,
"message": f"发送失败: {response.body.message}"
}
except Exception as e:
return {
"success": False,
"message": f"发送失败: {str(e)}"
}
def verify_code(phone: str, code: str) -> bool:
"""验证验证码"""
if phone not in VERIFICATION_CODES:
return False
stored = VERIFICATION_CODES[phone]
# 检查是否过期
if int(time.time()) > stored["expire"]:
del VERIFICATION_CODES[phone]
return False
# 验证码匹配
if stored["code"] == code:
# 验证成功,删除验证码
del VERIFICATION_CODES[phone]
return True
return False
def check_code_exists(phone: str) -> bool:
"""检查是否已发送过验证码"""
return phone in VERIFICATION_CODES

View File

@ -0,0 +1,132 @@
# 号码分类工具
# 按MEMORY.md最新规则 (2026-04-02)
# 优先级:数字越小越有价值
CATEGORIES = [
# 1. 圆圆号:无.123457只能用0689
{"name": "圆圆号", "cannot_use": ".123457", "must_have": ""},
# 2. 倒置号无23457可用01689必须有1
{"name": "倒置号", "cannot_use": "23457", "must_have": "1"},
# 3. 金马王无12347可用05689必须有5
{"name": "金马王", "cannot_use": "12347", "must_have": "5"},
# 4. 金马号无2347可用015689必须有1和5
{"name": "金马号", "cannot_use": "2347", "must_have": "15"},
# 5. 金山王无12457可用03689必须有3
{"name": "金山王", "cannot_use": "12457", "must_have": "3"},
# 6. 天马王无1247可用035689必须有3和5
{"name": "天马王", "cannot_use": "1247", "must_have": "35"},
# 7. 金山号无2457可用013689必须有1和3
{"name": "金山号", "cannot_use": "2457", "must_have": "13"},
# 8. 天马号无247可用0135689必须有1、3和5
{"name": "天马号", "cannot_use": "247", "must_have": "135"},
# 9. 朦胧王无13457
{"name": "朦胧王", "cannot_use": "13457", "must_have": ""},
# 10. 朦胧号无3457
{"name": "朦胧号", "cannot_use": "3457", "must_have": ""},
# 11. 如意号无1347
{"name": "如意号", "cannot_use": "1347", "must_have": ""},
# 12. 钻石号无347
{"name": "钻石号", "cannot_use": "347", "must_have": ""},
# 13. 永恒号无47
{"name": "永恒号", "cannot_use": "47", "must_have": ""},
# 14. 无4号不包含4
{"name": "无4号", "cannot_use": "4", "must_have": ""},
# 15. 通货含4
{"name": "通货", "cannot_use": "", "must_have": "4"},
]
def extract_digits(serial: str) -> dict:
"""提取冠字号中的数字部分"""
if not serial:
return {"digits": "", "type": "single"}
nums = serial.replace("J", "").replace(",", "").replace(".", "").strip()
nums = "".join(c for c in nums if c.isdigit())
if nums.endswith("01"):
return {"digits": nums[:-2], "type": "hundred"}
elif nums.endswith("1"):
return {"digits": nums[:-1], "type": "ten"}
else:
return {"digits": nums, "type": "single"}
def matches_category(digits: str, category: dict) -> bool:
cannot_use = category.get("cannot_use", "")
must_have = category.get("must_have", "")
# 检查不能用的数字
for n in cannot_use:
if n in digits:
return False
# 检查必须有的数字
if must_have:
for n in must_have:
if n not in digits:
return False
return True
def get_number_category(serial: str) -> str:
"""号码分类函数"""
if not serial:
return ""
# 提取数字
info = extract_digits(serial)
digits = info["digits"]
if not digits:
return ""
# 根据类型取对应位数
digits_type = info["type"]
if digits_type == "hundred":
# 标百看后6位
check_digits = digits[-6:] if len(digits) >= 6 else digits
elif digits_type == "ten":
# 标十看后7位
check_digits = digits[-7:] if len(digits) >= 7 else digits
else:
# 散钞看全部
check_digits = digits
# 按优先级匹配分类
for category in CATEGORIES:
if matches_category(check_digits, category):
return category["name"]
return "通货"
def get_number_category_color(category: str) -> str:
"""获取分类颜色"""
colors = {
"圆圆号": "#ef4444", # 红
"倒置号": "#f97316", # 橙
"金马王": "#eab308", # 黄
"金马号": "#84cc16", # 绿
"金山王": "#22c55e", # 深绿
"天马王": "#14b8a6", # 青
"金山号": "#06b6d4", # 蓝
"天马号": "#0ea5e9", # 浅蓝
"朦胧王": "#6366f1", # 靛蓝
"朦胧号": "#8b5cf6", # 紫
"如意号": "#a855f7", # 深紫
"钻石号": "#d946ef", # 品红
"永恒号": "#ec4899", # 粉红
"无4号": "#64748b", # 灰
"通货": "#9ca3af", # 浅灰
}
return colors.get(category, "#9ca3af")
def get_category_priority(category: str) -> int:
"""获取分类优先级(数字越小越高级)"""
for i, cat in enumerate(CATEGORIES, 1):
if cat["name"] == category:
return i
return 999

47
backend/logs/app.log Normal file

File diff suppressed because one or more lines are too long

13
backend/requirements.txt Normal file
View File

@ -0,0 +1,13 @@
# 甲辰藏品管理系统后端 - Python 依赖
# 版本v1.0.0
fastapi==0.109.0
uvicorn[standard]==0.27.0
sqlalchemy==2.0.25
psycopg2-binary==2.9.9
pydantic==2.5.3
python-jose[cryptography]==3.3.0
bcrypt==4.1.2
python-multipart==0.0.6
pillow==10.2.0
dashscope==1.14.1

0
backend/uploads/.gitkeep Normal file
View File

47
frontend/README.md Normal file
View File

@ -0,0 +1,47 @@
# 前端 - React + Vite
## 启动方式
### 开发环境
```bash
# 安装依赖
npm install
# 开发模式(热重载)
npm run dev
# 访问 http://localhost:5173
```
### 生产构建
```bash
# 构建
npm run build
# 部署 dist/ 目录到服务器
```
## 目录结构
```
frontend/
├── src/
│ ├── pages/ # 页面组件
│ ├── utils/ # 工具函数
│ └── config/ # 配置文件
├── public/ # 静态资源
└── dist/ # 构建产物
```
## 页面列表
- `/` - 首页
- `/login` - 登录
- `/stats` - 统计
- `/list` - 藏品列表
- `/add` - 添加藏品
- `/detail` - 藏品详情
- `/edit` - 编辑藏品
- `/admin` - 用户管理(仅管理员)

1
frontend/VERSION Normal file
View File

@ -0,0 +1 @@
VERSION=1.2.97

31
frontend/index.html Normal file
View File

@ -0,0 +1,31 @@
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
<meta name="apple-mobile-web-app-capable" content="yes">
<title>甲辰收藏 v=1.2.97</title>
<!-- Favicon -->
<link rel="icon" type="image/png" href="/static/icons/favicon.png" />
<link rel="apple-touch-icon" href="/static/icons/apple-touch-icon.png" />
<style>
* { margin: 0; padding: 0; box-sizing: border-box; }
html, body, #root {
min-height: 100%;
width: 100%;
overflow-y: auto;
}
body {
font-family: -apple-system, BlinkMacSystemFont, 'PingFang SC', sans-serif;
background: #0f172a;
color: #fff;
-webkit-overflow-scrolling: touch;
}
</style>
</head>
<body>
<div id="root"></div>
<script type="module" src="/src/main.jsx"></script>
</body>
</html>

2132
frontend/package-lock.json generated Normal file

File diff suppressed because it is too large Load Diff

21
frontend/package.json Normal file
View File

@ -0,0 +1,21 @@
{
"name": "jiachenlong-frontend",
"version": "1.2.82",
"private": true,
"description": "甲辰藏品管理系统 - 移动端前端",
"scripts": {
"dev": "vite",
"build": "vite build",
"preview": "vite preview"
},
"dependencies": {
"axios": "^1.7.9",
"react": "^18.3.1",
"react-dom": "^18.3.1",
"react-router-dom": "^7.1.0"
},
"devDependencies": {
"@vitejs/plugin-react": "^4.3.4",
"vite": "^6.4.2"
}
}

1
frontend/package.txt Normal file
View File

@ -0,0 +1 @@
v=1.2.80

20
frontend/postbuild.js Normal file
View File

@ -0,0 +1,20 @@
const fs = require('fs');
const path = require('path');
const src = path.join(__dirname, 'static', 'images');
const dst = path.join(__dirname, 'dist', 'static', 'images');
if (!fs.existsSync(dst)) {
fs.mkdirSync(dst, { recursive: true });
}
if (fs.existsSync(src)) {
fs.readdirSync(src).forEach(f => {
const srcFile = path.join(src, f);
const dstFile = path.join(dst, f);
fs.copyFileSync(srcFile, dstFile);
console.log('Copied:', f);
});
}
console.log('Logo复制完成');

Binary file not shown.

After

Width:  |  Height:  |  Size: 133 KiB

View File

@ -0,0 +1,26 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 400 80">
<defs>
<linearGradient id="goldGrad" x1="0%" y1="0%" x2="100%" y2="100%">
<stop offset="0%" stop-color="#FFE4B5"/>
<stop offset="25%" stop-color="#FFD700"/>
<stop offset="50%" stop-color="#FFA500"/>
<stop offset="75%" stop-color="#DAA520"/>
<stop offset="100%" stop-color="#B8860B"/>
</linearGradient>
<filter id="glow">
<feGaussianBlur stdDeviation="1.5" result="blur"/>
<feFlood flood-color="#FFD700" flood-opacity="0.6"/>
<feComposite in2="blur" operator="in"/>
<feMerge><feMergeNode/><feMergeNode in="SourceGraphic"/></feMerge>
</filter>
<filter id="shadow">
<feDropShadow dx="2" dy="3" stdDeviation="2" flood-color="#000" flood-opacity="0.5"/>
</filter>
</defs>
<!-- Main title -->
<text x="0" y="45" font-family="'Kaiti SC', 'STKaiti', 'KaiTi', 'SimKai', serif" font-size="52" font-weight="bold" fill="url(#goldGrad)" filter="url(#shadow)">甲辰收藏</text>
<!-- Subtitle -->
<text x="0" y="72" font-family="'Kaiti SC', 'STKaiti', 'KaiTi', 'SimKai', serif" font-size="20" fill="#DAA520" letter-spacing="4">生肖纪念钞管理系统</text>
</svg>

After

Width:  |  Height:  |  Size: 1.2 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 133 KiB

View File

Binary file not shown.

After

Width:  |  Height:  |  Size: 133 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 133 KiB

View File

@ -0,0 +1,115 @@
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
<title>用户协议 - 甲辰收藏</title>
<style>
body { font-family: -apple-system, BlinkMacSystemFont, 'PingFang SC', 'Helvetica Neue', sans-serif; padding: 20px; max-width: 800px; margin: 0 auto; line-height: 1.8; background: #f5f5f5; }
h1 { text-align: center; color: #1a1a1a; font-size: 24px; margin-bottom: 30px; }
h2 { color: #333; font-size: 18px; margin-top: 30px; margin-bottom: 15px; border-bottom: 1px solid #eee; padding-bottom: 8px; }
h3 { color: #555; font-size: 15px; margin-top: 20px; margin-bottom: 10px; }
.content { color: #444; font-size: 14px; background: #fff; padding: 20px; border-radius: 8px; box-shadow: 0 2px 8px rgba(0,0,0,0.05); }
.content p { margin: 10px 0; }
.highlight { font-weight: bold; }
.version { text-align: center; color: #999; font-size: 12px; margin-bottom: 20px; }
ul { padding-left: 20px; }
li { margin: 5px 0; }
</style>
</head>
<body>
<div class="content">
<h1>甲辰收藏平台用户协议</h1>
<div class="version">版本生效日期:自注册之日起</div>
<p><span class="highlight">特别提示:</span>本协议涉及您的重大权利义务,加粗条款请您重点阅读。您完成注册、登录或继续使用本平台服务,即视为已充分阅读、理解并同意本协议全部内容。本协议适用《中华人民共和国民法典》《网络安全法》《个人信息保护法》《电子商务法》等法律法规。</p>
<h2>一、协议主体与适用范围</h2>
<ol>
<li>本协议由您与甲辰收藏平台运营主体(以下简称"平台")签订,约束您使用平台藏品管理,信息展示,数据存储,社区互动等全部服务。</li>
<li>平台发布的隐私政策、藏品发布规则、交易规范等均为本协议组成部分,与本协议具有同等法律效力。</li>
<li>您承诺为具备完全民事行为能力的自然人/法人;未成年人使用需监护人同意并陪同。</li>
</ol>
<h2>二、个人信息收集与使用</h2>
<h3>(一)收集原则</h3>
<p>平台遵循合法、正当、必要、诚信、最小必要原则收集信息,仅为实现服务功能所必需,不强制收集非必要信息。</p>
<h3>(二)收集范围与目的</h3>
<ol>
<li><strong>注册与身份信息:</strong>用户名、手机号、邮箱(用于账号创建,安全验证、客服联系)。</li>
<li><strong>藏品与行为信息:</strong>藏品上传内容、收藏记录、浏览操作、发布评论、交易数据(用于藏品管理,服务优化、风控核验)。</li>
<li><strong>设备与网络信息:</strong>设备型号、系统版本、IP 地址、日志信息(用于安全防护、故障排查,防作弊)。</li>
<li><strong>位置信息:</strong>仅在您主动开启定位权限时收集,用于同城展示等可选功能,关闭不影响基础服务。</li>
</ol>
<h3>(三)信息使用规则</h3>
<ol>
<li>平台仅在您授权范围内使用信息,不超出约定目的、范围与期限处理。</li>
<li>向第三方共享信息时,将单独告知并取得您明确同意,法律法规要求除外。</li>
<li>您有权查阅、更正、删除个人信息,申请注销账号,平台在核验身份后依法处理。</li>
<li>平台采取加密、去标识化、权限管控等措施保护信息安全,制定安全事件应急预案。</li>
</ol>
<h2>三、公开信息使用与免责条款</h2>
<ol>
<li><strong>公开信息定义:</strong>您通过平台主动发布、设置为公开可见的藏品资料、图文、评论、动态等内容,均属于您自行公开的信息。</li>
<li><strong>授权使用:</strong>您同意平台可在合理范围内使用您的公开信息,用于藏品展示、平台运营、合规审核、服务推广等,不侵犯您合法权益。</li>
<li><strong>法定免责依据:</strong>根据《个人信息保护法》第二十七条,平台处理您自行合法公开的信息,在无明确拒绝且不对您权益造成重大影响的情形下,无需另行取得单独同意。</li>
<li><strong>第三方行为免责:</strong>
<ul>
<li>公开信息可被其他用户浏览、复制、存储、转发,平台无法完全控制第三方使用行为。</li>
<li>因第三方擅自使用、转载、篡改您公开信息引发的纠纷、损失,平台不承担责任。</li>
</ul>
</li>
<li><strong>内容责任自负:</strong>
<ul>
<li>您对公开信息的真实性、合法性、原创性承担全部责任,不得侵犯第三方知识产权、肖像权、名誉权等。</li>
<li>如因您发布违法、侵权内容导致平台受损,您应承担全部赔偿责任。</li>
</ul>
</li>
<li><strong>平台管理边界:</strong>平台仅依据法律法规与平台规则进行内容审核,对用户自主发布的公开信息不做修改、篡改,不承担真实性担保责任。</li>
</ol>
<h2>四、用户权利与义务</h2>
<ol>
<li>您有权使用平台基础服务,对账号与密码安全负责,不得转借、出售账号。</li>
<li>不得发布违法违规、侵权、虚假、低俗等违反法律法规与公序良俗的内容。</li>
<li>不得利用平台从事洗钱、诈骗、非法交易等违法活动。</li>
<li>您对自行上传的藏品素材、文字等享有知识产权,授权平台在服务范围内非独占使用。</li>
</ol>
<h2>五、知识产权条款</h2>
<ol>
<li>平台所有文字、图标、界面设计、软件代码等知识产权归平台所有,受法律保护。</li>
<li>您上传的原创内容知识产权归您所有;您授权平台为提供服务之目的,使用、存储、展示、传播该内容。</li>
<li>未经权利人书面许可,任何主体不得复制、改编、传播、商用平台内容或用户原创内容。</li>
</ol>
<h2>六、服务变更、中断与终止</h2>
<ol>
<li>平台因维护、升级、政策调整需变更或暂停服务的,将提前公示;因不可抗力、监管要求、第三方故障导致服务中断的,平台不承担违约责任。</li>
<li>平台有权对违规账号采取警示、限流、删帖、封禁等处理措施。</li>
<li>您可随时停止使用服务;账号注销后,平台按法律法规留存相关数据,逾期依法删除。</li>
</ol>
<h2>七、免责声明(法律允许范围内)</h2>
<ol>
<li>平台按"现状"提供服务,对服务及时性、安全性、稳定性不作绝对担保。</li>
<li>平台不对藏品真伪、价值、权属作明示或暗示保证,藏品鉴定与价值判断由您自行负责。</li>
<li>法律允许的最大范围内,平台不对间接损失、利润损失、数据丢失等承担赔偿责任;因平台故意或重大过失导致的损失除外。</li>
<li>因您自身操作不当、账号保管不善、第三方侵权等导致的损失,由您自行承担。</li>
</ol>
<h2>八、协议修改与争议解决</h2>
<ol>
<li>平台修改协议将提前7日公示您继续使用视为接受修订如不同意可停止使用并注销账号。</li>
<li>因本协议产生争议,双方协商解决;协商不成,提交平台运营主体所在地有管辖权的人民法院诉讼解决。</li>
<li>本协议适用中华人民共和国大陆地区法律(不含港澳台法律)。</li>
</ol>
<h2>九、联系与通知</h2>
<p>平台联系方式aicoolbot@163.com您可通过客服渠道咨询协议、隐私、投诉等相关事宜。</p>
</div>
</body>
</html>

115
frontend/src/App.jsx Normal file
View File

@ -0,0 +1,115 @@
import React, { useState, useEffect } from 'react'
import Home from './pages/Home'
import Settings from './pages/Settings'
import List from './pages/List'
import Add from './pages/Add'
import Stats from './pages/Stats'
import News from './pages/News'
import Login from './pages/Login'
import Detail from './pages/Detail'
import Edit from './pages/Edit'
import Admin from './pages/Admin'
export default function App() {
const [path, setPath] = useState(window.location.hash.slice(1) || '/')
useEffect(() => {
const handleHashChange = () => {
setPath(window.location.hash.slice(1) || '/')
}
window.addEventListener('hashchange', handleHashChange)
return () => window.removeEventListener('hashchange', handleHashChange)
}, [])
const handleNavigate = (newPath) => {
window.location.hash = '#' + newPath
setPath(newPath)
}
const getComponent = () => {
const basePath = path.split('?')[0]
if (basePath === '/') return <Home />
if (basePath === '/news') return <News />
if (basePath === '/stats') return <Stats />
if (basePath === '/list') return <List />
if (basePath === '/add') return <Add />
if (basePath === '/login') return <Login />
if (basePath === '/settings') return <Settings />
if (basePath === '/admin') return <Admin />
if (basePath.startsWith('/edit')) return <Edit />
if (basePath.startsWith('/detail')) return <Detail />
return <Home />
}
const token = localStorage.getItem('token')
const userStr = localStorage.getItem('user')
let user = null
try {
user = userStr ? JSON.parse(userStr) : null
} catch (e) {
console.error('Parse user error:', e)
}
const isAdmin = user && user.role === 'admin'
const isEditor = user && user.role === 'editor'
//
if (!token) {
//
if (path !== '/login') {
window.location.hash = '#/login'
}
return <Login />
}
//
if (path === '/login') {
// 使 href
window.location.href = window.location.origin + window.location.pathname + '#/'
return null
}
return (
<div style={{ minHeight: '100vh', background: '#0f172a' }}>
{getComponent()}
<div style={{
position: 'fixed',
bottom: 0,
left: 0,
right: 0,
height: '60px',
background: 'rgba(15, 23, 42, 0.98)',
display: 'flex',
borderTop: '1px solid rgba(255,255,255,0.1)',
zIndex: 1000
}}>
{[
{ path: '/', icon: '🏠', label: '首页' },
{ path: '/news', icon: '📰', label: '行情' },
{ path: '/stats', icon: '📊', label: '统计' },
{ path: '/list', icon: '📚', label: '我的' },
{ path: '/add', icon: '🎯', label: '录入' },
...(isAdmin ? [{ path: '/admin', icon: '⚙️', label: '管理' }] : [])
].map(tab => (
<div
key={tab.path}
onClick={() => handleNavigate(tab.path)}
style={{
flex: 1,
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
justifyContent: 'center',
color: path === tab.path ? '#fbbf24' : '#94a3b8',
cursor: 'pointer'
}}
>
<div style={{ fontSize: '22px' }}>{tab.icon}</div>
<div style={{ fontSize: '11px', marginTop: '2px' }}>{tab.label}</div>
</div>
))}
</div>
</div>
)
}
// Fri Apr 10 03:44:24 PM CST 2026

View File

@ -0,0 +1 @@
VERSION=1.2.100

1
frontend/src/index.css Normal file
View File

@ -0,0 +1 @@
/* 全局样式 */

23
frontend/src/main.jsx Normal file
View File

@ -0,0 +1,23 @@
import React from 'react'
import ReactDOM from 'react-dom/client'
import { HashRouter } from 'react-router-dom'
import App from './App'
import './index.css'
//
const root = document.getElementById('root')
try {
ReactDOM.createRoot(root).render(
<React.StrictMode>
<HashRouter>
<App />
</HashRouter>
</React.StrictMode>
)
console.log('App rendered successfully')
} catch (e) {
console.error('Render error:', e)
root.innerHTML = '<div style="color:red;padding:20px;background:#fff;">Error: ' + e.message + '</div>'
}
// v2.7.2 build
// Force rebuild v2.7.2 - 1773392274

1083
frontend/src/pages/Add.jsx Normal file

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,590 @@
import React, { useState, useEffect } from 'react'
import { APP_VERSION } from '../config/version'
export default function Admin() {
const [users, setUsers] = useState([])
const [loading, setLoading] = useState(true)
const [error, setError] = useState('')
const [showAddModal, setShowAddModal] = useState(false)
const [editingUser, setEditingUser] = useState(null)
const [newUser, setNewUser] = useState({ username: '', password: '', email: '', role: 'user' })
const token = localStorage.getItem('token')
//
const userStr = localStorage.getItem('user')
let user = null
try {
user = userStr ? JSON.parse(userStr) : null
} catch (e) {}
if (!user || user.role !== 'admin') {
return (
<div style={{ minHeight: '100vh', display: 'flex', alignItems: 'center', justifyContent: 'center', background: '#0f172a', color: '#ef4444', padding: '20px' }}>
<div style={{ textAlign: 'center' }}>
<div style={{ fontSize: '48px', marginBottom: '16px' }}>🚫</div>
<div style={{ fontSize: '18px', fontWeight: 'bold', marginBottom: '8px' }}>无权访问</div>
<div style={{ color: '#94a3b8', fontSize: '14px' }}>仅管理员可以访问用户管理界面</div>
</div>
</div>
)
}
useEffect(() => {
fetchUsers()
}, [])
const fetchUsers = async () => {
try {
const res = await fetch('/api/admin/users?page=1&limit=100', {
headers: { 'Authorization': `Bearer ${token}` }
})
if (!res.ok) throw new Error('获取用户列表失败')
const data = await res.json()
setUsers(data)
} catch (err) {
setError(err.message)
} finally {
setLoading(false)
}
}
const handleDeleteUser = async (userId, username) => {
if (!confirm(`确定要删除用户 "${username}" 吗?`)) return
try {
const res = await fetch(`/api/admin/users/${userId}`, {
method: 'DELETE',
headers: { 'Authorization': `Bearer ${token}` }
})
if (!res.ok) throw new Error('删除失败')
fetchUsers()
} catch (err) {
alert(err.message)
}
}
const handleAddUser = async () => {
if (!newUser.username || !newUser.password) {
alert('用户名和密码为必填项')
return
}
// email
const payload = { ...newUser }
if (!payload.email) {
delete payload.email
}
try {
const res = await fetch('/api/auth/register', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
},
body: JSON.stringify(payload)
})
if (!res.ok) {
const data = await res.json()
throw new Error(data.detail || '添加失败')
}
alert('添加成功!')
setShowAddModal(false)
setNewUser({ username: '', password: '', email: '', role: 'user' })
fetchUsers()
} catch (err) {
alert(err.message)
}
}
const handleEditUser = async () => {
if (!editingUser.username) {
alert('用户名不能为空')
return
}
//
if (editingUser.newPassword || editingUser.confirmPassword) {
if (!editingUser.newPassword || !editingUser.confirmPassword) {
alert('请填写完整密码信息')
return
}
if (editingUser.newPassword !== editingUser.confirmPassword) {
alert('两次输入的密码不一致')
return
}
if (editingUser.newPassword.length < 6) {
alert('密码至少 6 个字符')
return
}
}
try {
//
const updateData = {
username: editingUser.username,
email: editingUser.email,
phone: editingUser.phone,
phoneVerified: editingUser.phoneVerified,
role: editingUser.role,
user_code: editingUser.user_code,
level: editingUser.level,
loginCount: editingUser.loginCount,
aiCount: editingUser.aiCount,
searchCount: editingUser.searchCount,
points: editingUser.points,
balance: editingUser.balance,
totalAmount: editingUser.totalAmount,
phoneVerified: editingUser.phoneVerified
}
//
if (editingUser.newPassword && editingUser.newPassword.trim()) {
updateData.password = editingUser.newPassword
}
const res = await fetch(`/api/admin/users/${editingUser.id}`, {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${token}`
},
body: JSON.stringify(updateData)
})
if (!res.ok) {
const data = await res.json()
throw new Error(data.detail || '更新失败')
}
alert('更新成功!')
setEditingUser(null)
fetchUsers()
} catch (err) {
alert(err.message)
}
}
if (loading) return <div style={{ padding: '20px', color: '#fff' }}>加载中...</div>
if (error) return <div style={{ padding: '20px', color: '#ef4444' }}> {error}</div>
return (
<div style={{ minHeight: '100vh', overflowY: 'auto', background: '#0f172a', padding: '20px', paddingBottom: '80px' }}>
<div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '20px' }}>
<h1 style={{ color: '#fbbf24', fontSize: '24px', fontWeight: '700' }}>
用户管理
</h1>
<button
onClick={() => setShowAddModal(true)}
style={{
padding: '10px 20px',
background: '#fbbf24',
color: '#1e293b',
border: 'none',
borderRadius: '8px',
fontSize: '14px',
fontWeight: '600',
cursor: 'pointer'
}}
>
添加用户
</button>
</div>
{/* 用户列表 - 卡片式布局 */}
<div style={{ display: 'flex', flexDirection: 'column', gap: '12px' }}>
{users.map((user) => (
<div key={user.id} style={{ background: 'rgba(30, 41, 59, 0.8)', borderRadius: '12px', padding: '16px' }}>
<div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'flex-start' }}>
<div style={{ flex: 1 }}>
<div style={{ display: 'flex', alignItems: 'center', gap: '8px', flexWrap: 'wrap' }}>
<div style={{ color: '#fbbf24', fontSize: '16px', fontWeight: 'bold' }}>{user.username}</div>
<div style={{
padding: '2px 8px', borderRadius: '4px',
background: user.role === 'admin' ? 'rgba(16, 185, 129, 0.2)' : (user.role === 'editor' ? 'rgba(245, 158, 11, 0.2)' : 'rgba(148, 163, 184, 0.2)'),
color: user.role === 'admin' ? '#10b981' : (user.role === 'editor' ? '#f59e0b' : '#94a3b8'),
fontSize: '12px'
}}>
{user.role === 'admin' ? '👑 管理员' : (user.role === 'editor' ? '📝 信息员' : '👤 用户')}
</div>
<div style={{ background: 'rgba(59, 130, 246, 0.2)', padding: '2px 8px', borderRadius: '4px', color: '#60a5fa', fontSize: '12px' }}>
编码: {user.user_code || '-'}
</div>
<div style={{ background: 'rgba(168, 85, 247, 0.2)', padding: '2px 8px', borderRadius: '4px', color: '#a855f7', fontSize: '12px' }}>
等级: {user.level || '青铜'}
</div>
</div>
<div style={{ color: '#64748b', fontSize: '13px', marginTop: '8px' }}>
📧 {user.email || '未设置'} | 📱 {user.phone || '未设置'} | 📱已认证: {user.phoneVerified ? '✓' : '✗'}
</div>
</div>
<div style={{ textAlign: 'right' }}>
<div style={{ color: '#94a3b8', fontSize: '12px' }}>藏品数</div>
<div style={{ color: '#60a5fa', fontSize: '20px', fontWeight: 'bold', cursor: 'pointer' }} onClick={() => window.location.hash = '#/list?userId=' + user.id} title='点击查看'>{user.collectionCount || 0}</div>
</div>
</div>
{/* 更多字段 */}
<div style={{ display: 'flex', flexWrap: 'wrap', gap: '8px', marginTop: '12px', paddingTop: '12px', borderTop: '1px solid rgba(255,255,255,0.1)' }}>
<div style={{ background: 'rgba(16, 185, 129, 0.1)', padding: '4px 10px', borderRadius: '6px', fontSize: '12px', color: '#10b981' }}>
🔑 登录: {user.loginCount || 0}
</div>
<div style={{ background: 'rgba(59, 130, 246, 0.1)', padding: '4px 10px', borderRadius: '6px', fontSize: '12px', color: '#3b82f6' }}>
🤖 AI识别: {user.aiCount || 0}
</div>
<div style={{ background: 'rgba(20, 184, 166, 0.1)', padding: '4px 10px', borderRadius: '6px', fontSize: '12px', color: '#14b8a6' }}>
🎯 配号: {user.searchCount || 0}
</div>
<div style={{ background: 'rgba(245, 158, 11, 0.1)', padding: '4px 10px', borderRadius: '6px', fontSize: '12px', color: '#f59e0b' }}>
🔍 寻号: {user.searchCount || 0}
</div>
<div style={{ background: 'rgba(168, 85, 247, 0.1)', padding: '4px 10px', borderRadius: '6px', fontSize: '12px', color: '#a855f7' }}>
💎 积分: {user.points || 0}
</div>
<div style={{ background: 'rgba(236, 72, 153, 0.1)', padding: '4px 10px', borderRadius: '6px', fontSize: '12px', color: '#ec4899' }}>
💰 余额: {user.balance || 0}
</div>
<div style={{ background: 'rgba(34, 197, 94, 0.1)', padding: '4px 10px', borderRadius: '6px', fontSize: '12px', color: '#22c55e' }}>
📊 累计: {user.totalAmount || 0}
</div>
</div>
<div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginTop: '12px', paddingTop: '12px', borderTop: '1px solid rgba(255,255,255,0.1)' }}>
<div style={{ color: '#64748b', fontSize: '12px' }}>
注册时间{user.created_at ? new Date(user.created_at).toLocaleDateString('zh-CN') : '-'}
</div>
<div style={{ display: 'flex', gap: '8px' }}>
<button
onClick={() => setEditingUser({ ...user, email: user.email || '', phone: user.phone || '', phoneVerified: user.phoneVerified !== false, newPassword: '', confirmPassword: '' })}
style={{
padding: '6px 12px',
borderRadius: '6px',
border: 'none',
background: 'rgba(59, 130, 246, 0.2)',
color: '#3b82f6',
cursor: 'pointer',
fontSize: '12px'
}}
>
编辑
</button>
{user.role !== 'admin' && (
<button
onClick={() => handleDeleteUser(user.id, user.username)}
style={{
padding: '6px 12px',
borderRadius: '6px',
border: 'none',
background: 'rgba(239, 68, 68, 0.2)',
color: '#ef4444',
cursor: 'pointer',
fontSize: '12px'
}}
>
🗑 删除
</button>
)}
</div>
</div>
</div>
))}
</div>
{users.length === 0 && (
<div style={{ padding: '40px', textAlign: 'center', color: '#94a3b8' }}>
暂无用户数据
</div>
)}
{/* 添加用户模态框 */}
{showAddModal && (
<div style={{ position: 'fixed', top: 0, left: 0, right: 0, bottom: 0, background: 'rgba(0,0,0,0.8)', display: 'flex', alignItems: 'center', justifyContent: 'center', zIndex: 1000 }}>
<div style={{ background: '#1e293b', borderRadius: '12px', padding: '24px', width: '90%', maxWidth: '400px' }}>
<h2 style={{ color: '#fff', fontSize: '18px', fontWeight: 'bold', marginBottom: '20px' }}>添加用户</h2>
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '13px', marginBottom: '6px' }}>用户名 *</label>
<input
type="text"
value={newUser.username}
onChange={(e) => setNewUser({ ...newUser, username: e.target.value })}
style={{ width: '100%', padding: '10px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '8px', color: '#fff' }}
/>
</div>
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '13px', marginBottom: '6px' }}>密码 *</label>
<input
type="password"
value={newUser.password}
onChange={(e) => setNewUser({ ...newUser, password: e.target.value })}
style={{ width: '100%', padding: '10px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '8px', color: '#fff' }}
/>
</div>
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '13px', marginBottom: '6px' }}>邮箱</label>
<input
type="email"
value={newUser.email}
onChange={(e) => setNewUser({ ...newUser, email: e.target.value })}
style={{ width: '100%', padding: '10px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '8px', color: '#fff' }}
/>
</div>
<div style={{ marginBottom: '20px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '13px', marginBottom: '6px' }}>角色</label>
<select
value={newUser.role}
onChange={(e) => setNewUser({ ...newUser, role: e.target.value })}
style={{ width: '100%', padding: '10px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '8px', color: '#fff' }}
>
<option value="user">普通用户</option>
<option value="admin">管理员</option>
<option value="editor">信息员</option>
</select>
</div>
<div style={{ display: 'flex', gap: '12px' }}>
<button
onClick={() => setShowAddModal(false)}
style={{ flex: 1, padding: '12px', background: 'rgba(255,255,255,0.1)', color: '#fff', border: 'none', borderRadius: '8px', cursor: 'pointer' }}
>
取消
</button>
<button
onClick={handleAddUser}
style={{ flex: 1, padding: '12px', background: '#fbbf24', color: '#1e293b', border: 'none', borderRadius: '8px', fontWeight: '600', cursor: 'pointer' }}
>
确定
</button>
</div>
</div>
</div>
)}
{/* 编辑用户模态框 */}
{editingUser && (
<div style={{ position: 'fixed', top: 0, left: 0, right: 0, bottom: 0, background: 'rgba(0,0,0,0.8)', display: 'flex', alignItems: 'center', justifyContent: 'center', zIndex: 1000 }}>
<div style={{ background: '#1e293b', borderRadius: '12px', padding: '24px', width: '90%', maxWidth: '500px', maxHeight: '90vh', overflowY: 'auto' }}>
<h2 style={{ color: '#fff', fontSize: '18px', fontWeight: 'bold', marginBottom: '20px' }}>编辑用户</h2>
{/* 第一部分:基本信息 */}
<div style={{ marginBottom: '24px' }}>
<h3 style={{ color: '#fbbf24', fontSize: '15px', fontWeight: 'bold', marginBottom: '16px', paddingBottom: '8px', borderBottom: '1px solid rgba(251, 191, 36, 0.3)' }}>📋 基本信息</h3>
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '13px', marginBottom: '6px' }}>用户名</label>
<input
type="text"
value={editingUser.username}
onChange={(e) => setEditingUser({ ...editingUser, username: e.target.value })}
style={{ width: '100%', padding: '10px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '8px', color: '#fff' }}
/>
</div>
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '13px', marginBottom: '6px' }}>邮箱</label>
<input
type="email"
value={editingUser.email || ''}
onChange={(e) => setEditingUser({ ...editingUser, email: e.target.value })}
style={{ width: '100%', padding: '10px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '8px', color: '#fff' }}
/>
</div>
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '13px', marginBottom: '6px' }}>手机号</label>
<input
type="text"
value={editingUser.phone || ''}
onChange={(e) => setEditingUser({ ...editingUser, phone: e.target.value })}
style={{ width: '100%', padding: '10px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '8px', color: '#fff' }}
/>
</div>
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'flex', alignItems: 'center', color: '#94a3b8', fontSize: '13px', marginBottom: '6px', cursor: 'pointer' }}>
<input
type="checkbox"
checked={editingUser.phoneVerified === true}
onChange={(e) => setEditingUser({ ...editingUser, phoneVerified: e.target.checked })}
style={{ marginRight: '8px' }}
/>
手机号已验证
</label>
</div>
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '13px', marginBottom: '6px' }}>角色</label>
<select
value={editingUser.role}
onChange={(e) => setEditingUser({ ...editingUser, role: e.target.value })}
style={{ width: '100%', padding: '10px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '8px', color: '#fff' }}
>
<option value="user">普通用户</option>
<option value="admin">管理员</option>
<option value="editor">信息员</option>
</select>
</div>
</div>
{/* 第二部分:修改密码 */}
<div style={{ marginBottom: '24px' }}>
<h3 style={{ color: '#fbbf24', fontSize: '15px', fontWeight: 'bold', marginBottom: '16px', paddingBottom: '8px', borderBottom: '1px solid rgba(251, 191, 36, 0.3)' }}>🔐 修改密码可选</h3>
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '13px', marginBottom: '6px' }}>新密码 <span style={{ color: '#64748b', fontSize: '12px' }}>留空则不修改</span></label>
<input
type="password"
value={editingUser.newPassword || ''}
onChange={(e) => setEditingUser({ ...editingUser, newPassword: e.target.value })}
placeholder="请输入新密码(至少 6 位)"
style={{ width: '100%', padding: '10px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '8px', color: '#fff' }}
/>
</div>
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '13px', marginBottom: '6px' }}>确认新密码</label>
<input
type="password"
value={editingUser.confirmPassword || ''}
onChange={(e) => setEditingUser({ ...editingUser, confirmPassword: e.target.value })}
placeholder="请再次输入新密码"
style={{ width: '100%', padding: '10px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '8px', color: '#fff' }}
/>
</div>
</div>
{/* 第三部分:扩展信息 */}
<div style={{ marginBottom: '24px' }}>
<h3 style={{ color: '#a855f7', fontSize: '15px', fontWeight: 'bold', marginBottom: '16px', paddingBottom: '8px', borderBottom: '1px solid rgba(168, 85, 247, 0.3)' }}>📊 扩展信息</h3>
<div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '12px' }}>
<div style={{ marginBottom: '12px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '12px', marginBottom: '4px' }}>用户编码</label>
<input
type="text"
value={editingUser.user_code || ''}
onChange={(e) => setEditingUser({ ...editingUser, user_code: e.target.value })}
style={{ width: '100%', padding: '8px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#fff', fontSize: '13px' }}
/>
</div>
<div style={{ marginBottom: '12px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '12px', marginBottom: '4px' }}>会员等级</label>
<select
value={editingUser.level || '青铜'}
onChange={(e) => setEditingUser({ ...editingUser, level: e.target.value })}
style={{ width: '100%', padding: '8px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#fff', fontSize: '13px' }}
>
<option value="青铜">青铜</option>
<option value="白银">白银</option>
<option value="黄金">黄金</option>
<option value="铂金">铂金</option>
<option value="钻石号">钻石号</option>
<option value="永恒号">永恒号</option>
<option value="带7号">带7号</option>
<option value="带4号">带4号</option>
</select>
</div>
<div style={{ marginBottom: '12px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '12px', marginBottom: '4px' }}>登录次数</label>
<input
type="number"
value={editingUser.loginCount || 0}
onChange={(e) => setEditingUser({ ...editingUser, loginCount: parseInt(e.target.value) || 0 })}
style={{ width: '100%', padding: '8px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#fff', fontSize: '13px' }}
/>
</div>
<div style={{ marginBottom: '12px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '12px', marginBottom: '4px' }}>AI识别次数</label>
<input
type="number"
value={editingUser.aiCount || 0}
onChange={(e) => setEditingUser({ ...editingUser, aiCount: parseInt(e.target.value) || 0 })}
style={{ width: '100%', padding: '8px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#fff', fontSize: '13px' }}
/>
</div>
<div style={{ marginBottom: '12px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '12px', marginBottom: '4px' }}>配号次数</label>
<input
type="number"
value={editingUser.searchCount || 0}
onChange={(e) => setEditingUser({ ...editingUser, searchCount: parseInt(e.target.value) || 0 })}
style={{ width: '100%', padding: '8px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#fff', fontSize: '13px' }}
/>
</div>
<div style={{ marginBottom: '12px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '12px', marginBottom: '4px' }}>寻号次数</label>
<input
type="number"
value={editingUser.searchCount || 0}
onChange={(e) => setEditingUser({ ...editingUser, searchCount: parseInt(e.target.value) || 0 })}
style={{ width: '100%', padding: '8px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#fff', fontSize: '13px' }}
/>
</div>
<div style={{ marginBottom: '12px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '12px', marginBottom: '4px' }}>积分</label>
<input
type="number"
value={editingUser.points || 0}
onChange={(e) => setEditingUser({ ...editingUser, points: parseInt(e.target.value) || 0 })}
style={{ width: '100%', padding: '8px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#fff', fontSize: '13px' }}
/>
</div>
<div style={{ marginBottom: '12px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '12px', marginBottom: '4px' }}>余额</label>
<input
type="number"
step="0.01"
value={editingUser.balance || 0}
onChange={(e) => setEditingUser({ ...editingUser, balance: parseFloat(e.target.value) || 0 })}
style={{ width: '100%', padding: '8px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#fff', fontSize: '13px' }}
/>
</div>
<div style={{ marginBottom: '12px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '12px', marginBottom: '4px' }}>累计金额</label>
<input
type="number"
step="0.01"
value={editingUser.totalAmount || 0}
onChange={(e) => setEditingUser({ ...editingUser, totalAmount: parseFloat(e.target.value) || 0 })}
style={{ width: '100%', padding: '8px', background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#fff', fontSize: '13px' }}
/>
</div>
</div>
</div>
<div style={{ display: 'flex', gap: '12px' }}>
<button
onClick={() => setEditingUser(null)}
style={{ flex: 1, padding: '12px', background: 'rgba(255,255,255,0.1)', color: '#fff', border: 'none', borderRadius: '8px', cursor: 'pointer' }}
>
取消
</button>
<button
onClick={handleEditUser}
style={{ flex: 1, padding: '12px', background: '#fbbf24', color: '#1e293b', border: 'none', borderRadius: '8px', fontWeight: '600', cursor: 'pointer' }}
>
确定
</button>
</div>
</div>
</div>
)}
{/* 版本号 - 移到表格下方,避免被底部导航遮挡 */}
<div style={{ textAlign: 'center', padding: '20px', color: 'rgba(255,255,255,0.3)', fontSize: '12px' }}>
v{APP_VERSION}
</div>
</div>
)
}

View File

@ -0,0 +1,388 @@
import React, { useState, useEffect } from 'react'
export default function Detail() {
const params = new URLSearchParams(window.location.hash.split('?')[1] || '')
const id = params.get('id')
const [collection, setCollection] = useState(null)
const [loading, setLoading] = useState(true)
const [error, setError] = useState('')
const [showDelete, setShowDelete] = useState(false)
const [showImage, setShowImage] = useState(false)
const [currentImageIndex, setCurrentImageIndex] = useState(0)
useEffect(() => {
if (id) {
fetchDetail()
}
}, [id])
const fetchDetail = async () => {
setLoading(true)
const token = localStorage.getItem('token')
try {
const res = await fetch(`/api/collections/${id}`, {
headers: token ? { 'Authorization': 'Bearer ' + token } : {}
})
if (!res.ok) {
const errorData = await res.json()
const errorCode = errorData.error?.code || 'E00000'
const errorMessage = errorData.error?.message || '加载失败'
//
if (res.status === 404) {
setError('E00033: 藏品不存在')
} else if (res.status === 401) {
setError('E00010: 未登录或登录已过期')
} else if (res.status === 403) {
setError('E00014: 无权访问此藏品')
} else {
setError(`${errorCode}: ${errorMessage}`)
}
setLoading(false)
return
}
const data = await res.json()
// camelCase 使
const collectionData = data.data || data
if (collectionData && collectionData.id) {
setCollection(collectionData)
} else {
setError('E00000: 数据格式错误')
}
} catch (e) {
console.error(e)
setError('E00001: 网络连接失败')
}
setLoading(false)
}
const handleEdit = () => {
window.location.hash = '#/edit?id=' + id
}
const goBack = () => {
//
const lastUrl = sessionStorage.getItem('lastListUrl')
if (lastUrl) {
sessionStorage.removeItem('lastListUrl')
window.location.hash = '#' + lastUrl
} else {
window.location.hash = '#/list'
}
}
const doDelete = async () => {
const token = localStorage.getItem('token')
try {
const res = await fetch(`/api/collections/${id}`, {
method: 'DELETE',
headers: { 'Authorization': 'Bearer ' + token }
})
if (res.ok) {
alert('删除成功!')
if (window.refreshList) window.refreshList()
window.location.hash = '#/list'
} else {
alert('删除失败')
}
} catch (e) {
alert('删除失败')
}
setShowDelete(false)
}
const getStatusText = (status) => {
const map = { 'in_collection': '收藏中', 'selling': '出售中', 'sold': '已售', 'grading': '送评中', 'repairing': '修复中', 'transit': '在途中', 'other': '其他' }
return map[status] || status || '-'
}
const getCategoryText = (category) => {
const map = { '自持': '自持', '寄存': '寄存', '寄售': '寄售', '共有': '共有', '寻号': '寻号', '其他': '其他' }
return map[category] || category || '-'
}
const Field = ({ label, value, green }) => (
<div style={{ display: 'flex', justifyContent: 'space-between', padding: '6px 0', borderBottom: '1px solid rgba(255,255,255,0.05)' }}>
<span style={{ color: '#94a3b8', fontSize: '13px' }}>{label}</span>
<span style={{ color: green ? '#22c55e' : '#fff', fontSize: '13px', textAlign: 'right', maxWidth: '60%' }}>{value || '-'}</span>
</div>
)
const Section = ({ title, children }) => (
<div style={{ background: 'rgba(255,255,255,0.03)', borderRadius: '10px', padding: '12px', marginBottom: '10px' }}>
<div style={{ color: '#fbbf24', fontSize: '13px', fontWeight: 'bold', marginBottom: '8px' }}>{title}</div>
{children}
</div>
)
if (loading) {
return <div style={{ padding: '40px', textAlign: 'center', color: '#94a3b8' }}>加载中...</div>
}
if (error) {
return (
<div style={{ padding: '40px', textAlign: 'center' }}>
<div style={{ fontSize: '60px' }}></div>
<div style={{ color: '#ef4444', marginTop: '16px', fontSize: '16px', fontWeight: 'bold' }}>{error}</div>
<button onClick={goBack} style={{ marginTop: '20px', padding: '12px 24px', background: '#fbbf24', color: '#1e293b', border: 'none', borderRadius: '8px', cursor: 'pointer' }}>返回列表</button>
</div>
)
}
if (!collection) {
return (
<div style={{ padding: '40px', textAlign: 'center' }}>
<div style={{ fontSize: '60px' }}></div>
<div style={{ color: '#94a3b8', marginTop: '16px' }}>藏品不存在</div>
<button onClick={goBack} style={{ marginTop: '20px', padding: '12px 24px', background: '#fbbf24', color: '#1e293b', border: 'none', borderRadius: '8px', cursor: 'pointer' }}>返回列表</button>
</div>
)
}
return (
<div style={{ background: '#0f172a', minHeight: '100vh', paddingBottom: '80px' }}>
{/* 顶部 */}
<div style={{ padding: '12px 16px', background: 'rgba(255,255,255,0.02)', borderBottom: '1px solid rgba(255,255,255,0.05)', display: 'flex', alignItems: 'center', position: 'sticky', top: 0, zIndex: 100 }}>
<span style={{ fontSize: '16px', fontWeight: 'bold', color: '#fff' }}>藏品详情</span>
<div style={{ marginLeft: 'auto', display: 'flex', gap: '8px' }}>
<button onClick={goBack} style={{ padding: '6px 12px', background: 'rgba(255,255,255,0.1)', color: '#fff', border: 'none', borderRadius: '6px', fontSize: '13px' }}>返回</button>
<button onClick={() => setShowDelete(true)} style={{ padding: '6px 12px', background: '#ef4444', color: '#fff', border: 'none', borderRadius: '6px', fontSize: '13px' }}>删除</button>
<button onClick={handleEdit} style={{ padding: '6px 12px', background: '#fbbf24', color: '#1e293b', border: 'none', borderRadius: '6px', fontSize: '13px', fontWeight: '600' }}>编辑</button>
</div>
</div>
{/* 主信息 */}
<div style={{ padding: '16px' }}>
{/* 图片显示 */}
{collection.images && collection.images.length > 0 && (
<div style={{ marginBottom: '16px' }}>
<div style={{ display: 'grid', gridTemplateColumns: `repeat(${Math.min(collection.images.length, 1)}, 1fr)`, gap: '12px' }}>
{collection.images.map((img, index) => (
<div key={img.id || index} style={{ position: 'relative' }}>
<img
src={img.path?.startsWith('http') ? img.path : `/${img.path || `uploads/collections/${img.filename}`}`}
alt={img.originalName || '藏品图片'}
onClick={() => { setCurrentImageIndex(index); setShowImage(true); }}
style={{
width: '100%',
aspectRatio: '1.5',
objectFit: 'contain',
borderRadius: '12px',
border: '2px solid #10b981',
cursor: 'pointer',
boxShadow: '0 4px 12px rgba(0,0,0,0.3)',
background: '#0f172a'
}}
onError={(e) => {
// logo
e.target.style.display = 'none';
e.target.parentElement.innerHTML = '<div style="width:100%;aspectRatio:1.5;background:rgba(255,255,255,0.05);border-radius:12px;display:flex;align-items:center;justify-content:center;color:rgba(255,255,255,0.3);font-size:14px;">无图片</div>';
}}
/>
{collection.images.length > 1 && (
<div style={{
position: 'absolute',
top: '8px',
left: '8px',
background: 'rgba(0,0,0,0.6)',
color: '#fff',
padding: '4px 8px',
borderRadius: '4px',
fontSize: '12px'
}}>
{index + 1}/{collection.images.length}
</div>
)}
</div>
))}
</div>
</div>
)}
<div style={{ fontSize: '18px', fontWeight: 'bold', textAlign: 'center', color: '#fff', marginBottom: '8px' }}>{collection.name}</div>
<div style={{ textAlign: 'center', color: '#fbbf24', fontSize: '14px', fontFamily: 'monospace', fontWeight: 'bold' }}>{collection.prefixSerial || '-'}</div>
</div>
{/* 信息区块 */}
<div style={{ padding: '0 16px' }}>
<Section title="基本信息">
<Field label="编号" value={collection.code} />
<Field label="持仓类型" value={getCategoryText(collection.category)} />
<Field label="珍惜度" value={collection.rarity || '-'} green={collection.rarity && collection.rarity !== '通货'} />
<Field label="版别" value={collection.version} />
<Field label="面值" value={collection.denomination} />
<Field label="状态" value={getStatusText(collection.status)} green={collection.status === 'in_collection'} />
<Field label="包装" value={collection.packaging} />
<Field label="创建时间" value={collection.createdAt ? new Date(collection.createdAt).toLocaleDateString('zh-CN', { year: 'numeric', month: '2-digit', day: '2-digit' }).replace(/\//g, '-') : '-'} />
</Section>
<Section title="评级信息">
<Field label="是否评级" value={collection.isGraded ? '已评级' : '未评级'} />
<Field label="评级公司" value={collection.gradingCompany} />
<Field label="评级分数" value={collection.gradingScore} green={collection.gradingScore} />
<Field label="三星" value={collection.threeStar ? '是' : '否'} green={collection.threeStar} />
</Section>
<Section title="特殊信息">
<Field label="特殊标识" value={collection.specialMark} />
<Field label="号码特征" value={collection.serialFeature} />
<Field label="号码分类" value={collection.numberCategory} />
<Field label="发行方" value={collection.issuer} />
<Field label="发行年份" value={collection.issueYear} />
<Field label="材质" value={collection.material} />
<Field label="发行量" value={collection.issueQuantity} />
</Section>
<Section title="价格信息">
<Field label="成本价" value={collection.costPrice ? '¥' + collection.costPrice : '-'} />
<Field label="目标价" value={collection.targetPrice ? '¥' + collection.targetPrice : '-'} />
<Field label="出售价" value={collection.goalPrice ? '¥' + collection.goalPrice : '-'} green={collection.goalPrice} />
<Field label="修复费" value={collection.repairFee ? '¥' + collection.repairFee : '-'} />
<Field label="评级费" value={collection.gradingFee ? '¥' + collection.gradingFee : '-'} />
<Field label="用途" value={collection.purpose} />
</Section>
{collection.remark && (
<Section title="备注">
<div style={{ color: '#fff', fontSize: '13px', lineHeight: '1.5' }}>{collection.remark}</div>
</Section>
)}
</div>
{/* 删除确认弹窗 */}
{showDelete && (
<div style={{ position: 'fixed', top: 0, left: 0, right: 0, bottom: 0, background: 'rgba(0,0,0,0.8)', display: 'flex', alignItems: 'center', justifyContent: 'center', zIndex: 1000 }}>
<div style={{ background: '#1e293b', borderRadius: '12px', padding: '24px', width: '80%', maxWidth: '300px' }}>
<div style={{ color: '#fff', fontSize: '16px', fontWeight: 'bold', marginBottom: '16px', textAlign: 'center' }}>确定删除此藏品</div>
<div style={{ display: 'flex', gap: '12px' }}>
<button onClick={() => setShowDelete(false)} style={{ flex: 1, padding: '12px', background: 'rgba(255,255,255,0.1)', color: '#fff', border: 'none', borderRadius: '8px', fontSize: '14px' }}>取消</button>
<button onClick={doDelete} style={{ flex: 1, padding: '12px', background: '#ef4444', color: '#fff', border: 'none', borderRadius: '8px', fontSize: '14px' }}>删除</button>
</div>
</div>
</div>
)}
{/* 图片查看器 */}
{showImage && collection.images && collection.images.length > 0 && (
<div
style={{ position: 'fixed', top: 0, left: 0, right: 0, bottom: 0, background: 'rgba(0,0,0,0.95)', zIndex: 9999, display: 'flex', alignItems: 'center', justifyContent: 'center', padding: '20px' }}
onClick={() => setShowImage(false)}
>
{/* 左侧切换按钮 */}
{collection.images.length > 1 && (
<button
onClick={(e) => { e.stopPropagation(); setCurrentImageIndex((currentImageIndex - 1 + collection.images.length) % collection.images.length); }}
style={{
position: 'absolute',
left: '20px',
background: 'rgba(255,255,255,0.2)',
color: '#fff',
border: 'none',
borderRadius: '50%',
width: '50px',
height: '50px',
fontSize: '24px',
cursor: 'pointer',
display: 'flex',
alignItems: 'center',
justifyContent: 'center'
}}
>
</button>
)}
{/* 图片 */}
<img
src={collection.images[currentImageIndex].path?.startsWith('http') ? collection.images[currentImageIndex].path : `/${collection.images[currentImageIndex].path || `uploads/collections/${collection.images[currentImageIndex].filename}`}`}
alt={collection.images[currentImageIndex].originalName || '藏品图片'}
onClick={(e) => e.stopPropagation()}
style={{ maxWidth: '100%', maxHeight: '100%', objectFit: 'contain' }}
/>
{/* 右侧切换按钮 */}
{collection.images.length > 1 && (
<button
onClick={(e) => { e.stopPropagation(); setCurrentImageIndex((currentImageIndex + 1) % collection.images.length); }}
style={{
position: 'absolute',
right: '20px',
background: 'rgba(255,255,255,0.2)',
color: '#fff',
border: 'none',
borderRadius: '50%',
width: '50px',
height: '50px',
fontSize: '24px',
cursor: 'pointer',
display: 'flex',
alignItems: 'center',
justifyContent: 'center'
}}
>
</button>
)}
{/* 图片指示器 */}
{collection.images.length > 1 && (
<div
style={{
position: 'absolute',
bottom: '40px',
left: '50%',
transform: 'translateX(-50%)',
display: 'flex',
gap: '10px'
}}
onClick={(e) => e.stopPropagation()}
>
{collection.images.map((_, index) => (
<div
key={index}
onClick={() => setCurrentImageIndex(index)}
style={{
width: '12px',
height: '12px',
borderRadius: '50%',
background: index === currentImageIndex ? '#fbbf24' : 'rgba(255,255,255,0.3)',
cursor: 'pointer',
border: '2px solid #fff'
}}
/>
))}
</div>
)}
{/* 关闭提示 */}
<div
style={{
position: 'absolute',
top: '20px',
right: '20px',
background: 'rgba(255,255,255,0.2)',
color: '#fff',
border: 'none',
borderRadius: '50%',
width: '40px',
height: '40px',
fontSize: '24px',
cursor: 'pointer',
display: 'flex',
alignItems: 'center',
justifyContent: 'center'
}}
onClick={() => setShowImage(false)}
>
×
</div>
</div>
)}
</div>
)
}
// v2.7.1

491
frontend/src/pages/Edit.jsx Normal file
View File

@ -0,0 +1,491 @@
import React, { useState, useRef, useEffect } from 'react'
// Input Add.jsx
const Input = ({ form, handleChange, label, field, type = 'text', options = null }) => {
const onChange = (e) => {
const value = e.target.value
if (type === 'number' && value !== '') {
const num = parseFloat(value)
handleChange(field, isNaN(num) ? '' : num)
} else handleChange(field, value)
}
return (
<div style={{ flex: 1, minWidth: '45%', marginBottom: '12px' }}>
<div style={{ fontSize: '12px', color: '#94a3b8', marginBottom: '4px' }}>{label}</div>
{options ? (
<select value={form[field] || ''} onChange={onChange}
style={{ background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', color: '#fff', padding: '8px', borderRadius: '6px', width: '100%', fontSize: '13px' }}>
<option value="">请选择</option>
{options.map(o => <option key={o.value} value={o.value} style={{color:'#000'}}>{o.label}</option>)}
</select>
) : (
<input type={type} value={form[field] ?? ''} onChange={onChange}
style={{ background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', color: '#fff', padding: '8px', borderRadius: '6px', width: '100%', fontSize: '13px' }} />
)}
</div>
)
}
//
const statusOptions = [
{ value: 'in_collection', label: '收藏中' },
{ value: 'selling', label: '出售中' },
{ value: 'sold', label: '已售' },
{ value: 'grading', label: '送评中' },
{ value: 'repairing', label: '修复中' },
{ value: 'transit', label: '在途中' },
{ value: 'seeking', label: '寻号中' },
{ value: 'other', label: '其他' }
]
const categoryOptions = [
{ value: '自持', label: '自持' },
{ value: '寄存', label: '寄存' },
{ value: '寄售', label: '寄售' },
{ value: '共有', label: '共有' },
{ value: '其他', label: '其他' }
]
const numberCategoryOptions = [{value:'无2347',label:'无2347'},{value:'无347',label:'无347'},{value:'无247',label:'无247'},{value:'无47',label:'无47'},{value:'带7号',label:'带7号'},{value:'带4号',label:'带4号'},{value:'其他',label:'其他'}];
const rarityOptions = [
{ value: '通货', label: '通货' },
{ value: '特色', label: '特色' },
{ value: '少见', label: '少见' },
{ value: '稀有', label: '稀有' },
{ value: '珍品', label: '珍品' },
{ value: '孤品', label: '孤品' }
]
const packagingOptions = [
{ value: '标十', label: '标十' },
{ value: '标百', label: '标百' },
{ value: '单张', label: '单张' },
{ value: '裸钞', label: '裸钞' }
]
export default function Edit() {
// URL ID
const params = new URLSearchParams(window.location.hash.split('?')[1] || '')
const editId = params.get('id')
const [form, setForm] = useState({
name: '', code: '', category: '自持', rarity: '通货', numberCategory: '', prefixSerial: '',
version: '2024 龙', denomination: '', status: 'in_collection', packaging: '单张',
material: '塑料钞', issueQuantity: '1 亿', purpose: '收藏', isGraded: false,
gradingCompany: '', gradingScore: '', threeStar: false, specialMark: '',
serialFeature: '', issuer: '中国人民银行', issueYear: '2024',
costPrice: '', targetPrice: '', goalPrice: '', repairFee: '', gradingFee: '', remark: ''
})
const [loading, setLoading] = useState(true)
const [saving, setSaving] = useState(false)
const [error, setError] = useState('')
const [uploadImages, setUploadImages] = useState([])
const fileInputRef = useRef(null)
//
useEffect(() => {
if (editId) {
const token = localStorage.getItem('token')
fetch(`/api/collections/${editId}`, {
headers: { 'Authorization': 'Bearer ' + token }
})
.then(res => res.json())
.then(data => {
//
setForm({
name: data.name || '',
code: data.code || '',
category: data.category || '自持',
rarity: data.rarity || '通货',
numberCategory: data.numberCategory || '',
prefixSerial: data.prefixSerial || '',
version: data.version || '2024 龙',
denomination: data.denomination || '',
status: data.status || 'in_collection',
packaging: data.packaging || '单张',
isGraded: data.isGraded || false,
gradingCompany: data.gradingCompany || '',
gradingScore: data.gradingScore || '',
threeStar: data.threeStar || false,
specialMark: data.specialMark || '',
serialFeature: data.serialFeature || '',
issuer: data.issuer || '中国人民银行',
issueYear: data.issueYear || '2024',
material: data.material || '塑料钞',
issueQuantity: data.issueQuantity || '1 亿',
costPrice: data.costPrice || '',
targetPrice: data.targetPrice || '',
goalPrice: data.goalPrice || '',
repairFee: data.repairFee || '',
gradingFee: data.gradingFee || '',
purpose: data.purpose || '收藏',
remark: data.remark || ''
})
//
if (data.images && Array.isArray(data.images)) {
const images = data.images.map(img => ({
file: null,
preview: img.path?.startsWith('http') ? img.path : `/${img.path || `uploads/collections/${img.filename}`}`,
name: img.original_name || img.filename,
size: 0,
id: img.id
}))
setUploadImages(images)
}
setLoading(false)
})
.catch(err => {
console.error('加载藏品失败:', err)
setError('加载失败:' + err.message)
setLoading(false)
})
} else {
setError('未指定藏品 ID')
setLoading(false)
}
}, [editId])
const handleChange = (key, value) => {
setForm({ ...form, [key]: value })
if (key === 'targetPrice' && value) setForm(prev => ({ ...prev, status: 'sold' }))
//
if (key === 'prefixSerial') {
const serial = value
let cat = ''
const match = serial.match(/J(\d{9})/)
const digits = match ? match[1] : serial.replace(/\D/g, '').slice(0, 9)
if (digits) {
if (!digits.includes('2') && !digits.includes('3') && !digits.includes('4') && !digits.includes('7')) cat = '无2347'
else if (!digits.includes('3') && !digits.includes('4') && !digits.includes('7')) cat = '无347'
else if (digits.includes('4')) cat = '带4号'
else if (digits.includes('7')) cat = '带7号'
else if (!digits.includes('4') && !digits.includes('7')) cat = '无47'
else if (!digits.includes('2') && !digits.includes('4') && !digits.includes('7')) cat = '无247'
else cat = '其他'
}
setForm(prev => ({ ...prev, numberCategory: cat }))
}
//
if (key === 'version') {
const yearMatch = value.match(/(20\d{2})/)
if (yearMatch) {
setForm(prev => ({ ...prev, issueYear: yearMatch[1] }))
}
}
}
//
const handleImageUpload = async (e) => {
const files = Array.from(e.target.files)
if (files.length === 0 || !editId) return
const token = localStorage.getItem('token')
const file = files[0] // 1
const imgFormData = new FormData()
imgFormData.append('file', file)
try {
const res = await fetch(`/api/collections/upload-image?collection_id=${editId}`, {
method: 'POST',
headers: { 'Authorization': 'Bearer ' + token },
body: imgFormData
})
if (res.ok) {
//
const dataRes = await fetch(`/api/collections/${editId}`, {
headers: { 'Authorization': 'Bearer ' + token }
})
const data = await dataRes.json()
if (data.images && Array.isArray(data.images)) {
const images = data.images.map(img => ({
file: null,
preview: img.path?.startsWith('http') ? img.path : `/${img.path || `uploads/collections/${img.filename}`}`,
name: img.original_name || img.filename,
size: 0,
id: img.id
}))
setUploadImages(images)
}
alert('图片上传成功!')
} else {
alert('图片上传失败')
}
} catch (err) {
console.error('图片上传失败:', err)
alert('图片上传失败:' + err.message)
}
}
const handleSave = async () => {
if (!form.name || !form.version) { setError('名称和版别为必填项'); return }
setSaving(true)
setError('')
const token = localStorage.getItem('token')
const formData = convertField(form)
try {
// 1.
const res = await fetch(`/api/collections/${editId}`, {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
'Authorization': 'Bearer ' + token
},
body: JSON.stringify(formData)
})
if (!res.ok) {
const data = await res.json()
throw new Error(data.error?.message || data.detail || '更新失败')
}
alert('更新成功!')
window.location.hash = '#/list'
window.refreshList?.()
} catch (e) {
console.error('更新失败:', e)
alert('更新失败:' + e.message)
}
finally { setSaving(false) }
}
//
const convertField = (obj) => {
const map = {
id: 'f99_90_id', userId: 'f99_91_user_id',
name: 'f01_01_name', code: 'f01_02_code', category: 'f01_03_category',
status: 'f01_04_status', remark: 'f01_05_remark',
prefixSerial: 'f02_10_prefix_serial', version: 'f02_11_version',
packaging: 'f02_12_packaging', rarity: 'f02_13_rarity',
numberCategory: 'f02_14_number_category',
isGraded: 'f03_20_is_graded', gradingCompany: 'f03_21_grading_company',
gradingScore: 'f03_22_grading_score', threeStar: 'f03_23_three_star',
specialMark: 'f04_30_special_mark', serialFeature: 'f04_31_serial_feature',
issuer: 'f04_32_issuer', issueYear: 'f04_33_issue_year',
material: 'f04_34_material', denomination: 'f04_35_denomination',
issueQuantity: 'f04_36_issue_quantity',
costPrice: 'f05_40_cost_price', targetPrice: 'f05_41_target_price',
goalPrice: 'f05_42_goal_price', repairFee: 'f05_43_repair_fee',
gradingFee: 'f05_44_grading_fee', purpose: 'f06_50_purpose'
}
const result = {}
const numberFields = ['costPrice', 'targetPrice', 'goalPrice', 'repairFee', 'gradingFee']
for (const key in obj) {
let value = obj[key]
if (value === '' || value === null) value = null
else if (numberFields.includes(key)) {
value = parseFloat(value)
if (isNaN(value)) value = null
}
result[map[key] || key] = value
}
return result
}
if (loading) {
return (
<div style={{ background: '#0f172a', minHeight: '100vh', display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
<div style={{ color: '#94a3b8', fontSize: '16px' }}>加载中...</div>
</div>
)
}
return (
<div style={{ background: '#0f172a', minHeight: '100vh', paddingBottom: '80px' }}>
{/* 顶部标题 */}
<div style={{ padding: '16px', background: 'rgba(255,255,255,0.02)', borderBottom: '1px solid rgba(255,255,255,0.05)', display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
<div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: 'bold' }}>编辑藏品</div>
<div style={{ color: '#94a3b8', fontSize: '13px', marginTop: '4px' }}>修改藏品信息</div>
</div>
<div onClick={() => window.history.back()} style={{ color: '#60a5fa', fontSize: '24px', cursor: 'pointer', padding: '8px' }}></div>
</div>
{error && (
<div style={{ margin: '16px', padding: '12px', background: 'rgba(239, 68, 68, 0.2)', border: '1px solid #ef4444', color: '#ef4444', borderRadius: '8px' }}>
{error}
</div>
)}
<div style={{ padding: '16px' }}>
{/* 藏品图片 */}
<div style={{ background: 'rgba(255,255,255,0.03)', borderRadius: '12px', padding: '16px', marginBottom: '12px' }}>
<div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '12px' }}>
<div style={{ color: '#fbbf24', fontSize: '14px', fontWeight: 'bold' }}>藏品图片 ({uploadImages.length}/1)</div>
{uploadImages.length === 0 && (
<button
onClick={() => fileInputRef.current?.click()}
style={{
padding: '6px 12px',
background: 'rgba(34, 197, 94, 0.2)',
color: '#22c55e',
border: '1px solid #22c55e',
borderRadius: '6px',
fontSize: '12px',
cursor: 'pointer'
}}
>
📷 上传图片
</button>
)}
</div>
{/* 隐藏的文件输入框 */}
<input
ref={fileInputRef}
type="file"
accept="image/*"
onChange={handleImageUpload}
style={{ display: 'none' }}
/>
{uploadImages.length > 0 ? (
<div style={{ display: 'grid', gridTemplateColumns: `repeat(${Math.min(uploadImages.length, 1)}, 1fr)`, gap: '12px' }}>
{uploadImages.map((img, index) => (
<div key={img.id || index} style={{ position: 'relative' }}>
<img
src={img.preview}
alt={img.name || '藏品图片'}
style={{
width: '100%',
aspectRatio: '1.5',
objectFit: 'contain',
borderRadius: '12px',
border: '2px solid #10b981',
boxShadow: '0 4px 12px rgba(0,0,0,0.3)',
background: 'rgba(0,0,0,0.3)'
}}
/>
<div style={{
position: 'absolute',
top: '8px',
left: '8px',
background: 'rgba(0,0,0,0.6)',
color: '#fff',
padding: '4px 8px',
borderRadius: '4px',
fontSize: '12px'
}}>{index + 1}/{uploadImages.length}</div>
</div>
))}
</div>
) : (
<div style={{ textAlign: 'center', color: '#94a3b8', padding: '24px' }}>
📷 暂无图片
</div>
)}
</div>
{/* 基本信息 */}
<div style={{ background: 'rgba(255,255,255,0.03)', borderRadius: '12px', padding: '16px', marginBottom: '12px' }}>
<div style={{ color: '#fbbf24', fontSize: '14px', fontWeight: 'bold', marginBottom: '12px' }}>基本信息</div>
<div style={{ display: 'flex', flexWrap: 'wrap', gap: '12px' }}>
<Input form={form} handleChange={handleChange} label="名称 *" field="name" />
<Input form={form} handleChange={handleChange} label="编号" field="code" />
<Input form={form} handleChange={handleChange} label="持仓类型" field="category" options={categoryOptions} />
<Input form={form} handleChange={handleChange} label="珍惜度" field="rarity" options={rarityOptions} />
<Input form={form} handleChange={handleChange} label="冠字序号" field="prefixSerial" />
<Input form={form} handleChange={handleChange} label="版别 *" field="version" />
<Input form={form} handleChange={handleChange} label="面值" field="denomination" />
<Input form={form} handleChange={handleChange} label="状态" field="status" options={statusOptions} />
<Input form={form} handleChange={handleChange} label="包装" field="packaging" options={packagingOptions} />
</div>
</div>
{/* 评级信息 */}
<div style={{ background: 'rgba(255,255,255,0.03)', borderRadius: '12px', padding: '16px', marginBottom: '12px' }}>
<div style={{ color: '#fbbf24', fontSize: '14px', fontWeight: 'bold', marginBottom: '12px' }}>评级信息</div>
<div style={{ display: 'flex', flexWrap: 'wrap', gap: '12px', alignItems: 'center', marginBottom: '12px' }}>
<div style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>
<input type="checkbox" id="isGraded" checked={form.isGraded || false} onChange={(e) => handleChange('isGraded', e.target.checked)}
style={{ width: '18px', height: '18px', cursor: 'pointer', accentColor: '#22c55e' }} />
<label htmlFor="isGraded" style={{ color: '#fff', cursor: 'pointer', fontSize: '13px' }}>是否评级</label>
</div>
<div style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>
<input type="checkbox" id="threeStar" checked={form.threeStar || false} onChange={(e) => handleChange('threeStar', e.target.checked)}
style={{ width: '18px', height: '18px', cursor: 'pointer', accentColor: '#22c55e' }} />
<label htmlFor="threeStar" style={{ color: '#fff', cursor: 'pointer', fontSize: '13px' }}>三星</label>
</div>
</div>
<div style={{ display: 'flex', flexWrap: 'wrap', gap: '12px' }}>
<Input form={form} handleChange={handleChange} label="评级公司" field="gradingCompany" />
<Input form={form} handleChange={handleChange} label="评级分数" field="gradingScore" />
</div>
</div>
{/* 特殊信息 */}
<div style={{ background: 'rgba(255,255,255,0.03)', borderRadius: '12px', padding: '16px', marginBottom: '12px' }}>
<div style={{ color: '#fbbf24', fontSize: '14px', fontWeight: 'bold', marginBottom: '12px' }}>特殊信息</div>
<div style={{ display: 'flex', flexWrap: 'wrap', gap: '12px' }}>
<Input form={form} handleChange={handleChange} label="特殊标识" field="specialMark" />
<Input form={form} handleChange={handleChange} label="号码特征" field="serialFeature" />
<Input form={form} handleChange={handleChange} label="号码分类" field="numberCategory" options={numberCategoryOptions} />
<Input form={form} handleChange={handleChange} label="发行方" field="issuer" />
<Input form={form} handleChange={handleChange} label="发行年份" field="issueYear" />
<Input form={form} handleChange={handleChange} label="材质" field="material" />
<Input form={form} handleChange={handleChange} label="发行量" field="issueQuantity" />
</div>
</div>
{/* 价格信息 */}
<div style={{ background: 'rgba(255,255,255,0.03)', borderRadius: '12px', padding: '16px', marginBottom: '12px' }}>
<div style={{ color: '#fbbf24', fontSize: '14px', fontWeight: 'bold', marginBottom: '12px' }}>价格信息</div>
<div style={{ display: 'flex', flexWrap: 'wrap', gap: '12px' }}>
<Input form={form} handleChange={handleChange} label="成本价" field="costPrice" type="number" />
<Input form={form} handleChange={handleChange} label="目标价" field="targetPrice" type="number" />
<Input form={form} handleChange={handleChange} label="出售价" field="goalPrice" type="number" />
<Input form={form} handleChange={handleChange} label="修复费" field="repairFee" type="number" />
<Input form={form} handleChange={handleChange} label="评级费" field="gradingFee" type="number" />
<Input form={form} handleChange={handleChange} label="用途" field="purpose" />
</div>
</div>
{/* 备注 */}
<div style={{ background: 'rgba(255,255,255,0.03)', borderRadius: '12px', padding: '16px', marginBottom: '12px' }}>
<div style={{ fontSize: '13px', color: '#94a3b8', marginBottom: '6px' }}>备注</div>
<textarea
value={form.remark || ''}
onChange={(e) => handleChange('remark', e.target.value)}
rows={3}
style={{ background: 'rgba(255,255,255,0.05)', border: '1px solid rgba(255,255,255,0.1)', color: '#fff', padding: '10px', borderRadius: '8px', width: '100%', resize: 'none' }}
/>
</div>
{/* 按钮 */}
<button
onClick={saving ? null : handleSave}
disabled={saving}
style={{
width: '100%',
padding: '14px',
background: saving ? '#64748b' : '#fbbf24',
color: saving ? '#94a3b8' : '#1e293b',
border: 'none',
borderRadius: '10px',
fontSize: '16px',
fontWeight: '600',
cursor: saving ? 'not-allowed' : 'pointer',
marginBottom: '12px'
}}
>
{saving ? '更新中...' : '✅ 更新藏品'}
</button>
<button
onClick={() => window.location.hash = '#/list'}
style={{
width: '100%',
padding: '14px',
background: 'rgba(255,255,255,0.05)',
color: '#94a3b8',
border: '1px solid rgba(255,255,255,0.1)',
borderRadius: '10px',
fontSize: '14px',
cursor: 'pointer'
}}
>
🔄 返回列表
</button>
</div>
</div>
)
}

501
frontend/src/pages/Home.jsx Normal file
View File

@ -0,0 +1,501 @@
import React, { useState, useEffect } from 'react'
import { APP_VERSION } from '../config/version'
export default function Home() {
const [user, setUser] = useState(null)
const [stats, setStats] = useState({ totalCount: 0, totalCost: 0, totalRevenue: 0, expectedProfit: 0, totalProfit: 0, gradedCount: 0 })
const [recentCollections, setRecentCollections] = useState([])
const [yichensStats, setYichensStats] = useState({ total: 0, deals: 0, wants: 0, dragons: 0, horses: 0, tianma: 0 })
const [seekStats, setSeekStats] = useState({ seekCount: 0, matchedCount: 0 })
const [recentPosts, setRecentPosts] = useState([])
const [dragonStats, setDragonStats] = useState({})
const [dealVersion, setDealVersion] = useState('龙钞')
const [dealCategoryStats, setDealCategoryStats] = useState([])
const currentPath = window.location.hash.slice(1) || '/'
useEffect(() => {
const token = localStorage.getItem('token')
const userData = localStorage.getItem('user')
if (userData) {
try {
setUser(JSON.parse(userData))
} catch (e) {
console.error('Parse user error:', e)
}
}
if (token) {
fetch('/api/collections/stats', {
headers: { 'Authorization': 'Bearer ' + token }
}).then(res => {
if (!res.ok) throw new Error('Stats API failed')
return res.json()
}).then(data => {
// stats APIdata.data
const info = data.totalCount !== undefined ? data : (data.data || data)
if (info && info.totalCount !== undefined) {
// byGrading
const gradedCount = info.byGrading ? (info.byGrading.find(x => x.isGraded === true)?.count || 0) : 0
setStats({
totalCount: info.totalCount || 0,
totalCost: info.totalCost || 0,
totalRevenue: info.totalRevenue || 0,
expectedProfit: info.expectedProfit || 0,
totalProfit: info.totalProfit || 0,
gradedCount: gradedCount
})
}
})
fetch('/api/collections?limit=5&sort=createdAt&order=desc', {
headers: { 'Authorization': 'Bearer ' + token }
}).then(res => res.json()).then(data => {
// {data:[], pagination:{}} {items:[]}
const list = data.data || data.items || data
if (Array.isArray(list)) {
setRecentCollections(list)
}
})
}
}, [])
//
useEffect(() => {
fetch('/api/yichens/stats/dragons-today').then(res => res.json()).then(data => {
setDragonStats(data || {})
}).catch(() => {})
fetch('/api/yichens/stats/today').then(res => res.json()).then(data => {
setYichensStats(data || {})
}).catch(() => {})
//
fetch('/api/yichens/stats/dragons-today').then(res => res.json()).then(data => {
setDragonStats(data || {})
}).catch(() => {})
fetch('/api/yichens/posts?limit=20&offset=0').then(res => res.json()).then(data => {
setRecentPosts(data.posts || data || [])
}).catch(() => {})
//
fetch('/api/seek/stats').then(res => res.json()).then(data => {
setSeekStats({ seekCount: data.total || 0, userMatchedCount: data.matched || 0, totalMatchedCount: data.unmatched || 0 })
}).catch(() => {})
//
const token = localStorage.getItem('token')
const headers = token ? { 'Authorization': 'Bearer ' + token } : {}
fetch('/api/deal/category-stats?version=龙钞', { headers }).then(res => res.json()).then(data => {
setDealCategoryStats(data.data || [])
}).catch(() => {})
}, [])
//
const isAdmin = user && user.role === 'admin'
const handleLogout = () => {
localStorage.removeItem('token')
localStorage.removeItem('user')
window.location.hash = '#/login'
window.location.reload()
}
const formatMoney = (val) => {
if (!val || val === 0) return '0'
const v = val / 10000
return v.toFixed(1)
}
const statCards = [
{ label: '藏品数', value: stats.totalCount, color: '#3b82f6' },
{ label: '总成本', value: formatMoney(stats.totalCost) + '万', color: '#22c55e' },
{ label: '总收入', value: formatMoney(stats.totalRevenue) + '万', color: '#06b6d4' },
{ label: '评级数', value: stats.gradedCount, color: '#8b5cf6' },
{ label: '预期利润', value: formatMoney(stats.expectedProfit) + '万', color: stats.expectedProfit >= 0 ? '#f59e0b' : '#ef4444' },
{ label: '总利润', value: formatMoney(stats.totalProfit) + '万', color: stats.totalProfit >= 0 ? '#10b981' : '#f43f5e' }
]
return (
<div style={{
minHeight: '100vh', overflowY: 'auto',
background: 'linear-gradient(135deg, #0f172a 0%, #1e293b 50%, #0f172a 100%)',
padding: '20px',
fontFamily: '"Noto Sans SC", "PingFang SC", sans-serif'
}}>
{/* 顶部用户信息 */}
<div style={{
background: 'linear-gradient(135deg, rgba(59,130,246,0.2) 0%, rgba(139,92,246,0.2) 100%)',
borderRadius: '16px',
padding: '20px',
marginBottom: '20px',
border: '1px solid rgba(255,255,255,0.1)',
backdropFilter: 'blur(10px)'
}}>
<div style={{ display: 'flex', alignItems: 'center', gap: '12px' }}>
<img src="/static/images/jiachenlong-logo.png" alt="甲辰收藏" style={{ width: '48px', height: '48px', borderRadius: '50%', objectFit: 'cover' }} />
<div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: '600' }}>{user?.username || '用户'} <span style={{ color: 'rgba(255,255,255,0.4)', fontSize: '11px', fontWeight: 'normal' }}>ID:{user?.user_code || '-'}</span></div>
<div style={{ color: 'rgba(255,255,255,0.6)', fontSize: '12px' }}>欢迎回来 👋</div>
</div>
<div style={{ marginLeft: 'auto', display: 'flex', alignItems: 'center', gap: '12px' }}>
<div style={{ color: 'rgba(255,255,255,0.3)', fontSize: '10px' }}>v{APP_VERSION}</div>
<div onClick={() => window.location.hash = '#/settings'} style={{ color: 'rgba(255,255,255,0.5)', cursor: 'pointer', fontSize: '12px', padding: '4px 8px', border: '1px solid rgba(255,255,255,0.2)', borderRadius: '4px' }}>设置</div>
<div onClick={handleLogout} style={{ color: 'rgba(255,255,255,0.5)', cursor: 'pointer', fontSize: '12px', padding: '4px 8px', border: '1px solid rgba(255,255,255,0.2)', borderRadius: '4px' }}>退出</div>
</div>
</div>
</div>
{/* 统计卡片网格 */}
<div style={{
display: 'grid',
gridTemplateColumns: 'repeat(3, 1fr)',
gap: '12px',
marginBottom: '20px'
}}>
{statCards.map((card, idx) => (
<div key={idx} style={{
background: 'linear-gradient(135deg, rgba(255,255,255,0.08) 0%, rgba(255,255,255,0.02) 100%)',
borderRadius: '16px',
padding: '16px 12px',
border: '1px solid rgba(255,255,255,0.08)',
backdropFilter: 'blur(10px)',
textAlign: 'center',
transition: 'transform 0.2s, box-shadow 0.2s',
cursor: 'pointer'
}}
onMouseOver={e => { e.currentTarget.style.transform = 'translateY(-2px)' }}
onMouseOut={e => { e.currentTarget.style.transform = 'translateY(0)' }}
onClick={() => window.location.hash = '#/stats'}
>
<div style={{ color: card.color, fontSize: '18px', fontWeight: '700', marginBottom: '4px' }}>{card.value}</div>
<div style={{ color: 'rgba(255,255,255,0.5)', fontSize: '11px' }}>{card.label}</div>
</div>
))}
</div>
{/* 快捷操作 */}
<div style={{ marginBottom: '20px' }}>
<div style={{ color: 'rgba(255,255,255,0.7)', fontSize: '14px', marginBottom: '12px', paddingLeft: '4px' }}>快捷操作</div>
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(2, 1fr)', gap: '12px' }}>
<div onClick={() => window.location.hash = '#/add?mode=ocr'} style={{
background: 'linear-gradient(135deg, rgba(255,255,255,0.08) 0%, rgba(255,255,255,0.02) 100%)', border: '1px solid rgba(255,255,255,0.08)',
borderRadius: '12px',
padding: '12px 16px',
cursor: 'pointer',
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
justifyContent: 'center',
textAlign: 'center'
}}>
<div style={{ color: '#fff', fontSize: '14px', fontWeight: '600', whiteSpace: 'nowrap' }}>藏品录入</div>
<div style={{ color: 'rgba(255,255,255,0.7)', fontSize: '10px', marginTop: '2px' }}>AI识别添加</div>
</div>
<div onClick={() => window.location.hash = '#/add?mode=deal'} style={{
background: 'linear-gradient(135deg, rgba(255,255,255,0.08) 0%, rgba(255,255,255,0.02) 100%)', border: '1px solid rgba(255,255,255,0.08)',
borderRadius: '12px',
padding: '12px 16px',
cursor: 'pointer',
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
justifyContent: 'center',
textAlign: 'center'
}}>
<div style={{ color: '#fff', fontSize: '14px', fontWeight: '600', whiteSpace: 'nowrap' }}>行情录入</div>
<div style={{ color: 'rgba(255,255,255,0.7)', fontSize: '10px', marginTop: '2px' }}>录入成交行情</div>
</div>
<div onClick={() => window.location.hash = '#/news?type=seek'} style={{
background: 'linear-gradient(135deg, rgba(255,255,255,0.08) 0%, rgba(255,255,255,0.02) 100%)', border: '1px solid rgba(255,255,255,0.08)',
borderRadius: '12px',
padding: '12px 16px',
cursor: 'pointer',
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
justifyContent: 'center',
textAlign: 'center'
}}>
<div style={{ color: '#fff', fontSize: '14px', fontWeight: '600', whiteSpace: 'nowrap' }}>发布寻号</div>
<div style={{ color: 'rgba(255,255,255,0.7)', fontSize: '10px', marginTop: '2px' }}>发布寻配需求</div>
</div>
<div onClick={() => window.location.hash = '#/add?mode=manual'} style={{
background: 'linear-gradient(135deg, rgba(255,255,255,0.08) 0%, rgba(255,255,255,0.02) 100%)', border: '1px solid rgba(255,255,255,0.08)',
borderRadius: '12px',
padding: '12px 16px',
cursor: 'pointer',
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
justifyContent: 'center',
textAlign: 'center'
}}>
<div style={{ color: '#fff', fontSize: '14px', fontWeight: '600', whiteSpace: 'nowrap' }}>发布藏品</div>
<div style={{ color: 'rgba(255,255,255,0.7)', fontSize: '10px', marginTop: '2px' }}>手动发布</div>
</div>
</div>
</div>
{/* 寻配号数据 */}
<div style={{ marginBottom: '20px' }}>
<div style={{ color: 'rgba(255,255,255,0.7)', fontSize: '14px', marginBottom: '12px', paddingLeft: '4px' }}>🔍 寻配号数据</div>
<div onClick={() => window.location.hash = '#/news?type=seek'} style={{
background: 'linear-gradient(135deg, rgba(245,158,11,0.15) 0%, rgba(245,158,11,0.05) 100%)',
borderRadius: '12px',
padding: '16px',
border: '1px solid rgba(245,158,11,0.2)',
cursor: 'pointer'
}}>
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(3, 1fr)', gap: '12px', textAlign: 'center' }}>
<div>
<div style={{ color: '#fbbf24', fontSize: '18px', fontWeight: '700' }}>{seekStats.seekCount || 0}</div>
<div style={{ color: 'rgba(255,255,255,0.5)', fontSize: '11px' }}>寻号需求</div>
</div>
<div>
<div style={{ color: '#34d399', fontSize: '18px', fontWeight: '700' }}>{seekStats.userMatchedCount || 0}</div>
<div style={{ color: 'rgba(255,255,255,0.5)', fontSize: '11px' }}>我的匹配</div>
</div>
<div>
<div style={{ color: '#a78bfa', fontSize: '18px', fontWeight: '700' }}>{seekStats.totalMatchedCount || 0}</div>
<div style={{ color: 'rgba(255,255,255,0.5)', fontSize: '11px' }}>总共匹配</div>
</div>
</div>
</div>
</div>
{/* 成交行情信息 */}
<div style={{ marginBottom: '20px' }}>
{(() => {
const versions = ['龙钞', '马钞', '蛇钞', '其他']
const packagings = ['标百', '标十', '单张']
return (
<div>
<div style={{ color: 'rgba(255,255,255,0.7)', fontSize: '14px', marginBottom: '12px', paddingLeft: '4px' }}>💰 龙钞成交数据分类汇总均价</div>
<div style={{ background: 'linear-gradient(135deg, rgba(255,255,255,0.08) 0%, rgba(255,255,255,0.02) 100%)', borderRadius: '12px', padding: '16px', border: '1px solid rgba(255,255,255,0.08)' }}>
<div style={{ marginBottom: '16px' }}>
<div style={{ display: 'flex', gap: '12px', flexWrap: 'wrap', marginBottom: '12px' }}>
{versions.map(v => (
<button key={v} onClick={() => {
setDealVersion(v)
//
const token = localStorage.getItem('token')
const headers = token ? { 'Authorization': 'Bearer ' + token } : {}
fetch(`/api/deal/category-stats?version=${v}`, { headers }).then(res => res.json()).then(data => {
setDealCategoryStats(data.data || [])
}).catch(() => {})
}}
style={{ padding: '6px 16px', borderRadius: '8px', border: 'none', cursor: 'pointer',
background: dealVersion === v ? '#3b82f6' : 'rgba(255,255,255,0.1)',
color: '#fff', fontSize: '13px', fontWeight: dealVersion === v ? '600' : '400' }}>
{v}
</button>
))}
</div>
</div>
<div style={{ overflowX: 'auto' }}>
<table style={{ width: '100%', borderCollapse: 'collapse', fontSize: '13px' }}>
<thead>
<tr>
<th style={{ padding: '8px', textAlign: 'left', color: 'rgba(255,255,255,0.5)', borderBottom: '1px solid rgba(255,255,255,0.1)' }}></th>
{packagings.map(p => (
<th key={p} style={{ padding: '8px', textAlign: 'center', color: 'rgba(255,255,255,0.5)', borderBottom: '1px solid rgba(255,255,255,0.1)' }}>{p}</th>
))}
</tr>
</thead>
<tbody>
{dealCategoryStats.length === 0 ? (
<tr>
<td colSpan={4} style={{ padding: '20px', textAlign: 'center', color: 'rgba(255,255,255,0.3)' }}>暂无数据</td>
</tr>
) : (
dealCategoryStats.map(row => (
<tr key={row.category}>
<td style={{ padding: '8px', color: '#fbbf24', fontWeight: '500', borderBottom: '1px solid rgba(255,255,255,0.05)' }}>{row.category}</td>
{packagings.map(pkg => (
<td key={pkg} style={{ padding: '8px', textAlign: 'center', borderBottom: '1px solid rgba(255,255,255,0.05)' }}>
{row[pkg] ? (
<div style={{ color: '#22c55e', fontWeight: '600' }}>
¥{row[pkg].avg.toLocaleString()}
<span style={{ color: 'rgba(255,255,255,0.4)', fontSize: '11px', marginLeft: '4px' }}>({row[pkg].count})</span>
</div>
) : <span style={{ color: 'rgba(255,255,255,0.2)' }}>-</span>}
</td>
))}
</tr>
))
)}
</tbody>
</table>
</div>
</div>
</div>
)
})()}
</div>
{/* 一尘今日数据 */}
<div style={{ marginBottom: '20px' }}>
<div style={{ color: 'rgba(255,255,255,0.7)', fontSize: '14px', marginBottom: '12px', paddingLeft: '4px' }}>📊 一尘今日连体纪念钞数据</div>
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(3, 1fr)', gap: '8px' }}>
<div style={{ background: 'linear-gradient(135deg, rgba(255,255,255,0.08) 0%, rgba(255,255,255,0.02) 100%)', borderRadius: '12px', padding: '12px 8px', border: '1px solid rgba(255,255,255,0.08)', textAlign: 'center' }}>
<div style={{ color: '#60a5fa', fontSize: '20px', fontWeight: '700' }}>{yichensStats.total || 0}</div>
<div style={{ color: 'rgba(255,255,255,0.5)', fontSize: '10px' }}>总帖子</div>
</div>
<div style={{ background: 'linear-gradient(135deg, rgba(255,255,255,0.08) 0%, rgba(255,255,255,0.02) 100%)', borderRadius: '12px', padding: '12px 8px', border: '1px solid rgba(255,255,255,0.08)', textAlign: 'center' }}>
<div style={{ color: '#34d399', fontSize: '20px', fontWeight: '700' }}>{yichensStats.deals || 0}</div>
<div style={{ color: 'rgba(255,255,255,0.5)', fontSize: '10px' }}>出售</div>
</div>
<div style={{ background: 'linear-gradient(135deg, rgba(255,255,255,0.08) 0%, rgba(255,255,255,0.02) 100%)', borderRadius: '12px', padding: '12px 8px', border: '1px solid rgba(255,255,255,0.08)', textAlign: 'center' }}>
<div style={{ color: '#fbbf24', fontSize: '20px', fontWeight: '700' }}>{yichensStats.wants || 0}</div>
<div style={{ color: 'rgba(255,255,255,0.5)', fontSize: '10px' }}>求购</div>
</div>
<div style={{ background: 'linear-gradient(135deg, rgba(255,255,255,0.08) 0%, rgba(255,255,255,0.02) 100%)', borderRadius: '12px', padding: '12px 8px', border: '1px solid rgba(255,255,255,0.08)', textAlign: 'center' }}>
<div style={{ color: '#a78bfa', fontSize: '20px', fontWeight: '700' }}>{yichensStats.dragons || 0}</div>
<div style={{ color: 'rgba(255,255,255,0.5)', fontSize: '10px' }}>龙钞</div>
</div>
<div style={{ background: 'linear-gradient(135deg, rgba(255,255,255,0.08) 0%, rgba(255,255,255,0.02) 100%)', borderRadius: '12px', padding: '12px 8px', border: '1px solid rgba(255,255,255,0.08)', textAlign: 'center' }}>
<div style={{ color: '#f472b6', fontSize: '20px', fontWeight: '700' }}>{yichensStats.horses || 0}</div>
<div style={{ color: 'rgba(255,255,255,0.5)', fontSize: '10px' }}>马钞</div>
</div>
<div style={{ background: 'linear-gradient(135deg, rgba(255,255,255,0.08) 0%, rgba(255,255,255,0.02) 100%)', borderRadius: '12px', padding: '12px 8px', border: '1px solid rgba(255,255,255,0.08)', textAlign: 'center' }}>
<div style={{ color: '#2dd4bf', fontSize: '20px', fontWeight: '700' }}>{yichensStats.tianma || 0}</div>
<div style={{ color: 'rgba(255,255,255,0.5)', fontSize: '10px' }}>天马</div>
</div>
</div>
</div>
{/* 今日龙钞帖子数据统计 */}
<div style={{ marginBottom: '20px' }}>
<div style={{ color: 'rgba(255,255,255,0.7)', fontSize: '14px', marginBottom: '12px', paddingLeft: '4px' }}>🐉 今日龙钞帖子数据统计</div>
<div style={{ background: 'linear-gradient(135deg, rgba(255,255,255,0.08) 0%, rgba(255,255,255,0.02) 100%)', borderRadius: '12px', padding: '16px', border: '1px solid rgba(255,255,255,0.08)' }}>
{/* 表头 */}
<div style={{ display: 'grid', gridTemplateColumns: '60px 1fr 1fr 1fr', gap: '8px', marginBottom: '8px' }}>
<div></div>
<div style={{ color: '#fff', fontSize: '14px', fontWeight: '600', textAlign: 'center' }}>出售</div>
<div style={{ color: '#fff', fontSize: '14px', fontWeight: '600', textAlign: 'center' }}>求购</div>
<div style={{ color: 'rgba(255,255,255,0.7)', fontSize: '14px', fontWeight: '600', textAlign: 'center' }}>合计</div>
</div>
{/* 数据行 */}
<div style={{ display: 'grid', gridTemplateColumns: '60px 1fr 1fr 1fr', gap: '8px', marginBottom: '6px' }}>
<div style={{ color: '#fff', fontSize: '14px', fontWeight: '500' }}>带4</div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: '700', textAlign: 'center' }}>{dragonStats.dai4?.deals || 0}</div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: '700', textAlign: 'center' }}>{dragonStats.dai4?.wants || 0}</div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: '700', textAlign: 'center' }}>{(dragonStats.dai4?.deals || 0) + (dragonStats.dai4?.wants || 0)}</div>
</div>
<div style={{ display: 'grid', gridTemplateColumns: '60px 1fr 1fr 1fr', gap: '8px', marginBottom: '6px' }}>
<div style={{ color: '#fff', fontSize: '14px', fontWeight: '500' }}>带7号</div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: '700', textAlign: 'center' }}>{dragonStats.wu4?.deals || 0}</div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: '700', textAlign: 'center' }}>{dragonStats.wu4?.wants || 0}</div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: '700', textAlign: 'center' }}>{(dragonStats.wu4?.deals || 0) + (dragonStats.wu4?.wants || 0)}</div>
</div>
<div style={{ display: 'grid', gridTemplateColumns: '60px 1fr 1fr 1fr', gap: '8px', marginBottom: '6px' }}>
<div style={{ color: '#fff', fontSize: '14px', fontWeight: '500' }}>无47</div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: '700', textAlign: 'center' }}>{dragonStats.wu47?.deals || 0}</div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: '700', textAlign: 'center' }}>{dragonStats.wu47?.wants || 0}</div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: '700', textAlign: 'center' }}>{(dragonStats.wu47?.deals || 0) + (dragonStats.wu47?.wants || 0)}</div>
</div>
<div style={{ display: 'grid', gridTemplateColumns: '60px 1fr 1fr 1fr', gap: '8px', marginBottom: '6px' }}>
<div style={{ color: '#fff', fontSize: '14px', fontWeight: '500' }}>无247</div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: '700', textAlign: 'center' }}>{dragonStats.wu247?.deals || 0}</div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: '700', textAlign: 'center' }}>{dragonStats.wu247?.wants || 0}</div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: '700', textAlign: 'center' }}>{(dragonStats.wu247?.deals || 0) + (dragonStats.wu247?.wants || 0)}</div>
</div>
<div style={{ display: 'grid', gridTemplateColumns: '60px 1fr 1fr 1fr', gap: '8px' }}>
<div style={{ color: '#fff', fontSize: '14px', fontWeight: '500' }}>无347</div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: '700', textAlign: 'center' }}>{dragonStats.wu347?.deals || 0}</div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: '700', textAlign: 'center' }}>{dragonStats.wu347?.wants || 0}</div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: '700', textAlign: 'center' }}>{(dragonStats.wu347?.deals || 0) + (dragonStats.wu347?.wants || 0)}</div>
</div>
</div>
</div>
{/* 最新一尘发帖 */}
<div>
<div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '12px', paddingLeft: '4px' }}>
<div style={{ color: 'rgba(255,255,255,0.7)', fontSize: '14px' }}>📝 最新一尘发帖</div>
<div onClick={() => window.location.hash = '#/news'} style={{ color: '#3b82f6', fontSize: '12px', cursor: 'pointer' }}>查看全部 </div>
</div>
<div style={{
background: 'rgba(255,255,255,0.03)',
borderRadius: '12px',
border: '1px solid rgba(255,255,255,0.05)',
overflow: 'hidden'
}}>
{recentPosts.length === 0 ? (
<div style={{ padding: '40px', textAlign: 'center', color: 'rgba(255,255,255,0.3)' }}>暂无帖子</div>
) : (
recentPosts.map((item, idx) => (
<div key={item.post_id || idx} onClick={() => window.open(item.url, '_blank')} style={{
padding: '12px 16px',
borderBottom: idx < recentPosts.length - 1 ? '1px solid rgba(255,255,255,0.05)' : 'none',
cursor: 'pointer',
display: 'flex',
justifyContent: 'space-between',
alignItems: 'center'
}}>
<div style={{ flex: 1 }}>
<div style={{ color: '#fff', fontSize: '14px' }}>{item.title || '无标题'}</div>
<div style={{ color: 'rgba(255,255,255,0.4)', fontSize: '12px', marginTop: '2px' }}>{item.category || '-'} · {item.author_username || '未知'} · {item.post_time?.substring(0, 16) || ''}</div>
</div>
<div style={{
color: item.post_type === 'deal' ? '#10b981' : item.post_type === 'want' ? '#f59e0b' : '#8b5cf6',
fontSize: '12px',
padding: '2px 8px',
borderRadius: '4px',
background: item.post_type === 'deal' ? 'rgba(16,185,129,0.2)' : item.post_type === 'want' ? 'rgba(245,158,11,0.2)' : 'rgba(139,92,246,0.2)'
}}>
{item.post_type === 'deal' ? '出售' : item.post_type === 'want' ? '求购' : '其他'}
</div>
</div>
))
)}
</div>
</div>
{/* 底部导航 */}
<div style={{
position: 'fixed',
bottom: '0',
left: '0',
right: '0',
background: 'rgba(15, 23, 42, 0.95)',
borderTop: '1px solid rgba(255,255,255,0.1)',
display: 'flex',
justifyContent: 'space-around',
padding: '12px 0',
backdropFilter: 'blur(10px)'
}}>
{(isAdmin ? [
{ icon: '🏠', label: '首页', hash: '#/', idx: 0 },
{ icon: '📚', label: '藏品', hash: '#/list', idx: 1 },
{ icon: '', label: '录入', hash: '#/ocr', idx: 2 },
{ icon: '📊', label: '统计', hash: '#/stats', idx: 3 },
{ icon: '⚙️', label: '管理', hash: '#/admin', idx: 4 }
] : [
{ icon: '🏠', label: '首页', hash: '#/', idx: 0 },
{ icon: '📚', label: '藏品', hash: '#/list', idx: 1 },
{ icon: '', label: '录入', hash: '#/ocr', idx: 2 },
{ icon: '📊', label: '统计', hash: '#/stats', idx: 3 }
]).map((item) => (
<div key={item.idx} onClick={() => window.location.hash = item.hash} style={{
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
cursor: 'pointer',
color: currentPath === item.hash ? '#fbbf24' : '#64748b'
}}>
<div style={{ fontSize: '18px', fontWeight: currentPath === item.hash ? 'bold' : 'normal' }}>{item.icon}</div>
<div style={{ fontSize: '10px', marginTop: '2px', fontWeight: currentPath === item.hash ? 'bold' : 'normal' }}>{item.label}</div>
</div>
))}
</div>
<div style={{ height: '70px' }}></div>
</div>
)
}

948
frontend/src/pages/List.jsx Normal file
View File

@ -0,0 +1,948 @@
import React, { useState, useEffect } from 'react'
import { APP_VERSION } from '../config/version'
const API_BASE = localStorage.getItem('API_BASE') || ''
export default function List() {
const [collections, setCollections] = useState([])
const [loading, setLoading] = useState(true)
const [filter, setFilter] = useState('')
const [filterType, setFilterType] = useState('')
const urlParams = new URLSearchParams(window.location.hash.split('?')[1] || '')
const urlUserId = urlParams.get('userId') || ''
const [userIdFilter, setUserIdFilter] = useState(urlUserId)
const [sortField, setSortField] = useState('createdAt')
const [sortOrder, setSortOrder] = useState('desc')
const [viewMode, setViewMode] = useState('list')
const [key, setKey] = useState(0)
const [search, setSearch] = useState('')
const [isAdmin, setIsAdmin] = useState(false)
const [page, setPage] = useState(1)
const [pagination, setPagination] = useState({ total: 0, pages: 1 })
const [activeTab, setActiveTab] = useState('collections') // collections-, deals-
const [dealSearch, setDealSearch] = useState('')
const [dealSortField, setDealSortField] = useState('created_at')
const [dealSortOrder, setDealSortOrder] = useState('desc')
const [myDeals, setMyDeals] = useState([])
const [dealsLoading, setDealsLoading] = useState(false)
useEffect(() => {
//
const userStr = localStorage.getItem('user')
if (userStr) {
try {
const user = JSON.parse(userStr)
setIsAdmin(user.role === 'admin')
} catch (e) {}
}
// hash
const handleHashChange = () => {
const params = new URLSearchParams(window.location.hash.split('?')[1] || '')
// filter=category&value= filter=category=
let filterTypeParam = params.get('filter') || ''
let valueParam = params.get('value') || ''
if (filterTypeParam && valueParam) {
// filter=category&value=
setFilterType(filterTypeParam)
setFilter(decodeURIComponent(valueParam))
} else if (filterTypeParam && filterTypeParam.includes('=')) {
// filter=category=
const [type, value] = filterTypeParam.split('=')
setFilterType(type)
setFilter(decodeURIComponent(value))
} else {
setFilter('')
setFilterType('')
}
fetchCollections()
}
handleHashChange()
window.addEventListener('hashchange', handleHashChange)
window.addEventListener('focus', fetchCollections)
return () => {
window.removeEventListener('hashchange', handleHashChange)
window.removeEventListener('focus', fetchCollections)
}
}, [])
//
const fetchMyDeals = async () => {
setDealsLoading(true)
const token = localStorage.getItem('token')
const userStr = localStorage.getItem('user')
if (!token || !userStr) {
setDealsLoading(false)
return
}
try {
const user = JSON.parse(userStr)
const res = await fetch(`${API_BASE}/api/deal/list?user_only=true&page_size=500`, {
headers: { 'Authorization': 'Bearer ' + token }
})
const data = await res.json()
const list = data.data || data || []
setMyDeals(Array.isArray(list) ? list : [])
} catch (e) {
console.error('获取行情失败:', e)
}
setDealsLoading(false)
}
// tab
useEffect(() => {
if (activeTab === 'deals') {
fetchMyDeals()
}
}, [activeTab])
//
const filteredDeals = myDeals.filter(deal => {
if (!dealSearch) return true
const s = dealSearch.toLowerCase().trim()
const fields = [deal.title, deal.content, deal.category, deal.packaging, deal.grading_company, deal.grading_score, deal.deal_no, deal.seller, deal.platform, deal.buyer, deal.deal_price?.toString(), deal.deal_date].filter(v => v).map(v => v.toString().toLowerCase())
return fields.some(f => f.includes(s))
}).sort((a, b) => {
let aVal = a[dealSortField] || ''
let bVal = b[dealSortField] || ''
if (dealSortField === 'created_at') {
aVal = new Date(a.created_at).getTime()
bVal = new Date(b.created_at).getTime()
} else if (dealSortField === 'deal_price') {
aVal = a.deal_price || 0
bVal = b.deal_price || 0
}
if (dealSortOrder === 'asc') return aVal > bVal ? 1 : -1
return aVal < bVal ? 1 : -1
})
const fetchCollections = async () => {
setLoading(true)
const token = localStorage.getItem('token')
try {
// URL
const params = new URLSearchParams(window.location.hash.split('?')[1] || '')
const urlFilterType = params.get('filter') || ''
const urlFilterValue = params.get('value') ? decodeURIComponent(params.get('value')) : ''
let api = '/api/collections?page=' + page + '&limit=100&sortBy=' + sortField + '&sortOrder=' + sortOrder
if (urlFilterType && urlFilterValue) {
api += '&' + urlFilterType + '=' + encodeURIComponent(urlFilterValue)
}
const res = await fetch(api, {
headers: token ? { 'Authorization': 'Bearer ' + token } : {}
})
// 401
if (res.status === 401) {
localStorage.removeItem('token')
localStorage.removeItem('user')
window.location.hash = '#/login'
return
}
const data = await res.json()
// {data: [], pagination: {}}
let list = data.data || data
if (!Array.isArray(list) && list && Array.isArray(list.items)) {
list = list.items
}
//
// IDURL
if (userIdFilter) {
list = list.filter(item => item.userId === userIdFilter || item.userId === userIdFilter.replace(/-/g, ''))
}
if (filterType && filter) {
const fieldMap = {
status: 'status',
category: 'category',
packaging: 'packaging',
rarity: 'rarity',
numberCategory: 'numberCategory',
version: 'version',
gradingCompany: 'gradingCompany',
gradingScore: 'gradingScore',
specialMark: 'specialMark',
profitLoss: 'profitLoss'
}
const field = fieldMap[filterType] || filterType
if (filterType === 'profitLoss') {
//
list = list.filter(item => {
if (item.status !== 'sold') return false //
const totalCost = (item.costPrice || 0) + (item.repairFee || 0) + (item.gradingFee || 0)
const isProfit = item.goalPrice > totalCost
return filter === 'profit' ? isProfit : !isProfit
})
} else {
list = list.filter(item => {
const value = item[field] || item[filterType]
return value === filter
})
}
console.log(`筛选:${filterType} = ${filter}, 结果:${list.length}`)
}
setCollections(list || [])
//
if (data.pagination) {
setPagination({
total: data.pagination.total || 0,
pages: data.pagination.pages || 1
})
}
} catch (e) {
console.error('Fetch collections error:', e)
//
localStorage.removeItem('token')
localStorage.removeItem('user')
window.location.hash = '#/login'
}
setLoading(false)
}
//
useEffect(() => {
if (page > 1) {
fetchCollections()
}
}, [page])
const refresh = () => {
setKey(k => k + 1)
}
useEffect(() => {
window.refreshList = refresh
return () => { delete window.refreshList }
}, [])
const goDetail = (id) => {
// URL
sessionStorage.setItem('lastListUrl', window.location.hash.substring(1))
window.location.hash = '#/detail?id=' + id
}
//
const getFilterLabel = (type) => {
const labels = {
status: '状态',
category: '持仓类型',
packaging: '包装',
rarity: '珍惜度',
version: '版别',
gradingCompany: '评级公司',
gradingScore: '评级分数',
specialMark: '特殊标识',
profitLoss: '盈亏'
}
return labels[type] || type
}
//
const getFilterValueLabel = (type, value) => {
const valueLabels = {
status: {
in_collection: '收藏中',
selling: '出售中',
sold: '已售',
grading: '送评中',
repairing: '修复中',
transit: '在途中',
seeking: '寻号中',
other: '其他'
},
category: {
自持: '自持',
寄存: '寄存',
寄售: '寄售',
共有: '共有',
寻号: '寻号',
其他: '其他'
},
packaging: {
标十: '标十',
标百: '标百',
单张: '单张',
裸钞: '裸钞'
},
rarity: {
通货: '通货',
特色: '特色',
少见: '少见',
稀有: '稀有',
珍品: '珍品',
孤品: '孤品'
},
profitLoss: {
profit: '盈利',
loss: '亏损'
},
isGraded: {
true: '已评级',
false: '未评级'
}
}
const typeLabels = valueLabels[type]
if (typeLabels) {
return typeLabels[value] || value
}
return value
}
const versions = collections && collections.length ? [...new Set(collections.map(c => c.version).filter(v => v))] : []
//
const filteredCollections = collections.filter(c => {
//
if (filter && filterType) {
if (filterType === 'profitLoss') {
if (c.status !== 'sold') return false
if (filter === 'profit') return c.goalPrice > c.costPrice
return c.goalPrice <= c.costPrice
} else if (filterType === 'isGraded') {
if (c.isGraded !== (filter === 'true')) return false
} else if (c[filterType] !== filter) {
return false
}
}
// -
if (search) {
const s = search.toLowerCase().trim()
//
const allFields = [
//
c.name, c.code, c.prefixSerial, c.version,
c.status, c.category, c.packaging, c.rarity,
//
c.gradingCompany, c.gradingScore, c.specialMark,
c.isGraded ? '已评级' : '未评级',
c.threeStar ? '三星' : '',
//
c.targetPrice?.toString(), c.costPrice?.toString(), c.goalPrice?.toString(),
c.repairFee?.toString(), c.gradingFee?.toString(),
//
c.remark, c.purpose, c.material, c.denomination,
c.issueYear, c.issueQuantity, c.serialFeature, c.issuer,
//
c.username || '', c.userId || ''
].filter(v => v !== undefined && v !== null).map(v => v.toString().toLowerCase())
if (!allFields.some(f => f.includes(s))) {
return false
}
}
return true
}).sort((a, b) => {
let aVal = a[sortField]
let bVal = b[sortField]
if (sortField === 'createdAt') {
aVal = new Date(a.createdAt || 0).getTime()
bVal = new Date(b.createdAt || 0).getTime()
} else if (sortField === 'code') {
//
aVal = parseInt(a.code?.replace(/\D/g, '') || '0', 10)
bVal = parseInt(b.code?.replace(/\D/g, '') || '0', 10)
} else if (sortField === 'prefixSerial') {
//
aVal = a.prefixSerial || ''
bVal = b.prefixSerial || ''
} else if (['costPrice', 'targetPrice', 'goalPrice', 'gradingScore'].includes(sortField)) {
//
aVal = parseFloat(aVal) || 0
bVal = parseFloat(bVal) || 0
} else if (sortField === 'rarity') {
//
const rarityOrder = { '通货': 1, '特色': 2, '少见': 3, '稀有': 4, '珍品': 5, '孤品': 6 }
aVal = rarityOrder[aVal] || 0
bVal = rarityOrder[bVal] || 0
} else if (sortField === 'numberCategory') {
//
const numberCategoryOrder = { '无2347': 1, '无347': 2, '无247': 3, '无47': 4, '带7号': 5, '带4号': 6, '其他': 7 }
aVal = numberCategoryOrder[aVal] || 99
bVal = numberCategoryOrder[bVal] || 99
}
if (aVal == null) return 1
if (bVal == null) return -1
if (sortOrder === 'asc') {
return aVal > bVal ? 1 : -1
}
return aVal < bVal ? 1 : -1
})
const clearFilter = () => {
setFilter('')
setFilterType('')
window.location.hash = '#/stats'
}
const getStatusText = (status) => {
const map = {
'in_collection': '收藏中',
'selling': '出售中',
'sold': '已售',
'grading': '送评中',
'repairing': '修复中',
'transit': '在途中',
'seeking': '寻号中',
'other': '其他'
}
return map[status] || status || '-'
}
const getCategoryText = (category) => {
const map = { '自持': '自持', '寄存': '寄存', '寄售': '寄售', '共有': '共有', '其他': '其他' }
return map[category] || category || '自持'
}
const getCategoryColor = (category) => {
const colors = { '自持': '#22c55e', '寄存': '#3b82f6', '寄售': '#f59e0b', '共有': '#8b5cf6', '其他': '#64748b' }
return colors[category] || '#64748b'
}
const getNumberCategoryColor = (cat) => {
const colors = { '无2347': '#8b5cf6', '无347': '#ef4444', '无247': '#fbbf24', '无47': '#3b82f6', '带7号': '#06b6d4', '带4号': '#22c55e', '其他': '#64748b' };
return colors[cat] || '#64748b';
};
const getRarityColor = (rarity) => {
const colors = { '通货': '#22c55e', '特色': '#06b6d4', '少见': '#3b82f6', '稀有': '#ec4899', '珍品': '#ef4444', '孤品': '#8b5cf6' }
return colors[rarity] || '#64748b'
}
const formatPrefixSerial = (serial) => {
if (!serial) return '-'
// J101J + 9
const match = serial.match(/J(\d{9})/)
if (match) return 'J' + match[1]
// J10
return serial.substring(0, 10)
}
const getPackagingColor = (packaging) => {
const colors = { '裸钞': '#22c55e', '单张': '#3b82f6', '标十': '#fbbf24', '标百': '#8b5cf6' }
return colors[packaging] || '#64748b'
}
const getStatusColor = (status) => {
const colors = {
'in_collection': '#22c55e',
'selling': '#f59e0b',
'sold': '#ef4444',
'grading': '#8b5cf6',
'repairing': '#f97316',
'transit': '#06b6d4',
'seeking': '#ec4899',
'other': '#64748b'
}
return colors[status] || '#64748b'
}
const getVersionColor = (version) => {
if (!version) return { bg: 'rgba(255,255,255,0.08)', color: '#94a3b8' }
const v = version.toLowerCase()
if (v.includes('龙')) return { bg: 'linear-gradient(135deg, #fbbf24 0%, #f59e0b 100%)', color: '#1e293b' }
if (v.includes('蛇')) return { bg: 'linear-gradient(135deg, #ec4899 0%, #db2777 100%)', color: '#fff' }
if (v.includes('马')) return { bg: 'linear-gradient(135deg, #ef4444 0%, #dc2626 100%)', color: '#fff' }
if (v.includes('羊')) return { bg: 'linear-gradient(135deg, #f97316 0%, #ea580c 100%)', color: '#fff' }
if (v.includes('猴')) return { bg: 'linear-gradient(135deg, #8b5cf6 0%, #7c3aed 100%)', color: '#fff' }
if (v.includes('鸡')) return { bg: 'linear-gradient(135deg, #f59e0b 0%, #d97706 100%)', color: '#1e293b' }
if (v.includes('狗')) return { bg: 'linear-gradient(135deg, #6366f1 0%, #4f46e5 100%)', color: '#fff' }
if (v.includes('猪')) return { bg: 'linear-gradient(135deg, #ec4899 0%, #be185d 100%)', color: '#fff' }
if (v.includes('鼠')) return { bg: 'linear-gradient(135deg, #64748b 0%, #475569 100%)', color: '#fff' }
if (v.includes('牛')) return { bg: 'linear-gradient(135deg, #22c55e 0%, #16a34a 100%)', color: '#fff' }
if (v.includes('虎')) return { bg: 'linear-gradient(135deg, #f97316 0%, #ea580c 100%)', color: '#fff' }
if (v.includes('兔')) return { bg: 'linear-gradient(135deg, #f43f5e 0%, #e11d48 100%)', color: '#fff' }
return { bg: 'linear-gradient(135deg, #fbbf24 0%, #f59e0b 100%)', color: '#1e293b' }
}
const ListItem = ({ item }) => (
<div onClick={() => goDetail(item.id)} style={{ background: 'rgba(255,255,255,0.03)', border: '1px solid rgba(255,255,255,0.05)', borderRadius: '12px', padding: '10px', marginBottom: '8px', cursor: 'pointer' }}>
{/* 第1行编号 + 冠字号 + 包装(蓝色) | 状态 + 持仓类型 + 珍惜度(紫色) */}
<div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '4px' }}>
<div style={{ display: 'flex', alignItems: 'center', gap: '6px', flexWrap: 'wrap' }}>
<span style={{ color: '#fff', fontSize: '11px', fontWeight: 'normal' }}>{item.code || '-'}</span>
<span style={{ color: '#fbbf24', fontSize: '14px', fontFamily: 'monospace', }}>{formatPrefixSerial(item.prefixSerial)}</span>
{item.packaging && <span style={{ background: getPackagingColor(item.packaging) + '20', color: getPackagingColor(item.packaging), fontSize: '10px', padding: '1px 5px', borderRadius: '3px' }}>{item.packaging}</span>}
{item.numberCategory && <span style={{ color: getNumberCategoryColor(item.numberCategory), fontSize: '9px', padding: '1px 4px', background: getNumberCategoryColor(item.numberCategory) + '20', borderRadius: '2px', marginLeft: '4px' }}>{item.numberCategory}</span>}
</div>
<div style={{ display: 'flex', gap: '3px' }}>
{item.status && <span style={{ color: getStatusColor(item.status), fontSize: '9px', padding: '1px 4px', background: getStatusColor(item.status) + '25', borderRadius: '2px' }}>{getStatusText(item.status)}</span>}
{item.category && <span style={{ color: getCategoryColor(item.category), fontSize: '9px', padding: '1px 4px', background: getCategoryColor(item.category) + '25', borderRadius: '2px' }}>{getCategoryText(item.category)}</span>}
</div>
</div>
{/* 第2行版本(彩色) + 已评级 + 评级公司 + 评级分数 + 三星 + 特殊标识 | 备注 */}
<div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', gap: '2px', flexWrap: 'wrap', marginBottom: '4px' }}>
<div style={{ display: 'flex', alignItems: 'center', gap: '2px', flexWrap: 'wrap' }}>
{item.version && <span style={{ background: getVersionColor(item.version).bg, color: getVersionColor(item.version).color, fontSize: '10px', padding: '1px 5px', borderRadius: '3px' }}>{item.version}</span>}
{item.isGraded && <span style={{ background: 'rgba(6, 182, 212, 0.15)', color: '#06b6d4', fontSize: '9px', padding: '1px 4px', borderRadius: '2px' }}>已评级</span>}
{item.gradingCompany && <span style={{ background: 'rgba(6, 182, 212, 0.15)', color: '#06b6d4', fontSize: '9px', padding: '1px 4px', borderRadius: '2px' }}>{item.gradingCompany.substring(0,4)}</span>}
{item.gradingScore && <span style={{ background: 'rgba(249, 115, 22, 0.2)', color: '#f97316', fontSize: '9px', padding: '1px 4px', borderRadius: '2px', }}>{item.gradingScore}</span>}
{item.threeStar && <span style={{ background: 'rgba(6, 182, 212, 0.15)', color: '#06b6d4', fontSize: '9px', padding: '1px 4px', borderRadius: '2px' }}>三星</span>}
{item.specialMark && <span style={{ background: 'rgba(139, 92, 246, 0.15)', color: '#a78bfa', fontSize: '9px', padding: '1px 4px', borderRadius: '2px' }}>{item.specialMark}</span>}
</div>
<div style={{ display: 'flex', gap: '2px', marginLeft: 'auto' }}>
{item.rarity && <span style={{ color: getRarityColor(item.rarity), fontSize: '9px', padding: '1px 4px', background: getRarityColor(item.rarity) + '20', borderRadius: '2px' }}>{item.rarity}</span>}
{item.remark && <span style={{ background: 'rgba(100,116,139,0.2)', color: '#94a3b8', fontSize: '9px', padding: '1px 4px', borderRadius: '2px', maxWidth: '80px', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>{item.remark}</span>}
</div>
</div>
{/* 第3行成本 + 修复 + 评级 | 目标 + 出售 */}
<div style={{ display: 'flex', justifyContent: 'space-between', fontSize: '10px', color: '#94a3b8', paddingTop: '4px', borderTop: '1px solid rgba(255,255,255,0.05)' }}>
<div style={{ display: 'flex', gap: '8px' }}>
{item.costPrice && <span>成本: <span style={{ color: '#e2e8f0' }}>¥{item.costPrice}</span></span>}
{item.repairFee && <span>修复: <span style={{ color: '#e2e8f0' }}>¥{item.repairFee}</span></span>}
{item.gradingFee && <span>评级: <span style={{ color: '#e2e8f0' }}>¥{item.gradingFee}</span></span>}
</div>
<div style={{ display: 'flex', gap: '8px' }}>
{item.targetPrice && <span>目标: <span style={{ color: '#fbbf24' }}>¥{item.targetPrice}</span></span>}
{item.goalPrice && <span>出售: <span style={{ color: '#4ade80' }}>¥{item.goalPrice}</span></span>}
</div>
</div>
</div>
)
return (
<div style={{ minHeight: '100vh', overflowY: 'auto', background: '#0f172a', paddingBottom: '70px' }}>
<div style={{ padding: '20px', background: 'rgba(255,255,255,0.02)', borderBottom: '1px solid rgba(255,255,255,0.05)' }}>
<div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', marginBottom: '16px' }}>
<div style={{ color: '#fff', fontSize: '20px' }}>
<div style={{ display: 'flex', gap: '8px' }}>
<button onClick={() => setActiveTab('collections')}
style={{ padding: '6px 16px', background: activeTab === 'collections' ? '#fbbf24' : 'rgba(255,255,255,0.05)', color: activeTab === 'collections' ? '#1e293b' : '#fff', border: 'none', borderRadius: '6px', fontSize: '13px', fontWeight: '600', cursor: 'pointer' }}>
我的藏品 ({filteredCollections.length})
</button>
<button onClick={() => setActiveTab('deals')}
style={{ padding: '6px 16px', background: activeTab === 'deals' ? '#fbbf24' : 'rgba(255,255,255,0.05)', color: activeTab === 'deals' ? '#1e293b' : '#fff', border: 'none', borderRadius: '6px', fontSize: '13px', fontWeight: '600', cursor: 'pointer' }}>
我的行情 ({filteredDeals.length})
</button>
</div>
</div>
<div style={{ display: 'flex', alignItems: 'center', gap: '12px' }}>
{filter && filterType && (
<button
onClick={() => {
setFilter('')
setFilterType('')
window.location.hash = '#/list'
}}
style={{ background: 'rgba(239, 68, 68, 0.2)', color: '#ef4444', border: 'none', borderRadius: '6px', padding: '4px 10px', fontSize: '12px', cursor: 'pointer' }}
>
清除筛选
</button>
)}
<div style={{ color: 'rgba(255,255,255,0.3)', fontSize: '11px' }}>v{APP_VERSION}</div>
</div>
</div>
{filter && filterType && (
<div style={{ background: 'rgba(59, 130, 246, 0.1)', border: '1px solid rgba(59, 130, 246, 0.3)', borderRadius: '8px', padding: '12px', marginBottom: '16px' }}>
<div style={{ color: '#60a5fa', fontSize: '12px', }}>当前筛选</div>
<div style={{ color: '#fff', fontSize: '14px', marginTop: '4px' }}>
{getFilterLabel(filterType)} = <span style={{ color: '#fbbf24', }}>{getFilterValueLabel(filterType, filter)}</span>
</div>
</div>
)}
{activeTab === 'collections' && (
<>
{/* 搜索框 - 全字段搜索 */}
<div style={{ position: 'relative', marginBottom: '16px' }}>
<input type="text"
placeholder="🔍 搜索任意字段:名称、编号、冠字号、版别、评级公司、分数、价格..."
value={search}
onChange={e => setSearch(e.target.value)}
style={{
background: 'rgba(255,255,255,0.05)',
border: search ? '1px solid rgba(59, 130, 246, 0.5)' : '1px solid rgba(255,255,255,0.1)',
color: '#fff',
width: '100%',
boxSizing: 'border-box',
padding: '4px 40px 4px 8px',
borderRadius: '12px',
fontSize: '14px',
outline: 'none',
transition: 'border-color 0.2s'
}}
/>
{search && (
<button
onClick={() => setSearch('')}
style={{
position: 'absolute',
right: '12px',
top: '50%',
transform: 'translateY(-50%)',
background: 'rgba(255,255,255,0.1)',
border: 'none',
borderRadius: '50%',
width: '24px',
height: '24px',
color: '#fff',
fontSize: '16px',
cursor: 'pointer',
display: 'flex',
alignItems: 'center',
justifyContent: 'flex-start'
}}
>
</button>
)}
</div>
{/* 排序表头按钮 */}
<div style={{ display: 'flex', gap: '6px', alignItems: 'center', flexWrap: 'wrap', marginBottom: '12px' }}>
<span style={{ color: '#94a3b8', fontSize: '12px', marginRight: '2px' }}>排序:</span>
{[
{ key: 'code', label: '编号' },
{ key: 'rarity', label: '珍惜度' },
{ key: 'numberCategory', label: '号码分类' },
{ key: 'packaging', label: '包装类型' },
].map(item => (
<div key={item.key} onClick={() => {
if (sortField === item.key) {
setSortOrder(sortOrder === 'asc' ? 'desc' : 'asc')
} else {
setSortField(item.key)
setSortOrder('desc')
}
}} style={{
padding: '4px 8px',
borderRadius: '8px',
fontSize: '12px',
cursor: 'pointer',
background: sortField === item.key ? (sortOrder === 'asc' ? '#22c55e' : '#fbbf24') : 'rgba(255,255,255,0.08)',
color: sortField === item.key ? '#fff' : '#94a3b8',
fontWeight: sortField === item.key ? 'bold' : 'normal',
border: sortField === item.key ? 'none' : '1px solid rgba(255,255,255,0.1)'
}}>
{item.label} {sortField === item.key && (sortOrder === 'asc' ? '↑' : '↓')}
</div>
))}
</div>
</>
)}
{/* 分页组件 - 仅在藏品tab下显示 */}
{activeTab === 'collections' && pagination.pages > 1 && (
<div style={{ display: 'flex', gap: '6px', alignItems: 'center', justifyContent: 'flex-start', marginBottom: '12px', padding: '8px', background: 'rgba(255,255,255,0.03)', borderRadius: '8px' }}>
<button onClick={() => { setPage(Math.max(1, page - 1)) }} disabled={page === 1} style={{ padding: '4px 10px', borderRadius: '6px', border: 'none', background: page === 1 ? 'rgba(255,255,255,0.1)' : '#3b82f6', color: '#fff', cursor: page === 1 ? 'not-allowed' : 'pointer', opacity: page === 1 ? 0.5 : 1 }}>上一页</button>
{Array.from({ length: Math.min(5, pagination.pages) }, (_, i) => {
let startPage = Math.max(1, page - 2)
return <button key={i} onClick={() => { setPage(startPage + i) }} style={{ padding: '4px 8px', borderRadius: '6px', border: 'none', background: page === startPage + i ? '#3b82f6' : 'rgba(255,255,255,0.08)', color: '#fff', cursor: 'pointer' }}>{startPage + i}</button>
})}
<button onClick={() => { setPage(Math.min(pagination.pages, page + 1)) }} disabled={page === pagination.pages} style={{ padding: '4px 10px', borderRadius: '6px', border: 'none', background: page === pagination.pages ? 'rgba(255,255,255,0.1)' : '#3b82f6', color: '#fff', cursor: page === pagination.pages ? 'not-allowed' : 'pointer', opacity: page === pagination.pages ? 0.5 : 1 }}>下一页</button>
<span style={{ color: '#94a3b8', fontSize: '11px', marginLeft: '8px' }}>{pagination.total}</span>
</div>
)}
</div>
<div style={{ padding: '16px' }}>
{/* 行情tab内容 */}
{activeTab === 'deals' && (
<div>
{/* 行情搜索框 */}
<div style={{ marginBottom: '12px' }}>
<input type="text"
placeholder="🔍 搜索行情..."
value={dealSearch}
onChange={e => setDealSearch(e.target.value)}
style={{
width: '100%',
background: 'rgba(255,255,255,0.05)',
border: '1px solid rgba(255,255,255,0.1)',
color: '#fff',
padding: '10px 12px',
borderRadius: '8px',
fontSize: '14px',
outline: 'none',
boxSizing: 'border-box'
}}
/>
</div>
{dealsLoading ? (
<div style={{ textAlign: 'center', padding: '60px', color: '#64748b' }}>加载中...</div>
) : filteredDeals.length === 0 ? (
<div style={{ textAlign: 'center', padding: '60px 0' }}>
<div style={{ fontSize: '50px', opacity: 0.3 }}>📊</div>
<div style={{ color: '#64748b', marginTop: '16px' }}>{dealSearch ? '没有匹配的行情' : '暂无行情记录'}</div>
</div>
) : (
<div style={{ display: 'flex', flexDirection: 'column', gap: '10px' }}>
{filteredDeals.map(deal => (
<DealListItem key={deal.id} deal={deal} onRefresh={fetchMyDeals} />
))}
</div>
)}
</div>
)}
{/* 藏品tab内容 */}
{activeTab === 'collections' && (
<>
{loading ? (
<div style={{ textAlign: 'center', padding: '60px', color: '#64748b' }}>加载中...</div>
) : filteredCollections.length === 0 ? (
<div style={{ textAlign: 'center', padding: '60px 0' }}><div style={{ fontSize: '50px', opacity: 0.3 }}>📭</div><div style={{ color: '#64748b', marginTop: '16px' }}>{filter ? '暂无符合筛选条件的藏品' : '暂无藏品'}</div></div>
) : viewMode === 'grid' ? (
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(2, 1fr)', gap: '12px' }}>
{filteredCollections.map(item => (
<div key={item.id} onClick={() => goDetail(item.id)} style={{ background: 'rgba(255,255,255,0.03)', border: '1px solid rgba(255,255,255,0.05)', borderRadius: '12px', padding: '12px', cursor: 'pointer' }}>
<div style={{ height: '80px', background: 'rgba(255,255,255,0.03)', borderRadius: '8px', display: 'flex', alignItems: 'center', justifyContent: 'flex-start', fontSize: '32px', marginBottom: '10px' }}>🐉</div>
<div style={{ color: '#fff', fontSize: '11px', fontWeight: 'normal' }}>{item.code || '-'}</div>
<div style={{ color: '#fbbf24', fontSize: '11px', fontFamily: 'monospace', marginTop: '2px' }}>{formatPrefixSerial(item.prefixSerial)}</div>
<div style={{ display: 'flex', gap: '2px', marginTop: '6px', flexWrap: 'wrap' }}>
{item.gradingScore && <span style={{ color: '#fbbf24', fontSize: '11px', }}>{item.gradingScore}</span>}
{item.threeStar && <span style={{ color: '#fbbf24', fontSize: '10px' }}></span>}
</div>
</div>
))}
</div>
) : (
filteredCollections.map(item => <ListItem key={item.id} item={item} />)
)}
</>
)}
</div>
</div>
)
}
//
function DealListItem({ deal, onRefresh }) {
const [expanded, setExpanded] = useState(false)
const [editing, setEditing] = useState(false)
const [editForm, setEditForm] = useState({})
const API_BASE = localStorage.getItem('API_BASE') || ''
const openEdit = () => {
// content
let platform = '', seller = '', buyer = ''
if (deal.content) {
const platformMatch = deal.content.match(/平台:\s*([^\n]+)/)
const sellerMatch = deal.content.match(/出售者:\s*([^\n]+)/)
const buyerMatch = deal.content.match(/购买者:\s*([^\n]+)/)
if (platformMatch) platform = platformMatch[1].trim()
if (sellerMatch) seller = sellerMatch[1].trim()
if (buyerMatch) buyer = buyerMatch[1].trim()
}
setEditForm({
title: deal.title,
content: deal.content,
deal_price: deal.deal_price,
deal_date: deal.deal_date ? (typeof deal.deal_date === 'string' ? deal.deal_date.split('T')[0] : '') : '',
packaging: deal.packaging || '单张',
is_graded: deal.is_graded || false,
grading_company: deal.grading_company || '',
grading_score: deal.grading_score || '',
category: deal.category || '',
deal_no: deal.deal_no || '',
platform: platform,
seller: seller,
buyer: buyer
})
setEditing(true)
}
const saveEdit = async () => {
const token = localStorage.getItem('token')
try {
await fetch(`${API_BASE}/api/deal/${deal.id}`, {
method: 'PUT',
headers: { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' },
body: JSON.stringify(editForm)
})
setEditing(false)
onRefresh()
} catch(e) { alert('保存失败') }
}
const deleteDeal = async () => {
if (!confirm('确定删除这条行情?')) return
const token = localStorage.getItem('token')
try {
await fetch(`${API_BASE}/api/deal/${deal.id}`, {
method: 'DELETE',
headers: { 'Authorization': `Bearer ${token}` }
})
onRefresh()
} catch(e) { alert('删除失败') }
}
return (
<div style={{ background: 'rgba(255,255,255,0.05)', borderRadius: '10px', padding: '12px', border: '1px solid rgba(255,255,255,0.1)' }}>
{/* 简要展示 - 两行显示关键信息 */}
<div onClick={() => setExpanded(!expanded)} style={{ cursor: 'pointer', padding: '10px', background: 'rgba(0,0,0,0.2)', borderRadius: '8px' }}>
{/* 第一行:成交日期(月-日)+ 冠字号 + 包装 + 评级分数 + 价格 */}
<div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '6px', flexWrap: 'wrap', gap: '4px' }}>
{deal.deal_date && <span style={{ color: '#64748b', fontSize: '11px' }}>{deal.deal_date.slice(5)}</span>}
<span style={{ color: '#fbbf24', fontSize: '13px', fontFamily: 'monospace' }}>{deal.title?.split('-')[0] || '-'}</span>
{deal.packaging && <span style={{ background: 'rgba(139,92,246,0.15)', color: '#a78bfa', fontSize: '10px', padding: '2px 6px', borderRadius: '4px' }}>{deal.packaging}</span>}
{deal.grading_company && <span style={{ background: 'rgba(6,182,212,0.15)', color: '#06b6d4', fontSize: '10px', padding: '2px 6px', borderRadius: '4px' }}>{deal.grading_score}</span>}
<span style={{ color: '#22c55e', fontSize: '14px', fontWeight: 'bold' }}>¥{deal.deal_price?.toLocaleString()}</span>
</div>
{/* 第二行:编号 + 分类 + 大小号 + 展开箭头 */}
<div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
<div style={{ display: 'flex', gap: '6px', alignItems: 'center' }}>
{deal.deal_no && <span style={{ color: '#fff', fontSize: '10px' }}>{deal.deal_no}</span>}
{deal.category && <span style={{ background: 'rgba(59,130,246,0.15)', color: '#60a5fa', fontSize: '10px', padding: '2px 6px', borderRadius: '4px' }}>{deal.category}</span>}
{deal.content && (() => {
const sizeMatch = deal.content.match(/大小号:\s*([^\n]+)/)
return sizeMatch && <span style={{ background: 'rgba(34,197,94,0.15)', color: '#22c55e', fontSize: '10px', padding: '2px 6px', borderRadius: '4px' }}>{sizeMatch[1]}</span>
})()}
</div>
<span style={{ color: '#64748b', fontSize: '12px' }}>{expanded ? '▲ 收起' : '▼展开'}</span>
</div>
</div>
{/* 展开详情 */}
{expanded && (
<div style={{ marginTop: '12px', paddingTop: '12px', borderTop: '1px solid rgba(255,255,255,0.1)' }}>
{editing ? (
<div style={{ display: 'flex', flexDirection: 'column', gap: '12px' }}>
{/* 冠字号 */}
<div>
<div style={{ fontSize: '11px', color: '#64748b', marginBottom: '4px' }}>冠字号</div>
<input value={editForm.title?.split('-')[0] || ''} onChange={e => setEditForm({...editForm, title: `${e.target.value}${editForm.deal_price}`})} style={{ width: '100%', padding: '10px', background: 'rgba(0,0,0,0.3)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#fbbf24', fontSize: '14px', fontFamily: 'monospace' }} />
</div>
{/* 价格和日期 */}
<div style={{ display: 'flex', gap: '8px' }}>
<div style={{ flex: 1 }}>
<div style={{ fontSize: '11px', color: '#64748b', marginBottom: '4px' }}>价格</div>
<input type="number" value={editForm.deal_price} onChange={e => {
const val = parseFloat(e.target.value) || 0
const serial = editForm.title?.split('-')[0] || ''
setEditForm({...editForm, deal_price: val, title: `${serial}${val}`})
}} style={{ width: '100%', padding: '10px', background: 'rgba(0,0,0,0.3)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#22c55e', fontSize: '14px' }} />
</div>
<div style={{ flex: 1 }}>
<div style={{ fontSize: '11px', color: '#64748b', marginBottom: '4px' }}>日期</div>
<input type="date" value={editForm.deal_date} onChange={e => setEditForm({...editForm, deal_date: e.target.value})} style={{ width: '100%', padding: '10px', background: 'rgba(0,0,0,0.3)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#fff', fontSize: '14px' }} />
</div>
</div>
{/* 包装和分类 */}
<div style={{ display: 'flex', gap: '8px' }}>
<div style={{ flex: 1 }}>
<div style={{ fontSize: '11px', color: '#64748b', marginBottom: '4px' }}>包装</div>
<select value={editForm.packaging} onChange={e => setEditForm({...editForm, packaging: e.target.value})} style={{ width: '100%', padding: '10px', background: 'rgba(0,0,0,0.3)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#fff', fontSize: '13px' }}>
<option value="单张">单张</option>
<option value="标十">标十</option>
<option value="标百">标百</option>
</select>
</div>
<div style={{ flex: 1 }}>
<div style={{ fontSize: '11px', color: '#64748b', marginBottom: '4px' }}>分类</div>
<input value={editForm.category || ''} onChange={e => setEditForm({...editForm, category: e.target.value})} style={{ width: '100%', padding: '10px', background: 'rgba(0,0,0,0.3)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#fff', fontSize: '13px' }} />
</div>
</div>
{/* 评级 */}
<div style={{ display: 'flex', gap: '8px' }}>
<div style={{ flex: 1 }}>
<div style={{ fontSize: '11px', color: '#64748b', marginBottom: '4px' }}>评级机构</div>
<select value={editForm.grading_company || ''} onChange={e => setEditForm({...editForm, grading_company: e.target.value, is_graded: !!e.target.value})} style={{ width: '100%', padding: '10px', background: 'rgba(0,0,0,0.3)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#fff', fontSize: '13px' }}>
<option value="">未评级</option>
<option value="PCGS">PCGS</option>
<option value="PMG">PMG</option>
<option value="ACG">ACG</option>
<option value="爱藏">爱藏</option>
</select>
</div>
<div style={{ flex: 1 }}>
<div style={{ fontSize: '11px', color: '#64748b', marginBottom: '4px' }}>评级分数</div>
<input value={editForm.grading_score || ''} onChange={e => setEditForm({...editForm, grading_score: e.target.value})} placeholder="如: PC69, 67+" style={{ width: '100%', padding: '10px', background: 'rgba(0,0,0,0.3)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#06b6d4', fontSize: '13px' }} />
</div>
</div>
{/* 平台和出售者购买者 */}
<div>
<div style={{ fontSize: '11px', color: '#64748b', marginBottom: '4px' }}>平台</div>
<select value={editForm.platform || ''} onChange={e => setEditForm({...editForm, platform: e.target.value})} style={{ width: '100%', padding: '10px', background: 'rgba(0,0,0,0.3)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#fff', fontSize: '13px' }}>
<option value="">请选择</option>
<option value="淘宝">淘宝</option>
<option value="咸鱼">咸鱼</option>
<option value="抖音">抖音</option>
<option value="快手">快手</option>
<option value="微拍堂">微拍堂</option>
<option value="拼多多">拼多多</option>
<option value="一尘">一尘</option>
<option value="爱藏">爱藏</option>
<option value="其他">其他</option>
</select>
</div>
<div style={{ display: 'flex', gap: '8px' }}>
<div style={{ flex: 1 }}>
<div style={{ fontSize: '11px', color: '#64748b', marginBottom: '4px' }}>出售者</div>
<input value={editForm.seller || ''} onChange={e => setEditForm({...editForm, seller: e.target.value})} placeholder="请输入出售者" style={{ width: '100%', padding: '10px', background: 'rgba(0,0,0,0.3)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#fff', fontSize: '13px' }} />
</div>
<div style={{ flex: 1 }}>
<div style={{ fontSize: '11px', color: '#64748b', marginBottom: '4px' }}>购买者</div>
<input value={editForm.buyer || ''} onChange={e => setEditForm({...editForm, buyer: e.target.value})} placeholder="请输入购买者" style={{ width: '100%', padding: '10px', background: 'rgba(0,0,0,0.3)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#fff', fontSize: '13px' }} />
</div>
</div>
{/* 备注 */}
<div>
<div style={{ fontSize: '11px', color: '#64748b', marginBottom: '4px' }}>备注</div>
<textarea value={editForm.content || ''} onChange={e => setEditForm({...editForm, content: e.target.value})} rows={2} style={{ width: '100%', padding: '10px', background: 'rgba(0,0,0,0.3)', border: '1px solid rgba(255,255,255,0.1)', borderRadius: '6px', color: '#fff', fontSize: '13px', boxSizing: 'border-box' }} />
</div>
{/* 保存取消按钮 */}
<div style={{ display: 'flex', gap: '8px' }}>
<button onClick={saveEdit} style={{ flex: 1, padding: '12px', background: '#22c55e', color: '#fff', border: 'none', borderRadius: '8px', fontSize: '14px', fontWeight: '600', cursor: 'pointer' }}>保存</button>
<button onClick={() => setEditing(false)} style={{ flex: 1, padding: '12px', background: '#64748b', color: '#fff', border: 'none', borderRadius: '8px', fontSize: '14px', fontWeight: '600', cursor: 'pointer' }}>取消</button>
</div>
</div>
) : (
<div>
<div style={{ fontSize: '12px', color: '#94a3b8', marginBottom: '8px' }}>
{deal.deal_no && <div>编号: <span style={{ color: '#fbbf24' }}>{deal.deal_no}</span></div>}
<div>冠字号: <span style={{ color: '#fbbf24' }}>{deal.title?.split('-')[0] || '-'}</span></div>
<div>价格: <span style={{ color: '#22c55e' }}>¥{deal.deal_price?.toLocaleString()}</span></div>
<div>日期: {deal.deal_date}</div>
<div>包装: {deal.packaging || '单张'}</div>
<div>分类: {deal.category || '-'}</div>
<div>评级: {deal.grading_company ? `${deal.grading_company} ${deal.grading_score || ''}` : '未评级'}</div>
{deal.content && (() => {
const platformMatch = deal.content.match(/平台:\s*([^\n]+)/)
const sellerMatch = deal.content.match(/出售者:\s*([^\n]+)/)
const buyerMatch = deal.content.match(/购买者:\s*([^\n]+)/)
const sizeMatch = deal.content.match(/大小号:\s*([^\n]+)/)
const tailMatch = deal.content.match(/尾号:\s*([^\n]+)/)
return (
<div style={{ marginTop: '4px' }}>
{platformMatch && <div>平台: {platformMatch[1]}</div>}
{sellerMatch && <div>出售者: {sellerMatch[1]}</div>}
{buyerMatch && buyerMatch[1].trim() !== '-' && <div>购买者: {buyerMatch[1]}</div>}
{tailMatch && <div>尾号: {tailMatch[1]}</div>}
{sizeMatch && <div>大小号: <span style={{ color: '#60a5fa' }}>{sizeMatch[1]}</span></div>}
</div>
)
})()}
{deal.content && <div style={{ marginTop: '8px', color: '#64748b', fontSize: '11px' }}>{deal.content}</div>}
</div>
<div style={{ display: 'flex', gap: '8px', marginTop: '12px' }}>
<button onClick={openEdit} style={{ flex: 1, padding: '8px', background: 'rgba(59,130,246,0.2)', color: '#60a5fa', border: 'none', borderRadius: '6px', cursor: 'pointer', fontSize: '12px' }}>编辑</button>
<button onClick={deleteDeal} style={{ flex: 1, padding: '8px', background: 'rgba(239,68,68,0.2)', color: '#ef4444', border: 'none', borderRadius: '6px', cursor: 'pointer', fontSize: '12px' }}>删除</button>
</div>
</div>
)}
</div>
)}
</div>
)
}

View File

@ -0,0 +1,695 @@
import React, { useState, useEffect } from 'react'
import { APP_VERSION } from '../config/version'
import { api } from '../utils/api'
import { ErrorCodes } from '../utils/errorCodes'
export default function Login() {
const [username, setUsername] = useState('')
const [password, setPassword] = useState('')
const [loading, setLoading] = useState(false)
const [error, setError] = useState('')
const [captcha, setCaptcha] = useState({ num1: 0, num2: 0, answer: '' })
//
const [showRegister, setShowRegister] = useState(false)
const [registerData, setRegisterData] = useState({ agreeTerms: false,
username: '',
password: '',
confirmPassword: '',
email: '',
phone: '',
verifyCode: '',
inviteCode: ''
})
const [registerLoading, setRegisterLoading] = useState(false)
const [registerError, setRegisterError] = useState('')
//
const [sendingCode, setSendingCode] = useState(false)
const [codeCountdown, setCodeCountdown] = useState(0)
const [codeSent, setCodeSent] = useState(false)
//
useEffect(() => {
generateCaptcha()
}, [])
//
useEffect(() => {
if (codeCountdown > 0) {
const timer = setTimeout(() => setCodeCountdown(codeCountdown - 1), 1000)
return () => clearTimeout(timer)
}
}, [codeCountdown])
const generateCaptcha = () => {
const num1 = Math.floor(Math.random() * 10)
const num2 = Math.floor(Math.random() * 10)
setCaptcha({ num1, num2, answer: '' })
}
//
const handleSendCode = async () => {
if (!registerData.phone) {
setRegisterError('请先输入手机号')
return
}
//
const phoneRegex = /^1[3-9]\d{9}$/
if (!phoneRegex.test(registerData.phone)) {
setRegisterError('请输入正确的手机号')
return
}
setSendingCode(true)
setRegisterError('')
try {
const res = await fetch('/api/auth/send-verification-code', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({ phone: registerData.phone })
})
const data = await res.json()
if (data.success) {
setCodeSent(true)
setCodeCountdown(60)
setRegisterError('')
} else {
setRegisterError(data.message || '发送失败')
}
} catch (err) {
setRegisterError('发送失败,请稍后重试')
} finally {
setSendingCode(false)
}
}
//
const handleRegister = async () => {
//
if (!registerData.username || !registerData.password) {
setRegisterError('用户名和密码为必填项')
return
}
if (!registerData.agreeTerms) {
setRegisterError('请先同意用户协议')
return
}
if (registerData.username.length < 2) {
setRegisterError('用户名至少 2 个字符')
return
}
if (registerData.password.length < 8 || !/[A-Z]/.test(registerData.password) || !/[a-z]/.test(registerData.password) || !/[0-9]/.test(registerData.password)) {
setRegisterError('密码至少8位需包含大写、小写、数字')
return
}
if (registerData.password !== registerData.confirmPassword) {
setRegisterError('两次输入的密码不一致')
return
}
//
if (!registerData.phone) {
setRegisterError('手机号为必填项')
return
}
const phoneRegex = /^1[3-9]\d{9}$/
if (!phoneRegex.test(registerData.phone)) {
setRegisterError('请输入正确的手机号')
return
}
//
if (!registerData.verifyCode) {
setRegisterError('请输入短信获取')
return
}
setRegisterLoading(true)
setRegisterError('')
try {
const payload = {
username: registerData.username,
password: registerData.password,
phone: registerData.phone,
verifyCode: registerData.verifyCode
}
if (registerData.email) {
payload.email = registerData.email
}
if (registerData.inviteCode) {
payload.inviteCode = registerData.inviteCode
}
const res = await fetch('/api/auth/register', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify(payload)
})
const data = await res.json()
if (!res.ok) {
throw new Error(data.detail || data.error?.message || '注册失败')
}
alert('注册成功!请登录')
setShowRegister(false)
setRegisterData({ username: '', password: '', confirmPassword: '', email: '', phone: '', verifyCode: '', inviteCode: '' })
setCodeSent(false)
setCodeCountdown(0)
generateCaptcha()
} catch (err) {
console.error('注册错误:', err)
setRegisterError(err.message || '注册失败')
} finally {
setRegisterLoading(false)
}
}
const handleLogin = async () => {
//
if (!username || !password) {
setError(ErrorCodes.E00020.message)
return
}
if (username.length < 2) {
setError(ErrorCodes.E00021.message)
return
}
//
const expectedAnswer = captcha.num1 + captcha.num2
if (!captcha.answer || Number(captcha.answer) !== expectedAnswer) {
setError(ErrorCodes.E00012.message)
return
}
setLoading(true)
setError('')
try {
console.log('开始登录...')
const loginData = await api.auth.login(username, password)
console.log('登录响应:', loginData)
if (!loginData.access_token) {
throw new Error('登录响应中没有 access_token')
}
localStorage.setItem('token', loginData.access_token)
console.log('Token 已保存')
const userData = await api.user.me()
console.log('用户信息:', userData)
localStorage.setItem('user', JSON.stringify(userData))
console.log('用户信息已保存')
// React
window.location.href = '/'
console.log('跳转首页')
} catch (err) {
console.error('登录错误:', err)
const errorCode = err.code || 'E00000'
const errorMsg = err.message || '登录失败'
setError(`${errorCode}: ${errorMsg}`)
} finally {
setLoading(false)
}
}
return (
<div style={{
minHeight: '100vh',
background: 'linear-gradient(135deg, #0f172a 0%, #1e293b 50%, #0f172a 100%)',
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
justifyContent: 'center',
padding: '20px'
}}>
{/* Logo - 龙型 + 甲辰收藏文字 (橙色圆形设计) */}
<div style={{ marginBottom: '40px', textAlign: 'center' }}>
<img
src="/static/images/jiachenlong-logo.png?v=1"
alt="甲辰收藏"
style={{
width: '200px',
height: '200px',
marginBottom: '12px',
borderRadius: '50%',
boxShadow: '0 0 40px rgba(251, 191, 36, 0.4)',
background: '#fff'
}}
/>
<p style={{ color: 'rgba(255,255,255,0.6)', fontSize: '14px', margin: 0 }}>生肖纪念钞管理系统</p>
</div>
{/* 登录表单 */}
<div style={{
width: '100%',
maxWidth: '320px',
background: 'rgba(30, 41, 59, 0.8)',
borderRadius: '16px',
padding: '24px',
border: '1px solid rgba(255,255,255,0.1)'
}}>
<h2 style={{ color: '#fff', fontSize: '20px', fontWeight: '600', marginBottom: '24px', textAlign: 'center' }}>
欢迎回来 👋
</h2>
{error && (
<div style={{
background: 'rgba(239, 68, 68, 0.2)',
border: '1px solid rgba(239, 68, 68, 0.5)',
borderRadius: '8px',
padding: '12px',
marginBottom: '16px',
color: '#fca5a5',
fontSize: '13px'
}}>
{error}
</div>
)}
{/* 用户名 */}
<div style={{ marginBottom: '16px' }}>
<input
type="text"
value={username}
onChange={(e) => setUsername(e.target.value)}
placeholder="用户名"
style={{
width: '100%',
padding: '14px',
borderRadius: '8px',
border: '1px solid rgba(255,255,255,0.2)',
background: 'rgba(255,255,255,0.05)',
color: '#fff',
fontSize: '16px',
outline: 'none'
}}
/>
</div>
{/* 密码 */}
<div style={{ marginBottom: '20px' }}>
<input
type="password"
value={password}
onChange={(e) => setPassword(e.target.value)}
placeholder="密码"
style={{
width: '100%',
padding: '14px',
borderRadius: '8px',
border: '1px solid rgba(255,255,255,0.2)',
background: 'rgba(255,255,255,0.05)',
color: '#fff',
fontSize: '16px',
outline: 'none'
}}
/>
</div>
{/* 获取 */}
<div style={{ marginBottom: '24px' }}>
<div style={{ display: 'flex', gap: '12px' }}>
<div onClick={generateCaptcha} style={{
flex: 1, minWidth: "90px", width: "auto",
padding: '14px',
borderRadius: '8px',
border: '1px solid rgba(255,255,255,0.2)',
background: 'rgba(255,255,255,0.05)',
color: '#fbbf24',
fontSize: '18px',
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
fontWeight: '700',
cursor: 'pointer',
userSelect: 'none'
}}>
{captcha.num1} + {captcha.num2} = ?
</div>
<input
type="text"
value={captcha.answer}
onChange={(e) => setCaptcha(prev => ({ ...prev, answer: e.target.value }))}
placeholder="?"
style={{
width: '80px',
padding: '14px',
borderRadius: '8px',
border: '1px solid rgba(255,255,255,0.2)',
background: 'rgba(255,255,255,0.05)',
color: '#fff',
fontSize: '18px',
outline: 'none',
textAlign: 'center',
fontWeight: '700'
}}
/>
</div>
</div>
{/* 登录按钮 */}
<button
onClick={handleLogin}
disabled={loading}
style={{
width: '100%',
padding: '16px',
borderRadius: '12px',
border: 'none',
background: loading ? '#f59e0b' : 'linear-gradient(135deg, #fbbf24 0%, #f59e0b 100%)',
color: '#0f172a',
fontSize: '18px',
fontWeight: '700',
cursor: loading ? 'not-allowed' : 'pointer',
boxShadow: '0 4px 15px rgba(251, 191, 36, 0.3)'
}}
>
{loading ? '登录中...' : '登录'}
</button>
{/* 注册链接 */}
<div style={{ textAlign: 'center', marginTop: '16px', display: 'flex', justifyContent: 'center', gap: '16px' }}>
<span
onClick={() => setShowRegister(true)}
style={{
color: '#fbbf24',
fontSize: '14px',
cursor: 'pointer',
textDecoration: 'underline'
}}
>
注册新账号
</span>
<span style={{ color: 'rgba(255,255,255,0.3)' }}>|</span>
<span style={{ color: 'rgba(255,255,255,0.5)', fontSize: '14px' }}>
需要帮助联系管理员
</span>
</div>
</div>
{/* 版本号 */}
<div style={{
position: 'fixed',
bottom: '20px',
color: 'rgba(251, 191, 36, 0.5)',
fontSize: '12px',
textAlign: 'center',
fontWeight: '600'
}}>
v{APP_VERSION}
</div>
{/* 注册弹窗 */}
{showRegister && (
<div style={{
position: 'fixed',
top: 0,
left: 0,
right: 0,
bottom: 0,
background: 'rgba(0,0,0,0.8)',
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
padding: '20px',
zIndex: 1000
}}>
<div style={{
width: '100%',
maxWidth: '320px',
background: 'rgba(30, 41, 59, 0.95)',
borderRadius: '16px',
padding: '24px',
border: '1px solid rgba(255,255,255,0.1)',
maxHeight: '90vh',
overflowY: 'auto'
}}>
<h2 style={{ color: '#fbbf24', fontSize: '20px', fontWeight: '600', marginBottom: '20px', textAlign: 'center' }}>
注册新账号 🎉
</h2>
{registerError && (
<div style={{
background: 'rgba(239, 68, 68, 0.2)',
border: '1px solid rgba(239, 68, 68, 0.5)',
borderRadius: '8px',
padding: '12px',
marginBottom: '16px',
color: '#fca5a5',
fontSize: '13px'
}}>
{registerError}
</div>
)}
{/* 用户名 */}
<div style={{ marginBottom: '16px' }}>
<input
type="text"
value={registerData.username}
onChange={(e) => setRegisterData(prev => ({ ...prev, username: e.target.value }))}
placeholder="用户名(至少 2 个字符)"
style={{
width: '100%',
padding: '14px',
borderRadius: '8px',
border: '1px solid rgba(255,255,255,0.2)',
background: 'rgba(255,255,255,0.05)',
color: '#fff',
fontSize: '16px',
outline: 'none'
}}
/>
</div>
{/* 手机号 */}
<div style={{ marginBottom: '16px' }}>
<input
type="tel"
value={registerData.phone}
onChange={(e) => setRegisterData(prev => ({ ...prev, phone: e.target.value }))}
placeholder="手机号11位"
maxLength={11}
style={{
width: '100%',
padding: '14px',
borderRadius: '8px',
border: '1px solid rgba(255,255,255,0.2)',
background: 'rgba(255,255,255,0.05)',
color: '#fff',
fontSize: '16px',
outline: 'none'
}}
/>
</div>
{/* 短信获取 */}
<div style={{ marginBottom: '16px' }}>
<div style={{ display: 'flex', gap: '12px' }}>
<input
type="text"
value={registerData.verifyCode}
onChange={(e) => setRegisterData(prev => ({ ...prev, verifyCode: e.target.value }))}
placeholder="短信验证码"
maxLength={6}
style={{
flex: 1, minWidth: "90px", width: "auto",
padding: '14px',
borderRadius: '8px',
border: '1px solid rgba(255,255,255,0.2)',
background: 'rgba(255,255,255,0.05)',
color: '#fff',
fontSize: '16px',
outline: 'none'
}}
/>
<button
onClick={handleSendCode}
disabled={sendingCode || codeCountdown > 0}
style={{
minWidth: "90px", width: "auto",
padding: '14px',
borderRadius: '8px',
border: 'none',
background: codeCountdown > 0 ? 'rgba(148, 163, 184, 0.3)' : 'linear-gradient(135deg, #22c55e 0%, #16a34a 100%)',
color: '#fff',
fontSize: '14px',
fontWeight: '600',
cursor: codeCountdown > 0 ? 'not-allowed' : 'pointer',
whiteSpace: 'nowrap'
}}
>
{codeCountdown > 0 ? `${codeCountdown}` : sendingCode ? '发送中...' : '获取验证码'}
</button>
</div>
</div>
{/* 邮箱(可选) */}
<div style={{ marginBottom: '16px' }}>
<input
type="email"
value={registerData.email}
onChange={(e) => setRegisterData(prev => ({ ...prev, email: e.target.value }))}
placeholder="邮箱(可选)"
style={{
width: '100%',
padding: '14px',
borderRadius: '8px',
border: '1px solid rgba(255,255,255,0.2)',
background: 'rgba(255,255,255,0.05)',
color: '#fff',
fontSize: '16px',
outline: 'none'
}}
/>
</div>
{/* 密码 */}
<div style={{ marginBottom: '16px' }}>
<input
type="password"
value={registerData.password}
onChange={(e) => setRegisterData(prev => ({ ...prev, password: e.target.value }))}
placeholder="密码至少8位需大写+小写+数字)"
style={{
width: '100%',
padding: '14px',
borderRadius: '8px',
border: '1px solid rgba(255,255,255,0.2)',
background: 'rgba(255,255,255,0.05)',
color: '#fff',
fontSize: '16px',
outline: 'none'
}}
/>
</div>
{/* 确认密码 */}
<div style={{ marginBottom: '16px' }}>
<input
type="password"
value={registerData.confirmPassword}
onChange={(e) => setRegisterData(prev => ({ ...prev, confirmPassword: e.target.value }))}
placeholder="确认密码"
style={{
width: '100%',
padding: '14px',
borderRadius: '8px',
border: '1px solid rgba(255,255,255,0.2)',
background: 'rgba(255,255,255,0.05)',
color: '#fff',
fontSize: '16px',
outline: 'none'
}}
/>
</div>
{/* 邀请码(选填) */}
<div style={{ marginBottom: '24px' }}>
<input
type="text"
value={registerData.inviteCode}
onChange={(e) => setRegisterData(prev => ({ ...prev, inviteCode: e.target.value }))}
placeholder="邀请码(选填)"
style={{
width: '100%',
padding: '14px',
borderRadius: '8px',
border: '1px solid rgba(255,255,255,0.2)',
background: 'rgba(255,255,255,0.05)',
color: '#fff',
fontSize: '16px',
outline: 'none'
}}
/>
</div>
{/* 用户协议勾选 */}
<div style={{ marginBottom: '20px', display: 'flex', alignItems: 'flex-start', gap: '8px' }}>
<input
type="checkbox"
checked={registerData.agreeTerms}
onChange={(e) => setRegisterData(prev => ({ ...prev, agreeTerms: e.target.checked }))}
style={{ width: '18px', height: '18px', marginTop: '2px', cursor: 'pointer' }}
/>
<div style={{ fontSize: '12px', color: 'rgba(255,255,255,0.7)', lineHeight: '1.5' }}>
我已阅读并同意
<span
onClick={() => window.open('/user_agreement.html', '_blank')}
style={{ color: '#fbbf24', cursor: 'pointer', textDecoration: 'underline' }}
>用户协议</span>
</div>
</div>
{/* 按钮 */}
<div style={{ display: 'flex', gap: '12px' }}>
<button
onClick={() => {
setShowRegister(false)
setRegisterData({ username: '', password: '', confirmPassword: '', email: '', phone: '', verifyCode: '', inviteCode: '' })
setRegisterError('')
setCodeSent(false)
setCodeCountdown(0)
}}
style={{
flex: 1, minWidth: "90px", width: "auto",
padding: '14px',
borderRadius: '8px',
border: 'none',
background: 'rgba(148, 163, 184, 0.2)',
color: '#94a3b8',
fontSize: '16px',
fontWeight: '600',
cursor: 'pointer'
}}
>
取消
</button>
<button
onClick={handleRegister}
disabled={registerLoading}
style={{
flex: 1, minWidth: "90px", width: "auto",
padding: '14px',
borderRadius: '8px',
border: 'none',
background: registerLoading ? '#f59e0b' : 'linear-gradient(135deg, #fbbf24 0%, #f59e0b 100%)',
color: '#0f172a',
fontSize: '16px',
fontWeight: '600',
cursor: registerLoading ? 'not-allowed' : 'pointer'
}}
>
{registerLoading ? '注册中...' : '注册'}
</button>
</div>
</div>
</div>
)}
</div>
)
}

1244
frontend/src/pages/News.jsx Normal file

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,218 @@
import React, { useState, useEffect } from 'react'
export default function YichensBoard() {
const [todayStats, setTodayStats] = useState({ total: 0, deals: 0, wants: 0, others: 0 })
const [todayCategory, setTodayCategory] = useState([])
const [posts, setPosts] = useState([])
const [loading, setLoading] = useState(false)
const [expandedPosts, setExpandedPosts] = useState({})
const [postTypeFilter, setPostTypeFilter] = useState('all')
const [categoryFilter, setCategoryFilter] = useState('')
const [page, setPage] = useState(1)
const [totalPosts, setTotalPosts] = useState(0)
const [searchKeyword, setSearchKeyword] = useState('')
const API_BASE = localStorage.getItem('API_BASE') || ''
const today = new Date()
const dateStr = today.getFullYear() + '/' + (today.getMonth() + 1) + '/' + today.getDate()
useEffect(() => { fetchTodayStats(); fetchPosts(1, '') }, [])
const fetchTodayStats = async () => {
try {
const res = await fetch(API_BASE + '/api/yichens/stats/today')
setTodayStats(await res.json())
} catch(e) { console.error(e) }
}
const fetchTodayCategory = async () => {
try {
const res = await fetch(API_BASE + '/api/yichens/stats/today-category')
setTodayCategory(await res.json())
} catch(e) { console.error(e) }
}
const fetchPosts = async (p, cat) => {
setLoading(true)
const currentPage = p !== undefined ? p : page
const currentCat = cat !== undefined ? cat : categoryFilter
let url = API_BASE + '/api/yichens/posts?limit=390&offset=' + ((currentPage - 1) * 390)
if (postTypeFilter === 'deal') url += '&post_type=deal'
else if (postTypeFilter === 'want') url += '&post_type=want'
else if (postTypeFilter === 'other') url += '&post_type=normal'
try {
const res = await fetch(url)
let data = await res.json() || []
if (currentCat) {
if (currentCat === '龙') {
data = data.filter(p => p.category && (p.category.includes('龙') || p.category.includes('纪念钞')))
} else if (currentCat === '蛇') {
data = data.filter(p => p.category && p.category.includes('蛇'))
} else if (currentCat === '马') {
data = data.filter(p => p.category && p.category.includes('马'))
} else if (currentCat === '其他') {
data = data.filter(p => p.category && !p.category.includes('龙') && !p.category.includes('纪念钞') && !p.category.includes('蛇') && !p.category.includes('马'))
}
}
// -
if (searchKeyword) {
const kw = searchKeyword.trim()
if (kw) {
data = data.filter(p =>
(p.title && p.title.includes(kw)) ||
(p.content && p.content.includes(kw)) ||
(p.category && p.category.includes(kw)) ||
(p.contact && p.contact.includes(kw))
)
}
}
setPosts(data)
setTotalPosts(todayStats.total || 0)
} catch { setPosts([]) }
setLoading(false)
}
useEffect(() => { if (todayStats.total > 0) fetchTodayCategory() }, [todayStats])
//
useEffect(() => {
setPage(1)
fetchPosts(1, '')
}, [searchKeyword])
const togglePost = id => setExpandedPosts(p => ({ ...p, [id]: !p[id] }))
const StatCard = ({ label, value, color, onClick }) => (
<div onClick={onClick} style={{
background: 'linear-gradient(145deg, #1f2937 0%, #111827 100%)',
borderRadius: 12, padding: '12px 8px', border: '1px solid #374151',
cursor: onClick ? 'pointer' : 'default',
textAlign: 'center'
}}>
<div style={{ color: '#9ca3af', fontSize: 11, marginBottom: 4 }}>{label}</div>
<div style={{ color: color || '#fff', fontSize: 20, fontWeight: 'bold' }}>{value}</div>
</div>
)
return (
<div style={{ padding: '0' }}>
<div style={{ marginBottom: 16 }}>
<div style={{ color: '#f9fafb', fontSize: 14, fontWeight: 600, marginBottom: 10 }}>
📈 连体钞/纪念钞 <span style={{ color: '#9ca3af', fontWeight: 400 }}>{dateStr}</span>
</div>
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(4, 1fr)', gap: 8 }}>
<StatCard label='全部' value={todayStats.total} color='#3b82f6' onClick={() => { setPostTypeFilter('all'); setCategoryFilter(''); setPage(1); fetchPosts(1, '') }} />
<StatCard label='出售' value={todayStats.deals} color='#10b981' onClick={() => { setPostTypeFilter('deal'); setCategoryFilter(''); setPage(1); fetchPosts(1, '') }} />
<StatCard label='求购' value={todayStats.wants} color='#f59e0b' onClick={() => { setPostTypeFilter('want'); setCategoryFilter(''); setPage(1); fetchPosts(1, '') }} />
<StatCard label='其他' value={todayStats.others || 0} color='#8b5cf6' onClick={() => { setPostTypeFilter('other'); setCategoryFilter(''); setPage(1); fetchPosts(1, '') }} />
</div>
</div>
<div style={{ background: 'linear-gradient(145deg, #1f2937 0%, #111827 100%)', borderRadius: 12, padding: 12, marginBottom: 20, border: '1px solid #374151' }}>
<div style={{ color: '#f9fafb', fontSize: 14, fontWeight: 600, marginBottom: 8 }}>📊 今日分类统计</div>
<div style={{ display: 'flex', gap: 6, overflowX: 'auto', paddingBottom: 4 }}>
{todayCategory.map(cat => (
<span key={cat.category} style={{ padding: '4px 10px', background: 'rgba(59,130,246,0.2)', borderRadius: 16, color: '#93c5fd', fontSize: 11, whiteSpace: 'nowrap' }}>
{cat.category} ({cat.count})
</span>
))}
</div>
</div>
{/* 搜索框 */}
<div style={{ marginBottom: 12 }}>
<div style={{ display: 'flex', gap: 8 }}>
<input
type="text"
placeholder="搜索标题、内容、分类..."
value={searchKeyword}
onChange={(e) => { setSearchKeyword(e.target.value); setPage(1); fetchPosts(1, '') }}
style={{ flex: 1, padding: '10px 14px', borderRadius: 8, border: '1px solid #374151', background: '#1f2937', color: '#fff', fontSize: 13, outline: 'none' }}
/>
<button
onClick={() => { setSearchKeyword(''); setPage(1); fetchPosts(1, '') }}
style={{ padding: '10px 16px', borderRadius: 8, border: 'none', background: '#4b5563', color: '#fff', cursor: 'pointer', fontSize: 13 }}>
清空
</button>
</div>
{searchKeyword && <div style={{ color: '#9ca3af', fontSize: 12, marginTop: 6 }}>搜索: "{searchKeyword}"找到 {posts.length} 条结果</div>}
</div>
<div style={{ display: 'flex', gap: 8, marginBottom: 12 }}>
{[{key:'all',label:'全部'},{key:'deal',label:'出售'},{key:'want',label:'求购'},{key:'other',label:'其他'}].map(k => (
<button key={k.key} onClick={() => { setPostTypeFilter(k.key==='other'?'other':k.key); setCategoryFilter(''); setPage(1); fetchPosts(1, '') }}
style={{ padding: '8px 16px', borderRadius: 8, border: 'none',
background: postTypeFilter===k.key ? 'linear-gradient(135deg, #3b82f6 0%, #2563eb 100%)' : '#374151', color: '#fff', cursor: 'pointer', fontSize: 13 }}>
{k.label}
</button>
))}
</div>
<div style={{ display: 'flex', gap: 8, marginBottom: 16 }}>
{[{key:'',label:'全部'},{key:'龙',label:'龙钞'},{key:'蛇',label:'蛇钞'},{key:'马',label:'马钞'},{key:'其他',label:'其他'}].map(k => (
<button key={k.key} onClick={() => { setCategoryFilter(k.key); setPage(1); fetchPosts(1, k.key) }}
style={{ padding: '8px 16px', borderRadius: 8, border: 'none',
background: categoryFilter===k.key ? 'linear-gradient(135deg, #8b5cf6 0%, #7c3aed 100%)' : '#374151', color: '#fff', cursor: 'pointer', fontSize: 13 }}>
{k.label}
</button>
))}
</div>
{loading ? <div style={{textAlign:'center',color:'#9ca3af',padding:40}}>加载中...</div> : (
<div>
<div style={{ display: 'flex', flexDirection: 'column', gap: 12 }}>
{posts.map(post => (
<div key={post.post_id} style={{ background: 'linear-gradient(145deg, #1f2937 0%, #111827 100%)', borderRadius: 12, padding: 16, border: '1px solid #374151' }}>
<div onClick={() => togglePost(post.post_id)} style={{ cursor: 'pointer' }}>
<div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 8 }}>
<span style={{ color: '#fff', fontSize: 15, fontWeight: 500, flex: 1 }}>{post.title||'无标题'}</span>
<div style={{ display: 'flex', gap: 4 }}>
<span style={{ color: post.post_type==='deal'?'#10b981':post.post_type==='want'?'#f59e0b':post.post_type==='normal'?'#8b5cf6':'#9ca3af', fontSize: 12 }}>
{post.post_type==='deal'?'出售':post.post_type==='want'?'求购':post.post_type==='normal'?'其他':'普通'}
</span>
<span style={{ padding: '2px 8px', borderRadius: 4, fontSize: 11, background: post.category?.includes('龙') ? 'rgba(251,191,36,0.4)' : post.category?.includes('马') ? 'rgba(180,83,9,0.4)' : post.category?.includes('蛇') ? 'rgba(249,168,212,0.4)' : 'rgba(139,92,246,0.4)', color: post.category?.includes('龙') ? '#fde047' : post.category?.includes('马') ? '#d97706' : post.category?.includes('蛇') ? '#fbcfe8' : '#c4b5fd' }}>
{post.category || '-'}
</span>
</div>
</div>
<div style={{ display: 'flex', justifyContent: 'space-between', color: '#9ca3af', fontSize: 12 }}>
<span>{post.author_username||'未知'}</span>
<span>{post.post_time?.substring(0,16)||''}</span>
</div>
</div>
{expandedPosts[post.post_id] && post.content && (
<div style={{ marginTop: 12, paddingTop: 12, borderTop: '1px solid #374151' }}>
<div style={{ color: '#e2e8f0', fontSize: 13, lineHeight: 1.6, whiteSpace: 'pre-wrap', wordBreak: 'break-word', maxHeight: 300, overflowY: 'auto' }}>
{post.content}
</div>
{post.url && <a href={post.url} target='_blank' rel='noopener noreferrer' style={{ display:'inline-block', marginTop:12, padding:'8px 16px', background:'rgba(59,130,246,0.2)', borderRadius:8, color:'#60a5fa', textDecoration:'none', fontSize:13 }}>查看原帖</a>}
</div>
)}
</div>
))}
</div>
{/* 分页按钮移到页面底部 */}
<div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', padding: '12px 16px', background: '#1e293b', borderRadius: 12, marginTop: 16 }}>
<div style={{ color: '#9ca3af', fontSize: 12 }}>
{totalPosts} 条帖子{Math.ceil(totalPosts / 390)} 当前第 {page}
</div>
<div style={{ display: 'flex', gap: 8 }}>
{page > 1 ? (
<button onClick={() => { const newPage = page - 1; setPage(newPage); fetchPosts(newPage, categoryFilter) }} style={{ padding: '6px 12px', borderRadius: 6, border: 'none', background: '#3b82f6', color: '#fff', cursor: 'pointer', fontSize: 12 }}>上一页</button>
) : (
<span style={{ padding: '6px 12px', borderRadius: 6, background: '#374151', color: '#6b7280', fontSize: 12 }}>上一页</span>
)}
{posts.length >= 390 ? (
<button onClick={() => { const newPage = page + 1; setPage(newPage); fetchPosts(newPage, categoryFilter) }} style={{ padding: '6px 12px', borderRadius: 6, border: 'none', background: '#3b82f6', color: '#fff', cursor: 'pointer', fontSize: 12 }}>下一页</button>
) : (
<span style={{ padding: '6px 12px', borderRadius: 6, background: '#374151', color: '#6b7280', fontSize: 12 }}>下一页</span>
)}
</div>
</div>
</div>
)}
</div>
)
}

View File

@ -0,0 +1,434 @@
import React, { useState, useEffect } from 'react'
import { useNavigate } from 'react-router-dom'
export default function Settings() {
const [loading, setLoading] = useState(true)
const [saving, setSaving] = useState(false)
const [error, setError] = useState('')
const [success, setSuccess] = useState('')
const [form, setForm] = useState({
username: '',
email: '',
phone: '',
avatar: '',
address: '',
bio: ''
})
//
const [phoneChanged, setPhoneChanged] = useState(false)
const [newPhone, setNewPhone] = useState('')
const [verifyCode, setVerifyCode] = useState('')
const [sendingCode, setSendingCode] = useState(false)
const [codeCountdown, setCodeCountdown] = useState(0)
const [passwordForm, setPasswordForm] = useState({
oldPassword: '',
newPassword: '',
confirmPassword: ''
})
const navigate = useNavigate()
const token = localStorage.getItem('token')
useEffect(() => {
fetchUserInfo()
}, [])
//
useEffect(() => {
if (codeCountdown > 0) {
const timer = setTimeout(() => setCodeCountdown(codeCountdown - 1), 1000)
return () => clearTimeout(timer)
}
}, [codeCountdown])
const fetchUserInfo = async () => {
try {
const res = await fetch('/api/users/me', {
headers: { 'Authorization': 'Bearer ' + token }
})
if (res.ok) {
const data = await res.json()
console.log('用户信息:', data)
setForm({
username: data.username || '',
email: data.email || '',
phone: data.phone || '',
avatar: data.avatar || '',
address: data.address || '',
bio: data.bio || ''
})
setNewPhone(data.phone || '')
}
} catch (e) {
console.error('获取用户信息异常:', e)
const userStr = localStorage.getItem('user')
if (userStr) {
try {
const user = JSON.parse(userStr)
setForm({
username: user.username || '',
email: user.email || '',
phone: user.phone || '',
avatar: user.avatar || '',
address: user.address || '',
bio: user.bio || ''
})
setNewPhone(user.phone || '')
} catch (e2) {
setError('获取用户信息失败')
}
}
} finally {
setLoading(false)
}
}
//
const handleSendCode = async () => {
if (!newPhone) {
setError('请输入手机号')
return
}
const phoneRegex = /^1[3-9]\d{9}$/
if (!phoneRegex.test(newPhone)) {
setError('请输入正确的手机号')
return
}
setSendingCode(true)
setError('')
try {
const res = await fetch('/api/auth/send-verification-code', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({ phone: newPhone })
})
const data = await res.json()
if (data.success) {
setPhoneChanged(true)
setCodeCountdown(60)
setSuccess('验证码已发送到 ' + newPhone.substring(0,3) + '****' + newPhone.substring(7))
} else {
setError(data.message || '发送失败')
}
} catch (err) {
setError('发送失败,请稍后重试')
} finally {
setSendingCode(false)
}
}
const handleSubmit = async (e) => {
e.preventDefault()
setError('')
setSuccess('')
//
if (newPhone !== form.phone) {
if (!verifyCode) {
setError('请输入手机验证码')
return
}
}
setSaving(true)
try {
const updateData = {
username: form.username,
email: form.email || null,
phone: newPhone,
address: form.address,
bio: form.bio
}
//
if (newPhone !== form.phone) {
updateData.verifyCode = verifyCode
}
const res = await fetch('/api/users/me', {
method: 'PUT',
headers: {
'Authorization': 'Bearer ' + token,
'Content-Type': 'application/json'
},
body: JSON.stringify(updateData)
})
if (res.ok) {
const data = await res.json()
setSuccess('保存成功!')
setForm({...form, phone: newPhone})
setVerifyCode('')
setPhoneChanged(false)
//
const userStr = localStorage.getItem('user')
if (userStr) {
const user = JSON.parse(userStr)
user.username = data.username || user.username
user.email = data.email || user.email
user.phone = data.phone || user.phone
localStorage.setItem('user', JSON.stringify(user))
}
} else {
const data = await res.json()
setError(data.error?.message || data.detail || '保存失败')
}
} catch (e) {
setError('保存失败,请重试')
} finally {
setSaving(false)
}
}
const handlePasswordChange = async (e) => {
e.preventDefault()
setError('')
setSuccess('')
if (!passwordForm.oldPassword) {
setError('请输入当前密码')
return
}
if (passwordForm.newPassword !== passwordForm.confirmPassword) {
setError('两次输入的密码不一致')
return
}
if (passwordForm.newPassword.length < 8) {
setError('密码至少8位需包含大写+小写+数字')
return
}
setSaving(true)
try {
const res = await fetch('/api/auth/change-password', {
method: 'POST',
headers: {
'Authorization': 'Bearer ' + token,
'Content-Type': 'application/json'
},
body: JSON.stringify({
old_password: passwordForm.oldPassword,
new_password: passwordForm.newPassword
})
})
const data = await res.json()
if (res.ok) {
setSuccess('密码修改成功!')
setPasswordForm({ oldPassword: '', newPassword: '', confirmPassword: '' })
} else {
setError(data.error?.message || data.detail || '密码修改失败')
}
} catch (e) {
setError('密码修改失败,请重试')
} finally {
setSaving(false)
}
}
if (loading) {
return (
<div style={{ minHeight: '100vh', background: '#0f172a', display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
<div style={{ color: '#fff' }}>加载中...</div>
</div>
)
}
return (
<div style={{ minHeight: '100vh', background: '#0f172a', padding: '20px', paddingBottom: '80px' }}>
{/* 顶部导航 */}
<div style={{ display: 'flex', alignItems: 'center', marginBottom: '24px' }}>
<div onClick={() => window.history.back()} style={{ cursor: 'pointer', fontSize: '20px', color: '#fff' }}></div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: 'bold', marginLeft: '16px' }}>个人设置</div>
</div>
{error && <div style={{ background: '#fee2e2', color: '#dc2626', padding: '12px', borderRadius: '8px', marginBottom: '16px' }}>{error}</div>}
{success && <div style={{ background: '#dcfce7', color: '#16a34a', padding: '12px', borderRadius: '8px', marginBottom: '16px' }}>{success}</div>}
{/* 基本信息 */}
<div style={{ background: '#1e293b', borderRadius: '12px', padding: '20px', marginBottom: '16px' }}>
<div style={{ color: '#fff', fontSize: '16px', fontWeight: 'bold', marginBottom: '16px' }}>基本信息</div>
<form onSubmit={handleSubmit}>
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '14px', marginBottom: '8px' }}>用户名</label>
<input
type="text"
value={form.username}
onChange={(e) => setForm({ ...form, username: e.target.value })}
style={{ width: '100%', padding: '12px', borderRadius: '8px', border: '1px solid #334155', background: '#0f172a', color: '#fff' }}
/>
</div>
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '14px', marginBottom: '8px' }}>邮箱选填</label>
<input
type="email"
value={form.email}
onChange={(e) => setForm({ ...form, email: e.target.value })}
placeholder="选填"
style={{ width: '100%', padding: '12px', borderRadius: '8px', border: '1px solid #334155', background: '#0f172a', color: '#fff' }}
/>
</div>
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '14px', marginBottom: '8px' }}>手机号</label>
<input
type="tel"
value={newPhone}
onChange={(e) => {
setNewPhone(e.target.value)
setPhoneChanged(true)
setVerifyCode('')
}}
placeholder="11位手机号"
maxLength={11}
style={{ width: '100%', padding: '12px', borderRadius: '8px', border: '1px solid #334155', background: '#0f172a', color: '#fff' }}
/>
</div>
{/* 手机验证码 - 仅在手机号变更时显示 */}
{phoneChanged && (
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '14px', marginBottom: '8px' }}>手机验证码</label>
<div style={{ display: 'flex', gap: '12px' }}>
<input
type="text"
value={verifyCode}
onChange={(e) => setVerifyCode(e.target.value)}
placeholder="6位验证码"
maxLength={6}
style={{ flex: 1, padding: '12px', borderRadius: '8px', border: '1px solid #334155', background: '#0f172a', color: '#fff' }}
/>
<button
type="button"
onClick={handleSendCode}
disabled={sendingCode || codeCountdown > 0}
style={{
width: '120px',
padding: '12px',
borderRadius: '8px',
border: 'none',
background: codeCountdown > 0 ? '#4b5563' : '#22c55e',
color: '#fff',
fontSize: '14px',
cursor: codeCountdown > 0 ? 'not-allowed' : 'pointer'
}}
>
{codeCountdown > 0 ? codeCountdown + '秒' : sendingCode ? '发送中...' : '获取验证码'}
</button>
</div>
</div>
)}
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '14px', marginBottom: '8px' }}>地址选填</label>
<input
type="text"
value={form.address}
onChange={(e) => setForm({ ...form, address: e.target.value })}
placeholder="选填"
style={{ width: '100%', padding: '12px', borderRadius: '8px', border: '1px solid #334155', background: '#0f172a', color: '#fff' }}
/>
</div>
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '14px', marginBottom: '8px' }}>简介选填</label>
<textarea
value={form.bio}
onChange={(e) => setForm({ ...form, bio: e.target.value })}
placeholder="选填"
rows={3}
style={{ width: '100%', padding: '12px', borderRadius: '8px', border: '1px solid #334155', background: '#0f172a', color: '#fff', resize: 'none' }}
/>
</div>
<button
type="submit"
disabled={saving}
style={{ width: '100%', padding: '14px', borderRadius: '8px', border: 'none', background: '#3b82f6', color: '#fff', fontSize: '16px', cursor: saving ? 'not-allowed' : 'pointer', opacity: saving ? 0.6 : 1 }}
>
{saving ? '保存中...' : '保存修改'}
</button>
</form>
</div>
{/* 修改密码 */}
<div style={{ background: '#1e293b', borderRadius: '12px', padding: '20px', marginBottom: '16px' }}>
<div style={{ color: '#fff', fontSize: '16px', fontWeight: 'bold', marginBottom: '16px' }}>修改密码</div>
<form onSubmit={handlePasswordChange}>
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '14px', marginBottom: '8px' }}>当前密码</label>
<input
type="password"
value={passwordForm.oldPassword}
onChange={(e) => setPasswordForm({ ...passwordForm, oldPassword: e.target.value })}
placeholder="请输入当前密码"
style={{ width: '100%', padding: '12px', borderRadius: '8px', border: '1px solid #334155', background: '#0f172a', color: '#fff' }}
/>
</div>
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '14px', marginBottom: '8px' }}>新密码</label>
<input
type="password"
value={passwordForm.newPassword}
onChange={(e) => setPasswordForm({ ...passwordForm, newPassword: e.target.value })}
placeholder="至少8位需包含大写+小写+数字"
style={{ width: '100%', padding: '12px', borderRadius: '8px', border: '1px solid #334155', background: '#0f172a', color: '#fff' }}
/>
</div>
<div style={{ marginBottom: '16px' }}>
<label style={{ display: 'block', color: '#94a3b8', fontSize: '14px', marginBottom: '8px' }}>确认新密码</label>
<input
type="password"
value={passwordForm.confirmPassword}
onChange={(e) => setPasswordForm({ ...passwordForm, confirmPassword: e.target.value })}
placeholder="再次输入新密码"
style={{ width: '100%', padding: '12px', borderRadius: '8px', border: '1px solid #334155', background: '#0f172a', color: '#fff' }}
/>
</div>
<button
type="submit"
disabled={saving}
style={{ width: '100%', padding: '14px', borderRadius: '8px', border: 'none', background: '#f59e0b', color: '#fff', fontSize: '16px', cursor: saving ? 'not-allowed' : 'pointer', opacity: saving ? 0.6 : 1 }}
>
{saving ? '修改中...' : '修改密码'}
</button>
</form>
</div>
{/* 退出登录 */}
<div style={{ background: '#1e293b', borderRadius: '12px', padding: '20px' }}>
<button
onClick={() => {
localStorage.removeItem('token')
localStorage.removeItem('user')
window.location.hash = '#/login'
}}
style={{ width: '100%', padding: '14px', borderRadius: '8px', border: '1px solid #ef4444', background: 'transparent', color: '#ef4444', fontSize: '16px', cursor: 'pointer' }}
>
退出登录
</button>
</div>
</div>
)
}

View File

@ -0,0 +1,292 @@
// -
import React, { useState, useEffect } from 'react'
import { APP_VERSION } from '../config/version'
export default function Stats() {
const [stats, setStats] = useState({
totalCount: 0,
byCategory: [],
byStatus: [],
byGrading: [],
byPackaging: [],
byRarity: [],
byNumberCategory: [],
byVersion: [],
byGradingCompany: [],
byGradingScore: [],
bySpecialMark: [],
byProfitLoss: [],
totalCost: 0,
totalTarget: 0,
expectedProfit: 0,
totalRevenue: 0,
totalProfit: 0
})
const [loading, setLoading] = useState(true)
useEffect(() => {
fetchStats()
}, [])
const fetchStats = async () => {
setLoading(true)
const token = localStorage.getItem('token')
try {
const statsRes = await fetch('/api/collections/stats', {
headers: { 'Authorization': 'Bearer ' + token }
})
if (!statsRes.ok) {
throw new Error(`HTTP ${statsRes.status}`)
}
const data = await statsRes.json()
console.log('统计数据:', data)
setStats({
totalCount: data.totalCount || 0,
byCategory: data.byCategory || [],
byStatus: data.byStatus || [],
byGrading: data.byGrading || [],
byPackaging: data.byPackaging || [],
byRarity: data.byRarity || [],
byNumberCategory: data.byNumberCategory || [],
byVersion: data.byVersion || [],
byGradingCompany: data.byGradingCompany || [],
byGradingScore: data.byGradingScore || [],
bySpecialMark: data.bySpecialMark || [],
byProfitLoss: data.byProfitLoss || [],
totalCost: data.totalCost || 0,
totalTarget: data.totalTarget || 0,
expectedProfit: data.expectedProfit || 0,
totalRevenue: data.totalRevenue || 0,
totalProfit: data.totalProfit || 0
})
} catch (e) {
console.error('统计加载失败:', e)
alert('加载失败:' + e.message)
} finally {
setLoading(false)
}
}
//
const handleItemClick = (type, value) => {
const filterKey = getFilterKey(type)
//
window.location.hash = `#/list?filter=${filterKey}&value=${encodeURIComponent(value)}`
}
//
const getFilterKey = (type) => {
const map = {
status: 'status',
category: 'category',
packaging: 'packaging',
rarity: 'rarity',
version: 'version',
gradingCompany: 'gradingCompany',
gradingScore: 'gradingScore',
specialMark: 'specialMark',
numberCategory: 'numberCategory',
gradingCompany: 'gradingCompany',
gradingScore: 'gradingScore',
profitLoss: 'profitLoss'
}
return map[type] || type
}
//
const colors = {
packaging: { '标十': '#22c55e', '标百': '#3b82f6', '单张': '#f59e0b', '裸钞': '#64748b' },
rarity: { '通货': '#64748b', '特色': '#22c55e', '少见': '#3b82f6', '稀有': '#8b5cf6', '珍品': '#ef4444', '孤品': '#fbbf24' },
status: { 'in_collection': '#22c55e', 'selling': '#f59e0b', 'sold': '#ef4444', 'grading': '#8b5cf6', 'repairing': '#f97316', 'transit': '#06b6d4', 'seeking': '#ec4899' },
category: { '自持': '#22c55e', '寄存': '#3b82f6', '寄售': '#f59e0b', '共有': '#8b5cf6', '寻号': '#06b6d4', '生肖钞': '#22c55e', '其他': '#64748b' },
profitLoss: { 'profit': '#22c55e', 'loss': '#ef4444' },
numberCategory: { '无2347': '#8b5cf6', '无347': '#ef4444', '无247': '#fbbf24', '无47': '#3b82f6', '带7号': '#06b6d4', '带4号': '#22c55e', '其他': '#64748b' },
version: {},
gradingCompany: {},
gradingScore: {},
specialMark: {}
}
//
const labels = {
status: {
'in_collection': '收藏中',
'selling': '出售中',
'sold': '已售',
'grading': '送评中',
'repairing': '修复中',
'transit': '在途中',
'seeking': '寻号中'
},
profitLoss: {
'profit': '盈利',
'loss': '亏损'
}
}
const colorPalette = ['#22c55e', '#3b82f6', '#f59e0b', '#ef4444', '#8b5cf6', '#06b6d4', '#ec4899', '#f97316', '#14b8a6', '#a855f7']
const getColor = (type, value) => {
if (colors[type]?.[value]) return colors[type][value]
//
const key = String(value)
let hash = 0
for (let i = 0; i < key.length; i++) hash = key.charCodeAt(i) + ((hash << 5) - hash)
return colorPalette[Math.abs(hash) % colorPalette.length]
}
const getLabel = (type, value) => {
return labels[type]?.[value] || value
}
const formatMoney = (val) => {
if (val === null || val === undefined) return '0'
return Number(val).toLocaleString('zh-CN')
}
const numberCategoryOrder = ['无2347', '无347', '无247', '无47', '带7号', '带4号', '其他']
const getSortedData = (data, type) => {
if (type === 'numberCategory') {
return [...data].sort((a, b) => {
const order = numberCategoryOrder.indexOf(a.numberCategory)
const order2 = numberCategoryOrder.indexOf(b.numberCategory)
return order - order2
})
}
return data
}
const DistributionCard = ({ title, data, type, valueKey, labelKey }) => (
<div style={{ background: 'rgba(255,255,255,0.03)', borderRadius: '12px', padding: '16px', marginBottom: '12px' }}>
<div style={{ color: '#fbbf24', fontSize: '14px', fontWeight: 'bold', marginBottom: '12px' }}>{title}</div>
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(2, 1fr)', gap: '8px' }}>
{getSortedData(data, type).map((item, index) => {
const value = item[valueKey]
const label = getLabel(type, item[labelKey] || value)
const color = getColor(type, value)
return (
<div
key={index}
onClick={() => handleItemClick(type, value)}
style={{
background: 'rgba(255,255,255,0.05)',
borderRadius: '8px',
padding: '10px',
cursor: 'pointer',
border: '1px solid rgba(255,255,255,0.05)',
transition: 'all 0.2s'
}}
onMouseEnter={(e) => {
e.currentTarget.style.background = 'rgba(255,255,255,0.1)'
e.currentTarget.style.borderColor = 'rgba(251, 191, 36, 0.3)'
}}
onMouseLeave={(e) => {
e.currentTarget.style.background = 'rgba(255,255,255,0.05)'
e.currentTarget.style.borderColor = 'rgba(255,255,255,0.05)'
}}
>
<div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
<div style={{ display: 'flex', alignItems: 'center', gap: '6px', flex: 1, overflow: 'hidden' }}>
<div style={{ width: '8px', height: '8px', borderRadius: '2px', background: color, flexShrink: 0 }} />
<div style={{ color: color, fontSize: '12px', fontWeight: '500', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>
{label}
</div>
</div>
<div style={{ color: '#fff', fontSize: '14px', fontWeight: 'bold', marginLeft: '8px', flexShrink: 0 }}>
{item.count}
</div>
</div>
</div>
)
})}
</div>
{data.length > 6 && (
<div style={{ textAlign: 'center', color: '#94a3b8', fontSize: '12px', marginTop: '8px' }}>
{data.length}显示前 6
</div>
)}
</div>
)
if (loading) {
return (
<div style={{ background: '#0f172a', minHeight: '100vh', display: 'flex', alignItems: 'center', justifyContent: 'center' }}>
<div style={{ color: '#94a3b8', fontSize: '16px' }}>加载中...</div>
</div>
)
}
const gradedCount = stats.byGrading.find(g => g.isGraded === true)?.count || 0
const ungradedCount = stats.byGrading.find(g => g.isGraded === false)?.count || 0
return (
<div style={{ background: '#0f172a', minHeight: '100vh', paddingBottom: '80px' }}>
{/* 顶部 */}
<div style={{ padding: '16px', background: 'rgba(255,255,255,0.02)', borderBottom: '1px solid rgba(255,255,255,0.05)', display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
<div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: 'bold' }}>统计分析</div>
<div style={{ color: '#94a3b8', fontSize: '13px', marginTop: '4px' }}>点击统计项查看明细</div>
</div>
<div style={{ color: 'rgba(255,255,255,0.3)', fontSize: '11px' }}>v{APP_VERSION}</div>
</div>
<div style={{ padding: '16px' }}>
{/* 总统计 */}
<div style={{ background: 'linear-gradient(135deg, rgba(251, 191, 36, 0.2) 0%, rgba(251, 191, 36, 0.05) 100%)', borderRadius: '12px', padding: '20px', marginBottom: '16px', border: '1px solid rgba(251, 191, 36, 0.3)' }}>
<div style={{ color: '#fbbf24', fontSize: '14px', fontWeight: 'bold', marginBottom: '16px' }}>📊 总统计</div>
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(3, 1fr)', gap: '12px' }}>
<div style={{ textAlign: 'center' }}>
<div style={{ color: '#94a3b8', fontSize: '12px', marginBottom: '4px' }}>总数量</div>
<div style={{ color: '#fff', fontSize: '24px', fontWeight: 'bold' }}>{stats.totalCount}</div>
</div>
<div style={{ textAlign: 'center' }}>
<div style={{ color: '#94a3b8', fontSize: '12px', marginBottom: '4px' }}>已评级</div>
<div style={{ color: '#fff', fontSize: '24px', fontWeight: 'bold' }}>{gradedCount}</div>
</div>
<div style={{ textAlign: 'center' }}>
<div style={{ color: '#94a3b8', fontSize: '12px', marginBottom: '4px' }}>未评级</div>
<div style={{ color: '#fff', fontSize: '24px', fontWeight: 'bold' }}>{ungradedCount}</div>
</div>
</div>
</div>
{/* 财务统计 */}
<div style={{ background: 'linear-gradient(135deg, rgba(34, 197, 94, 0.2) 0%, rgba(34, 197, 94, 0.05) 100%)', borderRadius: '12px', padding: '20px', marginBottom: '16px', border: '1px solid rgba(34, 197, 94, 0.3)' }}>
<div style={{ color: '#22c55e', fontSize: '14px', fontWeight: 'bold', marginBottom: '16px' }}>💰 财务统计</div>
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(2, 1fr)', gap: '12px' }}>
<div style={{ textAlign: 'center' }}>
<div style={{ color: '#94a3b8', fontSize: '12px', marginBottom: '4px' }}>总成本</div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: 'bold' }}>¥{formatMoney(stats.totalCost)}</div>
</div>
<div style={{ textAlign: 'center' }}>
<div style={{ color: '#94a3b8', fontSize: '12px', marginBottom: '4px' }}>总收入</div>
<div style={{ color: '#fff', fontSize: '18px', fontWeight: 'bold' }}>¥{formatMoney(stats.totalRevenue)}</div>
</div>
<div style={{ textAlign: 'center' }}>
<div style={{ color: '#94a3b8', fontSize: '12px', marginBottom: '4px' }}>预期利润</div>
<div style={{ color: '#22c55e', fontSize: '18px', fontWeight: 'bold' }}>+¥{formatMoney(stats.expectedProfit)}</div>
</div>
<div style={{ textAlign: 'center' }}>
<div style={{ color: '#94a3b8', fontSize: '12px', marginBottom: '4px' }}>已实现利润</div>
<div style={{ color: '#22c55e', fontSize: '18px', fontWeight: 'bold' }}>+¥{formatMoney(stats.totalProfit)}</div>
</div>
</div>
</div>
{/* 盈亏统计移到顶部 */}
<DistributionCard title="💰 盈亏统计" data={stats.byProfitLoss} type="profitLoss" valueKey="type" labelKey="label" />
<DistributionCard title="📦 包装分布" data={stats.byPackaging} type="packaging" valueKey="packaging" />
<DistributionCard title="🔢 号码分类分布" data={stats.byNumberCategory} type="numberCategory" valueKey="numberCategory" />
<DistributionCard title="📋 状态分布" data={stats.byStatus} type="status" valueKey="status" />
<DistributionCard title="⭐ 珍惜度分布" data={stats.byRarity} type="rarity" valueKey="rarity" />
<DistributionCard title="🏷️ 版别分布" data={stats.byVersion} type="version" valueKey="version" />
<DistributionCard title="🏅 评级机构分布" data={stats.byGradingCompany} type="gradingCompany" valueKey="company" />
<DistributionCard title="📈 评级分数分布" data={stats.byGradingScore} type="gradingScore" valueKey="score" />
<DistributionCard title="✨ 特殊标识分布" data={stats.bySpecialMark} type="specialMark" valueKey="mark" />
</div>
</div>
)
}

View File

@ -0,0 +1,255 @@
import React, { useState, useEffect } from 'react'
export default function YichensBoard() {
const [todayStats, setTodayStats] = useState({ total: 0, deals: 0, wants: 0, others: 0 })
const [todayCategory, setTodayCategory] = useState([])
const [posts, setPosts] = useState([])
const [loading, setLoading] = useState(true)
const [error, setError] = useState(null)
const [expandedPosts, setExpandedPosts] = useState({})
const [postTypeFilter, setPostTypeFilter] = useState('all')
const [categoryFilter, setCategoryFilter] = useState('')
const [page, setPage] = useState(1)
const [totalPosts, setTotalPosts] = useState(0)
const [searchKeyword, setSearchKeyword] = useState('')
const today = new Date()
const dateStr = today.getFullYear() + '/' + (today.getMonth() + 1) + '/' + today.getDate()
useEffect(() => {
console.log('YichensBoard: 开始加载数据')
fetchTodayStats()
}, [])
const fetchTodayStats = async () => {
try {
console.log('YichensBoard: 请求 /api/yichens/stats/today')
const res = await fetch('/api/yichens/stats/today')
if (!res.ok) throw new Error('stats API error: ' + res.status)
const data = await res.json()
console.log('YichensBoard: stats data', data)
setTodayStats(data)
} catch(e) {
console.error('YichensBoard: fetchTodayStats error', e)
setError(e.message)
}
}
const fetchPosts = async (p, cat, kw) => {
setLoading(true)
setError(null)
const currentPage = p !== undefined ? p : page
const currentCat = cat !== undefined ? cat : categoryFilter
const searchKw = kw !== undefined ? kw : searchKeyword
let url = '/api/yichens/posts?limit=390&offset=' + ((currentPage - 1) * 390)
if (postTypeFilter === 'deal') url += '&post_type=deal'
else if (postTypeFilter === 'want') url += '&post_type=want'
else if (postTypeFilter === 'other') url += '&post_type=normal'
if (searchKw && searchKw.trim()) url += '&keyword=' + encodeURIComponent(searchKw.trim())
try {
console.log('YichensBoard: 请求 posts', url)
const res = await fetch(url)
if (!res.ok) throw new Error('posts API error: ' + res.status)
let data = await res.json() || []
// data
if (!Array.isArray(data)) {
data = data.posts || data.data || []
}
console.log('YichensBoard: posts data count', data.length)
if (currentCat && Array.isArray(data)) {
if (currentCat === '龙') {
data = data.filter(p => p.category && (p.category.includes('龙') || p.category.includes('纪念钞')))
} else if (currentCat === '蛇') {
data = data.filter(p => p.category && p.category.includes('蛇'))
} else if (currentCat === '马') {
data = data.filter(p => p.category && p.category.includes('马'))
} else if (currentCat === '其他') {
data = data.filter(p => p.category && !p.category.includes('龙') && !p.category.includes('纪念钞') && !p.category.includes('蛇') && !p.category.includes('马'))
}
}
// data
if (!Array.isArray(data)) {
data = data.posts || data.data || []
}
console.log('YichensBoard: posts data count', data.length)
if (currentCat && Array.isArray(data)) {
if (currentCat === '龙') {
data = data.filter(p => p.category && (p.category.includes('龙') || p.category.includes('纪念钞')))
} else if (currentCat === '蛇') {
data = data.filter(p => p.category && p.category.includes('蛇'))
} else if (currentCat === '马') {
data = data.filter(p => p.category && p.category.includes('马'))
} else if (currentCat === '其他') {
data = data.filter(p => p.category && !p.category.includes('龙') && !p.category.includes('纪念钞') && !p.category.includes('蛇') && !p.category.includes('马'))
}
}
// {posts:[], total:xxx} [{},{}]
const postsArray = Array.isArray(data) ? data : (data.posts || [])
const totalCount = data.total || todayStats.total || postsArray.length
setPosts(postsArray)
setTotalPosts(totalCount)
} catch(e) {
console.error('YichensBoard: fetchPosts error', e)
setError(e.message)
setPosts([])
} finally {
setLoading(false)
}
}
useEffect(() => {
if (todayStats.total > 0) {
fetchPosts(1, categoryFilter, searchKeyword)
}
}, [todayStats, categoryFilter, postTypeFilter])
useEffect(() => {
setPage(1)
fetchPosts(1, categoryFilter, searchKeyword)
}, [searchKeyword])
const togglePost = id => setExpandedPosts(p => ({ ...p, [id]: !p[id] }))
const StatCard = ({ label, value, color, onClick }) => (
<div onClick={() => { setLoading(true); if (onClick) onClick(); }}
style={{
background: 'linear-gradient(145deg, #1f2937 0%, #111827 100%)',
borderRadius: 12, padding: '12px 8px', border: '1px solid #374151',
cursor: onClick ? 'pointer' : 'default',
textAlign: 'center'
}}>
<div style={{ color: '#9ca3af', fontSize: 11, marginBottom: 4 }}>{label}</div>
<div style={{ color: color || '#fff', fontSize: 20, fontWeight: 'bold' }}>{value}</div>
</div>
)
if (error) {
return (
<div style={{ padding: 20, textAlign: 'center', color: '#ef4444' }}>
<div>加载失败: {error}</div>
<button onClick={() => { setError(null); fetchTodayStats(); }} style={{ marginTop: 10, padding: '8px 16px', background: '#3b82f6', color: '#fff', border: 'none', borderRadius: 6, cursor: 'pointer' }}>
重试
</button>
</div>
)
}
return (
<div style={{ padding: '0' }}>
<div style={{ marginBottom: 16 }}>
<div style={{ color: '#f9fafb', fontSize: 14, fontWeight: 600, marginBottom: 10 }}>
📈 连体钞/纪念钞 <span style={{ color: '#9ca3af', fontWeight: 400 }}>{dateStr}</span>
</div>
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(4, 1fr)', gap: 8 }}>
<StatCard label='全部' value={todayStats.total} color='#3b82f6' onClick={() => { setPostTypeFilter('all'); setCategoryFilter(''); setPage(1); }} />
<StatCard label='出售' value={todayStats.deals} color='#10b981' onClick={() => { setPostTypeFilter('deal'); setCategoryFilter(''); setPage(1); }} />
<StatCard label='求购' value={todayStats.wants} color='#f59e0b' onClick={() => { setPostTypeFilter('want'); setCategoryFilter(''); setPage(1); }} />
<StatCard label='其他' value={todayStats.others || 0} color='#8b5cf6' onClick={() => { setPostTypeFilter('other'); setCategoryFilter(''); setPage(1); }} />
</div>
</div>
<div style={{ background: 'linear-gradient(145deg, #1f2937 0%, #111827 100%)', borderRadius: 12, padding: 12, marginBottom: 20, border: '1px solid #374151' }}>
<div style={{ color: '#f9fafb', fontSize: 14, fontWeight: 600, marginBottom: 8 }}>📊 今日分类统计</div>
<div style={{ color: '#9ca3af', fontSize: 12 }}>: {todayStats.dragons || 0} | : {todayStats.horses || 0} | : {todayStats.snakes || 0} | 天马: {todayStats.tianma || 0}</div>
</div>
<div style={{ marginBottom: 12 }}>
<div style={{ display: 'flex', gap: 8 }}>
<input
type="text"
placeholder="搜索标题、内容、分类..."
value={searchKeyword}
onChange={(e) => { const kw = e.target.value; setSearchKeyword(kw); setPage(1); fetchPosts(1, '', kw) }}
style={{ flex: 1, padding: '10px 14px', borderRadius: 8, border: '1px solid #374151', background: '#1f2937', color: '#fff', fontSize: 13, outline: 'none' }}
/>
<button
onClick={() => { setSearchKeyword(''); setPage(1); fetchPosts(1, '') }}
style={{ padding: '10px 16px', borderRadius: 8, border: 'none', background: '#4b5563', color: '#fff', cursor: 'pointer', fontSize: 13 }}>
清空
</button>
</div>
{searchKeyword && <div style={{ color: '#9ca3af', fontSize: 12, marginTop: 6 }}>搜索: "{searchKeyword}"共找到 {totalPosts} 条结果</div>}
</div>
<div style={{ display: 'flex', gap: 8, marginBottom: 12 }}>
{[{key:'all',label:'全部'},{key:'deal',label:'出售'},{key:'want',label:'求购'},{key:'other',label:'其他'}].map(k => (
<button key={k.key} onClick={() => { setPostTypeFilter(k.key==='other'?'other':k.key); setCategoryFilter(''); setPage(1); }}
style={{ padding: '8px 16px', borderRadius: 8, border: 'none',
background: postTypeFilter===k.key ? 'linear-gradient(135deg, #3b82f6 0%, #2563eb 100%)' : '#374151', color: '#fff', cursor: 'pointer', fontSize: 13 }}>
{k.label}
</button>
))}
</div>
<div style={{ display: 'flex', gap: 8, marginBottom: 16 }}>
{[{key:'',label:'全部'},{key:'龙',label:'龙钞'},{key:'蛇',label:'蛇钞'},{key:'马',label:'马钞'},{key:'其他',label:'其他'}].map(k => (
<button key={k.key} onClick={() => { setCategoryFilter(k.key); setPage(1); }}
style={{ padding: '8px 16px', borderRadius: 8, border: 'none',
background: categoryFilter===k.key ? 'linear-gradient(135deg, #8b5cf6 0%, #7c3aed 100%)' : '#374151', color: '#fff', cursor: 'pointer', fontSize: 13 }}>
{k.label}
</button>
))}
</div>
{loading ? <div style={{textAlign:'center',color:'#9ca3af',padding:40}}>加载中...</div> : (
<div>
<div style={{ display: 'flex', flexDirection: 'column', gap: 12 }}>
{posts.length === 0 ? (
<div style={{ textAlign: 'center', color: '#9ca3af', padding: 40 }}>暂无帖子数据</div>
) : (
posts.map(post => (
<div key={post.post_id} style={{ background: 'linear-gradient(145deg, #1f2937 0%, #111827 100%)', borderRadius: 12, padding: 16, border: '1px solid #374151' }}>
<div onClick={() => togglePost(post.post_id)} style={{ cursor: 'pointer' }}>
<div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 8 }}>
<span style={{ color: '#fff', fontSize: 15, fontWeight: 500, flex: 1 }}>{post.title||'无标题'}</span>
<div style={{ display: 'flex', gap: 4 }}>
<span style={{ color: post.post_type==='deal'?'#10b981':post.post_type==='want'?'#f59e0b':post.post_type==='normal'?'#8b5cf6':'#9ca3af', fontSize: 12 }}>
{post.post_type==='deal'?'出售':post.post_type==='want'?'求购':post.post_type==='normal'?'其他':'普通'}
</span>
<span style={{ padding: '2px 8px', borderRadius: 4, fontSize: 11, background: post.category?.includes('龙') ? 'rgba(251,191,36,0.4)' : post.category?.includes('马') ? 'rgba(180,83,9,0.4)' : post.category?.includes('蛇') ? 'rgba(249,168,212,0.4)' : 'rgba(139,92,246,0.4)', color: post.category?.includes('龙') ? '#fde047' : post.category?.includes('马') ? '#d97706' : post.category?.includes('蛇') ? '#fbcfe8' : '#c4b5fd' }}>
{post.category || '-'}
</span>
</div>
</div>
<div style={{ display: 'flex', justifyContent: 'space-between', color: '#9ca3af', fontSize: 12 }}>
<span>{post.author_username||'未知'}</span>
<span>{post.post_time?.substring(0,16)||''}</span>
</div>
</div>
{expandedPosts[post.post_id] && post.content && (
<div style={{ marginTop: 12, paddingTop: 12, borderTop: '1px solid #374151' }}>
<div style={{ color: '#e2e8f0', fontSize: 13, lineHeight: 1.6, whiteSpace: 'pre-wrap', wordBreak: 'break-word', maxHeight: 300, overflowY: 'auto' }}>
{post.content}
</div>
{post.url && <a href={post.url} target='_blank' rel='noopener noreferrer' style={{ display:'inline-block', marginTop:12, padding:'8px 16px', background:'rgba(59,130,246,0.2)', borderRadius:8, color:'#60a5fa', textDecoration:'none', fontSize:13 }}>查看原帖</a>}
</div>
)}
</div>
))
)}
</div>
<div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', padding: '12px 16px', background: '#1e293b', borderRadius: 12, marginTop: 16 }}>
<div style={{ color: '#9ca3af', fontSize: 12 }}>
{totalPosts} 条结果{Math.ceil(totalPosts / 390)} 当前第 {page}
</div>
<div style={{ display: 'flex', gap: 8 }}>
{page > 1 ? (
<button onClick={() => { const newPage = page - 1; setPage(newPage); fetchPosts(newPage, categoryFilter, searchKeyword) }} style={{ padding: '6px 12px', borderRadius: 6, border: 'none', background: '#3b82f6', color: '#fff', cursor: 'pointer', fontSize: 12 }}>上一页</button>
) : (
<span style={{ padding: '6px 12px', borderRadius: 6, background: '#374151', color: '#6b7280', fontSize: 12 }}>上一页</span>
)}
{posts.length >= 390 && totalPosts > page * 390 ? (
<button onClick={() => { const newPage = page + 1; setPage(newPage); fetchPosts(newPage, categoryFilter, searchKeyword) }} style={{ padding: '6px 12px', borderRadius: 6, border: 'none', background: '#3b82f6', color: '#fff', cursor: 'pointer', fontSize: 12 }}>下一页</button>
) : (
<span style={{ padding: '6px 12px', borderRadius: 6, background: '#374151', color: '#6b7280', fontSize: 12 }}>下一页</span>
)}
</div>
</div>
</div>
)}
</div>
)
}

128
frontend/src/pages/news.py Normal file
View File

@ -0,0 +1,128 @@
from fastapi import APIRouter, Depends, HTTPException, Query
from sqlalchemy import Table, MetaData
from sqlalchemy.orm import Session
from pydantic import BaseModel
from typing import Optional, List
from datetime import datetime, date
from app.core.database import get_db, engine
from app.models.models import User
from app.routers.auth import get_current_user
router = APIRouter(prefix="/api/news", tags=["资讯"])
metadata = MetaData()
# 分类表
categories_table = Table('news_categories', metadata, autoload_with=engine)
news_table = Table('news', metadata, autoload_with=engine)
user_posts_table = Table('user_posts', metadata, autoload_with=engine)
users_table = Table('users', metadata, autoload_with=engine)
deals_table = Table('deals', metadata, autoload_with=engine)
notifications_table = Table('notifications', metadata, autoload_with=engine)
# ============ 获取分类 ============
@router.get("/categories")
def get_categories(db: Session = Depends(get_db)):
results = db.query(categories_table).order_by(categories_table.c.sort_order).all()
return [dict(r._mapping) for r in results]
# ============ 获取资讯 ============
@router.get("")
def get_news(
category_id: Optional[int] = None,
page: int = 1,
limit: int = 20,
db: Session = Depends(get_db)
):
query = db.query(news_table)
if category_id:
query = query.filter(news_table.c.category_id == category_id)
offset = (page - 1) * limit
results = query.order_by(news_table.c.created_at.desc()).offset(offset).limit(limit).all()
return [dict(r._mapping) for r in results]
# ============ 获取用户发布 ============
@router.get("/posts")
def get_posts(
post_type: Optional[str] = None,
status: str = "active",
page: int = 1,
limit: int = 20,
db: Session = Depends(get_db)
):
query = db.query(user_posts_table).filter(user_posts_table.c.status == status)
if post_type:
query = query.filter(user_posts_table.c.post_type == post_type)
offset = (page - 1) * limit
results = query.order_by(user_posts_table.c.created_at.desc()).offset(offset).limit(limit).all()
return [dict(r._mapping) for r in results]
# ============ 创建发布 ============
class PostCreate(BaseModel):
post_type: str
title: str
content: Optional[str] = None
zodiac_type: Optional[str] = None
packaging: Optional[str] = None
@router.post("/posts")
def create_post(
post: PostCreate,
current_user: User = Depends(get_current_user),
db: Session = Depends(get_db)
):
result = db.execute(user_posts_table.insert().values(
user_id=current_user.f99_90_id,
post_type=post.post_type,
title=post.title,
content=post.content,
zodiac_type=post.zodiac_type,
packaging=post.packaging,
status="pending"
))
db.commit()
return {"success": True, "id": result.inserted_primary_key[0]}
# ============ 成交数据 ============
@router.get("/deals")
def get_deals(
zodiac_type: Optional[str] = None,
limit: int = 20,
db: Session = Depends(get_db)
):
query = db.query(deals_table)
if zodiac_type:
query = query.filter(deals_table.c.zodiac_type == zodiac_type)
results = query.order_by(deals_table.c.deal_date.desc()).limit(limit).all()
return [dict(r._mapping) for r in results]
# ============ 通知 ============
@router.get("/notifications")
def get_notifications(limit: int = 10, db: Session = Depends(get_db)):
results = db.query(notifications_table).filter(
notifications_table.c.is_published == True
).order_by(notifications_table.c.created_at.desc()).limit(limit).all()
return [dict(r._mapping) for r in results]
# ============ 首页数据 ============
@router.get("/home")
def get_home(db: Session = Depends(get_db)):
# 推荐发布
posts = db.query(user_posts_table).filter(
user_posts_table.c.status == "active"
).order_by(user_posts_table.c.created_at.desc()).limit(10).all()
# 成交
deals = db.query(deals_table).order_by(
deals_table.c.deal_date.desc()
).limit(10).all()
# 通知
notices = db.query(notifications_table).filter(
notifications_table.c.is_published == True
).order_by(notifications_table.c.created_at.desc()).limit(5).all()
return {
"posts": [dict(p._mapping) for p in posts],
"deals": [dict(d._mapping) for d in deals],
"notices": [dict(n._mapping) for n in notices]
}

267
frontend/src/utils/api.js Normal file
View File

@ -0,0 +1,267 @@
// 统一的 API 客户端
const API_BASE = '' // 生产环境由 Nginx 代理
import { ErrorCodes, matchErrorCode } from './errorCodes.js'
// 错误处理
class ApiError extends Error {
constructor(message, status, data, code = null) {
super(message)
this.name = 'ApiError'
this.status = status
this.data = data
this.code = code || matchErrorCode(status, message).code
}
// 获取格式化的错误信息
get formattedMessage() {
return `${this.code}: ${this.message}`
}
}
// 获取 Token - 优先从Cookie读取兼容localStorage
const getToken = () => {
// 先尝试从Cookie获取
const cookies = document.cookie.split(';')
for (let cookie of cookies) {
const [name, value] = cookie.trim().split('=')
if (name === 'token') {
return value
}
}
// 兼容再从localStorage获取
return localStorage.getItem('token')
}
// 设置 Token - 同时设置Cookie和localStorage
const setToken = (token) => {
if (token) {
// 设置Cookie7天有效期
const expires = new Date()
expires.setDate(expires.getDate() + 7)
document.cookie = `token=${token};expires=${expires.toUTCString()};path=/;samesite=lax`
// 同时存localStorage兼容原有逻辑
localStorage.setItem('token', token)
}
}
// 清除 Token
const removeToken = () => {
// 清除Cookie
document.cookie = 'token=;expires=Thu, 01 Jan 1970 00:00:00 GMT;path=/'
// 清除localStorage
localStorage.removeItem('token')
localStorage.removeItem('user')
}
// 统一请求方法
async function request(endpoint, options = {}) {
const token = getToken()
const defaultHeaders = {
'Content-Type': 'application/json',
}
if (token) {
defaultHeaders['Authorization'] = `Bearer ${token}`
}
const config = {
...options,
headers: {
...defaultHeaders,
...(options.headers || {})
}
}
try {
const response = await fetch(`${API_BASE}${endpoint}`, config)
const data = await response.json()
if (!response.ok) {
// 处理 401 未授权
if (response.status === 401) {
removeToken()
window.location.hash = '#/login'
throw new ApiError(
data.detail || data.message || '登录已过期,请重新登录',
401,
data,
'E00010'
)
}
// 处理 422 验证错误
if (response.status === 422 && data.detail) {
const detail = Array.isArray(data.detail) ? data.detail[0] : data.detail
const field = detail.loc ? detail.loc.join('.') : ''
const msg = detail.msg || detail.message || data.message
throw new ApiError(
`${field}: ${msg}`,
422,
data
)
}
// 其他错误
throw new ApiError(
data.detail || data.message || data.error || '请求失败',
response.status,
data
)
}
return data
} catch (error) {
// 网络错误
if (error.name === 'TypeError' && error.message.includes('fetch')) {
throw new ApiError('网络连接失败,请检查网络', 0, null, 'E00001')
}
throw error
}
}
// API 模块
export const api = {
// 认证
auth: {
login: async (username, password) => {
// 登录时不使用 token
const params = new URLSearchParams()
params.append('username', username)
params.append('password', password)
const response = await fetch(`${API_BASE}/api/auth/login`, {
method: 'POST',
credentials: 'include', // 包含Cookie
headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
body: params.toString()
})
const data = await response.json()
if (!response.ok) {
// 优先使用 error.code 和 error.message后端标准格式
const errorCode = data.error?.code || data.code
const errorMsg = data.error?.message || data.detail || data.message || '登录失败'
const error = new ApiError(errorMsg, response.status, data)
if (errorCode) error.code = errorCode
throw error
}
// 登录成功保存Token同时存Cookie和localStorage
if (data.access_token) {
setToken(data.access_token)
}
return data
},
register: (data) => request('/api/auth/register', {
method: 'POST',
body: JSON.stringify(data)
})
},
// 当前用户
user: {
me: async () => {
const token = getToken()
if (!token) throw new ApiError('未登录', 401, null, 'E00010')
const response = await fetch(`${API_BASE}/api/users/me`, {
headers: { 'Authorization': `Bearer ${token}` }
})
const data = await response.json()
if (!response.ok) {
throw new ApiError(
data.detail || data.message || '获取用户信息失败',
response.status,
data
)
}
return data
},
update: (data) => request('/api/users/me', {
method: 'PUT',
body: JSON.stringify(data)
})
},
// 藏品
collections: {
// 列表
list: (params = {}) => {
const query = new URLSearchParams(params).toString()
return request(`/api/collections${query ? '?' + query : ''}`)
},
// 详情
get: (id) => request(`/api/collections/${id}`),
// 创建
create: (data) => request('/api/collections', {
method: 'POST',
body: JSON.stringify(data)
}),
// 更新
update: (id, data) => request(`/api/collections/${id}`, {
method: 'PUT',
body: JSON.stringify(data)
}),
// 删除
delete: (id) => request(`/api/collections/${id}`, {
method: 'DELETE'
}),
// 下一个编号
nextCode: () => request('/api/collections/next-code'),
// 统计
stats: (params = {}) => {
const query = new URLSearchParams(params).toString()
return request(`/api/collections/stats${query ? '?' + query : ''}`)
},
// 导出
export: (params) => request(`/api/collections/export?${new URLSearchParams(params)}`)
},
// OCR
ocr: {
recognize: (file) => {
const formData = new FormData()
formData.append('image', file)
return request('/api/ocr/recognize', {
method: 'POST',
body: formData
})
}
},
// 用户管理(仅管理员)
admin: {
users: {
list: (page = 1, limit = 20) => request(`/api/admin/users?page=${page}&limit=${limit}`),
get: (userId) => request(`/api/admin/users/${userId}`),
collections: (userId) => request(`/api/admin/users/${userId}/collections`),
count: (userId) => request(`/api/admin/users/${userId}/count`)
}
}
}
// 导出错误类
export { ApiError }
// 默认导出
export default api

View File

@ -0,0 +1,165 @@
// 错误码定义
// 格式E + 模块 (2 位) + 序号 (3 位)
export const ErrorCodes = {
// ============ 通用错误 (00-09) ============
E00000: { code: 'E00000', message: '未知错误', httpStatus: 0 },
E00001: { code: 'E00001', message: '网络连接失败,请检查网络', httpStatus: 0 },
E00002: { code: 'E00002', message: '服务器响应超时', httpStatus: 0 },
E00003: { code: 'E00003', message: '服务器内部错误', httpStatus: 500 },
// ============ 认证错误 (10-19) ============
E00010: { code: 'E00010', message: '未登录或登录已过期', httpStatus: 401 },
E00011: { code: 'E00011', message: '用户名或密码错误', httpStatus: 401 },
E00012: { code: 'E00012', message: '验证码错误', httpStatus: 400 },
E00013: { code: 'E00013', message: '账号已被禁用', httpStatus: 403 },
E00014: { code: 'E00014', message: '无权访问此资源', httpStatus: 403 },
E00015: { code: 'E00015', message: '令牌无效或已过期', httpStatus: 401 },
// ============ 登录注册 (20-29) ============
E00020: { code: 'E00020', message: '请输入用户名和密码', httpStatus: 400 },
E00021: { code: 'E00021', message: '用户名至少 3 个字符', httpStatus: 400 },
E00022: { code: 'E00022', message: '密码至少 6 个字符', httpStatus: 400 },
E00023: { code: 'E00023', message: '用户名已存在', httpStatus: 400 },
E00024: { code: 'E00024', message: '邮箱已被注册', httpStatus: 400 },
E00025: { code: 'E00025', message: '邮箱格式不正确', httpStatus: 400 },
E00026: { code: 'E00026', message: '手机号格式不正确', httpStatus: 400 },
// ============ 藏品管理 (30-39) ============
E00030: { code: 'E00030', message: '藏品名称不能为空', httpStatus: 400 },
E00031: { code: 'E00031', message: '藏品名称至少 2 个字符', httpStatus: 400 },
E00032: { code: 'E00032', message: '藏品分类不能为空', httpStatus: 400 },
E00033: { code: 'E00033', message: '藏品不存在', httpStatus: 404 },
E00034: { code: 'E00034', message: '禁止重复:此冠字号已存在', httpStatus: 400 },
E00035: { code: 'E00035', message: '成本价格必须>=0', httpStatus: 400 },
E00036: { code: 'E00036', message: '目标价格必须>=0', httpStatus: 400 },
E00037: { code: 'E00037', message: '发行年份必须是 4 位数字', httpStatus: 400 },
E00038: { code: 'E00038', message: '图片格式不正确', httpStatus: 400 },
E00039: { code: 'E00039', message: '图片大小不能超过 10MB', httpStatus: 400 },
// ============ OCR 识别 (40-49) ============
E00040: { code: 'E00040', message: '请选择图片文件', httpStatus: 400 },
E00041: { code: 'E00041', message: '图片尺寸太小,无法识别', httpStatus: 400 },
E00042: { code: 'E00042', message: 'OCR 识别失败,请重试', httpStatus: 500 },
E00043: { code: 'E00043', message: 'OCR 服务暂时不可用', httpStatus: 503 },
E00044: { code: 'E00044', message: '无法识别图片内容', httpStatus: 400 },
// ============ 用户管理 (50-59) ============
E00050: { code: 'E00050', message: '仅管理员可访问', httpStatus: 403 },
E00051: { code: 'E00051', message: '用户不存在', httpStatus: 404 },
E00052: { code: 'E00052', message: '不能删除自己', httpStatus: 400 },
E00053: { code: 'E00053', message: '不能修改自己的角色', httpStatus: 403 },
// ============ 文件上传 (60-69) ============
E00060: { code: 'E00060', message: '文件太大', httpStatus: 400 },
E00061: { code: 'E00061', message: '不支持的文件格式', httpStatus: 400 },
E00062: { code: 'E00062', message: '上传失败', httpStatus: 500 },
}
// 根据 HTTP 状态码和错误信息匹配错误码
export function matchErrorCode(status, errorMessage = '') {
// 首先尝试精确匹配错误信息
for (const code in ErrorCodes) {
const error = ErrorCodes[code]
if (error.httpStatus === status) {
// 检查错误信息是否包含关键词
const msg = errorMessage.toLowerCase()
if (status === 401) {
if (msg.includes('password') || msg.includes('密码')) return ErrorCodes.E00011
if (msg.includes('token') || msg.includes('令牌')) return ErrorCodes.E00015
return ErrorCodes.E00010
}
if (status === 403) {
if (msg.includes('admin') || msg.includes('管理员')) return ErrorCodes.E00050
return ErrorCodes.E00014
}
if (status === 404) {
if (msg.includes('user')) return ErrorCodes.E00051
if (msg.includes('collection') || msg.includes('藏品')) return ErrorCodes.E00033
}
if (status === 400) {
if (msg.includes('captcha') || msg.includes('验证码')) return ErrorCodes.E00012
if (msg.includes('username') || msg.includes('用户名')) return ErrorCodes.E00023
if (msg.includes('email') || msg.includes('邮箱')) return ErrorCodes.E00024
if (msg.includes('重复') || msg.includes('duplicate')) return ErrorCodes.E00034
if (msg.includes('价格') || msg.includes('price')) {
if (msg.includes('greater') || msg.includes('>=')) return ErrorCodes.E00035
}
if (msg.includes('year') || msg.includes('年份')) return ErrorCodes.E00037
if (msg.includes('image') || msg.includes('图片')) return ErrorCodes.E00038
}
if (status === 422) {
// 验证错误
if (msg.includes('cost_price') || msg.includes('成本')) return ErrorCodes.E00035
if (msg.includes('target_price') || msg.includes('目标价格')) return ErrorCodes.E00036
if (msg.includes('issue_year') || msg.includes('年份')) return ErrorCodes.E00037
if (msg.includes('name') || msg.includes('名称')) return ErrorCodes.E00031
if (msg.includes('category') || msg.includes('分类')) return ErrorCodes.E00032
}
if (status === 500) {
if (msg.includes('ocr') || msg.includes('识别')) return ErrorCodes.E00042
}
}
}
// 默认错误码
if (status === 0) return ErrorCodes.E00001
if (status >= 500) return ErrorCodes.E00003
return ErrorCodes.E00000
}
// 格式化错误信息
export function formatError(error) {
if (error.code && typeof error.code === 'string' && error.code.startsWith('E')) {
// 已经是错误码格式
const errorCode = ErrorCodes[error.code]
if (errorCode) {
return `${errorCode.code}: ${errorCode.message}`
}
}
// 匹配错误码
const status = error.status || error.httpStatus || 0
const message = error.message || error.detail || error.error || ''
const errorCode = matchErrorCode(status, message)
return `${errorCode.code}: ${errorCode.message}`
}
// 显示错误 Toast
export function showErrorToast(error, duration = 3000) {
const errorMessage = formatError(error)
// 创建 Toast 元素
const toast = document.createElement('div')
toast.style.cssText = `
position: fixed;
top: 20px;
left: 50%;
transform: translateX(-50%);
background: rgba(239, 68, 68, 0.95);
color: white;
padding: 12px 24px;
border-radius: 8px;
font-size: 14px;
z-index: 9999;
box-shadow: 0 4px 12px rgba(0,0,0,0.3);
animation: slideDown 0.3s ease;
`
toast.textContent = errorMessage
document.body.appendChild(toast)
// 3 秒后移除
setTimeout(() => {
toast.style.animation = 'slideUp 0.3s ease'
setTimeout(() => toast.remove(), 300)
}, duration)
}
export default { ErrorCodes, matchErrorCode, formatError, showErrorToast }

View File

@ -0,0 +1,129 @@
/**
* 号码分类工具
* 根据冠字号自动分类为圆圆号倒置号金马王金马号金山王天马王金山号天马号朦胧号如意号钻石号永恒号带7号带4号
*/
// 分类定义(按优先级排序)
const CATEGORIES = [
{ name: '圆圆号', mustNot: ['1','2','3','4','5','7'], mustHave: [] },
{ name: '倒置号', mustNot: ['2','3','4','5','7'], mustHave: ['1'] },
{ name: '金马王', mustNot: ['1','2','3','4','7'], mustHave: ['5'] },
{ name: '金马号', mustNot: ['2','3','4','7'], mustHave: ['1','5'] },
{ name: '金山王', mustNot: ['1','2','4','5','7'], mustHave: ['3'] },
{ name: '天马王', mustNot: ['1','2','4','7'], mustHave: ['3','5'] },
{ name: '金山号', mustNot: ['2','4','5','7'], mustHave: ['1','3'] },
{ name: '天马号', mustNot: ['2','4','7'], mustHave: ['1','3','5'] },
{ name: '朦胧号', mustNot: ['3','4','5','7'], mustHave: [] },
{ name: '如意号', mustNot: ['1','3','4','7'], mustHave: [] },
{ name: '钻石号', mustNot: ['3','4','7'], mustHave: [] },
{ name: '永恒号', mustNot: ['4','7'], mustHave: [] },
{ name: '带7号', mustNot: ['4'], mustHave: ['7'] },
{ name: '带4号', mustNot: [], mustHave: ['4'] },
]
/**
* 提取冠字号中的数字部分
* @param {string} serial - 冠字号 J0123456789 J0123456781 J0123456701
* @returns {object} - { digits: 数字串, type: 'single'|'ten'|'hundred' }
*/
export function extractDigits(serial) {
if (!serial) return { digits: '', type: 'single' }
// 去掉J取数字部分
const nums = serial.replace(/J/g, '').replace(/\D/g, '')
// 判断类型
if (nums.endsWith('01')) {
// 标百去掉最后2位
return { digits: nums.slice(0, -2), type: 'hundred' }
} else if (nums.endsWith('1')) {
// 标十去掉最后1位
return { digits: nums.slice(0, -1), type: 'ten' }
} else {
// 单张:全部数字
return { digits: nums, type: 'single' }
}
}
/**
* 号码分类函数
* @param {string} serial - 冠字号
* @returns {string} - 分类名称
*/
export function getNumberCategory(serial) {
const { digits } = extractDigits(serial)
if (!digits || digits.length < 7) {
return '其他'
}
// 按优先级匹配
for (const cat of CATEGORIES) {
if (matchesCategory(digits, cat)) {
return cat.name
}
}
return '其他'
}
/**
* 检查数字是否匹配分类条件
* @param {string} digits - 数字串
* @param {object} category - 分类定义
* @returns {boolean}
*/
function matchesCategory(digits, category) {
const mustNot = category.mustNot
const mustHave = category.mustHave
// 1. 检查必须不含的数字
for (const n of mustNot) {
if (digits.includes(n)) {
return false
}
}
// 2. 检查必须含有的数字
for (const n of mustHave) {
if (!digits.includes(n)) {
return false
}
}
return true
}
/**
* 获取分类颜色
* @param {string} category - 分类名称
* @returns {string} - 颜色 hex
*/
export function getNumberCategoryColor(category) {
const colors = {
'圆圆号': '#8b5cf6', // 紫
'倒置号': '#ec4899', // 粉
'金马王': '#f59e0b', // 金
'金马号': '#ef4444', // 红
'金山王': '#14b8a6', // 青
'天马王': '#06b6d4', // 蓝
'金山号': '#0d9488', // 绿松石
'天马号': '#22c55e', // 绿
'朦胧号': '#6366f1', // 靛蓝
'如意号': '#a855f7', // 紫红
'钻石号': '#eab308', // 黄
'永恒号': '#3b82f6', // <20><><EFBFBD>
'带7号': '#f97316', // 橙
'带4号': '#64748b', // 灰
'其他': '#94a3b8',
}
return colors[category] || colors['其他']
}
/**
* 分类优先级用于排序
*/
export const NUMBER_CATEGORY_ORDER = CATEGORIES.map(c => c.name)
// 可选值列表(用于下拉框)
export const NUMBER_CATEGORY_OPTIONS = CATEGORIES.map(c => ({ value: c.name, label: c.name }))

View File

View File

@ -0,0 +1,240 @@
# Logo 使用规范
**版本**: v1.0.0
**更新日期**: 2026-03-16
**状态**: ✅ 官方指定 Logo
---
## 🐉 官方 Logo
### 主 Logo
**文件**: `jiachenlong-logo.png`
**位置**:
- 本地:`/static/images/jiachenlong-logo.png`
- 前端服务器:`/var/www/html/static/images/jiachenlong-logo.png`
**规格**:
- 格式PNG
- 大小606KB
- 尺寸:正方形(适合圆形裁剪)
- 颜色:橙色(中国传统色)
- 设计:龙型环绕 + "甲辰收藏"文字
---
## 📋 使用场景
### 1. 登录页面
**文件**: `frontend/src/pages/Login.jsx`
```jsx
<img
src="/static/images/jiachenlong-logo.png"
alt="甲辰收藏"
style={{
width: '200px',
height: '200px',
borderRadius: '50%',
boxShadow: '0 0 40px rgba(251, 191, 36, 0.4)',
background: '#fff'
}}
/>
```
### 2. 首页
**文件**: `frontend/src/pages/Home.jsx`
```jsx
<img
src="/static/images/jiachenlong-logo.png"
alt="甲辰收藏"
style={{
width: '48px',
height: '48px',
borderRadius: '50%',
objectFit: 'cover'
}}
/>
```
### 3. 藏品详情页
**文件**: `frontend/src/pages/Detail.jsx`
```jsx
<img
src="/static/images/jiachenlong-logo.png"
alt="甲辰收藏"
onError={(e) => {
e.target.src = '/static/images/jiachenlong-logo.png';
}}
/>
```
---
## 🎨 样式规范
### 圆形样式(推荐)
```css
.logo {
width: 200px;
height: 200px;
border-radius: 50%;
object-fit: cover;
box-shadow: 0 0 40px rgba(251, 191, 36, 0.4);
background: #fff;
}
```
### 小尺寸(导航栏等)
```css
.logo-small {
width: 48px;
height: 48px;
border-radius: 50%;
object-fit: cover;
}
```
### 中等尺寸
```css
.logo-medium {
width: 100px;
height: 100px;
border-radius: 50%;
object-fit: cover;
}
```
---
## 📦 部署规范
### 部署脚本
**文件**: `scripts/deploy.sh`
部署脚本会自动:
1. ✅ 检查 Logo 文件是否存在
2. ✅ 部署前端构建文件
3. ✅ 部署 Logo 到服务器
4. ✅ 重启 Nginx
### 部署命令
```bash
# 测试环境
./scripts/deploy.sh 1.0.0 test
# 生产环境
./scripts/deploy.sh 1.0.0 production
```
### 手动部署
```bash
# 1. 构建前端
cd frontend
npm run build
# 2. 部署到服务器
scp -r dist/* root@8.149.137.26:/var/www/html/
scp static/images/jiachenlong-logo.png root@8.149.137.26:/var/www/html/static/images/
# 3. 重启 Nginx
ssh root@8.149.137.26 "nginx -s reload"
```
---
## ⚠️ 注意事项
### 必须遵守
1. ✅ **统一使用** `jiachenlong-logo.png`
2. ✅ **禁止使用** 旧版 `logo.jpg`、`dragon-logo.jpg`、`title_logo.svg`
3. ✅ **保持比例** - 始终使用正方形容器
4. ✅ **圆形裁剪** - 使用 `border-radius: 50%`
5. ✅ **白色背景** - Logo 需要白色背景衬托
### 禁止行为
- ❌ 不要修改 Logo 颜色
- ❌ 不要拉伸变形
- ❌ 不要添加其他效果
- ❌ 不要使用其他 Logo 文件
---
## 📁 文件位置
### 本地开发
```
jiachenlong/
└── static/
└── images/
└── jiachenlong-logo.png # ✅ 官方 Logo
```
### 前端服务器
```
/var/www/html/
└── static/
└── images/
└── jiachenlong-logo.png # ✅ 官方 Logo
```
---
## 🔄 更新流程
如需更新 Logo
1. **替换文件**
```bash
cp new-logo.png /static/images/jiachenlong-logo.png
```
2. **重新构建**
```bash
cd frontend
npm run build
```
3. **部署到服务器**
```bash
./scripts/deploy.sh 1.0.1 production
```
4. **验证部署**
```bash
curl http://8.149.137.26/static/images/jiachenlong-logo.png -o /tmp/logo-check.png
```
---
## 📊 Logo 对比
| 文件 | 状态 | 说明 |
|------|------|------|
| `jiachenlong-logo.png` | ✅ **官方指定** | 橙色圆形龙型 Logo |
| `logo.jpg` | ❌ 废弃 | 旧版 Logo |
| `dragon-logo.jpg` | ❌ 废弃 | 旧版龙型 Logo |
| `title_logo.svg` | ❌ 废弃 | 旧版 SVG Logo |
---
**所有部署必须使用 `jiachenlong-logo.png`**
**最后更新**: 2026-03-16

View File

@ -0,0 +1,36 @@
# 图片资源
本目录存放项目的所有图片资源。
## 📁 文件列表
- `logo.jpg` - 系统主 Logo106KB, 512x512
## 🎨 使用方式
### 前端访问
```jsx
<img src="/static/images/logo.jpg" alt="logo" />
```
### 后端访问FastAPI
```python
from fastapi.staticfiles import StaticFiles
app.mount("/static", StaticFiles(directory="static"), name="static")
```
## 📐 建议尺寸
- **Logo**: 512x512 或更大(用于缩放)
- **背景图**: 1920x1080全屏背景
- **头像**: 200x200用户头像
## 📦 格式建议
- **Logo**: PNG透明背景或 JPG
- **照片**: JPG压缩比好
- **图标**: SVG矢量可缩放或 PNG
---
**最后更新**: 2026-03-16

Binary file not shown.

After

Width:  |  Height:  |  Size: 133 KiB

View File

@ -0,0 +1,26 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 400 80">
<defs>
<linearGradient id="goldGrad" x1="0%" y1="0%" x2="100%" y2="100%">
<stop offset="0%" stop-color="#FFE4B5"/>
<stop offset="25%" stop-color="#FFD700"/>
<stop offset="50%" stop-color="#FFA500"/>
<stop offset="75%" stop-color="#DAA520"/>
<stop offset="100%" stop-color="#B8860B"/>
</linearGradient>
<filter id="glow">
<feGaussianBlur stdDeviation="1.5" result="blur"/>
<feFlood flood-color="#FFD700" flood-opacity="0.6"/>
<feComposite in2="blur" operator="in"/>
<feMerge><feMergeNode/><feMergeNode in="SourceGraphic"/></feMerge>
</filter>
<filter id="shadow">
<feDropShadow dx="2" dy="3" stdDeviation="2" flood-color="#000" flood-opacity="0.5"/>
</filter>
</defs>
<!-- Main title -->
<text x="0" y="45" font-family="'Kaiti SC', 'STKaiti', 'KaiTi', 'SimKai', serif" font-size="52" font-weight="bold" fill="url(#goldGrad)" filter="url(#shadow)">甲辰收藏</text>
<!-- Subtitle -->
<text x="0" y="72" font-family="'Kaiti SC', 'STKaiti', 'KaiTi', 'SimKai', serif" font-size="20" fill="#DAA520" letter-spacing="4">生肖纪念钞管理系统</text>
</svg>

After

Width:  |  Height:  |  Size: 1.2 KiB

59
frontend/vite.config.js Normal file
View File

@ -0,0 +1,59 @@
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
import { readFileSync, writeFileSync } from 'fs'
import { join } from 'path'
// 从 config/VERSION 文件读取版本号
function getVersion() {
try {
const versionFile = join(__dirname, '..', 'config', 'VERSION')
const content = readFileSync(versionFile, 'utf-8').trim()
// 移除 VERSION= 前缀
if (content.startsWith('VERSION=')) {
return content.substring(7).trim()
}
return content || '0.0.0'
} catch (e) {
console.error('读取 VERSION 文件失败:', e.message)
return '0.0.0'
}
}
const APP_VERSION = getVersion()
console.log('📦 构建版本v' + APP_VERSION)
// 构建时自动更新 index.html 的 title
function updateHtmlTitle() {
try {
const htmlPath = join(__dirname, 'index.html')
let htmlContent = readFileSync(htmlPath, 'utf-8')
// 替换 <title>甲辰收藏 vXXX</title>
htmlContent = htmlContent.replace(
/<title>甲辰收藏 v[\d.]+<\/title>/,
'<title>甲辰收藏 v' + APP_VERSION + '</title>'
)
writeFileSync(htmlPath, htmlContent, 'utf-8')
console.log('✅ 已更新 index.html title: 甲辰收藏 v' + APP_VERSION)
} catch (e) {
console.error('更新 index.html 失败:', e.message)
}
}
// 构建前执行
updateHtmlTitle()
export default defineConfig({
plugins: [react()],
define: {
'import.meta.env.APP_VERSION': JSON.stringify(APP_VERSION)
},
build: {
rollupOptions: {
output: {
entryFileNames: 'assets/[name]-[hash]-[name].js',
chunkFileNames: 'assets/[name]-[hash].js',
assetFileNames: 'assets/[name]-[hash].[ext]'
}
}
}
})