From 198ccd39769bfe8741b080b7fe80e6eeac1bca90 Mon Sep 17 00:00:00 2001
From: jinghui <181050043@qq.com>
Date: Thu, 22 Oct 2026 12:07:09 +0800
Subject: [PATCH] =?UTF-8?q?v1.1.0:=20AI=E5=9B=9E=E5=A4=8Dmax=5Ftokens?=
=?UTF-8?q?=E8=B0=83=E4=BC=98=20+=20=E5=95=86=E5=93=81=E7=BC=96=E8=BE=91(?=
=?UTF-8?q?=E6=A0=87=E9=A2=98/=E4=BB=B7=E6=A0=BC/=E6=8F=8F=E8=BF=B0)=20+?=
=?UTF-8?q?=20API=E5=AF=86=E9=92=A5=E6=8E=A9=E7=A0=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
- ai_reply_engine.py: 意图识别max_tokens=100, 回复生成max_tokens=2048
(deepseek-v4-flash推理模型思考吃光token导致回复为空)
- 商品管理弹窗新增标题/价格/描述编辑, 写入本地item_info
(闲鱼网页版不支持改真实商品, 界面已注明)
- GET ai-reply-settings密钥掩码 sk-4****27QK, PUT含****保留原值
- 新增自定义Dockerfile固化max_tokens补丁
- 新增.gitignore排除.env/data/logs/db, 仓库不含密钥
---
.dockerignore | 193 +
.gitignore | 32 +
CHANGELOG.md | 40 +
Dockerfile | 107 +
Dockerfile-cn | 110 +
Start.py | 142 +
XianyuAutoAsync.py | 4360 ++++++
ai_reply_engine.py | 370 +
config.py | 122 +
cookie_manager.py | 325 +
db_manager.py | 5202 ++++++++
docker-compose-cn.yml | 105 +
docker-compose.yml | 105 +
docker-deploy.bat | 228 +
docker-deploy.sh | 360 +
entrypoint.sh | 15 +
file_log_collector.py | 240 +
global_config.yml | 89 +
nginx/nginx.conf | 123 +
reply_server.py | 5014 +++++++
requirements.txt | 81 +
secure_confirm_decrypted.py | 180 +
secure_confirm_ultra.py | 42 +
secure_freeshipping_decrypted.py | 130 +
secure_freeshipping_ultra.py | 43 +
static/css/accounts.css | 227 +
static/css/admin.css | 405 +
static/css/app.css | 13 +
static/css/components.css | 403 +
static/css/dashboard.css | 68 +
static/css/items.css | 52 +
static/css/keywords.css | 403 +
static/css/layout.css | 202 +
static/css/logs.css | 147 +
static/css/notifications.css | 83 +
static/css/variables.css | 26 +
static/data_management.html | 556 +
static/index.html | 4458 +++++++
static/item_search.html | 1503 +++
static/js/app.js | 10915 ++++++++++++++++
.../lib/bootstrap-icons/bootstrap-icons.css | 2078 +++
.../fonts/bootstrap-icons.woff | Bin 0 -> 176196 bytes
.../fonts/bootstrap-icons.woff2 | Bin 0 -> 130764 bytes
static/lib/bootstrap/bootstrap.bundle.min.js | 7 +
static/lib/bootstrap/bootstrap.min.css | 6 +
static/log_management.html | 457 +
static/login.html | 673 +
static/qq-group.png | Bin 0 -> 145802 bytes
static/register.html | 576 +
static/user_management.html | 400 +
static/wechat-group.png | Bin 0 -> 170333 bytes
static/xianyu_js_version_2.js | 568 +
utils/agiso_client.py | 569 +
utils/image_uploader.py | 216 +
utils/image_utils.py | 256 +
utils/item_publisher.py | 333 +
utils/item_search.py | 1179 ++
utils/message_utils.py | 29 +
utils/order_detail_fetcher.py | 752 ++
utils/qr_login.py | 451 +
utils/user_profile.py | 215 +
utils/ws_utils.py | 89 +
utils/xianyu_utils.py | 379 +
63 files changed, 46452 insertions(+)
create mode 100644 .dockerignore
create mode 100644 .gitignore
create mode 100644 CHANGELOG.md
create mode 100644 Dockerfile
create mode 100644 Dockerfile-cn
create mode 100644 Start.py
create mode 100644 XianyuAutoAsync.py
create mode 100644 ai_reply_engine.py
create mode 100644 config.py
create mode 100644 cookie_manager.py
create mode 100644 db_manager.py
create mode 100644 docker-compose-cn.yml
create mode 100644 docker-compose.yml
create mode 100644 docker-deploy.bat
create mode 100644 docker-deploy.sh
create mode 100644 entrypoint.sh
create mode 100644 file_log_collector.py
create mode 100644 global_config.yml
create mode 100644 nginx/nginx.conf
create mode 100644 reply_server.py
create mode 100644 requirements.txt
create mode 100644 secure_confirm_decrypted.py
create mode 100644 secure_confirm_ultra.py
create mode 100644 secure_freeshipping_decrypted.py
create mode 100644 secure_freeshipping_ultra.py
create mode 100644 static/css/accounts.css
create mode 100644 static/css/admin.css
create mode 100644 static/css/app.css
create mode 100644 static/css/components.css
create mode 100644 static/css/dashboard.css
create mode 100644 static/css/items.css
create mode 100644 static/css/keywords.css
create mode 100644 static/css/layout.css
create mode 100644 static/css/logs.css
create mode 100644 static/css/notifications.css
create mode 100644 static/css/variables.css
create mode 100644 static/data_management.html
create mode 100644 static/index.html
create mode 100644 static/item_search.html
create mode 100644 static/js/app.js
create mode 100644 static/lib/bootstrap-icons/bootstrap-icons.css
create mode 100644 static/lib/bootstrap-icons/fonts/bootstrap-icons.woff
create mode 100644 static/lib/bootstrap-icons/fonts/bootstrap-icons.woff2
create mode 100644 static/lib/bootstrap/bootstrap.bundle.min.js
create mode 100644 static/lib/bootstrap/bootstrap.min.css
create mode 100644 static/log_management.html
create mode 100644 static/login.html
create mode 100644 static/qq-group.png
create mode 100644 static/register.html
create mode 100644 static/user_management.html
create mode 100644 static/wechat-group.png
create mode 100644 static/xianyu_js_version_2.js
create mode 100644 utils/agiso_client.py
create mode 100644 utils/image_uploader.py
create mode 100644 utils/image_utils.py
create mode 100644 utils/item_publisher.py
create mode 100644 utils/item_search.py
create mode 100644 utils/message_utils.py
create mode 100644 utils/order_detail_fetcher.py
create mode 100644 utils/qr_login.py
create mode 100644 utils/user_profile.py
create mode 100644 utils/ws_utils.py
create mode 100644 utils/xianyu_utils.py
diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 0000000..0ce6c78
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,193 @@
+# Git相关
+.git
+.gitignore
+.gitattributes
+
+# Python相关
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# 虚拟环境
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE相关
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# 操作系统相关
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# 日志文件
+logs/*.log
+*.log
+
+# 数据库文件(构建时不包含,运行时挂载)
+*.db
+*.sqlite
+*.sqlite3
+
+# 临时文件
+*.tmp
+*.temp
+temp/
+tmp/
+
+# 测试文件
+test_*.py
+*_test.py
+tests/
+
+# 文档
+*.md
+docs/
+
+# Docker相关(保留必要的构建文件)
+.dockerignore.bak
+docker-compose.override.yml
+
+# 配置文件(运行时挂载)
+# global_config.yml
+
+# 环境变量文件
+.env
+.env.*
+!.env.example
+*.local.yml
+*.dev.yml
+*.test.yml
+config.*.yml
+!global_config.yml
+
+# 前端相关
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+package-lock.json
+yarn.lock
+
+# 数据目录(运行时挂载)
+data/
+backups/
+logs/
+realtime.log
+
+# 上传文件
+static/uploads/*
+!static/uploads/.gitkeep
+!static/uploads/images/
+static/uploads/images/*
+!static/uploads/images/.gitkeep
+
+# Excel和数据文件
+*.xlsx
+*.xls
+*.csv
+keywords_*.xlsx
+export_*.csv
+export_*.json
+export_*.xlsx
+
+# 压缩文件
+*.zip
+*.tar.gz
+*.rar
+*.7z
+
+# 备份文件
+*.bak
+*.backup
+*.old
+
+# 密钥和证书
+*.key
+*.pem
+*.crt
+*.cert
+*.p12
+*.pfx
+ssl/
+secrets/
+credentials/
+
+# 运行时文件
+*.pid
+*.sock
+*.lock
+*.port
+
+# 性能分析文件
+*.prof
+*.profile
+*.pstats
+
+# 缓存文件
+.cache/
+cache/
+*.cache
+
+# 浏览器相关
+.playwright/
+playwright-report/
+test-results/
+
+# 示例和演示文件
+example_*.py
+*_example.py
+demo_*.py
+*_demo.py
+
+# AI模型文件
+*.model
+*.weights
+*.h5
+*.pb
+
+# 大文件
+*.iso
+*.dmg
+*.img
+
+# 监控和审计
+monitoring/
+*.access.log
+*.error.log
+*.audit.log
+
+# 本地开发文件
+local/
+.local/
+debug.log
+*.debug
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..fb64630
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,32 @@
+# 运行时数据与密钥 —— 永不提交
+.env
+.env.*
+*.env
+data/
+logs/
+backups/
+*.log
+realtime.log
+
+# 数据库
+*.db
+*.db-journal
+*.db-wal
+*.db-shm
+
+# 运行时上传目录(与容器共享)
+static/uploads/images/
+
+# Python 缓存
+__pycache__/
+*.py[cod]
+*.pyo
+.pytest_cache/
+.venv/
+venv/
+
+# 编辑器 / 系统
+.vscode/
+.idea/
+.DS_Store
+*.swp
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..88aa085
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,40 @@
+# 更新日志
+
+本项目基于闲鱼自动回复系统二次开发,记录本地改动。
+
+---
+
+## 2026-10-22 · v1.1.0
+
+### ✨ 新功能
+
+- **商品管理支持编辑标题 / 价格 / 描述**
+ - 后台「商品管理 → 编辑」弹窗新增 **商品标题、商品价格、商品描述** 三个输入框。
+ - 保存后写入本地数据库(`item_info` 表),供 AI 关键词匹配与回复参考。
+ - `db_manager.py` 新增 `update_item_fields()`,支持多字段动态更新。
+ - `reply_server.py` 的 `PUT /items/{cookie_id}/{item_id}` 接收新字段。
+ - 弹窗内提示:**闲鱼网页版不支持修改真实商品**,本地改动仅用于回复参考,真实商品请在闲鱼 APP 中编辑。
+
+- **API 密钥掩码显示(安全加固)**
+ - `GET /ai-reply-settings/{cookie_id}` 返回的 `api_key` 掩码为 `sk-4****27QK`,不再明文暴露。
+ - `PUT` 保存时,若密钥仍含 `****` 则**保留原值**,避免掩码覆盖真实密钥。
+ - 前端密钥输入框改为密码框,带 👁 显隐切换按钮;提示「密钥已掩码显示,如不修改则保持原值」。
+
+### 🐛 修复
+
+- **AI 回复无内容(reasoning 模型耗尽 token)**
+ - 根因:`deepseek-v4-flash` 为推理模型,思考阶段吃光 `max_tokens`,输出为空。
+ - `ai_reply_engine.py`:意图识别 `max_tokens` 设为 `100`;回复生成 `max_tokens` 提升至 `2048`。
+ - 修复后回复链路正常(实测 reasoning≈740 tokens 仍能产出正文)。
+
+### 🔧 工程
+
+- 新增**自定义 `Dockerfile`**:在官方镜像基础上用 `sed` 打 `max_tokens` 补丁,`docker compose build` 后改动不丢失。
+- 新增 `.gitignore`:排除 `.env`、`data/`、`logs/`、`*.db`、`uploads`、`__pycache__`,仓库不含任何运行时数据与密钥。
+
+---
+
+## 初始版本
+
+- 基于 `registry.cn-shanghai.aliyuncs.com/zhinian-software/xianyu-auto-reply:1.0` 镜像源码。
+- 功能:闲鱼自动回复、AI 大模型回复、关键词匹配、自动确认发货、免拼发货、商品与订单管理。
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..f54d11f
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,107 @@
+# 使用Python 3.11作为基础镜像
+FROM python:3.11-slim-bookworm
+
+# 设置标签信息
+LABEL maintainer="zhinianboke"
+LABEL version="2.1.0"
+LABEL description="闲鱼自动回复系统 - 企业级多用户版本,支持自动发货和免拼发货"
+LABEL repository="https://github.com/zhinianboke/xianyu-auto-reply"
+LABEL license="仅供学习使用,禁止商业用途"
+LABEL author="zhinianboke"
+
+# 设置工作目录
+WORKDIR /app
+
+# 设置环境变量
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV TZ=Asia/Shanghai
+ENV DOCKER_ENV=true
+ENV PLAYWRIGHT_BROWSERS_PATH=/ms-playwright
+
+# 安装系统依赖(包括Playwright浏览器依赖)
+RUN apt-get update && \
+ apt-get install -y --no-install-recommends \
+ # 基础工具
+ nodejs \
+ npm \
+ tzdata \
+ curl \
+ ca-certificates \
+ # 图像处理依赖
+ libjpeg-dev \
+ libpng-dev \
+ libfreetype6-dev \
+ fonts-dejavu-core \
+ fonts-liberation \
+ # Playwright浏览器依赖
+ libnss3 \
+ libnspr4 \
+ libatk-bridge2.0-0 \
+ libdrm2 \
+ libxkbcommon0 \
+ libxcomposite1 \
+ libxdamage1 \
+ libxrandr2 \
+ libgbm1 \
+ libxss1 \
+ libasound2 \
+ libatspi2.0-0 \
+ libgtk-3-0 \
+ libgdk-pixbuf2.0-0 \
+ libxcursor1 \
+ libxi6 \
+ libxrender1 \
+ libxext6 \
+ libx11-6 \
+ libxft2 \
+ libxinerama1 \
+ libxtst6 \
+ libappindicator3-1 \
+ libx11-xcb1 \
+ libxfixes3 \
+ xdg-utils \
+ && apt-get clean \
+ && rm -rf /var/lib/apt/lists/* \
+ && rm -rf /tmp/* \
+ && rm -rf /var/tmp/*
+
+# 设置时区
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
+# 验证Node.js安装并设置环境变量
+RUN node --version && npm --version
+ENV NODE_PATH=/usr/lib/node_modules
+
+# 复制requirements.txt并安装Python依赖
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+ pip install --no-cache-dir -r requirements.txt
+
+# 复制项目文件
+COPY . .
+
+# 安装Playwright浏览器(必须在复制项目文件之后)
+RUN playwright install chromium && \
+ playwright install-deps chromium
+
+# 创建必要的目录并设置权限
+RUN mkdir -p /app/logs /app/data /app/backups /app/static/uploads/images && \
+ chmod 777 /app/logs /app/data /app/backups /app/static/uploads /app/static/uploads/images
+
+# 注意: 为了简化权限问题,使用root用户运行
+# 在生产环境中,建议配置适当的用户映射
+
+# 暴露端口
+EXPOSE 8080
+
+# 健康检查
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+ CMD curl -f http://localhost:8080/health || exit 1
+
+# 复制启动脚本
+COPY entrypoint.sh /app/entrypoint.sh
+RUN chmod +x /app/entrypoint.sh
+
+# 启动命令
+CMD ["/app/entrypoint.sh"]
\ No newline at end of file
diff --git a/Dockerfile-cn b/Dockerfile-cn
new file mode 100644
index 0000000..95e28bf
--- /dev/null
+++ b/Dockerfile-cn
@@ -0,0 +1,110 @@
+# 使用Python 3.11作为基础镜像
+FROM python:3.11-slim-bookworm
+
+# 设置标签信息
+LABEL maintainer="zhinianboke"
+LABEL version="2.1.0"
+LABEL description="闲鱼自动回复系统 - 企业级多用户版本,支持自动发货和免拼发货"
+LABEL repository="https://github.com/zhinianboke/xianyu-auto-reply"
+LABEL license="仅供学习使用,禁止商业用途"
+LABEL author="zhinianboke"
+
+# 设置工作目录
+WORKDIR /app
+
+# 设置环境变量
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV TZ=Asia/Shanghai
+ENV DOCKER_ENV=true
+ENV PLAYWRIGHT_BROWSERS_PATH=/ms-playwright
+
+#更换中科大源
+RUN sed -i 's/deb.debian.org/mirrors.ustc.edu.cn/g' /etc/apt/sources.list.d/debian.sources
+
+# 安装系统依赖(包括Playwright浏览器依赖)
+RUN apt-get update && \
+ apt-get install -y --no-install-recommends \
+ # 基础工具
+ nodejs \
+ npm \
+ tzdata \
+ curl \
+ ca-certificates \
+ # 图像处理依赖
+ libjpeg-dev \
+ libpng-dev \
+ libfreetype6-dev \
+ fonts-dejavu-core \
+ fonts-liberation \
+ # Playwright浏览器依赖
+ libnss3 \
+ libnspr4 \
+ libatk-bridge2.0-0 \
+ libdrm2 \
+ libxkbcommon0 \
+ libxcomposite1 \
+ libxdamage1 \
+ libxrandr2 \
+ libgbm1 \
+ libxss1 \
+ libasound2 \
+ libatspi2.0-0 \
+ libgtk-3-0 \
+ libgdk-pixbuf2.0-0 \
+ libxcursor1 \
+ libxi6 \
+ libxrender1 \
+ libxext6 \
+ libx11-6 \
+ libxft2 \
+ libxinerama1 \
+ libxtst6 \
+ libappindicator3-1 \
+ libx11-xcb1 \
+ libxfixes3 \
+ xdg-utils \
+ && apt-get clean \
+ && rm -rf /var/lib/apt/lists/* \
+ && rm -rf /tmp/* \
+ && rm -rf /var/tmp/*
+
+# 设置时区
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
+# 验证Node.js安装并设置环境变量
+RUN node --version && npm --version
+ENV NODE_PATH=/usr/lib/node_modules
+
+# 复制requirements.txt并安装Python依赖
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip -i https://pypi.tuna.tsinghua.edu.cn/simple&& \
+ pip install --no-cache-dir -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
+
+# 复制项目文件
+COPY . .
+
+# 安装Playwright浏览器(必须在复制项目文件之后)
+RUN playwright install chromium && \
+ playwright install-deps chromium
+
+# 创建必要的目录并设置权限
+RUN mkdir -p /app/logs /app/data /app/backups /app/static/uploads/images && \
+ chmod 777 /app/logs /app/data /app/backups /app/static/uploads /app/static/uploads/images
+
+# 注意: 为了简化权限问题,使用root用户运行
+# 在生产环境中,建议配置适当的用户映射
+
+# 暴露端口
+EXPOSE 8080
+
+# 健康检查
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+ CMD curl -f http://localhost:8080/health || exit 1
+
+# 复制启动脚本
+COPY entrypoint.sh /app/entrypoint.sh
+RUN chmod +x /app/entrypoint.sh
+
+# 启动命令
+CMD ["/app/entrypoint.sh"]
diff --git a/Start.py b/Start.py
new file mode 100644
index 0000000..69e6b23
--- /dev/null
+++ b/Start.py
@@ -0,0 +1,142 @@
+"""项目启动入口:
+
+1. 创建 CookieManager,按配置文件 / 环境变量初始化账号任务
+2. 在后台线程启动 FastAPI (reply_server) 提供管理与自动回复接口
+3. 主协程保持运行
+"""
+
+import os
+import asyncio
+import threading
+import uvicorn
+from urllib.parse import urlparse
+from pathlib import Path
+from loguru import logger
+
+from config import AUTO_REPLY, COOKIES_LIST
+import cookie_manager as cm
+from db_manager import db_manager
+from file_log_collector import setup_file_logging
+
+
+def _start_api_server():
+ """后台线程启动 FastAPI 服务"""
+ api_conf = AUTO_REPLY.get('api', {})
+
+ # 优先使用环境变量配置
+ host = os.getenv('API_HOST', '0.0.0.0') # 默认绑定所有接口
+ port = int(os.getenv('API_PORT', '8080')) # 默认端口8080
+
+ # 如果配置文件中有特定配置,则使用配置文件
+ if 'host' in api_conf:
+ host = api_conf['host']
+ if 'port' in api_conf:
+ port = api_conf['port']
+
+ # 兼容旧的URL配置方式
+ if 'url' in api_conf and 'host' not in api_conf and 'port' not in api_conf:
+ url = api_conf.get('url', 'http://0.0.0.0:8080/xianyu/reply')
+ parsed = urlparse(url)
+ if parsed.hostname and parsed.hostname != 'localhost':
+ host = parsed.hostname
+ port = parsed.port or 8080
+
+ logger.info(f"启动Web服务器: http://{host}:{port}")
+ uvicorn.run("reply_server:app", host=host, port=port, log_level="info")
+
+
+def load_keywords_file(path: str):
+ """从文件读取关键字 -> [(keyword, reply)]"""
+ kw_list = []
+ p = Path(path)
+ if not p.exists():
+ return kw_list
+ with p.open('r', encoding='utf-8') as f:
+ for line in f:
+ line = line.strip()
+ if not line or line.startswith('#'):
+ continue
+ if '\t' in line:
+ k, r = line.split('\t', 1)
+ elif ' ' in line:
+ k, r = line.split(' ', 1)
+ elif ':' in line:
+ k, r = line.split(':', 1)
+ else:
+ continue
+ kw_list.append((k.strip(), r.strip()))
+ return kw_list
+
+
+async def main():
+ print("开始启动主程序...")
+
+ # 初始化文件日志收集器
+ print("初始化文件日志收集器...")
+ setup_file_logging()
+ logger.info("文件日志收集器已启动,开始收集实时日志")
+
+ loop = asyncio.get_running_loop()
+
+ # 创建 CookieManager 并在全局暴露
+ print("创建 CookieManager...")
+ cm.manager = cm.CookieManager(loop)
+ manager = cm.manager
+ print("CookieManager 创建完成")
+
+ # 1) 从数据库加载的 Cookie 已经在 CookieManager 初始化时完成
+ # 为每个启用的 Cookie 启动任务
+ for cid, val in manager.cookies.items():
+ # 检查账号是否启用
+ if not manager.get_cookie_status(cid):
+ logger.info(f"跳过禁用的 Cookie: {cid}")
+ continue
+
+ try:
+ # 直接启动任务,不重新保存到数据库
+ from db_manager import db_manager
+ logger.info(f"正在获取Cookie详细信息: {cid}")
+ cookie_info = db_manager.get_cookie_details(cid)
+ user_id = cookie_info.get('user_id') if cookie_info else None
+ logger.info(f"Cookie详细信息获取成功: {cid}, user_id: {user_id}")
+
+ logger.info(f"正在创建异步任务: {cid}")
+ task = loop.create_task(manager._run_xianyu(cid, val, user_id))
+ manager.tasks[cid] = task
+ logger.info(f"启动数据库中的 Cookie 任务: {cid} (用户ID: {user_id})")
+ logger.info(f"任务已添加到管理器,当前任务数: {len(manager.tasks)}")
+ except Exception as e:
+ logger.error(f"启动 Cookie 任务失败: {cid}, {e}")
+ import traceback
+ logger.error(f"详细错误信息: {traceback.format_exc()}")
+
+ # 2) 如果配置文件中有新的 Cookie,也加载它们
+ for entry in COOKIES_LIST:
+ cid = entry.get('id')
+ val = entry.get('value')
+ if not cid or not val or cid in manager.cookies:
+ continue
+
+ kw_file = entry.get('keywords_file')
+ kw_list = load_keywords_file(kw_file) if kw_file else None
+ manager.add_cookie(cid, val, kw_list)
+ logger.info(f"从配置文件加载 Cookie: {cid}")
+
+ # 3) 若老环境变量仍提供单账号 Cookie,则作为 default 账号
+ env_cookie = os.getenv('COOKIES_STR')
+ if env_cookie and 'default' not in manager.list_cookies():
+ manager.add_cookie('default', env_cookie)
+ logger.info("从环境变量加载 default Cookie")
+
+ # 启动 API 服务线程
+ print("启动 API 服务线程...")
+ threading.Thread(target=_start_api_server, daemon=True).start()
+ print("API 服务线程已启动")
+
+ # 阻塞保持运行
+ print("主程序启动完成,保持运行...")
+ await asyncio.Event().wait()
+
+
+if __name__ == '__main__':
+ asyncio.run(main())
\ No newline at end of file
diff --git a/XianyuAutoAsync.py b/XianyuAutoAsync.py
new file mode 100644
index 0000000..716d93a
--- /dev/null
+++ b/XianyuAutoAsync.py
@@ -0,0 +1,4360 @@
+import asyncio
+import json
+import re
+import time
+import base64
+import os
+from loguru import logger
+import websockets
+from utils.xianyu_utils import (
+ decrypt, generate_mid, generate_uuid, trans_cookies,
+ generate_device_id, generate_sign
+)
+from config import (
+ WEBSOCKET_URL, HEARTBEAT_INTERVAL, HEARTBEAT_TIMEOUT,
+ TOKEN_REFRESH_INTERVAL, TOKEN_RETRY_INTERVAL, COOKIES_STR,
+ LOG_CONFIG, AUTO_REPLY, DEFAULT_HEADERS, WEBSOCKET_HEADERS,
+ APP_CONFIG, API_ENDPOINTS, COOKIE_KEEPALIVE_INTERVAL
+)
+import sys
+import aiohttp
+from collections import defaultdict
+
+
+class AutoReplyPauseManager:
+ """自动回复暂停管理器"""
+ def __init__(self):
+ # 存储每个(chat_id, cookie_id)的暂停信息 {(chat_id, cookie_id): pause_until_timestamp}
+ self.paused_chats = {}
+
+ def _make_key(self, chat_id: str, cookie_id: str) -> tuple:
+ """生成暂停记录的复合键"""
+ return (chat_id, cookie_id)
+
+ def pause_chat(self, chat_id: str, cookie_id: str):
+ """暂停指定chat_id和账号的自动回复,使用账号特定的暂停时间"""
+ # 获取账号特定的暂停时间
+ try:
+ from db_manager import db_manager
+ pause_minutes = db_manager.get_cookie_pause_duration(cookie_id)
+ except Exception as e:
+ logger.error(f"获取账号 {cookie_id} 暂停时间失败: {e},使用默认10分钟")
+ pause_minutes = 10
+
+ pause_duration_seconds = pause_minutes * 60
+ pause_until = time.time() + pause_duration_seconds
+ key = self._make_key(chat_id, cookie_id)
+ self.paused_chats[key] = pause_until
+
+ # 计算暂停结束时间
+ end_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(pause_until))
+ logger.info(f"【{cookie_id}】检测到手动发出消息,chat_id {chat_id} 自动回复暂停{pause_minutes}分钟,恢复时间: {end_time}")
+
+ def is_chat_paused(self, chat_id: str, cookie_id: str) -> bool:
+ """检查指定chat_id和账号是否处于暂停状态"""
+ key = self._make_key(chat_id, cookie_id)
+ if key not in self.paused_chats:
+ return False
+
+ current_time = time.time()
+ pause_until = self.paused_chats[key]
+
+ if current_time >= pause_until:
+ # 暂停时间已过,移除记录
+ del self.paused_chats[key]
+ return False
+
+ return True
+
+ def get_remaining_pause_time(self, chat_id: str, cookie_id: str) -> int:
+ """获取指定chat_id和账号的剩余暂停时间(秒)"""
+ key = self._make_key(chat_id, cookie_id)
+ if key not in self.paused_chats:
+ return 0
+
+ current_time = time.time()
+ pause_until = self.paused_chats[key]
+ remaining = max(0, int(pause_until - current_time))
+
+ return remaining
+
+ def cleanup_expired_pauses(self):
+ """清理已过期的暂停记录"""
+ current_time = time.time()
+ expired_keys = [key for key, pause_until in self.paused_chats.items()
+ if current_time >= pause_until]
+
+ for key in expired_keys:
+ del self.paused_chats[key]
+
+
+# 全局暂停管理器实例
+pause_manager = AutoReplyPauseManager()
+
+# 日志配置
+log_dir = 'logs'
+os.makedirs(log_dir, exist_ok=True)
+log_path = os.path.join(log_dir, f"xianyu_{time.strftime('%Y-%m-%d')}.log")
+logger.remove()
+logger.add(
+ log_path,
+ rotation=LOG_CONFIG.get('rotation', '1 day'),
+ retention=LOG_CONFIG.get('retention', '7 days'),
+ compression=LOG_CONFIG.get('compression', 'zip'),
+ level=LOG_CONFIG.get('level', 'INFO'),
+ format=LOG_CONFIG.get('format', '{time:YYYY-MM-DD HH:mm:ss.SSS} | {level: <8} | {name}:{function}:{line} - {message}'),
+ encoding='utf-8',
+ enqueue=True
+)
+logger.add(
+ sys.stdout,
+ level=LOG_CONFIG.get('level', 'INFO'),
+ format=LOG_CONFIG.get('format', '{time:YYYY-MM-DD HH:mm:ss.SSS} | {level: <8} | {name}:{function}:{line} - {message}'),
+ enqueue=True
+)
+
+class XianyuLive:
+ # 类级别的锁字典,为每个order_id维护一个锁(用于自动发货)
+ _order_locks = defaultdict(lambda: asyncio.Lock())
+ # 记录锁的最后使用时间,用于清理
+ _lock_usage_times = {}
+ # 记录锁的持有状态和释放时间 {lock_key: {'locked': bool, 'release_time': float, 'task': asyncio.Task}}
+ _lock_hold_info = {}
+
+ # 独立的锁字典,用于订单详情获取(不使用延迟锁机制)
+ _order_detail_locks = defaultdict(lambda: asyncio.Lock())
+ # 记录订单详情锁的使用时间
+ _order_detail_lock_times = {}
+
+ def _safe_str(self, e):
+ """安全地将异常转换为字符串"""
+ try:
+ return str(e)
+ except:
+ try:
+ return repr(e)
+ except:
+ return "未知错误"
+
+ def __init__(self, cookies_str=None, cookie_id: str = "default", user_id: int = None):
+ """初始化闲鱼直播类"""
+ logger.info(f"【{cookie_id}】开始初始化XianyuLive...")
+
+ if not cookies_str:
+ cookies_str = COOKIES_STR
+ if not cookies_str:
+ raise ValueError("未提供cookies,请在global_config.yml中配置COOKIES_STR或通过参数传入")
+
+ logger.info(f"【{cookie_id}】解析cookies...")
+ self.cookies = trans_cookies(cookies_str)
+ logger.info(f"【{cookie_id}】cookies解析完成,包含字段: {list(self.cookies.keys())}")
+
+ self.cookie_id = cookie_id # 唯一账号标识
+ self.cookies_str = cookies_str # 保存原始cookie字符串
+ self.user_id = user_id # 保存用户ID,用于token刷新时保持正确的所有者关系
+ self.base_url = WEBSOCKET_URL
+
+ if 'unb' not in self.cookies:
+ raise ValueError(f"【{cookie_id}】Cookie中缺少必需的'unb'字段,当前字段: {list(self.cookies.keys())}")
+
+ self.myid = self.cookies['unb']
+ logger.info(f"【{cookie_id}】用户ID: {self.myid}")
+ self.device_id = generate_device_id(self.myid)
+
+ # 心跳相关配置
+ self.heartbeat_interval = HEARTBEAT_INTERVAL
+ self.heartbeat_timeout = HEARTBEAT_TIMEOUT
+ self.last_heartbeat_time = 0
+ self.last_heartbeat_response = 0
+ self.heartbeat_task = None
+ self.ws = None
+
+ # Token刷新相关配置
+ self.token_refresh_interval = TOKEN_REFRESH_INTERVAL
+ self.token_retry_interval = TOKEN_RETRY_INTERVAL
+ self.last_token_refresh_time = 0
+ self.current_token = None
+ self.token_refresh_task = None
+ self.connection_restart_flag = False # 连接重启标志
+
+ # 通知防重复机制
+ self.last_notification_time = {} # 记录每种通知类型的最后发送时间
+ self.notification_cooldown = 300 # 5分钟内不重复发送相同类型的通知
+ self.token_refresh_notification_cooldown = 18000 # Token刷新异常通知冷却时间:3小时
+
+ # 自动发货防重复机制
+ self.last_delivery_time = {} # 记录每个商品的最后发货时间
+ self.delivery_cooldown = 600 # 10分钟内不重复发货
+
+ # 自动确认发货防重复机制
+ self.confirmed_orders = {} # 记录已确认发货的订单,防止重复确认
+ self.order_confirm_cooldown = 600 # 10分钟内不重复确认同一订单
+
+ # 自动发货已发送订单记录
+ self.delivery_sent_orders = set() # 记录已发货的订单ID,防止重复发货
+
+ self.session = None # 用于API调用的aiohttp session
+
+ # 启动定期清理过期暂停记录的任务
+ self.cleanup_task = None
+
+
+
+ def is_auto_confirm_enabled(self) -> bool:
+ """检查当前账号是否启用自动确认发货"""
+ try:
+ from db_manager import db_manager
+ return db_manager.get_auto_confirm(self.cookie_id)
+ except Exception as e:
+ logger.error(f"【{self.cookie_id}】获取自动确认发货设置失败: {self._safe_str(e)}")
+ return True # 出错时默认启用
+
+
+
+ def can_auto_delivery(self, order_id: str) -> bool:
+ """检查是否可以进行自动发货(防重复发货)- 基于订单ID"""
+ if not order_id:
+ # 如果没有订单ID,则不进行冷却检查,允许发货
+ return True
+
+ current_time = time.time()
+ last_delivery = self.last_delivery_time.get(order_id, 0)
+
+ if current_time - last_delivery < self.delivery_cooldown:
+ logger.info(f"【{self.cookie_id}】订单 {order_id} 在冷却期内,跳过自动发货")
+ return False
+
+ return True
+
+ def mark_delivery_sent(self, order_id: str):
+ """标记订单已发货"""
+ self.delivery_sent_orders.add(order_id)
+ logger.info(f"【{self.cookie_id}】订单 {order_id} 已标记为发货")
+
+ async def _delayed_lock_release(self, lock_key: str, delay_minutes: int = 10):
+ """
+ 延迟释放锁的异步任务
+
+ Args:
+ lock_key: 锁的键
+ delay_minutes: 延迟时间(分钟),默认10分钟
+ """
+ try:
+ delay_seconds = delay_minutes * 60
+ logger.info(f"【{self.cookie_id}】订单锁 {lock_key} 将在 {delay_minutes} 分钟后释放")
+
+ # 等待指定时间
+ await asyncio.sleep(delay_seconds)
+
+ # 检查锁是否仍然存在且需要释放
+ if lock_key in self._lock_hold_info:
+ lock_info = self._lock_hold_info[lock_key]
+ if lock_info.get('locked', False):
+ # 释放锁
+ lock_info['locked'] = False
+ lock_info['release_time'] = time.time()
+ logger.info(f"【{self.cookie_id}】订单锁 {lock_key} 延迟释放完成")
+
+ # 清理锁信息(可选,也可以保留用于统计)
+ # del self._lock_hold_info[lock_key]
+
+ except asyncio.CancelledError:
+ logger.info(f"【{self.cookie_id}】订单锁 {lock_key} 延迟释放任务被取消")
+ except Exception as e:
+ logger.error(f"【{self.cookie_id}】订单锁 {lock_key} 延迟释放失败: {self._safe_str(e)}")
+
+ def is_lock_held(self, lock_key: str) -> bool:
+ """
+ 检查指定的锁是否仍在持有状态
+
+ Args:
+ lock_key: 锁的键
+
+ Returns:
+ bool: True表示锁仍在持有,False表示锁已释放或不存在
+ """
+ if lock_key not in self._lock_hold_info:
+ return False
+
+ lock_info = self._lock_hold_info[lock_key]
+ return lock_info.get('locked', False)
+
+ def cleanup_expired_locks(self, max_age_hours: int = 24):
+ """
+ 清理过期的锁(包括自动发货锁和订单详情锁)
+
+ Args:
+ max_age_hours: 锁的最大保留时间(小时),默认24小时
+ """
+ try:
+ current_time = time.time()
+ max_age_seconds = max_age_hours * 3600
+
+ # 清理自动发货锁
+ expired_delivery_locks = []
+ for order_id, last_used in self._lock_usage_times.items():
+ if current_time - last_used > max_age_seconds:
+ expired_delivery_locks.append(order_id)
+
+ # 清理过期的自动发货锁
+ for order_id in expired_delivery_locks:
+ if order_id in self._order_locks:
+ del self._order_locks[order_id]
+ if order_id in self._lock_usage_times:
+ del self._lock_usage_times[order_id]
+ # 清理锁持有信息
+ if order_id in self._lock_hold_info:
+ lock_info = self._lock_hold_info[order_id]
+ # 取消延迟释放任务
+ if 'task' in lock_info and lock_info['task']:
+ lock_info['task'].cancel()
+ del self._lock_hold_info[order_id]
+
+ # 清理订单详情锁
+ expired_detail_locks = []
+ for order_id, last_used in self._order_detail_lock_times.items():
+ if current_time - last_used > max_age_seconds:
+ expired_detail_locks.append(order_id)
+
+ # 清理过期的订单详情锁
+ for order_id in expired_detail_locks:
+ if order_id in self._order_detail_locks:
+ del self._order_detail_locks[order_id]
+ if order_id in self._order_detail_lock_times:
+ del self._order_detail_lock_times[order_id]
+
+ total_expired = len(expired_delivery_locks) + len(expired_detail_locks)
+ if total_expired > 0:
+ logger.info(f"【{self.cookie_id}】清理了 {total_expired} 个过期锁 (发货锁: {len(expired_delivery_locks)}, 详情锁: {len(expired_detail_locks)})")
+ logger.debug(f"【{self.cookie_id}】当前锁数量 - 发货锁: {len(self._order_locks)}, 详情锁: {len(self._order_detail_locks)}")
+
+ except Exception as e:
+ logger.error(f"【{self.cookie_id}】清理过期锁时发生错误: {self._safe_str(e)}")
+
+
+
+ def _is_auto_delivery_trigger(self, message: str) -> bool:
+ """检查消息是否为自动发货触发关键字"""
+ # 定义所有自动发货触发关键字
+ auto_delivery_keywords = [
+ # 系统消息
+ '[我已付款,等待你发货]',
+ '[已付款,待发货]',
+ '我已付款,等待你发货',
+ '[记得及时发货]',
+ ]
+
+ # 检查消息是否包含任何触发关键字
+ for keyword in auto_delivery_keywords:
+ if keyword in message:
+ return True
+
+ return False
+
+ def _extract_order_id(self, message: dict) -> str:
+ """从消息中提取订单ID"""
+ try:
+ order_id = None
+
+ # 先查看消息的完整结构
+ logger.debug(f"【{self.cookie_id}】🔍 完整消息结构: {message}")
+
+ # 检查message['1']的结构,处理可能是列表、字典或字符串的情况
+ message_1 = message.get('1', {})
+ content_json_str = ''
+
+ if isinstance(message_1, dict):
+ logger.debug(f"【{self.cookie_id}】🔍 message['1'] 是字典,keys: {list(message_1.keys())}")
+
+ # 检查message['1']['6']的结构
+ message_1_6 = message_1.get('6', {})
+ if isinstance(message_1_6, dict):
+ logger.debug(f"【{self.cookie_id}】🔍 message['1']['6'] 是字典,keys: {list(message_1_6.keys())}")
+ # 方法1: 从button的targetUrl中提取orderId
+ content_json_str = message_1_6.get('3', {}).get('5', '') if isinstance(message_1_6.get('3', {}), dict) else ''
+ else:
+ logger.debug(f"【{self.cookie_id}】🔍 message['1']['6'] 不是字典: {type(message_1_6)}")
+
+ elif isinstance(message_1, list):
+ logger.debug(f"【{self.cookie_id}】🔍 message['1'] 是列表,长度: {len(message_1)}")
+ # 如果message['1']是列表,跳过这种提取方式
+
+ elif isinstance(message_1, str):
+ logger.debug(f"【{self.cookie_id}】🔍 message['1'] 是字符串,长度: {len(message_1)}")
+ # 如果message['1']是字符串,跳过这种提取方式
+
+ else:
+ logger.debug(f"【{self.cookie_id}】🔍 message['1'] 未知类型: {type(message_1)}")
+ # 其他类型,跳过这种提取方式
+
+ if content_json_str:
+ try:
+ content_data = json.loads(content_json_str)
+
+ # 方法1a: 从button的targetUrl中提取orderId
+ target_url = content_data.get('dxCard', {}).get('item', {}).get('main', {}).get('exContent', {}).get('button', {}).get('targetUrl', '')
+ if target_url:
+ # 从URL中提取orderId参数
+ order_match = re.search(r'orderId=(\d+)', target_url)
+ if order_match:
+ order_id = order_match.group(1)
+ logger.info(f'【{self.cookie_id}】✅ 从button提取到订单ID: {order_id}')
+
+ # 方法1b: 从main的targetUrl中提取order_detail的id
+ if not order_id:
+ main_target_url = content_data.get('dxCard', {}).get('item', {}).get('main', {}).get('targetUrl', '')
+ if main_target_url:
+ order_match = re.search(r'order_detail\?id=(\d+)', main_target_url)
+ if order_match:
+ order_id = order_match.group(1)
+ logger.info(f'【{self.cookie_id}】✅ 从main targetUrl提取到订单ID: {order_id}')
+
+ except Exception as parse_e:
+ logger.debug(f"解析内容JSON失败: {parse_e}")
+
+ # 方法2: 从dynamicOperation中的order_detail URL提取orderId
+ if not order_id and content_json_str:
+ try:
+ content_data = json.loads(content_json_str)
+ dynamic_target_url = content_data.get('dynamicOperation', {}).get('changeContent', {}).get('dxCard', {}).get('item', {}).get('main', {}).get('exContent', {}).get('button', {}).get('targetUrl', '')
+ if dynamic_target_url:
+ # 从order_detail URL中提取id参数
+ order_match = re.search(r'order_detail\?id=(\d+)', dynamic_target_url)
+ if order_match:
+ order_id = order_match.group(1)
+ logger.info(f'【{self.cookie_id}】✅ 从order_detail提取到订单ID: {order_id}')
+ except Exception as parse_e:
+ logger.debug(f"解析dynamicOperation JSON失败: {parse_e}")
+
+ # 方法3: 如果前面的方法都失败,尝试在整个消息中搜索订单ID模式
+ if not order_id:
+ try:
+ # 将整个消息转换为字符串进行搜索
+ message_str = str(message)
+
+ # 搜索各种可能的订单ID模式
+ patterns = [
+ r'orderId[=:](\d{10,})', # orderId=123456789 或 orderId:123456789
+ r'order_detail\?id=(\d{10,})', # order_detail?id=123456789
+ r'"id"\s*:\s*"?(\d{10,})"?', # "id":"123456789" 或 "id":123456789
+ r'bizOrderId[=:](\d{10,})', # bizOrderId=123456789
+ ]
+
+ for pattern in patterns:
+ matches = re.findall(pattern, message_str)
+ if matches:
+ # 取第一个匹配的订单ID
+ order_id = matches[0]
+ logger.info(f'【{self.cookie_id}】✅ 从消息字符串中提取到订单ID: {order_id} (模式: {pattern})')
+ break
+
+ except Exception as search_e:
+ logger.debug(f"在消息字符串中搜索订单ID失败: {search_e}")
+
+ if order_id:
+ logger.info(f'【{self.cookie_id}】🎯 最终提取到订单ID: {order_id}')
+ else:
+ logger.debug(f'【{self.cookie_id}】❌ 未能从消息中提取到订单ID')
+
+ return order_id
+
+ except Exception as e:
+ logger.error(f"【{self.cookie_id}】提取订单ID失败: {self._safe_str(e)}")
+ return None
+
+ async def _handle_auto_delivery(self, websocket, message: dict, send_user_name: str, send_user_id: str,
+ item_id: str, chat_id: str, msg_time: str):
+ """统一处理自动发货逻辑"""
+ try:
+ # 检查商品是否属于当前cookies
+ if item_id and item_id != "未知商品":
+ try:
+ from db_manager import db_manager
+ item_info = db_manager.get_item_info(self.cookie_id, item_id)
+ if not item_info:
+ # 商品不在数据库中,尝试通过API获取并保存
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】商品 {item_id} 不在数据库中,尝试通过API获取...')
+ try:
+ api_item_info = await self.get_item_info(item_id)
+ if api_item_info and 'data' in api_item_info:
+ data = api_item_info['data']
+ item_data = data.get('itemDO', {})
+ share_data = item_data.get('shareData', {})
+ share_info_str = share_data.get('shareInfoJsonString', '')
+ item_title_from_api = item_data.get('title', '')
+ if share_info_str or item_title_from_api:
+ await self.save_item_info_to_db(item_id, share_info_str or item_title_from_api, item_title_from_api or item_id)
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】✅ 通过API获取并保存商品信息: {item_id}')
+ else:
+ logger.warning(f'[{msg_time}] 【{self.cookie_id}】⚠️ API返回的商品信息为空,允许继续自动发货')
+ else:
+ logger.warning(f'[{msg_time}] 【{self.cookie_id}】⚠️ API获取商品信息失败,允许继续自动发货')
+ except Exception as api_e:
+ logger.warning(f'[{msg_time}] 【{self.cookie_id}】⚠️ API获取商品信息异常: {self._safe_str(api_e)},允许继续自动发货')
+ else:
+ logger.debug(f'[{msg_time}] 【{self.cookie_id}】✅ 商品 {item_id} 归属验证通过')
+ except Exception as e:
+ logger.error(f'[{msg_time}] 【{self.cookie_id}】检查商品归属失败: {self._safe_str(e)},跳过自动发货')
+ return
+
+ # 提取订单ID
+ order_id = self._extract_order_id(message)
+
+ # 订单ID已提取,将在自动发货时进行确认发货处理
+ if order_id:
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】提取到订单ID: {order_id},将在自动发货时处理确认发货')
+ else:
+ logger.warning(f'[{msg_time}] 【{self.cookie_id}】❌ 未能提取到订单ID')
+
+ # 使用订单ID作为锁的键,如果没有订单ID则使用item_id+chat_id组合
+ lock_key = order_id if order_id else f"{item_id}_{chat_id}"
+
+ # 第一重检查:延迟锁状态(在获取锁之前检查,避免不必要的等待)
+ if self.is_lock_held(lock_key):
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】🔒【提前检查】订单 {lock_key} 延迟锁仍在持有状态,跳过发货')
+ return
+
+ # 第二重检查:基于时间的冷却机制
+ if not self.can_auto_delivery(order_id):
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】订单 {order_id} 在冷却期内,跳过发货')
+ return
+
+ # 获取或创建该订单的锁
+ order_lock = self._order_locks[lock_key]
+
+ # 更新锁的使用时间
+ self._lock_usage_times[lock_key] = time.time()
+
+ # 使用异步锁防止同一订单的并发处理
+ async with order_lock:
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】获取订单锁成功: {lock_key},开始处理自动发货')
+
+ # 第三重检查:获取锁后再次检查延迟锁状态(双重检查,防止在等待锁期间状态发生变化)
+ if self.is_lock_held(lock_key):
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】订单 {lock_key} 在获取锁后检查发现延迟锁仍持有,跳过发货')
+ return
+
+ # 第四重检查:获取锁后再次检查冷却状态
+ if not self.can_auto_delivery(order_id):
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】订单 {order_id} 在获取锁后检查发现仍在冷却期,跳过发货')
+ return
+
+ # 构造用户URL
+ user_url = f'https://www.goofish.com/personal?userId={send_user_id}'
+
+ # 自动发货逻辑
+ try:
+ # 设置默认标题(将通过API获取真实商品信息)
+ item_title = "待获取商品信息"
+
+ logger.info(f"【{self.cookie_id}】准备自动发货: item_id={item_id}, item_title={item_title}")
+
+ # 检查是否需要多数量发货
+ from db_manager import db_manager
+ quantity_to_send = 1 # 默认发送1个
+
+ # 检查商品是否开启了多数量发货
+ multi_quantity_delivery = db_manager.get_item_multi_quantity_delivery_status(self.cookie_id, item_id)
+
+ if multi_quantity_delivery and order_id:
+ logger.info(f"商品 {item_id} 开启了多数量发货,获取订单详情...")
+ try:
+ # 使用现有方法获取订单详情
+ order_detail = await self.fetch_order_detail_info(order_id, item_id, send_user_id)
+ if order_detail and order_detail.get('quantity'):
+ try:
+ order_quantity = int(order_detail['quantity'])
+ if order_quantity > 1:
+ quantity_to_send = order_quantity
+ logger.info(f"从订单详情获取数量: {order_quantity},将发送 {quantity_to_send} 个卡券")
+ else:
+ logger.info(f"订单数量为 {order_quantity},发送单个卡券")
+ except (ValueError, TypeError):
+ logger.warning(f"订单数量格式无效: {order_detail.get('quantity')},发送单个卡券")
+ else:
+ logger.info(f"未获取到订单数量信息,发送单个卡券")
+ except Exception as e:
+ logger.error(f"获取订单详情失败: {self._safe_str(e)},发送单个卡券")
+ elif not multi_quantity_delivery:
+ logger.info(f"商品 {item_id} 未开启多数量发货,发送单个卡券")
+ else:
+ logger.info(f"无订单ID,发送单个卡券")
+
+ # 多次调用自动发货方法,每次获取不同的内容
+ delivery_contents = []
+ success_count = 0
+
+ for i in range(quantity_to_send):
+ try:
+ # 每次调用都可能获取不同的内容(API卡券、批量数据等)
+ delivery_content = await self._auto_delivery(item_id, item_title, order_id, send_user_id, send_user_name)
+ if delivery_content:
+ delivery_contents.append(delivery_content)
+ success_count += 1
+ if quantity_to_send > 1:
+ logger.info(f"第 {i+1}/{quantity_to_send} 个卡券内容获取成功")
+ else:
+ logger.warning(f"第 {i+1}/{quantity_to_send} 个卡券内容获取失败")
+ except Exception as e:
+ logger.error(f"第 {i+1}/{quantity_to_send} 个卡券获取异常: {self._safe_str(e)}")
+
+ if delivery_contents:
+ # 标记已发货(防重复)- 基于订单ID
+ self.mark_delivery_sent(order_id)
+
+ # 标记锁为持有状态,并启动延迟释放任务
+ self._lock_hold_info[lock_key] = {
+ 'locked': True,
+ 'lock_time': time.time(),
+ 'release_time': None,
+ 'task': None
+ }
+
+ # 启动延迟释放锁的异步任务(10分钟后释放)
+ delay_task = asyncio.create_task(self._delayed_lock_release(lock_key, delay_minutes=10))
+ self._lock_hold_info[lock_key]['task'] = delay_task
+
+ # 发送所有获取到的发货内容
+ for i, delivery_content in enumerate(delivery_contents):
+ try:
+ # 检查是否是图片发送标记
+ if delivery_content.startswith("__IMAGE_SEND__"):
+ # 提取卡券ID和图片URL
+ image_data = delivery_content.replace("__IMAGE_SEND__", "")
+ if "|" in image_data:
+ card_id_str, image_url = image_data.split("|", 1)
+ try:
+ card_id = int(card_id_str)
+ except ValueError:
+ logger.error(f"无效的卡券ID: {card_id_str}")
+ card_id = None
+ else:
+ # 兼容旧格式(没有卡券ID)
+ card_id = None
+ image_url = image_data
+
+ # 发送图片消息
+ await self.send_image_msg(websocket, chat_id, send_user_id, image_url, card_id=card_id)
+ if len(delivery_contents) > 1:
+ logger.info(f'[{msg_time}] 【多数量自动发货图片】第 {i+1}/{len(delivery_contents)} 张已向 {user_url} 发送图片: {image_url}')
+ else:
+ logger.info(f'[{msg_time}] 【自动发货图片】已向 {user_url} 发送图片: {image_url}')
+
+ # 多数量发货时,消息间隔1秒
+ if len(delivery_contents) > 1 and i < len(delivery_contents) - 1:
+ await asyncio.sleep(1)
+
+ else:
+ # 普通文本发货内容
+ await self.send_msg(websocket, chat_id, send_user_id, delivery_content)
+ if len(delivery_contents) > 1:
+ logger.info(f'[{msg_time}] 【多数量自动发货】第 {i+1}/{len(delivery_contents)} 条已向 {user_url} 发送发货内容')
+ else:
+ logger.info(f'[{msg_time}] 【自动发货】已向 {user_url} 发送发货内容')
+
+ # 多数量发货时,消息间隔1秒
+ if len(delivery_contents) > 1 and i < len(delivery_contents) - 1:
+ await asyncio.sleep(1)
+
+ except Exception as e:
+ logger.error(f"发送第 {i+1} 条消息失败: {self._safe_str(e)}")
+
+ # 发送成功通知
+ if len(delivery_contents) > 1:
+ await self.send_delivery_failure_notification(send_user_name, send_user_id, item_id, f"多数量发货成功,共发送 {len(delivery_contents)} 个卡券")
+ else:
+ await self.send_delivery_failure_notification(send_user_name, send_user_id, item_id, "发货成功")
+ else:
+ logger.warning(f'[{msg_time}] 【自动发货】未找到匹配的发货规则或获取发货内容失败')
+ # 更新订单发货状态为失败
+ if order_id:
+ from db_manager import db_manager
+ db_manager.update_order_delivery_status(order_id, 'failed')
+ # 发送自动发货失败通知
+ await self.send_delivery_failure_notification(send_user_name, send_user_id, item_id, "未找到匹配的发货规则或获取发货内容失败")
+
+ except Exception as e:
+ logger.error(f"自动发货处理异常: {self._safe_str(e)}")
+ # 发送自动发货异常通知
+ await self.send_delivery_failure_notification(send_user_name, send_user_id, item_id, f"自动发货处理异常: {str(e)}")
+
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】订单锁释放: {lock_key},自动发货处理完成')
+
+ except Exception as e:
+ logger.error(f"统一自动发货处理异常: {self._safe_str(e)}")
+
+
+
+ async def refresh_token(self):
+ """刷新token"""
+ try:
+ logger.info(f"【{self.cookie_id}】开始刷新token...")
+ params = {
+ 'jsv': '2.7.2',
+ 'appKey': '34839810',
+ 't': str(int(time.time()) * 1000),
+ 'sign': '',
+ 'v': '1.0',
+ 'type': 'originaljson',
+ 'accountSite': 'xianyu',
+ 'dataType': 'json',
+ 'timeout': '20000',
+ 'api': 'mtop.taobao.idlemessage.pc.login.token',
+ 'sessionOption': 'AutoLoginOnly',
+ 'spm_cnt': 'a21ybx.im.0.0',
+ }
+ data_val = '{"appKey":"444e9908a51d1cb236a27862abc769c9","deviceId":"' + self.device_id + '"}'
+ data = {
+ 'data': data_val,
+ }
+
+ # 获取token
+ token = None
+ token = trans_cookies(self.cookies_str).get('_m_h5_tk', '').split('_')[0] if trans_cookies(self.cookies_str).get('_m_h5_tk') else ''
+
+ sign = generate_sign(params['t'], token, data_val)
+ params['sign'] = sign
+
+ # 发送请求
+ headers = DEFAULT_HEADERS.copy()
+ headers['cookie'] = self.cookies_str
+
+ async with aiohttp.ClientSession() as session:
+ async with session.post(
+ API_ENDPOINTS.get('token'),
+ params=params,
+ data=data,
+ headers=headers
+ ) as response:
+ res_json = await response.json()
+
+ # 检查并更新Cookie
+ if 'set-cookie' in response.headers:
+ new_cookies = {}
+ for cookie in response.headers.getall('set-cookie', []):
+ if '=' in cookie:
+ name, value = cookie.split(';')[0].split('=', 1)
+ new_cookies[name.strip()] = value.strip()
+
+ # 更新cookies
+ if new_cookies:
+ self.cookies.update(new_cookies)
+ # 生成新的cookie字符串
+ self.cookies_str = '; '.join([f"{k}={v}" for k, v in self.cookies.items()])
+ # 更新数据库中的Cookie
+ await self.update_config_cookies()
+ logger.debug("已更新Cookie到数据库")
+
+ if isinstance(res_json, dict):
+ ret_value = res_json.get('ret', [])
+ # 检查ret是否包含成功信息
+ if any('SUCCESS::调用成功' in ret for ret in ret_value):
+ if 'data' in res_json and 'accessToken' in res_json['data']:
+ new_token = res_json['data']['accessToken']
+ self.current_token = new_token
+ self.last_token_refresh_time = time.time()
+
+ # 更新数据库中的刷新时间
+ try:
+ from db_manager import db_manager
+ db_manager.update_cookie_refresh_time(self.cookie_id)
+ except Exception:
+ pass
+
+ logger.info(f"【{self.cookie_id}】Token刷新成功")
+ return new_token
+
+ logger.error(f"【{self.cookie_id}】Token刷新失败: {res_json}")
+
+ # 发送Token刷新失败通知
+ await self.send_token_refresh_notification(f"Token刷新失败: {res_json}", "token_refresh_failed")
+ return None
+
+ except Exception as e:
+ logger.error(f"Token刷新异常: {self._safe_str(e)}")
+ # 发送Token刷新异常通知
+ await self.send_token_refresh_notification(f"Token刷新异常: {str(e)}", "token_refresh_exception")
+ return None
+
+ async def update_config_cookies(self):
+ """更新数据库中的cookies"""
+ try:
+ from db_manager import db_manager
+
+ # 更新数据库中的Cookie
+ if hasattr(self, 'cookie_id') and self.cookie_id:
+ try:
+ # 获取当前Cookie的用户ID,避免在刷新时改变所有者
+ current_user_id = None
+ if hasattr(self, 'user_id') and self.user_id:
+ current_user_id = self.user_id
+
+ db_manager.save_cookie(self.cookie_id, self.cookies_str, current_user_id)
+ logger.debug(f"已更新Cookie到数据库: {self.cookie_id}")
+ except Exception as e:
+ logger.error(f"更新数据库Cookie失败: {self._safe_str(e)}")
+ # 发送数据库更新失败通知
+ await self.send_token_refresh_notification(f"数据库Cookie更新失败: {str(e)}", "db_update_failed")
+ else:
+ logger.warning("Cookie ID不存在,无法更新数据库")
+ # 发送Cookie ID缺失通知
+ await self.send_token_refresh_notification("Cookie ID不存在,无法更新数据库", "cookie_id_missing")
+
+ except Exception as e:
+ logger.error(f"更新Cookie失败: {self._safe_str(e)}")
+ # 发送Cookie更新失败通知
+ await self.send_token_refresh_notification(f"Cookie更新失败: {str(e)}", "cookie_update_failed")
+
+ async def _restart_instance(self):
+ """重启XianyuLive实例"""
+ try:
+ logger.info(f"【{self.cookie_id}】Token刷新成功,准备重启实例...")
+
+ # 导入CookieManager
+ from cookie_manager import manager as cookie_manager
+
+ if cookie_manager:
+ # 通过CookieManager重启实例
+ logger.info(f"【{self.cookie_id}】通过CookieManager重启实例...")
+
+ # 使用异步方式调用update_cookie,避免阻塞
+ def restart_task():
+ try:
+ cookie_manager.update_cookie(self.cookie_id, self.cookies_str)
+ logger.info(f"【{self.cookie_id}】实例重启请求已发送")
+ except Exception as e:
+ logger.error(f"【{self.cookie_id}】重启实例失败: {e}")
+
+ # 在后台执行重启任务
+ import threading
+ restart_thread = threading.Thread(target=restart_task, daemon=True)
+ restart_thread.start()
+
+ logger.info(f"【{self.cookie_id}】实例重启已在后台执行")
+ else:
+ logger.warning(f"【{self.cookie_id}】CookieManager不可用,无法重启实例")
+
+ except Exception as e:
+ logger.error(f"【{self.cookie_id}】重启实例失败: {self._safe_str(e)}")
+ # 发送重启失败通知
+ await self.send_token_refresh_notification(f"实例重启失败: {str(e)}", "instance_restart_failed")
+
+ async def save_item_info_to_db(self, item_id: str, item_detail: str = None, item_title: str = None):
+ """保存商品信息到数据库
+
+ Args:
+ item_id: 商品ID
+ item_detail: 商品详情内容(可以是任意格式的文本)
+ item_title: 商品标题
+ """
+ try:
+ # 跳过以 auto_ 开头的商品ID
+ if item_id and item_id.startswith('auto_'):
+ logger.debug(f"跳过保存自动生成的商品ID: {item_id}")
+ return
+
+ # 验证:如果只有商品ID,没有商品标题和商品详情,则不插入数据库
+ if not item_title and not item_detail:
+ logger.debug(f"跳过保存商品信息:缺少商品标题和详情 - {item_id}")
+ return
+
+ # 如果有商品标题但没有详情,也跳过(根据需求,需要同时有标题和详情)
+ if not item_title or not item_detail:
+ logger.debug(f"跳过保存商品信息:商品标题或详情不完整 - {item_id}")
+ return
+
+ from db_manager import db_manager
+
+ # 直接使用传入的详情内容
+ item_data = item_detail
+
+ # 保存到数据库
+ success = db_manager.save_item_info(self.cookie_id, item_id, item_data)
+ if success:
+ logger.info(f"商品信息已保存到数据库: {item_id}")
+ else:
+ logger.warning(f"保存商品信息到数据库失败: {item_id}")
+
+ except Exception as e:
+ logger.error(f"保存商品信息到数据库异常: {self._safe_str(e)}")
+
+ async def save_item_detail_only(self, item_id, item_detail):
+ """仅保存商品详情(不影响标题等基本信息)"""
+ try:
+ from db_manager import db_manager
+
+ # 使用专门的详情更新方法
+ success = db_manager.update_item_detail(self.cookie_id, item_id, item_detail)
+
+ if success:
+ logger.info(f"商品详情已更新: {item_id}")
+ else:
+ logger.warning(f"更新商品详情失败: {item_id}")
+
+ return success
+
+ except Exception as e:
+ logger.error(f"更新商品详情异常: {self._safe_str(e)}")
+ return False
+
+ async def fetch_item_detail_from_api(self, item_id: str) -> str:
+ """从外部API获取商品详情
+
+ Args:
+ item_id: 商品ID
+
+ Returns:
+ str: 商品详情文本,获取失败返回空字符串
+ """
+ try:
+ # 检查是否启用自动获取功能
+ from config import config
+ auto_fetch_config = config.get('ITEM_DETAIL', {}).get('auto_fetch', {})
+
+ if not auto_fetch_config.get('enabled', True):
+ logger.debug(f"自动获取商品详情功能已禁用: {item_id}")
+ return ""
+
+ # 从配置获取API地址和超时时间
+ api_base_url = auto_fetch_config.get('api_url', 'https://selfapi.zhinianboke.com/api/getItemDetail')
+ timeout_seconds = auto_fetch_config.get('timeout', 10)
+
+ api_url = f"{api_base_url}/{item_id}"
+
+ logger.info(f"正在从外部API获取商品详情: {item_id}")
+
+ # 使用aiohttp发送异步请求
+ import aiohttp
+ import asyncio
+
+ timeout = aiohttp.ClientTimeout(total=timeout_seconds)
+
+ async with aiohttp.ClientSession(timeout=timeout) as session:
+ async with session.get(api_url) as response:
+ if response.status == 200:
+ result = await response.json()
+
+ # 检查返回状态
+ if result.get('status') == '200' and result.get('data'):
+ item_detail = result['data']
+ logger.info(f"成功获取商品详情: {item_id}, 长度: {len(item_detail)}")
+ logger.debug(f"商品详情内容: {item_detail[:200]}...")
+ return item_detail
+ else:
+ logger.warning(f"API返回状态异常: {result.get('status')}, message: {result.get('message')}")
+ return ""
+ else:
+ logger.warning(f"API请求失败: HTTP {response.status}")
+ return ""
+
+ except asyncio.TimeoutError:
+ logger.warning(f"获取商品详情超时: {item_id}")
+ return ""
+ except Exception as e:
+ logger.error(f"获取商品详情异常: {item_id}, 错误: {self._safe_str(e)}")
+ return ""
+
+ async def save_items_list_to_db(self, items_list):
+ """批量保存商品列表信息到数据库(并发安全)
+
+ Args:
+ items_list: 从get_item_list_info获取的商品列表
+ """
+ try:
+ from db_manager import db_manager
+
+ # 准备批量数据
+ batch_data = []
+ items_need_detail = [] # 需要获取详情的商品列表
+
+ for item in items_list:
+ item_id = item.get('id')
+ if not item_id or item_id.startswith('auto_'):
+ continue
+
+ # 构造商品详情数据
+ item_detail = {
+ 'title': item.get('title', ''),
+ 'price': item.get('price', ''),
+ 'price_text': item.get('price_text', ''),
+ 'category_id': item.get('category_id', ''),
+ 'auction_type': item.get('auction_type', ''),
+ 'item_status': item.get('item_status', 0),
+ 'detail_url': item.get('detail_url', ''),
+ 'pic_info': item.get('pic_info', {}),
+ 'detail_params': item.get('detail_params', {}),
+ 'track_params': item.get('track_params', {}),
+ 'item_label_data': item.get('item_label_data', {}),
+ 'card_type': item.get('card_type', 0)
+ }
+
+ # 检查数据库中是否已有详情
+ existing_item = db_manager.get_item_info(self.cookie_id, item_id)
+ has_detail = existing_item and existing_item.get('item_detail') and existing_item['item_detail'].strip()
+
+ batch_data.append({
+ 'cookie_id': self.cookie_id,
+ 'item_id': item_id,
+ 'item_title': item.get('title', ''),
+ 'item_description': '', # 暂时为空
+ 'item_category': str(item.get('category_id', '')),
+ 'item_price': item.get('price_text', ''),
+ 'item_detail': json.dumps(item_detail, ensure_ascii=False)
+ })
+
+ # 如果没有详情,添加到需要获取详情的列表
+ if not has_detail:
+ items_need_detail.append({
+ 'item_id': item_id,
+ 'item_title': item.get('title', '')
+ })
+
+ if not batch_data:
+ logger.info("没有有效的商品数据需要保存")
+ return 0
+
+ # 使用批量保存方法(并发安全)
+ saved_count = db_manager.batch_save_item_basic_info(batch_data)
+ logger.info(f"批量保存商品信息完成: {saved_count}/{len(batch_data)} 个商品")
+
+ # 异步获取缺失的商品详情
+ if items_need_detail:
+ from config import config
+ auto_fetch_config = config.get('ITEM_DETAIL', {}).get('auto_fetch', {})
+
+ if auto_fetch_config.get('enabled', True):
+ logger.info(f"发现 {len(items_need_detail)} 个商品缺少详情,开始获取...")
+ detail_success_count = await self._fetch_missing_item_details(items_need_detail)
+ logger.info(f"成功获取 {detail_success_count}/{len(items_need_detail)} 个商品的详情")
+ else:
+ logger.info(f"发现 {len(items_need_detail)} 个商品缺少详情,但自动获取功能已禁用")
+
+ return saved_count
+
+ except Exception as e:
+ logger.error(f"批量保存商品信息异常: {self._safe_str(e)}")
+ return 0
+
+ async def _fetch_missing_item_details(self, items_need_detail):
+ """批量获取缺失的商品详情
+
+ Args:
+ items_need_detail: 需要获取详情的商品列表
+
+ Returns:
+ int: 成功获取详情的商品数量
+ """
+ success_count = 0
+
+ try:
+ from db_manager import db_manager
+ from config import config
+
+ # 从配置获取并发数量和延迟时间
+ auto_fetch_config = config.get('ITEM_DETAIL', {}).get('auto_fetch', {})
+ max_concurrent = auto_fetch_config.get('max_concurrent', 3)
+ retry_delay = auto_fetch_config.get('retry_delay', 0.5)
+
+ # 限制并发数量,避免对API服务器造成压力
+ semaphore = asyncio.Semaphore(max_concurrent)
+
+ async def fetch_single_item_detail(item_info):
+ async with semaphore:
+ try:
+ item_id = item_info['item_id']
+ item_title = item_info['item_title']
+
+ # 获取商品详情
+ item_detail_text = await self.fetch_item_detail_from_api(item_id)
+
+ if item_detail_text:
+ # 保存详情到数据库
+ success = await self.save_item_detail_only(item_id, item_detail_text)
+ if success:
+ logger.info(f"✅ 成功获取并保存商品详情: {item_id} - {item_title}")
+ return 1
+ else:
+ logger.warning(f"❌ 获取详情成功但保存失败: {item_id}")
+ else:
+ logger.warning(f"❌ 未能获取商品详情: {item_id} - {item_title}")
+
+ # 添加延迟,避免请求过于频繁
+ await asyncio.sleep(retry_delay)
+ return 0
+
+ except Exception as e:
+ logger.error(f"获取单个商品详情异常: {item_info.get('item_id', 'unknown')}, 错误: {self._safe_str(e)}")
+ return 0
+
+ # 并发获取所有商品详情
+ tasks = [fetch_single_item_detail(item_info) for item_info in items_need_detail]
+ results = await asyncio.gather(*tasks, return_exceptions=True)
+
+ # 统计成功数量
+ for result in results:
+ if isinstance(result, int):
+ success_count += result
+ elif isinstance(result, Exception):
+ logger.error(f"获取商品详情任务异常: {result}")
+
+ return success_count
+
+ except Exception as e:
+ logger.error(f"批量获取商品详情异常: {self._safe_str(e)}")
+ return success_count
+
+ async def get_item_info(self, item_id, retry_count=0):
+ """获取商品信息,自动处理token失效的情况"""
+ if retry_count >= 4: # 最多重试3次
+ logger.error("获取商品信息失败,重试次数过多")
+ return {"error": "获取商品信息失败,重试次数过多"}
+
+ # 确保session已创建
+ if not self.session:
+ await self.create_session()
+
+ params = {
+ 'jsv': '2.7.2',
+ 'appKey': '34839810',
+ 't': str(int(time.time()) * 1000),
+ 'sign': '',
+ 'v': '1.0',
+ 'type': 'originaljson',
+ 'accountSite': 'xianyu',
+ 'dataType': 'json',
+ 'timeout': '20000',
+ 'api': 'mtop.taobao.idle.pc.detail',
+ 'sessionOption': 'AutoLoginOnly',
+ 'spm_cnt': 'a21ybx.im.0.0',
+ }
+
+ data_val = '{"itemId":"' + item_id + '"}'
+ data = {
+ 'data': data_val,
+ }
+
+ # 始终从最新的cookies中获取_m_h5_tk token(刷新后cookies会被更新)
+ token = trans_cookies(self.cookies_str).get('_m_h5_tk', '').split('_')[0] if trans_cookies(self.cookies_str).get('_m_h5_tk') else ''
+
+ if token:
+ logger.debug(f"使用cookies中的_m_h5_tk token: {token}")
+ else:
+ logger.warning("cookies中没有找到_m_h5_tk token")
+
+ from utils.xianyu_utils import generate_sign
+ sign = generate_sign(params['t'], token, data_val)
+ params['sign'] = sign
+
+ try:
+ timeout = aiohttp.ClientTimeout(total=15)
+ async with self.session.post(
+ 'https://h5api.m.goofish.com/h5/mtop.taobao.idle.pc.detail/1.0/',
+ params=params,
+ data=data,
+ timeout=timeout
+ ) as response:
+ res_json = await response.json()
+
+ # 检查并更新Cookie
+ if 'set-cookie' in response.headers:
+ new_cookies = {}
+ for cookie in response.headers.getall('set-cookie', []):
+ if '=' in cookie:
+ name, value = cookie.split(';')[0].split('=', 1)
+ new_cookies[name.strip()] = value.strip()
+
+ # 更新cookies
+ if new_cookies:
+ self.cookies.update(new_cookies)
+ # 生成新的cookie字符串
+ self.cookies_str = '; '.join([f"{k}={v}" for k, v in self.cookies.items()])
+ # 更新数据库中的Cookie
+ await self.update_config_cookies()
+ logger.debug("已更新Cookie到数据库")
+
+ logger.debug(f"商品信息获取成功: {res_json}")
+ # 检查返回状态
+ if isinstance(res_json, dict):
+ ret_value = res_json.get('ret', [])
+ # 检查ret是否包含成功信息
+ if not any('SUCCESS::调用成功' in ret for ret in ret_value):
+ logger.warning(f"商品信息API调用失败,错误信息: {ret_value}")
+
+ await asyncio.sleep(0.5)
+ return await self.get_item_info(item_id, retry_count + 1)
+ else:
+ logger.debug(f"商品信息获取成功: {item_id}")
+ return res_json
+ else:
+ logger.error(f"商品信息API返回格式异常: {res_json}")
+ return await self.get_item_info(item_id, retry_count + 1)
+
+ except Exception as e:
+ logger.error(f"商品信息API请求异常: {self._safe_str(e)}")
+ await asyncio.sleep(0.5)
+ return await self.get_item_info(item_id, retry_count + 1)
+
+ def extract_item_id_from_message(self, message):
+ """从消息中提取商品ID的辅助方法"""
+ try:
+ # 方法1: 从message["1"]中提取(如果是字符串格式)
+ message_1 = message.get('1')
+ if isinstance(message_1, str):
+ # 尝试从字符串中提取数字ID
+ id_match = re.search(r'(\d{10,})', message_1)
+ if id_match:
+ logger.info(f"从message[1]字符串中提取商品ID: {id_match.group(1)}")
+ return id_match.group(1)
+
+ # 方法2: 从message["3"]中提取
+ message_3 = message.get('3', {})
+ if isinstance(message_3, dict):
+
+ # 从extension中提取
+ if 'extension' in message_3:
+ extension = message_3['extension']
+ if isinstance(extension, dict):
+ item_id = extension.get('itemId') or extension.get('item_id')
+ if item_id:
+ logger.info(f"从extension中提取商品ID: {item_id}")
+ return item_id
+
+ # 从bizData中提取
+ if 'bizData' in message_3:
+ biz_data = message_3['bizData']
+ if isinstance(biz_data, dict):
+ item_id = biz_data.get('itemId') or biz_data.get('item_id')
+ if item_id:
+ logger.info(f"从bizData中提取商品ID: {item_id}")
+ return item_id
+
+ # 从其他可能的字段中提取
+ for key, value in message_3.items():
+ if isinstance(value, dict):
+ item_id = value.get('itemId') or value.get('item_id')
+ if item_id:
+ logger.info(f"从{key}字段中提取商品ID: {item_id}")
+ return item_id
+
+ # 从消息内容中提取数字ID
+ content = message_3.get('content', '')
+ if isinstance(content, str) and content:
+ id_match = re.search(r'(\d{10,})', content)
+ if id_match:
+ logger.info(f"【{self.cookie_id}】从消息内容中提取商品ID: {id_match.group(1)}")
+ return id_match.group(1)
+
+ # 方法3: 遍历整个消息结构查找可能的商品ID
+ def find_item_id_recursive(obj, path=""):
+ if isinstance(obj, dict):
+ # 直接查找itemId字段
+ for key in ['itemId', 'item_id', 'id']:
+ if key in obj and isinstance(obj[key], (str, int)):
+ value = str(obj[key])
+ if len(value) >= 10 and value.isdigit():
+ logger.info(f"从{path}.{key}中提取商品ID: {value}")
+ return value
+
+ # 递归查找
+ for key, value in obj.items():
+ result = find_item_id_recursive(value, f"{path}.{key}" if path else key)
+ if result:
+ return result
+
+ elif isinstance(obj, str):
+ # 从字符串中提取可能的商品ID
+ id_match = re.search(r'(\d{10,})', obj)
+ if id_match:
+ logger.info(f"从{path}字符串中提取商品ID: {id_match.group(1)}")
+ return id_match.group(1)
+
+ return None
+
+ result = find_item_id_recursive(message)
+ if result:
+ return result
+
+ logger.debug("所有方法都未能提取到商品ID")
+ return None
+
+ except Exception as e:
+ logger.error(f"提取商品ID失败: {self._safe_str(e)}")
+ return None
+
+ def debug_message_structure(self, message, context=""):
+ """调试消息结构的辅助方法"""
+ try:
+ logger.debug(f"[{context}] 消息结构调试:")
+ logger.debug(f" 消息类型: {type(message)}")
+
+ if isinstance(message, dict):
+ for key, value in message.items():
+ logger.debug(f" 键 '{key}': {type(value)} - {str(value)[:100]}...")
+
+ # 特别关注可能包含商品ID的字段
+ if key in ["1", "3"] and isinstance(value, dict):
+ logger.debug(f" 详细结构 '{key}':")
+ for sub_key, sub_value in value.items():
+ logger.debug(f" '{sub_key}': {type(sub_value)} - {str(sub_value)[:50]}...")
+ else:
+ logger.debug(f" 消息内容: {str(message)[:200]}...")
+
+ except Exception as e:
+ logger.error(f"调试消息结构时发生错误: {self._safe_str(e)}")
+
+ async def get_default_reply(self, send_user_name: str, send_user_id: str, send_message: str, chat_id: str, item_id: str = None) -> str:
+ """获取默认回复内容,支持指定商品回复、变量替换和只回复一次功能"""
+ try:
+ from db_manager import db_manager
+
+ # 1. 优先检查指定商品回复
+ if item_id:
+ item_reply = db_manager.get_item_reply(self.cookie_id, item_id)
+ if item_reply and item_reply.get('reply_content'):
+ reply_content = item_reply['reply_content']
+ logger.info(f"【{self.cookie_id}】使用指定商品回复: 商品ID={item_id}")
+
+ # 进行变量替换
+ try:
+ formatted_reply = reply_content.format(
+ send_user_name=send_user_name,
+ send_user_id=send_user_id,
+ send_message=send_message,
+ item_id=item_id
+ )
+ logger.info(f"【{self.cookie_id}】指定商品回复内容: {formatted_reply}")
+ return formatted_reply
+ except Exception as format_error:
+ logger.error(f"指定商品回复变量替换失败: {self._safe_str(format_error)}")
+ # 如果变量替换失败,返回原始内容
+ return reply_content
+ else:
+ logger.debug(f"【{self.cookie_id}】商品ID {item_id} 没有配置指定回复,使用默认回复")
+
+ # 2. 获取当前账号的默认回复设置
+ default_reply_settings = db_manager.get_default_reply(self.cookie_id)
+
+ if not default_reply_settings or not default_reply_settings.get('enabled', False):
+ logger.debug(f"账号 {self.cookie_id} 未启用默认回复")
+ return None
+
+ # 检查"只回复一次"功能
+ if default_reply_settings.get('reply_once', False) and chat_id:
+ # 检查是否已经回复过这个chat_id
+ if db_manager.has_default_reply_record(self.cookie_id, chat_id):
+ logger.info(f"【{self.cookie_id}】chat_id {chat_id} 已使用过默认回复,跳过(只回复一次)")
+ return None
+
+ reply_content = default_reply_settings.get('reply_content', '')
+ if not reply_content or (reply_content and reply_content.strip() == ''):
+ logger.info(f"账号 {self.cookie_id} 默认回复内容为空,不进行回复")
+ return "EMPTY_REPLY" # 返回特殊标记表示不回复
+
+ # 进行变量替换
+ try:
+ # 获取当前商品是否有设置自动回复
+ item_replay = db_manager.get_item_replay(item_id)
+
+ formatted_reply = reply_content.format(
+ send_user_name=send_user_name,
+ send_user_id=send_user_id,
+ send_message=send_message
+ )
+
+ if item_replay:
+ formatted_reply = item_replay.get('reply_content', '')
+
+ # 如果开启了"只回复一次"功能,记录这次回复
+ if default_reply_settings.get('reply_once', False) and chat_id:
+ db_manager.add_default_reply_record(self.cookie_id, chat_id)
+ logger.info(f"【{self.cookie_id}】记录默认回复: chat_id={chat_id}")
+
+ logger.info(f"【{self.cookie_id}】使用默认回复: {formatted_reply}")
+ return formatted_reply
+ except Exception as format_error:
+ logger.error(f"默认回复变量替换失败: {self._safe_str(format_error)}")
+ # 如果变量替换失败,返回原始内容
+ return reply_content
+
+ except Exception as e:
+ logger.error(f"获取默认回复失败: {self._safe_str(e)}")
+ return None
+
+ async def get_keyword_reply(self, send_user_name: str, send_user_id: str, send_message: str, item_id: str = None) -> str:
+ """获取关键词匹配回复(支持商品ID优先匹配和图片类型)"""
+ try:
+ from db_manager import db_manager
+
+ # 获取当前账号的关键词列表(包含类型信息)
+ keywords = db_manager.get_keywords_with_type(self.cookie_id)
+
+ if not keywords:
+ logger.debug(f"账号 {self.cookie_id} 没有配置关键词")
+ return None
+
+ # 1. 如果有商品ID,优先匹配该商品ID对应的关键词
+ if item_id:
+ for keyword_data in keywords:
+ keyword = keyword_data['keyword']
+ reply = keyword_data['reply']
+ keyword_item_id = keyword_data['item_id']
+ keyword_type = keyword_data.get('type', 'text')
+ image_url = keyword_data.get('image_url')
+
+ if keyword_item_id == item_id and keyword.lower() in send_message.lower():
+ logger.info(f"商品ID关键词匹配成功: 商品{item_id} '{keyword}' (类型: {keyword_type})")
+
+ # 根据关键词类型处理
+ if keyword_type == 'image' and image_url:
+ # 图片类型关键词,发送图片
+ return await self._handle_image_keyword(keyword, image_url, send_user_name, send_user_id, send_message)
+ else:
+ # 文本类型关键词,检查回复内容是否为空
+ if not reply or (reply and reply.strip() == ''):
+ logger.info(f"商品ID关键词 '{keyword}' 回复内容为空,不进行回复")
+ return "EMPTY_REPLY" # 返回特殊标记表示匹配到但不回复
+
+ # 进行变量替换
+ try:
+ formatted_reply = reply.format(
+ send_user_name=send_user_name,
+ send_user_id=send_user_id,
+ send_message=send_message
+ )
+ logger.info(f"商品ID文本关键词回复: {formatted_reply}")
+ return formatted_reply
+ except Exception as format_error:
+ logger.error(f"关键词回复变量替换失败: {self._safe_str(format_error)}")
+ # 如果变量替换失败,返回原始内容
+ return reply
+
+ # 2. 如果商品ID匹配失败或没有商品ID,匹配没有商品ID的通用关键词
+ for keyword_data in keywords:
+ keyword = keyword_data['keyword']
+ reply = keyword_data['reply']
+ keyword_item_id = keyword_data['item_id']
+ keyword_type = keyword_data.get('type', 'text')
+ image_url = keyword_data.get('image_url')
+
+ if not keyword_item_id and keyword.lower() in send_message.lower():
+ logger.info(f"通用关键词匹配成功: '{keyword}' (类型: {keyword_type})")
+
+ # 根据关键词类型处理
+ if keyword_type == 'image' and image_url:
+ # 图片类型关键词,发送图片
+ return await self._handle_image_keyword(keyword, image_url, send_user_name, send_user_id, send_message)
+ else:
+ # 文本类型关键词,检查回复内容是否为空
+ if not reply or (reply and reply.strip() == ''):
+ logger.info(f"通用关键词 '{keyword}' 回复内容为空,不进行回复")
+ return "EMPTY_REPLY" # 返回特殊标记表示匹配到但不回复
+
+ # 进行变量替换
+ try:
+ formatted_reply = reply.format(
+ send_user_name=send_user_name,
+ send_user_id=send_user_id,
+ send_message=send_message
+ )
+ logger.info(f"通用文本关键词回复: {formatted_reply}")
+ return formatted_reply
+ except Exception as format_error:
+ logger.error(f"关键词回复变量替换失败: {self._safe_str(format_error)}")
+ # 如果变量替换失败,返回原始内容
+ return reply
+
+ logger.debug(f"未找到匹配的关键词: {send_message}")
+ return None
+
+ except Exception as e:
+ logger.error(f"获取关键词回复失败: {self._safe_str(e)}")
+ return None
+
+ async def _handle_image_keyword(self, keyword: str, image_url: str, send_user_name: str, send_user_id: str, send_message: str) -> str:
+ """处理图片类型关键词"""
+ try:
+ # 检查图片URL类型
+ if self._is_cdn_url(image_url):
+ # 已经是CDN链接,直接使用
+ logger.info(f"使用已有的CDN图片链接: {image_url}")
+ return f"__IMAGE_SEND__{image_url}"
+
+ elif image_url.startswith('/static/uploads/') or image_url.startswith('static/uploads/'):
+ # 本地图片,需要上传到闲鱼CDN
+ local_image_path = image_url.replace('/static/uploads/', 'static/uploads/')
+ if os.path.exists(local_image_path):
+ logger.info(f"准备上传本地图片到闲鱼CDN: {local_image_path}")
+
+ # 使用图片上传器上传到闲鱼CDN
+ from utils.image_uploader import ImageUploader
+ uploader = ImageUploader(self.cookies_str)
+
+ async with uploader:
+ cdn_url = await uploader.upload_image(local_image_path)
+ if cdn_url:
+ logger.info(f"图片上传成功,CDN URL: {cdn_url}")
+ # 更新数据库中的图片URL为CDN URL
+ await self._update_keyword_image_url(keyword, cdn_url)
+ image_url = cdn_url
+ else:
+ logger.error(f"图片上传失败: {local_image_path}")
+ return f"抱歉,图片发送失败,请稍后重试。"
+ else:
+ logger.error(f"本地图片文件不存在: {local_image_path}")
+ return f"抱歉,图片文件不存在。"
+
+ else:
+ # 其他类型的URL(可能是外部链接),直接使用
+ logger.info(f"使用外部图片链接: {image_url}")
+
+ # 发送图片(这里返回特殊标记,在调用处处理实际发送)
+ return f"__IMAGE_SEND__{image_url}"
+
+ except Exception as e:
+ logger.error(f"处理图片关键词失败: {e}")
+ return f"抱歉,图片发送失败: {str(e)}"
+
+ def _is_cdn_url(self, url: str) -> bool:
+ """检查URL是否是闲鱼CDN链接"""
+ if not url:
+ return False
+
+ # 闲鱼CDN域名列表
+ cdn_domains = [
+ 'gw.alicdn.com',
+ 'img.alicdn.com',
+ 'cloud.goofish.com',
+ 'goofish.com',
+ 'taobaocdn.com',
+ 'tbcdn.cn',
+ 'aliimg.com'
+ ]
+
+ # 检查是否包含CDN域名
+ url_lower = url.lower()
+ for domain in cdn_domains:
+ if domain in url_lower:
+ return True
+
+ # 检查是否是HTTPS链接且包含图片特征
+ if url_lower.startswith('https://') and any(ext in url_lower for ext in ['.jpg', '.jpeg', '.png', '.gif', '.webp']):
+ return True
+
+ return False
+
+ async def _update_keyword_image_url(self, keyword: str, new_image_url: str):
+ """更新关键词的图片URL"""
+ try:
+ from db_manager import db_manager
+ success = db_manager.update_keyword_image_url(self.cookie_id, keyword, new_image_url)
+ if success:
+ logger.info(f"图片URL已更新: {keyword} -> {new_image_url}")
+ else:
+ logger.warning(f"图片URL更新失败: {keyword}")
+ except Exception as e:
+ logger.error(f"更新关键词图片URL失败: {e}")
+
+ async def _update_card_image_url(self, card_id: int, new_image_url: str):
+ """更新卡券的图片URL"""
+ try:
+ from db_manager import db_manager
+ success = db_manager.update_card_image_url(card_id, new_image_url)
+ if success:
+ logger.info(f"卡券图片URL已更新: 卡券ID={card_id} -> {new_image_url}")
+ else:
+ logger.warning(f"卡券图片URL更新失败: 卡券ID={card_id}")
+ except Exception as e:
+ logger.error(f"更新卡券图片URL失败: {e}")
+
+ async def get_ai_reply(self, send_user_name: str, send_user_id: str, send_message: str, item_id: str, chat_id: str):
+ """获取AI回复"""
+ try:
+ from ai_reply_engine import ai_reply_engine
+
+ # 检查是否启用AI回复
+ if not ai_reply_engine.is_ai_enabled(self.cookie_id):
+ logger.debug(f"账号 {self.cookie_id} 未启用AI回复")
+ return None
+
+ # 从数据库获取商品信息
+ from db_manager import db_manager
+ item_info_raw = db_manager.get_item_info(self.cookie_id, item_id)
+
+ if not item_info_raw:
+ logger.info(f"数据库中无商品信息,尝试从API获取: {item_id}")
+ # 尝试从API获取商品信息并保存到数据库
+ try:
+ api_result = await self.get_item_info(item_id)
+ if api_result and 'data' in api_result:
+ data = api_result['data']
+ item_data = data.get('itemDO', {})
+ share_data = item_data.get('shareData', {})
+ share_info_str = share_data.get('shareInfoJsonString', '')
+ item_title = ''
+ item_price = ''
+ item_desc = ''
+ if share_info_str:
+ share_info = json.loads(share_info_str)
+ content_params = share_info.get('contentParams', {})
+ main_params = content_params.get('mainParams', {})
+ item_title = main_params.get('content', '')
+ if not item_title:
+ item_title = item_data.get('title', '')
+ item_price = item_data.get('price', '')
+ item_desc = item_data.get('desc', '')
+ if item_title:
+ save_data = {
+ 'title': item_title,
+ 'description': item_desc or item_title,
+ 'price': item_price,
+ }
+ db_manager.save_item_info(self.cookie_id, item_id, save_data)
+ logger.info(f"从API获取并保存商品信息: {item_id} -> {item_title[:50]}")
+ item_info_raw = db_manager.get_item_info(self.cookie_id, item_id)
+ except Exception as e:
+ logger.warning(f"从API获取商品信息失败: {self._safe_str(e)}")
+
+ if not item_info_raw:
+ logger.debug(f"商品信息不可用: {item_id}")
+ item_info = {
+ 'title': '商品信息获取失败',
+ 'price': 0,
+ 'desc': '暂无商品描述'
+ }
+ else:
+ # 解析数据库中的商品信息
+ item_info = {
+ 'title': item_info_raw.get('item_title', '未知商品'),
+ 'price': self._parse_price(item_info_raw.get('item_price', '0')),
+ 'desc': item_info_raw.get('item_description', '暂无商品描述')
+ }
+
+ # 生成AI回复(同步阻塞操作放到线程池,避免阻塞事件循环)
+ reply = await asyncio.to_thread(
+ ai_reply_engine.generate_reply,
+ message=send_message,
+ item_info=item_info,
+ chat_id=chat_id,
+ cookie_id=self.cookie_id,
+ user_id=send_user_id,
+ item_id=item_id
+ )
+
+ if reply:
+ logger.info(f"【{self.cookie_id}】AI回复生成成功: {reply}")
+ return reply
+ else:
+ logger.debug(f"AI回复生成失败")
+ return None
+
+ except Exception as e:
+ logger.error(f"获取AI回复失败: {self._safe_str(e)}")
+ return None
+
+ def _parse_price(self, price_str: str) -> float:
+ """解析价格字符串为数字"""
+ try:
+ if not price_str:
+ return 0.0
+ # 移除非数字字符,保留小数点
+ price_clean = re.sub(r'[^\d.]', '', str(price_str))
+ return float(price_clean) if price_clean else 0.0
+ except:
+ return 0.0
+
+ async def send_notification(self, send_user_name: str, send_user_id: str, send_message: str, item_id: str = None):
+ """发送消息通知"""
+ try:
+ from db_manager import db_manager
+ import aiohttp
+
+ logger.info(f"📱 开始发送消息通知 - 账号: {self.cookie_id}, 买家: {send_user_name}")
+
+ # 获取当前账号的通知配置
+ notifications = db_manager.get_account_notifications(self.cookie_id)
+
+ if not notifications:
+ logger.warning(f"📱 账号 {self.cookie_id} 未配置消息通知,跳过通知发送")
+ return
+
+ logger.info(f"📱 找到 {len(notifications)} 个通知渠道配置")
+
+ # 构建通知消息
+ notification_msg = f"🚨 接收消息通知\n\n" \
+ f"账号: {self.cookie_id}\n" \
+ f"买家: {send_user_name} (ID: {send_user_id})\n" \
+ f"商品ID: {item_id or '未知'}\n" \
+ f"消息内容: {send_message}\n" \
+ f"时间: {time.strftime('%Y-%m-%d %H:%M:%S')}\n\n"
+
+ # 发送通知到各个渠道
+ for i, notification in enumerate(notifications, 1):
+ logger.info(f"📱 处理第 {i} 个通知渠道: {notification.get('channel_name', 'Unknown')}")
+
+ if not notification.get('enabled', True):
+ logger.warning(f"📱 通知渠道 {notification.get('channel_name')} 已禁用,跳过")
+ continue
+
+ channel_type = notification.get('channel_type')
+ channel_config = notification.get('channel_config')
+
+ logger.info(f"📱 渠道类型: {channel_type}, 配置: {channel_config}")
+
+ try:
+ # 解析配置数据
+ config_data = self._parse_notification_config(channel_config)
+ logger.info(f"📱 解析后的配置数据: {config_data}")
+
+ match channel_type:
+ case 'qq':
+ logger.info(f"📱 开始发送QQ通知...")
+ await self._send_qq_notification(config_data, notification_msg)
+ case 'ding_talk' | 'dingtalk':
+ logger.info(f"📱 开始发送钉钉通知...")
+ await self._send_dingtalk_notification(config_data, notification_msg)
+ case 'email':
+ logger.info(f"📱 开始发送邮件通知...")
+ await self._send_email_notification(config_data, notification_msg)
+ case 'webhook':
+ logger.info(f"📱 开始发送Webhook通知...")
+ await self._send_webhook_notification(config_data, notification_msg)
+ case 'wechat':
+ logger.info(f"📱 开始发送微信通知...")
+ await self._send_wechat_notification(config_data, notification_msg)
+ case 'telegram':
+ logger.info(f"📱 开始发送Telegram通知...")
+ await self._send_telegram_notification(config_data, notification_msg)
+ case _:
+ logger.warning(f"📱 不支持的通知渠道类型: {channel_type}")
+
+ except Exception as notify_error:
+ logger.error(f"📱 发送通知失败 ({notification.get('channel_name', 'Unknown')}): {self._safe_str(notify_error)}")
+ import traceback
+ logger.error(f"📱 详细错误信息: {traceback.format_exc()}")
+
+ except Exception as e:
+ logger.error(f"📱 处理消息通知失败: {self._safe_str(e)}")
+ import traceback
+ logger.error(f"📱 详细错误信息: {traceback.format_exc()}")
+
+ def _parse_notification_config(self, config: str) -> dict:
+ """解析通知配置数据"""
+ try:
+ import json
+ # 尝试解析JSON格式的配置
+ return json.loads(config)
+ except (json.JSONDecodeError, TypeError):
+ # 兼容旧格式(直接字符串)
+ return {"config": config}
+
+ async def _send_qq_notification(self, config_data: dict, message: str):
+ """发送QQ通知"""
+ try:
+ import aiohttp
+
+ logger.info(f"📱 QQ通知 - 开始处理配置数据: {config_data}")
+
+ # 解析配置(QQ号码)
+ qq_number = config_data.get('qq_number') or config_data.get('config', '')
+ qq_number = qq_number.strip() if qq_number else ''
+
+ logger.info(f"📱 QQ通知 - 解析到QQ号码: {qq_number}")
+
+ if not qq_number:
+ logger.warning("📱 QQ通知 - QQ号码配置为空,无法发送通知")
+ return
+
+ # 构建请求URL
+ api_url = "http://notice.zhinianblog.cn/sendPrivateMsg"
+ params = {
+ 'qq': qq_number,
+ 'msg': message
+ }
+
+ logger.info(f"📱 QQ通知 - 请求URL: {api_url}")
+ logger.info(f"📱 QQ通知 - 请求参数: qq={qq_number}, msg长度={len(message)}")
+
+ # 发送GET请求
+ async with aiohttp.ClientSession() as session:
+ async with session.get(api_url, params=params, timeout=10) as response:
+ response_text = await response.text()
+ logger.info(f"📱 QQ通知 - 响应状态: {response.status}")
+ logger.info(f"📱 QQ通知 - 响应内容: {response_text}")
+
+ if response.status == 200:
+ logger.info(f"📱 QQ通知发送成功: {qq_number}")
+ else:
+ logger.warning(f"📱 QQ通知发送失败: HTTP {response.status}, 响应: {response_text}")
+
+ except Exception as e:
+ logger.error(f"📱 发送QQ通知异常: {self._safe_str(e)}")
+ import traceback
+ logger.error(f"📱 QQ通知异常详情: {traceback.format_exc()}")
+
+ async def _send_dingtalk_notification(self, config_data: dict, message: str):
+ """发送钉钉通知"""
+ try:
+ import aiohttp
+ import json
+ import hmac
+ import hashlib
+ import base64
+ import time
+
+ # 解析配置
+ webhook_url = config_data.get('webhook_url') or config_data.get('config', '')
+ secret = config_data.get('secret', '')
+
+ webhook_url = webhook_url.strip() if webhook_url else ''
+ if not webhook_url:
+ logger.warning("钉钉通知配置为空")
+ return
+
+ # 如果有加签密钥,生成签名
+ if secret:
+ timestamp = str(round(time.time() * 1000))
+ secret_enc = secret.encode('utf-8')
+ string_to_sign = f'{timestamp}\n{secret}'
+ string_to_sign_enc = string_to_sign.encode('utf-8')
+ hmac_code = hmac.new(secret_enc, string_to_sign_enc, digestmod=hashlib.sha256).digest()
+ sign = base64.b64encode(hmac_code).decode('utf-8')
+ webhook_url += f'×tamp={timestamp}&sign={sign}'
+
+ data = {
+ "msgtype": "markdown",
+ "markdown": {
+ "title": "闲鱼自动回复通知",
+ "text": message
+ }
+ }
+
+ async with aiohttp.ClientSession() as session:
+ async with session.post(webhook_url, json=data, timeout=10) as response:
+ if response.status == 200:
+ logger.info(f"钉钉通知发送成功")
+ else:
+ logger.warning(f"钉钉通知发送失败: {response.status}")
+
+ except Exception as e:
+ logger.error(f"发送钉钉通知异常: {self._safe_str(e)}")
+
+ async def _send_email_notification(self, config_data: dict, message: str):
+ """发送邮件通知"""
+ try:
+ import smtplib
+ from email.mime.text import MIMEText
+ from email.mime.multipart import MIMEMultipart
+
+ # 解析配置
+ smtp_server = config_data.get('smtp_server', '')
+ smtp_port = int(config_data.get('smtp_port', 587))
+ email_user = config_data.get('email_user', '')
+ email_password = config_data.get('email_password', '')
+ recipient_email = config_data.get('recipient_email', '')
+
+ if not all([smtp_server, email_user, email_password, recipient_email]):
+ logger.warning("邮件通知配置不完整")
+ return
+
+ # 创建邮件
+ msg = MIMEMultipart()
+ msg['From'] = email_user
+ msg['To'] = recipient_email
+ msg['Subject'] = "闲鱼自动回复通知"
+
+ # 添加邮件正文
+ msg.attach(MIMEText(message, 'plain', 'utf-8'))
+
+ # 发送邮件
+ server = smtplib.SMTP(smtp_server, smtp_port)
+ server.starttls()
+ server.login(email_user, email_password)
+ server.send_message(msg)
+ server.quit()
+
+ logger.info(f"邮件通知发送成功: {recipient_email}")
+
+ except Exception as e:
+ logger.error(f"发送邮件通知异常: {self._safe_str(e)}")
+
+ async def _send_webhook_notification(self, config_data: dict, message: str):
+ """发送Webhook通知"""
+ try:
+ import aiohttp
+ import json
+
+ # 解析配置
+ webhook_url = config_data.get('webhook_url', '')
+ http_method = config_data.get('http_method', 'POST').upper()
+ headers_str = config_data.get('headers', '{}')
+
+ if not webhook_url:
+ logger.warning("Webhook通知配置为空")
+ return
+
+ # 解析自定义请求头
+ try:
+ custom_headers = json.loads(headers_str) if headers_str else {}
+ except json.JSONDecodeError:
+ custom_headers = {}
+
+ # 设置默认请求头
+ headers = {'Content-Type': 'application/json'}
+ headers.update(custom_headers)
+
+ # 构建请求数据
+ data = {
+ 'message': message,
+ 'timestamp': time.strftime('%Y-%m-%d %H:%M:%S'),
+ 'source': 'xianyu-auto-reply'
+ }
+
+ async with aiohttp.ClientSession() as session:
+ if http_method == 'POST':
+ async with session.post(webhook_url, json=data, headers=headers, timeout=10) as response:
+ if response.status == 200:
+ logger.info(f"Webhook通知发送成功")
+ else:
+ logger.warning(f"Webhook通知发送失败: {response.status}")
+ elif http_method == 'PUT':
+ async with session.put(webhook_url, json=data, headers=headers, timeout=10) as response:
+ if response.status == 200:
+ logger.info(f"Webhook通知发送成功")
+ else:
+ logger.warning(f"Webhook通知发送失败: {response.status}")
+ else:
+ logger.warning(f"不支持的HTTP方法: {http_method}")
+
+ except Exception as e:
+ logger.error(f"发送Webhook通知异常: {self._safe_str(e)}")
+
+ async def _send_wechat_notification(self, config_data: dict, message: str):
+ """发送微信通知"""
+ try:
+ import aiohttp
+ import json
+
+ # 解析配置
+ webhook_url = config_data.get('webhook_url', '')
+
+ if not webhook_url:
+ logger.warning("微信通知配置为空")
+ return
+
+ data = {
+ "msgtype": "text",
+ "text": {
+ "content": message
+ }
+ }
+
+ async with aiohttp.ClientSession() as session:
+ async with session.post(webhook_url, json=data, timeout=10) as response:
+ if response.status == 200:
+ logger.info(f"微信通知发送成功")
+ else:
+ logger.warning(f"微信通知发送失败: {response.status}")
+
+ except Exception as e:
+ logger.error(f"发送微信通知异常: {self._safe_str(e)}")
+
+ async def _send_telegram_notification(self, config_data: dict, message: str):
+ """发送Telegram通知"""
+ try:
+ import aiohttp
+
+ # 解析配置
+ bot_token = config_data.get('bot_token', '')
+ chat_id = config_data.get('chat_id', '')
+
+ if not all([bot_token, chat_id]):
+ logger.warning("Telegram通知配置不完整")
+ return
+
+ # 构建API URL
+ api_url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
+
+ data = {
+ 'chat_id': chat_id,
+ 'text': message,
+ 'parse_mode': 'HTML'
+ }
+
+ async with aiohttp.ClientSession() as session:
+ async with session.post(api_url, json=data, timeout=10) as response:
+ if response.status == 200:
+ logger.info(f"Telegram通知发送成功")
+ else:
+ logger.warning(f"Telegram通知发送失败: {response.status}")
+
+ except Exception as e:
+ logger.error(f"发送Telegram通知异常: {self._safe_str(e)}")
+
+ async def send_token_refresh_notification(self, error_message: str, notification_type: str = "token_refresh"):
+ """发送Token刷新异常通知(带防重复机制)"""
+ try:
+ # 检查是否是正常的令牌过期,这种情况不需要发送通知
+ if self._is_normal_token_expiry(error_message):
+ logger.debug(f"检测到正常的令牌过期,跳过通知: {error_message}")
+ return
+
+ # 检查是否在冷却期内
+ current_time = time.time()
+ last_time = self.last_notification_time.get(notification_type, 0)
+
+ # 为Token刷新异常通知使用特殊的3小时冷却时间
+ # 基于错误消息内容判断是否为Token相关异常
+ if self._is_token_related_error(error_message):
+ cooldown_time = self.token_refresh_notification_cooldown
+ cooldown_desc = "3小时"
+ else:
+ cooldown_time = self.notification_cooldown
+ cooldown_desc = f"{self.notification_cooldown // 60}分钟"
+
+ if current_time - last_time < cooldown_time:
+ remaining_time = cooldown_time - (current_time - last_time)
+ remaining_hours = int(remaining_time // 3600)
+ remaining_minutes = int((remaining_time % 3600) // 60)
+ remaining_seconds = int(remaining_time % 60)
+
+ if remaining_hours > 0:
+ time_desc = f"{remaining_hours}小时{remaining_minutes}分钟"
+ elif remaining_minutes > 0:
+ time_desc = f"{remaining_minutes}分钟{remaining_seconds}秒"
+ else:
+ time_desc = f"{remaining_seconds}秒"
+
+ logger.debug(f"Token刷新通知在冷却期内,跳过发送: {notification_type} (还需等待 {time_desc})")
+ return
+
+ from db_manager import db_manager
+
+ # 获取当前账号的通知配置
+ notifications = db_manager.get_account_notifications(self.cookie_id)
+
+ if not notifications:
+ logger.debug("未配置消息通知,跳过Token刷新通知")
+ return
+
+ # 构造通知消息
+ notification_msg = f"""🔴 闲鱼账号Token刷新异常
+
+账号ID: {self.cookie_id}
+异常时间: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())}
+异常信息: {error_message}
+
+请检查账号Cookie是否过期,如有需要请及时更新Cookie配置。"""
+
+ logger.info(f"准备发送Token刷新异常通知: {self.cookie_id}")
+
+ # 发送通知到各个渠道
+ notification_sent = False
+ for notification in notifications:
+ if not notification.get('enabled', True):
+ continue
+
+ channel_type = notification.get('channel_type')
+ channel_config = notification.get('channel_config')
+
+ try:
+ # 解析配置数据
+ config_data = self._parse_notification_config(channel_config)
+
+ match channel_type:
+ case 'qq':
+ await self._send_qq_notification(config_data, notification_msg)
+ notification_sent = True
+ case 'ding_talk' | 'dingtalk':
+ await self._send_dingtalk_notification(config_data, notification_msg)
+ notification_sent = True
+ case 'email':
+ await self._send_email_notification(config_data, notification_msg)
+ notification_sent = True
+ case 'webhook':
+ await self._send_webhook_notification(config_data, notification_msg)
+ notification_sent = True
+ case 'wechat':
+ await self._send_wechat_notification(config_data, notification_msg)
+ notification_sent = True
+ case 'telegram':
+ await self._send_telegram_notification(config_data, notification_msg)
+ notification_sent = True
+ case _:
+ logger.warning(f"不支持的通知渠道类型: {channel_type}")
+
+ except Exception as notify_error:
+ logger.error(f"发送Token刷新通知失败 ({notification.get('channel_name', 'Unknown')}): {self._safe_str(notify_error)}")
+
+ # 如果成功发送了通知,更新最后发送时间
+ if notification_sent:
+ self.last_notification_time[notification_type] = current_time
+
+ # 根据错误消息内容使用不同的冷却时间
+ if self._is_token_related_error(error_message):
+ next_send_time = current_time + self.token_refresh_notification_cooldown
+ cooldown_desc = "3小时"
+ else:
+ next_send_time = current_time + self.notification_cooldown
+ cooldown_desc = f"{self.notification_cooldown // 60}分钟"
+
+ next_send_time_str = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(next_send_time))
+ logger.info(f"Token刷新通知已发送,下次可发送时间: {next_send_time_str} (冷却时间: {cooldown_desc})")
+
+ except Exception as e:
+ logger.error(f"处理Token刷新通知失败: {self._safe_str(e)}")
+
+ def _is_normal_token_expiry(self, error_message: str) -> bool:
+ """检查是否是正常的令牌过期或其他不需要通知的情况"""
+ # 不需要发送通知的关键词
+ no_notification_keywords = [
+ # 正常的令牌过期
+ 'FAIL_SYS_TOKEN_EXOIRED::令牌过期',
+ 'FAIL_SYS_TOKEN_EXPIRED::令牌过期',
+ 'FAIL_SYS_TOKEN_EXOIRED',
+ 'FAIL_SYS_TOKEN_EXPIRED',
+ '令牌过期',
+ # Session过期(正常情况)
+ 'FAIL_SYS_SESSION_EXPIRED::Session过期',
+ 'FAIL_SYS_SESSION_EXPIRED',
+ 'Session过期',
+ # Token定时刷新失败(会自动重试)
+ 'Token定时刷新失败,将自动重试',
+ 'Token定时刷新失败'
+ ]
+
+ # 检查错误消息是否包含不需要通知的关键词
+ for keyword in no_notification_keywords:
+ if keyword in error_message:
+ return True
+
+ return False
+
+ def _is_token_related_error(self, error_message: str) -> bool:
+ """检查是否是Token相关的错误,需要使用3小时冷却时间"""
+ # Token相关错误的关键词
+ token_error_keywords = [
+ # Token刷新失败相关
+ 'Token刷新失败',
+ 'Token刷新异常',
+ 'token刷新失败',
+ 'token刷新异常',
+ 'TOKEN刷新失败',
+ 'TOKEN刷新异常',
+ # 具体的Token错误信息
+ 'FAIL_SYS_USER_VALIDATE',
+ 'RGV587_ERROR',
+ '哎哟喂,被挤爆啦',
+ '请稍后重试',
+ 'punish?x5secdata',
+ 'captcha',
+ # Token获取失败
+ '无法获取有效token',
+ '无法获取有效Token',
+ 'Token获取失败',
+ 'token获取失败',
+ 'TOKEN获取失败',
+ # Token定时刷新失败
+ 'Token定时刷新失败',
+ 'token定时刷新失败',
+ 'TOKEN定时刷新失败',
+ # 初始化Token失败
+ '初始化时无法获取有效Token',
+ '初始化时无法获取有效token',
+ # 其他Token相关错误
+ 'accessToken',
+ 'access_token',
+ '_m_h5_tk',
+ 'mtop.taobao.idlemessage.pc.login.token'
+ ]
+
+ # 检查错误消息是否包含Token相关的关键词
+ error_message_lower = error_message.lower()
+ for keyword in token_error_keywords:
+ if keyword.lower() in error_message_lower:
+ return True
+
+ return False
+
+ async def send_delivery_failure_notification(self, send_user_name: str, send_user_id: str, item_id: str, error_message: str):
+ """发送自动发货失败通知"""
+ try:
+ from db_manager import db_manager
+
+ # 获取当前账号的通知配置
+ notifications = db_manager.get_account_notifications(self.cookie_id)
+
+ if not notifications:
+ logger.debug("未配置消息通知,跳过自动发货通知")
+ return
+
+ # 构造通知消息
+ notification_message = f"🚨 自动发货通知\n\n" \
+ f"账号: {self.cookie_id}\n" \
+ f"买家: {send_user_name} (ID: {send_user_id})\n" \
+ f"商品ID: {item_id}\n" \
+ f"结果: {error_message}\n" \
+ f"时间: {time.strftime('%Y-%m-%d %H:%M:%S')}\n\n" \
+ f"请及时处理!"
+
+ # 发送通知到所有已启用的通知渠道
+ for notification in notifications:
+ if notification.get('enabled', False):
+ channel_type = notification.get('channel_type', 'qq')
+ channel_config = notification.get('channel_config', '')
+
+ try:
+ # 解析配置数据
+ config_data = self._parse_notification_config(channel_config)
+
+ match channel_type:
+ case 'qq':
+ await self._send_qq_notification(config_data, notification_message)
+ logger.info(f"已发送自动发货通知到QQ")
+ case 'ding_talk' | 'dingtalk':
+ await self._send_dingtalk_notification(config_data, notification_message)
+ logger.info(f"已发送自动发货通知到钉钉")
+ case 'email':
+ await self._send_email_notification(config_data, notification_message)
+ logger.info(f"已发送自动发货通知到邮箱")
+ case 'webhook':
+ await self._send_webhook_notification(config_data, notification_message)
+ logger.info(f"已发送自动发货通知到Webhook")
+ case 'wechat':
+ await self._send_wechat_notification(config_data, notification_message)
+ logger.info(f"已发送自动发货通知到微信")
+ case 'telegram':
+ await self._send_telegram_notification(config_data, notification_message)
+ logger.info(f"已发送自动发货通知到Telegram")
+ case _:
+ logger.warning(f"不支持的通知渠道类型: {channel_type}")
+
+ except Exception as notify_error:
+ logger.error(f"发送自动发货通知失败: {self._safe_str(notify_error)}")
+
+ except Exception as e:
+ logger.error(f"发送自动发货通知异常: {self._safe_str(e)}")
+
+ async def auto_confirm(self, order_id, item_id=None, retry_count=0):
+ """自动确认发货 - 使用加密模块,不包含延时处理(延时已在_auto_delivery中处理)"""
+ try:
+ logger.debug(f"【{self.cookie_id}】开始确认发货,订单ID: {order_id}")
+
+ # 导入解密后的确认发货模块
+ from secure_confirm_decrypted import SecureConfirm
+
+ # 创建确认实例,传入主界面类实例
+ secure_confirm = SecureConfirm(self.session, self.cookies_str, self.cookie_id, self)
+
+ # 传递必要的属性
+ secure_confirm.current_token = self.current_token
+ secure_confirm.last_token_refresh_time = self.last_token_refresh_time
+ secure_confirm.token_refresh_interval = self.token_refresh_interval
+
+ # 调用确认方法,传入item_id用于token刷新
+ result = await secure_confirm.auto_confirm(order_id, item_id, retry_count)
+
+ # 同步更新后的cookies和token
+ if secure_confirm.cookies_str != self.cookies_str:
+ self.cookies_str = secure_confirm.cookies_str
+ self.cookies = secure_confirm.cookies
+ logger.debug(f"【{self.cookie_id}】已同步确认发货模块更新的cookies")
+
+ if secure_confirm.current_token != self.current_token:
+ self.current_token = secure_confirm.current_token
+ self.last_token_refresh_time = secure_confirm.last_token_refresh_time
+ logger.debug(f"【{self.cookie_id}】已同步确认发货模块更新的token")
+
+ return result
+
+ except Exception as e:
+ logger.error(f"【{self.cookie_id}】加密确认模块调用失败: {self._safe_str(e)}")
+ return {"error": f"加密确认模块调用失败: {self._safe_str(e)}", "order_id": order_id}
+
+ async def auto_freeshipping(self, order_id, item_id, buyer_id, retry_count=0):
+ """自动免拼发货 - 使用解密模块"""
+ try:
+ logger.debug(f"【{self.cookie_id}】开始免拼发货,订单ID: {order_id}")
+
+ # 导入解密后的免拼发货模块
+ from secure_freeshipping_decrypted import SecureFreeshipping
+
+ # 创建免拼发货实例
+ secure_freeshipping = SecureFreeshipping(self.session, self.cookies_str, self.cookie_id)
+
+ # 传递必要的属性
+ secure_freeshipping.current_token = self.current_token
+ secure_freeshipping.last_token_refresh_time = self.last_token_refresh_time
+ secure_freeshipping.token_refresh_interval = self.token_refresh_interval
+
+ # 调用免拼发货方法
+ return await secure_freeshipping.auto_freeshipping(order_id, item_id, buyer_id, retry_count)
+
+ except Exception as e:
+ logger.error(f"【{self.cookie_id}】免拼发货模块调用失败: {self._safe_str(e)}")
+ return {"error": f"免拼发货模块调用失败: {self._safe_str(e)}", "order_id": order_id}
+
+ async def fetch_order_detail_info(self, order_id: str, item_id: str = None, buyer_id: str = None, debug_headless: bool = None):
+ """获取订单详情信息(使用独立的锁机制,不受延迟锁影响)"""
+ # 使用独立的订单详情锁,不与自动发货锁冲突
+ order_detail_lock = self._order_detail_locks[order_id]
+
+ # 记录订单详情锁的使用时间
+ self._order_detail_lock_times[order_id] = time.time()
+
+ async with order_detail_lock:
+ logger.info(f"🔍 【{self.cookie_id}】获取订单详情锁 {order_id},开始处理...")
+
+ try:
+ logger.info(f"【{self.cookie_id}】开始获取订单详情: {order_id}")
+
+ # 导入订单详情获取器
+ from utils.order_detail_fetcher import fetch_order_detail_simple
+ from db_manager import db_manager
+
+ # 获取当前账号的cookie字符串
+ cookie_string = self.cookies_str
+ logger.debug(f"【{self.cookie_id}】使用Cookie长度: {len(cookie_string) if cookie_string else 0}")
+
+ # 确定是否使用有头模式(调试用)
+ headless_mode = True if debug_headless is None else debug_headless
+ if not headless_mode:
+ logger.info(f"【{self.cookie_id}】🖥️ 启用有头模式进行调试")
+
+ # 异步获取订单详情(使用当前账号的cookie)
+ result = await fetch_order_detail_simple(order_id, cookie_string, headless=headless_mode)
+
+ if result:
+ logger.info(f"【{self.cookie_id}】订单详情获取成功: {order_id}")
+ logger.info(f"【{self.cookie_id}】页面标题: {result.get('title', '未知')}")
+
+ # 获取解析后的规格信息
+ spec_name = result.get('spec_name', '')
+ spec_value = result.get('spec_value', '')
+ quantity = result.get('quantity', '')
+ amount = result.get('amount', '')
+
+ if spec_name and spec_value:
+ logger.info(f"【{self.cookie_id}】📋 规格名称: {spec_name}")
+ logger.info(f"【{self.cookie_id}】📝 规格值: {spec_value}")
+ print(f"🛍️ 【{self.cookie_id}】订单 {order_id} 规格信息: {spec_name} -> {spec_value}")
+ else:
+ logger.warning(f"【{self.cookie_id}】未获取到有效的规格信息")
+ print(f"⚠️ 【{self.cookie_id}】订单 {order_id} 规格信息获取失败")
+
+ # 插入或更新订单信息到数据库
+ try:
+ # 检查cookie_id是否在cookies表中存在
+ cookie_info = db_manager.get_cookie_by_id(self.cookie_id)
+ if not cookie_info:
+ logger.warning(f"Cookie ID {self.cookie_id} 不存在于cookies表中,丢弃订单 {order_id}")
+ else:
+ # 保存商品标题到 item_info(用于发货规则匹配)
+ item_title_from_result = result.get('title', '')
+ if item_id and item_title_from_result:
+ try:
+ await self.save_item_info_to_db(item_id, item_title_from_result, item_title_from_result)
+ except Exception as save_e:
+ logger.debug(f"保存商品信息失败: {self._safe_str(save_e)}")
+
+ success = db_manager.insert_or_update_order(
+ order_id=order_id,
+ item_id=item_id,
+ buyer_id=buyer_id,
+ spec_name=spec_name,
+ spec_value=spec_value,
+ quantity=quantity,
+ amount=amount,
+ order_status='processed', # 已处理状态
+ cookie_id=self.cookie_id
+ )
+
+ if success:
+ logger.info(f"【{self.cookie_id}】订单信息已保存到数据库: {order_id}")
+ print(f"💾 【{self.cookie_id}】订单 {order_id} 信息已保存到数据库")
+ else:
+ logger.warning(f"【{self.cookie_id}】订单信息保存失败: {order_id}")
+
+ except Exception as db_e:
+ logger.error(f"【{self.cookie_id}】保存订单信息到数据库失败: {self._safe_str(db_e)}")
+
+ return result
+ else:
+ logger.warning(f"【{self.cookie_id}】订单详情获取失败: {order_id}")
+ return None
+
+ except Exception as e:
+ logger.error(f"【{self.cookie_id}】获取订单详情异常: {self._safe_str(e)}")
+ return None
+
+ async def _auto_delivery(self, item_id: str, item_title: str = None, order_id: str = None, send_user_id: str = None, send_user_name: str = None):
+ """自动发货功能 - 获取卡券规则,执行延时,确认发货,发送内容"""
+ try:
+ from db_manager import db_manager
+
+ logger.info(f"开始自动发货检查: 商品ID={item_id}")
+
+ # 获取商品详细信息
+ item_info = None
+ search_text = item_title # 默认使用传入的标题
+
+ if item_id and item_id != "未知商品":
+ # 优先尝试通过API获取商品信息
+ try:
+ logger.info(f"通过API获取商品详细信息: {item_id}")
+ item_info = await self.get_item_info(item_id)
+ if item_info and 'data' in item_info:
+ data = item_info['data']
+ item_data = data['itemDO']
+ shareData = item_data['shareData']
+ shareInfoJsonString = shareData['shareInfoJsonString']
+
+ # 解析 shareInfoJsonString 并提取 content 内容
+ try:
+ share_info = json.loads(shareInfoJsonString)
+ content = share_info.get('contentParams', {}).get('mainParams', {}).get('content', '')
+ if content:
+ search_text = content
+ logger.info(f"API成功提取商品内容作为搜索文本: {content[:100]}...")
+ else:
+ search_text = shareInfoJsonString
+ logger.warning("未能从API商品信息中提取到content字段,使用完整JSON字符串")
+ except json.JSONDecodeError as json_e:
+ logger.warning(f"解析API商品信息JSON失败: {self._safe_str(json_e)},使用原始字符串")
+ search_text = shareInfoJsonString
+ except Exception as parse_e:
+ logger.warning(f"提取API商品内容失败: {self._safe_str(parse_e)},使用原始字符串")
+ search_text = shareInfoJsonString
+
+ logger.info(f"API获取到的商品信息为: {search_text[:200]}...")
+ else:
+ raise Exception("API返回数据格式异常")
+
+ except Exception as e:
+ logger.warning(f"API获取商品信息失败: {self._safe_str(e)},尝试从数据库获取")
+
+ # API失败时,从数据库获取商品信息
+ try:
+ db_item_info = db_manager.get_item_info(self.cookie_id, item_id)
+ if db_item_info:
+ # 拼接商品标题和详情作为搜索文本
+ item_title_db = db_item_info.get('item_title', '') or ''
+ item_detail_db = db_item_info.get('item_detail', '') or ''
+
+ # 如果数据库中没有详情,尝试从外部API获取
+ if not item_detail_db.strip():
+ from config import config
+ auto_fetch_config = config.get('ITEM_DETAIL', {}).get('auto_fetch', {})
+
+ if auto_fetch_config.get('enabled', True):
+ logger.info(f"数据库中商品详情为空,尝试从外部API获取: {item_id}")
+ try:
+ fetched_detail = await self.fetch_item_detail_from_api(item_id)
+ if fetched_detail:
+ # 保存获取到的详情
+ await self.save_item_detail_only(item_id, fetched_detail)
+ item_detail_db = fetched_detail
+ logger.info(f"成功从外部API获取并保存商品详情: {item_id}")
+ else:
+ logger.warning(f"外部API未能获取到商品详情: {item_id}")
+ except Exception as api_e:
+ logger.warning(f"从外部API获取商品详情失败: {item_id}, 错误: {self._safe_str(api_e)}")
+ else:
+ logger.debug(f"自动获取商品详情功能已禁用,跳过: {item_id}")
+
+ # 组合搜索文本:商品标题 + 商品详情
+ search_parts = []
+ if item_title_db.strip():
+ search_parts.append(item_title_db.strip())
+ if item_detail_db.strip():
+ search_parts.append(item_detail_db.strip())
+
+ if search_parts:
+ search_text = ' '.join(search_parts)
+ logger.info(f"使用数据库商品标题+详情作为搜索文本: 标题='{item_title_db}', 详情长度={len(item_detail_db)}")
+ logger.debug(f"完整搜索文本: {search_text[:200]}...")
+ else:
+ logger.warning(f"数据库中商品标题和详情都为空,且无法从API获取: {item_id}")
+ search_text = item_title or item_id
+ else:
+ logger.debug(f"数据库中未找到商品信息: {item_id}")
+ search_text = item_title or item_id
+
+ except Exception as db_e:
+ logger.debug(f"从数据库获取商品信息失败: {self._safe_str(db_e)}")
+ search_text = item_title or item_id
+
+ if not search_text:
+ search_text = item_id or "未知商品"
+
+ logger.info(f"使用搜索文本匹配发货规则: {search_text[:100]}...")
+
+ # 检查商品是否为多规格商品
+ is_multi_spec = db_manager.get_item_multi_spec_status(self.cookie_id, item_id)
+ spec_name = None
+ spec_value = None
+
+ # 如果是多规格商品且有订单ID,获取规格信息
+ if is_multi_spec and order_id:
+ logger.info(f"检测到多规格商品,获取订单规格信息: {order_id}")
+ try:
+ order_detail = await self.fetch_order_detail_info(order_id, item_id, send_user_id)
+ if order_detail:
+ spec_name = order_detail.get('spec_name', '')
+ spec_value = order_detail.get('spec_value', '')
+ if spec_name and spec_value:
+ logger.info(f"获取到规格信息: {spec_name} = {spec_value}")
+ else:
+ logger.warning(f"未能获取到规格信息,将使用兜底匹配")
+ else:
+ logger.warning(f"获取订单详情失败,将使用兜底匹配")
+ except Exception as e:
+ logger.error(f"获取订单规格信息失败: {self._safe_str(e)},将使用兜底匹配")
+
+ # 智能匹配发货规则:优先精确匹配,然后兜底匹配
+ delivery_rules = []
+
+ # 第一步:如果有规格信息,尝试精确匹配多规格发货规则
+ if spec_name and spec_value:
+ logger.info(f"尝试精确匹配多规格发货规则: {search_text[:50]}... [{spec_name}:{spec_value}]")
+ delivery_rules = db_manager.get_delivery_rules_by_keyword_and_spec(search_text, spec_name, spec_value)
+
+ if delivery_rules:
+ logger.info(f"✅ 找到精确匹配的多规格发货规则: {len(delivery_rules)}个")
+ else:
+ logger.info(f"❌ 未找到精确匹配的多规格发货规则")
+
+ # 第二步:如果精确匹配失败,尝试兜底匹配(普通发货规则)
+ if not delivery_rules:
+ logger.info(f"尝试兜底匹配普通发货规则: {search_text[:50]}...")
+ delivery_rules = db_manager.get_delivery_rules_by_keyword(search_text)
+
+ if delivery_rules:
+ logger.info(f"✅ 找到兜底匹配的普通发货规则: {len(delivery_rules)}个")
+ else:
+ logger.info(f"❌ 未找到任何匹配的发货规则")
+
+ if not delivery_rules:
+ logger.warning(f"未找到匹配的发货规则: {search_text[:50]}...")
+ return None
+
+ # 使用第一个匹配的规则(按关键字长度降序排列,优先匹配更精确的规则)
+ rule = delivery_rules[0]
+
+ # 保存商品信息到数据库(需要有商品标题才保存)
+ # 尝试获取商品标题
+ item_title_for_save = None
+ try:
+ from db_manager import db_manager
+ db_item_info = db_manager.get_item_info(self.cookie_id, item_id)
+ if db_item_info:
+ item_title_for_save = db_item_info.get('item_title', '').strip()
+ except:
+ pass
+
+ # 如果有商品标题,则保存商品信息
+ if item_title_for_save:
+ await self.save_item_info_to_db(item_id, search_text, item_title_for_save)
+ else:
+ logger.debug(f"跳过保存商品信息:缺少商品标题 - {item_id}")
+
+ # 详细的匹配结果日志
+ if rule.get('is_multi_spec'):
+ if spec_name and spec_value:
+ logger.info(f"🎯 精确匹配多规格发货规则: {rule['keyword']} -> {rule['card_name']} [{rule['spec_name']}:{rule['spec_value']}]")
+ logger.info(f"📋 订单规格: {spec_name}:{spec_value} ✅ 匹配卡券规格: {rule['spec_name']}:{rule['spec_value']}")
+ else:
+ logger.info(f"⚠️ 使用多规格发货规则但无订单规格信息: {rule['keyword']} -> {rule['card_name']} [{rule['spec_name']}:{rule['spec_value']}]")
+ else:
+ if spec_name and spec_value:
+ logger.info(f"🔄 兜底匹配普通发货规则: {rule['keyword']} -> {rule['card_name']} ({rule['card_type']})")
+ logger.info(f"📋 订单规格: {spec_name}:{spec_value} ➡️ 使用普通卡券兜底")
+ else:
+ logger.info(f"✅ 匹配普通发货规则: {rule['keyword']} -> {rule['card_name']} ({rule['card_type']})")
+
+ # 获取延时设置
+ delay_seconds = rule.get('card_delay_seconds', 0)
+
+ # 执行延时(不管是否确认发货,只要有延时设置就执行)
+ if delay_seconds and delay_seconds > 0:
+ logger.info(f"检测到发货延时设置: {delay_seconds}秒,开始延时...")
+ await asyncio.sleep(delay_seconds)
+ logger.info(f"延时完成")
+
+ # 如果有订单ID,执行确认发货
+ if order_id:
+ # 检查是否启用自动确认发货
+ if not self.is_auto_confirm_enabled():
+ logger.info(f"自动确认发货已关闭,跳过订单 {order_id}")
+ else:
+ # 检查确认发货冷却时间
+ current_time = time.time()
+ should_confirm = True
+
+ if order_id in self.confirmed_orders:
+ last_confirm_time = self.confirmed_orders[order_id]
+ if current_time - last_confirm_time < self.order_confirm_cooldown:
+ logger.info(f"订单 {order_id} 已在 {self.order_confirm_cooldown} 秒内确认过,跳过重复确认")
+ should_confirm = False
+
+ if should_confirm:
+ logger.info(f"开始自动确认发货: 订单ID={order_id}, 商品ID={item_id}")
+ confirm_result = await self.auto_confirm(order_id, item_id)
+ if confirm_result.get('success'):
+ self.confirmed_orders[order_id] = current_time
+ logger.info(f"🎉 自动确认发货成功!订单ID: {order_id}")
+ else:
+ logger.warning(f"⚠️ 自动确认发货失败: {confirm_result.get('error', '未知错误')}")
+ # 即使确认发货失败,也继续发送发货内容
+
+ # 检查是否存在订单ID,只有存在订单ID才处理发货内容
+ if order_id:
+ # 保存订单基本信息到数据库(如果还没有详细信息)
+ try:
+ from db_manager import db_manager
+
+ # 检查cookie_id是否在cookies表中存在
+ cookie_info = db_manager.get_cookie_by_id(self.cookie_id)
+ if not cookie_info:
+ logger.warning(f"Cookie ID {self.cookie_id} 不存在于cookies表中,丢弃订单 {order_id}")
+ else:
+ existing_order = db_manager.get_order_by_id(order_id)
+ if not existing_order:
+ # 插入基本订单信息
+ db_manager.insert_or_update_order(
+ order_id=order_id,
+ item_id=item_id,
+ buyer_id=send_user_id,
+ order_status='processing', # 处理中状态
+ cookie_id=self.cookie_id,
+ buyer_name=send_user_name or ''
+ )
+ logger.info(f"保存基本订单信息到数据库: {order_id}")
+ except Exception as db_e:
+ logger.error(f"保存基本订单信息失败: {self._safe_str(db_e)}")
+
+ # 开始处理发货内容
+ logger.info(f"开始处理发货内容,规则: {rule['keyword']} -> {rule['card_name']} ({rule['card_type']})")
+
+ delivery_content = None
+
+ # 根据卡券类型处理发货内容
+ if rule['card_type'] == 'api':
+ # API类型:调用API获取内容,传入订单和商品信息用于动态参数替换
+ delivery_content = await self._get_api_card_content(rule, order_id, item_id, send_user_id, spec_name, spec_value)
+
+ elif rule['card_type'] == 'text':
+ # 固定文字类型:直接使用文字内容
+ delivery_content = rule['text_content']
+
+ elif rule['card_type'] == 'data':
+ # 批量数据类型:获取并消费第一条数据
+ delivery_content = db_manager.consume_batch_data(rule['card_id'])
+
+ elif rule['card_type'] == 'image':
+ # 图片类型:返回图片发送标记,包含卡券ID
+ image_url = rule.get('image_url')
+ if image_url:
+ delivery_content = f"__IMAGE_SEND__{rule['card_id']}|{image_url}"
+ logger.info(f"准备发送图片: {image_url} (卡券ID: {rule['card_id']})")
+ else:
+ logger.error(f"图片卡券缺少图片URL: 卡券ID={rule['card_id']}")
+ delivery_content = None
+
+ if delivery_content:
+ # 处理备注信息和变量替换
+ final_content = self._process_delivery_content_with_description(delivery_content, rule.get('card_description', ''))
+
+ # 增加发货次数统计
+ db_manager.increment_delivery_times(rule['id'])
+
+ # 更新订单发货状态为成功
+ if order_id:
+ db_manager.update_order_delivery_status(order_id, 'delivered')
+
+ logger.info(f"自动发货成功: 规则ID={rule['id']}, 内容长度={len(final_content)}")
+ return final_content
+ else:
+ # 更新订单发货状态为失败
+ if order_id:
+ db_manager.update_order_delivery_status(order_id, 'failed')
+
+ logger.warning(f"获取发货内容失败: 规则ID={rule['id']}")
+ return None
+ else:
+ # 没有订单ID,记录日志但不处理发货内容
+ logger.info(f"⚠️ 未检测到订单ID,跳过发货内容处理。规则: {rule['keyword']} -> {rule['card_name']} ({rule['card_type']})")
+ return None
+
+ except Exception as e:
+ logger.error(f"自动发货失败: {self._safe_str(e)}")
+ return None
+
+
+
+ def _process_delivery_content_with_description(self, delivery_content: str, card_description: str) -> str:
+ """处理发货内容和备注信息,实现变量替换"""
+ try:
+ # 如果没有备注信息,直接返回发货内容
+ if not card_description or not card_description.strip():
+ return delivery_content
+
+ # 替换备注中的变量
+ processed_description = card_description.replace('{DELIVERY_CONTENT}', delivery_content)
+
+ # 如果备注中包含变量替换,返回处理后的备注
+ if '{DELIVERY_CONTENT}' in card_description:
+ return processed_description
+ else:
+ # 如果备注中没有变量,将备注和发货内容组合
+ return f"{processed_description}\n\n{delivery_content}"
+
+ except Exception as e:
+ logger.error(f"处理备注信息失败: {e}")
+ # 出错时返回原始发货内容
+ return delivery_content
+
+ async def _get_api_card_content(self, rule, order_id=None, item_id=None, buyer_id=None, spec_name=None, spec_value=None, retry_count=0):
+ """调用API获取卡券内容,支持动态参数替换和重试机制"""
+ max_retries = 4
+
+ if retry_count >= max_retries:
+ logger.error(f"API调用失败,已达到最大重试次数({max_retries})")
+ return None
+
+ try:
+ import aiohttp
+ import json
+
+ api_config = rule.get('api_config')
+ if not api_config:
+ logger.error(f"API配置为空,规则ID: {rule.get('id')}, 卡券名称: {rule.get('card_name')}")
+ logger.debug(f"规则详情: {rule}")
+ return None
+
+ # 解析API配置
+ if isinstance(api_config, str):
+ api_config = json.loads(api_config)
+
+ url = api_config.get('url')
+ method = api_config.get('method', 'GET').upper()
+ timeout = api_config.get('timeout', 10)
+ headers = api_config.get('headers', '{}')
+ params = api_config.get('params', '{}')
+
+ # 解析headers和params
+ if isinstance(headers, str):
+ headers = json.loads(headers)
+ if isinstance(params, str):
+ params = json.loads(params)
+
+ # 如果是POST请求且有动态参数,进行参数替换
+ if method == 'POST' and params:
+ params = await self._replace_api_dynamic_params(params, order_id, item_id, buyer_id, spec_name, spec_value)
+
+ retry_info = f" (重试 {retry_count + 1}/{max_retries})" if retry_count > 0 else ""
+ logger.info(f"调用API获取卡券: {method} {url}{retry_info}")
+ if method == 'POST' and params:
+ logger.debug(f"POST请求参数: {json.dumps(params, ensure_ascii=False)}")
+
+ # 确保session存在
+ if not self.session:
+ await self.create_session()
+
+ # 发起HTTP请求
+ timeout_obj = aiohttp.ClientTimeout(total=timeout)
+
+ if method == 'GET':
+ async with self.session.get(url, headers=headers, params=params, timeout=timeout_obj) as response:
+ status_code = response.status
+ response_text = await response.text()
+ elif method == 'POST':
+ async with self.session.post(url, headers=headers, json=params, timeout=timeout_obj) as response:
+ status_code = response.status
+ response_text = await response.text()
+ else:
+ logger.error(f"不支持的HTTP方法: {method}")
+ return None
+
+ if status_code == 200:
+ # 尝试解析JSON响应,如果失败则使用原始文本
+ try:
+ result = json.loads(response_text)
+ # 如果返回的是对象,尝试提取常见的内容字段
+ if isinstance(result, dict):
+ content = result.get('data') or result.get('content') or result.get('card') or str(result)
+ else:
+ content = str(result)
+ except:
+ content = response_text
+
+ logger.info(f"API调用成功,返回内容长度: {len(content)}")
+ return content
+ else:
+ logger.warning(f"API调用失败: {status_code} - {response_text[:200]}...")
+
+ # 如果是服务器错误(5xx)或请求超时,进行重试
+ if status_code >= 500 or status_code == 408:
+ if retry_count < max_retries - 1:
+ wait_time = (retry_count + 1) * 2 # 递增等待时间: 2s, 4s, 6s
+ logger.info(f"等待 {wait_time} 秒后重试...")
+ await asyncio.sleep(wait_time)
+ return await self._get_api_card_content(rule, order_id, item_id, buyer_id, spec_name, spec_value, retry_count + 1)
+
+ return None
+
+ except (aiohttp.ClientTimeout, aiohttp.ClientError) as e:
+ logger.warning(f"API调用网络异常: {self._safe_str(e)}")
+
+ # 网络异常也进行重试
+ if retry_count < max_retries - 1:
+ wait_time = (retry_count + 1) * 2 # 递增等待时间
+ logger.info(f"等待 {wait_time} 秒后重试...")
+ await asyncio.sleep(wait_time)
+ return await self._get_api_card_content(rule, order_id, item_id, buyer_id, spec_name, spec_value, retry_count + 1)
+ else:
+ logger.error(f"API调用网络异常,已达到最大重试次数: {self._safe_str(e)}")
+ return None
+
+ except Exception as e:
+ logger.error(f"API调用异常: {self._safe_str(e)}")
+ return None
+
+ async def _replace_api_dynamic_params(self, params, order_id=None, item_id=None, buyer_id=None, spec_name=None, spec_value=None):
+ """替换API请求参数中的动态参数"""
+ try:
+ if not params or not isinstance(params, dict):
+ return params
+
+ # 获取订单和商品信息
+ order_info = None
+ item_info = None
+
+ # 如果有订单ID,获取订单信息
+ if order_id:
+ try:
+ from db_manager import db_manager
+ # 尝试从数据库获取订单信息
+ order_info = db_manager.get_order_by_id(order_id)
+ if not order_info:
+ # 如果数据库中没有,尝试通过API获取
+ order_detail = await self.fetch_order_detail_info(order_id, item_id, buyer_id)
+ if order_detail:
+ order_info = order_detail
+ logger.debug(f"通过API获取到订单信息: {order_id}")
+ else:
+ logger.warning(f"无法获取订单信息: {order_id}")
+ else:
+ logger.debug(f"从数据库获取到订单信息: {order_id}")
+ except Exception as e:
+ logger.warning(f"获取订单信息失败: {self._safe_str(e)}")
+
+ # 如果有商品ID,获取商品信息
+ if item_id:
+ try:
+ from db_manager import db_manager
+ item_info = db_manager.get_item_info(self.cookie_id, item_id)
+ if item_info:
+ logger.debug(f"从数据库获取到商品信息: {item_id}")
+ else:
+ logger.warning(f"无法获取商品信息: {item_id}")
+ except Exception as e:
+ logger.warning(f"获取商品信息失败: {self._safe_str(e)}")
+
+ # 构建参数映射
+ param_mapping = {
+ 'order_id': order_id or '',
+ 'item_id': item_id or '',
+ 'buyer_id': buyer_id or '',
+ 'cookie_id': self.cookie_id or '',
+ 'spec_name': spec_name or '',
+ 'spec_value': spec_value or '',
+ }
+
+ # 从订单信息中提取参数
+ if order_info:
+ param_mapping.update({
+ 'order_amount': str(order_info.get('amount', '')),
+ 'order_quantity': str(order_info.get('quantity', '')),
+ })
+
+ # 从商品信息中提取参数
+ if item_info:
+ # 处理商品详情,如果是JSON字符串则提取detail字段
+ item_detail = item_info.get('item_detail', '')
+ if item_detail:
+ try:
+ # 尝试解析JSON
+ import json
+ detail_data = json.loads(item_detail)
+ if isinstance(detail_data, dict) and 'detail' in detail_data:
+ item_detail = detail_data['detail']
+ except (json.JSONDecodeError, TypeError):
+ # 如果不是JSON或解析失败,使用原始字符串
+ pass
+
+ param_mapping.update({
+ 'item_detail': item_detail,
+ })
+
+ # 递归替换参数
+ replaced_params = self._recursive_replace_params(params, param_mapping)
+
+ # 记录替换的参数
+ replaced_keys = []
+ for key, value in replaced_params.items():
+ if isinstance(value, str) and '{' in str(params.get(key, '')):
+ replaced_keys.append(key)
+
+ if replaced_keys:
+ logger.info(f"API动态参数替换完成,替换的参数: {replaced_keys}")
+ logger.debug(f"参数映射: {param_mapping}")
+
+ return replaced_params
+
+ except Exception as e:
+ logger.error(f"替换API动态参数失败: {self._safe_str(e)}")
+ return params
+
+ def _recursive_replace_params(self, obj, param_mapping):
+ """递归替换参数中的占位符"""
+ if isinstance(obj, dict):
+ result = {}
+ for key, value in obj.items():
+ result[key] = self._recursive_replace_params(value, param_mapping)
+ return result
+ elif isinstance(obj, list):
+ return [self._recursive_replace_params(item, param_mapping) for item in obj]
+ elif isinstance(obj, str):
+ # 替换字符串中的占位符
+ result = obj
+ for param_key, param_value in param_mapping.items():
+ placeholder = f"{{{param_key}}}"
+ if placeholder in result:
+ result = result.replace(placeholder, str(param_value))
+ return result
+ else:
+ return obj
+
+ async def token_refresh_loop(self):
+ """Token刷新循环"""
+ while True:
+ try:
+ # 检查账号是否启用
+ from cookie_manager import manager as cookie_manager
+ if cookie_manager and not cookie_manager.get_cookie_status(self.cookie_id):
+ logger.info(f"【{self.cookie_id}】账号已禁用,停止Token刷新循环")
+ break
+
+ # 直接等待刷新间隔,避免每60s空轮询
+ await asyncio.sleep(self.token_refresh_interval)
+
+ logger.info("Token即将过期,准备刷新...")
+
+ # 使用传统方式刷新token
+ new_token = await self.refresh_token()
+ if new_token:
+ logger.info(f"【{self.cookie_id}】Token刷新成功,准备重启实例...")
+ self.connection_restart_flag = True
+ if self.ws:
+ await self.ws.close()
+ break
+ else:
+ logger.error(f"【{self.cookie_id}】Token刷新失败,将在{self.token_retry_interval // 60}分钟后重试")
+ await self.send_token_refresh_notification("Token定时刷新失败,将自动重试", "token_scheduled_refresh_failed")
+ await asyncio.sleep(self.token_retry_interval)
+ continue
+ except Exception as e:
+ logger.error(f"Token刷新循环出错: {self._safe_str(e)}")
+ await asyncio.sleep(self.token_retry_interval)
+
+ async def create_chat(self, ws, toid, item_id='891198795482'):
+ msg = {
+ "lwp": "/r/SingleChatConversation/create",
+ "headers": {
+ "mid": generate_mid()
+ },
+ "body": [
+ {
+ "pairFirst": f"{toid}@goofish",
+ "pairSecond": f"{self.myid}@goofish",
+ "bizType": "1",
+ "extension": {
+ "itemId": item_id
+ },
+ "ctx": {
+ "appVersion": "1.0",
+ "platform": "web"
+ }
+ }
+ ]
+ }
+ await ws.send(json.dumps(msg))
+
+ async def send_msg(self, ws, cid, toid, text):
+ text = {
+ "contentType": 1,
+ "text": {
+ "text": text
+ }
+ }
+ text_base64 = str(base64.b64encode(json.dumps(text).encode('utf-8')), 'utf-8')
+ msg = {
+ "lwp": "/r/MessageSend/sendByReceiverScope",
+ "headers": {
+ "mid": generate_mid()
+ },
+ "body": [
+ {
+ "uuid": generate_uuid(),
+ "cid": f"{cid}@goofish",
+ "conversationType": 1,
+ "content": {
+ "contentType": 101,
+ "custom": {
+ "type": 1,
+ "data": text_base64
+ }
+ },
+ "redPointPolicy": 0,
+ "extension": {
+ "extJson": "{}"
+ },
+ "ctx": {
+ "appVersion": "1.0",
+ "platform": "web"
+ },
+ "mtags": {},
+ "msgReadStatusSetting": 1
+ },
+ {
+ "actualReceivers": [
+ f"{toid}@goofish",
+ f"{self.myid}@goofish"
+ ]
+ }
+ ]
+ }
+ await ws.send(json.dumps(msg))
+
+ async def init(self, ws):
+ # 如果没有token或者token过期,获取新token
+ token_refresh_attempted = False
+ if not self.current_token or (time.time() - self.last_token_refresh_time) >= self.token_refresh_interval:
+ logger.info(f"【{self.cookie_id}】获取初始token...")
+ token_refresh_attempted = True
+ await self.refresh_token()
+
+ if not self.current_token:
+ logger.error("无法获取有效token,初始化失败")
+ # 只有在没有尝试刷新token的情况下才发送通知,避免与refresh_token中的通知重复
+ if not token_refresh_attempted:
+ await self.send_token_refresh_notification("初始化时无法获取有效Token", "token_init_failed")
+ else:
+ logger.info("由于刚刚尝试过token刷新,跳过重复的初始化失败通知")
+ raise Exception("Token获取失败")
+
+ msg = {
+ "lwp": "/reg",
+ "headers": {
+ "cache-header": "app-key token ua wv",
+ "app-key": APP_CONFIG.get('app_key'),
+ "token": self.current_token,
+ "ua": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36 DingTalk(2.1.5) OS(Windows/10) Browser(Chrome/133.0.0.0) DingWeb/2.1.5 IMPaaS DingWeb/2.1.5",
+ "dt": "j",
+ "wv": "im:3,au:3,sy:6",
+ "sync": "0,0;0;0;",
+ "did": self.device_id,
+ "mid": generate_mid()
+ }
+ }
+ await ws.send(json.dumps(msg))
+ await asyncio.sleep(1)
+ current_time = int(time.time() * 1000)
+ msg = {
+ "lwp": "/r/SyncStatus/ackDiff",
+ "headers": {"mid": generate_mid()},
+ "body": [
+ {
+ "pipeline": "sync",
+ "tooLong2Tag": "PNM,1",
+ "channel": "sync",
+ "topic": "sync",
+ "highPts": 0,
+ "pts": current_time * 1000,
+ "seq": 0,
+ "timestamp": current_time
+ }
+ ]
+ }
+ await ws.send(json.dumps(msg))
+ logger.info(f'【{self.cookie_id}】连接注册完成')
+
+ async def send_heartbeat(self, ws):
+ """发送心跳包"""
+ msg = {
+ "lwp": "/!",
+ "headers": {
+ "mid": generate_mid()
+ }
+ }
+ await ws.send(json.dumps(msg))
+ self.last_heartbeat_time = time.time()
+ logger.debug(f"【{self.cookie_id}】心跳包已发送")
+
+ async def heartbeat_loop(self, ws):
+ """心跳循环"""
+ while True:
+ try:
+ # 检查账号是否启用
+ from cookie_manager import manager as cookie_manager
+ if cookie_manager and not cookie_manager.get_cookie_status(self.cookie_id):
+ logger.info(f"【{self.cookie_id}】账号已禁用,停止心跳循环")
+ break
+
+ await self.send_heartbeat(ws)
+ await asyncio.sleep(self.heartbeat_interval)
+ except Exception as e:
+ logger.error(f"心跳发送失败: {self._safe_str(e)}")
+ break
+
+ async def handle_heartbeat_response(self, message_data):
+ """处理心跳响应"""
+ try:
+ if message_data.get("code") == 200:
+ self.last_heartbeat_response = time.time()
+ logger.debug("心跳响应正常")
+ return True
+ except Exception as e:
+ logger.error(f"处理心跳响应出错: {self._safe_str(e)}")
+ return False
+
+ async def pause_cleanup_loop(self):
+ """定期清理过期的暂停记录和锁"""
+ while True:
+ try:
+ # 检查账号是否启用
+ from cookie_manager import manager as cookie_manager
+ if cookie_manager and not cookie_manager.get_cookie_status(self.cookie_id):
+ logger.info(f"【{self.cookie_id}】账号已禁用,停止清理循环")
+ break
+
+ # 清理过期的暂停记录
+ pause_manager.cleanup_expired_pauses()
+
+ # 清理过期的锁(每5分钟清理一次,保留24小时内的锁)
+ self.cleanup_expired_locks(max_age_hours=24)
+
+ # 每5分钟清理一次
+ await asyncio.sleep(300)
+ except Exception as e:
+ logger.error(f"【{self.cookie_id}】清理任务失败: {self._safe_str(e)}")
+ await asyncio.sleep(300) # 出错后也等待5分钟再重试
+
+ async def send_msg_once(self, toid, item_id, text):
+ headers = {
+ "Cookie": self.cookies_str,
+ "Host": "wss-goofish.dingtalk.com",
+ "Connection": "Upgrade",
+ "Pragma": "no-cache",
+ "Cache-Control": "no-cache",
+ "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36",
+ "Origin": "https://www.goofish.com",
+ "Accept-Encoding": "gzip, deflate, br, zstd",
+ "Accept-Language": "zh-CN,zh;q=0.9",
+ }
+ # 兼容不同版本的websockets库
+ try:
+ async with websockets.connect(
+ self.base_url,
+ extra_headers=headers
+ ) as websocket:
+ await self._handle_websocket_connection(websocket, toid, item_id, text)
+ except TypeError as e:
+ # 安全地检查异常信息
+ error_msg = self._safe_str(e)
+
+ if "extra_headers" in error_msg:
+ logger.warning("websockets库不支持extra_headers参数,使用兼容模式")
+ # 使用兼容模式,通过subprotocols传递部分头信息
+ async with websockets.connect(
+ self.base_url,
+ additional_headers=headers
+ ) as websocket:
+ await self._handle_websocket_connection(websocket, toid, item_id, text)
+ else:
+ raise
+
+ async def _create_websocket_connection(self, headers):
+ """创建WebSocket连接,兼容不同版本的websockets库"""
+ import websockets
+
+ # 获取websockets版本用于调试
+ websockets_version = getattr(websockets, '__version__', '未知')
+ logger.debug(f"websockets库版本: {websockets_version}")
+
+ try:
+ # 尝试使用extra_headers参数
+ return websockets.connect(
+ self.base_url,
+ extra_headers=headers
+ )
+ except Exception as e:
+ # 捕获所有异常类型,不仅仅是TypeError
+ error_msg = self._safe_str(e)
+ logger.debug(f"extra_headers参数失败: {error_msg}")
+
+ if "extra_headers" in error_msg or "unexpected keyword argument" in error_msg:
+ logger.warning("websockets库不支持extra_headers参数,尝试additional_headers")
+ # 使用additional_headers参数(较新版本)
+ try:
+ return websockets.connect(
+ self.base_url,
+ additional_headers=headers
+ )
+ except Exception as e2:
+ error_msg2 = self._safe_str(e2)
+ logger.debug(f"additional_headers参数失败: {error_msg2}")
+
+ if "additional_headers" in error_msg2 or "unexpected keyword argument" in error_msg2:
+ # 如果都不支持,则不传递headers
+ logger.warning("websockets库不支持headers参数,使用基础连接模式")
+ return websockets.connect(self.base_url)
+ else:
+ raise e2
+ else:
+ raise e
+
+ async def _handle_websocket_connection(self, websocket, toid, item_id, text):
+ """处理WebSocket连接的具体逻辑"""
+ await self.init(websocket)
+ await self.create_chat(websocket, toid, item_id)
+ async for message in websocket:
+ try:
+ logger.info(f"【{self.cookie_id}】message: {message}")
+ message = json.loads(message)
+ cid = message["body"]["singleChatConversation"]["cid"]
+ cid = cid.split('@')[0]
+ await self.send_msg(websocket, cid, toid, text)
+ logger.info(f'【{self.cookie_id}】send message')
+ return
+ except Exception as e:
+ pass
+
+ def is_chat_message(self, message):
+ """判断是否为用户聊天消息"""
+ try:
+ return (
+ isinstance(message, dict)
+ and "1" in message
+ and isinstance(message["1"], dict)
+ and "10" in message["1"]
+ and isinstance(message["1"]["10"], dict)
+ and "reminderContent" in message["1"]["10"]
+ )
+ except Exception:
+ return False
+
+ def is_sync_package(self, message_data):
+ """判断是否为同步包消息"""
+ try:
+ return (
+ isinstance(message_data, dict)
+ and "body" in message_data
+ and "syncPushPackage" in message_data["body"]
+ and "data" in message_data["body"]["syncPushPackage"]
+ and len(message_data["body"]["syncPushPackage"]["data"]) > 0
+ )
+ except Exception:
+ return False
+
+ async def create_session(self):
+ """创建aiohttp session"""
+ if not self.session:
+ # 创建带有cookies和headers的session
+ headers = DEFAULT_HEADERS.copy()
+ headers['cookie'] = self.cookies_str
+
+ self.session = aiohttp.ClientSession(
+ headers=headers,
+ timeout=aiohttp.ClientTimeout(total=30)
+ )
+
+ async def close_session(self):
+ """关闭aiohttp session"""
+ if self.session:
+ await self.session.close()
+ self.session = None
+
+ async def get_api_reply(self, msg_time, user_url, send_user_id, send_user_name, item_id, send_message, chat_id):
+ """调用API获取回复消息"""
+ try:
+ if not self.session:
+ await self.create_session()
+
+ api_config = AUTO_REPLY.get('api', {})
+ timeout = aiohttp.ClientTimeout(total=api_config.get('timeout', 10))
+
+ payload = {
+ "cookie_id": self.cookie_id,
+ "msg_time": msg_time,
+ "user_url": user_url,
+ "send_user_id": send_user_id,
+ "send_user_name": send_user_name,
+ "item_id": item_id,
+ "send_message": send_message,
+ "chat_id": chat_id
+ }
+
+ async with self.session.post(
+ api_config.get('url', 'http://localhost:8080/xianyu/reply'),
+ json=payload,
+ timeout=timeout
+ ) as response:
+ result = await response.json()
+
+ # 将code转换为字符串进行比较,或者直接用数字比较
+ if str(result.get('code')) == '200' or result.get('code') == 200:
+ send_msg = result.get('data', {}).get('send_msg')
+ if send_msg:
+ # 格式化消息中的占位符
+ return send_msg.format(
+ send_user_id=payload['send_user_id'],
+ send_user_name=payload['send_user_name'],
+ send_message=payload['send_message']
+ )
+ else:
+ logger.warning("API返回成功但无回复消息")
+ return None
+ else:
+ logger.warning(f"API返回错误: {result.get('msg', '未知错误')}")
+ return None
+
+ except asyncio.TimeoutError:
+ logger.error("API调用超时")
+ return None
+ except Exception as e:
+ logger.error(f"调用API出错: {self._safe_str(e)}")
+ return None
+
+ async def handle_message(self, message_data, websocket):
+ """处理所有类型的消息"""
+ try:
+ # 检查账号是否启用
+ from cookie_manager import manager as cookie_manager
+ if cookie_manager and not cookie_manager.get_cookie_status(self.cookie_id):
+ logger.debug(f"【{self.cookie_id}】账号已禁用,跳过消息处理")
+ return
+
+ # 发送确认消息
+ try:
+ message = message_data
+ ack = {
+ "code": 200,
+ "headers": {
+ "mid": message["headers"]["mid"] if "mid" in message["headers"] else generate_mid(),
+ "sid": message["headers"]["sid"] if "sid" in message["headers"] else '',
+ }
+ }
+ if 'app-key' in message["headers"]:
+ ack["headers"]["app-key"] = message["headers"]["app-key"]
+ if 'ua' in message["headers"]:
+ ack["headers"]["ua"] = message["headers"]["ua"]
+ if 'dt' in message["headers"]:
+ ack["headers"]["dt"] = message["headers"]["dt"]
+ await websocket.send(json.dumps(ack))
+ except Exception as e:
+ pass
+
+ # 如果不是同步包消息,直接返回
+ if not self.is_sync_package(message_data):
+ return
+
+ # 获取并解密数据
+ sync_data = message_data["body"]["syncPushPackage"]["data"][0]
+
+ # 检查是否有必要的字段
+ if "data" not in sync_data:
+ logger.debug("同步包中无data字段")
+ return
+
+ # 解密数据
+ message = None
+ try:
+ data = sync_data["data"]
+ try:
+ data = base64.b64decode(data).decode("utf-8")
+ parsed_data = json.loads(data)
+ # 处理未加密的消息(如系统提示等)
+ msg_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+ if isinstance(parsed_data, dict) and 'chatType' in parsed_data:
+ if 'operation' in parsed_data and 'content' in parsed_data['operation']:
+ content = parsed_data['operation']['content']
+ if 'sessionArouse' in content:
+ # 处理系统引导消息
+ logger.info(f"[{msg_time}] 【{self.cookie_id}】【系统】小闲鱼智能提示:")
+ if 'arouseChatScriptInfo' in content['sessionArouse']:
+ for qa in content['sessionArouse']['arouseChatScriptInfo']:
+ logger.info(f" - {qa['chatScrip']}")
+ elif 'contentType' in content:
+ # 其他类型的未加密消息
+ logger.debug(f"[{msg_time}] 【{self.cookie_id}】【系统】其他类型消息: {content}")
+ return
+ else:
+ # 如果不是系统消息,将解析的数据作为message
+ message = parsed_data
+ except Exception as e:
+ # 如果JSON解析失败,尝试解密
+ decrypted_data = decrypt(data)
+ message = json.loads(decrypted_data)
+ except Exception as e:
+ logger.error(f"消息解密失败: {self._safe_str(e)}")
+ return
+
+ # 确保message不为空
+ if message is None:
+ logger.error("消息解析后为空")
+ return
+
+ # 确保message是字典类型
+ if not isinstance(message, dict):
+ logger.error(f"消息格式错误,期望字典但得到: {type(message)}")
+ logger.debug(f"消息内容: {message}")
+ return
+
+ # 【优先处理】尝试获取订单ID并获取订单详情
+ order_id = None
+ try:
+ order_id = self._extract_order_id(message)
+ if order_id:
+ msg_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】✅ 检测到订单ID: {order_id},开始获取订单详情')
+
+ # 立即获取订单详情信息
+ try:
+ # 先尝试提取用户ID和商品ID用于订单详情获取
+ temp_user_id = None
+ temp_item_id = None
+
+ # 提取用户ID
+ try:
+ message_1 = message.get("1")
+ if isinstance(message_1, str) and '@' in message_1:
+ temp_user_id = message_1.split('@')[0]
+ elif isinstance(message_1, dict):
+ # 从字典中提取用户ID
+ if "10" in message_1 and isinstance(message_1["10"], dict):
+ temp_user_id = message_1["10"].get("senderUserId", "unknown_user")
+ else:
+ temp_user_id = "unknown_user"
+ else:
+ temp_user_id = "unknown_user"
+ except:
+ temp_user_id = "unknown_user"
+
+ # 提取商品ID
+ try:
+ if "1" in message and isinstance(message["1"], dict) and "10" in message["1"] and isinstance(message["1"]["10"], dict):
+ url_info = message["1"]["10"].get("reminderUrl", "")
+ if isinstance(url_info, str) and "itemId=" in url_info:
+ temp_item_id = url_info.split("itemId=")[1].split("&")[0]
+
+ if not temp_item_id:
+ temp_item_id = self.extract_item_id_from_message(message)
+ except:
+ pass
+
+ # 调用订单详情获取方法
+ order_detail = await self.fetch_order_detail_info(order_id, temp_item_id, temp_user_id)
+ if order_detail:
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】✅ 订单详情获取成功: {order_id}')
+ else:
+ logger.warning(f'[{msg_time}] 【{self.cookie_id}】⚠️ 订单详情获取失败: {order_id}')
+
+ # 同步保存商品信息到 item_info(用于发货规则匹配)
+ if temp_item_id:
+ try:
+ existing_item = db_manager.get_item_info(self.cookie_id, temp_item_id)
+ if not existing_item:
+ # 尝试从API获取商品标题
+ api_result = await self.get_item_info(temp_item_id)
+ if api_result and 'data' in api_result:
+ data = api_result['data']
+ item_data = data.get('itemDO', {})
+ share_data = item_data.get('shareData', {})
+ share_info_str = share_data.get('shareInfoJsonString', '')
+ item_title = ''
+ if share_info_str:
+ share_info = json.loads(share_info_str)
+ item_title = share_info.get('contentParams', {}).get('mainParams', {}).get('content', '')
+ if not item_title:
+ item_title = item_data.get('title', '')
+ if item_title:
+ await self.save_item_info_to_db(temp_item_id, item_title, item_title)
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】保存商品信息: {temp_item_id} -> {item_title[:50]}')
+ except Exception as item_e:
+ logger.debug(f"保存商品信息失败: {self._safe_str(item_e)}")
+
+ except Exception as detail_e:
+ logger.error(f'[{msg_time}] 【{self.cookie_id}】❌ 获取订单详情异常: {self._safe_str(detail_e)}')
+ else:
+ logger.debug(f"【{self.cookie_id}】未检测到订单ID")
+ except Exception as e:
+ logger.error(f"【{self.cookie_id}】提取订单ID失败: {self._safe_str(e)}")
+
+ # 安全地获取用户ID
+ user_id = None
+ try:
+ message_1 = message.get("1")
+ if isinstance(message_1, str) and '@' in message_1:
+ user_id = message_1.split('@')[0]
+ elif isinstance(message_1, dict):
+ # 如果message['1']是字典,从message["1"]["10"]["senderUserId"]中提取user_id
+ if "10" in message_1 and isinstance(message_1["10"], dict):
+ user_id = message_1["10"].get("senderUserId", "unknown_user")
+ else:
+ user_id = "unknown_user"
+ else:
+ user_id = "unknown_user"
+ except Exception as e:
+ logger.debug(f"提取用户ID失败: {self._safe_str(e)}")
+ user_id = "unknown_user"
+
+
+
+ # 安全地提取商品ID
+ item_id = None
+ try:
+ if "1" in message and isinstance(message["1"], dict) and "10" in message["1"] and isinstance(message["1"]["10"], dict):
+ url_info = message["1"]["10"].get("reminderUrl", "")
+ if isinstance(url_info, str) and "itemId=" in url_info:
+ item_id = url_info.split("itemId=")[1].split("&")[0]
+
+ # 如果没有提取到,使用辅助方法
+ if not item_id:
+ item_id = self.extract_item_id_from_message(message)
+
+ if not item_id:
+ item_id = f"auto_{user_id}_{int(time.time())}"
+ logger.debug(f"无法提取商品ID,使用默认值: {item_id}")
+
+ except Exception as e:
+ logger.error(f"提取商品ID时发生错误: {self._safe_str(e)}")
+ item_id = f"auto_{user_id}_{int(time.time())}"
+ # 处理订单状态消息
+ try:
+ logger.info(message)
+ msg_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+
+ # 安全地检查订单状态
+ red_reminder = None
+ if isinstance(message, dict) and "3" in message and isinstance(message["3"], dict):
+ red_reminder = message["3"].get("redReminder")
+
+ if red_reminder == '等待买家付款':
+ user_url = f'https://www.goofish.com/personal?userId={user_id}'
+ logger.info(f'[{msg_time}] 【系统】等待买家 {user_url} 付款')
+ return
+ elif red_reminder == '交易关闭':
+ user_url = f'https://www.goofish.com/personal?userId={user_id}'
+ logger.info(f'[{msg_time}] 【系统】买家 {user_url} 交易关闭')
+ return
+ elif red_reminder == '等待卖家发货':
+ user_url = f'https://www.goofish.com/personal?userId={user_id}'
+ logger.info(f'[{msg_time}] 【系统】交易成功 {user_url} 等待卖家发货')
+ # return
+ except:
+ pass
+
+ # 判断是否为聊天消息
+ if not self.is_chat_message(message):
+ logger.debug("非聊天消息")
+ return
+
+ # 处理聊天消息
+ try:
+ # 安全地提取聊天消息信息
+ if not (isinstance(message, dict) and "1" in message and isinstance(message["1"], dict)):
+ logger.error("消息格式错误:缺少必要的字段结构")
+ return
+
+ message_1 = message["1"]
+ if not isinstance(message_1.get("10"), dict):
+ logger.error("消息格式错误:缺少消息详情字段")
+ return
+
+ create_time = int(message_1.get("5", 0))
+ message_10 = message_1["10"]
+ send_user_name = message_10.get("senderNick", message_10.get("reminderTitle", "未知用户"))
+ send_user_id = message_10.get("senderUserId", "unknown")
+ send_message = message_10.get("reminderContent", "")
+
+ chat_id_raw = message_1.get("2", "")
+ chat_id = chat_id_raw.split('@')[0] if '@' in str(chat_id_raw) else str(chat_id_raw)
+
+ except Exception as e:
+ logger.error(f"提取聊天消息信息失败: {self._safe_str(e)}")
+ return
+
+ # 格式化消息时间
+ msg_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(create_time/1000))
+
+
+
+ # 判断消息方向
+ if send_user_id == self.myid:
+ logger.info(f"[{msg_time}] 【手动发出】 商品({item_id}): {send_message}")
+
+ # 暂停该chat_id的自动回复10分钟
+ pause_manager.pause_chat(chat_id, self.cookie_id)
+
+ return
+ else:
+ logger.info(f"[{msg_time}] 【收到】用户: {send_user_name} (ID: {send_user_id}), 商品({item_id}): {send_message}")
+
+ # 🔔 立即发送消息通知(独立于自动回复功能)
+ try:
+ await self.send_notification(send_user_name, send_user_id, send_message, item_id)
+ except Exception as notify_error:
+ logger.error(f"📱 发送消息通知失败: {self._safe_str(notify_error)}")
+
+
+
+
+ # 【优先处理】检查系统消息和自动发货触发消息(不受人工接入暂停影响)
+ if send_message == '[我已拍下,待付款]':
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】系统消息不处理')
+ return
+ elif send_message == '[你关闭了订单,钱款已原路退返]':
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】系统消息不处理')
+ return
+ elif send_message == '发来一条消息':
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】系统通知消息不处理')
+ return
+ elif send_message == '发来一条新消息':
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】系统通知消息不处理')
+ return
+ elif send_message == '[买家确认收货,交易成功]':
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】交易完成消息不处理')
+ return
+ elif send_message == '快给ta一个评价吧~' or send_message == '快给ta一个评价吧~':
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】评价提醒消息不处理')
+ return
+ elif send_message == '卖家人不错?送Ta闲鱼小红花':
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】小红花提醒消息不处理')
+ return
+ elif send_message == '[你已确认收货,交易成功]':
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】买家确认收货消息不处理')
+ return
+ elif send_message == '[你已发货]':
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】发货确认消息不处理')
+ return
+ # 【重要】检查是否为自动发货触发消息 - 即使在人工接入暂停期间也要处理
+ elif self._is_auto_delivery_trigger(send_message):
+ # 检查当前账号是否是卖家(只有卖家才执行自动发货)
+ is_seller = True
+ try:
+ message_3 = message.get("1", {}).get("3", {})
+ if isinstance(message_3, dict):
+ item_seller_id = message_3.get("itemSellerId", "")
+ if item_seller_id and item_seller_id != self.myid:
+ is_seller = False
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】当前账号不是卖家(卖家: {item_seller_id}),跳过自动发货')
+ except Exception:
+ pass
+
+ # 从消息中提取 itemTitle 并保存到 item_info
+ if item_id and item_id != "未知商品":
+ try:
+ msg_item_title = None
+ message_3 = message.get("1", {}).get("3", {})
+ if isinstance(message_3, dict):
+ msg_item_title = message_3.get("itemTitle", "")
+ if msg_item_title:
+ existing_item = db_manager.get_item_info(self.cookie_id, item_id)
+ if not existing_item:
+ await self.save_item_info_to_db(item_id, msg_item_title, msg_item_title)
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】从消息保存商品信息: {item_id} -> {msg_item_title[:50]}')
+ except Exception as e:
+ logger.debug(f"从消息保存商品信息失败: {self._safe_str(e)}")
+
+ if is_seller:
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】检测到自动发货触发消息,即使在暂停期间也继续处理: {send_message}')
+ # 使用统一的自动发货处理方法
+ await self._handle_auto_delivery(websocket, message, send_user_name, send_user_id,
+ item_id, chat_id, msg_time)
+ return
+ # 【重要】检查是否为"我已小刀,待刀成"卡片消息 - 即使在人工接入暂停期间也要处理
+ elif send_message == '[卡片消息]':
+ # 检查是否为"我已小刀,待刀成"的卡片消息
+ try:
+ # 从消息中提取卡片内容
+ card_title = None
+ if isinstance(message, dict) and "1" in message and isinstance(message["1"], dict):
+ message_1 = message["1"]
+ if "6" in message_1 and isinstance(message_1["6"], dict):
+ message_6 = message_1["6"]
+ if "3" in message_6 and isinstance(message_6["3"], dict):
+ message_6_3 = message_6["3"]
+ if "5" in message_6_3:
+ # 解析JSON内容
+ try:
+ card_content = json.loads(message_6_3["5"])
+ if "dxCard" in card_content and "item" in card_content["dxCard"]:
+ card_item = card_content["dxCard"]["item"]
+ if "main" in card_item and "exContent" in card_item["main"]:
+ ex_content = card_item["main"]["exContent"]
+ card_title = ex_content.get("title", "")
+ except (json.JSONDecodeError, KeyError) as e:
+ logger.debug(f"解析卡片消息失败: {e}")
+
+ # 检查是否为"我已小刀,待刀成"
+ if card_title == "我已小刀,待刀成":
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】【系统】检测到"我已小刀,待刀成",即使在暂停期间也继续处理')
+
+ # 检查商品是否属于当前cookies
+ if item_id and item_id != "未知商品":
+ try:
+ from db_manager import db_manager
+ item_info = db_manager.get_item_info(self.cookie_id, item_id)
+ if not item_info:
+ # 商品不在数据库中,尝试通过API获取并保存
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】商品 {item_id} 不在数据库中,尝试通过API获取...')
+ try:
+ api_item_info = await self.get_item_info(item_id)
+ if api_item_info and 'data' in api_item_info:
+ data = api_item_info['data']
+ item_data = data.get('itemDO', {})
+ share_data = item_data.get('shareData', {})
+ share_info_str = share_data.get('shareInfoJsonString', '')
+ item_title_from_api = item_data.get('title', '')
+ if share_info_str or item_title_from_api:
+ await self.save_item_info_to_db(item_id, share_info_str or item_title_from_api, item_title_from_api or item_id)
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】✅ 通过API获取并保存商品信息: {item_id}')
+ else:
+ logger.warning(f'[{msg_time}] 【{self.cookie_id}】⚠️ API返回的商品信息为空,允许继续免拼发货')
+ else:
+ logger.warning(f'[{msg_time}] 【{self.cookie_id}】⚠️ API获取商品信息失败,允许继续免拼发货')
+ except Exception as api_e:
+ logger.warning(f'[{msg_time}] 【{self.cookie_id}】⚠️ API获取商品信息异常: {self._safe_str(api_e)},允许继续免拼发货')
+ else:
+ logger.debug(f'[{msg_time}] 【{self.cookie_id}】✅ 商品 {item_id} 归属验证通过')
+ except Exception as e:
+ logger.error(f'[{msg_time}] 【{self.cookie_id}】检查商品归属失败: {self._safe_str(e)},跳过免拼发货')
+ return
+
+ # 提取订单ID
+ order_id = self._extract_order_id(message)
+ if order_id:
+ # 延迟2秒后执行免拼发货
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】延迟2秒后执行免拼发货...')
+ await asyncio.sleep(2)
+ # 调用自动免拼发货方法
+ result = await self.auto_freeshipping(order_id, item_id, send_user_id)
+ if result.get('success'):
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】✅ 自动免拼发货成功')
+ else:
+ logger.warning(f'[{msg_time}] 【{self.cookie_id}】❌ 自动免拼发货失败: {result.get("error", "未知错误")}')
+ await self._handle_auto_delivery(websocket, message, send_user_name, send_user_id,
+ item_id, chat_id, msg_time)
+ return
+ else:
+ logger.warning(f'[{msg_time}] 【{self.cookie_id}】❌ 未能提取到订单ID,无法执行免拼发货')
+ return
+ else:
+ logger.info(f'[{msg_time}] 【{self.cookie_id}】收到卡片消息,标题: {card_title or "未知"}')
+ # 如果不是目标卡片消息,继续正常处理流程(会受到暂停影响)
+
+ except Exception as e:
+ logger.error(f"处理卡片消息异常: {self._safe_str(e)}")
+ # 如果处理异常,继续正常处理流程(会受到暂停影响)
+
+ # 自动回复消息
+ if not AUTO_REPLY.get('enabled', True):
+ logger.info(f"[{msg_time}] 【{self.cookie_id}】【系统】自动回复已禁用")
+ return
+
+ # 检查该chat_id是否处于暂停状态
+ if pause_manager.is_chat_paused(chat_id, self.cookie_id):
+ remaining_time = pause_manager.get_remaining_pause_time(chat_id, self.cookie_id)
+ remaining_minutes = remaining_time // 60
+ remaining_seconds = remaining_time % 60
+ logger.info(f"[{msg_time}] 【{self.cookie_id}】【系统】chat_id {chat_id} 自动回复已暂停,剩余时间: {remaining_minutes}分{remaining_seconds}秒")
+ return
+
+ # 构造用户URL
+ user_url = f'https://www.goofish.com/personal?userId={send_user_id}'
+
+ reply = None
+ # 判断是否启用API回复
+ if AUTO_REPLY.get('api', {}).get('enabled', False):
+ reply = await self.get_api_reply(
+ msg_time, user_url, send_user_id, send_user_name,
+ item_id, send_message, chat_id
+ )
+ if not reply:
+ logger.error(f"[{msg_time}] 【API调用失败】用户: {send_user_name} (ID: {send_user_id}), 商品({item_id}): {send_message}")
+
+
+ # 记录回复来源
+ reply_source = 'API' # 默认假设是API回复
+
+ # 如果API回复失败或未启用API,按新的优先级顺序处理
+ if not reply:
+ # 1. 首先尝试关键词匹配(传入商品ID)
+ reply = await self.get_keyword_reply(send_user_name, send_user_id, send_message, item_id)
+ if reply == "EMPTY_REPLY":
+ # 匹配到关键词但回复内容为空,不进行任何回复
+ logger.info(f"[{msg_time}] 【{self.cookie_id}】匹配到空回复关键词,跳过自动回复")
+ return
+ elif reply:
+ reply_source = '关键词' # 标记为关键词回复
+ else:
+ # 2. 关键词匹配失败,如果AI开关打开,尝试AI回复
+ reply = await self.get_ai_reply(send_user_name, send_user_id, send_message, item_id, chat_id)
+ if reply:
+ reply_source = 'AI' # 标记为AI回复
+ else:
+ # 3. 最后使用默认回复
+ reply = await self.get_default_reply(send_user_name, send_user_id, send_message, chat_id, item_id)
+ if reply == "EMPTY_REPLY":
+ # 默认回复内容为空,不进行任何回复
+ logger.info(f"[{msg_time}] 【{self.cookie_id}】默认回复内容为空,跳过自动回复")
+ return
+ reply_source = '默认' # 标记为默认回复
+
+ # 注意:这里只有商品ID,没有标题和详情,根据新的规则不保存到数据库
+ # 商品信息会在其他有完整信息的地方保存(如发货规则匹配时)
+ # 消息通知已在收到消息时立即发送,此处不再重复发送
+
+ # 如果有回复内容,发送消息
+ if reply:
+ # 检查是否是图片发送标记
+ if reply.startswith("__IMAGE_SEND__"):
+ # 提取图片URL(关键词回复不包含卡券ID)
+ image_url = reply.replace("__IMAGE_SEND__", "")
+ # 发送图片消息
+ try:
+ await self.send_image_msg(websocket, chat_id, send_user_id, image_url)
+ # 记录发出的图片消息
+ msg_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+ logger.info(f"[{msg_time}] 【{reply_source}图片发出】用户: {send_user_name} (ID: {send_user_id}), 商品({item_id}): 图片 {image_url}")
+ except Exception as e:
+ # 图片发送失败,发送错误提示
+ logger.error(f"图片发送失败: {self._safe_str(e)}")
+ await self.send_msg(websocket, chat_id, send_user_id, "抱歉,图片发送失败,请稍后重试。")
+ msg_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+ logger.error(f"[{msg_time}] 【{reply_source}图片发送失败】用户: {send_user_name} (ID: {send_user_id}), 商品({item_id})")
+ else:
+ # 普通文本消息
+ await self.send_msg(websocket, chat_id, send_user_id, reply)
+ # 记录发出的消息
+ msg_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+ logger.info(f"[{msg_time}] 【{reply_source}发出】用户: {send_user_name} (ID: {send_user_id}), 商品({item_id}): {reply}")
+ else:
+ msg_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+ logger.info(f"[{msg_time}] 【{self.cookie_id}】【系统】未找到匹配的回复规则,不回复")
+
+ except Exception as e:
+ logger.error(f"处理消息时发生错误: {self._safe_str(e)}")
+ logger.debug(f"原始消息: {message_data}")
+
+ async def _update_online_status(self, is_online: bool):
+ """报告WebSocket在线状态给CookieManager"""
+ try:
+ from cookie_manager import manager as cookie_manager
+ if cookie_manager:
+ cookie_manager.update_online_status(self.cookie_id, is_online)
+ except Exception:
+ pass
+
+ async def main(self):
+ """主程序入口"""
+ try:
+ logger.info(f"【{self.cookie_id}】开始启动XianyuLive主程序...")
+ await self.create_session() # 创建session
+ logger.info(f"【{self.cookie_id}】Session创建完成,开始WebSocket连接循环...")
+
+ # 初始状态设为离线
+ await self._update_online_status(False)
+
+ while True:
+ try:
+ # 检查账号是否启用
+ from cookie_manager import manager as cookie_manager
+ if cookie_manager and not cookie_manager.get_cookie_status(self.cookie_id):
+ logger.info(f"【{self.cookie_id}】账号已禁用,停止主循环")
+ await self._update_online_status(False)
+ break
+
+ headers = WEBSOCKET_HEADERS.copy()
+ headers['Cookie'] = self.cookies_str
+
+ logger.info(f"【{self.cookie_id}】准备建立WebSocket连接到: {self.base_url}")
+ logger.debug(f"【{self.cookie_id}】WebSocket headers: {headers}")
+
+ # 兼容不同版本的websockets库
+ async with await self._create_websocket_connection(headers) as websocket:
+ logger.info(f"【{self.cookie_id}】WebSocket连接建立成功!")
+ self.ws = websocket
+ # WebSocket已连接,报告在线
+ await self._update_online_status(True)
+
+ logger.info(f"【{self.cookie_id}】开始初始化WebSocket连接...")
+ await self.init(websocket)
+ logger.info(f"【{self.cookie_id}】WebSocket初始化完成!")
+
+ # 启动心跳任务
+ logger.info(f"【{self.cookie_id}】启动心跳任务...")
+ self.heartbeat_task = asyncio.create_task(self.heartbeat_loop(websocket))
+
+ # 启动token刷新任务
+ logger.info(f"【{self.cookie_id}】启动token刷新任务...")
+ self.token_refresh_task = asyncio.create_task(self.token_refresh_loop())
+
+ # 启动暂停记录清理任务
+ if not self.cleanup_task:
+ logger.info(f"【{self.cookie_id}】启动暂停记录清理任务...")
+ self.cleanup_task = asyncio.create_task(self.pause_cleanup_loop())
+
+ logger.info(f"【{self.cookie_id}】开始监听WebSocket消息...")
+ logger.info(f"【{self.cookie_id}】WebSocket连接状态正常,等待服务器消息...")
+ logger.info(f"【{self.cookie_id}】准备进入消息循环...")
+
+ async for message in websocket:
+ logger.info(f"【{self.cookie_id}】收到WebSocket消息: {len(message) if message else 0} 字节")
+ try:
+ message_data = json.loads(message)
+
+ # 处理心跳响应
+ if await self.handle_heartbeat_response(message_data):
+ continue
+
+ # 处理其他消息
+ # 使用异步任务处理消息,防止阻塞后续消息接收
+ asyncio.create_task(self.handle_message(message_data, websocket))
+
+ except Exception as e:
+ logger.error(f"处理消息出错: {self._safe_str(e)}")
+ continue
+
+ # async for 正常结束意味着连接已关闭
+ logger.info(f"【{self.cookie_id}】WebSocket连接已关闭")
+ await self._update_online_status(False)
+
+ except Exception as e:
+ error_msg = self._safe_str(e)
+ logger.error(f"WebSocket连接异常: {error_msg}")
+ if self.heartbeat_task:
+ self.heartbeat_task.cancel()
+ if self.token_refresh_task:
+ self.token_refresh_task.cancel()
+ if self.cleanup_task:
+ self.cleanup_task.cancel()
+ # 连接断开,报告离线
+ await self._update_online_status(False)
+ # Token相关错误说明短期内无法恢复,延长重试间隔
+ if "Token" in error_msg:
+ retry_delay = 300
+ else:
+ retry_delay = 60
+ logger.info(f"【{self.cookie_id}】等待 {retry_delay} 秒后重试连接...")
+ await asyncio.sleep(retry_delay)
+ continue
+ finally:
+ # 清理所有任务
+ await self._update_online_status(False)
+ if self.heartbeat_task:
+ self.heartbeat_task.cancel()
+ if self.token_refresh_task:
+ self.token_refresh_task.cancel()
+ if self.cleanup_task:
+ self.cleanup_task.cancel()
+ await self.close_session() # 确保关闭session
+
+ async def get_item_list_info(self, page_number=1, page_size=20, retry_count=0):
+ """获取商品信息,自动处理token失效的情况
+
+ Args:
+ page_number (int): 页码,从1开始
+ page_size (int): 每页数量,默认20
+ retry_count (int): 重试次数,内部使用
+ """
+ if retry_count >= 4: # 最多重试3次
+ logger.error("获取商品信息失败,重试次数过多")
+ return {"error": "获取商品信息失败,重试次数过多"}
+
+ # 确保session已创建
+ if not self.session:
+ await self.create_session()
+
+ params = {
+ 'jsv': '2.7.2',
+ 'appKey': '34839810',
+ 't': str(int(time.time()) * 1000),
+ 'sign': '',
+ 'v': '1.0',
+ 'type': 'originaljson',
+ 'accountSite': 'xianyu',
+ 'dataType': 'json',
+ 'timeout': '20000',
+ 'api': 'mtop.idle.web.xyh.item.list',
+ 'sessionOption': 'AutoLoginOnly',
+ 'spm_cnt': 'a21ybx.im.0.0',
+ 'spm_pre': 'a21ybx.collection.menu.1.272b5141NafCNK'
+ }
+
+ data = {
+ 'needGroupInfo': False,
+ 'pageNumber': page_number,
+ 'pageSize': page_size,
+ 'groupName': '在售',
+ 'groupId': '58877261',
+ 'defaultGroup': True,
+ "userId": self.myid
+ }
+
+ # 始终从最新的cookies中获取_m_h5_tk token(刷新后cookies会被更新)
+ token = trans_cookies(self.cookies_str).get('_m_h5_tk', '').split('_')[0] if trans_cookies(self.cookies_str).get('_m_h5_tk') else ''
+
+ logger.warning(f"准备获取商品列表,token: {token}")
+ if token:
+ logger.debug(f"使用cookies中的_m_h5_tk token: {token}")
+ else:
+ logger.warning("cookies中没有找到_m_h5_tk token")
+
+ # 生成签名
+ data_val = json.dumps(data, separators=(',', ':'))
+ sign = generate_sign(params['t'], token, data_val)
+ params['sign'] = sign
+
+ try:
+ async with self.session.post(
+ 'https://h5api.m.goofish.com/h5/mtop.idle.web.xyh.item.list/1.0/',
+ params=params,
+ data={'data': data_val}
+ ) as response:
+ res_json = await response.json()
+
+ # 检查并更新Cookie
+ if 'set-cookie' in response.headers:
+ new_cookies = {}
+ for cookie in response.headers.getall('set-cookie', []):
+ if '=' in cookie:
+ name, value = cookie.split(';')[0].split('=', 1)
+ new_cookies[name.strip()] = value.strip()
+
+ # 更新cookies
+ if new_cookies:
+ self.cookies.update(new_cookies)
+ # 生成新的cookie字符串
+ self.cookies_str = '; '.join([f"{k}={v}" for k, v in self.cookies.items()])
+ # 更新数据库中的Cookie
+ await self.update_config_cookies()
+ logger.debug("已更新Cookie到数据库")
+
+ logger.info(f"商品信息获取响应: {res_json}")
+
+ # 检查响应是否成功
+ if res_json.get('ret') and res_json['ret'][0] == 'SUCCESS::调用成功':
+ items_data = res_json.get('data', {})
+ # 从cardList中提取商品信息
+ card_list = items_data.get('cardList', [])
+
+ # 解析cardList中的商品信息
+ items_list = []
+ for card in card_list:
+ card_data = card.get('cardData', {})
+ if card_data:
+ # 提取商品基本信息
+ item_info = {
+ 'id': card_data.get('id', ''),
+ 'title': card_data.get('title', ''),
+ 'price': card_data.get('priceInfo', {}).get('price', ''),
+ 'price_text': card_data.get('priceInfo', {}).get('preText', '') + card_data.get('priceInfo', {}).get('price', ''),
+ 'category_id': card_data.get('categoryId', ''),
+ 'auction_type': card_data.get('auctionType', ''),
+ 'item_status': card_data.get('itemStatus', 0),
+ 'detail_url': card_data.get('detailUrl', ''),
+ 'pic_info': card_data.get('picInfo', {}),
+ 'detail_params': card_data.get('detailParams', {}),
+ 'track_params': card_data.get('trackParams', {}),
+ 'item_label_data': card_data.get('itemLabelDataVO', {}),
+ 'card_type': card.get('cardType', 0)
+ }
+ items_list.append(item_info)
+
+ logger.info(f"成功获取到 {len(items_list)} 个商品")
+
+ # 打印商品详细信息到控制台
+ print("\n" + "="*80)
+ print(f"📦 账号 {self.myid} 的商品列表 (第{page_number}页,{len(items_list)} 个商品)")
+ print("="*80)
+
+ for i, item in enumerate(items_list, 1):
+ print(f"\n🔸 商品 {i}:")
+ print(f" 商品ID: {item.get('id', 'N/A')}")
+ print(f" 商品标题: {item.get('title', 'N/A')}")
+ print(f" 价格: {item.get('price_text', 'N/A')}")
+ print(f" 分类ID: {item.get('category_id', 'N/A')}")
+ print(f" 商品状态: {item.get('item_status', 'N/A')}")
+ print(f" 拍卖类型: {item.get('auction_type', 'N/A')}")
+ print(f" 详情链接: {item.get('detail_url', 'N/A')}")
+ if item.get('pic_info'):
+ pic_info = item['pic_info']
+ print(f" 图片信息: {pic_info.get('width', 'N/A')}x{pic_info.get('height', 'N/A')}")
+ print(f" 图片链接: {pic_info.get('picUrl', 'N/A')}")
+ print(f" 完整信息: {json.dumps(item, ensure_ascii=False, indent=2)}")
+
+ print("\n" + "="*80)
+ print("✅ 商品列表获取完成")
+ print("="*80)
+
+ # 自动保存商品信息到数据库
+ if items_list:
+ saved_count = await self.save_items_list_to_db(items_list)
+ logger.info(f"已将 {saved_count} 个商品信息保存到数据库")
+
+ return {
+ "success": True,
+ "page_number": page_number,
+ "page_size": page_size,
+ "current_count": len(items_list),
+ "items": items_list,
+ "saved_count": saved_count if items_list else 0,
+ "raw_data": items_data # 保留原始数据以备调试
+ }
+ else:
+ # 检查是否是token失效
+ error_msg = res_json.get('ret', [''])[0] if res_json.get('ret') else ''
+ if 'FAIL_SYS_TOKEN_EXOIRED' in error_msg or 'token' in error_msg.lower():
+ logger.warning(f"Token失效,准备重试: {error_msg}")
+ await asyncio.sleep(0.5)
+ return await self.get_item_list_info(page_number, page_size, retry_count + 1)
+ else:
+ logger.error(f"获取商品信息失败: {res_json}")
+ return {"error": f"获取商品信息失败: {error_msg}"}
+
+ except Exception as e:
+ logger.error(f"商品信息API请求异常: {self._safe_str(e)}")
+ await asyncio.sleep(0.5)
+ return await self.get_item_list_info(page_number, page_size, retry_count + 1)
+
+ async def get_all_items(self, page_size=20, max_pages=None):
+ """获取所有商品信息(自动分页)
+
+ Args:
+ page_size (int): 每页数量,默认20
+ max_pages (int): 最大页数限制,None表示无限制
+
+ Returns:
+ dict: 包含所有商品信息的字典
+ """
+ all_items = []
+ page_number = 1
+ total_saved = 0
+
+ logger.info(f"开始获取所有商品信息,每页{page_size}条")
+
+ while True:
+ if max_pages and page_number > max_pages:
+ logger.info(f"达到最大页数限制 {max_pages},停止获取")
+ break
+
+ logger.info(f"正在获取第 {page_number} 页...")
+ result = await self.get_item_list_info(page_number, page_size)
+
+ if not result.get("success"):
+ logger.error(f"获取第 {page_number} 页失败: {result}")
+ break
+
+ current_items = result.get("items", [])
+ if not current_items:
+ logger.info(f"第 {page_number} 页没有数据,获取完成")
+ break
+
+ all_items.extend(current_items)
+ total_saved += result.get("saved_count", 0)
+
+ logger.info(f"第 {page_number} 页获取到 {len(current_items)} 个商品")
+
+ # 如果当前页商品数量少于页面大小,说明已经是最后一页
+ if len(current_items) < page_size:
+ logger.info(f"第 {page_number} 页商品数量({len(current_items)})少于页面大小({page_size}),获取完成")
+ break
+
+ page_number += 1
+
+ # 添加延迟避免请求过快
+ await asyncio.sleep(1)
+
+ logger.info(f"所有商品获取完成,共 {len(all_items)} 个商品,保存了 {total_saved} 个")
+
+ return {
+ "success": True,
+ "total_pages": page_number,
+ "total_count": len(all_items),
+ "total_saved": total_saved,
+ "items": all_items
+ }
+
+ async def send_image_msg(self, ws, cid, toid, image_url, width=800, height=600, card_id=None):
+ """发送图片消息"""
+ try:
+ # 检查图片URL是否需要上传到CDN
+ original_url = image_url
+
+ if self._is_cdn_url(image_url):
+ # 已经是CDN链接,直接使用
+ logger.info(f"【{self.cookie_id}】使用已有的CDN图片链接: {image_url}")
+ elif image_url.startswith('/static/uploads/') or image_url.startswith('static/uploads/'):
+ # 本地图片,需要上传到闲鱼CDN
+ local_image_path = image_url.replace('/static/uploads/', 'static/uploads/')
+ if os.path.exists(local_image_path):
+ logger.info(f"【{self.cookie_id}】准备上传本地图片到闲鱼CDN: {local_image_path}")
+
+ # 使用图片上传器上传到闲鱼CDN
+ from utils.image_uploader import ImageUploader
+ uploader = ImageUploader(self.cookies_str)
+
+ async with uploader:
+ cdn_url = await uploader.upload_image(local_image_path)
+ if cdn_url:
+ logger.info(f"【{self.cookie_id}】图片上传成功,CDN URL: {cdn_url}")
+ image_url = cdn_url
+
+ # 如果是卡券图片,更新数据库中的图片URL
+ if card_id is not None:
+ await self._update_card_image_url(card_id, cdn_url)
+
+ # 获取实际图片尺寸
+ from utils.image_utils import image_manager
+ try:
+ actual_width, actual_height = image_manager.get_image_size(local_image_path)
+ if actual_width and actual_height:
+ width, height = actual_width, actual_height
+ logger.info(f"【{self.cookie_id}】获取到实际图片尺寸: {width}x{height}")
+ except Exception as e:
+ logger.warning(f"【{self.cookie_id}】获取图片尺寸失败,使用默认尺寸: {e}")
+ else:
+ logger.error(f"【{self.cookie_id}】图片上传失败: {local_image_path}")
+ raise Exception(f"图片上传失败: {local_image_path}")
+ else:
+ logger.error(f"【{self.cookie_id}】本地图片文件不存在: {local_image_path}")
+ raise Exception(f"本地图片文件不存在: {local_image_path}")
+ else:
+ logger.warning(f"【{self.cookie_id}】未知的图片URL格式: {image_url}")
+
+ # 记录详细的图片信息
+ logger.info(f"【{self.cookie_id}】准备发送图片消息:")
+ logger.info(f" - 原始URL: {original_url}")
+ logger.info(f" - CDN URL: {image_url}")
+ logger.info(f" - 图片尺寸: {width}x{height}")
+ logger.info(f" - 聊天ID: {cid}")
+ logger.info(f" - 接收者ID: {toid}")
+
+ # 构造图片消息内容 - 使用正确的闲鱼格式
+ image_content = {
+ "contentType": 2, # 图片消息类型
+ "image": {
+ "pics": [
+ {
+ "height": int(height),
+ "type": 0,
+ "url": image_url,
+ "width": int(width)
+ }
+ ]
+ }
+ }
+
+ # Base64编码
+ content_json = json.dumps(image_content, ensure_ascii=False)
+ content_base64 = str(base64.b64encode(content_json.encode('utf-8')), 'utf-8')
+
+ logger.info(f"【{self.cookie_id}】图片内容JSON: {content_json}")
+ logger.info(f"【{self.cookie_id}】Base64编码长度: {len(content_base64)}")
+
+ # 构造WebSocket消息(完全参考send_msg的格式)
+ msg = {
+ "lwp": "/r/MessageSend/sendByReceiverScope",
+ "headers": {
+ "mid": generate_mid()
+ },
+ "body": [
+ {
+ "uuid": generate_uuid(),
+ "cid": f"{cid}@goofish",
+ "conversationType": 1,
+ "content": {
+ "contentType": 101,
+ "custom": {
+ "type": 1,
+ "data": content_base64
+ }
+ },
+ "redPointPolicy": 0,
+ "extension": {
+ "extJson": "{}"
+ },
+ "ctx": {
+ "appVersion": "1.0",
+ "platform": "web"
+ },
+ "mtags": {},
+ "msgReadStatusSetting": 1
+ },
+ {
+ "actualReceivers": [
+ f"{toid}@goofish",
+ f"{self.myid}@goofish"
+ ]
+ }
+ ]
+ }
+
+ await ws.send(json.dumps(msg))
+ logger.info(f"【{self.cookie_id}】图片消息发送成功: {image_url}")
+
+ except Exception as e:
+ logger.error(f"【{self.cookie_id}】发送图片消息失败: {self._safe_str(e)}")
+ raise
+
+ async def send_image_from_file(self, ws, cid, toid, image_path):
+ """从本地文件发送图片"""
+ try:
+ # 上传图片到闲鱼CDN
+ logger.info(f"【{self.cookie_id}】开始上传图片: {image_path}")
+
+ from utils.image_uploader import ImageUploader
+ uploader = ImageUploader(self.cookies_str)
+
+ async with uploader:
+ image_url = await uploader.upload_image(image_path)
+
+ if image_url:
+ # 获取图片信息
+ from utils.image_utils import image_manager
+ try:
+ from PIL import Image
+ with Image.open(image_path) as img:
+ width, height = img.size
+ except Exception as e:
+ logger.warning(f"无法获取图片尺寸,使用默认值: {e}")
+ width, height = 800, 600
+
+ # 发送图片消息
+ await self.send_image_msg(ws, cid, toid, image_url, width, height)
+ logger.info(f"【{self.cookie_id}】图片发送完成: {image_path} -> {image_url}")
+ return True
+ else:
+ logger.error(f"【{self.cookie_id}】图片上传失败: {image_path}")
+ return False
+
+ except Exception as e:
+ logger.error(f"【{self.cookie_id}】从文件发送图片失败: {self._safe_str(e)}")
+ return False
+
+if __name__ == '__main__':
+ cookies_str = os.getenv('COOKIES_STR')
+ xianyuLive = XianyuLive(cookies_str)
+ asyncio.run(xianyuLive.main())
diff --git a/ai_reply_engine.py b/ai_reply_engine.py
new file mode 100644
index 0000000..d8e8201
--- /dev/null
+++ b/ai_reply_engine.py
@@ -0,0 +1,370 @@
+"""
+AI回复引擎模块
+集成XianyuAutoAgent的AI回复功能到现有项目中
+"""
+
+import os
+import json
+import time
+import hashlib
+import sqlite3
+from typing import List, Dict, Optional
+from loguru import logger
+from openai import OpenAI
+from db_manager import db_manager
+
+
+class AIReplyEngine:
+ """AI回复引擎"""
+
+ def __init__(self):
+ self.clients = {} # 存储不同账号的OpenAI客户端
+ self.agents = {} # 存储不同账号的Agent实例
+ self._cache = {} # AI回复缓存 {cache_key: (reply, expiry)}
+ self._intent_cache = {} # 意图缓存 {cache_key: (intent, expiry)}
+ self._cache_ttl = 3600 # 缓存有效期1小时
+ self._init_default_prompts()
+
+ def _make_cache_key(self, cookie_id: str, chat_id: str, message: str) -> str:
+ """生成缓存键"""
+ raw = f"{cookie_id}|{chat_id}|{message}"
+ return hashlib.md5(raw.encode()).hexdigest()
+
+ def _get_cached_reply(self, cookie_id: str, chat_id: str, message: str) -> Optional[str]:
+ """获取缓存的AI回复"""
+ key = self._make_cache_key(cookie_id, chat_id, message)
+ cached = self._cache.get(key)
+ if cached and time.time() < cached[1]:
+ logger.info(f"命中AI回复缓存 (账号: {cookie_id})")
+ return cached[0]
+ if cached:
+ del self._cache[key]
+ return None
+
+ def _set_cached_reply(self, cookie_id: str, chat_id: str, message: str, reply: str):
+ """设置AI回复缓存"""
+ key = self._make_cache_key(cookie_id, chat_id, message)
+ self._cache[key] = (reply, time.time() + self._cache_ttl)
+
+ def _get_cached_intent(self, cookie_id: str, message: str) -> Optional[str]:
+ """获取缓存的意图"""
+ key = self._make_cache_key(cookie_id, "", message)
+ cached = self._intent_cache.get(key)
+ if cached and time.time() < cached[1]:
+ return cached[0]
+ if cached:
+ del self._intent_cache[key]
+ return None
+
+ def _set_cached_intent(self, cookie_id: str, message: str, intent: str):
+ """设置意图缓存"""
+ key = self._make_cache_key(cookie_id, "", message)
+ self._intent_cache[key] = (intent, time.time() + self._cache_ttl)
+
+ def _init_default_prompts(self):
+ """初始化默认提示词"""
+ self.default_prompts = {
+ 'classify': '''你是一个意图分类专家,需要判断用户消息的意图类型。
+请根据用户消息内容,返回以下意图之一:
+- price: 价格相关(议价、优惠、降价等)
+- tech: 技术相关(产品参数、使用方法、故障等)
+- refund: 退款相关(申请退款、退货、投诉等)
+- default: 其他一般咨询
+
+只返回意图类型,不要其他内容。''',
+
+ 'price': '''你是一位经验丰富的销售专家,擅长议价。
+语言要求:简短直接,每句≤10字,总字数≤40字。
+议价策略:
+1. 根据议价次数递减优惠:第1次小幅优惠,第2次中等优惠,第3次最大优惠
+2. 接近最大议价轮数时要坚持底线,强调商品价值
+3. 优惠不能超过设定的最大百分比和金额
+4. 语气要友好但坚定,突出商品优势
+注意:结合商品信息、对话历史和议价设置,给出合适的回复。''',
+
+ 'tech': '''你是一位技术专家,专业解答产品相关问题。
+语言要求:简短专业,每句≤10字,总字数≤40字。
+回答重点:产品功能、使用方法、注意事项。
+注意:基于商品信息回答,避免过度承诺。''',
+
+ 'refund': '''你是一位售后客服,处理用户的退款退货请求。
+语言要求:礼貌耐心,语气温和,每句≤15字,总字数≤60字。
+注意:请严格遵循【退款策略】指示。''',
+
+ 'default': '''你是一位资深电商卖家,提供优质客服。
+语言要求:简短友好,每句≤10字,总字数≤40字。
+回答重点:商品介绍、物流、售后等常见问题。
+注意:结合商品信息,给出实用建议。'''
+ }
+
+ def get_client(self, cookie_id: str) -> Optional[OpenAI]:
+ """获取指定账号的OpenAI客户端"""
+ if cookie_id not in self.clients:
+ settings = db_manager.get_ai_reply_settings(cookie_id)
+ if not settings['ai_enabled']:
+ logger.warning(f"AI回复未启用 (账号: {cookie_id})")
+ return None
+ if not settings['api_key']:
+ logger.warning(f"AI回复的 API Key 未配置 (账号: {cookie_id})")
+ return None
+
+ try:
+ self.clients[cookie_id] = OpenAI(
+ api_key=settings['api_key'],
+ base_url=settings['base_url'],
+ timeout=60
+ )
+ logger.info(f"为账号 {cookie_id} 创建OpenAI客户端")
+ except Exception as e:
+ logger.error(f"创建OpenAI客户端失败 {cookie_id}: {e}")
+ return None
+
+ return self.clients[cookie_id]
+
+ def is_ai_enabled(self, cookie_id: str) -> bool:
+ """检查指定账号是否启用AI回复"""
+ settings = db_manager.get_ai_reply_settings(cookie_id)
+ return settings['ai_enabled']
+
+ def detect_intent(self, message: str, cookie_id: str) -> str:
+ """检测用户消息意图(带缓存)"""
+ cached = self._get_cached_intent(cookie_id, message)
+ if cached:
+ return cached
+
+ client = self.get_client(cookie_id)
+ if not client:
+ return 'default'
+
+ try:
+ settings = db_manager.get_ai_reply_settings(cookie_id)
+ custom_prompts = json.loads(settings['custom_prompts']) if settings['custom_prompts'] else {}
+ classify_prompt = custom_prompts.get('classify', self.default_prompts['classify'])
+
+ response = client.chat.completions.create(
+ model=settings['model_name'],
+ messages=[
+ {"role": "system", "content": classify_prompt},
+ {"role": "user", "content": message}
+ ],
+ max_tokens=100,
+ temperature=0.1
+ )
+
+ raw_content = response.choices[0].message.content
+ intent = raw_content.strip().lower() if raw_content else 'default'
+ if intent not in ['price', 'tech', 'refund', 'default']:
+ intent = 'default'
+
+ self._set_cached_intent(cookie_id, message, intent)
+ return intent
+
+ except Exception as e:
+ logger.error(f"意图检测失败 {cookie_id}: {e}")
+ return 'default'
+
+ def generate_reply(self, message: str, item_info: dict, chat_id: str,
+ cookie_id: str, user_id: str, item_id: str) -> Optional[str]:
+ """生成AI回复(带缓存,带重试)"""
+ if not self.is_ai_enabled(cookie_id):
+ return None
+
+ # 检查缓存
+ cached_reply = self._get_cached_reply(cookie_id, chat_id, message)
+ if cached_reply:
+ return cached_reply
+
+ client = self.get_client(cookie_id)
+ if not client:
+ logger.warning(f"生成AI回复失败: 无法获取 OpenAI 客户端 (账号: {cookie_id})")
+ return None
+
+ # 获取设置(重试参数也放在 settings 里)
+ try:
+ settings = db_manager.get_ai_reply_settings(cookie_id)
+ except Exception as e:
+ logger.error(f"获取AI回复设置失败 {cookie_id}: {e}")
+ return None
+
+ # 读取重试配置
+ max_retry = 3
+ retry_interval = 5
+
+ # 检测意图
+ intent = self.detect_intent(message, cookie_id)
+ logger.info(f"检测到意图: {intent} (账号: {cookie_id})")
+
+ # 获取对话历史和议价信息(在重试循环外,只做一次)
+ context = self.get_conversation_context(chat_id, cookie_id)
+ bargain_count = self.get_bargain_count(chat_id, cookie_id)
+ refund_policy = settings.get('refund_policy', 'allow')
+
+ # 检查议价轮数限制
+ if intent == "price":
+ max_bargain_rounds = settings.get('max_bargain_rounds', 3)
+ if bargain_count >= max_bargain_rounds:
+ logger.info(f"议价次数已达上限 ({bargain_count}/{max_bargain_rounds}),拒绝继续议价")
+ refuse_reply = "抱歉,这个价格已经是最优惠的了,不能再便宜了哦!"
+ self.save_conversation(chat_id, cookie_id, user_id, item_id, "user", message, intent)
+ self.save_conversation(chat_id, cookie_id, user_id, item_id, "assistant", refuse_reply, intent)
+ return refuse_reply
+
+ # 构建提示词相关(在重试循环外,只做一次)
+ custom_prompts = json.loads(settings['custom_prompts']) if settings.get('custom_prompts') else {}
+ system_prompt = custom_prompts.get(intent, self.default_prompts[intent])
+
+ item_desc = f"商品标题: {item_info.get('title', '未知')}\n"
+ item_desc += f"商品价格: {item_info.get('price', '未知')}元\n"
+ item_desc += f"商品描述: {item_info.get('desc', '无')}"
+
+ context_str = "\n".join([f"{msg['role']}: {msg['content']}" for msg in context[-10:]])
+ max_bargain_rounds = settings.get('max_bargain_rounds', 3)
+ max_discount_percent = settings.get('max_discount_percent', 10)
+ max_discount_amount = settings.get('max_discount_amount', 100)
+
+ refund_instruction = "" if intent != "refund" else (
+ "【退款策略】该商品支持退款,请引导用户通过平台申请退款,告知流程和预计时间。"
+ if refund_policy == "allow"
+ else "【退款策略】该商品不支持退款,请礼貌说明原因(虚拟商品/已发货/特殊商品等),并表示歉意。"
+ )
+
+ user_prompt = f"""商品信息:
+{item_desc}
+
+对话历史:
+{context_str}
+
+议价设置:
+- 当前议价次数:{bargain_count}
+- 最大议价轮数:{max_bargain_rounds}
+- 最大优惠百分比:{max_discount_percent}%
+- 最大优惠金额:{max_discount_amount}元
+
+{refund_instruction}
+
+用户消息:{message}
+
+请根据以上信息生成回复:"""
+
+ # === 带重试的 API 调用 ===
+ last_error = None
+ for attempt in range(max_retry):
+ try:
+ response = client.chat.completions.create(
+ model=settings['model_name'],
+ messages=[
+ {"role": "system", "content": system_prompt},
+ {"role": "user", "content": user_prompt}
+ ],
+ max_tokens=2048,
+ temperature=0.7
+ )
+
+ raw_reply = response.choices[0].message.content
+ if not raw_reply:
+ raise ValueError("AI 返回内容为空")
+ reply = raw_reply.strip()
+
+ # 保存对话记录
+ self.save_conversation(chat_id, cookie_id, user_id, item_id, "user", message, intent)
+ self.save_conversation(chat_id, cookie_id, user_id, item_id, "assistant", reply, intent)
+
+ # 更新议价次数
+ if intent == "price":
+ self.increment_bargain_count(chat_id, cookie_id)
+
+ # 写入缓存
+ self._set_cached_reply(cookie_id, chat_id, message, reply)
+
+ logger.info(f"AI回复生成成功 (账号: {cookie_id}): {reply}")
+ return reply
+
+ except Exception as e:
+ last_error = e
+ if attempt < max_retry - 1:
+ logger.warning(f"AI回复生成失败 (第{attempt + 1}/{max_retry}次重试) {cookie_id}: {e}")
+ time.sleep(retry_interval)
+ else:
+ logger.error(f"AI回复生成失败 (已重试{max_retry}次) {cookie_id}: {e}")
+
+ return None
+
+ def get_conversation_context(self, chat_id: str, cookie_id: str, limit: int = 20) -> List[Dict]:
+ """获取对话上下文"""
+ try:
+ with db_manager.lock:
+ cursor = db_manager.conn.cursor()
+ cursor.execute('''
+ SELECT role, content FROM ai_conversations
+ WHERE chat_id = ? AND cookie_id = ?
+ ORDER BY created_at DESC LIMIT ?
+ ''', (chat_id, cookie_id, limit))
+
+ results = cursor.fetchall()
+ # 反转顺序,使其按时间正序
+ context = [{"role": row[0], "content": row[1]} for row in reversed(results)]
+ return context
+ except Exception as e:
+ logger.error(f"获取对话上下文失败: {e}")
+ return []
+
+ def save_conversation(self, chat_id: str, cookie_id: str, user_id: str,
+ item_id: str, role: str, content: str, intent: str = None):
+ """保存对话记录"""
+ try:
+ with db_manager.lock:
+ cursor = db_manager.conn.cursor()
+ cursor.execute('''
+ INSERT INTO ai_conversations
+ (cookie_id, chat_id, user_id, item_id, role, content, intent)
+ VALUES (?, ?, ?, ?, ?, ?, ?)
+ ''', (cookie_id, chat_id, user_id, item_id, role, content, intent))
+ db_manager.conn.commit()
+ except Exception as e:
+ logger.error(f"保存对话记录失败: {e}")
+
+ def get_bargain_count(self, chat_id: str, cookie_id: str) -> int:
+ """获取议价次数"""
+ try:
+ with db_manager.lock:
+ cursor = db_manager.conn.cursor()
+ cursor.execute('''
+ SELECT COUNT(*) FROM ai_conversations
+ WHERE chat_id = ? AND cookie_id = ? AND intent = 'price' AND role = 'user'
+ ''', (chat_id, cookie_id))
+
+ result = cursor.fetchone()
+ return result[0] if result else 0
+ except Exception as e:
+ logger.error(f"获取议价次数失败: {e}")
+ return 0
+
+ def increment_bargain_count(self, chat_id: str, cookie_id: str):
+ """增加议价次数(通过保存记录自动增加)"""
+ # 议价次数通过查询price意图的用户消息数量来计算,无需单独操作
+ pass
+
+ def clear_cache(self, cookie_id: str = None):
+ """清理AI回复和意图缓存"""
+ if cookie_id:
+ prefix = hashlib.md5(f"{cookie_id}|".encode()).hexdigest()[:8]
+ self._cache = {k: v for k, v in self._cache.items() if not k.startswith(prefix)}
+ self._intent_cache = {k: v for k, v in self._intent_cache.items() if not k.startswith(prefix)}
+ logger.info(f"清理账号 {cookie_id} 的AI回复缓存")
+ else:
+ self._cache.clear()
+ self._intent_cache.clear()
+ logger.info("清理所有AI回复缓存")
+
+ def clear_client_cache(self, cookie_id: str = None):
+ """清理客户端缓存"""
+ if cookie_id:
+ self.clients.pop(cookie_id, None)
+ logger.info(f"清理账号 {cookie_id} 的客户端缓存")
+ else:
+ self.clients.clear()
+ logger.info("清理所有客户端缓存")
+
+
+# 全局AI回复引擎实例
+ai_reply_engine = AIReplyEngine()
diff --git a/config.py b/config.py
new file mode 100644
index 0000000..9aa5af4
--- /dev/null
+++ b/config.py
@@ -0,0 +1,122 @@
+import os
+import yaml
+from typing import Dict, Any
+
+class Config:
+ """配置管理类
+
+ 用于加载和管理全局配置文件(global_config.yml)。
+ 支持配置的读取、修改和保存。
+ """
+
+ _instance = None
+ _config = {}
+
+ def __new__(cls):
+ if cls._instance is None:
+ cls._instance = super(Config, cls).__new__(cls)
+ cls._instance._load_config()
+ return cls._instance
+
+ def _load_config(self):
+ """加载配置文件
+
+ 从global_config.yml文件中加载配置信息。
+ 如果文件不存在则抛出FileNotFoundError异常。
+ """
+ config_path = os.path.join(os.path.dirname(__file__), 'global_config.yml')
+ if not os.path.exists(config_path):
+ raise FileNotFoundError(f"配置文件不存在: {config_path}")
+
+ with open(config_path, 'r', encoding='utf-8') as f:
+ self._config = yaml.safe_load(f)
+
+ def get(self, key: str, default: Any = None) -> Any:
+ """获取配置项
+
+ Args:
+ key: 配置项的键,支持点号分隔的多级键
+ default: 当配置项不存在时返回的默认值
+
+ Returns:
+ 配置项的值或默认值
+ """
+ keys = key.split('.')
+ value = self._config
+ for k in keys:
+ if isinstance(value, dict):
+ value = value.get(k)
+ else:
+ return default
+ if value is None:
+ return default
+ return value
+
+ def set(self, key: str, value: Any) -> None:
+ """设置配置项
+
+ Args:
+ key: 配置项的键,支持点号分隔的多级键
+ value: 要设置的值
+ """
+ keys = key.split('.')
+ config = self._config
+ for k in keys[:-1]:
+ if k not in config:
+ config[k] = {}
+ config = config[k]
+ config[keys[-1]] = value
+
+ def save(self) -> None:
+ """保存配置到文件
+
+ 将当前配置保存回global_config.yml文件
+ """
+ config_path = os.path.join(os.path.dirname(__file__), 'global_config.yml')
+ with open(config_path, 'w', encoding='utf-8') as f:
+ yaml.safe_dump(self._config, f, allow_unicode=True, default_flow_style=False)
+
+ @property
+ def config(self) -> Dict[str, Any]:
+ """获取完整配置
+
+ Returns:
+ 包含所有配置项的字典
+ """
+ return self._config
+
+# 创建全局配置实例
+config = Config()
+
+# 导出常用配置项
+COOKIES_STR = config.get('COOKIES.value', '')
+COOKIES_LAST_UPDATE = config.get('COOKIES.last_update_time', '')
+WEBSOCKET_URL = config.get('WEBSOCKET_URL', 'wss://wss-goofish.dingtalk.com/')
+HEARTBEAT_INTERVAL = config.get('HEARTBEAT_INTERVAL', 15)
+HEARTBEAT_TIMEOUT = config.get('HEARTBEAT_TIMEOUT', 5)
+TOKEN_REFRESH_INTERVAL = config.get('TOKEN_REFRESH_INTERVAL', 36000)
+TOKEN_RETRY_INTERVAL = config.get('TOKEN_RETRY_INTERVAL', 1800)
+COOKIE_KEEPALIVE_INTERVAL = config.get('COOKIE_KEEPALIVE_INTERVAL', 7200)
+MESSAGE_EXPIRE_TIME = config.get('MESSAGE_EXPIRE_TIME', 300000)
+API_ENDPOINTS = config.get('API_ENDPOINTS', {})
+DEFAULT_HEADERS = config.get('DEFAULT_HEADERS', {})
+WEBSOCKET_HEADERS = config.get('WEBSOCKET_HEADERS', {})
+APP_CONFIG = config.get('APP_CONFIG', {})
+AUTO_REPLY = config.get('AUTO_REPLY', {
+ 'enabled': True,
+ 'default_message': '亲爱的"{send_user_name}" 老板你好!所有宝贝都可以拍,秒发货的哈~不满意的话可以直接申请退款哈~',
+ 'api': {
+ 'enabled': False,
+ 'url': 'http://localhost:8080/xianyu/reply',
+ 'timeout': 10
+ }
+})
+MANUAL_MODE = config.get('MANUAL_MODE', {})
+LOG_CONFIG = config.get('LOG_CONFIG', {})
+_cookies_raw = config.get('COOKIES', [])
+if isinstance(_cookies_raw, list):
+ COOKIES_LIST = _cookies_raw
+else:
+ # 兼容旧格式,仅有 value 字段
+ val = _cookies_raw.get('value') if isinstance(_cookies_raw, dict) else None
+ COOKIES_LIST = [{'id': 'default', 'value': val}] if val else []
\ No newline at end of file
diff --git a/cookie_manager.py b/cookie_manager.py
new file mode 100644
index 0000000..e815f7d
--- /dev/null
+++ b/cookie_manager.py
@@ -0,0 +1,325 @@
+from __future__ import annotations
+import asyncio
+from typing import Dict, List, Tuple, Optional
+from loguru import logger
+from db_manager import db_manager
+
+__all__ = ["CookieManager", "manager"]
+
+
+class CookieManager:
+ """管理多账号 Cookie 及其对应的 XianyuLive 任务和关键字"""
+
+ def __init__(self, loop: asyncio.AbstractEventLoop):
+ self.loop = loop
+ self.cookies: Dict[str, str] = {}
+ self.tasks: Dict[str, asyncio.Task] = {}
+ self.keywords: Dict[str, List[Tuple[str, str]]] = {}
+ self.cookie_status: Dict[str, bool] = {} # 账号启用状态
+ self.auto_confirm_settings: Dict[str, bool] = {} # 自动确认发货设置
+ self.online_status: Dict[str, bool] = {} # WebSocket 真实在线状态
+ self.xianyu_instances: Dict[str, object] = {} # XianyuLive 实例缓存
+ self._load_from_db()
+
+ def _load_from_db(self):
+ """从数据库加载所有Cookie、关键字和状态"""
+ try:
+ # 加载所有Cookie
+ self.cookies = db_manager.get_all_cookies()
+ # 加载所有关键字
+ self.keywords = db_manager.get_all_keywords()
+ # 加载所有Cookie状态(默认启用)
+ self.cookie_status = db_manager.get_all_cookie_status()
+ # 加载所有auto_confirm设置
+ self.auto_confirm_settings = {}
+ for cookie_id in self.cookies.keys():
+ # 为没有状态记录的Cookie设置默认启用状态
+ if cookie_id not in self.cookie_status:
+ self.cookie_status[cookie_id] = True
+ # 加载auto_confirm设置
+ self.auto_confirm_settings[cookie_id] = db_manager.get_auto_confirm(cookie_id)
+ # 初始化在线状态为False
+ self.online_status[cookie_id] = False
+ logger.info(f"从数据库加载了 {len(self.cookies)} 个Cookie、{len(self.keywords)} 组关键字、{len(self.cookie_status)} 个状态记录和 {len(self.auto_confirm_settings)} 个自动确认设置")
+ except Exception as e:
+ logger.error(f"从数据库加载数据失败: {e}")
+
+ def reload_from_db(self):
+ """重新从数据库加载所有数据(用于备份导入后刷新)"""
+ logger.info("重新从数据库加载数据...")
+ old_cookies_count = len(self.cookies)
+ old_keywords_count = len(self.keywords)
+
+ # 重新加载数据
+ self._load_from_db()
+
+ new_cookies_count = len(self.cookies)
+ new_keywords_count = len(self.keywords)
+
+ logger.info(f"数据重新加载完成: Cookie {old_cookies_count} -> {new_cookies_count}, 关键字组 {old_keywords_count} -> {new_keywords_count}")
+ return True
+
+ # ------------------------ 内部协程 ------------------------
+ async def _run_xianyu(self, cookie_id: str, cookie_value: str, user_id: int = None):
+ """在事件循环中启动 XianyuLive.main"""
+ logger.info(f"【{cookie_id}】_run_xianyu方法开始执行...")
+
+ try:
+ logger.info(f"【{cookie_id}】正在导入XianyuLive...")
+ from XianyuAutoAsync import XianyuLive # 延迟导入,避免循环
+ logger.info(f"【{cookie_id}】XianyuLive导入成功")
+
+ logger.info(f"【{cookie_id}】开始创建XianyuLive实例...")
+ logger.info(f"【{cookie_id}】Cookie值长度: {len(cookie_value)}")
+ live = XianyuLive(cookie_value, cookie_id=cookie_id, user_id=user_id)
+ self.xianyu_instances[cookie_id] = live
+ logger.info(f"【{cookie_id}】XianyuLive实例创建成功,开始调用main()...")
+ await live.main()
+ except asyncio.CancelledError:
+ logger.info(f"XianyuLive 任务已取消: {cookie_id}")
+ except Exception as e:
+ logger.error(f"XianyuLive 任务异常({cookie_id}): {e}")
+ import traceback
+ logger.error(f"详细错误信息: {traceback.format_exc()}")
+
+ async def _add_cookie_async(self, cookie_id: str, cookie_value: str, user_id: int = None):
+ if cookie_id in self.tasks:
+ raise ValueError("Cookie ID already exists")
+ self.cookies[cookie_id] = cookie_value
+
+ # 数据库操作放到线程池,避免阻塞事件循环导致其他账号心跳超时离线
+ await asyncio.to_thread(db_manager.save_cookie, cookie_id, cookie_value, user_id)
+
+ # 获取实际保存的user_id(如果没有指定,数据库会返回实际的user_id)
+ actual_user_id = user_id
+ if actual_user_id is None:
+ cookie_info = await asyncio.to_thread(db_manager.get_cookie_details, cookie_id)
+ if cookie_info:
+ actual_user_id = cookie_info.get('user_id')
+
+ task = self.loop.create_task(self._run_xianyu(cookie_id, cookie_value, actual_user_id))
+ self.tasks[cookie_id] = task
+ logger.info(f"已启动账号任务: {cookie_id} (用户ID: {actual_user_id})")
+
+ async def _remove_cookie_async(self, cookie_id: str):
+ task = self.tasks.pop(cookie_id, None)
+ if task:
+ task.cancel()
+ self.cookies.pop(cookie_id, None)
+ self.keywords.pop(cookie_id, None)
+ self.xianyu_instances.pop(cookie_id, None)
+ # 数据库操作放到线程池,避免阻塞事件循环
+ await asyncio.to_thread(db_manager.delete_cookie, cookie_id)
+ logger.info(f"已移除账号: {cookie_id}")
+
+ # ------------------------ 对外线程安全接口 ------------------------
+ def add_cookie(self, cookie_id: str, cookie_value: str, kw_list: Optional[List[Tuple[str, str]]] = None, user_id: int = None):
+ """线程安全新增 Cookie 并启动任务"""
+ if kw_list is not None:
+ self.keywords[cookie_id] = kw_list
+ else:
+ self.keywords.setdefault(cookie_id, [])
+ try:
+ current_loop = asyncio.get_running_loop()
+ except RuntimeError:
+ current_loop = None
+
+ if current_loop and current_loop == self.loop:
+ # 同一事件循环中,直接调度
+ return self.loop.create_task(self._add_cookie_async(cookie_id, cookie_value, user_id))
+ else:
+ fut = asyncio.run_coroutine_threadsafe(self._add_cookie_async(cookie_id, cookie_value, user_id), self.loop)
+ return fut.result()
+
+ def remove_cookie(self, cookie_id: str):
+ try:
+ current_loop = asyncio.get_running_loop()
+ except RuntimeError:
+ current_loop = None
+
+ if current_loop and current_loop == self.loop:
+ return self.loop.create_task(self._remove_cookie_async(cookie_id))
+ else:
+ fut = asyncio.run_coroutine_threadsafe(self._remove_cookie_async(cookie_id), self.loop)
+ return fut.result()
+
+ # 更新 Cookie 值
+ def update_cookie(self, cookie_id: str, new_value: str):
+ """替换指定账号的 Cookie 并重启任务"""
+ async def _update():
+ # 获取原有的user_id和关键词
+ original_user_id = None
+ original_keywords = []
+ original_status = True
+
+ cookie_info = await asyncio.to_thread(db_manager.get_cookie_details, cookie_id)
+ if cookie_info:
+ original_user_id = cookie_info.get('user_id')
+
+ # 保存原有的关键词和状态
+ if cookie_id in self.keywords:
+ original_keywords = self.keywords[cookie_id].copy()
+ if cookie_id in self.cookie_status:
+ original_status = self.cookie_status[cookie_id]
+
+ # 先移除任务(但不删除数据库记录)
+ task = self.tasks.pop(cookie_id, None)
+ if task:
+ task.cancel()
+
+ # 更新Cookie值(保持原有user_id,不删除关键词)
+ self.cookies[cookie_id] = new_value
+ await asyncio.to_thread(db_manager.save_cookie, cookie_id, new_value, original_user_id)
+
+ # 恢复关键词和状态
+ self.keywords[cookie_id] = original_keywords
+ self.cookie_status[cookie_id] = original_status
+
+ # 重新启动任务
+ task = self.loop.create_task(self._run_xianyu(cookie_id, new_value, original_user_id))
+ self.tasks[cookie_id] = task
+
+ logger.info(f"已更新Cookie并重启任务: {cookie_id} (用户ID: {original_user_id}, 关键词: {len(original_keywords)}条)")
+
+ try:
+ current_loop = asyncio.get_running_loop()
+ except RuntimeError:
+ current_loop = None
+
+ if current_loop and current_loop == self.loop:
+ return self.loop.create_task(_update())
+ else:
+ fut = asyncio.run_coroutine_threadsafe(_update(), self.loop)
+ return fut.result()
+
+ def update_keywords(self, cookie_id: str, kw_list: List[Tuple[str, str]]):
+ """线程安全更新关键字"""
+ self.keywords[cookie_id] = kw_list
+ # 保存到数据库
+ db_manager.save_keywords(cookie_id, kw_list)
+ logger.info(f"更新关键字: {cookie_id} -> {len(kw_list)} 条")
+
+ # 查询接口
+ def list_cookies(self):
+ return list(self.cookies.keys())
+
+ def get_keywords(self, cookie_id: str) -> List[Tuple[str, str]]:
+ return self.keywords.get(cookie_id, [])
+
+ def update_cookie_status(self, cookie_id: str, enabled: bool):
+ """更新Cookie的启用/禁用状态"""
+ if cookie_id not in self.cookies:
+ raise ValueError(f"Cookie ID {cookie_id} 不存在")
+
+ old_status = self.cookie_status.get(cookie_id, True)
+ self.cookie_status[cookie_id] = enabled
+ # 保存到数据库
+ db_manager.save_cookie_status(cookie_id, enabled)
+ logger.info(f"更新Cookie状态: {cookie_id} -> {'启用' if enabled else '禁用'}")
+
+ # 如果状态发生变化,需要启动或停止任务
+ if old_status != enabled:
+ if enabled:
+ # 启用账号:启动任务
+ self._start_cookie_task(cookie_id)
+ else:
+ # 禁用账号:停止任务
+ self._stop_cookie_task(cookie_id)
+
+ def get_cookie_status(self, cookie_id: str) -> bool:
+ """获取Cookie的启用状态"""
+ return self.cookie_status.get(cookie_id, True) # 默认启用
+
+ def get_enabled_cookies(self) -> Dict[str, str]:
+ """获取所有启用的Cookie"""
+ return {cid: value for cid, value in self.cookies.items()
+ if self.cookie_status.get(cid, True)}
+
+ def _start_cookie_task(self, cookie_id: str):
+ """启动指定Cookie的任务"""
+ if cookie_id in self.tasks:
+ logger.warning(f"Cookie任务已存在,跳过启动: {cookie_id}")
+ return
+
+ cookie_value = self.cookies.get(cookie_id)
+ if not cookie_value:
+ logger.error(f"Cookie值不存在,无法启动任务: {cookie_id}")
+ return
+
+ try:
+ # 获取Cookie对应的user_id
+ cookie_info = db_manager.get_cookie_details(cookie_id)
+ user_id = cookie_info.get('user_id') if cookie_info else None
+
+ # 使用异步方式启动任务(直接调用_run_xianyu,跳过重复的数据库操作)
+ async def _start():
+ task = self.loop.create_task(self._run_xianyu(cookie_id, cookie_value, user_id))
+ self.tasks[cookie_id] = task
+
+ if hasattr(self.loop, 'is_running') and self.loop.is_running():
+ fut = asyncio.run_coroutine_threadsafe(_start(), self.loop)
+ fut.result(timeout=5)
+ else:
+ task = self.loop.create_task(self._run_xianyu(cookie_id, cookie_value, user_id))
+ self.tasks[cookie_id] = task
+
+ logger.info(f"成功启动Cookie任务: {cookie_id}")
+ except Exception as e:
+ logger.error(f"启动Cookie任务失败: {cookie_id}, {e}")
+
+ def _stop_cookie_task(self, cookie_id: str):
+ """停止指定Cookie的任务"""
+ if cookie_id not in self.tasks:
+ logger.warning(f"Cookie任务不存在,跳过停止: {cookie_id}")
+ return
+
+ try:
+ task = self.tasks[cookie_id]
+ if not task.done():
+ task.cancel()
+ logger.info(f"已取消Cookie任务: {cookie_id}")
+ del self.tasks[cookie_id]
+ logger.info(f"成功停止Cookie任务: {cookie_id}")
+ except Exception as e:
+ logger.error(f"停止Cookie任务失败: {cookie_id}, {e}")
+
+ def update_auto_confirm_setting(self, cookie_id: str, auto_confirm: bool):
+ """实时更新账号的自动确认发货设置"""
+ try:
+ # 更新内存中的设置
+ self.auto_confirm_settings[cookie_id] = auto_confirm
+ logger.info(f"更新账号 {cookie_id} 自动确认发货设置: {'开启' if auto_confirm else '关闭'}")
+
+ # 如果账号正在运行,通知XianyuLive实例更新设置
+ if cookie_id in self.tasks and not self.tasks[cookie_id].done():
+ # 这里可以通过某种方式通知正在运行的XianyuLive实例
+ # 由于XianyuLive会从数据库读取设置,所以数据库已经更新就足够了
+ logger.info(f"账号 {cookie_id} 正在运行,自动确认发货设置已实时生效")
+ except Exception as e:
+ logger.error(f"更新自动确认发货设置失败: {cookie_id}, {e}")
+
+ def update_online_status(self, cookie_id: str, is_online: bool):
+ """更新指定Cookie的WebSocket在线状态(由XianyuLive调用)"""
+ self.online_status[cookie_id] = is_online
+ status_text = "在线" if is_online else "离线"
+ logger.debug(f"更新在线状态: {cookie_id} -> {status_text}")
+
+ def get_online_status(self, cookie_id: str) -> Optional[bool]:
+ """获取指定Cookie的在线状态,None表示未知"""
+ return self.online_status.get(cookie_id)
+
+ def get_all_online_status(self) -> Dict[str, bool]:
+ """获取所有Cookie的在线状态"""
+ return dict(self.online_status)
+
+ def get_auto_confirm_setting(self, cookie_id: str) -> bool:
+ """获取账号的自动确认发货设置"""
+ return self.auto_confirm_settings.get(cookie_id, True) # 默认开启
+
+ def get_xianyu(self, cookie_id: str):
+ """获取指定账号的XianyuLive实例"""
+ return self.xianyu_instances.get(cookie_id)
+
+
+# 在 Start.py 中会把此变量赋值为具体实例
+manager: Optional[CookieManager] = None
\ No newline at end of file
diff --git a/db_manager.py b/db_manager.py
new file mode 100644
index 0000000..4c2188b
--- /dev/null
+++ b/db_manager.py
@@ -0,0 +1,5202 @@
+import sqlite3
+import os
+import threading
+import hashlib
+import time
+import json
+import random
+import string
+import aiohttp
+import io
+import base64
+from PIL import Image, ImageDraw, ImageFont
+from typing import List, Tuple, Dict, Optional, Any
+from loguru import logger
+
+class DBManager:
+ """SQLite数据库管理,持久化存储Cookie和关键字"""
+
+ def __init__(self, db_path: str = None):
+ """初始化数据库连接和表结构"""
+ # 支持环境变量配置数据库路径
+ if db_path is None:
+ db_path = os.getenv('DB_PATH', 'xianyu_data.db')
+
+ # 确保数据目录存在并有正确权限
+ db_dir = os.path.dirname(db_path)
+ if db_dir and not os.path.exists(db_dir):
+ try:
+ os.makedirs(db_dir, mode=0o755, exist_ok=True)
+ logger.info(f"创建数据目录: {db_dir}")
+ except PermissionError as e:
+ logger.error(f"创建数据目录失败,权限不足: {e}")
+ # 尝试使用当前目录
+ db_path = os.path.basename(db_path)
+ logger.warning(f"使用当前目录作为数据库路径: {db_path}")
+ except Exception as e:
+ logger.error(f"创建数据目录失败: {e}")
+ raise
+
+ # 检查目录权限
+ if db_dir and os.path.exists(db_dir):
+ if not os.access(db_dir, os.W_OK):
+ logger.error(f"数据目录没有写权限: {db_dir}")
+ # 尝试使用当前目录
+ db_path = os.path.basename(db_path)
+ logger.warning(f"使用当前目录作为数据库路径: {db_path}")
+
+ self.db_path = db_path
+ logger.info(f"数据库路径: {self.db_path}")
+ self.conn = None
+ self.lock = threading.RLock() # 使用可重入锁保护数据库操作
+
+ # SQL日志配置 - 默认启用
+ self.sql_log_enabled = True # 默认启用SQL日志
+ self.sql_log_level = 'INFO' # 默认使用INFO级别
+
+ # 允许通过环境变量覆盖默认设置
+ if os.getenv('SQL_LOG_ENABLED'):
+ self.sql_log_enabled = os.getenv('SQL_LOG_ENABLED', 'true').lower() == 'true'
+ if os.getenv('SQL_LOG_LEVEL'):
+ self.sql_log_level = os.getenv('SQL_LOG_LEVEL', 'INFO').upper()
+
+ logger.info(f"SQL日志已启用,日志级别: {self.sql_log_level}")
+
+ self.init_db()
+
+ def init_db(self):
+ """初始化数据库表结构"""
+ try:
+ self.conn = sqlite3.connect(self.db_path, check_same_thread=False)
+ cursor = self.conn.cursor()
+
+ # 创建用户表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS users (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ username TEXT UNIQUE NOT NULL,
+ email TEXT UNIQUE NOT NULL,
+ password_hash TEXT NOT NULL,
+ is_active BOOLEAN DEFAULT TRUE,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+ )
+ ''')
+
+ # 创建邮箱验证码表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS email_verifications (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ email TEXT NOT NULL,
+ code TEXT NOT NULL,
+ expires_at TIMESTAMP NOT NULL,
+ used BOOLEAN DEFAULT FALSE,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+ )
+ ''')
+
+ # 创建图形验证码表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS captcha_codes (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ session_id TEXT NOT NULL,
+ code TEXT NOT NULL,
+ expires_at TIMESTAMP NOT NULL,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+ )
+ ''')
+
+ # 创建cookies表(添加user_id字段和auto_confirm字段)
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS cookies (
+ id TEXT PRIMARY KEY,
+ value TEXT NOT NULL,
+ user_id INTEGER NOT NULL,
+ auto_confirm INTEGER DEFAULT 1,
+ remark TEXT DEFAULT '',
+ pause_duration INTEGER DEFAULT 10,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+ )
+ ''')
+
+
+ # 创建keywords表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS keywords (
+ cookie_id TEXT,
+ keyword TEXT,
+ reply TEXT,
+ item_id TEXT,
+ type TEXT DEFAULT 'text',
+ image_url TEXT,
+ FOREIGN KEY (cookie_id) REFERENCES cookies(id) ON DELETE CASCADE
+ )
+ ''')
+
+ # 创建cookie_status表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS cookie_status (
+ cookie_id TEXT PRIMARY KEY,
+ enabled BOOLEAN DEFAULT TRUE,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ FOREIGN KEY (cookie_id) REFERENCES cookies(id) ON DELETE CASCADE
+ )
+ ''')
+
+ # 创建AI回复配置表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS ai_reply_settings (
+ cookie_id TEXT PRIMARY KEY,
+ ai_enabled BOOLEAN DEFAULT FALSE,
+ model_name TEXT DEFAULT 'qwen-plus',
+ api_key TEXT,
+ base_url TEXT DEFAULT 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+ max_discount_percent INTEGER DEFAULT 10,
+ max_discount_amount INTEGER DEFAULT 100,
+ max_bargain_rounds INTEGER DEFAULT 3,
+ custom_prompts TEXT,
+ refund_policy TEXT DEFAULT 'allow',
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ FOREIGN KEY (cookie_id) REFERENCES cookies(id) ON DELETE CASCADE
+ )
+ ''')
+
+ # 创建AI对话历史表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS ai_conversations (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ cookie_id TEXT NOT NULL,
+ chat_id TEXT NOT NULL,
+ user_id TEXT NOT NULL,
+ item_id TEXT NOT NULL,
+ role TEXT NOT NULL,
+ content TEXT NOT NULL,
+ intent TEXT,
+ bargain_count INTEGER DEFAULT 0,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ FOREIGN KEY (cookie_id) REFERENCES cookies (id) ON DELETE CASCADE
+ )
+ ''')
+
+ # 创建AI商品信息缓存表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS ai_item_cache (
+ item_id TEXT PRIMARY KEY,
+ data TEXT NOT NULL,
+ price REAL,
+ description TEXT,
+ last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+ )
+ ''')
+
+ # 创建卡券表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS cards (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ name TEXT NOT NULL,
+ type TEXT NOT NULL CHECK (type IN ('api', 'text', 'data', 'image')),
+ api_config TEXT,
+ text_content TEXT,
+ data_content TEXT,
+ image_url TEXT,
+ description TEXT,
+ enabled BOOLEAN DEFAULT TRUE,
+ delay_seconds INTEGER DEFAULT 0,
+ is_multi_spec BOOLEAN DEFAULT FALSE,
+ spec_name TEXT,
+ spec_value TEXT,
+ user_id INTEGER NOT NULL DEFAULT 1,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ FOREIGN KEY (user_id) REFERENCES users (id)
+ )
+ ''')
+
+ # 创建订单表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS orders (
+ order_id TEXT PRIMARY KEY,
+ item_id TEXT,
+ buyer_id TEXT,
+ spec_name TEXT,
+ spec_value TEXT,
+ quantity TEXT,
+ amount TEXT,
+ order_status TEXT DEFAULT 'unknown',
+ cookie_id TEXT,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ FOREIGN KEY (cookie_id) REFERENCES cookies(id) ON DELETE CASCADE
+ )
+ ''')
+
+ # 检查并添加 user_id 列(用于数据库迁移)
+ try:
+ self._execute_sql(cursor, "SELECT user_id FROM cards LIMIT 1")
+ except sqlite3.OperationalError:
+ # user_id 列不存在,需要添加
+ logger.info("正在为 cards 表添加 user_id 列...")
+ self._execute_sql(cursor, "ALTER TABLE cards ADD COLUMN user_id INTEGER NOT NULL DEFAULT 1")
+ self._execute_sql(cursor, "CREATE INDEX IF NOT EXISTS idx_cards_user_id ON cards(user_id)")
+ logger.info("cards 表 user_id 列添加完成")
+
+ # 检查并添加 delay_seconds 列(用于自动发货延时功能)
+ try:
+ self._execute_sql(cursor, "SELECT delay_seconds FROM cards LIMIT 1")
+ except sqlite3.OperationalError:
+ # delay_seconds 列不存在,需要添加
+ logger.info("正在为 cards 表添加 delay_seconds 列...")
+ self._execute_sql(cursor, "ALTER TABLE cards ADD COLUMN delay_seconds INTEGER DEFAULT 0")
+ logger.info("cards 表 delay_seconds 列添加完成")
+
+ # 检查并添加 item_id 列(用于自动回复商品ID功能)
+ try:
+ self._execute_sql(cursor, "SELECT item_id FROM keywords LIMIT 1")
+ except sqlite3.OperationalError:
+ # item_id 列不存在,需要添加
+ logger.info("正在为 keywords 表添加 item_id 列...")
+ self._execute_sql(cursor, "ALTER TABLE keywords ADD COLUMN item_id TEXT")
+ logger.info("keywords 表 item_id 列添加完成")
+
+ # 检查并添加 delivery_status 列(用于订单发货状态跟踪)
+ try:
+ self._execute_sql(cursor, "SELECT delivery_status FROM orders LIMIT 1")
+ except sqlite3.OperationalError:
+ # delivery_status 列不存在,需要添加
+ logger.info("正在为 orders 表添加 delivery_status 列...")
+ self._execute_sql(cursor, "ALTER TABLE orders ADD COLUMN delivery_status TEXT DEFAULT 'pending'")
+ logger.info("orders 表 delivery_status 列添加完成")
+
+ # 检查并添加 buyer_name 列(用于存储买家昵称)
+ try:
+ self._execute_sql(cursor, "SELECT buyer_name FROM orders LIMIT 1")
+ except sqlite3.OperationalError:
+ logger.info("正在为 orders 表添加 buyer_name 列...")
+ self._execute_sql(cursor, "ALTER TABLE orders ADD COLUMN buyer_name TEXT DEFAULT ''")
+ logger.info("orders 表 buyer_name 列添加完成")
+
+ # 创建商品信息表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS item_info (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ cookie_id TEXT NOT NULL,
+ item_id TEXT NOT NULL,
+ item_title TEXT,
+ item_description TEXT,
+ item_category TEXT,
+ item_price TEXT,
+ item_detail TEXT,
+ is_multi_spec BOOLEAN DEFAULT FALSE,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ FOREIGN KEY (cookie_id) REFERENCES cookies(id) ON DELETE CASCADE,
+ UNIQUE(cookie_id, item_id)
+ )
+ ''')
+
+ # 检查并添加 multi_quantity_delivery 列(用于多数量发货功能)
+ try:
+ self._execute_sql(cursor, "SELECT multi_quantity_delivery FROM item_info LIMIT 1")
+ except sqlite3.OperationalError:
+ # multi_quantity_delivery 列不存在,需要添加
+ logger.info("正在为 item_info 表添加 multi_quantity_delivery 列...")
+ self._execute_sql(cursor, "ALTER TABLE item_info ADD COLUMN multi_quantity_delivery BOOLEAN DEFAULT FALSE")
+ logger.info("item_info 表 multi_quantity_delivery 列添加完成")
+
+ # 创建自动发货规则表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS delivery_rules (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ keyword TEXT NOT NULL,
+ card_id INTEGER NOT NULL,
+ delivery_count INTEGER DEFAULT 1,
+ enabled BOOLEAN DEFAULT TRUE,
+ description TEXT,
+ delivery_times INTEGER DEFAULT 0,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ FOREIGN KEY (card_id) REFERENCES cards(id) ON DELETE CASCADE
+ )
+ ''')
+
+ # 创建默认回复表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS default_replies (
+ cookie_id TEXT PRIMARY KEY,
+ enabled BOOLEAN DEFAULT FALSE,
+ reply_content TEXT,
+ reply_once BOOLEAN DEFAULT FALSE,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ FOREIGN KEY (cookie_id) REFERENCES cookies(id) ON DELETE CASCADE
+ )
+ ''')
+
+ # 添加 reply_once 字段(如果不存在)
+ try:
+ cursor.execute('ALTER TABLE default_replies ADD COLUMN reply_once BOOLEAN DEFAULT FALSE')
+ self.conn.commit()
+ logger.info("已添加 reply_once 字段到 default_replies 表")
+ except sqlite3.OperationalError as e:
+ if "duplicate column name" not in str(e).lower():
+ logger.warning(f"添加 reply_once 字段失败: {e}")
+
+ # 创建指定商品回复表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS item_replay (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ item_id TEXT NOT NULL,
+ cookie_id TEXT NOT NULL,
+ reply_content TEXT NOT NULL ,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+ )
+ ''')
+
+ # 创建默认回复记录表(记录已回复的chat_id)
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS default_reply_records (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ cookie_id TEXT NOT NULL,
+ chat_id TEXT NOT NULL,
+ replied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ UNIQUE(cookie_id, chat_id),
+ FOREIGN KEY (cookie_id) REFERENCES cookies(id) ON DELETE CASCADE
+ )
+ ''')
+
+ # 创建通知渠道表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS notification_channels (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ name TEXT NOT NULL,
+ type TEXT NOT NULL CHECK (type IN ('qq')),
+ config TEXT NOT NULL,
+ enabled BOOLEAN DEFAULT TRUE,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+ )
+ ''')
+
+ # 创建系统设置表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS system_settings (
+ key TEXT PRIMARY KEY,
+ value TEXT NOT NULL,
+ description TEXT,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+ )
+ ''')
+
+ # 创建消息通知配置表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS message_notifications (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ cookie_id TEXT NOT NULL,
+ channel_id INTEGER NOT NULL,
+ enabled BOOLEAN DEFAULT TRUE,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ FOREIGN KEY (cookie_id) REFERENCES cookies(id) ON DELETE CASCADE,
+ FOREIGN KEY (channel_id) REFERENCES notification_channels(id) ON DELETE CASCADE,
+ UNIQUE(cookie_id, channel_id)
+ )
+ ''')
+
+ # 创建用户设置表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS user_settings (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ user_id INTEGER NOT NULL,
+ key TEXT NOT NULL,
+ value TEXT NOT NULL,
+ description TEXT,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+ UNIQUE(user_id, key)
+ )
+ ''')
+
+ # 创建阿奇索账户表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS agiso_accounts (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ user_id INTEGER NOT NULL,
+ name TEXT NOT NULL,
+ cookie TEXT NOT NULL,
+ authorization TEXT NOT NULL,
+ is_active BOOLEAN DEFAULT TRUE,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+ )
+ ''')
+
+ # 创建转卖记录表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS resell_records (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ user_id INTEGER NOT NULL,
+ agiso_account_id INTEGER NOT NULL,
+ source_item_id TEXT NOT NULL,
+ source_title TEXT,
+ source_price TEXT,
+ source_image TEXT,
+ resell_price TEXT,
+ resell_stock INTEGER DEFAULT 1,
+ resell_description TEXT,
+ status TEXT DEFAULT 'pending',
+ agiso_item_id TEXT,
+ error_message TEXT,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+ FOREIGN KEY (agiso_account_id) REFERENCES agiso_accounts(id) ON DELETE CASCADE
+ )
+ ''')
+
+ # 插入默认系统设置(不包括管理员密码,由reply_server.py初始化)
+ cursor.execute('''
+ INSERT OR IGNORE INTO system_settings (key, value, description) VALUES
+ ('theme_color', 'blue', '主题颜色'),
+ ('registration_enabled', 'true', '是否开启用户注册'),
+ ('smtp_server', '', 'SMTP服务器地址'),
+ ('smtp_port', '587', 'SMTP端口'),
+ ('smtp_user', '', 'SMTP登录用户名(发件邮箱)'),
+ ('smtp_password', '', 'SMTP登录密码/授权码'),
+ ('smtp_from', '', '发件人显示名(留空则使用用户名)'),
+ ('smtp_use_tls', 'true', '是否启用TLS'),
+ ('smtp_use_ssl', 'false', '是否启用SSL'),
+ ('ai_default_enabled', 'false', 'AI回复-默认启用'),
+ ('ai_default_model', 'qwen-plus', 'AI回复-默认模型'),
+ ('ai_default_base_url', 'https://dashscope.aliyuncs.com/compatible-mode/v1', 'AI回复-默认API地址'),
+ ('ai_default_api_key', '', 'AI回复-默认API密钥'),
+ ('ai_default_max_discount_percent', '10', 'AI回复-默认最大优惠百分比'),
+ ('ai_default_max_discount_amount', '100', 'AI回复-默认最大优惠金额'),
+ ('ai_default_max_bargain_rounds', '3', 'AI回复-默认最大议价轮数'),
+ ('ai_default_prompts', '', 'AI回复-默认自定义提示词'),
+ ('ai_default_refund_policy', 'allow', 'AI回复-默认退款策略(allow/disallow)')
+ ''')
+
+ # 检查并升级数据库
+ self.check_and_upgrade_db(cursor)
+
+ # 执行数据库迁移
+ self._migrate_database(cursor)
+
+ self.conn.commit()
+ logger.info("数据库初始化完成")
+ except Exception as e:
+ logger.error(f"数据库初始化失败: {e}")
+ self.conn.rollback()
+ raise
+
+ def _migrate_database(self, cursor):
+ """执行数据库迁移"""
+ try:
+ # 检查cards表是否存在image_url列
+ cursor.execute("PRAGMA table_info(cards)")
+ columns = [column[1] for column in cursor.fetchall()]
+
+ if 'image_url' not in columns:
+ logger.info("添加cards表的image_url列...")
+ cursor.execute("ALTER TABLE cards ADD COLUMN image_url TEXT")
+ logger.info("数据库迁移完成:添加image_url列")
+
+ # 检查并更新CHECK约束(重建表以支持image类型)
+ self._update_cards_table_constraints(cursor)
+
+ # 检查cookies表是否存在remark列
+ cursor.execute("PRAGMA table_info(cookies)")
+ cookie_columns = [column[1] for column in cursor.fetchall()]
+
+ if 'remark' not in cookie_columns:
+ logger.info("添加cookies表的remark列...")
+ cursor.execute("ALTER TABLE cookies ADD COLUMN remark TEXT DEFAULT ''")
+ logger.info("数据库迁移完成:添加remark列")
+
+ # 检查cookies表是否存在pause_duration列
+ if 'pause_duration' not in cookie_columns:
+ logger.info("添加cookies表的pause_duration列...")
+ cursor.execute("ALTER TABLE cookies ADD COLUMN pause_duration INTEGER DEFAULT 10")
+ logger.info("数据库迁移完成:添加pause_duration列")
+
+ # 检查cookies表是否存在nickname列
+ if 'nickname' not in cookie_columns:
+ logger.info("添加cookies表的nickname列...")
+ cursor.execute("ALTER TABLE cookies ADD COLUMN nickname TEXT DEFAULT ''")
+ logger.info("数据库迁移完成:添加nickname列")
+
+ # 检查cookies表是否存在avatar_url列
+ if 'avatar_url' not in cookie_columns:
+ logger.info("添加cookies表的avatar_url列...")
+ cursor.execute("ALTER TABLE cookies ADD COLUMN avatar_url TEXT DEFAULT ''")
+ logger.info("数据库迁移完成:添加avatar_url列")
+
+ except Exception as e:
+ logger.error(f"数据库迁移失败: {e}")
+ # 迁移失败不应该阻止程序启动
+ pass
+
+ def _update_cards_table_constraints(self, cursor):
+ """更新cards表的CHECK约束以支持image类型"""
+ try:
+ # 尝试插入一个测试的image类型记录来检查约束
+ cursor.execute('''
+ INSERT INTO cards (name, type, user_id)
+ VALUES ('__test_image_constraint__', 'image', 1)
+ ''')
+ # 如果插入成功,立即删除测试记录
+ cursor.execute("DELETE FROM cards WHERE name = '__test_image_constraint__'")
+ logger.info("cards表约束检查通过,支持image类型")
+ except Exception as e:
+ if "CHECK constraint failed" in str(e) or "constraint" in str(e).lower():
+ logger.info("检测到旧的CHECK约束,开始更新cards表...")
+
+ # 重建表以更新约束
+ try:
+ # 1. 创建新表
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS cards_new (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ name TEXT NOT NULL,
+ type TEXT NOT NULL CHECK (type IN ('api', 'text', 'data', 'image')),
+ api_config TEXT,
+ text_content TEXT,
+ data_content TEXT,
+ image_url TEXT,
+ description TEXT,
+ enabled BOOLEAN DEFAULT TRUE,
+ delay_seconds INTEGER DEFAULT 0,
+ is_multi_spec BOOLEAN DEFAULT FALSE,
+ spec_name TEXT,
+ spec_value TEXT,
+ user_id INTEGER NOT NULL DEFAULT 1,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ FOREIGN KEY (user_id) REFERENCES users (id)
+ )
+ ''')
+
+ # 2. 复制数据
+ cursor.execute('''
+ INSERT INTO cards_new (id, name, type, api_config, text_content, data_content, image_url,
+ description, enabled, delay_seconds, is_multi_spec, spec_name, spec_value,
+ user_id, created_at, updated_at)
+ SELECT id, name, type, api_config, text_content, data_content, image_url,
+ description, enabled, delay_seconds, is_multi_spec, spec_name, spec_value,
+ user_id, created_at, updated_at
+ FROM cards
+ ''')
+
+ # 3. 删除旧表
+ cursor.execute("DROP TABLE cards")
+
+ # 4. 重命名新表
+ cursor.execute("ALTER TABLE cards_new RENAME TO cards")
+
+ logger.info("cards表约束更新完成,现在支持image类型")
+
+ except Exception as rebuild_error:
+ logger.error(f"重建cards表失败: {rebuild_error}")
+ # 如果重建失败,尝试回滚
+ try:
+ cursor.execute("DROP TABLE IF EXISTS cards_new")
+ except:
+ pass
+ else:
+ logger.error(f"检查cards表约束时出现未知错误: {e}")
+
+ def check_and_upgrade_db(self, cursor):
+ """检查数据库版本并执行必要的升级"""
+ try:
+ # 获取当前数据库版本
+ current_version = self.get_system_setting("db_version") or "1.0"
+ logger.info(f"当前数据库版本: {current_version}")
+
+ if current_version == "1.0":
+ logger.info("开始升级数据库到版本1.0...")
+ self.update_admin_user_id(cursor)
+ self.set_system_setting("db_version", "1.0", "数据库版本号")
+ logger.info("数据库升级到版本1.0完成")
+
+ # 如果版本低于需要升级的版本,执行升级
+ if current_version < "1.1":
+ logger.info("开始升级数据库到版本1.1...")
+ self.upgrade_notification_channels_table(cursor)
+ self.set_system_setting("db_version", "1.1", "数据库版本号")
+ logger.info("数据库升级到版本1.1完成")
+
+ # 升级到版本1.2 - 支持更多通知渠道类型
+ if current_version < "1.2":
+ logger.info("开始升级数据库到版本1.2...")
+ self.upgrade_notification_channels_types(cursor)
+ self.set_system_setting("db_version", "1.2", "数据库版本号")
+ logger.info("数据库升级到版本1.2完成")
+
+ # 升级到版本1.3 - 添加关键词类型和图片URL字段
+ if current_version < "1.3":
+ logger.info("开始升级数据库到版本1.3...")
+ self.upgrade_keywords_table_for_image_support(cursor)
+ self.set_system_setting("db_version", "1.3", "数据库版本号")
+ logger.info("数据库升级到版本1.3完成")
+
+ # 升级到版本1.4 - 添加AI回复退款策略字段
+ if current_version < "1.4":
+ logger.info("开始升级数据库到版本1.4...")
+ cursor.execute("PRAGMA table_info(ai_reply_settings)")
+ ai_columns = [col[1] for col in cursor.fetchall()]
+ if 'refund_policy' not in ai_columns:
+ cursor.execute("ALTER TABLE ai_reply_settings ADD COLUMN refund_policy TEXT DEFAULT 'allow'")
+ logger.info("添加ai_reply_settings表的refund_policy列")
+ self.set_system_setting("db_version", "1.4", "数据库版本号")
+ logger.info("数据库升级到版本1.4完成")
+
+ # 升级到版本1.5 - 添加用户角色字段
+ if current_version < "1.5":
+ logger.info("开始升级数据库到版本1.5...")
+ cursor.execute("PRAGMA table_info(users)")
+ user_columns = [col[1] for col in cursor.fetchall()]
+ if 'role' not in user_columns:
+ cursor.execute("ALTER TABLE users ADD COLUMN role TEXT DEFAULT 'user'")
+ cursor.execute("UPDATE users SET role = 'admin' WHERE username = 'admin'")
+ logger.info("添加users表的role列,并将admin用户设为admin角色")
+ self.set_system_setting("db_version", "1.5", "数据库版本号")
+ logger.info("数据库升级到版本1.5完成")
+
+ # 迁移遗留数据(在所有版本升级完成后执行)
+ self.migrate_legacy_data(cursor)
+
+ except Exception as e:
+ logger.error(f"数据库版本检查或升级失败: {e}")
+ raise
+
+ def update_admin_user_id(self, cursor):
+ """更新admin用户ID"""
+ try:
+ logger.info("开始更新admin用户ID...")
+ # 创建默认admin用户(只在首次初始化时创建)
+ cursor.execute('SELECT COUNT(*) FROM users WHERE username = ?', ('admin',))
+ admin_exists = cursor.fetchone()[0] > 0
+
+ if not admin_exists:
+ # 首次创建admin用户,设置默认密码
+ default_password_hash = hashlib.sha256("admin123".encode()).hexdigest()
+ cursor.execute('''
+ INSERT INTO users (username, email, password_hash) VALUES
+ ('admin', 'admin@localhost', ?)
+ ''', (default_password_hash,))
+ logger.info("创建默认admin用户,密码: admin123")
+
+ # 获取admin用户ID,用于历史数据绑定
+ self._execute_sql(cursor, "SELECT id FROM users WHERE username = 'admin'")
+ admin_user = cursor.fetchone()
+ if admin_user:
+ admin_user_id = admin_user[0]
+
+ # 将历史cookies数据绑定到admin用户(如果user_id列不存在)
+ try:
+ self._execute_sql(cursor, "SELECT user_id FROM cookies LIMIT 1")
+ except sqlite3.OperationalError:
+ # user_id列不存在,需要添加并更新历史数据
+ self._execute_sql(cursor, "ALTER TABLE cookies ADD COLUMN user_id INTEGER")
+ self._execute_sql(cursor, "UPDATE cookies SET user_id = ? WHERE user_id IS NULL", (admin_user_id,))
+ else:
+ # user_id列存在,更新NULL值
+ self._execute_sql(cursor, "UPDATE cookies SET user_id = ? WHERE user_id IS NULL", (admin_user_id,))
+
+ # 为cookies表添加auto_confirm字段(如果不存在)
+ try:
+ self._execute_sql(cursor, "SELECT auto_confirm FROM cookies LIMIT 1")
+ except sqlite3.OperationalError:
+ # auto_confirm列不存在,需要添加并设置默认值
+ self._execute_sql(cursor, "ALTER TABLE cookies ADD COLUMN auto_confirm INTEGER DEFAULT 1")
+ self._execute_sql(cursor, "UPDATE cookies SET auto_confirm = 1 WHERE auto_confirm IS NULL")
+ else:
+ # auto_confirm列存在,更新NULL值
+ self._execute_sql(cursor, "UPDATE cookies SET auto_confirm = 1 WHERE auto_confirm IS NULL")
+
+ # 为delivery_rules表添加user_id字段(如果不存在)
+ try:
+ self._execute_sql(cursor, "SELECT user_id FROM delivery_rules LIMIT 1")
+ except sqlite3.OperationalError:
+ # user_id列不存在,需要添加并更新历史数据
+ self._execute_sql(cursor, "ALTER TABLE delivery_rules ADD COLUMN user_id INTEGER")
+ self._execute_sql(cursor, "UPDATE delivery_rules SET user_id = ? WHERE user_id IS NULL", (admin_user_id,))
+ else:
+ # user_id列存在,更新NULL值
+ self._execute_sql(cursor, "UPDATE delivery_rules SET user_id = ? WHERE user_id IS NULL", (admin_user_id,))
+
+ # 为notification_channels表添加user_id字段(如果不存在)
+ try:
+ self._execute_sql(cursor, "SELECT user_id FROM notification_channels LIMIT 1")
+ except sqlite3.OperationalError:
+ # user_id列不存在,需要添加并更新历史数据
+ self._execute_sql(cursor, "ALTER TABLE notification_channels ADD COLUMN user_id INTEGER")
+ self._execute_sql(cursor, "UPDATE notification_channels SET user_id = ? WHERE user_id IS NULL", (admin_user_id,))
+ else:
+ # user_id列存在,更新NULL值
+ self._execute_sql(cursor, "UPDATE notification_channels SET user_id = ? WHERE user_id IS NULL", (admin_user_id,))
+
+ # 为email_verifications表添加type字段(如果不存在)
+ try:
+ self._execute_sql(cursor, "SELECT type FROM email_verifications LIMIT 1")
+ except sqlite3.OperationalError:
+ # type列不存在,需要添加并更新历史数据
+ self._execute_sql(cursor, "ALTER TABLE email_verifications ADD COLUMN type TEXT DEFAULT 'register'")
+ self._execute_sql(cursor, "UPDATE email_verifications SET type = 'register' WHERE type IS NULL")
+ else:
+ # type列存在,更新NULL值
+ self._execute_sql(cursor, "UPDATE email_verifications SET type = 'register' WHERE type IS NULL")
+
+ # 为cards表添加多规格字段(如果不存在)
+ try:
+ self._execute_sql(cursor, "SELECT is_multi_spec FROM cards LIMIT 1")
+ except sqlite3.OperationalError:
+ # 多规格字段不存在,需要添加
+ self._execute_sql(cursor, "ALTER TABLE cards ADD COLUMN is_multi_spec BOOLEAN DEFAULT FALSE")
+ self._execute_sql(cursor, "ALTER TABLE cards ADD COLUMN spec_name TEXT")
+ self._execute_sql(cursor, "ALTER TABLE cards ADD COLUMN spec_value TEXT")
+ logger.info("为cards表添加多规格字段")
+
+ # 为item_info表添加多规格字段(如果不存在)
+ try:
+ self._execute_sql(cursor, "SELECT is_multi_spec FROM item_info LIMIT 1")
+ except sqlite3.OperationalError:
+ # 多规格字段不存在,需要添加
+ self._execute_sql(cursor, "ALTER TABLE item_info ADD COLUMN is_multi_spec BOOLEAN DEFAULT FALSE")
+ logger.info("为item_info表添加多规格字段")
+
+ # 为item_info表添加多数量发货字段(如果不存在)
+ try:
+ self._execute_sql(cursor, "SELECT multi_quantity_delivery FROM item_info LIMIT 1")
+ except sqlite3.OperationalError:
+ # 多数量发货字段不存在,需要添加
+ self._execute_sql(cursor, "ALTER TABLE item_info ADD COLUMN multi_quantity_delivery BOOLEAN DEFAULT FALSE")
+ logger.info("为item_info表添加多数量发货字段")
+
+ # 为cookies表添加last_refreshed_at字段(用于追踪Cookie刷新时间)
+ try:
+ self._execute_sql(cursor, "SELECT last_refreshed_at FROM cookies LIMIT 1")
+ except sqlite3.OperationalError:
+ self._execute_sql(cursor, "ALTER TABLE cookies ADD COLUMN last_refreshed_at TIMESTAMP")
+ self._execute_sql(cursor, "UPDATE cookies SET last_refreshed_at = created_at WHERE last_refreshed_at IS NULL")
+ logger.info("为cookies表添加last_refreshed_at字段")
+
+ # 处理keywords表的唯一约束问题
+ # 由于SQLite不支持直接修改约束,我们需要重建表
+ self._migrate_keywords_table_constraints(cursor)
+
+ self.conn.commit()
+ logger.info(f"admin用户ID更新完成")
+ except Exception as e:
+ logger.error(f"更新admin用户ID失败: {e}")
+ raise
+
+ def upgrade_notification_channels_table(self, cursor):
+ """升级notification_channels表的type字段约束"""
+ try:
+ logger.info("开始升级notification_channels表...")
+
+ # 检查表是否存在
+ cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='notification_channels'")
+ if not cursor.fetchone():
+ logger.info("notification_channels表不存在,无需升级")
+ return True
+
+ # 检查表中是否有数据
+ cursor.execute("SELECT COUNT(*) FROM notification_channels")
+ count = cursor.fetchone()[0]
+
+ # 删除可能存在的临时表
+ cursor.execute("DROP TABLE IF EXISTS notification_channels_new")
+
+ # 创建临时表
+ cursor.execute('''
+ CREATE TABLE notification_channels_new (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ name TEXT NOT NULL,
+ user_id INTEGER NOT NULL,
+ type TEXT NOT NULL CHECK (type IN ('qq','ding_talk')),
+ config TEXT NOT NULL,
+ enabled BOOLEAN DEFAULT TRUE,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+ )
+ ''')
+
+ # 复制数据,并转换不兼容的类型
+ if count > 0:
+ logger.info(f"复制 {count} 条通知渠道数据到新表")
+ # 先查看现有数据的类型
+ cursor.execute("SELECT DISTINCT type FROM notification_channels")
+ existing_types = [row[0] for row in cursor.fetchall()]
+ logger.info(f"现有通知渠道类型: {existing_types}")
+
+ # 获取所有现有数据进行逐行处理
+ cursor.execute("SELECT * FROM notification_channels")
+ existing_data = cursor.fetchall()
+
+ # 逐行转移数据,确保类型映射正确
+ for row in existing_data:
+ old_type = row[3] if len(row) > 3 else 'qq' # type字段,默认为qq
+
+ # 类型映射规则
+ type_mapping = {
+ 'dingtalk': 'ding_talk',
+ 'ding_talk': 'ding_talk',
+ 'qq': 'qq',
+ 'email': 'qq', # 暂时映射为qq,后续版本会支持
+ 'webhook': 'qq', # 暂时映射为qq,后续版本会支持
+ 'wechat': 'qq', # 暂时映射为qq,后续版本会支持
+ 'telegram': 'qq' # 暂时映射为qq,后续版本会支持
+ }
+
+ new_type = type_mapping.get(old_type, 'qq') # 默认转换为qq类型
+
+ if old_type != new_type:
+ logger.info(f"转换通知渠道类型: {old_type} -> {new_type}")
+
+ # 插入到新表
+ cursor.execute('''
+ INSERT INTO notification_channels_new
+ (id, name, user_id, type, config, enabled, created_at, updated_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+ ''', (
+ row[0], # id
+ row[1], # name
+ row[2], # user_id
+ new_type, # type (转换后的)
+ row[4] if len(row) > 4 else '{}', # config
+ row[5] if len(row) > 5 else True, # enabled
+ row[6] if len(row) > 6 else None, # created_at
+ row[7] if len(row) > 7 else None # updated_at
+ ))
+
+ # 删除旧表
+ cursor.execute("DROP TABLE notification_channels")
+
+ # 重命名新表
+ cursor.execute("ALTER TABLE notification_channels_new RENAME TO notification_channels")
+
+ logger.info("notification_channels表升级完成")
+ return True
+ except Exception as e:
+ logger.error(f"升级notification_channels表失败: {e}")
+ raise
+
+ def upgrade_notification_channels_types(self, cursor):
+ """升级notification_channels表支持更多渠道类型"""
+ try:
+ logger.info("开始升级notification_channels表支持更多渠道类型...")
+
+ # 检查表是否存在
+ cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='notification_channels'")
+ if not cursor.fetchone():
+ logger.info("notification_channels表不存在,无需升级")
+ return True
+
+ # 检查表中是否有数据
+ cursor.execute("SELECT COUNT(*) FROM notification_channels")
+ count = cursor.fetchone()[0]
+
+ # 获取现有数据
+ existing_data = []
+ if count > 0:
+ cursor.execute("SELECT * FROM notification_channels")
+ existing_data = cursor.fetchall()
+ logger.info(f"备份 {count} 条通知渠道数据")
+
+ # 创建新表,支持更多渠道类型
+ cursor.execute('''
+ CREATE TABLE notification_channels_new (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ name TEXT NOT NULL,
+ user_id INTEGER NOT NULL,
+ type TEXT NOT NULL CHECK (type IN ('qq','ding_talk','dingtalk','email','webhook','wechat','telegram')),
+ config TEXT NOT NULL,
+ enabled BOOLEAN DEFAULT TRUE,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+ )
+ ''')
+
+ # 复制数据,同时处理类型映射
+ if existing_data:
+ logger.info(f"迁移 {len(existing_data)} 条通知渠道数据到新表")
+ for row in existing_data:
+ # 处理类型映射,支持更多渠道类型
+ old_type = row[3] if len(row) > 3 else 'qq' # type字段
+
+ # 扩展的类型映射规则
+ type_mapping = {
+ 'ding_talk': 'dingtalk', # 统一为dingtalk
+ 'dingtalk': 'dingtalk',
+ 'qq': 'qq',
+ 'email': 'email', # 现在支持email
+ 'webhook': 'webhook', # 现在支持webhook
+ 'wechat': 'wechat', # 现在支持wechat
+ 'telegram': 'telegram' # 现在支持telegram
+ }
+
+ new_type = type_mapping.get(old_type, 'qq') # 默认为qq
+
+ if old_type != new_type:
+ logger.info(f"转换通知渠道类型: {old_type} -> {new_type}")
+
+ # 插入到新表,确保字段完整性
+ cursor.execute('''
+ INSERT INTO notification_channels_new
+ (id, name, user_id, type, config, enabled, created_at, updated_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+ ''', (
+ row[0], # id
+ row[1], # name
+ row[2], # user_id
+ new_type, # type (转换后的)
+ row[4] if len(row) > 4 else '{}', # config
+ row[5] if len(row) > 5 else True, # enabled
+ row[6] if len(row) > 6 else None, # created_at
+ row[7] if len(row) > 7 else None # updated_at
+ ))
+
+ # 删除旧表
+ cursor.execute("DROP TABLE notification_channels")
+
+ # 重命名新表
+ cursor.execute("ALTER TABLE notification_channels_new RENAME TO notification_channels")
+
+ logger.info("notification_channels表类型升级完成")
+ return True
+ except Exception as e:
+ logger.error(f"升级notification_channels表类型失败: {e}")
+ raise
+
+ def migrate_legacy_data(self, cursor):
+ """迁移遗留数据到新表结构"""
+ try:
+ logger.info("开始检查和迁移遗留数据...")
+
+ # 检查是否有需要迁移的老表
+ legacy_tables = [
+ 'old_notification_channels',
+ 'legacy_delivery_rules',
+ 'old_keywords',
+ 'backup_cookies'
+ ]
+
+ for table_name in legacy_tables:
+ cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name=?", (table_name,))
+ if cursor.fetchone():
+ logger.info(f"发现遗留表: {table_name},开始迁移数据...")
+ self._migrate_table_data(cursor, table_name)
+
+ logger.info("遗留数据迁移完成")
+ return True
+ except Exception as e:
+ logger.error(f"迁移遗留数据失败: {e}")
+ return False
+
+ def _migrate_table_data(self, cursor, table_name: str):
+ """迁移指定表的数据"""
+ try:
+ if table_name == 'old_notification_channels':
+ # 迁移通知渠道数据
+ cursor.execute(f"SELECT COUNT(*) FROM {table_name}")
+ count = cursor.fetchone()[0]
+
+ if count > 0:
+ cursor.execute(f"SELECT * FROM {table_name}")
+ old_data = cursor.fetchall()
+
+ for row in old_data:
+ # 处理数据格式转换
+ cursor.execute('''
+ INSERT OR IGNORE INTO notification_channels
+ (name, user_id, type, config, enabled)
+ VALUES (?, ?, ?, ?, ?)
+ ''', (
+ row[1] if len(row) > 1 else f"迁移渠道_{row[0]}",
+ row[2] if len(row) > 2 else 1, # 默认admin用户
+ self._normalize_channel_type(row[3] if len(row) > 3 else 'qq'),
+ row[4] if len(row) > 4 else '{}',
+ row[5] if len(row) > 5 else True
+ ))
+
+ logger.info(f"成功迁移 {count} 条通知渠道数据")
+
+ # 迁移完成后删除老表
+ cursor.execute(f"DROP TABLE {table_name}")
+ logger.info(f"已删除遗留表: {table_name}")
+
+ except Exception as e:
+ logger.error(f"迁移表 {table_name} 数据失败: {e}")
+
+ def _normalize_channel_type(self, old_type: str) -> str:
+ """标准化通知渠道类型"""
+ type_mapping = {
+ 'ding_talk': 'dingtalk',
+ 'dingtalk': 'dingtalk',
+ 'qq': 'qq',
+ 'email': 'email',
+ 'webhook': 'webhook',
+ 'wechat': 'wechat',
+ 'telegram': 'telegram',
+ # 处理一些可能的变体
+ 'dingding': 'dingtalk',
+ 'weixin': 'wechat',
+ 'tg': 'telegram'
+ }
+ return type_mapping.get(old_type.lower(), 'qq')
+
+ def _migrate_keywords_table_constraints(self, cursor):
+ """迁移keywords表的约束,支持基于商品ID的唯一性校验"""
+ try:
+ # 检查是否已经迁移过(通过检查是否存在新的唯一索引)
+ cursor.execute("SELECT name FROM sqlite_master WHERE type='index' AND name='idx_keywords_unique_with_item'")
+ if cursor.fetchone():
+ logger.info("keywords表约束已经迁移过,跳过")
+ return
+
+ logger.info("开始迁移keywords表约束...")
+
+ # 1. 创建临时表,不设置主键约束
+ cursor.execute('''
+ CREATE TABLE IF NOT EXISTS keywords_temp (
+ cookie_id TEXT,
+ keyword TEXT,
+ reply TEXT,
+ item_id TEXT,
+ FOREIGN KEY (cookie_id) REFERENCES cookies(id) ON DELETE CASCADE
+ )
+ ''')
+
+ # 2. 复制现有数据到临时表
+ cursor.execute('''
+ INSERT INTO keywords_temp (cookie_id, keyword, reply, item_id)
+ SELECT cookie_id, keyword, reply, item_id FROM keywords
+ ''')
+
+ # 3. 删除原表
+ cursor.execute('DROP TABLE keywords')
+
+ # 4. 重命名临时表
+ cursor.execute('ALTER TABLE keywords_temp RENAME TO keywords')
+
+ # 5. 创建复合唯一索引来实现我们需要的约束逻辑
+ # 对于item_id为空的情况:(cookie_id, keyword)必须唯一
+ cursor.execute('''
+ CREATE UNIQUE INDEX idx_keywords_unique_no_item
+ ON keywords(cookie_id, keyword)
+ WHERE item_id IS NULL OR item_id = ''
+ ''')
+
+ # 对于item_id不为空的情况:(cookie_id, keyword, item_id)必须唯一
+ cursor.execute('''
+ CREATE UNIQUE INDEX idx_keywords_unique_with_item
+ ON keywords(cookie_id, keyword, item_id)
+ WHERE item_id IS NOT NULL AND item_id != ''
+ ''')
+
+ logger.info("keywords表约束迁移完成")
+
+ except Exception as e:
+ logger.error(f"迁移keywords表约束失败: {e}")
+ # 如果迁移失败,尝试回滚
+ try:
+ cursor.execute('DROP TABLE IF EXISTS keywords_temp')
+ except:
+ pass
+ raise
+
+ def close(self):
+ """关闭数据库连接"""
+ if self.conn:
+ self.conn.close()
+ self.conn = None
+
+ def get_connection(self):
+ """获取数据库连接,如果已关闭则重新连接"""
+ if self.conn is None:
+ self.conn = sqlite3.connect(self.db_path, check_same_thread=False)
+ return self.conn
+
+ def _log_sql(self, sql: str, params: tuple = None, operation: str = "EXECUTE"):
+ """记录SQL执行日志"""
+ if not self.sql_log_enabled:
+ return
+
+ # 格式化参数
+ params_str = ""
+ if params:
+ if isinstance(params, (list, tuple)):
+ if len(params) > 0:
+ # 限制参数长度,避免日志过长
+ formatted_params = []
+ for param in params:
+ if isinstance(param, str) and len(param) > 100:
+ formatted_params.append(f"{param[:100]}...")
+ else:
+ formatted_params.append(repr(param))
+ params_str = f" | 参数: [{', '.join(formatted_params)}]"
+
+ # 格式化SQL(移除多余空白)
+ formatted_sql = ' '.join(sql.split())
+
+ # 根据配置的日志级别输出
+ log_message = f"🗄️ SQL {operation}: {formatted_sql}{params_str}"
+
+ if self.sql_log_level == 'DEBUG':
+ logger.debug(log_message)
+ elif self.sql_log_level == 'INFO':
+ logger.info(log_message)
+ elif self.sql_log_level == 'WARNING':
+ logger.warning(log_message)
+ else:
+ logger.debug(log_message)
+
+ def _execute_sql(self, cursor, sql: str, params: tuple = None):
+ """执行SQL并记录日志"""
+ self._log_sql(sql, params, "EXECUTE")
+ if params:
+ return cursor.execute(sql, params)
+ else:
+ return cursor.execute(sql)
+
+ def _executemany_sql(self, cursor, sql: str, params_list):
+ """批量执行SQL并记录日志"""
+ self._log_sql(sql, f"批量执行 {len(params_list)} 条记录", "EXECUTEMANY")
+ return cursor.executemany(sql, params_list)
+
+ # -------------------- Cookie操作 --------------------
+ def save_cookie(self, cookie_id: str, cookie_value: str, user_id: int = None) -> bool:
+ """保存Cookie到数据库,如存在则更新"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+
+ # 如果没有提供user_id,尝试从现有记录获取,否则使用admin用户ID
+ if user_id is None:
+ self._execute_sql(cursor, "SELECT user_id FROM cookies WHERE id = ?", (cookie_id,))
+ existing = cursor.fetchone()
+ if existing:
+ user_id = existing[0]
+ else:
+ # 获取admin用户ID作为默认值
+ self._execute_sql(cursor, "SELECT id FROM users WHERE username = 'admin'")
+ admin_user = cursor.fetchone()
+ user_id = admin_user[0] if admin_user else 1
+
+ self._execute_sql(cursor,
+ "INSERT OR REPLACE INTO cookies (id, value, user_id, last_refreshed_at) VALUES (?, ?, ?, CURRENT_TIMESTAMP)",
+ (cookie_id, cookie_value, user_id)
+ )
+
+ self.conn.commit()
+ logger.info(f"Cookie保存成功: {cookie_id} (用户ID: {user_id})")
+
+ # 验证保存结果
+ self._execute_sql(cursor, "SELECT user_id FROM cookies WHERE id = ?", (cookie_id,))
+ saved_user_id = cursor.fetchone()
+ if saved_user_id:
+ logger.info(f"Cookie保存验证: {cookie_id} 实际绑定到用户ID: {saved_user_id[0]}")
+ else:
+ logger.error(f"Cookie保存验证失败: {cookie_id} 未找到记录")
+ return True
+ except Exception as e:
+ logger.error(f"Cookie保存失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def update_cookie_refresh_time(self, cookie_id: str) -> bool:
+ """更新Cookie的最后刷新时间"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor,
+ "UPDATE cookies SET last_refreshed_at = CURRENT_TIMESTAMP WHERE id = ?",
+ (cookie_id,)
+ )
+ self.conn.commit()
+ return True
+ except Exception as e:
+ logger.error(f"更新Cookie刷新时间失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def get_cookie_refresh_info(self, cookie_id: str) -> dict:
+ """获取Cookie的刷新信息(创建时间、最后刷新时间)"""
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor,
+ "SELECT created_at, last_refreshed_at FROM cookies WHERE id = ?",
+ (cookie_id,)
+ )
+ row = cursor.fetchone()
+ if row:
+ return {
+ 'created_at': row[0],
+ 'last_refreshed_at': row[1] or row[0]
+ }
+ return None
+ except Exception as e:
+ logger.error(f"获取Cookie刷新信息失败: {e}")
+ return None
+
+ def update_cookie_user_info(self, cookie_id: str, nickname: str = None, avatar_url: str = None) -> bool:
+ """更新Cookie的用户信息(昵称和头像)"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+
+ updates = []
+ params = []
+
+ if nickname is not None:
+ updates.append("nickname = ?")
+ params.append(nickname)
+
+ if avatar_url is not None:
+ updates.append("avatar_url = ?")
+ params.append(avatar_url)
+
+ if not updates:
+ return False
+
+ params.append(cookie_id)
+ sql = f"UPDATE cookies SET {', '.join(updates)} WHERE id = ?"
+
+ self._execute_sql(cursor, sql, params)
+ self.conn.commit()
+
+ logger.info(f"Cookie用户信息更新成功: {cookie_id}, nickname={nickname}, avatar_url={avatar_url}")
+ return True
+ except Exception as e:
+ logger.error(f"Cookie用户信息更新失败: {e}")
+ self.conn.rollback()
+ return False
+
+
+ def delete_cookie(self, cookie_id: str) -> bool:
+ """从数据库删除Cookie及其关键字"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ # 删除关联的关键字
+ self._execute_sql(cursor, "DELETE FROM keywords WHERE cookie_id = ?", (cookie_id,))
+ # 删除Cookie
+ self._execute_sql(cursor, "DELETE FROM cookies WHERE id = ?", (cookie_id,))
+ self.conn.commit()
+ logger.debug(f"Cookie删除成功: {cookie_id}")
+ return True
+ except Exception as e:
+ logger.error(f"Cookie删除失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def get_cookie(self, cookie_id: str) -> Optional[str]:
+ """获取指定Cookie值"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "SELECT value FROM cookies WHERE id = ?", (cookie_id,))
+ result = cursor.fetchone()
+ return result[0] if result else None
+ except Exception as e:
+ logger.error(f"获取Cookie失败: {e}")
+ return None
+
+ def get_all_cookies(self, user_id: int = None) -> Dict[str, str]:
+ """获取所有Cookie(支持用户隔离)"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ if user_id is not None:
+ self._execute_sql(cursor, "SELECT id, value FROM cookies WHERE user_id = ?", (user_id,))
+ else:
+ self._execute_sql(cursor, "SELECT id, value FROM cookies")
+ return {row[0]: row[1] for row in cursor.fetchall()}
+ except Exception as e:
+ logger.error(f"获取所有Cookie失败: {e}")
+ return {}
+
+
+
+ def get_cookie_by_id(self, cookie_id: str) -> Optional[Dict[str, str]]:
+ """根据ID获取Cookie信息
+
+ Args:
+ cookie_id: Cookie ID
+
+ Returns:
+ Dict包含cookie信息,包括cookies_str字段,如果不存在返回None
+ """
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "SELECT id, value, created_at FROM cookies WHERE id = ?", (cookie_id,))
+ result = cursor.fetchone()
+ if result:
+ return {
+ 'id': result[0],
+ 'cookies_str': result[1], # 使用cookies_str字段名以匹配调用方期望
+ 'value': result[1], # 保持向后兼容
+ 'created_at': result[2]
+ }
+ return None
+ except Exception as e:
+ logger.error(f"根据ID获取Cookie失败: {e}")
+ return None
+
+ def get_cookie_details(self, cookie_id: str) -> Optional[Dict[str, any]]:
+ """获取Cookie的详细信息,包括user_id、auto_confirm、remark和pause_duration"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "SELECT id, value, user_id, auto_confirm, remark, pause_duration, created_at, nickname, avatar_url FROM cookies WHERE id = ?", (cookie_id,))
+ result = cursor.fetchone()
+ if result:
+ return {
+ 'id': result[0],
+ 'value': result[1],
+ 'user_id': result[2],
+ 'auto_confirm': bool(result[3]),
+ 'remark': result[4] or '',
+ 'pause_duration': result[5] or 10,
+ 'created_at': result[6],
+ 'nickname': result[7] or '',
+ 'avatar_url': result[8] or ''
+ }
+ return None
+ except Exception as e:
+ logger.error(f"获取Cookie详细信息失败: {e}")
+ return None
+
+ def update_auto_confirm(self, cookie_id: str, auto_confirm: bool) -> bool:
+ """更新Cookie的自动确认发货设置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "UPDATE cookies SET auto_confirm = ? WHERE id = ?", (int(auto_confirm), cookie_id))
+ self.conn.commit()
+ logger.info(f"更新账号 {cookie_id} 自动确认发货设置: {'开启' if auto_confirm else '关闭'}")
+ return True
+ except Exception as e:
+ logger.error(f"更新自动确认发货设置失败: {e}")
+ return False
+
+ def update_cookie_remark(self, cookie_id: str, remark: str) -> bool:
+ """更新Cookie的备注"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "UPDATE cookies SET remark = ? WHERE id = ?", (remark, cookie_id))
+ self.conn.commit()
+ logger.info(f"更新账号 {cookie_id} 备注: {remark}")
+ return True
+ except Exception as e:
+ logger.error(f"更新账号备注失败: {e}")
+ return False
+
+ def update_cookie_pause_duration(self, cookie_id: str, pause_duration: int) -> bool:
+ """更新Cookie的自动回复暂停时间"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "UPDATE cookies SET pause_duration = ? WHERE id = ?", (pause_duration, cookie_id))
+ self.conn.commit()
+ logger.info(f"更新账号 {cookie_id} 自动回复暂停时间: {pause_duration}分钟")
+ return True
+ except Exception as e:
+ logger.error(f"更新账号自动回复暂停时间失败: {e}")
+ return False
+
+ def get_cookie_pause_duration(self, cookie_id: str) -> int:
+ """获取Cookie的自动回复暂停时间"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "SELECT pause_duration FROM cookies WHERE id = ?", (cookie_id,))
+ result = cursor.fetchone()
+ if result:
+ return result[0] or 10 # 默认10分钟
+ return 10 # 如果没有找到记录,返回默认值
+ except Exception as e:
+ logger.error(f"获取账号自动回复暂停时间失败: {e}")
+ return 10 # 出错时返回默认值
+
+ def get_auto_confirm(self, cookie_id: str) -> bool:
+ """获取Cookie的自动确认发货设置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "SELECT auto_confirm FROM cookies WHERE id = ?", (cookie_id,))
+ result = cursor.fetchone()
+ if result:
+ return bool(result[0])
+ return True # 默认开启
+ except Exception as e:
+ logger.error(f"获取自动确认发货设置失败: {e}")
+ return True # 出错时默认开启
+
+ # -------------------- 阿奇索账户操作 --------------------
+ def add_agiso_account(self, user_id: int, name: str, cookie: str, authorization: str) -> int:
+ """添加阿奇索账户"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor,
+ "INSERT INTO agiso_accounts (user_id, name, cookie, authorization) VALUES (?, ?, ?, ?)",
+ (user_id, name, cookie, authorization))
+ self.conn.commit()
+ account_id = cursor.lastrowid
+ logger.info(f"添加阿奇索账户成功: id={account_id}, name={name}")
+ return account_id
+ except Exception as e:
+ logger.error(f"添加阿奇索账户失败: {e}")
+ return -1
+
+ def get_agiso_accounts(self, user_id: int) -> List[Dict[str, Any]]:
+ """获取用户的所有阿奇索账户"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor,
+ "SELECT id, name, cookie, authorization, is_active, created_at FROM agiso_accounts WHERE user_id = ?",
+ (user_id,))
+ return [
+ {
+ "id": row[0],
+ "name": row[1],
+ "cookie": row[2],
+ "authorization": row[3],
+ "is_active": bool(row[4]),
+ "created_at": row[5]
+ }
+ for row in cursor.fetchall()
+ ]
+ except Exception as e:
+ logger.error(f"获取阿奇索账户列表失败: {e}")
+ return []
+
+ def get_agiso_account_by_id(self, account_id: int) -> Optional[Dict[str, Any]]:
+ """根据ID获取阿奇索账户"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor,
+ "SELECT id, user_id, name, cookie, authorization, is_active, created_at FROM agiso_accounts WHERE id = ?",
+ (account_id,))
+ result = cursor.fetchone()
+ if result:
+ return {
+ "id": result[0],
+ "user_id": result[1],
+ "name": result[2],
+ "cookie": result[3],
+ "authorization": result[4],
+ "is_active": bool(result[5]),
+ "created_at": result[6]
+ }
+ return None
+ except Exception as e:
+ logger.error(f"获取阿奇索账户失败: {e}")
+ return None
+
+ def update_agiso_account(self, account_id: int, name: str = None, cookie: str = None, authorization: str = None) -> bool:
+ """更新阿奇索账户"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ updates = []
+ params = []
+ if name is not None:
+ updates.append("name = ?")
+ params.append(name)
+ if cookie is not None:
+ updates.append("cookie = ?")
+ params.append(cookie)
+ if authorization is not None:
+ updates.append("authorization = ?")
+ params.append(authorization)
+ if not updates:
+ return False
+ params.append(account_id)
+ self._execute_sql(cursor,
+ f"UPDATE agiso_accounts SET {', '.join(updates)} WHERE id = ?",
+ tuple(params))
+ self.conn.commit()
+ logger.info(f"更新阿奇索账户成功: id={account_id}")
+ return True
+ except Exception as e:
+ logger.error(f"更新阿奇索账户失败: {e}")
+ return False
+
+ def delete_agiso_account(self, account_id: int) -> bool:
+ """删除阿奇索账户"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "DELETE FROM agiso_accounts WHERE id = ?", (account_id,))
+ self.conn.commit()
+ logger.info(f"删除阿奇索账户成功: id={account_id}")
+ return True
+ except Exception as e:
+ logger.error(f"删除阿奇索账户失败: {e}")
+ return False
+
+ # -------------------- 转卖记录操作 --------------------
+ def add_resell_record(self, user_id: int, agiso_account_id: int, source_item_id: str,
+ source_title: str = None, source_price: str = None, source_image: str = None,
+ resell_price: str = None, resell_stock: int = 1, resell_description: str = None) -> int:
+ """添加转卖记录"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor,
+ """INSERT INTO resell_records
+ (user_id, agiso_account_id, source_item_id, source_title, source_price,
+ source_image, resell_price, resell_stock, resell_description)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+ (user_id, agiso_account_id, source_item_id, source_title, source_price,
+ source_image, resell_price, resell_stock, resell_description))
+ self.conn.commit()
+ record_id = cursor.lastrowid
+ logger.info(f"添加转卖记录成功: id={record_id}, item={source_item_id}")
+ return record_id
+ except Exception as e:
+ logger.error(f"添加转卖记录失败: {e}")
+ return -1
+
+ def update_resell_record_status(self, record_id: int, status: str, agiso_item_id: str = None, error_message: str = None) -> bool:
+ """更新转卖记录状态"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor,
+ "UPDATE resell_records SET status = ?, agiso_item_id = ?, error_message = ? WHERE id = ?",
+ (status, agiso_item_id, error_message, record_id))
+ self.conn.commit()
+ logger.info(f"更新转卖记录状态: id={record_id}, status={status}")
+ return True
+ except Exception as e:
+ logger.error(f"更新转卖记录状态失败: {e}")
+ return False
+
+ def get_resell_records(self, user_id: int, limit: int = 50, offset: int = 0) -> List[Dict[str, Any]]:
+ """获取用户的转卖记录"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor,
+ """SELECT r.id, r.agiso_account_id, a.name as account_name, r.source_item_id,
+ r.source_title, r.source_price, r.source_image, r.resell_price,
+ r.resell_stock, r.resell_description, r.status, r.agiso_item_id,
+ r.error_message, r.created_at
+ FROM resell_records r
+ LEFT JOIN agiso_accounts a ON r.agiso_account_id = a.id
+ WHERE r.user_id = ?
+ ORDER BY r.created_at DESC
+ LIMIT ? OFFSET ?""",
+ (user_id, limit, offset))
+ return [
+ {
+ "id": row[0],
+ "agiso_account_id": row[1],
+ "account_name": row[2],
+ "source_item_id": row[3],
+ "source_title": row[4],
+ "source_price": row[5],
+ "source_image": row[6],
+ "resell_price": row[7],
+ "resell_stock": row[8],
+ "resell_description": row[9],
+ "status": row[10],
+ "agiso_item_id": row[11],
+ "error_message": row[12],
+ "created_at": row[13]
+ }
+ for row in cursor.fetchall()
+ ]
+ except Exception as e:
+ logger.error(f"获取转卖记录失败: {e}")
+ return []
+
+ def get_resell_record_by_id(self, record_id: int) -> Optional[Dict[str, Any]]:
+ """根据ID获取转卖记录"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor,
+ """SELECT r.id, r.agiso_account_id, a.name as account_name, r.source_item_id,
+ r.source_title, r.source_price, r.source_image, r.resell_price,
+ r.resell_stock, r.resell_description, r.status, r.agiso_item_id,
+ r.error_message, r.created_at
+ FROM resell_records r
+ LEFT JOIN agiso_accounts a ON r.agiso_account_id = a.id
+ WHERE r.id = ?""",
+ (record_id,))
+ result = cursor.fetchone()
+ if result:
+ return {
+ "id": result[0],
+ "agiso_account_id": result[1],
+ "account_name": result[2],
+ "source_item_id": result[3],
+ "source_title": result[4],
+ "source_price": result[5],
+ "source_image": result[6],
+ "resell_price": result[7],
+ "resell_stock": result[8],
+ "resell_description": result[9],
+ "status": result[10],
+ "agiso_item_id": result[11],
+ "error_message": result[12],
+ "created_at": result[13]
+ }
+ return None
+ except Exception as e:
+ logger.error(f"获取转卖记录失败: {e}")
+ return None
+
+ # -------------------- 关键字操作 --------------------
+ def save_keywords(self, cookie_id: str, keywords: List[Tuple[str, str]]) -> bool:
+ """保存关键字列表,先删除旧数据再插入新数据(向后兼容方法)"""
+ # 转换为新格式(不包含item_id)
+ keywords_with_item_id = [(keyword, reply, None) for keyword, reply in keywords]
+ return self.save_keywords_with_item_id(cookie_id, keywords_with_item_id)
+
+ def save_keywords_with_item_id(self, cookie_id: str, keywords: List[Tuple[str, str, str]]) -> bool:
+ """保存关键字列表(包含商品ID),先删除旧数据再插入新数据"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+
+ # 先删除该cookie_id的所有关键字
+ self._execute_sql(cursor, "DELETE FROM keywords WHERE cookie_id = ?", (cookie_id,))
+
+ # 插入新关键字,使用INSERT OR REPLACE来处理可能的唯一约束冲突
+ for keyword, reply, item_id in keywords:
+ # 标准化item_id:空字符串转为NULL
+ normalized_item_id = item_id if item_id and item_id.strip() else None
+
+ try:
+ self._execute_sql(cursor,
+ "INSERT INTO keywords (cookie_id, keyword, reply, item_id) VALUES (?, ?, ?, ?)",
+ (cookie_id, keyword, reply, normalized_item_id))
+ except sqlite3.IntegrityError as ie:
+ # 如果遇到唯一约束冲突,记录详细错误信息
+ item_desc = f"商品ID: {normalized_item_id}" if normalized_item_id else "通用关键词"
+ logger.error(f"关键词唯一约束冲突: Cookie={cookie_id}, 关键词='{keyword}', {item_desc}")
+ raise ie
+
+ self.conn.commit()
+ logger.info(f"关键字保存成功: {cookie_id}, {len(keywords)}条")
+ return True
+ except Exception as e:
+ logger.error(f"关键字保存失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def save_text_keywords_only(self, cookie_id: str, keywords: List[Tuple[str, str, str]]) -> bool:
+ """保存文本关键字列表,只删除文本类型的关键词,保留图片关键词"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+
+ # 只删除该cookie_id的文本类型关键字,保留图片关键词
+ self._execute_sql(cursor,
+ "DELETE FROM keywords WHERE cookie_id = ? AND (type IS NULL OR type = 'text')",
+ (cookie_id,))
+
+ # 插入新的文本关键字
+ for keyword, reply, item_id in keywords:
+ # 标准化item_id:空字符串转为NULL
+ normalized_item_id = item_id if item_id and item_id.strip() else None
+
+ try:
+ self._execute_sql(cursor,
+ "INSERT INTO keywords (cookie_id, keyword, reply, item_id, type) VALUES (?, ?, ?, ?, 'text')",
+ (cookie_id, keyword, reply, normalized_item_id))
+ except sqlite3.IntegrityError as ie:
+ # 如果遇到唯一约束冲突,记录详细错误信息并回滚
+ item_desc = f"商品ID: {normalized_item_id}" if normalized_item_id else "通用关键词"
+ logger.error(f"关键词唯一约束冲突: Cookie={cookie_id}, 关键词='{keyword}', {item_desc}")
+ self.conn.rollback()
+ raise ie
+
+ self.conn.commit()
+ logger.info(f"文本关键字保存成功: {cookie_id}, {len(keywords)}条,图片关键词已保留")
+ return True
+ except sqlite3.IntegrityError:
+ # 唯一约束冲突,重新抛出异常让上层处理
+ raise
+ except Exception as e:
+ logger.error(f"文本关键字保存失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def get_keywords(self, cookie_id: str) -> List[Tuple[str, str]]:
+ """获取指定Cookie的关键字列表(向后兼容方法)"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "SELECT keyword, reply FROM keywords WHERE cookie_id = ?", (cookie_id,))
+ return [(row[0], row[1]) for row in cursor.fetchall()]
+ except Exception as e:
+ logger.error(f"获取关键字失败: {e}")
+ return []
+
+ def get_keywords_with_item_id(self, cookie_id: str) -> List[Tuple[str, str, str]]:
+ """获取指定Cookie的关键字列表(包含商品ID)"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "SELECT keyword, reply, item_id FROM keywords WHERE cookie_id = ?", (cookie_id,))
+ return [(row[0], row[1], row[2]) for row in cursor.fetchall()]
+ except Exception as e:
+ logger.error(f"获取关键字失败: {e}")
+ return []
+
+ def check_keyword_duplicate(self, cookie_id: str, keyword: str, item_id: str = None) -> bool:
+ """检查关键词是否重复"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ if item_id:
+ # 如果有商品ID,检查相同cookie_id、keyword、item_id的组合
+ self._execute_sql(cursor,
+ "SELECT COUNT(*) FROM keywords WHERE cookie_id = ? AND keyword = ? AND item_id = ?",
+ (cookie_id, keyword, item_id))
+ else:
+ # 如果没有商品ID,检查相同cookie_id、keyword且item_id为空的组合
+ self._execute_sql(cursor,
+ "SELECT COUNT(*) FROM keywords WHERE cookie_id = ? AND keyword = ? AND (item_id IS NULL OR item_id = '')",
+ (cookie_id, keyword))
+
+ count = cursor.fetchone()[0]
+ return count > 0
+ except Exception as e:
+ logger.error(f"检查关键词重复失败: {e}")
+ return False
+
+ def save_image_keyword(self, cookie_id: str, keyword: str, image_url: str, item_id: str = None) -> bool:
+ """保存图片关键词(调用前应先检查重复)"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+
+ # 标准化item_id:空字符串转为NULL
+ normalized_item_id = item_id if item_id and item_id.strip() else None
+
+ # 直接插入图片关键词(重复检查应在调用前完成)
+ self._execute_sql(cursor,
+ "INSERT INTO keywords (cookie_id, keyword, reply, item_id, type, image_url) VALUES (?, ?, ?, ?, ?, ?)",
+ (cookie_id, keyword, '', normalized_item_id, 'image', image_url))
+
+ self.conn.commit()
+ logger.info(f"图片关键词保存成功: {cookie_id}, 关键词: {keyword}, 图片: {image_url}")
+ return True
+ except Exception as e:
+ logger.error(f"图片关键词保存失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def get_keywords_with_type(self, cookie_id: str) -> List[Dict[str, any]]:
+ """获取指定Cookie的关键字列表(包含类型信息)"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor,
+ "SELECT keyword, reply, item_id, type, image_url FROM keywords WHERE cookie_id = ?",
+ (cookie_id,))
+
+ results = []
+ for row in cursor.fetchall():
+ keyword_data = {
+ 'keyword': row[0],
+ 'reply': row[1],
+ 'item_id': row[2],
+ 'type': row[3] or 'text', # 默认为text类型
+ 'image_url': row[4]
+ }
+ results.append(keyword_data)
+
+ return results
+ except Exception as e:
+ logger.error(f"获取关键字失败: {e}")
+ return []
+
+ def update_keyword_image_url(self, cookie_id: str, keyword: str, new_image_url: str) -> bool:
+ """更新关键词的图片URL"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+
+ # 更新图片URL
+ self._execute_sql(cursor,
+ "UPDATE keywords SET image_url = ? WHERE cookie_id = ? AND keyword = ? AND type = 'image'",
+ (new_image_url, cookie_id, keyword))
+
+ self.conn.commit()
+
+ # 检查是否有行被更新
+ if cursor.rowcount > 0:
+ logger.info(f"关键词图片URL更新成功: {cookie_id}, 关键词: {keyword}, 新URL: {new_image_url}")
+ return True
+ else:
+ logger.warning(f"未找到匹配的图片关键词: {cookie_id}, 关键词: {keyword}")
+ return False
+
+ except Exception as e:
+ logger.error(f"更新关键词图片URL失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def delete_keyword_by_index(self, cookie_id: str, index: int) -> bool:
+ """根据索引删除关键词"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+
+ # 先获取所有关键词
+ self._execute_sql(cursor,
+ "SELECT rowid FROM keywords WHERE cookie_id = ? ORDER BY rowid",
+ (cookie_id,))
+ rows = cursor.fetchall()
+
+ if 0 <= index < len(rows):
+ rowid = rows[index][0]
+ self._execute_sql(cursor, "DELETE FROM keywords WHERE rowid = ?", (rowid,))
+ self.conn.commit()
+ logger.info(f"删除关键词成功: {cookie_id}, 索引: {index}")
+ return True
+ else:
+ logger.warning(f"关键词索引超出范围: {index}")
+ return False
+
+ except Exception as e:
+ logger.error(f"删除关键词失败: {e}")
+ self.conn.rollback()
+ return False
+
+
+ def get_all_keywords(self, user_id: int = None) -> Dict[str, List[Tuple[str, str]]]:
+ """获取所有Cookie的关键字(支持用户隔离)"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ if user_id is not None:
+ cursor.execute("""
+ SELECT k.cookie_id, k.keyword, k.reply
+ FROM keywords k
+ JOIN cookies c ON k.cookie_id = c.id
+ WHERE c.user_id = ?
+ """, (user_id,))
+ else:
+ self._execute_sql(cursor, "SELECT cookie_id, keyword, reply FROM keywords")
+
+ result = {}
+ for row in cursor.fetchall():
+ cookie_id, keyword, reply = row
+ if cookie_id not in result:
+ result[cookie_id] = []
+ result[cookie_id].append((keyword, reply))
+
+ return result
+ except Exception as e:
+ logger.error(f"获取所有关键字失败: {e}")
+ return {}
+
+ def save_cookie_status(self, cookie_id: str, enabled: bool):
+ """保存Cookie的启用状态"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ INSERT OR REPLACE INTO cookie_status (cookie_id, enabled, updated_at)
+ VALUES (?, ?, CURRENT_TIMESTAMP)
+ ''', (cookie_id, enabled))
+ self.conn.commit()
+ logger.debug(f"保存Cookie状态: {cookie_id} -> {'启用' if enabled else '禁用'}")
+ except Exception as e:
+ logger.error(f"保存Cookie状态失败: {e}")
+ raise
+
+ def get_cookie_status(self, cookie_id: str) -> bool:
+ """获取Cookie的启用状态"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('SELECT enabled FROM cookie_status WHERE cookie_id = ?', (cookie_id,))
+ result = cursor.fetchone()
+ return bool(result[0]) if result else True # 默认启用
+ except Exception as e:
+ logger.error(f"获取Cookie状态失败: {e}")
+ return True # 出错时默认启用
+
+ def get_all_cookie_status(self) -> Dict[str, bool]:
+ """获取所有Cookie的启用状态"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('SELECT cookie_id, enabled FROM cookie_status')
+
+ result = {}
+ for row in cursor.fetchall():
+ cookie_id, enabled = row
+ result[cookie_id] = bool(enabled)
+
+ return result
+ except Exception as e:
+ logger.error(f"获取所有Cookie状态失败: {e}")
+ return {}
+
+ # -------------------- AI回复设置操作 --------------------
+ def save_ai_reply_settings(self, cookie_id: str, settings: dict) -> bool:
+ """保存AI回复设置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ INSERT OR REPLACE INTO ai_reply_settings
+ (cookie_id, ai_enabled, model_name, api_key, base_url,
+ max_discount_percent, max_discount_amount, max_bargain_rounds,
+ custom_prompts, refund_policy, updated_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+ ''', (
+ cookie_id,
+ settings.get('ai_enabled', False),
+ settings.get('model_name', 'qwen-plus'),
+ settings.get('api_key', ''),
+ settings.get('base_url', 'https://dashscope.aliyuncs.com/compatible-mode/v1'),
+ settings.get('max_discount_percent', 10),
+ settings.get('max_discount_amount', 100),
+ settings.get('max_bargain_rounds', 3),
+ settings.get('custom_prompts', ''),
+ settings.get('refund_policy', 'allow')
+ ))
+ self.conn.commit()
+ logger.debug(f"AI回复设置保存成功: {cookie_id}")
+ return True
+ except Exception as e:
+ logger.error(f"保存AI回复设置失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def get_ai_reply_settings(self, cookie_id: str) -> dict:
+ """获取AI回复设置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT ai_enabled, model_name, api_key, base_url,
+ max_discount_percent, max_discount_amount, max_bargain_rounds,
+ custom_prompts, refund_policy
+ FROM ai_reply_settings WHERE cookie_id = ?
+ ''', (cookie_id,))
+
+ result = cursor.fetchone()
+ if result:
+ return {
+ 'ai_enabled': bool(result[0]),
+ 'model_name': result[1] or 'qwen-plus',
+ 'api_key': result[2] or '',
+ 'base_url': result[3] or 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+ 'max_discount_percent': result[4],
+ 'max_discount_amount': result[5],
+ 'max_bargain_rounds': result[6],
+ 'custom_prompts': result[7],
+ 'refund_policy': result[8] or 'allow'
+ }
+ else:
+ # 使用系统全局默认设置
+ return self.get_ai_default_settings()
+ except Exception as e:
+ logger.error(f"获取AI回复设置失败: {e}")
+ return self.get_ai_default_settings()
+
+ def get_all_ai_reply_settings(self) -> Dict[str, dict]:
+ """获取所有账号的AI回复设置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT cookie_id, ai_enabled, model_name, api_key, base_url,
+ max_discount_percent, max_discount_amount, max_bargain_rounds,
+ custom_prompts, refund_policy
+ FROM ai_reply_settings
+ ''')
+
+ result = {}
+ for row in cursor.fetchall():
+ cookie_id = row[0]
+ result[cookie_id] = {
+ 'ai_enabled': bool(row[1]),
+ 'model_name': row[2],
+ 'api_key': row[3] or '',
+ 'base_url': row[4],
+ 'max_discount_percent': row[5],
+ 'max_discount_amount': row[6],
+ 'max_bargain_rounds': row[7],
+ 'custom_prompts': row[8],
+ 'refund_policy': row[9] or 'allow'
+ }
+
+ return result
+ except Exception as e:
+ logger.error(f"获取所有AI回复设置失败: {e}")
+ return {}
+
+ # -------------------- 默认回复操作 --------------------
+ def save_default_reply(self, cookie_id: str, enabled: bool, reply_content: str = None, reply_once: bool = False):
+ """保存默认回复设置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ INSERT OR REPLACE INTO default_replies (cookie_id, enabled, reply_content, reply_once, updated_at)
+ VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
+ ''', (cookie_id, enabled, reply_content, reply_once))
+ self.conn.commit()
+ logger.debug(f"保存默认回复设置: {cookie_id} -> {'启用' if enabled else '禁用'}, 只回复一次: {'是' if reply_once else '否'}")
+ except Exception as e:
+ logger.error(f"保存默认回复设置失败: {e}")
+ raise
+
+ def get_default_reply(self, cookie_id: str) -> Optional[Dict[str, any]]:
+ """获取指定账号的默认回复设置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT enabled, reply_content, reply_once FROM default_replies WHERE cookie_id = ?
+ ''', (cookie_id,))
+ result = cursor.fetchone()
+ if result:
+ enabled, reply_content, reply_once = result
+ return {
+ 'enabled': bool(enabled),
+ 'reply_content': reply_content or '',
+ 'reply_once': bool(reply_once) if reply_once is not None else False
+ }
+ return None
+ except Exception as e:
+ logger.error(f"获取默认回复设置失败: {e}")
+ return None
+
+ def get_all_default_replies(self) -> Dict[str, Dict[str, any]]:
+ """获取所有账号的默认回复设置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('SELECT cookie_id, enabled, reply_content, reply_once FROM default_replies')
+
+ result = {}
+ for row in cursor.fetchall():
+ cookie_id, enabled, reply_content, reply_once = row
+ result[cookie_id] = {
+ 'enabled': bool(enabled),
+ 'reply_content': reply_content or '',
+ 'reply_once': bool(reply_once) if reply_once is not None else False
+ }
+
+ return result
+ except Exception as e:
+ logger.error(f"获取所有默认回复设置失败: {e}")
+ return {}
+
+ def add_default_reply_record(self, cookie_id: str, chat_id: str):
+ """记录已回复的chat_id"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ INSERT OR IGNORE INTO default_reply_records (cookie_id, chat_id)
+ VALUES (?, ?)
+ ''', (cookie_id, chat_id))
+ self.conn.commit()
+ logger.debug(f"记录默认回复: {cookie_id} -> {chat_id}")
+ except Exception as e:
+ logger.error(f"记录默认回复失败: {e}")
+
+ def has_default_reply_record(self, cookie_id: str, chat_id: str) -> bool:
+ """检查是否已经回复过该chat_id"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT 1 FROM default_reply_records WHERE cookie_id = ? AND chat_id = ?
+ ''', (cookie_id, chat_id))
+ result = cursor.fetchone()
+ return result is not None
+ except Exception as e:
+ logger.error(f"检查默认回复记录失败: {e}")
+ return False
+
+ def clear_default_reply_records(self, cookie_id: str):
+ """清空指定账号的默认回复记录"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('DELETE FROM default_reply_records WHERE cookie_id = ?', (cookie_id,))
+ self.conn.commit()
+ logger.debug(f"清空默认回复记录: {cookie_id}")
+ except Exception as e:
+ logger.error(f"清空默认回复记录失败: {e}")
+
+ def delete_default_reply(self, cookie_id: str) -> bool:
+ """删除指定账号的默认回复设置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "DELETE FROM default_replies WHERE cookie_id = ?", (cookie_id,))
+ self.conn.commit()
+ logger.debug(f"删除默认回复设置: {cookie_id}")
+ return True
+ except Exception as e:
+ logger.error(f"删除默认回复设置失败: {e}")
+ self.conn.rollback()
+ return False
+
+ # -------------------- 通知渠道操作 --------------------
+ def create_notification_channel(self, name: str, channel_type: str, config: str, user_id: int = None) -> int:
+ """创建通知渠道"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ INSERT INTO notification_channels (name, type, config, user_id)
+ VALUES (?, ?, ?, ?)
+ ''', (name, channel_type, config, user_id))
+ self.conn.commit()
+ channel_id = cursor.lastrowid
+ logger.debug(f"创建通知渠道: {name} (ID: {channel_id})")
+ return channel_id
+ except Exception as e:
+ logger.error(f"创建通知渠道失败: {e}")
+ self.conn.rollback()
+ raise
+
+ def get_notification_channels(self, user_id: int = None) -> List[Dict[str, any]]:
+ """获取所有通知渠道"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ if user_id is not None:
+ cursor.execute('''
+ SELECT id, name, type, config, enabled, created_at, updated_at
+ FROM notification_channels
+ WHERE user_id = ?
+ ORDER BY created_at DESC
+ ''', (user_id,))
+ else:
+ cursor.execute('''
+ SELECT id, name, type, config, enabled, created_at, updated_at
+ FROM notification_channels
+ ORDER BY created_at DESC
+ ''')
+
+ channels = []
+ for row in cursor.fetchall():
+ channels.append({
+ 'id': row[0],
+ 'name': row[1],
+ 'type': row[2],
+ 'config': row[3],
+ 'enabled': bool(row[4]),
+ 'created_at': row[5],
+ 'updated_at': row[6]
+ })
+
+ return channels
+ except Exception as e:
+ logger.error(f"获取通知渠道失败: {e}")
+ return []
+
+ def get_notification_channel(self, channel_id: int) -> Optional[Dict[str, any]]:
+ """获取指定通知渠道"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT id, name, type, config, enabled, created_at, updated_at
+ FROM notification_channels WHERE id = ?
+ ''', (channel_id,))
+
+ row = cursor.fetchone()
+ if row:
+ return {
+ 'id': row[0],
+ 'name': row[1],
+ 'type': row[2],
+ 'config': row[3],
+ 'enabled': bool(row[4]),
+ 'created_at': row[5],
+ 'updated_at': row[6]
+ }
+ return None
+ except Exception as e:
+ logger.error(f"获取通知渠道失败: {e}")
+ return None
+
+ def update_notification_channel(self, channel_id: int, name: str, config: str, enabled: bool = True) -> bool:
+ """更新通知渠道"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ UPDATE notification_channels
+ SET name = ?, config = ?, enabled = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE id = ?
+ ''', (name, config, enabled, channel_id))
+ self.conn.commit()
+ logger.debug(f"更新通知渠道: {channel_id}")
+ return cursor.rowcount > 0
+ except Exception as e:
+ logger.error(f"更新通知渠道失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def delete_notification_channel(self, channel_id: int) -> bool:
+ """删除通知渠道"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "DELETE FROM notification_channels WHERE id = ?", (channel_id,))
+ self.conn.commit()
+ logger.debug(f"删除通知渠道: {channel_id}")
+ return cursor.rowcount > 0
+ except Exception as e:
+ logger.error(f"删除通知渠道失败: {e}")
+ self.conn.rollback()
+ return False
+
+ # -------------------- 消息通知配置操作 --------------------
+ def set_message_notification(self, cookie_id: str, channel_id: int, enabled: bool = True) -> bool:
+ """设置账号的消息通知"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ INSERT OR REPLACE INTO message_notifications (cookie_id, channel_id, enabled)
+ VALUES (?, ?, ?)
+ ''', (cookie_id, channel_id, enabled))
+ self.conn.commit()
+ logger.debug(f"设置消息通知: {cookie_id} -> {channel_id}")
+ return True
+ except Exception as e:
+ logger.error(f"设置消息通知失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def get_account_notifications(self, cookie_id: str) -> List[Dict[str, any]]:
+ """获取账号的通知配置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT mn.id, mn.channel_id, mn.enabled, nc.name, nc.type, nc.config
+ FROM message_notifications mn
+ JOIN notification_channels nc ON mn.channel_id = nc.id
+ WHERE mn.cookie_id = ? AND nc.enabled = 1
+ ORDER BY mn.id
+ ''', (cookie_id,))
+
+ notifications = []
+ for row in cursor.fetchall():
+ notifications.append({
+ 'id': row[0],
+ 'channel_id': row[1],
+ 'enabled': bool(row[2]),
+ 'channel_name': row[3],
+ 'channel_type': row[4],
+ 'channel_config': row[5]
+ })
+
+ return notifications
+ except Exception as e:
+ logger.error(f"获取账号通知配置失败: {e}")
+ return []
+
+ def get_all_message_notifications(self) -> Dict[str, List[Dict[str, any]]]:
+ """获取所有账号的通知配置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT mn.cookie_id, mn.id, mn.channel_id, mn.enabled, nc.name, nc.type, nc.config
+ FROM message_notifications mn
+ JOIN notification_channels nc ON mn.channel_id = nc.id
+ WHERE nc.enabled = 1
+ ORDER BY mn.cookie_id, mn.id
+ ''')
+
+ result = {}
+ for row in cursor.fetchall():
+ cookie_id = row[0]
+ if cookie_id not in result:
+ result[cookie_id] = []
+
+ result[cookie_id].append({
+ 'id': row[1],
+ 'channel_id': row[2],
+ 'enabled': bool(row[3]),
+ 'channel_name': row[4],
+ 'channel_type': row[5],
+ 'channel_config': row[6]
+ })
+
+ return result
+ except Exception as e:
+ logger.error(f"获取所有消息通知配置失败: {e}")
+ return {}
+
+ def delete_message_notification(self, notification_id: int) -> bool:
+ """删除消息通知配置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "DELETE FROM message_notifications WHERE id = ?", (notification_id,))
+ self.conn.commit()
+ logger.debug(f"删除消息通知配置: {notification_id}")
+ return cursor.rowcount > 0
+ except Exception as e:
+ logger.error(f"删除消息通知配置失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def delete_account_notifications(self, cookie_id: str) -> bool:
+ """删除账号的所有消息通知配置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "DELETE FROM message_notifications WHERE cookie_id = ?", (cookie_id,))
+ self.conn.commit()
+ logger.debug(f"删除账号通知配置: {cookie_id}")
+ return cursor.rowcount > 0
+ except Exception as e:
+ logger.error(f"删除账号通知配置失败: {e}")
+ self.conn.rollback()
+ return False
+
+ # -------------------- 备份和恢复操作 --------------------
+ def export_backup(self, user_id: int = None) -> Dict[str, any]:
+ """导出系统备份数据(支持用户隔离)"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ backup_data = {
+ 'version': '1.0',
+ 'timestamp': time.time(),
+ 'user_id': user_id,
+ 'data': {}
+ }
+
+ if user_id is not None:
+ # 用户级备份:只备份该用户的数据
+ # 备份用户的cookies
+ self._execute_sql(cursor, "SELECT * FROM cookies WHERE user_id = ?", (user_id,))
+ columns = [description[0] for description in cursor.description]
+ rows = cursor.fetchall()
+ backup_data['data']['cookies'] = {
+ 'columns': columns,
+ 'rows': [list(row) for row in rows]
+ }
+
+ # 备份用户cookies相关的其他数据
+ user_cookie_ids = [row[0] for row in rows] # 获取用户的cookie_id列表
+
+ if user_cookie_ids:
+ placeholders = ','.join(['?' for _ in user_cookie_ids])
+
+ # 备份关键字
+ cursor.execute(f"SELECT * FROM keywords WHERE cookie_id IN ({placeholders})", user_cookie_ids)
+ columns = [description[0] for description in cursor.description]
+ rows = cursor.fetchall()
+ backup_data['data']['keywords'] = {
+ 'columns': columns,
+ 'rows': [list(row) for row in rows]
+ }
+
+ # 备份其他相关表
+ related_tables = ['cookie_status', 'default_replies', 'message_notifications',
+ 'item_info', 'ai_reply_settings', 'ai_conversations']
+
+ for table in related_tables:
+ cursor.execute(f"SELECT * FROM {table} WHERE cookie_id IN ({placeholders})", user_cookie_ids)
+ columns = [description[0] for description in cursor.description]
+ rows = cursor.fetchall()
+ backup_data['data'][table] = {
+ 'columns': columns,
+ 'rows': [list(row) for row in rows]
+ }
+ else:
+ # 系统级备份:备份所有数据
+ tables = [
+ 'cookies', 'keywords', 'cookie_status', 'cards',
+ 'delivery_rules', 'default_replies', 'notification_channels',
+ 'message_notifications', 'system_settings', 'item_info',
+ 'ai_reply_settings', 'ai_conversations', 'ai_item_cache'
+ ]
+
+ for table in tables:
+ cursor.execute(f"SELECT * FROM {table}")
+ columns = [description[0] for description in cursor.description]
+ rows = cursor.fetchall()
+
+ backup_data['data'][table] = {
+ 'columns': columns,
+ 'rows': [list(row) for row in rows]
+ }
+
+ logger.info(f"导出备份成功,用户ID: {user_id}")
+ return backup_data
+
+ except Exception as e:
+ logger.error(f"导出备份失败: {e}")
+ raise
+
+ def import_backup(self, backup_data: Dict[str, any], user_id: int = None) -> bool:
+ """导入系统备份数据(支持用户隔离)"""
+ with self.lock:
+ try:
+ # 验证备份数据格式
+ if not isinstance(backup_data, dict) or 'data' not in backup_data:
+ raise ValueError("备份数据格式无效")
+
+ # 开始事务
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "BEGIN TRANSACTION")
+
+ if user_id is not None:
+ # 用户级导入:只清空该用户的数据
+ # 获取用户的cookie_id列表
+ self._execute_sql(cursor, "SELECT id FROM cookies WHERE user_id = ?", (user_id,))
+ user_cookie_ids = [row[0] for row in cursor.fetchall()]
+
+ if user_cookie_ids:
+ placeholders = ','.join(['?' for _ in user_cookie_ids])
+
+ # 删除用户相关数据
+ related_tables = ['message_notifications', 'default_replies', 'item_info',
+ 'cookie_status', 'keywords', 'ai_conversations', 'ai_reply_settings']
+
+ for table in related_tables:
+ cursor.execute(f"DELETE FROM {table} WHERE cookie_id IN ({placeholders})", user_cookie_ids)
+
+ # 删除用户的cookies
+ self._execute_sql(cursor, "DELETE FROM cookies WHERE user_id = ?", (user_id,))
+ else:
+ # 系统级导入:清空所有数据(除了用户和管理员密码)
+ tables = [
+ 'message_notifications', 'notification_channels', 'default_replies',
+ 'delivery_rules', 'cards', 'item_info', 'cookie_status', 'keywords',
+ 'ai_conversations', 'ai_reply_settings', 'ai_item_cache', 'cookies'
+ ]
+
+ for table in tables:
+ cursor.execute(f"DELETE FROM {table}")
+
+ # 清空系统设置(保留管理员密码)
+ self._execute_sql(cursor, "DELETE FROM system_settings WHERE key != 'admin_password_hash'")
+
+ # 导入数据
+ data = backup_data['data']
+ for table_name, table_data in data.items():
+ if table_name not in ['cookies', 'keywords', 'cookie_status', 'cards',
+ 'delivery_rules', 'default_replies', 'notification_channels',
+ 'message_notifications', 'system_settings', 'item_info',
+ 'ai_reply_settings', 'ai_conversations', 'ai_item_cache']:
+ continue
+
+ columns = table_data['columns']
+ rows = table_data['rows']
+
+ if not rows:
+ continue
+
+ # 如果是用户级导入,需要确保cookies表的user_id正确
+ if user_id is not None and table_name == 'cookies':
+ # 更新所有导入的cookies的user_id
+ updated_rows = []
+ for row in rows:
+ row_dict = dict(zip(columns, row))
+ row_dict['user_id'] = user_id
+ updated_rows.append([row_dict[col] for col in columns])
+ rows = updated_rows
+
+ # 构建插入语句
+ placeholders = ','.join(['?' for _ in columns])
+
+ if table_name == 'system_settings':
+ # 系统设置需要特殊处理,避免覆盖管理员密码
+ for row in rows:
+ if len(row) >= 1 and row[0] != 'admin_password_hash':
+ cursor.execute(f"INSERT INTO {table_name} ({','.join(columns)}) VALUES ({placeholders})", row)
+ else:
+ cursor.executemany(f"INSERT INTO {table_name} ({','.join(columns)}) VALUES ({placeholders})", rows)
+
+ # 提交事务
+ self.conn.commit()
+ logger.info("导入备份成功")
+ return True
+
+ except Exception as e:
+ logger.error(f"导入备份失败: {e}")
+ self.conn.rollback()
+ return False
+
+ # -------------------- 系统设置操作 --------------------
+ def get_system_setting(self, key: str) -> Optional[str]:
+ """获取系统设置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "SELECT value FROM system_settings WHERE key = ?", (key,))
+ result = cursor.fetchone()
+ return result[0] if result else None
+ except Exception as e:
+ logger.error(f"获取系统设置失败: {e}")
+ return None
+
+ def set_system_setting(self, key: str, value: str, description: str = None) -> bool:
+ """设置系统设置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ INSERT OR REPLACE INTO system_settings (key, value, description, updated_at)
+ VALUES (?, ?, ?, CURRENT_TIMESTAMP)
+ ''', (key, value, description))
+ self.conn.commit()
+ logger.debug(f"设置系统设置: {key}")
+ return True
+ except Exception as e:
+ logger.error(f"设置系统设置失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def get_ai_default_settings(self) -> dict:
+ """获取AI回复的全局默认设置(从 system_settings 表中读取)"""
+ all_settings = self.get_all_system_settings()
+ return {
+ 'ai_enabled': all_settings.get('ai_default_enabled', 'false').lower() == 'true',
+ 'model_name': all_settings.get('ai_default_model', 'qwen-plus'),
+ 'api_key': all_settings.get('ai_default_api_key', ''),
+ 'base_url': all_settings.get('ai_default_base_url', 'https://dashscope.aliyuncs.com/compatible-mode/v1'),
+ 'max_discount_percent': int(all_settings.get('ai_default_max_discount_percent', '10')),
+ 'max_discount_amount': int(all_settings.get('ai_default_max_discount_amount', '100')),
+ 'max_bargain_rounds': int(all_settings.get('ai_default_max_bargain_rounds', '3')),
+ 'custom_prompts': all_settings.get('ai_default_prompts', ''),
+ 'refund_policy': all_settings.get('ai_default_refund_policy', 'allow')
+ }
+
+ def get_all_system_settings(self) -> Dict[str, str]:
+ """获取所有系统设置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "SELECT key, value FROM system_settings")
+
+ settings = {}
+ for row in cursor.fetchall():
+ settings[row[0]] = row[1]
+
+ return settings
+ except Exception as e:
+ logger.error(f"获取所有系统设置失败: {e}")
+ return {}
+
+ # 管理员密码现在统一使用用户表管理,不再需要单独的方法
+
+ # ==================== 用户管理方法 ====================
+
+ def create_user(self, username: str, email: str, password: str, role: str = 'user') -> bool:
+ """创建新用户"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ password_hash = hashlib.sha256(password.encode()).hexdigest()
+
+ cursor.execute('''
+ INSERT INTO users (username, email, password_hash, role)
+ VALUES (?, ?, ?, ?)
+ ''', (username, email, password_hash, role))
+
+ self.conn.commit()
+ logger.info(f"创建用户成功: {username} ({email}), 角色: {role}")
+ return True
+ except sqlite3.IntegrityError as e:
+ logger.error(f"创建用户失败,用户名或邮箱已存在: {e}")
+ self.conn.rollback()
+ return False
+ except Exception as e:
+ logger.error(f"创建用户失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def get_user_by_username(self, username: str) -> Optional[Dict[str, Any]]:
+ """根据用户名获取用户信息"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT id, username, email, password_hash, is_active, created_at, updated_at, COALESCE(role, 'user') as role
+ FROM users WHERE username = ?
+ ''', (username,))
+
+ row = cursor.fetchone()
+ if row:
+ return {
+ 'id': row[0],
+ 'username': row[1],
+ 'email': row[2],
+ 'password_hash': row[3],
+ 'is_active': row[4],
+ 'created_at': row[5],
+ 'updated_at': row[6],
+ 'role': row[7]
+ }
+ return None
+ except Exception as e:
+ logger.error(f"获取用户信息失败: {e}")
+ return None
+
+ def get_user_by_email(self, email: str) -> Optional[Dict[str, Any]]:
+ """根据邮箱获取用户信息"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT id, username, email, password_hash, is_active, created_at, updated_at, COALESCE(role, 'user') as role
+ FROM users WHERE email = ?
+ ''', (email,))
+
+ row = cursor.fetchone()
+ if row:
+ return {
+ 'id': row[0],
+ 'username': row[1],
+ 'email': row[2],
+ 'password_hash': row[3],
+ 'is_active': row[4],
+ 'created_at': row[5],
+ 'updated_at': row[6],
+ 'role': row[7]
+ }
+ return None
+ except Exception as e:
+ logger.error(f"获取用户信息失败: {e}")
+ return None
+
+ def verify_user_password(self, username: str, password: str) -> bool:
+ """验证用户密码"""
+ user = self.get_user_by_username(username)
+ if not user:
+ return False
+
+ password_hash = hashlib.sha256(password.encode()).hexdigest()
+ return user['password_hash'] == password_hash and user['is_active']
+
+ def update_user_password(self, username: str, new_password: str) -> bool:
+ """更新用户密码"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ password_hash = hashlib.sha256(new_password.encode()).hexdigest()
+
+ cursor.execute('''
+ UPDATE users SET password_hash = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE username = ?
+ ''', (password_hash, username))
+
+ if cursor.rowcount > 0:
+ self.conn.commit()
+ logger.info(f"用户 {username} 密码更新成功")
+ return True
+ else:
+ logger.warning(f"用户 {username} 不存在,密码更新失败")
+ return False
+
+ except Exception as e:
+ logger.error(f"更新用户密码失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def update_user_email(self, username: str, new_email: str) -> bool:
+ """更新用户邮箱"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ UPDATE users SET email = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE username = ?
+ ''', (new_email, username))
+ if cursor.rowcount > 0:
+ self.conn.commit()
+ logger.info(f"用户 {username} 邮箱更新成功: {new_email}")
+ return True
+ return False
+ except Exception as e:
+ logger.error(f"更新用户邮箱失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def update_user_role(self, username: str, new_role: str) -> bool:
+ """更新用户角色"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ UPDATE users SET role = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE username = ?
+ ''', (new_role, username))
+ if cursor.rowcount > 0:
+ self.conn.commit()
+ logger.info(f"用户 {username} 角色更新成功: {new_role}")
+ return True
+ return False
+ except Exception as e:
+ logger.error(f"更新用户角色失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def generate_verification_code(self) -> str:
+ """生成6位数字验证码"""
+ return ''.join(random.choices(string.digits, k=6))
+
+ def generate_captcha(self) -> Tuple[str, str]:
+ """生成图形验证码
+ 返回: (验证码文本, base64编码的图片)
+ """
+ try:
+ # 生成4位随机数字验证码
+ chars = string.digits
+ captcha_text = ''.join(random.choices(chars, k=4))
+
+ # 创建图片
+ width, height = 120, 40
+ image = Image.new('RGB', (width, height), color='white')
+ draw = ImageDraw.Draw(image)
+
+ # 尝试使用系统字体,如果失败则使用默认字体
+ try:
+ # Windows系统字体
+ font = ImageFont.truetype("arial.ttf", 20)
+ except:
+ try:
+ # 备用字体
+ font = ImageFont.truetype("C:/Windows/Fonts/arial.ttf", 20)
+ except:
+ # 使用默认字体
+ font = ImageFont.load_default()
+
+ # 绘制验证码文本
+ for i, char in enumerate(captcha_text):
+ # 随机颜色
+ color = (
+ random.randint(0, 100),
+ random.randint(0, 100),
+ random.randint(0, 100)
+ )
+
+ # 随机位置(稍微偏移)
+ x = 20 + i * 20 + random.randint(-3, 3)
+ y = 8 + random.randint(-3, 3)
+
+ draw.text((x, y), char, font=font, fill=color)
+
+ # 添加干扰线
+ for _ in range(3):
+ start = (random.randint(0, width), random.randint(0, height))
+ end = (random.randint(0, width), random.randint(0, height))
+ draw.line([start, end], fill=(random.randint(100, 200), random.randint(100, 200), random.randint(100, 200)), width=1)
+
+ # 添加干扰点
+ for _ in range(20):
+ x = random.randint(0, width)
+ y = random.randint(0, height)
+ draw.point((x, y), fill=(random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)))
+
+ # 转换为base64
+ buffer = io.BytesIO()
+ image.save(buffer, format='PNG')
+ img_base64 = base64.b64encode(buffer.getvalue()).decode()
+
+ return captcha_text, f"data:image/png;base64,{img_base64}"
+
+ except Exception as e:
+ logger.error(f"生成图形验证码失败: {e}")
+ # 返回简单的文本验证码作为备用
+ simple_code = ''.join(random.choices(string.digits, k=4))
+ return simple_code, ""
+
+ def save_captcha(self, session_id: str, captcha_text: str, expires_minutes: int = 5) -> bool:
+ """保存图形验证码"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ expires_at = time.time() + (expires_minutes * 60)
+
+ # 删除该session的旧验证码
+ cursor.execute('DELETE FROM captcha_codes WHERE session_id = ?', (session_id,))
+
+ cursor.execute('''
+ INSERT INTO captcha_codes (session_id, code, expires_at)
+ VALUES (?, ?, ?)
+ ''', (session_id, captcha_text.upper(), expires_at))
+
+ self.conn.commit()
+ logger.debug(f"保存图形验证码成功: {session_id}")
+ return True
+ except Exception as e:
+ logger.error(f"保存图形验证码失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def verify_captcha(self, session_id: str, user_input: str) -> bool:
+ """验证图形验证码"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ current_time = time.time()
+
+ # 查找有效的验证码
+ cursor.execute('''
+ SELECT id FROM captcha_codes
+ WHERE session_id = ? AND code = ? AND expires_at > ?
+ ORDER BY created_at DESC LIMIT 1
+ ''', (session_id, user_input.upper(), current_time))
+
+ row = cursor.fetchone()
+ if row:
+ # 删除已使用的验证码
+ cursor.execute('DELETE FROM captcha_codes WHERE id = ?', (row[0],))
+ self.conn.commit()
+ logger.debug(f"图形验证码验证成功: {session_id}")
+ return True
+ else:
+ logger.warning(f"图形验证码验证失败: {session_id} - {user_input}")
+ return False
+ except Exception as e:
+ logger.error(f"验证图形验证码失败: {e}")
+ return False
+
+ def save_verification_code(self, email: str, code: str, code_type: str = 'register', expires_minutes: int = 10) -> bool:
+ """保存邮箱验证码"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ expires_at = time.time() + (expires_minutes * 60)
+
+ cursor.execute('''
+ INSERT INTO email_verifications (email, code, type, expires_at)
+ VALUES (?, ?, ?, ?)
+ ''', (email, code, code_type, expires_at))
+
+ self.conn.commit()
+ logger.info(f"保存验证码成功: {email} ({code_type})")
+ return True
+ except Exception as e:
+ logger.error(f"保存验证码失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def verify_email_code(self, email: str, code: str, code_type: str = 'register') -> bool:
+ """验证邮箱验证码"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ current_time = time.time()
+
+ # 查找有效的验证码
+ cursor.execute('''
+ SELECT id FROM email_verifications
+ WHERE email = ? AND code = ? AND type = ? AND expires_at > ? AND used = FALSE
+ ORDER BY created_at DESC LIMIT 1
+ ''', (email, code, code_type, current_time))
+
+ row = cursor.fetchone()
+ if row:
+ # 标记验证码为已使用
+ cursor.execute('''
+ UPDATE email_verifications SET used = TRUE WHERE id = ?
+ ''', (row[0],))
+ self.conn.commit()
+ logger.info(f"验证码验证成功: {email} ({code_type})")
+ return True
+ else:
+ logger.warning(f"验证码验证失败: {email} - {code} ({code_type})")
+ return False
+ except Exception as e:
+ logger.error(f"验证邮箱验证码失败: {e}")
+ return False
+
+ async def send_verification_email(self, email: str, code: str) -> bool:
+ """发送验证码邮件(支持SMTP和API两种方式)"""
+ try:
+ subject = "闲鱼自动回复系统 - 邮箱验证码"
+ # 使用简单的纯文本邮件内容
+ text_content = f"""【闲鱼自动回复系统】邮箱验证码
+
+您好!
+
+感谢您使用闲鱼自动回复系统。为了确保账户安全,请使用以下验证码完成邮箱验证:
+
+验证码:{code}
+
+重要提醒:
+• 验证码有效期为 10 分钟,请及时使用
+• 请勿将验证码分享给任何人
+• 如非本人操作,请忽略此邮件
+• 系统不会主动索要您的验证码
+
+如果您在使用过程中遇到任何问题,请联系我们的技术支持团队。
+感谢您选择闲鱼自动回复系统!
+
+---
+此邮件由系统自动发送,请勿直接回复
+© 2025 闲鱼自动回复系统"""
+
+ # 从系统设置读取SMTP配置
+ try:
+ smtp_server = self.get_system_setting('smtp_server') or ''
+ smtp_port = int(self.get_system_setting('smtp_port') or 0)
+ smtp_user = self.get_system_setting('smtp_user') or ''
+ smtp_password = self.get_system_setting('smtp_password') or ''
+ smtp_from = (self.get_system_setting('smtp_from') or '').strip() or smtp_user
+ smtp_use_tls = (self.get_system_setting('smtp_use_tls') or 'true').lower() == 'true'
+ smtp_use_ssl = (self.get_system_setting('smtp_use_ssl') or 'false').lower() == 'true'
+ except Exception as e:
+ logger.error(f"读取SMTP系统设置失败: {e}")
+ # 如果读取配置失败,使用API方式
+ return await self._send_email_via_api(email, subject, text_content)
+
+ # 检查SMTP配置是否完整
+ if smtp_server and smtp_port and smtp_user and smtp_password:
+ # 配置完整,使用SMTP方式发送
+ logger.info(f"使用SMTP方式发送验证码邮件: {email}")
+ return await self._send_email_via_smtp(email, subject, text_content,
+ smtp_server, smtp_port, smtp_user,
+ smtp_password, smtp_from, smtp_use_tls, smtp_use_ssl)
+ else:
+ # 配置不完整,使用API方式发送
+ logger.info(f"SMTP配置不完整,使用API方式发送验证码邮件: {email}")
+ return await self._send_email_via_api(email, subject, text_content)
+
+ except Exception as e:
+ logger.error(f"发送验证码邮件异常: {e}")
+ return False
+
+ async def _send_email_via_smtp(self, email: str, subject: str, text_content: str,
+ smtp_server: str, smtp_port: int, smtp_user: str,
+ smtp_password: str, smtp_from: str, smtp_use_tls: bool, smtp_use_ssl: bool) -> bool:
+ """使用SMTP方式发送邮件"""
+ try:
+ import smtplib
+ from email.mime.text import MIMEText
+ from email.mime.multipart import MIMEMultipart
+
+ msg = MIMEMultipart()
+ msg['Subject'] = subject
+ msg['From'] = smtp_from
+ msg['To'] = email
+
+ msg.attach(MIMEText(text_content, 'plain', 'utf-8'))
+
+ if smtp_use_ssl:
+ server = smtplib.SMTP_SSL(smtp_server, smtp_port)
+ else:
+ server = smtplib.SMTP(smtp_server, smtp_port)
+
+ server.ehlo()
+ if smtp_use_tls and not smtp_use_ssl:
+ server.starttls()
+ server.ehlo()
+
+ server.login(smtp_user, smtp_password)
+ server.sendmail(smtp_user, [email], msg.as_string())
+ server.quit()
+
+ logger.info(f"验证码邮件发送成功(SMTP): {email}")
+ return True
+ except Exception as e:
+ logger.error(f"SMTP发送验证码邮件失败: {e}")
+ # SMTP发送失败,尝试使用API方式
+ logger.info(f"SMTP发送失败,尝试使用API方式发送: {email}")
+ return await self._send_email_via_api(email, subject, text_content)
+
+ async def _send_email_via_api(self, email: str, subject: str, text_content: str) -> bool:
+ """使用API方式发送邮件"""
+ try:
+ import aiohttp
+
+ # 使用GET请求发送邮件
+ api_url = "https://dy.zhinianboke.com/api/emailSend"
+ params = {
+ 'subject': subject,
+ 'receiveUser': email,
+ 'sendHtml': text_content
+ }
+
+ async with aiohttp.ClientSession() as session:
+ try:
+ logger.info(f"使用API发送验证码邮件: {email}")
+ async with session.get(api_url, params=params, timeout=15) as response:
+ response_text = await response.text()
+ logger.info(f"邮件API响应: {response.status}")
+
+ if response.status == 200:
+ logger.info(f"验证码邮件发送成功(API): {email}")
+ return True
+ else:
+ logger.error(f"API发送验证码邮件失败: {email}, 状态码: {response.status}, 响应: {response_text[:200]}")
+ return False
+ except Exception as e:
+ logger.error(f"API邮件发送异常: {email}, 错误: {e}")
+ return False
+ except Exception as e:
+ logger.error(f"API邮件发送方法异常: {e}")
+ return False
+
+ # ==================== 卡券管理方法 ====================
+
+ def create_card(self, name: str, card_type: str, api_config=None,
+ text_content: str = None, data_content: str = None, image_url: str = None,
+ description: str = None, enabled: bool = True, delay_seconds: int = 0,
+ is_multi_spec: bool = False, spec_name: str = None, spec_value: str = None,
+ user_id: int = None):
+ """创建新卡券(支持多规格)"""
+ with self.lock:
+ try:
+ # 验证多规格参数
+ if is_multi_spec:
+ if not spec_name or not spec_value:
+ raise ValueError("多规格卡券必须提供规格名称和规格值")
+
+ # 检查唯一性:卡券名称+规格名称+规格值
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT COUNT(*) FROM cards
+ WHERE name = ? AND spec_name = ? AND spec_value = ? AND user_id = ?
+ ''', (name, spec_name, spec_value, user_id))
+
+ if cursor.fetchone()[0] > 0:
+ raise ValueError(f"卡券已存在:{name} - {spec_name}:{spec_value}")
+ else:
+ # 检查唯一性:仅卡券名称
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT COUNT(*) FROM cards
+ WHERE name = ? AND (is_multi_spec = 0 OR is_multi_spec IS NULL) AND user_id = ?
+ ''', (name, user_id))
+
+ if cursor.fetchone()[0] > 0:
+ raise ValueError(f"卡券名称已存在:{name}")
+
+ # 处理api_config参数 - 如果是字典则转换为JSON字符串
+ api_config_str = None
+ if api_config is not None:
+ if isinstance(api_config, dict):
+ import json
+ api_config_str = json.dumps(api_config)
+ else:
+ api_config_str = str(api_config)
+
+ cursor.execute('''
+ INSERT INTO cards (name, type, api_config, text_content, data_content, image_url,
+ description, enabled, delay_seconds, is_multi_spec,
+ spec_name, spec_value, user_id)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ ''', (name, card_type, api_config_str, text_content, data_content, image_url,
+ description, enabled, delay_seconds, is_multi_spec,
+ spec_name, spec_value, user_id))
+ self.conn.commit()
+ card_id = cursor.lastrowid
+
+ if is_multi_spec:
+ logger.info(f"创建多规格卡券成功: {name} - {spec_name}:{spec_value} (ID: {card_id})")
+ else:
+ logger.info(f"创建卡券成功: {name} (ID: {card_id})")
+ return card_id
+ except Exception as e:
+ logger.error(f"创建卡券失败: {e}")
+ raise
+
+ def get_all_cards(self, user_id: int = None):
+ """获取所有卡券(支持用户隔离)"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ if user_id is not None:
+ cursor.execute('''
+ SELECT id, name, type, api_config, text_content, data_content, image_url,
+ description, enabled, delay_seconds, is_multi_spec,
+ spec_name, spec_value, created_at, updated_at
+ FROM cards
+ WHERE user_id = ?
+ ORDER BY created_at DESC
+ ''', (user_id,))
+ else:
+ cursor.execute('''
+ SELECT id, name, type, api_config, text_content, data_content, image_url,
+ description, enabled, delay_seconds, is_multi_spec,
+ spec_name, spec_value, created_at, updated_at
+ FROM cards
+ ORDER BY created_at DESC
+ ''')
+
+ cards = []
+ for row in cursor.fetchall():
+ # 解析api_config JSON字符串
+ api_config = row[3]
+ if api_config:
+ try:
+ import json
+ api_config = json.loads(api_config)
+ except (json.JSONDecodeError, TypeError):
+ # 如果解析失败,保持原始字符串
+ pass
+
+ cards.append({
+ 'id': row[0],
+ 'name': row[1],
+ 'type': row[2],
+ 'api_config': api_config,
+ 'text_content': row[4],
+ 'data_content': row[5],
+ 'image_url': row[6],
+ 'description': row[7],
+ 'enabled': bool(row[8]),
+ 'delay_seconds': row[9] or 0,
+ 'is_multi_spec': bool(row[10]) if row[10] is not None else False,
+ 'spec_name': row[11],
+ 'spec_value': row[12],
+ 'created_at': row[13],
+ 'updated_at': row[14]
+ })
+
+ return cards
+ except Exception as e:
+ logger.error(f"获取卡券列表失败: {e}")
+ return []
+
+ def get_card_by_id(self, card_id: int, user_id: int = None):
+ """根据ID获取卡券(支持用户隔离)"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ if user_id is not None:
+ cursor.execute('''
+ SELECT id, name, type, api_config, text_content, data_content, image_url,
+ description, enabled, delay_seconds, is_multi_spec,
+ spec_name, spec_value, created_at, updated_at
+ FROM cards WHERE id = ? AND user_id = ?
+ ''', (card_id, user_id))
+ else:
+ cursor.execute('''
+ SELECT id, name, type, api_config, text_content, data_content, image_url,
+ description, enabled, delay_seconds, is_multi_spec,
+ spec_name, spec_value, created_at, updated_at
+ FROM cards WHERE id = ?
+ ''', (card_id,))
+
+ row = cursor.fetchone()
+ if row:
+ # 解析api_config JSON字符串
+ api_config = row[3]
+ if api_config:
+ try:
+ import json
+ api_config = json.loads(api_config)
+ except (json.JSONDecodeError, TypeError):
+ # 如果解析失败,保持原始字符串
+ pass
+
+ return {
+ 'id': row[0],
+ 'name': row[1],
+ 'type': row[2],
+ 'api_config': api_config,
+ 'text_content': row[4],
+ 'data_content': row[5],
+ 'image_url': row[6],
+ 'description': row[7],
+ 'enabled': bool(row[8]),
+ 'delay_seconds': row[9] or 0,
+ 'is_multi_spec': bool(row[10]) if row[10] is not None else False,
+ 'spec_name': row[11],
+ 'spec_value': row[12],
+ 'created_at': row[13],
+ 'updated_at': row[14]
+ }
+ return None
+ except Exception as e:
+ logger.error(f"获取卡券失败: {e}")
+ return None
+
+ def update_card(self, card_id: int, name: str = None, card_type: str = None,
+ api_config=None, text_content: str = None, data_content: str = None,
+ image_url: str = None, description: str = None, enabled: bool = None,
+ delay_seconds: int = None, is_multi_spec: bool = None, spec_name: str = None,
+ spec_value: str = None):
+ """更新卡券"""
+ with self.lock:
+ try:
+ # 处理api_config参数
+ api_config_str = None
+ if api_config is not None:
+ if isinstance(api_config, dict):
+ import json
+ api_config_str = json.dumps(api_config)
+ else:
+ api_config_str = str(api_config)
+
+ cursor = self.conn.cursor()
+
+ # 构建更新语句
+ update_fields = []
+ params = []
+
+ if name is not None:
+ update_fields.append("name = ?")
+ params.append(name)
+ if card_type is not None:
+ update_fields.append("type = ?")
+ params.append(card_type)
+ if api_config_str is not None:
+ update_fields.append("api_config = ?")
+ params.append(api_config_str)
+ if text_content is not None:
+ update_fields.append("text_content = ?")
+ params.append(text_content)
+ if data_content is not None:
+ update_fields.append("data_content = ?")
+ params.append(data_content)
+ if image_url is not None:
+ update_fields.append("image_url = ?")
+ params.append(image_url)
+ if description is not None:
+ update_fields.append("description = ?")
+ params.append(description)
+ if enabled is not None:
+ update_fields.append("enabled = ?")
+ params.append(enabled)
+ if delay_seconds is not None:
+ update_fields.append("delay_seconds = ?")
+ params.append(delay_seconds)
+ if is_multi_spec is not None:
+ update_fields.append("is_multi_spec = ?")
+ params.append(is_multi_spec)
+ if spec_name is not None:
+ update_fields.append("spec_name = ?")
+ params.append(spec_name)
+ if spec_value is not None:
+ update_fields.append("spec_value = ?")
+ params.append(spec_value)
+
+ if not update_fields:
+ return True # 没有需要更新的字段
+
+ update_fields.append("updated_at = CURRENT_TIMESTAMP")
+ params.append(card_id)
+
+ sql = f"UPDATE cards SET {', '.join(update_fields)} WHERE id = ?"
+ self._execute_sql(cursor, sql, params)
+
+ if cursor.rowcount > 0:
+ self.conn.commit()
+ logger.info(f"更新卡券成功: ID {card_id}")
+ return True
+ else:
+ return False # 没有找到对应的记录
+
+ except Exception as e:
+ logger.error(f"更新卡券失败: {e}")
+ self.conn.rollback()
+ raise
+
+ def update_card_image_url(self, card_id: int, new_image_url: str) -> bool:
+ """更新卡券的图片URL"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+
+ # 更新图片URL
+ self._execute_sql(cursor,
+ "UPDATE cards SET image_url = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ? AND type = 'image'",
+ (new_image_url, card_id))
+
+ self.conn.commit()
+
+ # 检查是否有行被更新
+ if cursor.rowcount > 0:
+ logger.info(f"卡券图片URL更新成功: 卡券ID: {card_id}, 新URL: {new_image_url}")
+ return True
+ else:
+ logger.warning(f"未找到匹配的图片卡券: 卡券ID: {card_id}")
+ return False
+
+ except Exception as e:
+ logger.error(f"更新卡券图片URL失败: {e}")
+ self.conn.rollback()
+ return False
+
+ # ==================== 自动发货规则方法 ====================
+
+ def create_delivery_rule(self, keyword: str, card_id: int, delivery_count: int = 1,
+ enabled: bool = True, description: str = None, user_id: int = None):
+ """创建发货规则"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ INSERT INTO delivery_rules (keyword, card_id, delivery_count, enabled, description, user_id)
+ VALUES (?, ?, ?, ?, ?, ?)
+ ''', (keyword, card_id, delivery_count, enabled, description, user_id))
+ self.conn.commit()
+ rule_id = cursor.lastrowid
+ logger.info(f"创建发货规则成功: {keyword} -> 卡券ID {card_id} (规则ID: {rule_id})")
+ return rule_id
+ except Exception as e:
+ logger.error(f"创建发货规则失败: {e}")
+ raise
+
+ def get_all_delivery_rules(self, user_id: int = None):
+ """获取所有发货规则"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ if user_id is not None:
+ cursor.execute('''
+ SELECT dr.id, dr.keyword, dr.card_id, dr.delivery_count, dr.enabled,
+ dr.description, dr.delivery_times, dr.created_at, dr.updated_at,
+ c.name as card_name, c.type as card_type,
+ c.is_multi_spec, c.spec_name, c.spec_value
+ FROM delivery_rules dr
+ LEFT JOIN cards c ON dr.card_id = c.id
+ WHERE dr.user_id = ?
+ ORDER BY dr.created_at DESC
+ ''', (user_id,))
+ else:
+ cursor.execute('''
+ SELECT dr.id, dr.keyword, dr.card_id, dr.delivery_count, dr.enabled,
+ dr.description, dr.delivery_times, dr.created_at, dr.updated_at,
+ c.name as card_name, c.type as card_type,
+ c.is_multi_spec, c.spec_name, c.spec_value
+ FROM delivery_rules dr
+ LEFT JOIN cards c ON dr.card_id = c.id
+ ORDER BY dr.created_at DESC
+ ''')
+
+ rules = []
+ for row in cursor.fetchall():
+ rules.append({
+ 'id': row[0],
+ 'keyword': row[1],
+ 'card_id': row[2],
+ 'delivery_count': row[3],
+ 'enabled': bool(row[4]),
+ 'description': row[5],
+ 'delivery_times': row[6],
+ 'created_at': row[7],
+ 'updated_at': row[8],
+ 'card_name': row[9],
+ 'card_type': row[10],
+ 'is_multi_spec': bool(row[11]) if row[11] is not None else False,
+ 'spec_name': row[12],
+ 'spec_value': row[13]
+ })
+
+ return rules
+ except Exception as e:
+ logger.error(f"获取发货规则列表失败: {e}")
+ return []
+
+ def get_delivery_rules_by_keyword(self, keyword: str):
+ """根据关键字获取匹配的发货规则"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ # 使用更灵活的匹配方式:既支持商品内容包含关键字,也支持关键字包含在商品内容中
+ cursor.execute('''
+ SELECT dr.id, dr.keyword, dr.card_id, dr.delivery_count, dr.enabled,
+ dr.description, dr.delivery_times,
+ c.name as card_name, c.type as card_type, c.api_config,
+ c.text_content, c.data_content, c.image_url, c.enabled as card_enabled, c.description as card_description,
+ c.delay_seconds as card_delay_seconds
+ FROM delivery_rules dr
+ LEFT JOIN cards c ON dr.card_id = c.id
+ WHERE dr.enabled = 1 AND c.enabled = 1
+ AND (? LIKE '%' || dr.keyword || '%' OR dr.keyword LIKE '%' || ? || '%')
+ ORDER BY
+ CASE
+ WHEN ? LIKE '%' || dr.keyword || '%' THEN LENGTH(dr.keyword)
+ ELSE LENGTH(dr.keyword) / 2
+ END DESC,
+ dr.id ASC
+ ''', (keyword, keyword, keyword))
+
+ rules = []
+ for row in cursor.fetchall():
+ # 解析api_config JSON字符串
+ api_config = row[9]
+ if api_config:
+ try:
+ import json
+ api_config = json.loads(api_config)
+ except (json.JSONDecodeError, TypeError):
+ # 如果解析失败,保持原始字符串
+ pass
+
+ rules.append({
+ 'id': row[0],
+ 'keyword': row[1],
+ 'card_id': row[2],
+ 'delivery_count': row[3],
+ 'enabled': bool(row[4]),
+ 'description': row[5],
+ 'delivery_times': row[6],
+ 'card_name': row[7],
+ 'card_type': row[8],
+ 'api_config': api_config, # 修复字段名
+ 'text_content': row[10],
+ 'data_content': row[11],
+ 'image_url': row[12],
+ 'card_enabled': bool(row[13]),
+ 'card_description': row[14], # 卡券备注信息
+ 'card_delay_seconds': row[15] or 0 # 延时秒数
+ })
+
+ return rules
+ except Exception as e:
+ logger.error(f"根据关键字获取发货规则失败: {e}")
+ return []
+
+ def get_delivery_rule_by_id(self, rule_id: int, user_id: int = None):
+ """根据ID获取发货规则(支持用户隔离)"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ if user_id is not None:
+ self._execute_sql(cursor, '''
+ SELECT dr.id, dr.keyword, dr.card_id, dr.delivery_count, dr.enabled,
+ dr.description, dr.delivery_times, dr.created_at, dr.updated_at,
+ c.name as card_name, c.type as card_type
+ FROM delivery_rules dr
+ LEFT JOIN cards c ON dr.card_id = c.id
+ WHERE dr.id = ? AND dr.user_id = ?
+ ''', (rule_id, user_id))
+ else:
+ self._execute_sql(cursor, '''
+ SELECT dr.id, dr.keyword, dr.card_id, dr.delivery_count, dr.enabled,
+ dr.description, dr.delivery_times, dr.created_at, dr.updated_at,
+ c.name as card_name, c.type as card_type
+ FROM delivery_rules dr
+ LEFT JOIN cards c ON dr.card_id = c.id
+ WHERE dr.id = ?
+ ''', (rule_id,))
+
+ row = cursor.fetchone()
+ if row:
+ return {
+ 'id': row[0],
+ 'keyword': row[1],
+ 'card_id': row[2],
+ 'delivery_count': row[3],
+ 'enabled': bool(row[4]),
+ 'description': row[5],
+ 'delivery_times': row[6],
+ 'created_at': row[7],
+ 'updated_at': row[8],
+ 'card_name': row[9],
+ 'card_type': row[10]
+ }
+ return None
+ except Exception as e:
+ logger.error(f"获取发货规则失败: {e}")
+ return None
+
+ def update_delivery_rule(self, rule_id: int, keyword: str = None, card_id: int = None,
+ delivery_count: int = None, enabled: bool = None,
+ description: str = None, user_id: int = None):
+ """更新发货规则(支持用户隔离)"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+
+ # 构建更新语句
+ update_fields = []
+ params = []
+
+ if keyword is not None:
+ update_fields.append("keyword = ?")
+ params.append(keyword)
+ if card_id is not None:
+ update_fields.append("card_id = ?")
+ params.append(card_id)
+ if delivery_count is not None:
+ update_fields.append("delivery_count = ?")
+ params.append(delivery_count)
+ if enabled is not None:
+ update_fields.append("enabled = ?")
+ params.append(enabled)
+ if description is not None:
+ update_fields.append("description = ?")
+ params.append(description)
+
+ if not update_fields:
+ return True # 没有需要更新的字段
+
+ update_fields.append("updated_at = CURRENT_TIMESTAMP")
+ params.append(rule_id)
+
+ if user_id is not None:
+ params.append(user_id)
+ sql = f"UPDATE delivery_rules SET {', '.join(update_fields)} WHERE id = ? AND user_id = ?"
+ else:
+ sql = f"UPDATE delivery_rules SET {', '.join(update_fields)} WHERE id = ?"
+
+ self._execute_sql(cursor, sql, params)
+
+ if cursor.rowcount > 0:
+ self.conn.commit()
+ logger.info(f"更新发货规则成功: ID {rule_id}")
+ return True
+ else:
+ return False # 没有找到对应的记录
+
+ except Exception as e:
+ logger.error(f"更新发货规则失败: {e}")
+ self.conn.rollback()
+ raise
+
+ def increment_delivery_times(self, rule_id: int):
+ """增加发货次数"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ UPDATE delivery_rules
+ SET delivery_times = delivery_times + 1, updated_at = CURRENT_TIMESTAMP
+ WHERE id = ?
+ ''', (rule_id,))
+ self.conn.commit()
+ logger.debug(f"发货规则 {rule_id} 发货次数已增加")
+ except Exception as e:
+ logger.error(f"更新发货次数失败: {e}")
+
+ def get_delivery_rules_by_keyword_and_spec(self, keyword: str, spec_name: str = None, spec_value: str = None):
+ """根据关键字和规格信息获取匹配的发货规则(支持多规格)"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+
+ # 优先匹配:卡券名称+规格名称+规格值
+ if spec_name and spec_value:
+ cursor.execute('''
+ SELECT dr.id, dr.keyword, dr.card_id, dr.delivery_count, dr.enabled,
+ dr.description, dr.delivery_times,
+ c.name as card_name, c.type as card_type, c.api_config,
+ c.text_content, c.data_content, c.enabled as card_enabled,
+ c.description as card_description, c.delay_seconds as card_delay_seconds,
+ c.is_multi_spec, c.spec_name, c.spec_value
+ FROM delivery_rules dr
+ LEFT JOIN cards c ON dr.card_id = c.id
+ WHERE dr.enabled = 1 AND c.enabled = 1
+ AND (? LIKE '%' || dr.keyword || '%' OR dr.keyword LIKE '%' || ? || '%')
+ AND c.is_multi_spec = 1 AND c.spec_name = ? AND c.spec_value = ?
+ ORDER BY
+ CASE
+ WHEN ? LIKE '%' || dr.keyword || '%' THEN LENGTH(dr.keyword)
+ ELSE LENGTH(dr.keyword) / 2
+ END DESC,
+ dr.delivery_times ASC
+ ''', (keyword, keyword, spec_name, spec_value, keyword))
+
+ rules = []
+ for row in cursor.fetchall():
+ # 解析api_config JSON字符串
+ api_config = row[9]
+ if api_config:
+ try:
+ import json
+ api_config = json.loads(api_config)
+ except (json.JSONDecodeError, TypeError):
+ # 如果解析失败,保持原始字符串
+ pass
+
+ rules.append({
+ 'id': row[0],
+ 'keyword': row[1],
+ 'card_id': row[2],
+ 'delivery_count': row[3],
+ 'enabled': bool(row[4]),
+ 'description': row[5],
+ 'delivery_times': row[6] or 0,
+ 'card_name': row[7],
+ 'card_type': row[8],
+ 'api_config': api_config,
+ 'text_content': row[10],
+ 'data_content': row[11],
+ 'card_enabled': bool(row[12]),
+ 'card_description': row[13],
+ 'card_delay_seconds': row[14] or 0,
+ 'is_multi_spec': bool(row[15]),
+ 'spec_name': row[16],
+ 'spec_value': row[17]
+ })
+
+ if rules:
+ logger.info(f"找到多规格匹配规则: {keyword} - {spec_name}:{spec_value}")
+ return rules
+
+ # 兜底匹配:仅卡券名称
+ cursor.execute('''
+ SELECT dr.id, dr.keyword, dr.card_id, dr.delivery_count, dr.enabled,
+ dr.description, dr.delivery_times,
+ c.name as card_name, c.type as card_type, c.api_config,
+ c.text_content, c.data_content, c.enabled as card_enabled,
+ c.description as card_description, c.delay_seconds as card_delay_seconds,
+ c.is_multi_spec, c.spec_name, c.spec_value
+ FROM delivery_rules dr
+ LEFT JOIN cards c ON dr.card_id = c.id
+ WHERE dr.enabled = 1 AND c.enabled = 1
+ AND (? LIKE '%' || dr.keyword || '%' OR dr.keyword LIKE '%' || ? || '%')
+ AND (c.is_multi_spec = 0 OR c.is_multi_spec IS NULL)
+ ORDER BY
+ CASE
+ WHEN ? LIKE '%' || dr.keyword || '%' THEN LENGTH(dr.keyword)
+ ELSE LENGTH(dr.keyword) / 2
+ END DESC,
+ dr.delivery_times ASC
+ ''', (keyword, keyword, keyword))
+
+ rules = []
+ for row in cursor.fetchall():
+ # 解析api_config JSON字符串
+ api_config = row[9]
+ if api_config:
+ try:
+ import json
+ api_config = json.loads(api_config)
+ except (json.JSONDecodeError, TypeError):
+ # 如果解析失败,保持原始字符串
+ pass
+
+ rules.append({
+ 'id': row[0],
+ 'keyword': row[1],
+ 'card_id': row[2],
+ 'delivery_count': row[3],
+ 'enabled': bool(row[4]),
+ 'description': row[5],
+ 'delivery_times': row[6] or 0,
+ 'card_name': row[7],
+ 'card_type': row[8],
+ 'api_config': api_config,
+ 'text_content': row[10],
+ 'data_content': row[11],
+ 'card_enabled': bool(row[12]),
+ 'card_description': row[13],
+ 'card_delay_seconds': row[14] or 0,
+ 'is_multi_spec': bool(row[15]) if row[15] is not None else False,
+ 'spec_name': row[16],
+ 'spec_value': row[17]
+ })
+
+ if rules:
+ logger.info(f"找到兜底匹配规则: {keyword}")
+ else:
+ logger.info(f"未找到匹配规则: {keyword}")
+
+ return rules
+
+ except Exception as e:
+ logger.error(f"获取发货规则失败: {e}")
+ return []
+
+ def delete_card(self, card_id: int):
+ """删除卡券"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ self._execute_sql(cursor, "DELETE FROM cards WHERE id = ?", (card_id,))
+
+ if cursor.rowcount > 0:
+ self.conn.commit()
+ logger.info(f"删除卡券成功: ID {card_id}")
+ return True
+ else:
+ return False # 没有找到对应的记录
+
+ except Exception as e:
+ logger.error(f"删除卡券失败: {e}")
+ self.conn.rollback()
+ raise
+
+ def delete_delivery_rule(self, rule_id: int, user_id: int = None):
+ """删除发货规则(支持用户隔离)"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ if user_id is not None:
+ self._execute_sql(cursor, "DELETE FROM delivery_rules WHERE id = ? AND user_id = ?", (rule_id, user_id))
+ else:
+ self._execute_sql(cursor, "DELETE FROM delivery_rules WHERE id = ?", (rule_id,))
+
+ if cursor.rowcount > 0:
+ self.conn.commit()
+ logger.info(f"删除发货规则成功: ID {rule_id} (用户ID: {user_id})")
+ return True
+ else:
+ return False # 没有找到对应的记录
+
+ except Exception as e:
+ logger.error(f"删除发货规则失败: {e}")
+ self.conn.rollback()
+ raise
+
+ def consume_batch_data(self, card_id: int):
+ """消费批量数据的第一条记录(线程安全)"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+
+ # 获取卡券的批量数据
+ self._execute_sql(cursor, "SELECT data_content FROM cards WHERE id = ? AND type = 'data'", (card_id,))
+ result = cursor.fetchone()
+
+ if not result or not result[0]:
+ logger.warning(f"卡券 {card_id} 没有批量数据")
+ return None
+
+ data_content = result[0]
+ lines = [line.strip() for line in data_content.split('\n') if line.strip()]
+
+ if not lines:
+ logger.warning(f"卡券 {card_id} 批量数据为空")
+ return None
+
+ # 获取第一条数据
+ first_line = lines[0]
+
+ # 移除第一条数据,更新数据库
+ remaining_lines = lines[1:]
+ new_data_content = '\n'.join(remaining_lines)
+
+ cursor.execute('''
+ UPDATE cards
+ SET data_content = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE id = ?
+ ''', (new_data_content, card_id))
+
+ self.conn.commit()
+
+ logger.info(f"消费批量数据成功: 卡券ID={card_id}, 剩余={len(remaining_lines)}条")
+ return first_line
+
+ except Exception as e:
+ logger.error(f"消费批量数据失败: {e}")
+ self.conn.rollback()
+ return None
+
+ # ==================== 商品信息管理 ====================
+
+ def save_item_basic_info(self, cookie_id: str, item_id: str, item_title: str = None,
+ item_description: str = None, item_category: str = None,
+ item_price: str = None, item_detail: str = None) -> bool:
+ """保存或更新商品基本信息,使用原子操作避免并发问题
+
+ Args:
+ cookie_id: Cookie ID
+ item_id: 商品ID
+ item_title: 商品标题
+ item_description: 商品描述
+ item_category: 商品分类
+ item_price: 商品价格
+ item_detail: 商品详情JSON
+
+ Returns:
+ bool: 操作是否成功
+ """
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+
+ # 使用 INSERT OR IGNORE + UPDATE 的原子操作模式
+ # 首先尝试插入,如果已存在则忽略
+ cursor.execute('''
+ INSERT OR IGNORE INTO item_info (cookie_id, item_id, item_title, item_description,
+ item_category, item_price, item_detail, created_at, updated_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+ ''', (cookie_id, item_id, item_title or '', item_description or '',
+ item_category or '', item_price or '', item_detail or ''))
+
+ # 如果是新插入的记录,直接返回成功
+ if cursor.rowcount > 0:
+ self.conn.commit()
+ logger.info(f"新增商品基本信息: {item_id} - {item_title}")
+ return True
+
+ # 记录已存在,使用原子UPDATE操作,只更新非空字段且不覆盖现有非空值
+ update_parts = []
+ params = []
+
+ # 使用 CASE WHEN 语句进行条件更新,避免覆盖现有数据
+ if item_title:
+ update_parts.append("item_title = CASE WHEN (item_title IS NULL OR item_title = '') THEN ? ELSE item_title END")
+ params.append(item_title)
+
+ if item_description:
+ update_parts.append("item_description = CASE WHEN (item_description IS NULL OR item_description = '') THEN ? ELSE item_description END")
+ params.append(item_description)
+
+ if item_category:
+ update_parts.append("item_category = CASE WHEN (item_category IS NULL OR item_category = '') THEN ? ELSE item_category END")
+ params.append(item_category)
+
+ if item_price:
+ update_parts.append("item_price = CASE WHEN (item_price IS NULL OR item_price = '') THEN ? ELSE item_price END")
+ params.append(item_price)
+
+ # 对于item_detail,只有在现有值为空时才更新
+ if item_detail:
+ update_parts.append("item_detail = CASE WHEN (item_detail IS NULL OR item_detail = '' OR TRIM(item_detail) = '') THEN ? ELSE item_detail END")
+ params.append(item_detail)
+
+ if update_parts:
+ update_parts.append("updated_at = CURRENT_TIMESTAMP")
+ params.extend([cookie_id, item_id])
+
+ sql = f"UPDATE item_info SET {', '.join(update_parts)} WHERE cookie_id = ? AND item_id = ?"
+ self._execute_sql(cursor, sql, params)
+
+ if cursor.rowcount > 0:
+ logger.info(f"更新商品基本信息: {item_id} - {item_title}")
+ else:
+ logger.debug(f"商品信息无需更新: {item_id}")
+
+ self.conn.commit()
+ return True
+
+ except Exception as e:
+ logger.error(f"保存商品基本信息失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def save_item_info(self, cookie_id: str, item_id: str, item_data = None) -> bool:
+ """保存或更新商品信息
+
+ Args:
+ cookie_id: Cookie ID
+ item_id: 商品ID
+ item_data: 商品详情数据,可以是字符串或字典,也可以为None
+
+ Returns:
+ bool: 操作是否成功
+ """
+ try:
+ # 验证:如果只有商品ID,没有商品详情数据,则不插入数据库
+ if not item_data:
+ logger.debug(f"跳过保存商品信息:缺少商品详情数据 - {item_id}")
+ return False
+
+ # 如果是字典类型,检查是否有标题信息
+ if isinstance(item_data, dict):
+ title = item_data.get('title', '').strip()
+ if not title:
+ logger.debug(f"跳过保存商品信息:缺少商品标题 - {item_id}")
+ return False
+
+ # 如果是字符串类型,检查是否为空
+ if isinstance(item_data, str) and not item_data.strip():
+ logger.debug(f"跳过保存商品信息:商品详情为空 - {item_id}")
+ return False
+
+ with self.lock:
+ cursor = self.conn.cursor()
+
+ # 检查商品是否已存在
+ cursor.execute('''
+ SELECT id, item_detail FROM item_info
+ WHERE cookie_id = ? AND item_id = ?
+ ''', (cookie_id, item_id))
+
+ existing = cursor.fetchone()
+
+ if existing:
+ # 如果传入的商品详情有值,则用最新数据覆盖
+ if item_data is not None and item_data:
+ # 处理字符串类型的详情数据
+ if isinstance(item_data, str):
+ cursor.execute('''
+ UPDATE item_info SET
+ item_detail = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE cookie_id = ? AND item_id = ?
+ ''', (item_data, cookie_id, item_id))
+ else:
+ # 处理字典类型的详情数据(向后兼容)
+ cursor.execute('''
+ UPDATE item_info SET
+ item_title = ?, item_description = ?, item_category = ?,
+ item_price = ?, item_detail = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE cookie_id = ? AND item_id = ?
+ ''', (
+ item_data.get('title', ''),
+ item_data.get('description', ''),
+ item_data.get('category', ''),
+ item_data.get('price', ''),
+ json.dumps(item_data, ensure_ascii=False),
+ cookie_id, item_id
+ ))
+ logger.info(f"更新商品信息(覆盖): {item_id}")
+ else:
+ # 如果商品详情没有数据,则不更新,只记录存在
+ logger.debug(f"商品信息已存在,无新数据,跳过更新: {item_id}")
+ return True
+ else:
+ # 新增商品信息
+ if isinstance(item_data, str):
+ # 直接保存字符串详情
+ cursor.execute('''
+ INSERT INTO item_info (cookie_id, item_id, item_detail)
+ VALUES (?, ?, ?)
+ ''', (cookie_id, item_id, item_data))
+ else:
+ # 处理字典类型的详情数据(向后兼容)
+ cursor.execute('''
+ INSERT INTO item_info (cookie_id, item_id, item_title, item_description,
+ item_category, item_price, item_detail)
+ VALUES (?, ?, ?, ?, ?, ?, ?)
+ ''', (
+ cookie_id, item_id,
+ item_data.get('title', '') if item_data else '',
+ item_data.get('description', '') if item_data else '',
+ item_data.get('category', '') if item_data else '',
+ item_data.get('price', '') if item_data else '',
+ json.dumps(item_data, ensure_ascii=False) if item_data else ''
+ ))
+ logger.info(f"新增商品信息: {item_id}")
+
+ self.conn.commit()
+ return True
+
+ except Exception as e:
+ logger.error(f"保存商品信息失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def get_item_info(self, cookie_id: str, item_id: str) -> Optional[Dict]:
+ """获取商品信息
+
+ Args:
+ cookie_id: Cookie ID
+ item_id: 商品ID
+
+ Returns:
+ Dict: 商品信息,如果不存在返回None
+ """
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT * FROM item_info
+ WHERE cookie_id = ? AND item_id = ?
+ ''', (cookie_id, item_id))
+
+ row = cursor.fetchone()
+ if row:
+ columns = [description[0] for description in cursor.description]
+ item_info = dict(zip(columns, row))
+
+ # 解析item_detail JSON
+ if item_info.get('item_detail'):
+ try:
+ item_info['item_detail_parsed'] = json.loads(item_info['item_detail'])
+ except:
+ item_info['item_detail_parsed'] = {}
+
+ return item_info
+ return None
+
+ except Exception as e:
+ logger.error(f"获取商品信息失败: {e}")
+ return None
+
+ def update_item_multi_spec_status(self, cookie_id: str, item_id: str, is_multi_spec: bool) -> bool:
+ """更新商品的多规格状态"""
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ UPDATE item_info
+ SET is_multi_spec = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE cookie_id = ? AND item_id = ?
+ ''', (is_multi_spec, cookie_id, item_id))
+
+ if cursor.rowcount > 0:
+ self.conn.commit()
+ logger.info(f"更新商品多规格状态成功: {item_id} -> {is_multi_spec}")
+ return True
+ else:
+ logger.warning(f"商品不存在,无法更新多规格状态: {item_id}")
+ return False
+
+ except Exception as e:
+ logger.error(f"更新商品多规格状态失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def get_item_multi_spec_status(self, cookie_id: str, item_id: str) -> bool:
+ """获取商品的多规格状态"""
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT is_multi_spec FROM item_info
+ WHERE cookie_id = ? AND item_id = ?
+ ''', (cookie_id, item_id))
+
+ row = cursor.fetchone()
+ if row:
+ return bool(row[0]) if row[0] is not None else False
+ return False
+
+ except Exception as e:
+ logger.error(f"获取商品多规格状态失败: {e}")
+ return False
+
+ def update_item_multi_quantity_delivery_status(self, cookie_id: str, item_id: str, multi_quantity_delivery: bool) -> bool:
+ """更新商品的多数量发货状态"""
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ UPDATE item_info
+ SET multi_quantity_delivery = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE cookie_id = ? AND item_id = ?
+ ''', (multi_quantity_delivery, cookie_id, item_id))
+
+ if cursor.rowcount > 0:
+ self.conn.commit()
+ logger.info(f"更新商品多数量发货状态成功: {item_id} -> {multi_quantity_delivery}")
+ return True
+ else:
+ logger.warning(f"未找到要更新的商品: {item_id}")
+ return False
+
+ except Exception as e:
+ logger.error(f"更新商品多数量发货状态失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def get_item_multi_quantity_delivery_status(self, cookie_id: str, item_id: str) -> bool:
+ """获取商品的多数量发货状态"""
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT multi_quantity_delivery FROM item_info
+ WHERE cookie_id = ? AND item_id = ?
+ ''', (cookie_id, item_id))
+
+ row = cursor.fetchone()
+ if row:
+ return bool(row[0]) if row[0] is not None else False
+ return False
+
+ except Exception as e:
+ logger.error(f"获取商品多数量发货状态失败: {e}")
+ return False
+
+ def get_items_by_cookie(self, cookie_id: str) -> List[Dict]:
+ """获取指定Cookie的所有商品信息
+
+ Args:
+ cookie_id: Cookie ID
+
+ Returns:
+ List[Dict]: 商品信息列表
+ """
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT * FROM item_info
+ WHERE cookie_id = ?
+ ORDER BY updated_at DESC
+ ''', (cookie_id,))
+
+ columns = [description[0] for description in cursor.description]
+ items = []
+
+ for row in cursor.fetchall():
+ item_info = dict(zip(columns, row))
+
+ # 解析item_detail JSON
+ if item_info.get('item_detail'):
+ try:
+ item_info['item_detail_parsed'] = json.loads(item_info['item_detail'])
+ except:
+ item_info['item_detail_parsed'] = {}
+
+ items.append(item_info)
+
+ return items
+
+ except Exception as e:
+ logger.error(f"获取Cookie商品信息失败: {e}")
+ return []
+
+ def get_all_items(self) -> List[Dict]:
+ """获取所有商品信息
+
+ Returns:
+ List[Dict]: 所有商品信息列表
+ """
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT * FROM item_info
+ ORDER BY updated_at DESC
+ ''')
+
+ columns = [description[0] for description in cursor.description]
+ items = []
+
+ for row in cursor.fetchall():
+ item_info = dict(zip(columns, row))
+
+ # 解析item_detail JSON
+ if item_info.get('item_detail'):
+ try:
+ item_info['item_detail_parsed'] = json.loads(item_info['item_detail'])
+ except:
+ item_info['item_detail_parsed'] = {}
+
+ items.append(item_info)
+
+ return items
+
+ except Exception as e:
+ logger.error(f"获取所有商品信息失败: {e}")
+ return []
+
+ def update_item_fields(self, cookie_id: str, item_id: str,
+ item_title: str = None, item_price: str = None,
+ item_description: str = None, item_detail: str = None) -> bool:
+ """更新商品多个字段
+
+ Args:
+ cookie_id: Cookie ID
+ item_id: 商品ID
+ item_title: 商品标题
+ item_price: 商品价格
+ item_description: 商品描述
+ item_detail: 商品详情JSON字符串
+
+ Returns:
+ bool: 操作是否成功
+ """
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+ # 动态构建 SET 子句
+ set_fields = []
+ params = []
+ if item_title is not None:
+ set_fields.append("item_title = ?")
+ params.append(item_title)
+ if item_price is not None:
+ set_fields.append("item_price = ?")
+ params.append(item_price)
+ if item_description is not None:
+ set_fields.append("item_description = ?")
+ params.append(item_description)
+ if item_detail is not None:
+ set_fields.append("item_detail = ?")
+ params.append(item_detail)
+
+ if not set_fields:
+ logger.warning(f"没有要更新的字段: {item_id}")
+ return False
+
+ set_fields.append("updated_at = CURRENT_TIMESTAMP")
+ params.extend([cookie_id, item_id])
+
+ sql = f'''UPDATE item_info SET
+ {', '.join(set_fields)}
+ WHERE cookie_id = ? AND item_id = ?'''
+ cursor.execute(sql, params)
+
+ if cursor.rowcount > 0:
+ self.conn.commit()
+ logger.info(f"更新商品字段成功: {item_id} ({len(set_fields)}个字段)")
+ return True
+ else:
+ logger.warning(f"未找到商品: {item_id}")
+ return False
+ except Exception as e:
+ logger.error(f"更新商品字段失败 {item_id}: {e}")
+ return False
+ def update_item_title_only(self, cookie_id: str, item_id: str, item_title: str) -> bool:
+ """仅更新商品标题(并发安全)
+
+ Args:
+ cookie_id: Cookie ID
+ item_id: 商品ID
+ item_title: 商品标题
+
+ Returns:
+ bool: 操作是否成功
+ """
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+ # 使用 INSERT OR REPLACE 确保记录存在,但只更新标题字段
+ cursor.execute('''
+ INSERT INTO item_info (cookie_id, item_id, item_title, item_description,
+ item_category, item_price, item_detail, created_at, updated_at)
+ VALUES (?, ?, ?,
+ COALESCE((SELECT item_description FROM item_info WHERE cookie_id = ? AND item_id = ?), ''),
+ COALESCE((SELECT item_category FROM item_info WHERE cookie_id = ? AND item_id = ?), ''),
+ COALESCE((SELECT item_price FROM item_info WHERE cookie_id = ? AND item_id = ?), ''),
+ COALESCE((SELECT item_detail FROM item_info WHERE cookie_id = ? AND item_id = ?), ''),
+ COALESCE((SELECT created_at FROM item_info WHERE cookie_id = ? AND item_id = ?), CURRENT_TIMESTAMP),
+ CURRENT_TIMESTAMP)
+ ON CONFLICT(cookie_id, item_id) DO UPDATE SET
+ item_title = excluded.item_title,
+ updated_at = CURRENT_TIMESTAMP
+ ''', (cookie_id, item_id, item_title,
+ cookie_id, item_id, cookie_id, item_id, cookie_id, item_id,
+ cookie_id, item_id, cookie_id, item_id))
+
+ self.conn.commit()
+ logger.info(f"更新商品标题成功: {item_id} - {item_title}")
+ return True
+
+ except Exception as e:
+ logger.error(f"更新商品标题失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def batch_save_item_basic_info(self, items_data: list) -> int:
+ """批量保存商品基本信息(并发安全)
+
+ Args:
+ items_data: 商品数据列表,每个元素包含 cookie_id, item_id, item_title 等字段
+
+ Returns:
+ int: 成功保存的商品数量
+ """
+ if not items_data:
+ return 0
+
+ success_count = 0
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+
+ # 使用事务批量处理
+ cursor.execute('BEGIN TRANSACTION')
+
+ for item_data in items_data:
+ try:
+ cookie_id = item_data.get('cookie_id')
+ item_id = item_data.get('item_id')
+ item_title = item_data.get('item_title', '')
+ item_description = item_data.get('item_description', '')
+ item_category = item_data.get('item_category', '')
+ item_price = item_data.get('item_price', '')
+ item_detail = item_data.get('item_detail', '')
+
+ if not cookie_id or not item_id:
+ continue
+
+ # 验证:如果没有商品标题,则跳过保存
+ if not item_title or not item_title.strip():
+ logger.debug(f"跳过批量保存商品信息:缺少商品标题 - {item_id}")
+ continue
+
+ # 使用 INSERT OR IGNORE + UPDATE 模式
+ cursor.execute('''
+ INSERT OR IGNORE INTO item_info (cookie_id, item_id, item_title, item_description,
+ item_category, item_price, item_detail, created_at, updated_at)
+ VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+ ''', (cookie_id, item_id, item_title, item_description,
+ item_category, item_price, item_detail))
+
+ if cursor.rowcount == 0:
+ # 记录已存在,进行条件更新
+ update_sql = '''
+ UPDATE item_info SET
+ item_title = CASE WHEN (item_title IS NULL OR item_title = '') AND ? != '' THEN ? ELSE item_title END,
+ item_description = CASE WHEN (item_description IS NULL OR item_description = '') AND ? != '' THEN ? ELSE item_description END,
+ item_category = CASE WHEN (item_category IS NULL OR item_category = '') AND ? != '' THEN ? ELSE item_category END,
+ item_price = CASE WHEN (item_price IS NULL OR item_price = '') AND ? != '' THEN ? ELSE item_price END,
+ item_detail = CASE WHEN (item_detail IS NULL OR item_detail = '' OR TRIM(item_detail) = '') AND ? != '' THEN ? ELSE item_detail END,
+ updated_at = CURRENT_TIMESTAMP
+ WHERE cookie_id = ? AND item_id = ?
+ '''
+ self._execute_sql(cursor, update_sql, (
+ item_title, item_title,
+ item_description, item_description,
+ item_category, item_category,
+ item_price, item_price,
+ item_detail, item_detail,
+ cookie_id, item_id
+ ))
+
+ success_count += 1
+
+ except Exception as item_e:
+ logger.warning(f"批量保存单个商品失败 {item_data.get('item_id', 'unknown')}: {item_e}")
+ continue
+
+ cursor.execute('COMMIT')
+ logger.info(f"批量保存商品信息完成: {success_count}/{len(items_data)} 个商品")
+ return success_count
+
+ except Exception as e:
+ logger.error(f"批量保存商品信息失败: {e}")
+ try:
+ cursor.execute('ROLLBACK')
+ except:
+ pass
+ return success_count
+
+ def delete_item_info(self, cookie_id: str, item_id: str) -> bool:
+ """删除商品信息
+
+ Args:
+ cookie_id: Cookie ID
+ item_id: 商品ID
+
+ Returns:
+ bool: 操作是否成功
+ """
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+ cursor.execute('DELETE FROM item_info WHERE cookie_id = ? AND item_id = ?',
+ (cookie_id, item_id))
+
+ if cursor.rowcount > 0:
+ self.conn.commit()
+ logger.info(f"删除商品信息成功: {cookie_id} - {item_id}")
+ return True
+ else:
+ logger.warning(f"未找到要删除的商品信息: {cookie_id} - {item_id}")
+ return False
+
+ except Exception as e:
+ logger.error(f"删除商品信息失败: {e}")
+ self.conn.rollback()
+ return False
+
+ def batch_delete_item_info(self, items_to_delete: list) -> int:
+ """批量删除商品信息
+
+ Args:
+ items_to_delete: 要删除的商品列表,每个元素包含 cookie_id 和 item_id
+
+ Returns:
+ int: 成功删除的商品数量
+ """
+ if not items_to_delete:
+ return 0
+
+ success_count = 0
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+ cursor.execute('BEGIN TRANSACTION')
+
+ for item_data in items_to_delete:
+ try:
+ cookie_id = item_data.get('cookie_id')
+ item_id = item_data.get('item_id')
+
+ if not cookie_id or not item_id:
+ continue
+
+ cursor.execute('DELETE FROM item_info WHERE cookie_id = ? AND item_id = ?',
+ (cookie_id, item_id))
+
+ if cursor.rowcount > 0:
+ success_count += 1
+ logger.debug(f"删除商品信息: {cookie_id} - {item_id}")
+
+ except Exception as item_e:
+ logger.warning(f"删除单个商品失败 {item_data.get('item_id', 'unknown')}: {item_e}")
+ continue
+
+ cursor.execute('COMMIT')
+ logger.info(f"批量删除商品信息完成: {success_count}/{len(items_to_delete)} 个商品")
+ return success_count
+
+ except Exception as e:
+ logger.error(f"批量删除商品信息失败: {e}")
+ try:
+ cursor.execute('ROLLBACK')
+ except:
+ pass
+ return success_count
+
+ # ==================== 用户设置管理方法 ====================
+
+ def get_user_settings(self, user_id: int):
+ """获取用户的所有设置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT key, value, description, updated_at
+ FROM user_settings
+ WHERE user_id = ?
+ ORDER BY key
+ ''', (user_id,))
+
+ settings = {}
+ for row in cursor.fetchall():
+ settings[row[0]] = {
+ 'value': row[1],
+ 'description': row[2],
+ 'updated_at': row[3]
+ }
+
+ return settings
+ except Exception as e:
+ logger.error(f"获取用户设置失败: {e}")
+ return {}
+
+ def get_user_setting(self, user_id: int, key: str):
+ """获取用户的特定设置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT value, description, updated_at
+ FROM user_settings
+ WHERE user_id = ? AND key = ?
+ ''', (user_id, key))
+
+ row = cursor.fetchone()
+ if row:
+ return {
+ 'key': key,
+ 'value': row[0],
+ 'description': row[1],
+ 'updated_at': row[2]
+ }
+ return None
+ except Exception as e:
+ logger.error(f"获取用户设置失败: {e}")
+ return None
+
+ def set_user_setting(self, user_id: int, key: str, value: str, description: str = None):
+ """设置用户配置"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ INSERT OR REPLACE INTO user_settings (user_id, key, value, description, updated_at)
+ VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
+ ''', (user_id, key, value, description))
+
+ self.conn.commit()
+ logger.info(f"用户设置更新成功: user_id={user_id}, key={key}")
+ return True
+ except Exception as e:
+ logger.error(f"设置用户配置失败: {e}")
+ self.conn.rollback()
+ return False
+
+ # ==================== 管理员专用方法 ====================
+
+ def get_all_users(self):
+ """获取所有用户信息(管理员专用)"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT id, username, email, created_at, updated_at, COALESCE(role, 'user') as role
+ FROM users
+ ORDER BY created_at DESC
+ ''')
+
+ users = []
+ for row in cursor.fetchall():
+ users.append({
+ 'id': row[0],
+ 'username': row[1],
+ 'email': row[2],
+ 'created_at': row[3],
+ 'updated_at': row[4],
+ 'role': row[5]
+ })
+
+ return users
+ except Exception as e:
+ logger.error(f"获取所有用户失败: {e}")
+ return []
+
+ def get_user_by_id(self, user_id: int):
+ """根据ID获取用户信息"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT id, username, email, created_at, updated_at, COALESCE(role, 'user') as role
+ FROM users
+ WHERE id = ?
+ ''', (user_id,))
+
+ row = cursor.fetchone()
+ if row:
+ return {
+ 'id': row[0],
+ 'username': row[1],
+ 'email': row[2],
+ 'created_at': row[3],
+ 'updated_at': row[4],
+ 'role': row[5]
+ }
+ return None
+ except Exception as e:
+ logger.error(f"获取用户信息失败: {e}")
+ return None
+
+ def delete_user_and_data(self, user_id: int):
+ """删除用户及其所有相关数据"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+
+ # 开始事务
+ cursor.execute('BEGIN TRANSACTION')
+
+ # 删除用户相关的所有数据
+ # 1. 删除用户设置
+ cursor.execute('DELETE FROM user_settings WHERE user_id = ?', (user_id,))
+
+ # 2. 删除用户的卡券
+ cursor.execute('DELETE FROM cards WHERE user_id = ?', (user_id,))
+
+ # 3. 删除用户的发货规则
+ cursor.execute('DELETE FROM delivery_rules WHERE user_id = ?', (user_id,))
+
+ # 4. 删除用户的通知渠道
+ cursor.execute('DELETE FROM notification_channels WHERE user_id = ?', (user_id,))
+
+ # 5. 删除用户的Cookie
+ cursor.execute('DELETE FROM cookies WHERE user_id = ?', (user_id,))
+
+ # 6. 删除用户的关键字
+ cursor.execute('DELETE FROM keywords WHERE cookie_id IN (SELECT id FROM cookies WHERE user_id = ?)', (user_id,))
+
+ # 7. 删除用户的默认回复
+ cursor.execute('DELETE FROM default_replies WHERE cookie_id IN (SELECT id FROM cookies WHERE user_id = ?)', (user_id,))
+
+ # 8. 删除用户的AI回复设置
+ cursor.execute('DELETE FROM ai_reply_settings WHERE cookie_id IN (SELECT id FROM cookies WHERE user_id = ?)', (user_id,))
+
+ # 9. 删除用户的消息通知
+ cursor.execute('DELETE FROM message_notifications WHERE cookie_id IN (SELECT id FROM cookies WHERE user_id = ?)', (user_id,))
+
+ # 10. 最后删除用户本身
+ cursor.execute('DELETE FROM users WHERE id = ?', (user_id,))
+
+ # 提交事务
+ cursor.execute('COMMIT')
+
+ logger.info(f"用户及相关数据删除成功: user_id={user_id}")
+ return True
+
+ except Exception as e:
+ # 回滚事务
+ cursor.execute('ROLLBACK')
+ logger.error(f"删除用户及相关数据失败: {e}")
+ return False
+
+ def get_table_data(self, table_name: str):
+ """获取指定表的所有数据"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+
+ # 获取表结构
+ cursor.execute(f"PRAGMA table_info({table_name})")
+ columns_info = cursor.fetchall()
+ columns = [col[1] for col in columns_info] # 列名
+
+ # 获取表数据
+ cursor.execute(f"SELECT * FROM {table_name}")
+ rows = cursor.fetchall()
+
+ # 转换为字典列表
+ data = []
+ for row in rows:
+ row_dict = {}
+ for i, value in enumerate(row):
+ row_dict[columns[i]] = value
+ data.append(row_dict)
+
+ return data, columns
+
+ except Exception as e:
+ logger.error(f"获取表数据失败: {table_name} - {e}")
+ return [], []
+
+ def get_ai_conversations(self, cookie_id: str = None, user_id: str = None,
+ item_id: str = None, page: int = 1, page_size: int = 20,
+ user_cookie_ids: list = None) -> dict:
+ """分页查询AI对话历史
+
+ Args:
+ cookie_id: 按账号筛选
+ user_id: 按买家用户ID筛选
+ item_id: 按商品ID筛选
+ page: 页码,从1开始
+ page_size: 每页条数,默认20
+ user_cookie_ids: 当前用户可访问的cookie_id列表(权限过滤)
+ """
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ conditions = []
+ params = []
+
+ if user_cookie_ids:
+ placeholders = ','.join('?' * len(user_cookie_ids))
+ conditions.append(f'c.cookie_id IN ({placeholders})')
+ params.extend(user_cookie_ids)
+
+ if cookie_id:
+ conditions.append('c.cookie_id = ?')
+ params.append(cookie_id)
+
+ if user_id:
+ conditions.append('c.user_id = ?')
+ params.append(user_id)
+
+ if item_id:
+ conditions.append('c.item_id = ?')
+ params.append(item_id)
+
+ where_clause = ' AND '.join(conditions) if conditions else '1=1'
+
+ # 查询总数
+ count_sql = f'SELECT COUNT(*) FROM ai_conversations c WHERE {where_clause}'
+ cursor.execute(count_sql, params)
+ total = cursor.fetchone()[0]
+
+ # 查询分页数据(按时间倒序)
+ offset = (page - 1) * page_size
+ data_sql = f'''
+ SELECT c.id, c.cookie_id, c.chat_id, c.user_id, c.item_id,
+ c.role, c.content, c.intent, c.created_at
+ FROM ai_conversations c
+ WHERE {where_clause}
+ ORDER BY c.created_at DESC
+ LIMIT ? OFFSET ?
+ '''
+ cursor.execute(data_sql, params + [page_size, offset])
+ rows = cursor.fetchall()
+
+ columns = ['id', 'cookie_id', 'chat_id', 'user_id', 'item_id',
+ 'role', 'content', 'intent', 'created_at']
+ data = []
+ for row in rows:
+ row_dict = {}
+ for i, value in enumerate(row):
+ row_dict[columns[i]] = value
+ data.append(row_dict)
+
+ total_pages = max(1, (total + page_size - 1) // page_size)
+
+ return {
+ 'data': data,
+ 'total': total,
+ 'page': page,
+ 'page_size': page_size,
+ 'total_pages': total_pages
+ }
+
+ except Exception as e:
+ logger.error(f"获取AI对话历史失败: {e}")
+ return {
+ 'data': [],
+ 'total': 0,
+ 'page': page,
+ 'page_size': page_size,
+ 'total_pages': 1
+ }
+
+ def insert_or_update_order(self, order_id: str, item_id: str = None, buyer_id: str = None,
+ spec_name: str = None, spec_value: str = None, quantity: str = None,
+ amount: str = None, order_status: str = None, cookie_id: str = None,
+ delivery_status: str = None, buyer_name: str = None):
+ """插入或更新订单信息"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+
+ # 检查cookie_id是否在cookies表中存在(如果提供了cookie_id)
+ if cookie_id:
+ cursor.execute("SELECT id FROM cookies WHERE id = ?", (cookie_id,))
+ cookie_exists = cursor.fetchone()
+ if not cookie_exists:
+ logger.warning(f"Cookie ID {cookie_id} 不存在于cookies表中,拒绝插入订单 {order_id}")
+ return False
+
+ # 检查订单是否已存在
+ cursor.execute("SELECT order_id FROM orders WHERE order_id = ?", (order_id,))
+ existing = cursor.fetchone()
+
+ if existing:
+ # 更新现有订单
+ update_fields = []
+ update_values = []
+
+ if item_id is not None:
+ update_fields.append("item_id = ?")
+ update_values.append(item_id)
+ if buyer_id is not None:
+ update_fields.append("buyer_id = ?")
+ update_values.append(buyer_id)
+ if spec_name is not None:
+ update_fields.append("spec_name = ?")
+ update_values.append(spec_name)
+ if spec_value is not None:
+ update_fields.append("spec_value = ?")
+ update_values.append(spec_value)
+ if quantity is not None:
+ update_fields.append("quantity = ?")
+ update_values.append(quantity)
+ if amount is not None:
+ update_fields.append("amount = ?")
+ update_values.append(amount)
+ if order_status is not None:
+ update_fields.append("order_status = ?")
+ update_values.append(order_status)
+ if cookie_id is not None:
+ update_fields.append("cookie_id = ?")
+ update_values.append(cookie_id)
+ if delivery_status is not None:
+ update_fields.append("delivery_status = ?")
+ update_values.append(delivery_status)
+ if buyer_name is not None and buyer_name != '':
+ update_fields.append("buyer_name = ?")
+ update_values.append(buyer_name)
+
+ if update_fields:
+ update_fields.append("updated_at = CURRENT_TIMESTAMP")
+ update_values.append(order_id)
+
+ sql = f"UPDATE orders SET {', '.join(update_fields)} WHERE order_id = ?"
+ cursor.execute(sql, update_values)
+ logger.info(f"更新订单信息: {order_id}")
+ else:
+ # 插入新订单
+ cursor.execute('''
+ INSERT INTO orders (order_id, item_id, buyer_id, spec_name, spec_value,
+ quantity, amount, order_status, cookie_id, delivery_status, buyer_name)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ ''', (order_id, item_id, buyer_id, spec_name, spec_value,
+ quantity, amount, order_status or 'unknown', cookie_id,
+ delivery_status or 'pending', buyer_name or ''))
+ logger.info(f"插入新订单: {order_id}")
+
+ self.conn.commit()
+ return True
+
+ except Exception as e:
+ logger.error(f"插入或更新订单失败: {order_id} - {e}")
+ self.conn.rollback()
+ return False
+
+ def get_order_by_id(self, order_id: str):
+ """根据订单ID获取订单信息"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT order_id, item_id, buyer_id, spec_name, spec_value,
+ quantity, amount, order_status, cookie_id, created_at, updated_at,
+ delivery_status, buyer_name
+ FROM orders WHERE order_id = ?
+ ''', (order_id,))
+
+ row = cursor.fetchone()
+ if row:
+ return {
+ 'order_id': row[0],
+ 'item_id': row[1],
+ 'buyer_id': row[2],
+ 'spec_name': row[3],
+ 'spec_value': row[4],
+ 'quantity': row[5],
+ 'amount': row[6],
+ 'order_status': row[7],
+ 'cookie_id': row[8],
+ 'created_at': row[9],
+ 'updated_at': row[10],
+ 'delivery_status': row[11] if len(row) > 11 else 'pending',
+ 'buyer_name': row[12] if len(row) > 12 else ''
+ }
+ return None
+
+ except Exception as e:
+ logger.error(f"获取订单信息失败: {order_id} - {e}")
+ return None
+
+ def update_order_delivery_status(self, order_id: str, delivery_status: str) -> bool:
+ """更新订单的发货状态"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ UPDATE orders SET delivery_status = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE order_id = ?
+ ''', (delivery_status, order_id))
+ self.conn.commit()
+ logger.info(f"更新订单发货状态: {order_id} -> {delivery_status}")
+ return True
+ except Exception as e:
+ logger.error(f"更新订单发货状态失败: {order_id} - {e}")
+ self.conn.rollback()
+ return False
+
+ def get_orders_by_cookie(self, cookie_id: str, limit: int = 100):
+ """根据Cookie ID获取订单列表"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT order_id, item_id, buyer_id, spec_name, spec_value,
+ quantity, amount, order_status, created_at, updated_at
+ FROM orders WHERE cookie_id = ?
+ ORDER BY created_at DESC LIMIT ?
+ ''', (cookie_id, limit))
+
+ orders = []
+ for row in cursor.fetchall():
+ orders.append({
+ 'order_id': row[0],
+ 'item_id': row[1],
+ 'buyer_id': row[2],
+ 'spec_name': row[3],
+ 'spec_value': row[4],
+ 'quantity': row[5],
+ 'amount': row[6],
+ 'order_status': row[7],
+ 'created_at': row[8],
+ 'updated_at': row[9]
+ })
+
+ return orders
+
+ except Exception as e:
+ logger.error(f"获取Cookie订单列表失败: {cookie_id} - {e}")
+ return []
+
+ def delete_table_record(self, table_name: str, record_id: str):
+ """删除指定表的指定记录"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+
+ # 根据表名确定主键字段
+ primary_key_map = {
+ 'users': 'id',
+ 'cookies': 'id',
+ 'cookie_status': 'id',
+ 'keywords': 'id',
+ 'default_replies': 'id',
+ 'default_reply_records': 'id',
+ 'item_replay': 'item_id',
+ 'ai_reply_settings': 'id',
+ 'ai_conversations': 'id',
+ 'ai_item_cache': 'id',
+ 'item_info': 'id',
+ 'message_notifications': 'id',
+ 'cards': 'id',
+ 'delivery_rules': 'id',
+ 'notification_channels': 'id',
+ 'user_settings': 'id',
+ 'system_settings': 'id',
+ 'email_verifications': 'id',
+ 'captcha_codes': 'id',
+ 'orders': 'order_id'
+ }
+
+ primary_key = primary_key_map.get(table_name, 'id')
+
+ # 删除记录
+ cursor.execute(f"DELETE FROM {table_name} WHERE {primary_key} = ?", (record_id,))
+
+ if cursor.rowcount > 0:
+ self.conn.commit()
+ logger.info(f"删除表记录成功: {table_name}.{record_id}")
+ return True
+ else:
+ logger.warning(f"删除表记录失败,记录不存在: {table_name}.{record_id}")
+ return False
+
+ except Exception as e:
+ logger.error(f"删除表记录失败: {table_name}.{record_id} - {e}")
+ self.conn.rollback()
+ return False
+
+ def clear_table_data(self, table_name: str):
+ """清空指定表的所有数据"""
+ with self.lock:
+ try:
+ cursor = self.conn.cursor()
+
+ # 清空表数据
+ cursor.execute(f"DELETE FROM {table_name}")
+
+ # 重置自增ID(如果有的话)
+ cursor.execute(f"DELETE FROM sqlite_sequence WHERE name = ?", (table_name,))
+
+ self.conn.commit()
+ logger.info(f"清空表数据成功: {table_name}")
+ return True
+
+ except Exception as e:
+ logger.error(f"清空表数据失败: {table_name} - {e}")
+ self.conn.rollback()
+ return False
+
+ def upgrade_keywords_table_for_image_support(self, cursor):
+ """升级keywords表以支持图片关键词"""
+ try:
+ logger.info("开始升级keywords表以支持图片关键词...")
+
+ # 检查是否已经有type字段
+ cursor.execute("PRAGMA table_info(keywords)")
+ columns = [column[1] for column in cursor.fetchall()]
+
+ if 'type' not in columns:
+ logger.info("添加type字段到keywords表...")
+ cursor.execute("ALTER TABLE keywords ADD COLUMN type TEXT DEFAULT 'text'")
+
+ if 'image_url' not in columns:
+ logger.info("添加image_url字段到keywords表...")
+ cursor.execute("ALTER TABLE keywords ADD COLUMN image_url TEXT")
+
+ # 为现有记录设置默认类型
+ cursor.execute("UPDATE keywords SET type = 'text' WHERE type IS NULL")
+
+ logger.info("keywords表升级完成")
+ return True
+
+ except Exception as e:
+ logger.error(f"升级keywords表失败: {e}")
+ raise
+ def get_item_replay(self, item_id: str) -> Optional[Dict[str, Any]]:
+ """
+ 根据商品ID获取商品回复信息,并返回统一格式
+
+ Args:
+ item_id (str): 商品ID
+
+ Returns:
+ Optional[Dict[str, Any]]: 商品回复信息字典(统一格式),找不到返回 None
+ """
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT reply_content FROM item_replay
+ WHERE item_id = ?
+ ''', (item_id,))
+
+ row = cursor.fetchone()
+ if row:
+ (reply_content,) = row
+ return {
+ 'reply_content': reply_content or ''
+ }
+ return None
+ except Exception as e:
+ logger.error(f"获取商品回复失败: {e}")
+ return None
+
+ def get_item_reply(self, cookie_id: str, item_id: str) -> Optional[Dict[str, Any]]:
+ """
+ 获取指定账号和商品的回复内容
+
+ Args:
+ cookie_id (str): 账号ID
+ item_id (str): 商品ID
+
+ Returns:
+ Dict: 包含回复内容的字典,如果不存在返回None
+ """
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT reply_content, created_at, updated_at
+ FROM item_replay
+ WHERE cookie_id = ? AND item_id = ?
+ ''', (cookie_id, item_id))
+
+ row = cursor.fetchone()
+ if row:
+ return {
+ 'reply_content': row[0] or '',
+ 'created_at': row[1],
+ 'updated_at': row[2]
+ }
+ return None
+ except Exception as e:
+ logger.error(f"获取指定商品回复失败: {e}")
+ return None
+
+ def update_item_reply(self, cookie_id: str, item_id: str, reply_content: str) -> bool:
+ """
+ 更新指定cookie和item的回复内容及更新时间
+
+ Args:
+ cookie_id (str): 账号ID
+ item_id (str): 商品ID
+ reply_content (str): 回复内容
+
+ Returns:
+ bool: 更新成功返回True,失败返回False
+ """
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ UPDATE item_replay
+ SET reply_content = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE cookie_id = ? AND item_id = ?
+ ''', (reply_content, cookie_id, item_id))
+
+ if cursor.rowcount == 0:
+ # 如果没更新到,说明该条记录不存在,可以考虑插入
+ cursor.execute('''
+ INSERT INTO item_replay (item_id, cookie_id, reply_content, created_at, updated_at)
+ VALUES (?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+ ''', (item_id, cookie_id, reply_content))
+
+ self.conn.commit()
+ return True
+ except Exception as e:
+ logger.error(f"更新商品回复失败: {e}")
+ return False
+
+ def get_itemReplays_by_cookie(self, cookie_id: str) -> List[Dict]:
+ """获取指定Cookie的所有商品信息
+
+ Args:
+ cookie_id: Cookie ID
+
+ Returns:
+ List[Dict]: 商品信息列表
+ """
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ SELECT r.item_id, r.cookie_id, r.reply_content, r.created_at, r.updated_at, i.item_title, i.item_detail
+ FROM item_replay r
+ LEFT JOIN item_info i ON i.item_id = r.item_id
+ WHERE r.cookie_id = ?
+ ORDER BY r.updated_at DESC
+ ''', (cookie_id,))
+
+ columns = [description[0] for description in cursor.description]
+ items = []
+
+ for row in cursor.fetchall():
+ item_info = dict(zip(columns, row))
+
+ items.append(item_info)
+
+ return items
+
+ except Exception as e:
+ logger.error(f"获取Cookie商品信息失败: {e}")
+ return []
+
+ def delete_item_reply(self, cookie_id: str, item_id: str) -> bool:
+ """
+ 删除指定 cookie_id 和 item_id 的商品回复
+
+ Args:
+ cookie_id: Cookie ID
+ item_id: 商品ID
+
+ Returns:
+ bool: 删除成功返回 True,失败返回 False
+ """
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+ cursor.execute('''
+ DELETE FROM item_replay
+ WHERE cookie_id = ? AND item_id = ?
+ ''', (cookie_id, item_id))
+ self.conn.commit()
+ # 判断是否有删除行
+ return cursor.rowcount > 0
+ except Exception as e:
+ logger.error(f"删除商品回复失败: {e}")
+ return False
+
+ def batch_delete_item_replies(self, items: List[Dict[str, str]]) -> Dict[str, int]:
+ """
+ 批量删除商品回复
+
+ Args:
+ items: List[Dict] 每个字典包含 cookie_id 和 item_id
+
+ Returns:
+ Dict[str, int]: 返回成功和失败的数量,例如 {"success_count": 3, "failed_count": 1}
+ """
+ success_count = 0
+ failed_count = 0
+
+ try:
+ with self.lock:
+ cursor = self.conn.cursor()
+ for item in items:
+ cookie_id = item.get('cookie_id')
+ item_id = item.get('item_id')
+ if not cookie_id or not item_id:
+ failed_count += 1
+ continue
+ cursor.execute('''
+ DELETE FROM item_replay
+ WHERE cookie_id = ? AND item_id = ?
+ ''', (cookie_id, item_id))
+ if cursor.rowcount > 0:
+ success_count += 1
+ else:
+ failed_count += 1
+ self.conn.commit()
+ except Exception as e:
+ logger.error(f"批量删除商品回复失败: {e}")
+ # 整体失败则视为全部失败
+ return {"success_count": 0, "failed_count": len(items)}
+
+ return {"success_count": success_count, "failed_count": failed_count}
+
+
+
+# 全局单例
+db_manager = DBManager()
+
+# 确保进程结束时关闭数据库连接
+import atexit
+atexit.register(db_manager.close)
diff --git a/docker-compose-cn.yml b/docker-compose-cn.yml
new file mode 100644
index 0000000..32b5e5b
--- /dev/null
+++ b/docker-compose-cn.yml
@@ -0,0 +1,105 @@
+services:
+ xianyu-app:
+ build:
+ context: .
+ dockerfile: Dockerfile-cn
+ image: xianyu-auto-reply:latest
+ container_name: xianyu-auto-reply
+ restart: unless-stopped
+ # 使用root用户避免权限问题
+ user: "0:0"
+ ports:
+ - "${WEB_PORT:-8080}:8080"
+ volumes:
+ # 数据持久化
+ - ./data:/app/data:rw
+ - ./logs:/app/logs:rw
+ - ./global_config.yml:/app/global_config.yml:ro
+ # 可选:如果需要自定义配置
+ # - ./custom_config.yml:/app/global_config.yml:ro
+ # 可选:备份目录
+ - ./backups:/app/backups:rw
+ environment:
+ - PYTHONUNBUFFERED=${PYTHONUNBUFFERED:-1}
+ - PYTHONDONTWRITEBYTECODE=${PYTHONDONTWRITEBYTECODE:-1}
+ - TZ=${TZ:-Asia/Shanghai}
+ - DB_PATH=${DB_PATH:-/app/data/xianyu_data.db}
+ - LOG_LEVEL=${LOG_LEVEL:-INFO}
+ - DEBUG=${DEBUG:-false}
+ - RELOAD=${RELOAD:-false}
+ # SQL日志配置(默认启用,可通过环境变量覆盖)
+ - SQL_LOG_ENABLED=${SQL_LOG_ENABLED:-true}
+ - SQL_LOG_LEVEL=${SQL_LOG_LEVEL:-INFO}
+ - ADMIN_USERNAME=${ADMIN_USERNAME:-admin}
+ - ADMIN_PASSWORD=${ADMIN_PASSWORD:-admin123}
+ - JWT_SECRET_KEY=${JWT_SECRET_KEY:-default-secret-key}
+ - SESSION_TIMEOUT=${SESSION_TIMEOUT:-3600}
+ # 多用户系统配置
+ - MULTIUSER_ENABLED=${MULTIUSER_ENABLED:-true}
+ - USER_REGISTRATION_ENABLED=${USER_REGISTRATION_ENABLED:-true}
+ - EMAIL_VERIFICATION_ENABLED=${EMAIL_VERIFICATION_ENABLED:-true}
+ - CAPTCHA_ENABLED=${CAPTCHA_ENABLED:-true}
+ - TOKEN_EXPIRE_TIME=${TOKEN_EXPIRE_TIME:-86400}
+ - AUTO_REPLY_ENABLED=${AUTO_REPLY_ENABLED:-true}
+ - AUTO_DELIVERY_ENABLED=${AUTO_DELIVERY_ENABLED:-true}
+ - AUTO_DELIVERY_TIMEOUT=${AUTO_DELIVERY_TIMEOUT:-30}
+ - API_CARD_TIMEOUT=${API_CARD_TIMEOUT:-10}
+ - BATCH_DATA_LOCK_TIMEOUT=${BATCH_DATA_LOCK_TIMEOUT:-5}
+ # AI回复相关配置
+ - AI_REPLY_ENABLED=${AI_REPLY_ENABLED:-false}
+ - DEFAULT_AI_MODEL=${DEFAULT_AI_MODEL:-qwen-plus}
+ - DEFAULT_AI_BASE_URL=${DEFAULT_AI_BASE_URL:-https://dashscope.aliyuncs.com/compatible-mode/v1}
+ - AI_REQUEST_TIMEOUT=${AI_REQUEST_TIMEOUT:-30}
+ - AI_MAX_TOKENS=${AI_MAX_TOKENS:-100}
+ - WEBSOCKET_URL=${WEBSOCKET_URL:-wss://wss-goofish.dingtalk.com/}
+ - HEARTBEAT_INTERVAL=${HEARTBEAT_INTERVAL:-15}
+ - HEARTBEAT_TIMEOUT=${HEARTBEAT_TIMEOUT:-5}
+ - TOKEN_REFRESH_INTERVAL=${TOKEN_REFRESH_INTERVAL:-3600}
+ - TOKEN_RETRY_INTERVAL=${TOKEN_RETRY_INTERVAL:-300}
+ - MESSAGE_EXPIRE_TIME=${MESSAGE_EXPIRE_TIME:-300000}
+
+ networks:
+ - xianyu-network
+ healthcheck:
+ test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
+ interval: 30s
+ timeout: 10s
+ retries: 3
+ start_period: 40s
+ # 资源限制
+ deploy:
+ resources:
+ limits:
+ memory: ${MEMORY_LIMIT:-512}M
+ cpus: '${CPU_LIMIT:-0.5}'
+ reservations:
+ memory: ${MEMORY_RESERVATION:-256}M
+ cpus: '${CPU_RESERVATION:-0.25}'
+
+ # 可选:添加Nginx反向代理
+ nginx:
+ image: nginx:alpine
+ container_name: xianyu-nginx
+ restart: unless-stopped
+ ports:
+ - "80:80"
+ - "443:443"
+ volumes:
+ - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
+ - ./nginx/ssl:/etc/nginx/ssl:ro
+ depends_on:
+ - xianyu-app
+ networks:
+ - xianyu-network
+ profiles:
+ - with-nginx
+
+networks:
+ xianyu-network:
+ driver: bridge
+
+volumes:
+ xianyu-data:
+ driver: local
+ xianyu-logs:
+ driver: local
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 0000000..d9daf0e
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,105 @@
+services:
+ xianyu-app:
+ build:
+ context: .
+ dockerfile: Dockerfile
+ image: xianyu-auto-reply:latest
+ container_name: xianyu-auto-reply
+ restart: unless-stopped
+ # 使用root用户避免权限问题
+ user: "0:0"
+ ports:
+ - "${WEB_PORT:-8080}:8080"
+ volumes:
+ # 数据持久化
+ - ./data:/app/data:rw
+ - ./logs:/app/logs:rw
+ - ./global_config.yml:/app/global_config.yml:ro
+ # 可选:如果需要自定义配置
+ # - ./custom_config.yml:/app/global_config.yml:ro
+ # 可选:备份目录
+ - ./backups:/app/backups:rw
+ environment:
+ - PYTHONUNBUFFERED=${PYTHONUNBUFFERED:-1}
+ - PYTHONDONTWRITEBYTECODE=${PYTHONDONTWRITEBYTECODE:-1}
+ - TZ=${TZ:-Asia/Shanghai}
+ - DB_PATH=${DB_PATH:-/app/data/xianyu_data.db}
+ - LOG_LEVEL=${LOG_LEVEL:-INFO}
+ - DEBUG=${DEBUG:-false}
+ - RELOAD=${RELOAD:-false}
+ # SQL日志配置(默认启用,可通过环境变量覆盖)
+ - SQL_LOG_ENABLED=${SQL_LOG_ENABLED:-true}
+ - SQL_LOG_LEVEL=${SQL_LOG_LEVEL:-INFO}
+ - ADMIN_USERNAME=${ADMIN_USERNAME:-admin}
+ - ADMIN_PASSWORD=${ADMIN_PASSWORD:-admin123}
+ - JWT_SECRET_KEY=${JWT_SECRET_KEY:-default-secret-key}
+ - SESSION_TIMEOUT=${SESSION_TIMEOUT:-3600}
+ # 多用户系统配置
+ - MULTIUSER_ENABLED=${MULTIUSER_ENABLED:-true}
+ - USER_REGISTRATION_ENABLED=${USER_REGISTRATION_ENABLED:-true}
+ - EMAIL_VERIFICATION_ENABLED=${EMAIL_VERIFICATION_ENABLED:-true}
+ - CAPTCHA_ENABLED=${CAPTCHA_ENABLED:-true}
+ - TOKEN_EXPIRE_TIME=${TOKEN_EXPIRE_TIME:-86400}
+ - AUTO_REPLY_ENABLED=${AUTO_REPLY_ENABLED:-true}
+ - AUTO_DELIVERY_ENABLED=${AUTO_DELIVERY_ENABLED:-true}
+ - AUTO_DELIVERY_TIMEOUT=${AUTO_DELIVERY_TIMEOUT:-30}
+ - API_CARD_TIMEOUT=${API_CARD_TIMEOUT:-10}
+ - BATCH_DATA_LOCK_TIMEOUT=${BATCH_DATA_LOCK_TIMEOUT:-5}
+ # AI回复相关配置
+ - AI_REPLY_ENABLED=${AI_REPLY_ENABLED:-false}
+ - DEFAULT_AI_MODEL=${DEFAULT_AI_MODEL:-qwen-plus}
+ - DEFAULT_AI_BASE_URL=${DEFAULT_AI_BASE_URL:-https://dashscope.aliyuncs.com/compatible-mode/v1}
+ - AI_REQUEST_TIMEOUT=${AI_REQUEST_TIMEOUT:-30}
+ - AI_MAX_TOKENS=${AI_MAX_TOKENS:-100}
+ - WEBSOCKET_URL=${WEBSOCKET_URL:-wss://wss-goofish.dingtalk.com/}
+ - HEARTBEAT_INTERVAL=${HEARTBEAT_INTERVAL:-15}
+ - HEARTBEAT_TIMEOUT=${HEARTBEAT_TIMEOUT:-5}
+ - TOKEN_REFRESH_INTERVAL=${TOKEN_REFRESH_INTERVAL:-3600}
+ - TOKEN_RETRY_INTERVAL=${TOKEN_RETRY_INTERVAL:-300}
+ - MESSAGE_EXPIRE_TIME=${MESSAGE_EXPIRE_TIME:-300000}
+
+ networks:
+ - xianyu-network
+ healthcheck:
+ test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
+ interval: 30s
+ timeout: 10s
+ retries: 3
+ start_period: 40s
+ # 资源限制
+ deploy:
+ resources:
+ limits:
+ memory: ${MEMORY_LIMIT:-512}M
+ cpus: '${CPU_LIMIT:-0.5}'
+ reservations:
+ memory: ${MEMORY_RESERVATION:-256}M
+ cpus: '${CPU_RESERVATION:-0.25}'
+
+ # 可选:添加Nginx反向代理
+ nginx:
+ image: nginx:alpine
+ container_name: xianyu-nginx
+ restart: unless-stopped
+ ports:
+ - "80:80"
+ - "443:443"
+ volumes:
+ - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
+ - ./nginx/ssl:/etc/nginx/ssl:ro
+ depends_on:
+ - xianyu-app
+ networks:
+ - xianyu-network
+ profiles:
+ - with-nginx
+
+networks:
+ xianyu-network:
+ driver: bridge
+
+volumes:
+ xianyu-data:
+ driver: local
+ xianyu-logs:
+ driver: local
diff --git a/docker-deploy.bat b/docker-deploy.bat
new file mode 100644
index 0000000..961af36
--- /dev/null
+++ b/docker-deploy.bat
@@ -0,0 +1,228 @@
+@echo off
+chcp 65001 >nul
+setlocal enabledelayedexpansion
+
+REM 闲鱼自动回复系统 Docker 部署脚本 (Windows版本)
+REM 支持快速部署和管理
+
+title 闲鱼自动回复系统 Docker 部署
+
+REM 项目配置
+set PROJECT_NAME=xianyu-auto-reply
+set COMPOSE_FILE=docker-compose.yml
+
+REM 颜色定义(Windows CMD不支持ANSI颜色,使用echo代替)
+set "INFO_PREFIX=[INFO]"
+set "SUCCESS_PREFIX=[SUCCESS]"
+set "WARNING_PREFIX=[WARNING]"
+set "ERROR_PREFIX=[ERROR]"
+
+REM 检查依赖
+echo %INFO_PREFIX% 检查系统依赖...
+
+where docker >nul 2>&1
+if %errorlevel% neq 0 (
+ echo %ERROR_PREFIX% Docker 未安装,请先安装 Docker Desktop
+ echo 下载地址: https://www.docker.com/products/docker-desktop
+ pause
+ exit /b 1
+)
+
+where docker-compose >nul 2>&1
+if %errorlevel% neq 0 (
+ echo %ERROR_PREFIX% Docker Compose 未安装,请先安装 Docker Compose
+ pause
+ exit /b 1
+)
+
+echo %SUCCESS_PREFIX% 系统依赖检查通过
+
+REM 初始化配置
+echo %INFO_PREFIX% 初始化配置文件...
+
+REM 检查关键文件
+if not exist "entrypoint.sh" (
+ echo %ERROR_PREFIX% entrypoint.sh 文件不存在,Docker容器将无法启动
+ echo %INFO_PREFIX% 请确保项目文件完整
+ pause
+ exit /b 1
+) else (
+ echo %SUCCESS_PREFIX% entrypoint.sh 文件已存在
+)
+
+if not exist "global_config.yml" (
+ echo %ERROR_PREFIX% global_config.yml 配置文件不存在
+ echo %INFO_PREFIX% 请确保配置文件存在
+ pause
+ exit /b 1
+) else (
+ echo %SUCCESS_PREFIX% global_config.yml 配置文件已存在
+)
+
+REM 创建必要的目录
+if not exist "data" mkdir data
+if not exist "logs" mkdir logs
+if not exist "backups" mkdir backups
+if not exist "static\uploads\images" mkdir static\uploads\images
+echo %SUCCESS_PREFIX% 已创建必要的目录
+
+REM 处理命令行参数
+if "%1"=="" goto quick_deploy
+if "%1"=="help" goto show_help
+if "%1"=="start" goto start_services
+if "%1"=="stop" goto stop_services
+if "%1"=="restart" goto restart_services
+if "%1"=="status" goto show_status
+if "%1"=="logs" goto show_logs
+if "%1"=="build" goto build_image
+if "%1"=="cleanup" goto cleanup
+goto unknown_command
+
+:quick_deploy
+echo %INFO_PREFIX% 快速部署模式
+goto build_and_start
+
+:build_image
+echo %INFO_PREFIX% 构建 Docker 镜像...
+set /p use_cn="是否使用国内镜像源?(y/n): "
+if /i "!use_cn!"=="y" (
+ docker-compose -f docker-compose-cn.yml build --no-cache
+) else (
+ docker-compose build --no-cache
+)
+if %errorlevel% neq 0 (
+ echo %ERROR_PREFIX% 镜像构建失败
+ pause
+ exit /b 1
+)
+echo %SUCCESS_PREFIX% 镜像构建完成
+goto end
+
+:build_and_start
+call :build_image
+if %errorlevel% neq 0 exit /b 1
+
+:start_services
+echo %INFO_PREFIX% 启动服务...
+docker-compose up -d
+if %errorlevel% neq 0 (
+ echo %ERROR_PREFIX% 服务启动失败
+ docker-compose logs
+ pause
+ exit /b 1
+)
+
+echo %SUCCESS_PREFIX% 服务启动完成
+
+REM 等待服务就绪
+echo %INFO_PREFIX% 等待服务就绪...
+timeout /t 10 /nobreak >nul
+
+REM 检查服务状态
+docker-compose ps | findstr "Up" >nul
+if %errorlevel% equ 0 (
+ echo %SUCCESS_PREFIX% 服务运行正常
+ call :show_access_info
+) else (
+ echo %ERROR_PREFIX% 服务启动失败
+ docker-compose logs
+ pause
+ exit /b 1
+)
+goto end
+
+:stop_services
+echo %INFO_PREFIX% 停止服务...
+docker-compose down
+echo %SUCCESS_PREFIX% 服务已停止
+goto end
+
+:restart_services
+echo %INFO_PREFIX% 重启服务...
+docker-compose restart
+echo %SUCCESS_PREFIX% 服务已重启
+goto end
+
+:show_status
+echo %INFO_PREFIX% 服务状态:
+docker-compose ps
+echo.
+echo %INFO_PREFIX% 资源使用:
+for /f "tokens=*" %%i in ('docker-compose ps -q') do (
+ docker stats --no-stream %%i
+)
+goto end
+
+:show_logs
+if "%2"=="" (
+ docker-compose logs -f
+) else (
+ docker-compose logs -f %2
+)
+goto end
+
+:cleanup
+echo %WARNING_PREFIX% 这将删除所有容器、镜像和数据,确定要继续吗?
+set /p confirm="请输入 y 确认: "
+if /i "!confirm!"=="y" (
+ echo %INFO_PREFIX% 清理环境...
+ docker-compose down -v --rmi all
+ rmdir /s /q data logs backups 2>nul
+ echo %SUCCESS_PREFIX% 环境清理完成
+) else (
+ echo %INFO_PREFIX% 取消清理操作
+)
+goto end
+
+:show_access_info
+echo.
+echo %SUCCESS_PREFIX% 🎉 部署完成!
+echo.
+echo 📱 访问地址:
+echo HTTP: http://localhost:8080
+echo.
+echo 🔐 默认登录信息:
+echo 用户名: admin
+echo 密码: admin123
+echo.
+echo 📊 管理命令:
+echo 查看状态: %~nx0 status
+echo 查看日志: %~nx0 logs
+echo 重启服务: %~nx0 restart
+echo 停止服务: %~nx0 stop
+echo.
+goto :eof
+
+:show_help
+echo 闲鱼自动回复系统 Docker 部署脚本 (Windows版本)
+echo.
+echo 用法: %~nx0 [命令]
+echo.
+echo 命令:
+echo start 启动服务
+echo stop 停止服务
+echo restart 重启服务
+echo status 查看服务状态
+echo logs 查看日志
+echo build 构建镜像
+echo cleanup 清理环境
+echo help 显示帮助信息
+echo.
+echo 示例:
+echo %~nx0 # 快速部署
+echo %~nx0 start # 启动服务
+echo %~nx0 logs # 查看日志
+echo.
+goto end
+
+:unknown_command
+echo %ERROR_PREFIX% 未知命令: %1
+call :show_help
+exit /b 1
+
+:end
+if "%1"=="" (
+ echo.
+ echo 按任意键退出...
+ pause >nul
+)
diff --git a/docker-deploy.sh b/docker-deploy.sh
new file mode 100644
index 0000000..7c45749
--- /dev/null
+++ b/docker-deploy.sh
@@ -0,0 +1,360 @@
+#!/bin/bash
+
+# 闲鱼自动回复系统 Docker 部署脚本
+# 支持快速部署和管理
+
+set -e
+
+# 颜色定义
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# 项目配置
+PROJECT_NAME="xianyu-auto-reply"
+COMPOSE_FILE="docker-compose.yml"
+
+# 打印带颜色的消息
+print_info() {
+ echo -e "${BLUE}ℹ️ $1${NC}"
+}
+
+print_success() {
+ echo -e "${GREEN}✅ $1${NC}"
+}
+
+print_warning() {
+ echo -e "${YELLOW}⚠️ $1${NC}"
+}
+
+print_error() {
+ echo -e "${RED}❌ $1${NC}"
+}
+
+# 检查依赖
+check_dependencies() {
+ print_info "检查系统依赖..."
+
+ if ! command -v docker &> /dev/null; then
+ print_error "Docker 未安装,请先安装 Docker"
+ exit 1
+ fi
+
+ if ! command -v docker-compose &> /dev/null; then
+ print_error "Docker Compose 未安装,请先安装 Docker Compose"
+ exit 1
+ fi
+
+ print_success "系统依赖检查通过"
+}
+
+# 初始化配置
+init_config() {
+ print_info "初始化配置文件..."
+
+ # 检查关键文件
+ if [ ! -f "entrypoint.sh" ]; then
+ print_error "entrypoint.sh 文件不存在,Docker容器将无法启动"
+ print_info "请确保项目文件完整"
+ exit 1
+ else
+ print_success "entrypoint.sh 文件已存在"
+ fi
+
+ if [ ! -f "global_config.yml" ]; then
+ print_error "global_config.yml 配置文件不存在"
+ print_info "请确保配置文件存在"
+ exit 1
+ else
+ print_success "global_config.yml 配置文件已存在"
+ fi
+
+ # 创建必要的目录
+ mkdir -p data logs backups static/uploads/images
+ print_success "已创建必要的目录"
+}
+
+# 构建镜像
+build_image() {
+ print_info "构建 Docker 镜像..."
+ echo "是否需要使用国内镜像(y/n): " && read iscn
+ if [[ $iscn == "y" ]]; then
+ docker-compose -f docker-compose-cn.yml build --no-cache
+ else
+ docker-compose build --no-cache
+ fi
+ print_success "镜像构建完成"
+}
+
+# 启动服务
+start_services() {
+ local profile=""
+ if [ "$1" = "with-nginx" ]; then
+ profile="--profile with-nginx"
+ print_info "启动服务(包含 Nginx)..."
+ else
+ print_info "启动基础服务..."
+ fi
+
+ docker-compose $profile up -d
+ print_success "服务启动完成"
+
+ # 等待服务就绪
+ print_info "等待服务就绪..."
+ sleep 10
+
+ # 检查服务状态
+ if docker-compose ps | grep -q "Up"; then
+ print_success "服务运行正常"
+ show_access_info "$1"
+ else
+ print_error "服务启动失败"
+ docker-compose logs
+ exit 1
+ fi
+}
+
+# 停止服务
+stop_services() {
+ print_info "停止服务..."
+ docker-compose down
+ print_success "服务已停止"
+}
+
+# 重启服务
+restart_services() {
+ print_info "重启服务..."
+ docker-compose restart
+ print_success "服务已重启"
+}
+
+# 查看日志
+show_logs() {
+ local service="$1"
+ if [ -z "$service" ]; then
+ docker-compose logs -f
+ else
+ docker-compose logs -f "$service"
+ fi
+}
+
+# 查看状态
+show_status() {
+ print_info "服务状态:"
+ docker-compose ps
+
+ print_info "资源使用:"
+ docker stats --no-stream $(docker-compose ps -q)
+}
+
+# 显示访问信息
+show_access_info() {
+ local with_nginx="$1"
+
+ echo ""
+ print_success "🎉 部署完成!"
+ echo ""
+
+ if [ "$with_nginx" = "with-nginx" ]; then
+ echo "📱 访问地址:"
+ echo " HTTP: http://localhost"
+ echo " HTTPS: https://localhost (如果配置了SSL)"
+ else
+ echo "📱 访问地址:"
+ echo " HTTP: http://localhost:8080"
+ fi
+
+ echo ""
+ echo "🔐 默认登录信息:"
+ echo " 用户名: admin"
+ echo " 密码: admin123"
+ echo ""
+ echo "📊 管理命令:"
+ echo " 查看状态: $0 status"
+ echo " 查看日志: $0 logs"
+ echo " 重启服务: $0 restart"
+ echo " 停止服务: $0 stop"
+ echo ""
+}
+
+# 健康检查
+health_check() {
+ print_info "执行健康检查..."
+
+ local url="http://localhost:8080/health"
+ local max_attempts=30
+ local attempt=1
+
+ while [ $attempt -le $max_attempts ]; do
+ if curl -f -s "$url" > /dev/null 2>&1; then
+ print_success "健康检查通过"
+ return 0
+ fi
+
+ print_info "等待服务就绪... ($attempt/$max_attempts)"
+ sleep 2
+ ((attempt++))
+ done
+
+ print_error "健康检查失败"
+ return 1
+}
+
+# 备份数据
+backup_data() {
+ print_info "备份数据..."
+
+ local backup_dir="backups/$(date +%Y%m%d_%H%M%S)"
+ mkdir -p "$backup_dir"
+
+ # 备份数据库
+ if [ -f "data/xianyu_data.db" ]; then
+ cp data/xianyu_data.db "$backup_dir/"
+ print_success "数据库备份完成"
+ fi
+
+ # 备份配置
+ cp "$ENV_FILE" "$backup_dir/"
+ cp global_config.yml "$backup_dir/" 2>/dev/null || true
+
+ print_success "数据备份完成: $backup_dir"
+}
+
+# 更新部署
+update_deployment() {
+ print_info "更新部署..."
+
+ # 备份数据
+ backup_data
+
+ # 停止服务
+ stop_services
+
+ # 拉取最新代码(如果是git仓库)
+ if [ -d ".git" ]; then
+ print_info "拉取最新代码..."
+ git pull
+ fi
+
+ # 重新构建
+ build_image
+
+ # 启动服务
+ start_services
+
+ print_success "更新完成"
+}
+
+# 清理环境
+cleanup() {
+ print_warning "这将删除所有容器、镜像和数据,确定要继续吗?(y/N)"
+ read -r response
+
+ if [[ "$response" =~ ^[Yy]$ ]]; then
+ print_info "清理环境..."
+
+ # 停止并删除容器
+ docker-compose down -v --rmi all
+
+ # 删除数据目录
+ rm -rf data logs backups
+
+ print_success "环境清理完成"
+ else
+ print_info "取消清理操作"
+ fi
+}
+
+# 显示帮助信息
+show_help() {
+ echo "闲鱼自动回复系统 Docker 部署脚本"
+ echo ""
+ echo "用法: $0 [命令] [选项]"
+ echo ""
+ echo "命令:"
+ echo " init 初始化配置文件"
+ echo " build 构建 Docker 镜像"
+ echo " start [with-nginx] 启动服务(可选包含 Nginx)"
+ echo " stop 停止服务"
+ echo " restart 重启服务"
+ echo " status 查看服务状态"
+ echo " logs [service] 查看日志"
+ echo " health 健康检查"
+ echo " backup 备份数据"
+ echo " update 更新部署"
+ echo " cleanup 清理环境"
+ echo " help 显示帮助信息"
+ echo ""
+ echo "示例:"
+ echo " $0 init # 初始化配置"
+ echo " $0 start # 启动基础服务"
+ echo " $0 start with-nginx # 启动包含 Nginx 的服务"
+ echo " $0 logs xianyu-app # 查看应用日志"
+ echo ""
+}
+
+# 主函数
+main() {
+ case "$1" in
+ "init")
+ check_dependencies
+ init_config
+ ;;
+ "build")
+ check_dependencies
+ build_image
+ ;;
+ "start")
+ check_dependencies
+ init_config
+ build_image
+ start_services "$2"
+ ;;
+ "stop")
+ stop_services
+ ;;
+ "restart")
+ restart_services
+ ;;
+ "status")
+ show_status
+ ;;
+ "logs")
+ show_logs "$2"
+ ;;
+ "health")
+ health_check
+ ;;
+ "backup")
+ backup_data
+ ;;
+ "update")
+ check_dependencies
+ update_deployment
+ ;;
+ "cleanup")
+ cleanup
+ ;;
+
+ "help"|"--help"|"-h")
+ show_help
+ ;;
+ "")
+ print_info "快速部署模式"
+ check_dependencies
+ init_config
+ build_image
+ start_services
+ ;;
+ *)
+ print_error "未知命令: $1"
+ show_help
+ exit 1
+ ;;
+ esac
+}
+
+# 执行主函数
+main "$@"
diff --git a/entrypoint.sh b/entrypoint.sh
new file mode 100644
index 0000000..c472e48
--- /dev/null
+++ b/entrypoint.sh
@@ -0,0 +1,15 @@
+#!/bin/bash
+set -e
+
+echo "🚀 启动闲鱼自动回复系统..."
+echo "📊 数据库将在应用启动时自动初始化..."
+echo "🎯 启动主应用..."
+
+# 确保数据目录存在
+mkdir -p /app/data /app/logs /app/backups /app/static/uploads/images
+
+# 设置目录权限
+chmod 777 /app/data /app/logs /app/backups /app/static/uploads /app/static/uploads/images
+
+# 启动主应用
+exec python Start.py
diff --git a/file_log_collector.py b/file_log_collector.py
new file mode 100644
index 0000000..7dd51e7
--- /dev/null
+++ b/file_log_collector.py
@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""
+基于文件监控的日志收集器
+"""
+
+import os
+import re
+import time
+import threading
+from collections import deque
+from datetime import datetime
+from typing import List, Dict, Optional
+from pathlib import Path
+
+class FileLogCollector:
+ """基于文件监控的日志收集器"""
+
+ def __init__(self, max_logs: int = 2000):
+ self.max_logs = max_logs
+ self.logs = deque(maxlen=max_logs)
+ self.lock = threading.Lock()
+
+ # 日志文件路径
+ self.log_file = None
+ self.last_position = 0
+
+ # 启动文件监控
+ self.setup_file_monitoring()
+
+ def setup_file_monitoring(self):
+ """设置文件监控"""
+ # 查找日志文件
+ possible_files = [
+ "xianyu.log",
+ "app.log",
+ "system.log",
+ "logs/xianyu.log",
+ "logs/app.log"
+ ]
+
+ for file_path in possible_files:
+ if os.path.exists(file_path):
+ self.log_file = file_path
+ break
+
+ if not self.log_file:
+ # 如果没有找到现有文件,创建一个新的
+ self.log_file = "realtime.log"
+
+ # 设置loguru输出到文件
+ self.setup_loguru_file_output()
+
+ # 启动文件监控线程
+ self.monitor_thread = threading.Thread(target=self.monitor_file, daemon=True)
+ self.monitor_thread.start()
+
+ def setup_loguru_file_output(self):
+ """设置loguru输出到文件"""
+ try:
+ from loguru import logger
+
+ # 添加文件输出
+ logger.add(
+ self.log_file,
+ format="{time:YYYY-MM-DD HH:mm:ss.SSS} | {level} | {name}:{function}:{line} - {message}",
+ level="DEBUG",
+ rotation="10 MB",
+ retention="7 days",
+ enqueue=False, # 改为False,避免队列延迟
+ buffering=1 # 行缓冲,立即写入
+ )
+
+ logger.info("文件日志收集器已启动")
+
+ except ImportError:
+ pass
+
+ def monitor_file(self):
+ """监控日志文件变化"""
+ while True:
+ try:
+ if os.path.exists(self.log_file):
+ # 获取文件大小
+ file_size = os.path.getsize(self.log_file)
+
+ if file_size > self.last_position:
+ # 读取新增内容
+ with open(self.log_file, 'r', encoding='utf-8') as f:
+ f.seek(self.last_position)
+ new_lines = f.readlines()
+ self.last_position = f.tell()
+
+ # 解析新增的日志行
+ for line in new_lines:
+ self.parse_log_line(line.strip())
+
+ time.sleep(0.5) # 每0.5秒检查一次
+
+ except Exception as e:
+ time.sleep(1) # 出错时等待1秒
+
+ def parse_log_line(self, line: str):
+ """解析日志行"""
+ if not line:
+ return
+
+ try:
+ # 解析loguru格式的日志
+ # 格式: 2025-07-23 15:46:03.430 | INFO | __main__:debug_collector:70 - 消息
+ pattern = r'(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}) \| (\w+) \| ([^:]+):([^:]+):(\d+) - (.*)'
+ match = re.match(pattern, line)
+
+ if match:
+ timestamp_str, level, source, function, line_num, message = match.groups()
+
+ # 转换时间格式
+ try:
+ timestamp = datetime.strptime(timestamp_str, '%Y-%m-%d %H:%M:%S.%f')
+ except:
+ timestamp = datetime.now()
+
+ log_entry = {
+ "timestamp": timestamp.isoformat(),
+ "level": level,
+ "source": source,
+ "function": function,
+ "line": int(line_num),
+ "message": message
+ }
+
+ with self.lock:
+ self.logs.append(log_entry)
+
+ except Exception as e:
+ # 如果解析失败,作为普通消息处理
+ log_entry = {
+ "timestamp": datetime.now().isoformat(),
+ "level": "INFO",
+ "source": "system",
+ "function": "unknown",
+ "line": 0,
+ "message": line
+ }
+
+ with self.lock:
+ self.logs.append(log_entry)
+
+ def get_logs(self, lines: int = 200, level_filter: str = None, source_filter: str = None) -> List[Dict]:
+ """获取日志记录"""
+ with self.lock:
+ logs_list = list(self.logs)
+
+ # 应用过滤器
+ if level_filter:
+ logs_list = [log for log in logs_list if log['level'] == level_filter]
+
+ if source_filter:
+ logs_list = [log for log in logs_list if source_filter.lower() in log['source'].lower()]
+
+ # 返回最后N行
+ return logs_list[-lines:] if len(logs_list) > lines else logs_list
+
+ def clear_logs(self):
+ """清空日志"""
+ with self.lock:
+ self.logs.clear()
+
+ def get_stats(self) -> Dict:
+ """获取日志统计信息"""
+ with self.lock:
+ total_logs = len(self.logs)
+
+ # 统计各级别日志数量
+ level_counts = {}
+ source_counts = {}
+
+ for log in self.logs:
+ level = log['level']
+ source = log['source']
+
+ level_counts[level] = level_counts.get(level, 0) + 1
+ source_counts[source] = source_counts.get(source, 0) + 1
+
+ return {
+ "total_logs": total_logs,
+ "level_counts": level_counts,
+ "source_counts": source_counts,
+ "max_capacity": self.max_logs,
+ "log_file": self.log_file
+ }
+
+
+# 全局文件日志收集器实例
+_file_collector = None
+_file_collector_lock = threading.Lock()
+
+
+def get_file_log_collector() -> FileLogCollector:
+ """获取全局文件日志收集器实例"""
+ global _file_collector
+
+ if _file_collector is None:
+ with _file_collector_lock:
+ if _file_collector is None:
+ _file_collector = FileLogCollector(max_logs=2000)
+
+ return _file_collector
+
+
+def setup_file_logging():
+ """设置文件日志系统"""
+ collector = get_file_log_collector()
+ return collector
+
+
+if __name__ == "__main__":
+ # 测试文件日志收集器
+ collector = setup_file_logging()
+
+ # 生成一些测试日志
+ from loguru import logger
+
+ logger.info("文件日志收集器测试开始")
+ logger.debug("这是调试信息")
+ logger.warning("这是警告信息")
+ logger.error("这是错误信息")
+ logger.info("文件日志收集器测试结束")
+
+ # 等待文件写入和监控
+ time.sleep(2)
+
+ # 获取日志
+ logs = collector.get_logs(10)
+ print(f"收集到 {len(logs)} 条日志:")
+ for log in logs:
+ print(f" [{log['level']}] {log['source']}: {log['message']}")
+
+ # 获取统计信息
+ stats = collector.get_stats()
+ print(f"\n统计信息: {stats}")
diff --git a/global_config.yml b/global_config.yml
new file mode 100644
index 0000000..d1b7ac2
--- /dev/null
+++ b/global_config.yml
@@ -0,0 +1,89 @@
+API_ENDPOINTS:
+ login_check: https://passport.goofish.com/newlogin/hasLogin.do
+ message_headinfo: https://h5api.m.goofish.com/h5/mtop.idle.trade.pc.message.headinfo/1.0/
+ token: https://h5api.m.goofish.com/h5/mtop.taobao.idlemessage.pc.login.token/1.0/
+APP_CONFIG:
+ api_version: '1.0'
+ app_key: 444e9908a51d1cb236a27862abc769c9
+ app_version: '1.0'
+ platform: web
+AUTO_REPLY:
+ api:
+ enabled: false # 禁用API回复,使用AI回复或关键词回复
+ host: 0.0.0.0 # 绑定所有网络接口,支持IP访问
+ port: 8080 # Web服务端口
+ timeout: 10
+ url: http://localhost:8080/xianyu/reply # 修复URL地址
+ default_message: 亲爱的"{send_user_name}" 老板你好!所有宝贝都可以拍,秒发货的哈~不满意的话可以直接申请退款哈~
+ enabled: true
+ max_retry: 3
+ retry_interval: 5
+ITEM_DETAIL:
+ auto_fetch:
+ enabled: true # 是否启用自动获取商品详情
+ api_url: https://selfapi.zhinianboke.com/api/getItemDetail # 外部API地址
+ timeout: 30 # 请求超时时间(秒)
+ max_concurrent: 3 # 最大并发请求数
+ retry_delay: 0.5 # 请求间隔(秒)
+COOKIES:
+ last_update_time: ''
+ value: ''
+DEFAULT_HEADERS:
+ accept: application/json
+ accept-language: zh-CN,zh;q=0.9
+ cache-control: no-cache
+ origin: https://www.goofish.com
+ pragma: no-cache
+ priority: u=1, i
+ referer: https://www.goofish.com/
+ sec-ch-ua: '"Not(A:Brand";v="99", "Google Chrome";v="133", "Chromium";v="133"'
+ sec-ch-ua-mobile: ?0
+ sec-ch-ua-platform: '"Windows"'
+ sec-fetch-dest: empty
+ sec-fetch-mode: cors
+ sec-fetch-site: same-site
+ user-agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML,
+ like Gecko) Chrome/133.0.0.0 Safari/537.36
+HEARTBEAT_INTERVAL: 15
+HEARTBEAT_TIMEOUT: 5
+LOG_CONFIG:
+ compression: zip
+ format: '{time:YYYY-MM-DD HH:mm:ss.SSS} | {level: <8}
+ | {name}:{function}:{line} - {message}'
+ level: INFO
+ retention: 7 days
+ rotation: 1 day
+MANUAL_MODE:
+ enabled: false
+ timeout: 3600
+ toggle_keywords: []
+MESSAGE_EXPIRE_TIME: 300000
+TOKEN_REFRESH_INTERVAL: 36000 # 10小时刷新一次token(原来20小时太长)
+TOKEN_RETRY_INTERVAL: 1800 # 失败后30分钟重试(原来2小时太长)
+COOKIE_KEEPALIVE_INTERVAL: 7200 # 每2小时发一次保活请求,延长Cookie有效期
+WEBSOCKET_HEADERS:
+ Accept-Encoding: gzip, deflate, br, zstd
+ Accept-Language: zh-CN,zh;q=0.9
+ Cache-Control: no-cache
+ Connection: Upgrade
+ Host: wss-goofish.dingtalk.com
+ Origin: https://www.goofish.com
+ Pragma: no-cache
+ User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML,
+ like Gecko) Chrome/133.0.0.0 Safari/537.36
+WEBSOCKET_URL: wss://wss-goofish.dingtalk.com/
+
+# 阿奇索转卖配置
+AGISO_CONFIG:
+ enabled: true # 是否启用了阿奇索转卖功能
+ base_url: https://aldsidle.agiso.com # 阿奇索平台地址
+ api_endpoints:
+ verify: /api/GetUserInfo # 验证账户接口
+ upload: /api/upload # 图片上传接口
+ publish: /api/item/publish # 商品发布接口
+ item_list: /api/item/list # 商品列表接口
+ category_list: /api/category/list # 分类列表接口
+ timeout: 60 # 请求超时时间(秒)
+ max_concurrent: 3 # 最大并发请求数
+ retry_times: 2 # 重试次数
+ retry_delay: 1 # 重试间隔(秒)
diff --git a/nginx/nginx.conf b/nginx/nginx.conf
new file mode 100644
index 0000000..cb8c977
--- /dev/null
+++ b/nginx/nginx.conf
@@ -0,0 +1,123 @@
+events {
+ worker_connections 1024;
+}
+
+http {
+ include /etc/nginx/mime.types;
+ default_type application/octet-stream;
+
+ # 日志格式
+ log_format main '$remote_addr - $remote_user [$time_local] "$request" '
+ '$status $body_bytes_sent "$http_referer" '
+ '"$http_user_agent" "$http_x_forwarded_for"';
+
+ access_log /var/log/nginx/access.log main;
+ error_log /var/log/nginx/error.log warn;
+
+ # 基本设置
+ sendfile on;
+ tcp_nopush on;
+ tcp_nodelay on;
+ keepalive_timeout 65;
+ types_hash_max_size 2048;
+ client_max_body_size 10M;
+
+ # Gzip压缩
+ gzip on;
+ gzip_vary on;
+ gzip_min_length 1024;
+ gzip_proxied any;
+ gzip_comp_level 6;
+ gzip_types
+ text/plain
+ text/css
+ text/xml
+ text/javascript
+ application/json
+ application/javascript
+ application/xml+rss
+ application/atom+xml
+ image/svg+xml;
+
+ # 上游服务器
+ upstream xianyu_backend {
+ server xianyu-app:8080;
+ keepalive 32;
+ }
+
+ # HTTP服务器配置
+ server {
+ listen 80;
+ server_name localhost;
+
+ # 安全头
+ add_header X-Frame-Options "SAMEORIGIN" always;
+ add_header X-XSS-Protection "1; mode=block" always;
+ add_header X-Content-Type-Options "nosniff" always;
+ add_header Referrer-Policy "no-referrer-when-downgrade" always;
+ add_header Content-Security-Policy "default-src 'self' http: https: data: blob: 'unsafe-inline'" always;
+
+ # 代理到后端应用
+ location / {
+ proxy_pass http://xianyu_backend;
+ proxy_http_version 1.1;
+ proxy_set_header Upgrade $http_upgrade;
+ proxy_set_header Connection 'upgrade';
+ proxy_set_header Host $host;
+ proxy_set_header X-Real-IP $remote_addr;
+ proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+ proxy_set_header X-Forwarded-Proto $scheme;
+ proxy_cache_bypass $http_upgrade;
+ proxy_connect_timeout 30s;
+ proxy_send_timeout 30s;
+ proxy_read_timeout 30s;
+ }
+
+ # 静态文件缓存
+ location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg)$ {
+ proxy_pass http://xianyu_backend;
+ expires 1y;
+ add_header Cache-Control "public, immutable";
+ }
+
+ # 健康检查
+ location /health {
+ proxy_pass http://xianyu_backend/health;
+ access_log off;
+ }
+
+ # 错误页面
+ error_page 500 502 503 504 /50x.html;
+ location = /50x.html {
+ root /usr/share/nginx/html;
+ }
+ }
+
+ # HTTPS服务器配置(可选)
+ # server {
+ # listen 443 ssl http2;
+ # server_name localhost;
+ #
+ # ssl_certificate /etc/nginx/ssl/cert.pem;
+ # ssl_certificate_key /etc/nginx/ssl/key.pem;
+ # ssl_session_timeout 1d;
+ # ssl_session_cache shared:MozTLS:10m;
+ # ssl_session_tickets off;
+ #
+ # ssl_protocols TLSv1.2 TLSv1.3;
+ # ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384;
+ # ssl_prefer_server_ciphers off;
+ #
+ # location / {
+ # proxy_pass http://xianyu_backend;
+ # proxy_http_version 1.1;
+ # proxy_set_header Upgrade $http_upgrade;
+ # proxy_set_header Connection 'upgrade';
+ # proxy_set_header Host $host;
+ # proxy_set_header X-Real-IP $remote_addr;
+ # proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+ # proxy_set_header X-Forwarded-Proto $scheme;
+ # proxy_cache_bypass $http_upgrade;
+ # }
+ # }
+}
diff --git a/reply_server.py b/reply_server.py
new file mode 100644
index 0000000..eb47917
--- /dev/null
+++ b/reply_server.py
@@ -0,0 +1,5014 @@
+from fastapi import FastAPI, HTTPException, Depends, status, UploadFile, File, Form, Body
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse, RedirectResponse, JSONResponse, StreamingResponse
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from pydantic import BaseModel
+from typing import List, Tuple, Optional, Dict, Any
+from starlette.requests import Request
+from pathlib import Path
+from urllib.parse import unquote
+import hashlib
+import secrets
+import time
+import json
+import os
+import uvicorn
+import pandas as pd
+import io
+
+import cookie_manager
+from db_manager import db_manager
+from file_log_collector import setup_file_logging, get_file_log_collector
+from ai_reply_engine import ai_reply_engine
+from utils.qr_login import qr_login_manager
+from utils.xianyu_utils import trans_cookies
+from utils.image_utils import image_manager
+from utils.user_profile import get_user_profile_from_cookies
+from loguru import logger
+
+# 关键字文件路径
+KEYWORDS_FILE = Path(__file__).parent / "回复关键字.txt"
+
+# 简单的用户认证配置
+ADMIN_USERNAME = "admin"
+DEFAULT_ADMIN_PASSWORD = "admin123" # 系统初始化时的默认密码
+SESSION_TOKENS = {} # 存储会话token: {token: {'user_id': int, 'username': str, 'timestamp': float}}
+TOKEN_EXPIRE_TIME = 24 * 60 * 60 # token过期时间:24小时
+
+# HTTP Bearer认证
+security = HTTPBearer(auto_error=False)
+
+# 不再需要单独的密码初始化,由数据库初始化时处理
+
+
+def load_keywords() -> List[Tuple[str, str]]:
+ """读取关键字→回复映射表
+
+ 文件格式支持:
+ 关键字<空格/制表符/冒号>回复内容
+ 忽略空行和以 # 开头的注释行
+ """
+ mapping: List[Tuple[str, str]] = []
+ if not KEYWORDS_FILE.exists():
+ return mapping
+
+ with KEYWORDS_FILE.open('r', encoding='utf-8') as f:
+ for line in f:
+ line = line.strip()
+ if not line or line.startswith('#'):
+ continue
+ # 尝试用\t、空格、冒号分隔
+ if '\t' in line:
+ key, reply = line.split('\t', 1)
+ elif ' ' in line:
+ key, reply = line.split(' ', 1)
+ elif ':' in line:
+ key, reply = line.split(':', 1)
+ else:
+ # 无法解析的行,跳过
+ continue
+ mapping.append((key.strip(), reply.strip()))
+ return mapping
+
+
+KEYWORDS_MAPPING = load_keywords()
+
+
+# 认证相关模型
+class LoginRequest(BaseModel):
+ username: Optional[str] = None
+ password: Optional[str] = None
+ email: Optional[str] = None
+ verification_code: Optional[str] = None
+
+
+class LoginResponse(BaseModel):
+ success: bool
+ token: Optional[str] = None
+ message: str
+ user_id: Optional[int] = None
+ username: Optional[str] = None
+ is_admin: Optional[bool] = None
+ captcha_required: bool = False
+
+
+class ChangePasswordRequest(BaseModel):
+ current_password: str
+ new_password: str
+
+
+class RegisterRequest(BaseModel):
+ username: str
+ email: str
+ password: str
+ verification_code: str
+
+
+class RegisterResponse(BaseModel):
+ success: bool
+ message: str
+
+
+class SendCodeRequest(BaseModel):
+ email: str
+ session_id: Optional[str] = None
+ type: Optional[str] = 'register' # 'register' 或 'login'
+
+
+class SendCodeResponse(BaseModel):
+ success: bool
+ message: str
+
+
+class CaptchaRequest(BaseModel):
+ session_id: str
+
+
+class CaptchaResponse(BaseModel):
+ success: bool
+ captcha_image: str
+ session_id: str
+ message: str
+
+
+class VerifyCaptchaRequest(BaseModel):
+ session_id: str
+ captcha_code: str
+
+
+class VerifyCaptchaResponse(BaseModel):
+ success: bool
+ message: str
+
+
+def generate_token() -> str:
+ """生成随机token"""
+ return secrets.token_urlsafe(32)
+
+
+def verify_token(credentials: Optional[HTTPAuthorizationCredentials] = Depends(security)) -> Optional[Dict[str, Any]]:
+ """验证token并返回用户信息"""
+ if not credentials:
+ return None
+
+ token = credentials.credentials
+ if token not in SESSION_TOKENS:
+ return None
+
+ token_data = SESSION_TOKENS[token]
+
+ # 检查token是否过期
+ if time.time() - token_data['timestamp'] > TOKEN_EXPIRE_TIME:
+ del SESSION_TOKENS[token]
+ return None
+
+ return token_data
+
+
+def verify_admin_token(credentials: Optional[HTTPAuthorizationCredentials] = Depends(security)) -> Dict[str, Any]:
+ """验证管理员token"""
+ user_info = verify_token(credentials)
+ if not user_info:
+ raise HTTPException(status_code=401, detail="未授权访问")
+
+ # 检查是否是管理员
+ if user_info['username'] != ADMIN_USERNAME:
+ raise HTTPException(status_code=403, detail="需要管理员权限")
+
+ return user_info
+
+
+def require_auth(user_info: Optional[Dict[str, Any]] = Depends(verify_token)):
+ """需要认证的依赖,返回用户信息"""
+ if not user_info:
+ raise HTTPException(status_code=401, detail="未授权访问")
+ return user_info
+
+
+def get_current_user(user_info: Dict[str, Any] = Depends(require_auth)) -> Dict[str, Any]:
+ """获取当前登录用户信息"""
+ return user_info
+
+
+def get_current_user_optional(user_info: Optional[Dict[str, Any]] = Depends(verify_token)) -> Optional[Dict[str, Any]]:
+ """获取当前用户信息(可选,不强制要求登录)"""
+ return user_info
+
+
+def get_user_log_prefix(user_info: Dict[str, Any] = None) -> str:
+ """获取用户日志前缀"""
+ if user_info:
+ return f"【{user_info['username']}#{user_info['user_id']}】"
+ return "【系统】"
+
+
+def require_admin(current_user: Dict[str, Any] = Depends(get_current_user)) -> Dict[str, Any]:
+ """要求管理员权限"""
+ role = current_user.get('role', 'user')
+ if role != 'admin' and current_user['username'] != 'admin':
+ raise HTTPException(status_code=403, detail="需要管理员权限")
+ return current_user
+
+
+def get_user_permissions() -> dict:
+ """从系统设置中获取角色权限配置"""
+ from db_manager import db_manager as _db
+ try:
+ val = _db.get_system_setting('user_permissions')
+ if val:
+ return json.loads(val)
+ except Exception:
+ pass
+ return {}
+
+
+ALL_PERMISSIONS = {
+ 'dashboard': '仪表盘',
+ 'accounts': '账号管理',
+ 'items': '商品管理',
+ 'orders': '订单管理',
+ 'auto_reply': '自动回复',
+ 'ai_conversation': 'AI对话历史',
+ 'items_reply': '指定商品回复',
+ 'cards': '卡券管理',
+ 'auto_delivery': '自动发货',
+ 'notification_channels': '通知渠道',
+ 'message_notifications': '消息通知',
+ 'item_search': '商品搜索',
+ 'password_settings': '密码设置',
+ 'system_settings': '系统设置',
+ 'user_management': '用户管理',
+ 'system_logs': '系统日志',
+ 'data_management': '数据管理',
+ 'export_backup': '备份导出',
+ 'import_backup': '备份导入',
+}
+
+
+def get_role_permissions(role: str, roles_config: dict = None) -> dict:
+ """获取指定角色的权限字典"""
+ if roles_config is None:
+ roles_config = get_user_permissions()
+ role_data = roles_config.get(role, {})
+ if isinstance(role_data, dict):
+ return role_data
+ return {}
+
+
+def has_permission(current_user: Dict[str, Any], permission: str) -> bool:
+ """检查当前用户是否有指定权限"""
+ username = current_user.get('username', '')
+ if username == 'admin':
+ return True
+ role = current_user.get('role', 'user')
+ roles_config = get_user_permissions()
+ role_perms = get_role_permissions(role, roles_config)
+ # admin 角色默认拥有所有权限
+ if role == 'admin' and not role_perms:
+ return True
+ return role_perms.get(permission, False) is True
+
+
+def require_permission(permission: str):
+ """返回一个依赖项,检查用户是否有指定权限"""
+ def _checker(current_user: Dict[str, Any] = Depends(get_current_user)):
+ if not has_permission(current_user, permission):
+ raise HTTPException(status_code=403, detail=f"没有「{ALL_PERMISSIONS.get(permission, permission)}」权限,请联系管理员")
+ return current_user
+ return _checker
+
+
+def log_with_user(level: str, message: str, user_info: Dict[str, Any] = None):
+ """带用户信息的日志记录"""
+ prefix = get_user_log_prefix(user_info)
+ full_message = f"{prefix} {message}"
+
+ if level.lower() == 'info':
+ logger.info(full_message)
+ elif level.lower() == 'error':
+ logger.error(full_message)
+ elif level.lower() == 'warning':
+ logger.warning(full_message)
+ elif level.lower() == 'debug':
+ logger.debug(full_message)
+ else:
+ logger.info(full_message)
+
+
+def match_reply(cookie_id: str, message: str) -> Optional[str]:
+ """根据 cookie_id 及消息内容匹配回复
+ 只有启用的账号才会匹配关键字回复
+ """
+ mgr = cookie_manager.manager
+ if mgr is None:
+ return None
+
+ # 检查账号是否启用
+ if not mgr.get_cookie_status(cookie_id):
+ return None # 禁用的账号不参与自动回复
+
+ # 优先账号级关键字
+ if mgr.get_keywords(cookie_id):
+ for k, r in mgr.get_keywords(cookie_id):
+ if k in message:
+ return r
+
+ # 全局关键字
+ for k, r in KEYWORDS_MAPPING:
+ if k in message:
+ return r
+ return None
+
+
+class RequestModel(BaseModel):
+ cookie_id: str
+ msg_time: str
+ user_url: str
+ send_user_id: str
+ send_user_name: str
+ item_id: str
+ send_message: str
+ chat_id: str
+
+
+class ResponseData(BaseModel):
+ send_msg: str
+
+
+class ResponseModel(BaseModel):
+ code: int
+ data: ResponseData
+
+
+app = FastAPI(
+ title="Xianyu Auto Reply API",
+ version="1.0.0",
+ description="闲鱼自动回复系统API",
+ docs_url="/docs",
+ redoc_url="/redoc"
+)
+
+# 初始化文件日志收集器
+setup_file_logging()
+
+# 添加一条测试日志
+from loguru import logger
+logger.info("Web服务器启动,文件日志收集器已初始化")
+
+# 添加请求日志中间件
+@app.middleware("http")
+async def log_requests(request, call_next):
+ start_time = time.time()
+
+ # 获取用户信息
+ user_info = "未登录"
+ try:
+ # 从请求头中获取Authorization
+ auth_header = request.headers.get("Authorization")
+ if auth_header and auth_header.startswith("Bearer "):
+ token = auth_header.split(" ")[1]
+ if token in SESSION_TOKENS:
+ token_data = SESSION_TOKENS[token]
+ # 检查token是否过期
+ if time.time() - token_data['timestamp'] <= TOKEN_EXPIRE_TIME:
+ user_info = f"【{token_data['username']}#{token_data['user_id']}】"
+ except Exception:
+ pass
+
+ logger.info(f"🌐 {user_info} API请求: {request.method} {request.url.path}")
+
+ response = await call_next(request)
+
+ process_time = time.time() - start_time
+ logger.info(f"✅ {user_info} API响应: {request.method} {request.url.path} - {response.status_code} ({process_time:.3f}s)")
+
+ return response
+
+# 提供前端静态文件
+import os
+static_dir = os.path.join(os.path.dirname(__file__), 'static')
+if not os.path.exists(static_dir):
+ os.makedirs(static_dir, exist_ok=True)
+
+app.mount('/static', StaticFiles(directory=static_dir), name='static')
+
+# 确保图片上传目录存在
+uploads_dir = os.path.join(static_dir, 'uploads', 'images')
+if not os.path.exists(uploads_dir):
+ os.makedirs(uploads_dir, exist_ok=True)
+ logger.info(f"创建图片上传目录: {uploads_dir}")
+
+# 健康检查端点
+@app.get('/health')
+async def health_check():
+ """健康检查端点,用于Docker健康检查和负载均衡器"""
+ try:
+ # 检查Cookie管理器状态
+ manager_status = "ok" if cookie_manager.manager is not None else "error"
+
+ # 检查数据库连接
+ from db_manager import db_manager
+ try:
+ db_manager.get_all_cookies()
+ db_status = "ok"
+ except Exception:
+ db_status = "error"
+
+ # 获取系统状态
+ import psutil
+ cpu_percent = psutil.cpu_percent(interval=1)
+ memory_info = psutil.virtual_memory()
+
+ status = {
+ "status": "healthy" if manager_status == "ok" and db_status == "ok" else "unhealthy",
+ "timestamp": time.time(),
+ "services": {
+ "cookie_manager": manager_status,
+ "database": db_status
+ },
+ "system": {
+ "cpu_percent": cpu_percent,
+ "memory_percent": memory_info.percent,
+ "memory_available": memory_info.available
+ }
+ }
+
+ if status["status"] == "unhealthy":
+ raise HTTPException(status_code=503, detail=status)
+
+ return status
+
+ except Exception as e:
+ return {
+ "status": "unhealthy",
+ "timestamp": time.time(),
+ "error": str(e)
+ }
+
+
+# 重定向根路径到登录页面
+@app.get('/', response_class=HTMLResponse)
+async def root():
+ login_path = os.path.join(static_dir, 'login.html')
+ if os.path.exists(login_path):
+ with open(login_path, 'r', encoding='utf-8') as f:
+ return HTMLResponse(f.read())
+ else:
+ return HTMLResponse('
Login page not found
')
+
+
+# 登录页面路由
+@app.get('/login.html', response_class=HTMLResponse)
+async def login_page():
+ login_path = os.path.join(static_dir, 'login.html')
+ if os.path.exists(login_path):
+ with open(login_path, 'r', encoding='utf-8') as f:
+ return HTMLResponse(f.read())
+ else:
+ return HTMLResponse('Login page not found
')
+
+
+# 注册页面路由
+@app.get('/register.html', response_class=HTMLResponse)
+async def register_page():
+ # 检查注册是否开启
+ from db_manager import db_manager
+ registration_enabled = db_manager.get_system_setting('registration_enabled')
+ if registration_enabled != 'true':
+ return HTMLResponse('''
+
+
+
+ 注册已关闭
+
+
+
+
+ 🚫 注册功能已关闭
+ 系统管理员已关闭用户注册功能
+
+
+
+ ''', status_code=403)
+
+ register_path = os.path.join(static_dir, 'register.html')
+ if os.path.exists(register_path):
+ with open(register_path, 'r', encoding='utf-8') as f:
+ return HTMLResponse(f.read())
+ else:
+ return HTMLResponse('Register page not found
')
+
+
+# 管理页面(不需要服务器端认证,由前端JavaScript处理)
+@app.get('/admin', response_class=HTMLResponse)
+async def admin_page():
+ index_path = os.path.join(static_dir, 'index.html')
+ if not os.path.exists(index_path):
+ return HTMLResponse('No front-end found
')
+ with open(index_path, 'r', encoding='utf-8') as f:
+ return HTMLResponse(f.read())
+
+
+# 用户管理页面路由
+@app.get('/user_management.html', response_class=HTMLResponse)
+async def user_management_page():
+ page_path = os.path.join(static_dir, 'user_management.html')
+ if os.path.exists(page_path):
+ with open(page_path, 'r', encoding='utf-8') as f:
+ return HTMLResponse(f.read())
+ else:
+ return HTMLResponse('User management page not found
')
+
+
+# 日志管理页面路由
+@app.get('/log_management.html', response_class=HTMLResponse)
+async def log_management_page():
+ page_path = os.path.join(static_dir, 'log_management.html')
+ if os.path.exists(page_path):
+ with open(page_path, 'r', encoding='utf-8') as f:
+ return HTMLResponse(f.read())
+ else:
+ return HTMLResponse('Log management page not found
')
+
+
+# 数据管理页面路由
+@app.get('/data_management.html', response_class=HTMLResponse)
+async def data_management_page():
+ page_path = os.path.join(static_dir, 'data_management.html')
+ if os.path.exists(page_path):
+ with open(page_path, 'r', encoding='utf-8') as f:
+ return HTMLResponse(f.read())
+ else:
+ return HTMLResponse('Data management page not found
')
+
+
+
+
+
+# 商品搜索页面路由
+@app.get('/item_search.html', response_class=HTMLResponse)
+async def item_search_page():
+ page_path = os.path.join(static_dir, 'item_search.html')
+ if os.path.exists(page_path):
+ with open(page_path, 'r', encoding='utf-8') as f:
+ return HTMLResponse(f.read())
+ else:
+ return HTMLResponse('Item search page not found
')
+
+
+# 登录接口
+@app.post('/login')
+async def login(request: LoginRequest):
+ from db_manager import db_manager
+
+ # 判断登录方式
+ if request.username and request.password:
+ # 用户名/密码登录
+ logger.info(f"【{request.username}】尝试用户名登录")
+
+ # 统一使用用户表验证(包括admin用户)
+ if db_manager.verify_user_password(request.username, request.password):
+ user = db_manager.get_user_by_username(request.username)
+ if user:
+ # 生成token
+ token = generate_token()
+ SESSION_TOKENS[token] = {
+ 'user_id': user['id'],
+ 'username': user['username'],
+ 'role': user.get('role', 'user'),
+ 'timestamp': time.time()
+ }
+
+ # 区分管理员和普通用户的日志
+ if user['username'] == ADMIN_USERNAME:
+ logger.info(f"【{user['username']}#{user['id']}】登录成功(管理员)")
+ else:
+ logger.info(f"【{user['username']}#{user['id']}】登录成功")
+
+ return LoginResponse(
+ success=True,
+ token=token,
+ message="登录成功",
+ user_id=user['id'],
+ username=user['username'],
+ is_admin=(user['username'] == ADMIN_USERNAME)
+ )
+
+ logger.warning(f"【{request.username}】登录失败:用户名或密码错误")
+ return LoginResponse(
+ success=False,
+ message="用户名或密码错误",
+ captcha_required=True
+ )
+
+ elif request.email and request.password:
+ # 邮箱/密码登录
+ logger.info(f"【{request.email}】尝试邮箱密码登录")
+
+ user = db_manager.get_user_by_email(request.email)
+ if user and db_manager.verify_user_password(user['username'], request.password):
+ # 生成token
+ token = generate_token()
+ SESSION_TOKENS[token] = {
+ 'user_id': user['id'],
+ 'username': user['username'],
+ 'role': user.get('role', 'user'),
+ 'timestamp': time.time()
+ }
+
+ logger.info(f"【{user['username']}#{user['id']}】邮箱登录成功")
+
+ return LoginResponse(
+ success=True,
+ token=token,
+ message="登录成功",
+ user_id=user['id'],
+ username=user['username'],
+ is_admin=(user['username'] == ADMIN_USERNAME)
+ )
+
+ logger.warning(f"【{request.email}】邮箱登录失败:邮箱或密码错误")
+ return LoginResponse(
+ success=False,
+ message="邮箱或密码错误",
+ captcha_required=True
+ )
+
+ elif request.email and request.verification_code:
+ # 邮箱/验证码登录
+ logger.info(f"【{request.email}】尝试邮箱验证码登录")
+
+ # 验证邮箱验证码
+ if not db_manager.verify_email_code(request.email, request.verification_code, 'login'):
+ logger.warning(f"【{request.email}】验证码登录失败:验证码错误或已过期")
+ return LoginResponse(
+ success=False,
+ message="验证码错误或已过期"
+ )
+
+ # 获取用户信息
+ user = db_manager.get_user_by_email(request.email)
+ if not user:
+ logger.warning(f"【{request.email}】验证码登录失败:用户不存在")
+ return LoginResponse(
+ success=False,
+ message="用户不存在"
+ )
+
+ # 生成token
+ token = generate_token()
+ SESSION_TOKENS[token] = {
+ 'user_id': user['id'],
+ 'username': user['username'],
+ 'role': user.get('role', 'user'),
+ 'timestamp': time.time()
+ }
+
+ logger.info(f"【{user['username']}#{user['id']}】验证码登录成功")
+
+ return LoginResponse(
+ success=True,
+ token=token,
+ message="登录成功",
+ user_id=user['id'],
+ username=user['username'],
+ is_admin=(user['username'] == ADMIN_USERNAME)
+ )
+
+ else:
+ return LoginResponse(
+ success=False,
+ message="请提供有效的登录信息"
+ )
+
+
+# 验证token接口
+@app.get('/verify')
+async def verify(user_info: Optional[Dict[str, Any]] = Depends(verify_token)):
+ if user_info:
+ role = user_info.get('role', 'user')
+ return {
+ "authenticated": True,
+ "user_id": user_info['user_id'],
+ "username": user_info['username'],
+ "role": role,
+ "is_admin": role == 'admin' or user_info['username'] == ADMIN_USERNAME
+ }
+ return {"authenticated": False}
+
+
+# 登出接口
+@app.post('/logout')
+async def logout(credentials: Optional[HTTPAuthorizationCredentials] = Depends(security)):
+ if credentials and credentials.credentials in SESSION_TOKENS:
+ del SESSION_TOKENS[credentials.credentials]
+ return {"message": "已登出"}
+
+
+# 修改管理员密码接口
+@app.post('/change-admin-password')
+async def change_admin_password(request: ChangePasswordRequest, admin_user: Dict[str, Any] = Depends(verify_admin_token)):
+ from db_manager import db_manager
+
+ try:
+ # 验证当前密码(使用用户表验证)
+ if not db_manager.verify_user_password('admin', request.current_password):
+ return {"success": False, "message": "当前密码错误"}
+
+ # 更新密码(使用用户表更新)
+ success = db_manager.update_user_password('admin', request.new_password)
+
+ if success:
+ logger.info(f"【admin#{admin_user['user_id']}】管理员密码修改成功")
+ return {"success": True, "message": "密码修改成功"}
+ else:
+ return {"success": False, "message": "密码修改失败"}
+
+ except Exception as e:
+ logger.error(f"修改管理员密码异常: {e}")
+ return {"success": False, "message": "系统错误"}
+
+
+# 生成图形验证码接口
+@app.post('/generate-captcha')
+async def generate_captcha(request: CaptchaRequest):
+ from db_manager import db_manager
+
+ try:
+ # 生成图形验证码
+ captcha_text, captcha_image = db_manager.generate_captcha()
+
+ if not captcha_image:
+ return CaptchaResponse(
+ success=False,
+ captcha_image="",
+ session_id=request.session_id,
+ message="图形验证码生成失败"
+ )
+
+ # 保存验证码到数据库
+ if db_manager.save_captcha(request.session_id, captcha_text):
+ return CaptchaResponse(
+ success=True,
+ captcha_image=captcha_image,
+ session_id=request.session_id,
+ message="图形验证码生成成功"
+ )
+ else:
+ return CaptchaResponse(
+ success=False,
+ captcha_image="",
+ session_id=request.session_id,
+ message="图形验证码保存失败"
+ )
+
+ except Exception as e:
+ logger.error(f"生成图形验证码失败: {e}")
+ return CaptchaResponse(
+ success=False,
+ captcha_image="",
+ session_id=request.session_id,
+ message="图形验证码生成失败"
+ )
+
+
+# 验证图形验证码接口
+@app.post('/verify-captcha')
+async def verify_captcha(request: VerifyCaptchaRequest):
+ from db_manager import db_manager
+
+ try:
+ if db_manager.verify_captcha(request.session_id, request.captcha_code):
+ return VerifyCaptchaResponse(
+ success=True,
+ message="图形验证码验证成功"
+ )
+ else:
+ return VerifyCaptchaResponse(
+ success=False,
+ message="图形验证码错误或已过期"
+ )
+
+ except Exception as e:
+ logger.error(f"验证图形验证码失败: {e}")
+ return VerifyCaptchaResponse(
+ success=False,
+ message="图形验证码验证失败"
+ )
+
+
+# 发送验证码接口(需要先验证图形验证码)
+@app.post('/send-verification-code')
+async def send_verification_code(request: SendCodeRequest):
+ from db_manager import db_manager
+
+ try:
+ # 检查是否已验证图形验证码
+ # 通过检查数据库中是否存在已验证的图形验证码记录
+ with db_manager.lock:
+ cursor = db_manager.conn.cursor()
+ current_time = time.time()
+
+ # 查找最近5分钟内该session_id的验证记录
+ # 由于验证成功后验证码会被删除,我们需要另一种方式来跟踪验证状态
+ # 这里我们检查该session_id是否在最近验证过(通过检查是否有已删除的记录)
+
+ # 为了简化,我们要求前端在验证图形验证码成功后立即发送邮件验证码
+ # 或者我们可以在验证成功后设置一个临时标记
+ pass
+
+ # 根据验证码类型进行不同的检查
+ if request.type == 'register':
+ # 注册验证码:检查邮箱是否已注册
+ existing_user = db_manager.get_user_by_email(request.email)
+ if existing_user:
+ return SendCodeResponse(
+ success=False,
+ message="该邮箱已被注册"
+ )
+ elif request.type == 'login':
+ # 登录验证码:检查邮箱是否存在
+ existing_user = db_manager.get_user_by_email(request.email)
+ if not existing_user:
+ return SendCodeResponse(
+ success=False,
+ message="该邮箱未注册"
+ )
+
+ # 生成验证码
+ code = db_manager.generate_verification_code()
+
+ # 保存验证码到数据库
+ if not db_manager.save_verification_code(request.email, code, request.type):
+ return SendCodeResponse(
+ success=False,
+ message="验证码保存失败,请稍后重试"
+ )
+
+ # 发送验证码邮件
+ if await db_manager.send_verification_email(request.email, code):
+ return SendCodeResponse(
+ success=True,
+ message="验证码已发送到您的邮箱,请查收"
+ )
+ else:
+ return SendCodeResponse(
+ success=False,
+ message="验证码发送失败,请检查邮箱地址或稍后重试"
+ )
+
+ except Exception as e:
+ logger.error(f"发送验证码失败: {e}")
+ return SendCodeResponse(
+ success=False,
+ message="发送验证码失败,请稍后重试"
+ )
+
+
+# 用户注册接口
+@app.post('/register')
+async def register(request: RegisterRequest):
+ from db_manager import db_manager
+
+ # 检查注册是否开启
+ registration_enabled = db_manager.get_system_setting('registration_enabled')
+ if registration_enabled != 'true':
+ logger.warning(f"【{request.username}】注册失败: 注册功能已关闭")
+ return RegisterResponse(
+ success=False,
+ message="注册功能已关闭,请联系管理员"
+ )
+
+ try:
+ logger.info(f"【{request.username}】尝试注册,邮箱: {request.email}")
+
+ # 验证邮箱验证码
+ if not db_manager.verify_email_code(request.email, request.verification_code):
+ logger.warning(f"【{request.username}】注册失败: 验证码错误或已过期")
+ return RegisterResponse(
+ success=False,
+ message="验证码错误或已过期"
+ )
+
+ # 检查用户名是否已存在
+ existing_user = db_manager.get_user_by_username(request.username)
+ if existing_user:
+ logger.warning(f"【{request.username}】注册失败: 用户名已存在")
+ return RegisterResponse(
+ success=False,
+ message="用户名已存在"
+ )
+
+ # 检查邮箱是否已注册
+ existing_email = db_manager.get_user_by_email(request.email)
+ if existing_email:
+ logger.warning(f"【{request.username}】注册失败: 邮箱已被注册")
+ return RegisterResponse(
+ success=False,
+ message="该邮箱已被注册"
+ )
+
+ # 创建用户
+ if db_manager.create_user(request.username, request.email, request.password):
+ logger.info(f"【{request.username}】注册成功")
+ return RegisterResponse(
+ success=True,
+ message="注册成功,请登录"
+ )
+ else:
+ logger.error(f"【{request.username}】注册失败: 数据库操作失败")
+ return RegisterResponse(
+ success=False,
+ message="注册失败,请稍后重试"
+ )
+
+ except Exception as e:
+ logger.error(f"【{request.username}】注册异常: {e}")
+ return RegisterResponse(
+ success=False,
+ message="注册失败,请稍后重试"
+ )
+
+
+@app.post("/xianyu/reply", response_model=ResponseModel)
+async def xianyu_reply(req: RequestModel):
+ msg_template = match_reply(req.cookie_id, req.send_message)
+ is_default_reply = False
+
+ if not msg_template:
+ # 从数据库获取默认回复
+ from db_manager import db_manager
+ default_reply_settings = db_manager.get_default_reply(req.cookie_id)
+
+ if default_reply_settings and default_reply_settings.get('enabled', False):
+ # 检查是否开启了"只回复一次"功能
+ if default_reply_settings.get('reply_once', False):
+ # 检查是否已经回复过这个chat_id
+ if db_manager.has_default_reply_record(req.cookie_id, req.chat_id):
+ raise HTTPException(status_code=404, detail="该对话已使用默认回复,不再重复回复")
+
+ msg_template = default_reply_settings.get('reply_content', '')
+ is_default_reply = True
+
+ # 如果数据库中没有设置或为空,返回错误
+ if not msg_template:
+ raise HTTPException(status_code=404, detail="未找到匹配的回复规则且未设置默认回复")
+
+ # 按占位符格式化
+ try:
+ send_msg = msg_template.format(
+ send_user_id=req.send_user_id,
+ send_user_name=req.send_user_name,
+ send_message=req.send_message,
+ )
+ except Exception:
+ # 如果格式化失败,返回原始内容
+ send_msg = msg_template
+
+ # 如果是默认回复且开启了"只回复一次",记录回复记录
+ if is_default_reply:
+ from db_manager import db_manager
+ default_reply_settings = db_manager.get_default_reply(req.cookie_id)
+ if default_reply_settings and default_reply_settings.get('reply_once', False):
+ db_manager.add_default_reply_record(req.cookie_id, req.chat_id)
+
+ return {"code": 200, "data": {"send_msg": send_msg}}
+
+# ------------------------- 账号 / 关键字管理接口 -------------------------
+
+
+class CookieIn(BaseModel):
+ id: str
+ value: str
+
+
+class CookieStatusIn(BaseModel):
+ enabled: bool
+
+
+class DefaultReplyIn(BaseModel):
+ enabled: bool
+ reply_content: Optional[str] = None
+ reply_once: bool = False
+
+
+class NotificationChannelIn(BaseModel):
+ name: str
+ type: str = "qq"
+ config: str
+
+
+class NotificationChannelUpdate(BaseModel):
+ name: str
+ config: str
+ enabled: bool = True
+
+
+class MessageNotificationIn(BaseModel):
+ channel_id: int
+ enabled: bool = True
+
+
+class SystemSettingIn(BaseModel):
+ key: str
+ value: str
+ description: Optional[str] = None
+
+
+
+
+
+@app.get("/cookies")
+def list_cookies(current_user: Dict[str, Any] = Depends(get_current_user)):
+ if cookie_manager.manager is None:
+ return []
+
+ # 获取当前用户的cookies
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+ return list(user_cookies.keys())
+
+
+@app.get("/cookies/details")
+def get_cookies_details(current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取所有Cookie的详细信息(包括值和状态)"""
+ if cookie_manager.manager is None:
+ return []
+
+ # 获取当前用户的cookies
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ # 从配置获取刷新间隔(秒)
+ from config import TOKEN_REFRESH_INTERVAL
+ refresh_interval_seconds = TOKEN_REFRESH_INTERVAL
+
+ result = []
+ for cookie_id, cookie_value in user_cookies.items():
+ cookie_enabled = cookie_manager.manager.get_cookie_status(cookie_id)
+ auto_confirm = db_manager.get_auto_confirm(cookie_id)
+ # 获取备注信息
+ cookie_details = db_manager.get_cookie_details(cookie_id)
+ remark = cookie_details.get('remark', '') if cookie_details else ''
+
+ created_at = cookie_details.get('created_at') if cookie_details else None
+ nickname = cookie_details.get('nickname', '') if cookie_details else ''
+ avatar_url = cookie_details.get('avatar_url', '') if cookie_details else ''
+
+ # 获取刷新信息
+ refresh_info = db_manager.get_cookie_refresh_info(cookie_id)
+ last_refreshed_at = refresh_info.get('last_refreshed_at') if refresh_info else created_at
+
+ # 计算过期时间
+ import datetime
+ expire_at = None
+ expire_hours_left = None
+ if last_refreshed_at:
+ try:
+ if isinstance(last_refreshed_at, str):
+ refresh_time = datetime.datetime.fromisoformat(str(last_refreshed_at))
+ else:
+ refresh_time = last_refreshed_at
+ expire_time = refresh_time + datetime.timedelta(seconds=refresh_interval_seconds)
+ expire_at = expire_time.strftime('%Y-%m-%d %H:%M:%S')
+ now = datetime.datetime.now()
+ remaining = (expire_time - now).total_seconds()
+ expire_hours_left = round(remaining / 3600, 1)
+ except Exception:
+ pass
+
+ result.append({
+ 'id': cookie_id,
+ 'value': cookie_value,
+ 'enabled': cookie_enabled,
+ 'auto_confirm': auto_confirm,
+ 'remark': remark,
+ 'pause_duration': cookie_details.get('pause_duration', 10) if cookie_details else 10,
+ 'created_at': created_at,
+ 'last_refreshed_at': last_refreshed_at,
+ 'expire_at': expire_at,
+ 'expire_hours_left': expire_hours_left,
+ 'nickname': nickname,
+ 'avatar_url': avatar_url
+ })
+ return result
+
+
+@app.post("/cookies")
+def add_cookie(item: CookieIn, current_user: Dict[str, Any] = Depends(get_current_user)):
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+ try:
+ # 添加cookie时绑定到当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+
+ log_with_user('info', f"尝试添加Cookie: {item.id}, 当前用户ID: {user_id}, 用户名: {current_user.get('username', 'unknown')}", current_user)
+
+ # 检查cookie是否已存在且属于其他用户
+ existing_cookies = db_manager.get_all_cookies()
+ if item.id in existing_cookies:
+ # 检查是否属于当前用户
+ user_cookies = db_manager.get_all_cookies(user_id)
+ if item.id not in user_cookies:
+ log_with_user('warning', f"Cookie ID冲突: {item.id} 已被其他用户使用", current_user)
+ raise HTTPException(status_code=400, detail="该Cookie ID已被其他用户使用")
+
+ # 保存到数据库时指定用户ID
+ db_manager.save_cookie(item.id, item.value, user_id)
+
+ # 添加到CookieManager,同时指定用户ID
+ cookie_manager.manager.add_cookie(item.id, item.value, user_id=user_id)
+ log_with_user('info', f"Cookie添加成功: {item.id}", current_user)
+ return {"msg": "success"}
+ except HTTPException:
+ raise
+ except Exception as e:
+ log_with_user('error', f"添加Cookie失败: {item.id} - {str(e)}", current_user)
+ raise HTTPException(status_code=400, detail=str(e))
+
+
+@app.put('/cookies/{cid}')
+def update_cookie(cid: str, item: CookieIn, current_user: Dict[str, Any] = Depends(get_current_user)):
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail='CookieManager 未就绪')
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限操作该Cookie")
+
+ # 更新cookie时保持用户绑定
+ db_manager.save_cookie(cid, item.value, user_id)
+ cookie_manager.manager.update_cookie(cid, item.value)
+ return {'msg': 'updated'}
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+
+# ========================= 扫码登录相关接口 =========================
+
+@app.post("/qr-login/generate")
+async def generate_qr_code(current_user: Dict[str, Any] = Depends(get_current_user)):
+ """生成扫码登录二维码"""
+ try:
+ log_with_user('info', "请求生成扫码登录二维码", current_user)
+
+ result = await qr_login_manager.generate_qr_code()
+
+ if result['success']:
+ log_with_user('info', f"扫码登录二维码生成成功: {result['session_id']}", current_user)
+ else:
+ log_with_user('warning', f"扫码登录二维码生成失败: {result.get('message', '未知错误')}", current_user)
+
+ return result
+
+ except Exception as e:
+ log_with_user('error', f"生成扫码登录二维码异常: {str(e)}", current_user)
+ return {'success': False, 'message': f'生成二维码失败: {str(e)}'}
+
+
+@app.get("/qr-login/check/{session_id}")
+async def check_qr_code_status(session_id: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """检查扫码登录状态"""
+ try:
+ # 清理过期会话
+ qr_login_manager.cleanup_expired_sessions()
+
+ # 获取会话状态
+ status_info = qr_login_manager.get_session_status(session_id)
+
+ if status_info['status'] == 'success':
+ # 登录成功,处理Cookie
+ cookies_info = qr_login_manager.get_session_cookies(session_id)
+ if cookies_info:
+ account_info = await process_qr_login_cookies(
+ cookies_info['cookies'],
+ cookies_info['unb'],
+ current_user
+ )
+ status_info['account_info'] = account_info
+
+ log_with_user('info', f"扫码登录成功处理完成: {session_id}, 账号: {account_info.get('account_id', 'unknown')}", current_user)
+
+ return status_info
+
+ except Exception as e:
+ log_with_user('error', f"检查扫码登录状态异常: {str(e)}", current_user)
+ return {'status': 'error', 'message': str(e)}
+
+
+async def process_qr_login_cookies(cookies: str, unb: str, current_user: Dict[str, Any]) -> Dict[str, Any]:
+ """处理扫码登录获取的Cookie"""
+ try:
+ user_id = current_user['user_id']
+
+ # 获取用户资料(昵称和头像)
+ nickname = ''
+ avatar_url = ''
+ try:
+ user_profile = await get_user_profile_from_cookies(cookies)
+ if user_profile:
+ nickname = user_profile.get('nickname', '')
+ avatar_url = user_profile.get('avatar_url', '')
+ log_with_user('info', f"获取用户资料成功: nickname={nickname}, avatar_url={avatar_url[:50]}..." if avatar_url else f"获取用户资料成功: nickname={nickname}", current_user)
+ else:
+ log_with_user('warning', "获取用户资料失败,将使用默认值", current_user)
+ except Exception as e:
+ log_with_user('warning', f"获取用户资料异常: {e}", current_user)
+
+ # 检查是否已存在相同unb的账号
+ existing_cookies = db_manager.get_all_cookies(user_id)
+ existing_account_id = None
+
+ for account_id, cookie_value in existing_cookies.items():
+ try:
+ # 解析现有Cookie中的unb
+ existing_cookie_dict = trans_cookies(cookie_value)
+ if existing_cookie_dict.get('unb') == unb:
+ existing_account_id = account_id
+ break
+ except:
+ continue
+
+ if existing_account_id:
+ # 更新现有账号的Cookie
+ db_manager.save_cookie(existing_account_id, cookies, user_id)
+
+ # 更新用户资料
+ if nickname or avatar_url:
+ db_manager.update_cookie_user_info(existing_account_id, nickname, avatar_url)
+
+ # 更新cookie_manager中的Cookie
+ if cookie_manager.manager:
+ cookie_manager.manager.update_cookie(existing_account_id, cookies)
+
+ log_with_user('info', f"扫码登录更新现有账号Cookie: {existing_account_id}, UNB: {unb}, nickname: {nickname}", current_user)
+
+ return {
+ 'account_id': existing_account_id,
+ 'is_new_account': False,
+ 'nickname': nickname,
+ 'avatar_url': avatar_url
+ }
+ else:
+ # 创建新账号,使用unb作为账号ID
+ account_id = unb
+
+ # 确保账号ID唯一
+ counter = 1
+ original_account_id = account_id
+ while account_id in existing_cookies:
+ account_id = f"{original_account_id}_{counter}"
+ counter += 1
+
+ # 保存新账号
+ db_manager.save_cookie(account_id, cookies, user_id)
+
+ # 保存用户资料
+ if nickname or avatar_url:
+ db_manager.update_cookie_user_info(account_id, nickname, avatar_url)
+
+ # 添加到cookie_manager
+ if cookie_manager.manager:
+ cookie_manager.manager.add_cookie(account_id, cookies)
+
+ log_with_user('info', f"扫码登录创建新账号: {account_id}, UNB: {unb}, nickname: {nickname}", current_user)
+
+ return {
+ 'account_id': account_id,
+ 'is_new_account': True,
+ 'nickname': nickname,
+ 'avatar_url': avatar_url
+ }
+
+ except Exception as e:
+ log_with_user('error', f"处理扫码登录Cookie失败: {str(e)}", current_user)
+ raise e
+
+
+@app.put('/cookies/{cid}/status')
+def update_cookie_status(cid: str, status_data: CookieStatusIn, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """更新账号的启用/禁用状态"""
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail='CookieManager 未就绪')
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限操作该Cookie")
+
+ cookie_manager.manager.update_cookie_status(cid, status_data.enabled)
+ return {'msg': 'status updated', 'enabled': status_data.enabled}
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+
+# ------------------------- 默认回复管理接口 -------------------------
+
+@app.get('/default-replies/{cid}')
+def get_default_reply(cid: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取指定账号的默认回复设置"""
+ from db_manager import db_manager
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限访问该Cookie")
+
+ result = db_manager.get_default_reply(cid)
+ if result is None:
+ # 如果没有设置,返回默认值
+ return {'enabled': False, 'reply_content': '', 'reply_once': False}
+ return result
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put('/default-replies/{cid}')
+def update_default_reply(cid: str, reply_data: DefaultReplyIn, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """更新指定账号的默认回复设置"""
+ from db_manager import db_manager
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限操作该Cookie")
+
+ db_manager.save_default_reply(cid, reply_data.enabled, reply_data.reply_content, reply_data.reply_once)
+ return {'msg': 'default reply updated', 'enabled': reply_data.enabled, 'reply_once': reply_data.reply_once}
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get('/default-replies')
+def get_all_default_replies(current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取当前用户所有账号的默认回复设置"""
+ from db_manager import db_manager
+ try:
+ # 只返回当前用户的默认回复设置
+ user_id = current_user['user_id']
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ all_replies = db_manager.get_all_default_replies()
+ # 过滤只属于当前用户的回复设置
+ user_replies = {cid: reply for cid, reply in all_replies.items() if cid in user_cookies}
+ return user_replies
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete('/default-replies/{cid}')
+def delete_default_reply(cid: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """删除指定账号的默认回复设置"""
+ from db_manager import db_manager
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限操作该Cookie")
+
+ success = db_manager.delete_default_reply(cid)
+ if success:
+ return {'msg': 'default reply deleted'}
+ else:
+ raise HTTPException(status_code=400, detail='删除失败')
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post('/default-replies/{cid}/clear-records')
+def clear_default_reply_records(cid: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """清空指定账号的默认回复记录"""
+ from db_manager import db_manager
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限操作该Cookie")
+
+ db_manager.clear_default_reply_records(cid)
+ return {'msg': 'default reply records cleared'}
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+# ------------------------- 通知渠道管理接口 -------------------------
+
+@app.get('/notification-channels')
+def get_notification_channels(current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取所有通知渠道"""
+ from db_manager import db_manager
+ try:
+ user_id = current_user['user_id']
+ return db_manager.get_notification_channels(user_id)
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post('/notification-channels')
+def create_notification_channel(channel_data: NotificationChannelIn, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """创建通知渠道"""
+ from db_manager import db_manager
+ try:
+ user_id = current_user['user_id']
+ channel_id = db_manager.create_notification_channel(
+ channel_data.name,
+ channel_data.type,
+ channel_data.config,
+ user_id
+ )
+ return {'msg': 'notification channel created', 'id': channel_id}
+ except Exception as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+
+@app.get('/notification-channels/{channel_id}')
+def get_notification_channel(channel_id: int, _: None = Depends(require_auth)):
+ """获取指定通知渠道"""
+ from db_manager import db_manager
+ try:
+ channel = db_manager.get_notification_channel(channel_id)
+ if not channel:
+ raise HTTPException(status_code=404, detail='通知渠道不存在')
+ return channel
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put('/notification-channels/{channel_id}')
+def update_notification_channel(channel_id: int, channel_data: NotificationChannelUpdate, _: None = Depends(require_auth)):
+ """更新通知渠道"""
+ from db_manager import db_manager
+ try:
+ success = db_manager.update_notification_channel(
+ channel_id,
+ channel_data.name,
+ channel_data.config,
+ channel_data.enabled
+ )
+ if success:
+ return {'msg': 'notification channel updated'}
+ else:
+ raise HTTPException(status_code=404, detail='通知渠道不存在')
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+
+@app.delete('/notification-channels/{channel_id}')
+def delete_notification_channel(channel_id: int, _: None = Depends(require_auth)):
+ """删除通知渠道"""
+ from db_manager import db_manager
+ try:
+ success = db_manager.delete_notification_channel(channel_id)
+ if success:
+ return {'msg': 'notification channel deleted'}
+ else:
+ raise HTTPException(status_code=404, detail='通知渠道不存在')
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+# ------------------------- 消息通知配置接口 -------------------------
+
+@app.get('/message-notifications')
+def get_all_message_notifications(current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取当前用户所有账号的消息通知配置"""
+ from db_manager import db_manager
+ try:
+ # 只返回当前用户的消息通知配置
+ user_id = current_user['user_id']
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ all_notifications = db_manager.get_all_message_notifications()
+ # 过滤只属于当前用户的通知配置
+ user_notifications = {cid: notifications for cid, notifications in all_notifications.items() if cid in user_cookies}
+ return user_notifications
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get('/message-notifications/{cid}')
+def get_account_notifications(cid: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取指定账号的消息通知配置"""
+ from db_manager import db_manager
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限访问该Cookie")
+
+ return db_manager.get_account_notifications(cid)
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post('/message-notifications/{cid}')
+def set_message_notification(cid: str, notification_data: MessageNotificationIn, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """设置账号的消息通知"""
+ from db_manager import db_manager
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限操作该Cookie")
+
+ # 检查通知渠道是否存在
+ channel = db_manager.get_notification_channel(notification_data.channel_id)
+ if not channel:
+ raise HTTPException(status_code=404, detail='通知渠道不存在')
+
+ success = db_manager.set_message_notification(cid, notification_data.channel_id, notification_data.enabled)
+ if success:
+ return {'msg': 'message notification set'}
+ else:
+ raise HTTPException(status_code=400, detail='设置失败')
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete('/message-notifications/account/{cid}')
+def delete_account_notifications(cid: str, _: None = Depends(require_auth)):
+ """删除账号的所有消息通知配置"""
+ from db_manager import db_manager
+ try:
+ success = db_manager.delete_account_notifications(cid)
+ if success:
+ return {'msg': 'account notifications deleted'}
+ else:
+ raise HTTPException(status_code=404, detail='账号通知配置不存在')
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete('/message-notifications/{notification_id}')
+def delete_message_notification(notification_id: int, _: None = Depends(require_auth)):
+ """删除消息通知配置"""
+ from db_manager import db_manager
+ try:
+ success = db_manager.delete_message_notification(notification_id)
+ if success:
+ return {'msg': 'message notification deleted'}
+ else:
+ raise HTTPException(status_code=404, detail='通知配置不存在')
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+# ------------------------- 系统设置接口 -------------------------
+
+@app.get('/system-settings')
+def get_system_settings(_: None = Depends(require_auth)):
+ """获取系统设置(排除敏感信息)"""
+ from db_manager import db_manager
+ try:
+ settings = db_manager.get_all_system_settings()
+ # 移除敏感信息
+ if 'admin_password_hash' in settings:
+ del settings['admin_password_hash']
+ return settings
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+
+
+
+@app.put('/system-settings/ai-defaults')
+async def update_ai_defaults(request: Request, _: None = Depends(require_auth)):
+ """批量保存AI回复全局默认设置"""
+ from db_manager import db_manager
+ try:
+ settings = await request.json()
+ mapping = {
+ 'ai_default_enabled': 'ai_default_enabled',
+ 'ai_default_model': 'ai_default_model',
+ 'ai_default_base_url': 'ai_default_base_url',
+ 'ai_default_api_key': 'ai_default_api_key',
+ 'ai_default_max_discount_percent': 'ai_default_max_discount_percent',
+ 'ai_default_max_discount_amount': 'ai_default_max_discount_amount',
+ 'ai_default_max_bargain_rounds': 'ai_default_max_bargain_rounds',
+ 'ai_default_prompts': 'ai_default_prompts',
+ 'ai_default_refund_policy': 'ai_default_refund_policy',
+ }
+ for key, db_key in mapping.items():
+ if key in settings:
+ db_manager.set_system_setting(db_key, str(settings[key]), f'AI回复-{key}')
+ # 清理AI引擎缓存,使新设置生效
+ from ai_reply_engine import ai_reply_engine
+ ai_reply_engine.clear_client_cache()
+ return {'msg': 'AI global defaults updated'}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put('/system-settings/{key}')
+def update_system_setting(key: str, setting_data: SystemSettingIn, _: None = Depends(require_auth)):
+ """更新系统设置"""
+ from db_manager import db_manager
+ try:
+ # 禁止直接修改密码哈希
+ if key == 'admin_password_hash':
+ raise HTTPException(status_code=400, detail='请使用密码修改接口')
+
+ success = db_manager.set_system_setting(key, setting_data.value, setting_data.description)
+ if success:
+ return {'msg': 'system setting updated'}
+ else:
+ raise HTTPException(status_code=400, detail='更新失败')
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+# ------------------------- 注册设置接口 -------------------------
+
+@app.get('/registration-status')
+def get_registration_status():
+ """获取注册开关状态(公开接口,无需认证)"""
+ from db_manager import db_manager
+ try:
+ enabled_str = db_manager.get_system_setting('registration_enabled')
+ logger.info(f"从数据库获取的注册设置值: '{enabled_str}'") # 调试信息
+
+ # 如果设置不存在,默认为开启
+ if enabled_str is None:
+ enabled_bool = True
+ message = '注册功能已开启'
+ else:
+ enabled_bool = enabled_str == 'true'
+ message = '注册功能已开启' if enabled_bool else '注册功能已关闭'
+
+ logger.info(f"解析后的注册状态: enabled={enabled_bool}, message='{message}'") # 调试信息
+
+ return {
+ 'enabled': enabled_bool,
+ 'message': message
+ }
+ except Exception as e:
+ logger.error(f"获取注册状态失败: {e}")
+ return {'enabled': True, 'message': '注册功能已开启'} # 出错时默认开启
+
+
+class RegistrationSettingUpdate(BaseModel):
+ enabled: bool
+
+
+@app.put('/registration-settings')
+def update_registration_settings(setting_data: RegistrationSettingUpdate, admin_user: Dict[str, Any] = Depends(require_permission('system_settings'))):
+ """更新注册开关设置"""
+ from db_manager import db_manager
+ try:
+ enabled = setting_data.enabled
+ success = db_manager.set_system_setting(
+ 'registration_enabled',
+ 'true' if enabled else 'false',
+ '是否开启用户注册'
+ )
+ if success:
+ log_with_user('info', f"更新注册设置: {'开启' if enabled else '关闭'}", admin_user)
+ return {
+ 'success': True,
+ 'enabled': enabled,
+ 'message': f"注册功能已{'开启' if enabled else '关闭'}"
+ }
+ else:
+ raise HTTPException(status_code=500, detail='更新注册设置失败')
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"更新注册设置失败: {e}")
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+
+
+
+@app.delete("/cookies/{cid}")
+def remove_cookie(cid: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限操作该Cookie")
+
+ cookie_manager.manager.remove_cookie(cid)
+ return {"msg": "removed"}
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+
+class AutoConfirmUpdate(BaseModel):
+ auto_confirm: bool
+
+
+class RemarkUpdate(BaseModel):
+ remark: str
+
+
+class PauseDurationUpdate(BaseModel):
+ pause_duration: int
+
+
+@app.put("/cookies/{cid}/auto-confirm")
+def update_auto_confirm(cid: str, update_data: AutoConfirmUpdate, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """更新账号的自动确认发货设置"""
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限操作该Cookie")
+
+ # 更新数据库中的auto_confirm设置
+ success = db_manager.update_auto_confirm(cid, update_data.auto_confirm)
+ if not success:
+ raise HTTPException(status_code=500, detail="更新自动确认发货设置失败")
+
+ # 通知CookieManager更新设置(如果账号正在运行)
+ if hasattr(cookie_manager.manager, 'update_auto_confirm_setting'):
+ cookie_manager.manager.update_auto_confirm_setting(cid, update_data.auto_confirm)
+
+ return {
+ "msg": "success",
+ "auto_confirm": update_data.auto_confirm,
+ "message": f"自动确认发货已{'开启' if update_data.auto_confirm else '关闭'}"
+ }
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/cookies/{cid}/auto-confirm")
+def get_auto_confirm(cid: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取账号的自动确认发货设置"""
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限操作该Cookie")
+
+ # 获取auto_confirm设置
+ auto_confirm = db_manager.get_auto_confirm(cid)
+ return {
+ "auto_confirm": auto_confirm,
+ "message": f"自动确认发货当前{'开启' if auto_confirm else '关闭'}"
+ }
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put("/cookies/{cid}/remark")
+def update_cookie_remark(cid: str, update_data: RemarkUpdate, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """更新账号备注"""
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限操作该Cookie")
+
+ # 更新备注
+ success = db_manager.update_cookie_remark(cid, update_data.remark)
+ if success:
+ log_with_user('info', f"更新账号备注: {cid} -> {update_data.remark}", current_user)
+ return {
+ "message": "备注更新成功",
+ "remark": update_data.remark
+ }
+ else:
+ raise HTTPException(status_code=500, detail="备注更新失败")
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/cookies/{cid}/remark")
+def get_cookie_remark(cid: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取账号备注"""
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限操作该Cookie")
+
+ # 获取Cookie详细信息(包含备注)
+ cookie_details = db_manager.get_cookie_details(cid)
+ if cookie_details:
+ return {
+ "remark": cookie_details.get('remark', ''),
+ "message": "获取备注成功"
+ }
+ else:
+ raise HTTPException(status_code=404, detail="账号不存在")
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put("/cookies/{cid}/pause-duration")
+def update_cookie_pause_duration(cid: str, update_data: PauseDurationUpdate, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """更新账号自动回复暂停时间"""
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限操作该Cookie")
+
+ # 验证暂停时间范围(1-60分钟)
+ if not (1 <= update_data.pause_duration <= 60):
+ raise HTTPException(status_code=400, detail="暂停时间必须在1-60分钟之间")
+
+ # 更新暂停时间
+ success = db_manager.update_cookie_pause_duration(cid, update_data.pause_duration)
+ if success:
+ log_with_user('info', f"更新账号自动回复暂停时间: {cid} -> {update_data.pause_duration}分钟", current_user)
+ return {
+ "message": "暂停时间更新成功",
+ "pause_duration": update_data.pause_duration
+ }
+ else:
+ raise HTTPException(status_code=500, detail="暂停时间更新失败")
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/cookies/{cid}/pause-duration")
+def get_cookie_pause_duration(cid: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取账号自动回复暂停时间"""
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限操作该Cookie")
+
+ # 获取暂停时间
+ pause_duration = db_manager.get_cookie_pause_duration(cid)
+ return {
+ "pause_duration": pause_duration,
+ "message": "获取暂停时间成功"
+ }
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+
+
+class KeywordIn(BaseModel):
+ keywords: Dict[str, str] # key -> reply
+
+class KeywordWithItemIdIn(BaseModel):
+ keywords: List[Dict[str, Any]] # [{"keyword": str, "reply": str, "item_id": str}]
+
+
+@app.get("/keywords/{cid}")
+def get_keywords(cid: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限访问该Cookie")
+
+ # 直接从数据库获取所有关键词(避免重复计算)
+ item_keywords = db_manager.get_keywords_with_item_id(cid)
+
+ # 转换为统一格式
+ all_keywords = []
+ for keyword, reply, item_id in item_keywords:
+ all_keywords.append({
+ "keyword": keyword,
+ "reply": reply,
+ "item_id": item_id,
+ "type": "item" if item_id else "normal"
+ })
+
+ return all_keywords
+
+
+@app.get("/keywords-with-item-id/{cid}")
+def get_keywords_with_item_id(cid: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取包含商品ID的关键词列表"""
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限访问该Cookie")
+
+ # 获取包含类型信息的关键词
+ keywords = db_manager.get_keywords_with_type(cid)
+
+ # 转换为前端需要的格式
+ result = []
+ for keyword_data in keywords:
+ result.append({
+ "keyword": keyword_data['keyword'],
+ "reply": keyword_data['reply'],
+ "item_id": keyword_data['item_id'] or "",
+ "type": keyword_data['type'],
+ "image_url": keyword_data['image_url']
+ })
+
+ return result
+
+
+@app.post("/keywords/{cid}")
+def update_keywords(cid: str, body: KeywordIn, current_user: Dict[str, Any] = Depends(get_current_user)):
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ log_with_user('warning', f"尝试操作其他用户的Cookie关键字: {cid}", current_user)
+ raise HTTPException(status_code=403, detail="无权限操作该Cookie")
+
+ kw_list = [(k, v) for k, v in body.keywords.items()]
+ log_with_user('info', f"更新Cookie关键字: {cid}, 数量: {len(kw_list)}", current_user)
+
+ cookie_manager.manager.update_keywords(cid, kw_list)
+ log_with_user('info', f"Cookie关键字更新成功: {cid}", current_user)
+ return {"msg": "updated", "count": len(kw_list)}
+
+
+@app.post("/keywords-with-item-id/{cid}")
+def update_keywords_with_item_id(cid: str, body: KeywordWithItemIdIn, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """更新包含商品ID的关键词列表"""
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ log_with_user('warning', f"尝试操作其他用户的Cookie关键字: {cid}", current_user)
+ raise HTTPException(status_code=403, detail="无权限操作该Cookie")
+
+ # 验证数据格式
+ keywords_to_save = []
+ keyword_set = set() # 用于检查当前提交的关键词中是否有重复
+
+ for kw_data in body.keywords:
+ keyword = kw_data.get('keyword', '').strip()
+ reply = kw_data.get('reply', '').strip()
+ item_id = kw_data.get('item_id', '').strip() or None
+
+ if not keyword:
+ raise HTTPException(status_code=400, detail="关键词不能为空")
+
+ # 检查当前提交的关键词中是否有重复
+ keyword_key = f"{keyword}|{item_id or ''}"
+ if keyword_key in keyword_set:
+ item_id_text = f"(商品ID: {item_id})" if item_id else "(通用关键词)"
+ raise HTTPException(status_code=400, detail=f"关键词 '{keyword}' {item_id_text} 在当前提交中重复")
+ keyword_set.add(keyword_key)
+
+ keywords_to_save.append((keyword, reply, item_id))
+
+ # 保存关键词(只保存文本关键词,保留图片关键词)
+ try:
+ success = db_manager.save_text_keywords_only(cid, keywords_to_save)
+ if not success:
+ raise HTTPException(status_code=500, detail="保存关键词失败")
+ except Exception as e:
+ error_msg = str(e)
+ if "UNIQUE constraint failed" in error_msg:
+ # 解析具体的冲突信息
+ if "keywords.cookie_id, keywords.keyword" in error_msg:
+ raise HTTPException(status_code=400, detail="关键词重复!该关键词已存在(可能是图片关键词或文本关键词),请使用其他关键词")
+ else:
+ raise HTTPException(status_code=400, detail="关键词重复!请使用不同的关键词或商品ID组合")
+ else:
+ log_with_user('error', f"保存关键词时发生未知错误: {error_msg}", current_user)
+ raise HTTPException(status_code=500, detail="保存关键词失败")
+
+ log_with_user('info', f"更新Cookie关键字(含商品ID): {cid}, 数量: {len(keywords_to_save)}", current_user)
+ return {"msg": "updated", "count": len(keywords_to_save)}
+
+
+@app.get("/items/{cid}")
+def get_items_list(cid: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取指定账号的商品列表"""
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限访问该Cookie")
+
+ try:
+ # 获取该账号的所有商品
+ with db_manager.lock:
+ cursor = db_manager.conn.cursor()
+ cursor.execute('''
+ SELECT item_id, item_title, item_price, updated_at
+ FROM item_info
+ WHERE cookie_id = ?
+ ORDER BY updated_at DESC
+ ''', (cid,))
+
+ items = []
+ for row in cursor.fetchall():
+ items.append({
+ 'item_id': row[0],
+ 'item_title': row[1] or '未知商品',
+ 'item_price': row[2] or '价格未知',
+ 'updated_at': row[3]
+ })
+
+ return {"items": items, "count": len(items)}
+
+ except Exception as e:
+ logger.error(f"获取商品列表失败: {e}")
+ raise HTTPException(status_code=500, detail="获取商品列表失败")
+
+
+@app.get("/keywords-export/{cid}")
+def export_keywords(cid: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """导出指定账号的关键词为Excel文件"""
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限访问该Cookie")
+
+ try:
+ # 获取关键词数据(包含类型信息)
+ keywords = db_manager.get_keywords_with_type(cid)
+
+ # 创建DataFrame,只导出文本类型的关键词
+ data = []
+ for keyword_data in keywords:
+ # 只导出文本类型的关键词
+ if keyword_data.get('type', 'text') == 'text':
+ data.append({
+ '关键词': keyword_data['keyword'],
+ '商品ID': keyword_data['item_id'] or '',
+ '关键词内容': keyword_data['reply']
+ })
+
+ # 如果没有数据,创建空的DataFrame但保留列名(作为模板)
+ if not data:
+ df = pd.DataFrame(columns=['关键词', '商品ID', '关键词内容'])
+ else:
+ df = pd.DataFrame(data)
+
+ # 创建Excel文件
+ output = io.BytesIO()
+ with pd.ExcelWriter(output, engine='openpyxl') as writer:
+ df.to_excel(writer, sheet_name='关键词数据', index=False)
+
+ # 如果是空模板,添加一些示例说明
+ if data == []:
+ worksheet = writer.sheets['关键词数据']
+ # 添加示例数据作为注释(从第2行开始)
+ worksheet['A2'] = '你好'
+ worksheet['B2'] = ''
+ worksheet['C2'] = '您好!欢迎咨询,有什么可以帮助您的吗?'
+
+ worksheet['A3'] = '价格'
+ worksheet['B3'] = '123456'
+ worksheet['C3'] = '这个商品的价格是99元,现在有优惠活动哦!'
+
+ worksheet['A4'] = '发货'
+ worksheet['B4'] = ''
+ worksheet['C4'] = '我们会在24小时内发货,请耐心等待。'
+
+ # 设置示例行的样式(浅灰色背景)
+ from openpyxl.styles import PatternFill
+ gray_fill = PatternFill(start_color='F0F0F0', end_color='F0F0F0', fill_type='solid')
+ for row in range(2, 5):
+ for col in range(1, 4):
+ worksheet.cell(row=row, column=col).fill = gray_fill
+
+ output.seek(0)
+
+ # 生成文件名(使用URL编码处理中文)
+ from urllib.parse import quote
+ if not data:
+ filename = f"keywords_template_{cid}_{int(time.time())}.xlsx"
+ else:
+ filename = f"keywords_{cid}_{int(time.time())}.xlsx"
+ encoded_filename = quote(filename.encode('utf-8'))
+
+ # 返回文件
+ return StreamingResponse(
+ io.BytesIO(output.read()),
+ media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+ headers={
+ "Content-Disposition": f"attachment; filename*=UTF-8''{encoded_filename}"
+ }
+ )
+
+ except Exception as e:
+ logger.error(f"导出关键词失败: {e}")
+ raise HTTPException(status_code=500, detail=f"导出关键词失败: {str(e)}")
+
+
+@app.post("/keywords-import/{cid}")
+async def import_keywords(cid: str, file: UploadFile = File(...), current_user: Dict[str, Any] = Depends(get_current_user)):
+ """导入Excel文件中的关键词到指定账号"""
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cid not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限访问该Cookie")
+
+ # 检查文件类型
+ if not file.filename.endswith(('.xlsx', '.xls')):
+ raise HTTPException(status_code=400, detail="请上传Excel文件(.xlsx或.xls)")
+
+ try:
+ # 读取Excel文件
+ contents = await file.read()
+ df = pd.read_excel(io.BytesIO(contents))
+
+ # 检查必要的列
+ required_columns = ['关键词', '商品ID', '关键词内容']
+ missing_columns = [col for col in required_columns if col not in df.columns]
+ if missing_columns:
+ raise HTTPException(status_code=400, detail=f"Excel文件缺少必要的列: {', '.join(missing_columns)}")
+
+ # 获取现有的文本类型关键词(用于比较更新/新增)
+ existing_keywords = db_manager.get_keywords_with_type(cid)
+ existing_dict = {}
+ for keyword_data in existing_keywords:
+ # 只考虑文本类型的关键词
+ if keyword_data.get('type', 'text') == 'text':
+ keyword = keyword_data['keyword']
+ reply = keyword_data['reply']
+ item_id = keyword_data['item_id']
+ key = f"{keyword}|{item_id or ''}"
+ existing_dict[key] = (keyword, reply, item_id)
+
+ # 处理导入数据
+ import_data = []
+ update_count = 0
+ add_count = 0
+
+ for index, row in df.iterrows():
+ keyword = str(row['关键词']).strip()
+ item_id = str(row['商品ID']).strip() if pd.notna(row['商品ID']) and str(row['商品ID']).strip() else None
+ reply = str(row['关键词内容']).strip()
+
+ if not keyword:
+ continue # 跳过没有关键词的行
+
+ # 检查是否重复
+ key = f"{keyword}|{item_id or ''}"
+ if key in existing_dict:
+ # 更新现有关键词
+ update_count += 1
+ else:
+ # 新增关键词
+ add_count += 1
+
+ import_data.append((keyword, reply, item_id))
+
+ if not import_data:
+ raise HTTPException(status_code=400, detail="Excel文件中没有有效的关键词数据")
+
+ # 保存到数据库(只影响文本关键词,保留图片关键词)
+ success = db_manager.save_text_keywords_only(cid, import_data)
+ if not success:
+ raise HTTPException(status_code=500, detail="保存关键词到数据库失败")
+
+ log_with_user('info', f"导入关键词成功: {cid}, 新增: {add_count}, 更新: {update_count}", current_user)
+
+ return {
+ "msg": "导入成功",
+ "total": len(import_data),
+ "added": add_count,
+ "updated": update_count
+ }
+
+ except pd.errors.EmptyDataError:
+ raise HTTPException(status_code=400, detail="Excel文件为空")
+ except pd.errors.ParserError:
+ raise HTTPException(status_code=400, detail="Excel文件格式错误")
+ except Exception as e:
+ logger.error(f"导入关键词失败: {e}")
+ raise HTTPException(status_code=500, detail=f"导入关键词失败: {str(e)}")
+
+
+@app.post("/keywords/{cid}/image")
+async def add_image_keyword(
+ cid: str,
+ keyword: str = Form(...),
+ item_id: str = Form(default=""),
+ image: UploadFile = File(...),
+ current_user: Dict[str, Any] = Depends(get_current_user)
+):
+ """添加图片关键词"""
+ logger.info(f"接收到图片关键词添加请求: cid={cid}, keyword={keyword}, item_id={item_id}")
+
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+
+ # 检查参数
+ if not keyword or not keyword.strip():
+ raise HTTPException(status_code=400, detail="关键词不能为空")
+
+ if not image or not image.filename:
+ raise HTTPException(status_code=400, detail="请选择图片文件")
+
+ # 检查cookie是否属于当前用户
+ cookie_details = db_manager.get_cookie_details(cid)
+ if not cookie_details or cookie_details['user_id'] != current_user['user_id']:
+ raise HTTPException(status_code=404, detail="账号不存在或无权限")
+
+ try:
+ logger.info(f"接收到图片关键词添加请求: cid={cid}, keyword={keyword}, item_id={item_id}, filename={image.filename}")
+
+ # 验证图片文件
+ if not image.content_type or not image.content_type.startswith('image/'):
+ logger.warning(f"无效的图片文件类型: {image.content_type}")
+ raise HTTPException(status_code=400, detail="请上传图片文件")
+
+ # 读取图片数据
+ image_data = await image.read()
+ logger.info(f"读取图片数据成功,大小: {len(image_data)} bytes")
+
+ # 保存图片
+ image_url = image_manager.save_image(image_data, image.filename)
+ if not image_url:
+ logger.error("图片保存失败")
+ raise HTTPException(status_code=400, detail="图片保存失败")
+
+ logger.info(f"图片保存成功: {image_url}")
+
+ # 先检查关键词是否已存在
+ normalized_item_id = item_id if item_id and item_id.strip() else None
+ if db_manager.check_keyword_duplicate(cid, keyword, normalized_item_id):
+ # 删除已保存的图片
+ image_manager.delete_image(image_url)
+ if normalized_item_id:
+ raise HTTPException(status_code=400, detail=f"关键词 '{keyword}' 在商品 '{normalized_item_id}' 中已存在")
+ else:
+ raise HTTPException(status_code=400, detail=f"通用关键词 '{keyword}' 已存在")
+
+ # 保存图片关键词到数据库
+ success = db_manager.save_image_keyword(cid, keyword, image_url, item_id or None)
+ if not success:
+ # 如果数据库保存失败,删除已保存的图片
+ logger.error("数据库保存失败,删除已保存的图片")
+ image_manager.delete_image(image_url)
+ raise HTTPException(status_code=400, detail="图片关键词保存失败,请稍后重试")
+
+ log_with_user('info', f"添加图片关键词成功: {cid}, 关键词: {keyword}", current_user)
+
+ return {
+ "msg": "图片关键词添加成功",
+ "keyword": keyword,
+ "image_url": image_url,
+ "item_id": item_id or None
+ }
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"添加图片关键词失败: {e}")
+ raise HTTPException(status_code=500, detail=f"添加图片关键词失败: {str(e)}")
+
+
+@app.post("/upload-image")
+async def upload_image(
+ image: UploadFile = File(...),
+ current_user: Dict[str, Any] = Depends(get_current_user)
+):
+ """上传图片(用于卡券等功能)"""
+ try:
+ logger.info(f"接收到图片上传请求: filename={image.filename}")
+
+ # 验证图片文件
+ if not image.content_type or not image.content_type.startswith('image/'):
+ logger.warning(f"无效的图片文件类型: {image.content_type}")
+ raise HTTPException(status_code=400, detail="请上传图片文件")
+
+ # 读取图片数据
+ image_data = await image.read()
+ logger.info(f"读取图片数据成功,大小: {len(image_data)} bytes")
+
+ # 保存图片
+ image_url = image_manager.save_image(image_data, image.filename)
+ if not image_url:
+ logger.error("图片保存失败")
+ raise HTTPException(status_code=400, detail="图片保存失败")
+
+ logger.info(f"图片上传成功: {image_url}")
+
+ return {
+ "message": "图片上传成功",
+ "image_url": image_url
+ }
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"图片上传失败: {e}")
+ raise HTTPException(status_code=500, detail=f"图片上传失败: {str(e)}")
+
+
+@app.get("/keywords-with-type/{cid}")
+def get_keywords_with_type(cid: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取包含类型信息的关键词列表"""
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+
+ # 检查cookie是否属于当前用户
+ cookie_details = db_manager.get_cookie_details(cid)
+ if not cookie_details or cookie_details['user_id'] != current_user['user_id']:
+ raise HTTPException(status_code=404, detail="账号不存在或无权限")
+
+ try:
+ keywords = db_manager.get_keywords_with_type(cid)
+ return keywords
+ except Exception as e:
+ logger.error(f"获取关键词列表失败: {e}")
+ raise HTTPException(status_code=500, detail=f"获取关键词列表失败: {str(e)}")
+
+
+@app.delete("/keywords/{cid}/{index}")
+def delete_keyword_by_index(cid: str, index: int, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """根据索引删除关键词"""
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail="CookieManager 未就绪")
+
+ # 检查cookie是否属于当前用户
+ cookie_details = db_manager.get_cookie_details(cid)
+ if not cookie_details or cookie_details['user_id'] != current_user['user_id']:
+ raise HTTPException(status_code=404, detail="账号不存在或无权限")
+
+ try:
+ # 先获取要删除的关键词信息(用于删除图片文件)
+ keywords = db_manager.get_keywords_with_type(cid)
+ if 0 <= index < len(keywords):
+ keyword_data = keywords[index]
+
+ # 删除关键词
+ success = db_manager.delete_keyword_by_index(cid, index)
+ if not success:
+ raise HTTPException(status_code=400, detail="删除关键词失败")
+
+ # 如果是图片关键词,删除对应的图片文件
+ if keyword_data.get('type') == 'image' and keyword_data.get('image_url'):
+ image_manager.delete_image(keyword_data['image_url'])
+
+ log_with_user('info', f"删除关键词成功: {cid}, 索引: {index}, 关键词: {keyword_data.get('keyword')}", current_user)
+
+ return {"msg": "删除成功"}
+ else:
+ raise HTTPException(status_code=400, detail="关键词索引无效")
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"删除关键词失败: {e}")
+ raise HTTPException(status_code=500, detail=f"删除关键词失败: {str(e)}")
+
+
+@app.get("/debug/keywords-table-info")
+def debug_keywords_table_info(current_user: Dict[str, Any] = Depends(get_current_user)):
+ """调试:检查keywords表结构"""
+ try:
+ import sqlite3
+ conn = sqlite3.connect(db_manager.db_path)
+ cursor = conn.cursor()
+
+ # 获取表结构信息
+ cursor.execute("PRAGMA table_info(keywords)")
+ columns = cursor.fetchall()
+
+ # 获取数据库版本
+ cursor.execute("SELECT value FROM system_settings WHERE key = 'db_version'")
+ version_result = cursor.fetchone()
+ db_version = version_result[0] if version_result else "未知"
+
+ conn.close()
+
+ return {
+ "db_version": db_version,
+ "table_columns": [{"name": col[1], "type": col[2], "default": col[4]} for col in columns]
+ }
+ except Exception as e:
+ logger.error(f"检查表结构失败: {e}")
+ raise HTTPException(status_code=500, detail=f"检查表结构失败: {str(e)}")
+
+
+# 卡券管理API
+@app.get("/cards")
+def get_cards(current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取当前用户的卡券列表"""
+ try:
+ from db_manager import db_manager
+ user_id = current_user['user_id']
+ cards = db_manager.get_all_cards(user_id)
+ return cards
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/cards")
+def create_card(card_data: dict, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """创建新卡券"""
+ try:
+ from db_manager import db_manager
+ user_id = current_user['user_id']
+ card_name = card_data.get('name', '未命名卡券')
+
+ log_with_user('info', f"创建卡券: {card_name}", current_user)
+
+ # 验证多规格字段
+ is_multi_spec = card_data.get('is_multi_spec', False)
+ if is_multi_spec:
+ if not card_data.get('spec_name') or not card_data.get('spec_value'):
+ raise HTTPException(status_code=400, detail="多规格卡券必须提供规格名称和规格值")
+
+ card_id = db_manager.create_card(
+ name=card_data.get('name'),
+ card_type=card_data.get('type'),
+ api_config=card_data.get('api_config'),
+ text_content=card_data.get('text_content'),
+ data_content=card_data.get('data_content'),
+ image_url=card_data.get('image_url'),
+ description=card_data.get('description'),
+ enabled=card_data.get('enabled', True),
+ delay_seconds=card_data.get('delay_seconds', 0),
+ is_multi_spec=is_multi_spec,
+ spec_name=card_data.get('spec_name') if is_multi_spec else None,
+ spec_value=card_data.get('spec_value') if is_multi_spec else None,
+ user_id=user_id
+ )
+
+ log_with_user('info', f"卡券创建成功: {card_name} (ID: {card_id})", current_user)
+ return {"id": card_id, "message": "卡券创建成功"}
+ except Exception as e:
+ log_with_user('error', f"创建卡券失败: {card_data.get('name', '未知')} - {str(e)}", current_user)
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/cards/{card_id}")
+def get_card(card_id: int, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取单个卡券详情"""
+ try:
+ from db_manager import db_manager
+ user_id = current_user['user_id']
+ card = db_manager.get_card_by_id(card_id, user_id)
+ if card:
+ return card
+ else:
+ raise HTTPException(status_code=404, detail="卡券不存在")
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put("/cards/{card_id}")
+def update_card(card_id: int, card_data: dict, _: None = Depends(require_auth)):
+ """更新卡券"""
+ try:
+ from db_manager import db_manager
+ # 验证多规格字段
+ is_multi_spec = card_data.get('is_multi_spec')
+ if is_multi_spec:
+ if not card_data.get('spec_name') or not card_data.get('spec_value'):
+ raise HTTPException(status_code=400, detail="多规格卡券必须提供规格名称和规格值")
+
+ success = db_manager.update_card(
+ card_id=card_id,
+ name=card_data.get('name'),
+ card_type=card_data.get('type'),
+ api_config=card_data.get('api_config'),
+ text_content=card_data.get('text_content'),
+ data_content=card_data.get('data_content'),
+ image_url=card_data.get('image_url'),
+ description=card_data.get('description'),
+ enabled=card_data.get('enabled', True),
+ delay_seconds=card_data.get('delay_seconds'),
+ is_multi_spec=is_multi_spec,
+ spec_name=card_data.get('spec_name'),
+ spec_value=card_data.get('spec_value')
+ )
+ if success:
+ return {"message": "卡券更新成功"}
+ else:
+ raise HTTPException(status_code=404, detail="卡券不存在")
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put("/cards/{card_id}/image")
+async def update_card_with_image(
+ card_id: int,
+ image: UploadFile = File(...),
+ name: str = Form(...),
+ type: str = Form(...),
+ description: str = Form(default=""),
+ delay_seconds: int = Form(default=0),
+ enabled: bool = Form(default=True),
+ is_multi_spec: bool = Form(default=False),
+ spec_name: str = Form(default=""),
+ spec_value: str = Form(default=""),
+ current_user: Dict[str, Any] = Depends(get_current_user)
+):
+ """更新带图片的卡券"""
+ try:
+ logger.info(f"接收到带图片的卡券更新请求: card_id={card_id}, name={name}, type={type}")
+
+ # 验证图片文件
+ if not image.content_type or not image.content_type.startswith('image/'):
+ logger.warning(f"无效的图片文件类型: {image.content_type}")
+ raise HTTPException(status_code=400, detail="请上传图片文件")
+
+ # 验证多规格字段
+ if is_multi_spec:
+ if not spec_name or not spec_value:
+ raise HTTPException(status_code=400, detail="多规格卡券必须提供规格名称和规格值")
+
+ # 读取图片数据
+ image_data = await image.read()
+ logger.info(f"读取图片数据成功,大小: {len(image_data)} bytes")
+
+ # 保存图片
+ image_url = image_manager.save_image(image_data, image.filename)
+ if not image_url:
+ logger.error("图片保存失败")
+ raise HTTPException(status_code=400, detail="图片保存失败")
+
+ logger.info(f"图片保存成功: {image_url}")
+
+ # 更新卡券
+ from db_manager import db_manager
+ success = db_manager.update_card(
+ card_id=card_id,
+ name=name,
+ card_type=type,
+ image_url=image_url,
+ description=description,
+ enabled=enabled,
+ delay_seconds=delay_seconds,
+ is_multi_spec=is_multi_spec,
+ spec_name=spec_name if is_multi_spec else None,
+ spec_value=spec_value if is_multi_spec else None
+ )
+
+ if success:
+ logger.info(f"卡券更新成功: {name} (ID: {card_id})")
+ return {"message": "卡券更新成功", "image_url": image_url}
+ else:
+ # 如果数据库更新失败,删除已保存的图片
+ image_manager.delete_image(image_url)
+ raise HTTPException(status_code=404, detail="卡券不存在")
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"更新带图片的卡券失败: {e}")
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+# 自动发货规则API
+@app.get("/delivery-rules")
+def get_delivery_rules(current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取发货规则列表"""
+ try:
+ from db_manager import db_manager
+ user_id = current_user['user_id']
+ rules = db_manager.get_all_delivery_rules(user_id)
+ return rules
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/delivery-rules")
+def create_delivery_rule(rule_data: dict, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """创建新发货规则"""
+ try:
+ from db_manager import db_manager
+ user_id = current_user['user_id']
+ rule_id = db_manager.create_delivery_rule(
+ keyword=rule_data.get('keyword'),
+ card_id=rule_data.get('card_id'),
+ delivery_count=rule_data.get('delivery_count', 1),
+ enabled=rule_data.get('enabled', True),
+ description=rule_data.get('description'),
+ user_id=user_id
+ )
+ return {"id": rule_id, "message": "发货规则创建成功"}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/delivery-rules/{rule_id}")
+def get_delivery_rule(rule_id: int, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取单个发货规则详情"""
+ try:
+ from db_manager import db_manager
+ user_id = current_user['user_id']
+ rule = db_manager.get_delivery_rule_by_id(rule_id, user_id)
+ if rule:
+ return rule
+ else:
+ raise HTTPException(status_code=404, detail="发货规则不存在")
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put("/delivery-rules/{rule_id}")
+def update_delivery_rule(rule_id: int, rule_data: dict, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """更新发货规则"""
+ try:
+ from db_manager import db_manager
+ user_id = current_user['user_id']
+ success = db_manager.update_delivery_rule(
+ rule_id=rule_id,
+ keyword=rule_data.get('keyword'),
+ card_id=rule_data.get('card_id'),
+ delivery_count=rule_data.get('delivery_count', 1),
+ enabled=rule_data.get('enabled', True),
+ description=rule_data.get('description'),
+ user_id=user_id
+ )
+ if success:
+ return {"message": "发货规则更新成功"}
+ else:
+ raise HTTPException(status_code=404, detail="发货规则不存在")
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete("/cards/{card_id}")
+def delete_card(card_id: int, _: None = Depends(require_auth)):
+ """删除卡券"""
+ try:
+ from db_manager import db_manager
+ success = db_manager.delete_card(card_id)
+ if success:
+ return {"message": "卡券删除成功"}
+ else:
+ raise HTTPException(status_code=404, detail="卡券不存在")
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete("/delivery-rules/{rule_id}")
+def delete_delivery_rule(rule_id: int, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """删除发货规则"""
+ try:
+ from db_manager import db_manager
+ user_id = current_user['user_id']
+ success = db_manager.delete_delivery_rule(rule_id, user_id)
+ if success:
+ return {"message": "发货规则删除成功"}
+ else:
+ raise HTTPException(status_code=404, detail="发货规则不存在")
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+# ==================== 备份和恢复 API ====================
+
+@app.get("/backup/export")
+def export_backup(current_user: Dict[str, Any] = Depends(get_current_user)):
+ """导出用户备份"""
+ try:
+ from db_manager import db_manager
+ user_id = current_user['user_id']
+ username = current_user['username']
+
+ # 导出当前用户的数据
+ backup_data = db_manager.export_backup(user_id)
+
+ # 生成文件名
+ import datetime
+ timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+ filename = f"xianyu_backup_{username}_{timestamp}.json"
+
+ # 返回JSON响应,设置下载头
+ response = JSONResponse(content=backup_data)
+ response.headers["Content-Disposition"] = f"attachment; filename={filename}"
+ response.headers["Content-Type"] = "application/json"
+
+ return response
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"导出备份失败: {str(e)}")
+
+
+@app.post("/backup/import")
+def import_backup(file: UploadFile = File(...), current_user: Dict[str, Any] = Depends(get_current_user)):
+ """导入用户备份"""
+ try:
+ # 验证文件类型
+ if not file.filename.endswith('.json'):
+ raise HTTPException(status_code=400, detail="只支持JSON格式的备份文件")
+
+ # 读取文件内容
+ content = file.file.read()
+ backup_data = json.loads(content.decode('utf-8'))
+
+ # 导入备份到当前用户
+ from db_manager import db_manager
+ user_id = current_user['user_id']
+ success = db_manager.import_backup(backup_data, user_id)
+
+ if success:
+ # 备份导入成功后,刷新 CookieManager 的内存缓存
+ import cookie_manager
+ if cookie_manager.manager:
+ try:
+ cookie_manager.manager.reload_from_db()
+ logger.info("备份导入后已刷新 CookieManager 缓存")
+ except Exception as e:
+ logger.error(f"刷新 CookieManager 缓存失败: {e}")
+
+ return {"message": "备份导入成功"}
+ else:
+ raise HTTPException(status_code=400, detail="备份导入失败")
+
+ except json.JSONDecodeError:
+ raise HTTPException(status_code=400, detail="备份文件格式无效")
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"导入备份失败: {str(e)}")
+
+
+@app.post("/system/reload-cache")
+def reload_cache(_: None = Depends(require_auth)):
+ """重新加载系统缓存(用于手动刷新数据)"""
+ try:
+ import cookie_manager
+ if cookie_manager.manager:
+ success = cookie_manager.manager.reload_from_db()
+ if success:
+ return {"message": "系统缓存已刷新", "success": True}
+ else:
+ raise HTTPException(status_code=500, detail="缓存刷新失败")
+ else:
+ raise HTTPException(status_code=500, detail="CookieManager 未初始化")
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"刷新缓存失败: {str(e)}")
+
+
+# ==================== 商品管理 API ====================
+
+@app.get("/items")
+def get_all_items(current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取当前用户的所有商品信息"""
+ try:
+ # 只返回当前用户的商品信息
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ all_items = []
+ for cookie_id in user_cookies.keys():
+ items = db_manager.get_items_by_cookie(cookie_id)
+ all_items.extend(items)
+
+ # 按更新时间倒序排列
+ all_items.sort(key=lambda x: x.get("updated_at") or "", reverse=True)
+
+ return {"items": all_items}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"获取商品信息失败: {str(e)}")
+
+
+# ==================== 商品搜索 API ====================
+
+class ItemSearchRequest(BaseModel):
+ keyword: str
+ page: int = 1
+ page_size: int = 20
+
+class ItemSearchMultipleRequest(BaseModel):
+ keyword: str
+ total_pages: int = 1
+
+@app.post("/items/search")
+async def search_items(
+ search_request: ItemSearchRequest,
+ current_user: Optional[Dict[str, Any]] = Depends(get_current_user_optional)
+):
+ """搜索闲鱼商品"""
+ user_info = f"【{current_user.get('username', 'unknown')}#{current_user.get('user_id', 'unknown')}】" if current_user else "【未登录】"
+
+ try:
+ logger.info(f"{user_info} 开始单页搜索: 关键词='{search_request.keyword}', 页码={search_request.page}, 每页={search_request.page_size}")
+
+ from utils.item_search import search_xianyu_items
+
+ # 执行搜索
+ result = await search_xianyu_items(
+ keyword=search_request.keyword,
+ page=search_request.page,
+ page_size=search_request.page_size
+ )
+
+ # 检查是否有错误
+ has_error = result.get("error")
+ items_count = len(result.get("items", []))
+
+ logger.info(f"{user_info} 单页搜索完成: 获取到 {items_count} 条数据" +
+ (f", 错误: {has_error}" if has_error else ""))
+
+ response_data = {
+ "success": True,
+ "data": result.get("items", []),
+ "total": result.get("total", 0),
+ "page": search_request.page,
+ "page_size": search_request.page_size,
+ "keyword": search_request.keyword,
+ "is_real_data": result.get("is_real_data", False),
+ "source": result.get("source", "unknown")
+ }
+
+ # 如果有错误信息,也包含在响应中
+ if has_error:
+ response_data["error"] = has_error
+
+ return response_data
+
+ except Exception as e:
+ error_msg = str(e)
+ logger.error(f"{user_info} 商品搜索失败: {error_msg}")
+ raise HTTPException(status_code=500, detail=f"商品搜索失败: {error_msg}")
+
+
+@app.get("/cookies/check")
+async def check_valid_cookies(
+ current_user: Optional[Dict[str, Any]] = Depends(get_current_user_optional)
+):
+ """检查是否有有效的cookies账户(必须是启用状态)"""
+ try:
+ if cookie_manager.manager is None:
+ return {
+ "success": True,
+ "hasValidCookies": False,
+ "validCount": 0,
+ "enabledCount": 0,
+ "totalCount": 0
+ }
+
+ from db_manager import db_manager
+
+ # 获取所有cookies
+ all_cookies = db_manager.get_all_cookies()
+
+ # 检查启用状态和有效性
+ valid_cookies = []
+ enabled_cookies = []
+
+ for cookie_id, cookie_value in all_cookies.items():
+ # 检查是否启用
+ is_enabled = cookie_manager.manager.get_cookie_status(cookie_id)
+ if is_enabled:
+ enabled_cookies.append(cookie_id)
+ # 检查是否有效(长度大于50)
+ if len(cookie_value) > 50:
+ valid_cookies.append(cookie_id)
+
+ return {
+ "success": True,
+ "hasValidCookies": len(valid_cookies) > 0,
+ "validCount": len(valid_cookies),
+ "enabledCount": len(enabled_cookies),
+ "totalCount": len(all_cookies)
+ }
+
+ except Exception as e:
+ logger.error(f"检查cookies失败: {str(e)}")
+ return {
+ "success": False,
+ "hasValidCookies": False,
+ "error": str(e)
+ }
+
+@app.get("/cookies/online-status")
+async def get_cookies_online_status(
+ current_user: Optional[Dict[str, Any]] = Depends(get_current_user_optional)
+):
+ """获取所有Cookie的WebSocket实时在线状态"""
+ try:
+ if cookie_manager.manager is None:
+ return {"success": True, "status": {}}
+
+ from db_manager import db_manager as db
+ user_id = current_user['user_id'] if current_user else None
+ all_cookies = db.get_all_cookies(user_id)
+
+ result = {}
+ for cookie_id in all_cookies:
+ is_enabled = cookie_manager.manager.get_cookie_status(cookie_id)
+ is_online = cookie_manager.manager.get_online_status(cookie_id)
+ # 禁用状态显示为 disabled,启用状态根据在线状态显示
+ if not is_enabled:
+ status = "disabled"
+ elif is_online is True:
+ status = "online"
+ else:
+ status = "offline"
+ result[cookie_id] = {
+ "status": status,
+ "enabled": is_enabled,
+ "online": is_online if is_online is not None else False
+ }
+
+ return {"success": True, "status": result}
+ except Exception as e:
+ logger.error(f"获取在线状态失败: {str(e)}")
+ return {"success": False, "status": {}}
+
+@app.post("/items/search_multiple")
+async def search_multiple_pages(
+ search_request: ItemSearchMultipleRequest,
+ current_user: Optional[Dict[str, Any]] = Depends(get_current_user_optional)
+):
+ """搜索多页闲鱼商品"""
+ user_info = f"【{current_user.get('username', 'unknown')}#{current_user.get('user_id', 'unknown')}】" if current_user else "【未登录】"
+
+ try:
+ logger.info(f"{user_info} 开始多页搜索: 关键词='{search_request.keyword}', 页数={search_request.total_pages}")
+
+ from utils.item_search import search_multiple_pages_xianyu
+
+ # 执行多页搜索
+ result = await search_multiple_pages_xianyu(
+ keyword=search_request.keyword,
+ total_pages=search_request.total_pages
+ )
+
+ # 检查是否有错误
+ has_error = result.get("error")
+ items_count = len(result.get("items", []))
+
+ logger.info(f"{user_info} 多页搜索完成: 获取到 {items_count} 条数据" +
+ (f", 错误: {has_error}" if has_error else ""))
+
+ response_data = {
+ "success": True,
+ "data": result.get("items", []),
+ "total": result.get("total", 0),
+ "total_pages": search_request.total_pages,
+ "keyword": search_request.keyword,
+ "is_real_data": result.get("is_real_data", False),
+ "is_fallback": result.get("is_fallback", False),
+ "source": result.get("source", "unknown")
+ }
+
+ # 如果有错误信息,也包含在响应中
+ if has_error:
+ response_data["error"] = has_error
+
+ return response_data
+
+ except Exception as e:
+ error_msg = str(e)
+ logger.error(f"{user_info} 多页商品搜索失败: {error_msg}")
+ raise HTTPException(status_code=500, detail=f"多页商品搜索失败: {error_msg}")
+
+
+@app.get("/items/detail/{item_id}")
+async def get_public_item_detail(
+ item_id: str,
+ current_user: Optional[Dict[str, Any]] = Depends(get_current_user_optional)
+):
+ """获取公开商品详情(通过外部API)"""
+ try:
+ from utils.item_search import get_item_detail_from_api
+
+ # 从外部API获取商品详情
+ detail = await get_item_detail_from_api(item_id)
+
+ if detail:
+ return {
+ "success": True,
+ "data": detail
+ }
+ else:
+ raise HTTPException(status_code=404, detail="商品详情获取失败")
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"获取商品详情失败: {str(e)}")
+ raise HTTPException(status_code=500, detail=f"获取商品详情失败: {str(e)}")
+
+
+@app.get("/items/cookie/{cookie_id}")
+def get_items_by_cookie(cookie_id: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取指定Cookie的商品信息"""
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cookie_id not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限访问该Cookie")
+
+ items = db_manager.get_items_by_cookie(cookie_id)
+ return {"items": items}
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"获取商品信息失败: {str(e)}")
+
+
+@app.get("/items/{cookie_id}/{item_id}")
+def get_item_detail(cookie_id: str, item_id: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取商品详情"""
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cookie_id not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限访问该Cookie")
+
+ item = db_manager.get_item_info(cookie_id, item_id)
+ if not item:
+ raise HTTPException(status_code=404, detail="商品不存在")
+ return {"item": item}
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"获取商品详情失败: {str(e)}")
+
+
+class ItemDetailUpdate(BaseModel):
+ item_title: Optional[str] = None
+ item_price: Optional[str] = None
+ item_description: Optional[str] = None
+ item_detail: Optional[str] = None
+ sync_to_xianyu: bool = False
+
+
+@app.put("/items/{cookie_id}/{item_id}")
+def update_item_detail(
+ cookie_id: str,
+ item_id: str,
+ update_data: ItemDetailUpdate,
+ current_user: Dict[str, Any] = Depends(get_current_user)
+):
+ """更新商品详情,可选择同步到闲鱼"""
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cookie_id not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限操作该Cookie")
+
+ # 保存到本地数据库
+ success = db_manager.update_item_fields(
+ cookie_id, item_id,
+ item_title=update_data.item_title,
+ item_price=update_data.item_price,
+ item_description=update_data.item_description,
+ item_detail=update_data.item_detail
+ )
+ if not success:
+ raise HTTPException(status_code=400, detail="更新失败,商品不存在")
+
+ result = {"message": "商品更新成功", "sync_success": True, "sync_result": ""}
+
+ # 如果需要同步到闲鱼
+ if update_data.sync_to_xianyu:
+ has_sync_fields = any([
+ update_data.item_title,
+ update_data.item_price,
+ update_data.item_description
+ ])
+ if has_sync_fields:
+ # 闲鱼网页版不支持商品编辑,只能通过 APP 操作
+ logger.info(f"闲鱼同步请求: {cookie_id}/{item_id} title={update_data.item_title}")
+ result['sync_result'] = '闲鱼网页版不支持编辑商品,请到闲鱼 APP 修改'
+ result['sync_success'] = False
+ else:
+ result['sync_result'] = '未修改标题/价格/描述,跳过同步'
+ else:
+ result['sync_result'] = '未勾选同步到闲鱼'
+
+ return result
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"更新商品详情失败: {str(e)}")
+
+
+@app.delete("/items/{cookie_id}/{item_id}")
+def delete_item_info(
+ cookie_id: str,
+ item_id: str,
+ current_user: Dict[str, Any] = Depends(get_current_user)
+):
+ """删除商品信息"""
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cookie_id not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限操作该Cookie")
+
+ success = db_manager.delete_item_info(cookie_id, item_id)
+ if success:
+ return {"message": "商品信息删除成功"}
+ else:
+ raise HTTPException(status_code=404, detail="商品信息不存在")
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"删除商品信息异常: {e}")
+ raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}")
+
+
+class BatchDeleteRequest(BaseModel):
+ items: List[dict] # [{"cookie_id": "xxx", "item_id": "yyy"}, ...]
+
+
+class AIReplySettings(BaseModel):
+ ai_enabled: bool
+ model_name: str = "qwen-plus"
+ api_key: str = ""
+ base_url: str = "https://dashscope.aliyuncs.com/compatible-mode/v1"
+ max_discount_percent: int = 10
+ max_discount_amount: int = 100
+ max_bargain_rounds: int = 3
+ custom_prompts: str = ""
+ refund_policy: str = "allow"
+
+
+@app.delete("/items/batch")
+def batch_delete_items(
+ request: BatchDeleteRequest,
+ _: None = Depends(require_auth)
+):
+ """批量删除商品信息"""
+ try:
+ if not request.items:
+ raise HTTPException(status_code=400, detail="删除列表不能为空")
+
+ success_count = db_manager.batch_delete_item_info(request.items)
+ total_count = len(request.items)
+
+ return {
+ "message": f"批量删除完成",
+ "success_count": success_count,
+ "total_count": total_count,
+ "failed_count": total_count - success_count
+ }
+ except Exception as e:
+ logger.error(f"批量删除商品信息异常: {e}")
+ raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}")
+
+
+# ==================== AI回复管理API ====================
+
+@app.get("/ai-reply-settings/{cookie_id}")
+def get_ai_reply_settings(cookie_id: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取指定账号的AI回复设置"""
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cookie_id not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限访问该Cookie")
+
+ settings = db_manager.get_ai_reply_settings(cookie_id)
+
+ # 掩码处理 API 密钥:仅显示首4位+****+末4位
+ api_key = settings.get('api_key', '')
+ if api_key and len(api_key) > 8:
+ masked_key = api_key[:4] + '****' + api_key[-4:]
+ elif api_key:
+ masked_key = api_key[:2] + '****' if len(api_key) > 4 else '****'
+ else:
+ masked_key = ''
+ settings['api_key'] = masked_key
+
+ return settings
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"获取AI回复设置异常: {e}")
+ raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}")
+
+
+@app.put("/ai-reply-settings/{cookie_id}")
+def update_ai_reply_settings(cookie_id: str, settings: AIReplySettings, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """更新指定账号的AI回复设置"""
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cookie_id not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限操作该Cookie")
+
+ # 检查账号是否存在
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail='CookieManager 未就绪')
+
+ # 保存设置
+ settings_dict = settings.dict()
+
+ # 如果 API 密钥包含 ****,说明用户没改密钥,保持原值
+ if settings_dict.get('api_key') and '****' in settings_dict['api_key']:
+ # 从数据库获取当前密钥
+ current_settings = db_manager.get_ai_reply_settings(cookie_id)
+ if current_settings and current_settings.get('api_key'):
+ settings_dict['api_key'] = current_settings['api_key']
+
+ success = db_manager.save_ai_reply_settings(cookie_id, settings_dict)
+
+ if success:
+ # 清理客户端缓存,强制重新创建
+ ai_reply_engine.clear_client_cache(cookie_id)
+
+ # 如果启用了AI回复,记录日志
+ if settings.ai_enabled:
+ logger.info(f"账号 {cookie_id} 启用AI回复")
+ else:
+ logger.info(f"账号 {cookie_id} 禁用AI回复")
+
+ return {"message": "AI回复设置更新成功"}
+ else:
+ raise HTTPException(status_code=400, detail="更新失败")
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"更新AI回复设置异常: {e}")
+ raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}")
+
+
+@app.get("/ai-reply-settings")
+def get_all_ai_reply_settings(current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取当前用户所有账号的AI回复设置"""
+ try:
+ # 只返回当前用户的AI回复设置
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ all_settings = db_manager.get_all_ai_reply_settings()
+ # 过滤只属于当前用户的设置
+ user_settings = {cid: settings for cid, settings in all_settings.items() if cid in user_cookies}
+ return user_settings
+ except Exception as e:
+ logger.error(f"获取所有AI回复设置异常: {e}")
+ raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}")
+
+
+@app.post("/ai-reply-test/{cookie_id}")
+def test_ai_reply(cookie_id: str, test_data: dict = Body(...), _: None = Depends(require_auth)):
+ """测试AI回复功能"""
+ try:
+ # 检查账号是否存在
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=500, detail='CookieManager 未就绪')
+
+ if cookie_id not in cookie_manager.manager.cookies:
+ raise HTTPException(status_code=404, detail='账号不存在')
+
+ # 检查是否启用AI回复
+ if not ai_reply_engine.is_ai_enabled(cookie_id):
+ raise HTTPException(status_code=400, detail='该账号未启用AI回复')
+
+ # 检查 API Key 是否已配置
+ settings = db_manager.get_ai_reply_settings(cookie_id)
+ if not settings.get('api_key'):
+ raise HTTPException(status_code=400, detail='请先配置 AI 回复的 API Key')
+
+ # 构造测试数据
+ test_message = test_data.get('message', '你好')
+ test_item_info = {
+ 'title': test_data.get('item_title', '测试商品'),
+ 'price': test_data.get('item_price', 100),
+ 'desc': test_data.get('item_desc', '这是一个测试商品')
+ }
+
+ # 生成测试回复
+ reply = ai_reply_engine.generate_reply(
+ message=test_message,
+ item_info=test_item_info,
+ chat_id=f"test_{int(time.time())}",
+ cookie_id=cookie_id,
+ user_id="test_user",
+ item_id="test_item"
+ )
+
+ if reply:
+ return {"message": "测试成功", "reply": reply}
+ else:
+ raise HTTPException(status_code=400, detail="AI回复生成失败")
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"测试AI回复异常: {e}")
+ raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}")
+
+
+# ------------------------- AI对话历史接口 -------------------------
+
+@app.get("/ai-conversations")
+def get_ai_conversations(
+ cookie_id: str = None,
+ buyer_id: str = None,
+ item_id: str = None,
+ page: int = 1,
+ page_size: int = 20,
+ current_user: Dict[str, Any] = Depends(get_current_user)
+):
+ """分页获取AI对话历史"""
+ try:
+ from db_manager import db_manager
+ uid = current_user['user_id']
+ is_admin = current_user.get('is_admin', False)
+
+ # 非管理员只能查看自己账号的对话
+ if is_admin:
+ user_cookie_ids = None
+ else:
+ user_cookies = db_manager.get_all_cookies(uid)
+ user_cookie_ids = list(user_cookies.keys()) if user_cookies else []
+
+ result = db_manager.get_ai_conversations(
+ cookie_id=cookie_id,
+ user_id=buyer_id,
+ item_id=item_id,
+ page=page,
+ page_size=page_size,
+ user_cookie_ids=user_cookie_ids
+ )
+ return result
+ except Exception as e:
+ logger.error(f"获取AI对话历史异常: {e}")
+ raise HTTPException(status_code=500, detail=f"服务器错误: {str(e)}")
+
+
+# ==================== 日志管理API ====================
+
+@app.get("/logs")
+async def get_logs(lines: int = 200, level: str = None, source: str = None, _: None = Depends(require_auth)):
+ """获取实时系统日志"""
+ try:
+ # 获取文件日志收集器
+ collector = get_file_log_collector()
+
+ # 获取日志
+ logs = collector.get_logs(lines=lines, level_filter=level, source_filter=source)
+
+ return {"success": True, "logs": logs}
+
+ except Exception as e:
+ return {"success": False, "message": f"获取日志失败: {str(e)}", "logs": []}
+
+
+@app.get("/logs/stats")
+async def get_log_stats(_: None = Depends(require_auth)):
+ """获取日志统计信息"""
+ try:
+ collector = get_file_log_collector()
+ stats = collector.get_stats()
+
+ return {"success": True, "stats": stats}
+
+ except Exception as e:
+ return {"success": False, "message": f"获取日志统计失败: {str(e)}", "stats": {}}
+
+
+@app.post("/logs/clear")
+async def clear_logs(_: None = Depends(require_auth)):
+ """清空日志"""
+ try:
+ collector = get_file_log_collector()
+ collector.clear_logs()
+
+ return {"success": True, "message": "日志已清空"}
+
+ except Exception as e:
+ return {"success": False, "message": f"清空日志失败: {str(e)}"}
+
+
+# ==================== 商品管理API ====================
+
+@app.post("/items/get-all-from-account")
+async def get_all_items_from_account(request: dict, _: None = Depends(require_auth)):
+ """从指定账号获取所有商品信息"""
+ try:
+ cookie_id = request.get('cookie_id')
+ if not cookie_id:
+ return {"success": False, "message": "缺少cookie_id参数"}
+
+ # 获取指定账号的cookie信息
+ cookie_info = db_manager.get_cookie_by_id(cookie_id)
+ if not cookie_info:
+ return {"success": False, "message": "未找到指定的账号信息"}
+
+ cookies_str = cookie_info.get('cookies_str', '')
+ if not cookies_str:
+ return {"success": False, "message": "账号cookie信息为空"}
+
+ # 创建XianyuLive实例,传入正确的cookie_id
+ from XianyuAutoAsync import XianyuLive
+ xianyu_instance = XianyuLive(cookies_str, cookie_id)
+
+ # 调用获取所有商品信息的方法(自动分页)
+ logger.info(f"开始获取账号 {cookie_id} 的所有商品信息")
+ result = await xianyu_instance.get_all_items()
+
+ # 关闭session
+ await xianyu_instance.close_session()
+
+ if result.get('error'):
+ logger.error(f"获取商品信息失败: {result['error']}")
+ return {"success": False, "message": result['error']}
+ else:
+ total_count = result.get('total_count', 0)
+ total_pages = result.get('total_pages', 1)
+ logger.info(f"成功获取账号 {cookie_id} 的 {total_count} 个商品(共{total_pages}页)")
+ return {
+ "success": True,
+ "message": f"成功获取 {total_count} 个商品(共{total_pages}页),详细信息已打印到控制台",
+ "total_count": total_count,
+ "total_pages": total_pages
+ }
+
+ except Exception as e:
+ logger.error(f"获取账号商品信息异常: {str(e)}")
+ return {"success": False, "message": f"获取商品信息异常: {str(e)}"}
+
+
+@app.post("/items/get-by-page")
+async def get_items_by_page(request: dict, _: None = Depends(require_auth)):
+ """从指定账号按页获取商品信息"""
+ try:
+ # 验证参数
+ cookie_id = request.get('cookie_id')
+ page_number = request.get('page_number', 1)
+ page_size = request.get('page_size', 20)
+
+ if not cookie_id:
+ return {"success": False, "message": "缺少cookie_id参数"}
+
+ # 验证分页参数
+ try:
+ page_number = int(page_number)
+ page_size = int(page_size)
+ except (ValueError, TypeError):
+ return {"success": False, "message": "页码和每页数量必须是数字"}
+
+ if page_number < 1:
+ return {"success": False, "message": "页码必须大于0"}
+
+ if page_size < 1 or page_size > 100:
+ return {"success": False, "message": "每页数量必须在1-100之间"}
+
+ # 获取账号信息
+ account = db_manager.get_cookie_by_id(cookie_id)
+ if not account:
+ return {"success": False, "message": "账号不存在"}
+
+ cookies_str = account['cookies_str']
+ if not cookies_str:
+ return {"success": False, "message": "账号cookies为空"}
+
+ # 创建XianyuLive实例,传入正确的cookie_id
+ from XianyuAutoAsync import XianyuLive
+ xianyu_instance = XianyuLive(cookies_str, cookie_id)
+
+ # 调用获取指定页商品信息的方法
+ logger.info(f"开始获取账号 {cookie_id} 第{page_number}页商品信息(每页{page_size}条)")
+ result = await xianyu_instance.get_item_list_info(page_number, page_size)
+
+ # 关闭session
+ await xianyu_instance.close_session()
+
+ if result.get('error'):
+ logger.error(f"获取商品信息失败: {result['error']}")
+ return {"success": False, "message": result['error']}
+ else:
+ current_count = result.get('current_count', 0)
+ logger.info(f"成功获取账号 {cookie_id} 第{page_number}页 {current_count} 个商品")
+ return {
+ "success": True,
+ "message": f"成功获取第{page_number}页 {current_count} 个商品,详细信息已打印到控制台",
+ "page_number": page_number,
+ "page_size": page_size,
+ "current_count": current_count
+ }
+
+ except Exception as e:
+ logger.error(f"获取账号商品信息异常: {str(e)}")
+ return {"success": False, "message": f"获取商品信息异常: {str(e)}"}
+
+
+# ------------------------- 用户设置接口 -------------------------
+
+@app.get('/user-settings')
+def get_user_settings(current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取当前用户的设置"""
+ from db_manager import db_manager
+ try:
+ user_id = current_user['user_id']
+ settings = db_manager.get_user_settings(user_id)
+ return settings
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+@app.put('/user-settings/{key}')
+def update_user_setting(key: str, setting_data: dict, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """更新用户设置"""
+ from db_manager import db_manager
+ try:
+ user_id = current_user['user_id']
+ value = setting_data.get('value')
+ description = setting_data.get('description', '')
+
+ log_with_user('info', f"更新用户设置: {key} = {value}", current_user)
+
+ success = db_manager.set_user_setting(user_id, key, value, description)
+ if success:
+ log_with_user('info', f"用户设置更新成功: {key}", current_user)
+ return {'msg': 'setting updated', 'key': key, 'value': value}
+ else:
+ log_with_user('error', f"用户设置更新失败: {key}", current_user)
+ raise HTTPException(status_code=400, detail='更新失败')
+ except Exception as e:
+ log_with_user('error', f"更新用户设置异常: {key} - {str(e)}", current_user)
+ raise HTTPException(status_code=500, detail=str(e))
+
+@app.get('/user-settings/{key}')
+def get_user_setting(key: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取用户特定设置"""
+ from db_manager import db_manager
+ try:
+ user_id = current_user['user_id']
+ setting = db_manager.get_user_setting(user_id, key)
+ if setting:
+ return setting
+ else:
+ raise HTTPException(status_code=404, detail='设置不存在')
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+# ------------------------- 管理员专用接口 -------------------------
+
+@app.get('/admin/users')
+def get_all_users(admin_user: Dict[str, Any] = Depends(require_permission('user_management'))):
+ """获取所有用户信息(管理员专用)"""
+ from db_manager import db_manager
+ try:
+ log_with_user('info', "查询所有用户信息", admin_user)
+ users = db_manager.get_all_users()
+
+ # 为每个用户添加统计信息
+ for user in users:
+ user_id = user['id']
+ # 统计用户的Cookie数量
+ user_cookies = db_manager.get_all_cookies(user_id)
+ user['cookie_count'] = len(user_cookies)
+
+ # 统计用户的卡券数量
+ user_cards = db_manager.get_all_cards(user_id)
+ user['card_count'] = len(user_cards) if user_cards else 0
+
+ # 隐藏密码字段
+ if 'password_hash' in user:
+ del user['password_hash']
+
+ log_with_user('info', f"返回用户信息,共 {len(users)} 个用户", admin_user)
+ return {"users": users}
+ except Exception as e:
+ log_with_user('error', f"获取用户信息失败: {str(e)}", admin_user)
+ raise HTTPException(status_code=500, detail=str(e))
+
+@app.post('/admin/users')
+def create_user_by_admin(admin_user: Dict[str, Any] = Depends(require_permission('user_management')), data: dict = Body(...)):
+ """管理员创建新用户"""
+ from db_manager import db_manager
+ try:
+ username = data.get('username', '').strip()
+ email = data.get('email', '').strip()
+ password = data.get('password', '').strip()
+ role = data.get('role', 'user').strip()
+
+ if not username or not email or not password:
+ raise HTTPException(status_code=400, detail="用户名、邮箱和密码不能为空")
+
+ if len(username) < 2:
+ raise HTTPException(status_code=400, detail="用户名至少2个字符")
+
+ if len(password) < 6:
+ raise HTTPException(status_code=400, detail="密码至少6位")
+
+ if role not in ('user', 'admin'):
+ raise HTTPException(status_code=400, detail="角色无效")
+
+ # 检查用户名是否已存在
+ existing = db_manager.get_user_by_username(username)
+ if existing:
+ raise HTTPException(status_code=400, detail=f"用户名 '{username}' 已存在")
+
+ success = db_manager.create_user(username, email, password, role)
+ if success:
+ log_with_user('info', f"管理员创建用户成功: {username}, 角色: {role}", admin_user)
+ return {"success": True, "message": f"用户 '{username}' 创建成功"}
+ else:
+ raise HTTPException(status_code=400, detail="创建用户失败,用户名或邮箱可能已存在")
+ except HTTPException:
+ raise
+ except Exception as e:
+ log_with_user('error', f"创建用户异常: {str(e)}", admin_user)
+ raise HTTPException(status_code=500, detail=str(e))
+
+@app.put('/admin/users/{user_id}')
+def update_user_by_admin(user_id: int, data: dict = Body(...), admin_user: Dict[str, Any] = Depends(require_permission('user_management'))):
+ """管理员修改用户信息(密码重置)"""
+ from db_manager import db_manager
+ try:
+ user = db_manager.get_user_by_id(user_id)
+ if not user:
+ raise HTTPException(status_code=404, detail="用户不存在")
+
+ new_password = data.get('password', '').strip()
+ if new_password:
+ if len(new_password) < 6:
+ raise HTTPException(status_code=400, detail="密码至少6位")
+ success = db_manager.update_user_password(user['username'], new_password)
+ if success:
+ log_with_user('info', f"管理员重置用户密码成功: {user['username']}", admin_user)
+ return {"success": True, "message": f"用户 '{user['username']}' 密码已重置"}
+
+ new_email = data.get('email', '').strip()
+ if new_email:
+ db_manager.update_user_email(user['username'], new_email)
+ log_with_user('info', f"管理员更新用户邮箱: {user['username']} -> {new_email}", admin_user)
+ return {"success": True, "message": f"用户 '{user['username']}' 邮箱已更新"}
+
+ new_role = data.get('role', '').strip()
+ if new_role:
+ if new_role not in ('user', 'admin'):
+ raise HTTPException(status_code=400, detail="角色无效")
+ db_manager.update_user_role(user['username'], new_role)
+ log_with_user('info', f"管理员更新用户角色: {user['username']} -> {new_role}", admin_user)
+ return {"success": True, "message": f"用户 '{user['username']}' 角色已更新为 {new_role}"}
+
+ raise HTTPException(status_code=400, detail="未提供需要修改的字段")
+ except HTTPException:
+ raise
+ except Exception as e:
+ log_with_user('error', f"修改用户异常: {str(e)}", admin_user)
+ raise HTTPException(status_code=500, detail=str(e))
+
+@app.delete('/admin/users/{user_id}')
+def delete_user(user_id: int, admin_user: Dict[str, Any] = Depends(require_permission('user_management'))):
+ """删除用户(管理员专用)"""
+ from db_manager import db_manager
+ try:
+ # 不能删除管理员自己
+ if user_id == admin_user['user_id']:
+ log_with_user('warning', "尝试删除管理员自己", admin_user)
+ raise HTTPException(status_code=400, detail="不能删除管理员自己")
+
+ # 获取要删除的用户信息
+ user_to_delete = db_manager.get_user_by_id(user_id)
+ if not user_to_delete:
+ raise HTTPException(status_code=404, detail="用户不存在")
+
+ log_with_user('info', f"准备删除用户: {user_to_delete['username']} (ID: {user_id})", admin_user)
+
+ # 删除用户及其相关数据
+ success = db_manager.delete_user_and_data(user_id)
+
+ if success:
+ log_with_user('info', f"用户删除成功: {user_to_delete['username']} (ID: {user_id})", admin_user)
+ return {"message": f"用户 {user_to_delete['username']} 删除成功"}
+ else:
+ log_with_user('error', f"用户删除失败: {user_to_delete['username']} (ID: {user_id})", admin_user)
+ raise HTTPException(status_code=400, detail="删除失败")
+ except HTTPException:
+ raise
+ except Exception as e:
+ log_with_user('error', f"删除用户异常: {str(e)}", admin_user)
+ raise HTTPException(status_code=500, detail=str(e))
+
+@app.get('/admin/logs')
+def get_system_logs(admin_user: Dict[str, Any] = Depends(require_permission('system_logs')),
+ lines: int = 100,
+ level: str = None):
+ """获取系统日志(管理员专用)"""
+ import os
+ import glob
+ from datetime import datetime
+
+ try:
+ log_with_user('info', f"查询系统日志,行数: {lines}, 级别: {level}", admin_user)
+
+ # 查找日志文件
+ log_files = glob.glob("logs/xianyu_*.log")
+ logger.info(f"找到日志文件: {log_files}")
+
+ if not log_files:
+ logger.warning("未找到日志文件")
+ return {"logs": [], "message": "未找到日志文件", "success": False}
+
+ # 获取最新的日志文件
+ latest_log_file = max(log_files, key=os.path.getctime)
+ logger.info(f"使用最新日志文件: {latest_log_file}")
+
+ logs = []
+ try:
+ with open(latest_log_file, 'r', encoding='utf-8') as f:
+ all_lines = f.readlines()
+ logger.info(f"读取到 {len(all_lines)} 行日志")
+
+ # 如果指定了日志级别,进行过滤
+ if level:
+ import re as re_module
+ level_pattern = re_module.compile(rf'\|\s*{re_module.escape(level.upper())}\s*\|')
+ filtered_lines = [line for line in all_lines if level_pattern.search(line)]
+ logger.info(f"按级别 {level} 过滤后剩余 {len(filtered_lines)} 行")
+ else:
+ filtered_lines = all_lines
+
+ # 获取最后N行
+ recent_lines = filtered_lines[-lines:] if len(filtered_lines) > lines else filtered_lines
+ logger.info(f"取最后 {len(recent_lines)} 行日志")
+
+ for line in recent_lines:
+ logs.append(line.strip())
+
+ except Exception as e:
+ logger.error(f"读取日志文件失败: {str(e)}")
+ log_with_user('error', f"读取日志文件失败: {str(e)}", admin_user)
+ return {"logs": [], "message": f"读取日志文件失败: {str(e)}", "success": False}
+
+ log_with_user('info', f"返回日志记录 {len(logs)} 条", admin_user)
+ logger.info(f"成功返回 {len(logs)} 条日志记录")
+
+ return {
+ "logs": logs,
+ "log_file": latest_log_file,
+ "total_lines": len(logs),
+ "success": True
+ }
+
+ except Exception as e:
+ logger.error(f"获取系统日志失败: {str(e)}")
+ log_with_user('error', f"获取系统日志失败: {str(e)}", admin_user)
+ return {"logs": [], "message": f"获取系统日志失败: {str(e)}", "success": False}
+
+@app.get('/admin/stats')
+def get_system_stats(admin_user: Dict[str, Any] = Depends(require_permission('data_management'))):
+ """获取系统统计信息"""
+ from db_manager import db_manager
+ try:
+ log_with_user('info', "查询系统统计信息", admin_user)
+
+ stats = {
+ "users": {
+ "total": 0,
+ "active_today": 0
+ },
+ "cookies": {
+ "total": 0,
+ "enabled": 0
+ },
+ "cards": {
+ "total": 0,
+ "enabled": 0
+ },
+ "system": {
+ "uptime": "未知",
+ "version": "1.0.0"
+ }
+ }
+
+ # 用户统计
+ all_users = db_manager.get_all_users()
+ stats["users"]["total"] = len(all_users)
+
+ # Cookie统计
+ all_cookies = db_manager.get_all_cookies()
+ stats["cookies"]["total"] = len(all_cookies)
+
+ # 卡券统计
+ all_cards = db_manager.get_all_cards()
+ if all_cards:
+ stats["cards"]["total"] = len(all_cards)
+ stats["cards"]["enabled"] = len([card for card in all_cards if card.get('enabled', True)])
+
+ log_with_user('info', "系统统计信息查询完成", admin_user)
+ return stats
+
+ except Exception as e:
+ log_with_user('error', f"获取系统统计信息失败: {str(e)}", admin_user)
+ raise HTTPException(status_code=500, detail=str(e))
+
+@app.get('/admin/permissions')
+def get_default_roles() -> dict:
+ """获取默认角色权限配置"""
+ admin_perms = {k: True for k in ALL_PERMISSIONS}
+ user_perms = {}
+ for k in ALL_PERMISSIONS:
+ # 管理员功能默认不给普通用户
+ if k in ('user_management', 'system_logs', 'data_management', 'system_settings', 'export_backup', 'import_backup'):
+ user_perms[k] = False
+ else:
+ user_perms[k] = True
+ return {'admin': admin_perms, 'user': user_perms}
+
+def get_permissions(admin_user: Dict[str, Any] = Depends(require_admin)):
+ """获取角色权限配置"""
+ from db_manager import db_manager as _db
+ try:
+ val = _db.get_system_setting('user_permissions')
+ roles = json.loads(val) if val else {}
+ if not roles:
+ roles = get_default_roles()
+ _db.set_system_setting('user_permissions', json.dumps(roles), '角色权限配置')
+ return {"success": True, "roles": roles, "all_permissions": ALL_PERMISSIONS}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+@app.put('/admin/permissions')
+def set_permissions(data: dict = Body(...), admin_user: Dict[str, Any] = Depends(require_admin)):
+ """保存角色权限配置"""
+ from db_manager import db_manager as _db
+ try:
+ roles = data.get('roles', {})
+ _db.set_system_setting('user_permissions', json.dumps(roles), '角色权限配置')
+ log_with_user('info', f"更新角色权限配置", admin_user)
+ return {"success": True, "message": "角色权限配置已保存"}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+@app.get('/admin/roles')
+def get_roles(admin_user: Dict[str, Any] = Depends(require_admin)):
+ """获取所有可用角色列表"""
+ from db_manager import db_manager as _db
+ try:
+ val = _db.get_system_setting('user_permissions')
+ roles = json.loads(val) if val else {}
+ role_names = list(roles.keys())
+ if 'admin' not in role_names:
+ role_names.insert(0, 'admin')
+ if 'user' not in role_names:
+ role_names.append('user')
+ return {"success": True, "roles": role_names}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+@app.get('/my-permissions')
+def get_my_permissions(current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取当前用户的有效权限"""
+ try:
+ username = current_user.get('username', '')
+ if username == 'admin':
+ return {"success": True, "role": "admin", "permissions": {k: True for k in ALL_PERMISSIONS}}
+
+ role = current_user.get('role', 'user')
+ roles_config = get_user_permissions()
+ role_data = roles_config.get(role, {})
+ if role == 'admin' and not role_data:
+ return {"success": True, "role": role, "permissions": {k: True for k in ALL_PERMISSIONS}}
+
+ return {"success": True, "role": role, "permissions": role_data}
+ except Exception as e:
+ return {"success": False, "error": str(e), "permissions": {}}
+
+# ------------------------- 指定商品回复接口 -------------------------
+
+@app.get("/itemReplays")
+def get_all_items(current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取当前用户的所有商品回复信息"""
+ try:
+ # 只返回当前用户的商品信息
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ all_items = []
+ for cookie_id in user_cookies.keys():
+ items = db_manager.get_itemReplays_by_cookie(cookie_id)
+ all_items.extend(items)
+
+ return {"items": all_items}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"获取商品回复信息失败: {str(e)}")
+
+@app.get("/itemReplays/cookie/{cookie_id}")
+def get_items_by_cookie(cookie_id: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """获取指定Cookie的商品信息"""
+ try:
+ # 检查cookie是否属于当前用户
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+ user_cookies = db_manager.get_all_cookies(user_id)
+
+ if cookie_id not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限访问该Cookie")
+
+ items = db_manager.get_itemReplays_by_cookie(cookie_id)
+ return {"items": items}
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"获取商品信息失败: {str(e)}")
+
+@app.put("/item-reply/{cookie_id}/{item_id}")
+def update_item_reply(
+ cookie_id: str,
+ item_id: str,
+ data: dict,
+ current_user: Dict[str, Any] = Depends(get_current_user)
+):
+ """
+ 更新指定账号和商品的回复内容
+ """
+ try:
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+
+ # 验证cookie是否属于用户
+ user_cookies = db_manager.get_all_cookies(user_id)
+ if cookie_id not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限访问该Cookie")
+
+ reply_content = data.get("reply_content", "").strip()
+ if not reply_content:
+ raise HTTPException(status_code=400, detail="回复内容不能为空")
+
+ db_manager.update_item_reply(cookie_id=cookie_id, item_id=item_id, reply_content=reply_content)
+
+ return {"message": "商品回复更新成功"}
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"更新商品回复失败: {str(e)}")
+
+@app.delete("/item-reply/{cookie_id}/{item_id}")
+def delete_item_reply(cookie_id: str, item_id: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """
+ 删除指定账号cookie_id和商品item_id的商品回复
+ """
+ try:
+ user_id = current_user['user_id']
+ user_cookies = db_manager.get_all_cookies(user_id)
+ if cookie_id not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限访问该Cookie")
+
+ success = db_manager.delete_item_reply(cookie_id, item_id)
+ if not success:
+ raise HTTPException(status_code=404, detail="商品回复不存在")
+
+ return {"message": "商品回复删除成功"}
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"删除商品回复失败: {str(e)}")
+
+class ItemToDelete(BaseModel):
+ cookie_id: str
+ item_id: str
+
+class BatchDeleteRequest(BaseModel):
+ items: List[ItemToDelete]
+
+@app.delete("/item-reply/batch")
+async def batch_delete_item_reply(
+ req: BatchDeleteRequest,
+ current_user: Dict[str, Any] = Depends(get_current_user)
+):
+ """
+ 批量删除商品回复
+ """
+ user_id = current_user['user_id']
+ from db_manager import db_manager
+
+ # 先校验当前用户是否有权限删除每个cookie对应的回复
+ user_cookies = db_manager.get_all_cookies(user_id)
+ for item in req.items:
+ if item.cookie_id not in user_cookies:
+ raise HTTPException(status_code=403, detail=f"无权限访问Cookie {item.cookie_id}")
+
+ result = db_manager.batch_delete_item_replies([item.dict() for item in req.items])
+ return {
+ "success_count": result["success_count"],
+ "failed_count": result["failed_count"]
+ }
+
+@app.get("/item-reply/{cookie_id}/{item_id}")
+def get_item_reply(cookie_id: str, item_id: str, current_user: Dict[str, Any] = Depends(get_current_user)):
+ """
+ 获取指定账号cookie_id和商品item_id的商品回复内容
+ """
+ try:
+ user_id = current_user['user_id']
+ # 校验cookie_id是否属于当前用户
+ user_cookies = db_manager.get_all_cookies(user_id)
+ if cookie_id not in user_cookies:
+ raise HTTPException(status_code=403, detail="无权限访问该Cookie")
+
+ # 获取指定商品回复
+ item_replies = db_manager.get_itemReplays_by_cookie(cookie_id)
+ # 找对应item_id的回复
+ item_reply = next((r for r in item_replies if r['item_id'] == item_id), None)
+
+ if item_reply is None:
+ raise HTTPException(status_code=404, detail="商品回复不存在")
+
+ return item_reply
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"获取商品回复失败: {str(e)}")
+
+
+# ------------------------- 数据库备份和恢复接口 -------------------------
+
+@app.get('/admin/backup/download')
+def download_database_backup(admin_user: Dict[str, Any] = Depends(require_permission('data_management'))):
+ """下载数据库备份文件"""
+ import os
+ from fastapi.responses import FileResponse
+ from datetime import datetime
+
+ try:
+ log_with_user('info', "请求下载数据库备份", admin_user)
+
+ # 使用db_manager的实际数据库路径
+ from db_manager import db_manager
+ db_file_path = db_manager.db_path
+
+ # 检查数据库文件是否存在
+ if not os.path.exists(db_file_path):
+ log_with_user('error', f"数据库文件不存在: {db_file_path}", admin_user)
+ raise HTTPException(status_code=404, detail="数据库文件不存在")
+
+ # 生成带时间戳的文件名
+ timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+ download_filename = f"xianyu_backup_{timestamp}.db"
+
+ log_with_user('info', f"开始下载数据库备份: {download_filename}", admin_user)
+
+ return FileResponse(
+ path=db_file_path,
+ filename=download_filename,
+ media_type='application/octet-stream'
+ )
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ log_with_user('error', f"下载数据库备份失败: {str(e)}", admin_user)
+ raise HTTPException(status_code=500, detail=str(e))
+
+@app.post('/admin/backup/upload')
+async def upload_database_backup(admin_user: Dict[str, Any] = Depends(require_permission('import_backup')),
+ backup_file: UploadFile = File(...)):
+ """上传并恢复数据库备份文件(管理员专用)"""
+ import os
+ import shutil
+ import sqlite3
+ from datetime import datetime
+
+ try:
+ log_with_user('info', f"开始上传数据库备份: {backup_file.filename}", admin_user)
+
+ # 验证文件类型
+ if not backup_file.filename.endswith('.db'):
+ log_with_user('warning', f"无效的备份文件类型: {backup_file.filename}", admin_user)
+ raise HTTPException(status_code=400, detail="只支持.db格式的数据库文件")
+
+ # 验证文件大小(限制100MB)
+ content = await backup_file.read()
+ if len(content) > 100 * 1024 * 1024: # 100MB
+ log_with_user('warning', f"备份文件过大: {len(content)} bytes", admin_user)
+ raise HTTPException(status_code=400, detail="备份文件大小不能超过100MB")
+
+ # 验证是否为有效的SQLite数据库文件
+ temp_file_path = f"temp_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.db"
+
+ try:
+ # 保存临时文件
+ with open(temp_file_path, 'wb') as temp_file:
+ temp_file.write(content)
+
+ # 验证数据库文件完整性
+ conn = sqlite3.connect(temp_file_path)
+ cursor = conn.cursor()
+ cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+ tables = cursor.fetchall()
+ conn.close()
+
+ # 检查是否包含必要的表
+ table_names = [table[0] for table in tables]
+ required_tables = ['users', 'cookies'] # 最基本的表
+
+ missing_tables = [table for table in required_tables if table not in table_names]
+ if missing_tables:
+ log_with_user('warning', f"备份文件缺少必要的表: {missing_tables}", admin_user)
+ raise HTTPException(status_code=400, detail=f"备份文件不完整,缺少表: {', '.join(missing_tables)}")
+
+ log_with_user('info', f"备份文件验证通过,包含 {len(table_names)} 个表", admin_user)
+
+ except sqlite3.Error as e:
+ log_with_user('error', f"备份文件验证失败: {str(e)}", admin_user)
+ if os.path.exists(temp_file_path):
+ os.remove(temp_file_path)
+ raise HTTPException(status_code=400, detail="无效的数据库文件")
+
+ # 备份当前数据库
+ from db_manager import db_manager
+ current_db_path = db_manager.db_path
+
+ # 生成备份文件路径(与原数据库在同一目录)
+ db_dir = os.path.dirname(current_db_path)
+ backup_filename = f"xianyu_data_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.db"
+ backup_current_path = os.path.join(db_dir, backup_filename)
+
+ if os.path.exists(current_db_path):
+ shutil.copy2(current_db_path, backup_current_path)
+ log_with_user('info', f"当前数据库已备份为: {backup_current_path}", admin_user)
+
+ # 关闭当前数据库连接
+ if hasattr(db_manager, 'conn') and db_manager.conn:
+ db_manager.conn.close()
+ log_with_user('info', "已关闭当前数据库连接", admin_user)
+
+ # 替换数据库文件
+ shutil.move(temp_file_path, current_db_path)
+ log_with_user('info', f"数据库文件已替换: {current_db_path}", admin_user)
+
+ # 重新初始化数据库连接(使用原有的db_path)
+ db_manager.__init__(db_manager.db_path)
+ log_with_user('info', "数据库连接已重新初始化", admin_user)
+
+ # 验证新数据库
+ try:
+ test_users = db_manager.get_all_users()
+ log_with_user('info', f"数据库恢复成功,包含 {len(test_users)} 个用户", admin_user)
+ except Exception as e:
+ log_with_user('error', f"数据库恢复后验证失败: {str(e)}", admin_user)
+ # 如果验证失败,尝试恢复原数据库
+ if os.path.exists(backup_current_path):
+ shutil.copy2(backup_current_path, current_db_path)
+ db_manager.__init__()
+ log_with_user('info', "已恢复原数据库", admin_user)
+ raise HTTPException(status_code=500, detail="数据库恢复失败,已回滚到原数据库")
+
+ return {
+ "success": True,
+ "message": "数据库恢复成功",
+ "backup_file": backup_current_path,
+ "user_count": len(test_users)
+ }
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ log_with_user('error', f"上传数据库备份失败: {str(e)}", admin_user)
+ # 清理临时文件
+ if 'temp_file_path' in locals() and os.path.exists(temp_file_path):
+ os.remove(temp_file_path)
+ raise HTTPException(status_code=500, detail=str(e))
+
+@app.get('/admin/backup/list')
+def list_backup_files(admin_user: Dict[str, Any] = Depends(require_permission('data_management'))):
+ """列出服务器上的备份文件(管理员专用)"""
+ import os
+ import glob
+ from datetime import datetime
+
+ try:
+ log_with_user('info', "查询备份文件列表", admin_user)
+
+ # 查找备份文件
+ backup_files = glob.glob("xianyu_data_backup_*.db")
+
+ backup_list = []
+ for file_path in backup_files:
+ try:
+ stat = os.stat(file_path)
+ backup_list.append({
+ 'filename': os.path.basename(file_path),
+ 'size': stat.st_size,
+ 'size_mb': round(stat.st_size / (1024 * 1024), 2),
+ 'created_time': datetime.fromtimestamp(stat.st_ctime).strftime('%Y-%m-%d %H:%M:%S'),
+ 'modified_time': datetime.fromtimestamp(stat.st_mtime).strftime('%Y-%m-%d %H:%M:%S')
+ })
+ except Exception as e:
+ log_with_user('warning', f"读取备份文件信息失败: {file_path} - {str(e)}", admin_user)
+
+ # 按修改时间倒序排列
+ backup_list.sort(key=lambda x: x['modified_time'], reverse=True)
+
+ log_with_user('info', f"找到 {len(backup_list)} 个备份文件", admin_user)
+
+ return {
+ "backups": backup_list,
+ "total": len(backup_list)
+ }
+
+ except Exception as e:
+ log_with_user('error', f"查询备份文件列表失败: {str(e)}", admin_user)
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+# ------------------------- 数据管理接口 -------------------------
+
+@app.get('/admin/orders')
+def get_orders_with_item_title(admin_user: Dict[str, Any] = Depends(require_permission('data_management'))):
+ """获取订单列表(含商品标题)"""
+ from db_manager import db_manager
+ try:
+ log_with_user('info', "查询订单列表(含商品标题)", admin_user)
+
+ with db_manager.lock:
+ cursor = db_manager.conn.cursor()
+ cursor.execute('''
+ SELECT o.order_id, o.item_id, o.buyer_id, o.spec_name, o.spec_value,
+ o.quantity, o.amount, o.order_status, o.cookie_id,
+ o.created_at, o.updated_at, i.item_title,
+ o.delivery_status, o.buyer_name
+ FROM orders o
+ LEFT JOIN item_info i ON o.cookie_id = i.cookie_id AND o.item_id = i.item_id
+ ORDER BY o.created_at DESC
+ ''')
+
+ data = []
+ for row in cursor.fetchall():
+ data.append({
+ 'order_id': row[0],
+ 'item_id': row[1],
+ 'buyer_id': row[2],
+ 'spec_name': row[3],
+ 'spec_value': row[4],
+ 'quantity': row[5],
+ 'amount': row[6],
+ 'order_status': row[7],
+ 'cookie_id': row[8],
+ 'created_at': row[9],
+ 'updated_at': row[10],
+ 'item_title': row[11],
+ 'delivery_status': row[12] if row[12] else 'pending',
+ 'buyer_name': row[13] if row[13] else ''
+ })
+
+ log_with_user('info', f"订单列表查询成功,共 {len(data)} 条记录", admin_user)
+
+ return {
+ "success": True,
+ "data": data,
+ "count": len(data)
+ }
+
+ except Exception as e:
+ log_with_user('error', f"查询订单列表失败: {str(e)}", admin_user)
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get('/admin/data/{table_name}')
+def get_table_data(table_name: str, admin_user: Dict[str, Any] = Depends(require_permission('data_management'))):
+ """获取指定表的所有数据"""
+ from db_manager import db_manager
+ try:
+ log_with_user('info', f"查询表数据: {table_name}", admin_user)
+
+ # 验证表名安全性
+ allowed_tables = [
+ 'users', 'cookies', 'cookie_status', 'keywords', 'default_replies', 'default_reply_records',
+ 'ai_reply_settings', 'ai_conversations', 'ai_item_cache', 'item_info',
+ 'message_notifications', 'cards', 'delivery_rules', 'notification_channels',
+ 'user_settings', 'system_settings', 'email_verifications', 'captcha_codes', 'orders', "item_replay"
+ ]
+
+ if table_name not in allowed_tables:
+ log_with_user('warning', f"尝试访问不允许的表: {table_name}", admin_user)
+ raise HTTPException(status_code=400, detail="不允许访问该表")
+
+ # 获取表数据
+ data, columns = db_manager.get_table_data(table_name)
+
+ log_with_user('info', f"表 {table_name} 查询成功,共 {len(data)} 条记录", admin_user)
+
+ return {
+ "success": True,
+ "data": data,
+ "columns": columns,
+ "count": len(data)
+ }
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ log_with_user('error', f"查询表数据失败: {table_name} - {str(e)}", admin_user)
+ raise HTTPException(status_code=500, detail=str(e))
+
+@app.delete('/admin/data/{table_name}/{record_id}')
+def delete_table_record(table_name: str, record_id: str, admin_user: Dict[str, Any] = Depends(require_permission('data_management'))):
+ """删除指定表的指定记录"""
+ from db_manager import db_manager
+ try:
+ log_with_user('info', f"删除表记录: {table_name}.{record_id}", admin_user)
+
+ # 验证表名安全性
+ allowed_tables = [
+ 'users', 'cookies', 'cookie_status', 'keywords', 'default_replies', 'default_reply_records',
+ 'ai_reply_settings', 'ai_conversations', 'ai_item_cache', 'item_info',
+ 'message_notifications', 'cards', 'delivery_rules', 'notification_channels',
+ 'user_settings', 'system_settings', 'email_verifications', 'captcha_codes', 'orders','item_replay'
+ ]
+
+ if table_name not in allowed_tables:
+ log_with_user('warning', f"尝试删除不允许的表记录: {table_name}", admin_user)
+ raise HTTPException(status_code=400, detail="不允许操作该表")
+
+ # 特殊保护:不能删除管理员用户
+ if table_name == 'users' and record_id == str(admin_user['user_id']):
+ log_with_user('warning', "尝试删除管理员自己", admin_user)
+ raise HTTPException(status_code=400, detail="不能删除管理员自己")
+
+ # 删除记录
+ success = db_manager.delete_table_record(table_name, record_id)
+
+ if success:
+ log_with_user('info', f"表记录删除成功: {table_name}.{record_id}", admin_user)
+ return {"success": True, "message": "删除成功"}
+ else:
+ log_with_user('warning', f"表记录删除失败: {table_name}.{record_id}", admin_user)
+ raise HTTPException(status_code=400, detail="删除失败,记录可能不存在")
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ log_with_user('error', f"删除表记录异常: {table_name}.{record_id} - {str(e)}", admin_user)
+ raise HTTPException(status_code=500, detail=str(e))
+
+@app.delete('/admin/data/{table_name}')
+def clear_table_data(table_name: str, admin_user: Dict[str, Any] = Depends(require_permission('data_management'))):
+ """清空指定表的所有数据"""
+ from db_manager import db_manager
+ try:
+ log_with_user('info', f"清空表数据: {table_name}", admin_user)
+
+ # 验证表名安全性
+ allowed_tables = [
+ 'cookies', 'cookie_status', 'keywords', 'default_replies', 'default_reply_records',
+ 'ai_reply_settings', 'ai_conversations', 'ai_item_cache', 'item_info',
+ 'message_notifications', 'cards', 'delivery_rules', 'notification_channels',
+ 'user_settings', 'system_settings', 'email_verifications', 'captcha_codes', 'orders', "item_replay"
+ ]
+
+ # 不允许清空用户表
+ if table_name == 'users':
+ log_with_user('warning', "尝试清空用户表", admin_user)
+ raise HTTPException(status_code=400, detail="不允许清空用户表")
+
+ if table_name not in allowed_tables:
+ log_with_user('warning', f"尝试清空不允许的表: {table_name}", admin_user)
+ raise HTTPException(status_code=400, detail="不允许清空该表")
+
+ # 清空表数据
+ success = db_manager.clear_table_data(table_name)
+
+ if success:
+ log_with_user('info', f"表数据清空成功: {table_name}", admin_user)
+ return {"success": True, "message": "清空成功"}
+ else:
+ log_with_user('warning', f"表数据清空失败: {table_name}", admin_user)
+ raise HTTPException(status_code=400, detail="清空失败")
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ log_with_user('error', f"清空表数据异常: {table_name} - {str(e)}", admin_user)
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+# 订单重新发货API
+@app.post("/orders/{order_id}/retry-delivery")
+async def retry_order_delivery(order_id: str, admin_user: Dict[str, Any] = Depends(require_permission('data_management'))):
+ """重新发货 - 对失败的订单重新执行自动发货"""
+ try:
+ from db_manager import db_manager
+
+ log_with_user('info', f"尝试重新发货: 订单 {order_id}", admin_user)
+
+ # 获取订单信息
+ order = db_manager.get_order_by_id(order_id)
+ if not order:
+ raise HTTPException(status_code=404, detail="订单不存在")
+
+ cookie_id = order.get('cookie_id')
+ item_id = order.get('item_id')
+ buyer_id = order.get('buyer_id')
+
+ if not cookie_id or not item_id:
+ raise HTTPException(status_code=400, detail="订单缺少必要的商品或账号信息")
+
+ # 查找对应的 XianyuLive 实例
+ if cookie_manager.manager is None:
+ raise HTTPException(status_code=400, detail="Cookie管理器未初始化")
+
+ # 找到商品真正的卖家账号
+ seller_cookie_id = cookie_id
+ try:
+ cursor = db_manager.conn.cursor()
+ cursor.execute('SELECT cookie_id FROM item_info WHERE item_id = ?', (item_id,))
+ row = cursor.fetchone()
+ if row and row[0]:
+ seller_cookie_id = row[0]
+ log_with_user('info', f"重新发货: 找到商品卖家账号 {seller_cookie_id}", admin_user)
+ except Exception:
+ pass
+
+ xianyu_instance = cookie_manager.manager.get_xianyu(seller_cookie_id)
+ if not xianyu_instance:
+ # 尝试原始cookie_id
+ xianyu_instance = cookie_manager.manager.get_xianyu(cookie_id)
+ if not xianyu_instance:
+ raise HTTPException(status_code=400, detail=f"账号 {seller_cookie_id} 未在线,无法重新发货")
+
+ # 重置订单状态为处理中
+ db_manager.update_order_delivery_status(order_id, 'pending')
+
+ # 先尝试获取商品标题(用于匹配发货规则)
+ item_title = None
+ try:
+ # 1. 从所有账号的商品信息中查找
+ cursor = db_manager.conn.cursor()
+ cursor.execute('SELECT item_title FROM item_info WHERE item_id = ?', (item_id,))
+ row = cursor.fetchone()
+ if row and row[0]:
+ item_title = row[0]
+ except Exception:
+ pass
+
+ if not item_title:
+ try:
+ # 2. 通过API获取(用当前账号)
+ api_result = await xianyu_instance.get_item_info(item_id)
+ if api_result and 'data' in api_result:
+ data = api_result['data']
+ item_data = data.get('itemDO', {})
+ share_data = item_data.get('shareData', {})
+ share_info_str = share_data.get('shareInfoJsonString', '')
+ if share_info_str:
+ import json
+ share_info = json.loads(share_info_str)
+ item_title = share_info.get('contentParams', {}).get('mainParams', {}).get('content', '')
+ if not item_title:
+ item_title = item_data.get('title', '')
+ except Exception:
+ pass
+
+ # 3. 尝试从发货规则反向查找(用订单的item_id匹配)
+ if not item_title:
+ try:
+ cursor = db_manager.conn.cursor()
+ cursor.execute('SELECT keyword FROM delivery_rules WHERE enabled = 1')
+ rules = cursor.fetchall()
+ # 返回所有规则关键字供前端选择
+ rule_keywords = [r[0] for r in rules]
+ log_with_user('warning', f"无法获取商品标题,但找到发货规则: {rule_keywords}", admin_user)
+ except Exception:
+ pass
+
+ if not item_title:
+ item_title = "未知商品"
+
+ log_with_user('info', f"重新发货: 订单 {order_id}, 商品ID={item_id}, 商品标题={item_title[:50]}", admin_user)
+
+ # 调用自动发货方法
+ delivery_content = await xianyu_instance._auto_delivery(item_id, item_title, order_id, buyer_id)
+
+ if delivery_content:
+ # 发货成功,更新状态
+ db_manager.update_order_delivery_status(order_id, 'delivered')
+
+ # 发送发货消息(用卖家的聊天ID格式)
+ chat_id = f"{item_id}_{buyer_id}"
+ ws = xianyu_instance.ws
+ if not ws:
+ log_with_user('warning', f"重新发货: WebSocket未连接,无法发送消息 {order_id}", admin_user)
+ return {"success": True, "message": "发货内容获取成功,但WebSocket未连接,消息未发送"}
+
+ # 获取商品的session_id用于构造正确的chat_id
+ try:
+ cursor = db_manager.conn.cursor()
+ cursor.execute("SELECT value FROM cookies WHERE id = ?", (seller_cookie_id,))
+ cookie_row = cursor.fetchone()
+ if cookie_row:
+ from cookie_manager import manager as cm
+ if cm and seller_cookie_id in cm.keywords:
+ pass
+ except Exception:
+ pass
+
+ if delivery_content.startswith("__IMAGE_SEND__"):
+ image_data = delivery_content.replace("__IMAGE_SEND__", "")
+ if "|" in image_data:
+ card_id_str, image_url = image_data.split("|", 1)
+ try:
+ card_id = int(card_id_str)
+ except ValueError:
+ card_id = None
+ await xianyu_instance.send_image_msg(ws, chat_id, buyer_id, image_url, card_id=card_id)
+ else:
+ await xianyu_instance.send_image_msg(ws, chat_id, buyer_id, image_data)
+ else:
+ await xianyu_instance.send_msg(ws, chat_id, buyer_id, delivery_content)
+
+ log_with_user('info', f"重新发货成功: 订单 {order_id}", admin_user)
+ return {"success": True, "message": "重新发货成功"}
+ else:
+ # 发货失败
+ db_manager.update_order_delivery_status(order_id, 'failed')
+ log_with_user('warning', f"重新发货失败: 订单 {order_id}", admin_user)
+ raise HTTPException(status_code=400, detail="重新发货失败,未找到匹配的发货规则或获取发货内容失败")
+
+ except HTTPException:
+ raise
+ except Exception as e:
+ log_with_user('error', f"重新发货异常: {order_id} - {str(e)}", admin_user)
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+# 商品多规格管理API
+@app.put("/items/{cookie_id}/{item_id}/multi-spec")
+def update_item_multi_spec(cookie_id: str, item_id: str, spec_data: dict, _: None = Depends(require_auth)):
+ """更新商品的多规格状态"""
+ try:
+ from db_manager import db_manager
+
+ is_multi_spec = spec_data.get('is_multi_spec', False)
+
+ success = db_manager.update_item_multi_spec_status(cookie_id, item_id, is_multi_spec)
+
+ if success:
+ return {"message": f"商品多规格状态已{'开启' if is_multi_spec else '关闭'}"}
+ else:
+ raise HTTPException(status_code=404, detail="商品不存在")
+
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+# 商品多数量发货管理API
+@app.put("/items/{cookie_id}/{item_id}/multi-quantity-delivery")
+def update_item_multi_quantity_delivery(cookie_id: str, item_id: str, delivery_data: dict, _: None = Depends(require_auth)):
+ """更新商品的多数量发货状态"""
+ try:
+ from db_manager import db_manager
+
+ multi_quantity_delivery = delivery_data.get('multi_quantity_delivery', False)
+
+ success = db_manager.update_item_multi_quantity_delivery_status(cookie_id, item_id, multi_quantity_delivery)
+
+ if success:
+ return {"message": f"商品多数量发货状态已{'开启' if multi_quantity_delivery else '关闭'}"}
+ else:
+ raise HTTPException(status_code=404, detail="商品不存在")
+
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+# 移除自动启动,由Start.py或手动启动
+# if __name__ == "__main__":
+# uvicorn.run(app, host="0.0.0.0", port=8080)
+
+
+# ========================= 阿奇索账户管理API =========================
+
+class AgisoAccountRequest(BaseModel):
+ name: str
+ cookie: str
+ authorization: str
+
+class AgisoAccountUpdateRequest(BaseModel):
+ name: Optional[str] = None
+ cookie: Optional[str] = None
+ authorization: Optional[str] = None
+
+class ResellRequest(BaseModel):
+ agiso_account_id: int
+ source_item: Dict[str, Any]
+ resell_price: str
+ stock: int = 1
+ description: str = ""
+
+
+@app.get("/agiso/accounts")
+async def get_agiso_accounts(
+ current_user: Optional[Dict[str, Any]] = Depends(get_current_user_optional)
+):
+ """获取当前用户的所有阿奇索账户"""
+ if not current_user:
+ raise HTTPException(status_code=401, detail="未登录")
+
+ try:
+ from db_manager import db_manager
+ accounts = db_manager.get_agiso_accounts(current_user["user_id"])
+ # 隐藏敏感信息
+ for account in accounts:
+ if account.get("cookie"):
+ account["cookie"] = account["cookie"][:20] + "..." if len(account["cookie"]) > 20 else "***"
+ if account.get("authorization"):
+ account["authorization"] = account["authorization"][:20] + "..." if len(account["authorization"]) > 20 else "***"
+ return {"success": True, "data": accounts}
+ except Exception as e:
+ logger.error(f"获取阿奇索账户列表失败: {e}")
+ raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/agiso/accounts")
+async def add_agiso_account(
+ request: AgisoAccountRequest,
+ current_user: Optional[Dict[str, Any]] = Depends(get_current_user_optional)
+):
+ """添加阿奇索账户"""
+ if not current_user:
+ raise HTTPException(status_code=401, detail="未登录")
+
+ try:
+ from db_manager import db_manager
+
+ # 尝试验证账户有效性(可选,即使失败也允许添加)
+ verify_message = ""
+ try:
+ from utils.agiso_client import AgisoClient
+ async with AgisoClient(request.cookie, request.authorization) as client:
+ verify_result = await client.verify_account()
+ if not verify_result.get("success"):
+ verify_message = f"(注意:{verify_result.get('message')},但账户已添加,后续使用时可能需要重新配置)"
+ except Exception as e:
+ logger.warning(f"验证阿奇索账户时出错: {e}")
+ verify_message = "(账户已添加,验证功能暂时不可用)"
+
+ # 添加账户
+ account_id = db_manager.add_agiso_account(
+ user_id=current_user["user_id"],
+ name=request.name,
+ cookie=request.cookie,
+ authorization=request.authorization
+ )
+
+ if account_id == -1:
+ return {"success": False, "message": "添加账户失败"}
+
+ message = f"添加成功{verify_message}" if verify_message else "添加成功"
+ return {"success": True, "message": message, "account_id": account_id}
+ except Exception as e:
+ logger.error(f"添加阿奇索账户失败: {e}")
+ return {"success": False, "message": str(e)}
+
+
+@app.put("/agiso/accounts/{account_id}")
+async def update_agiso_account(
+ account_id: int,
+ request: AgisoAccountUpdateRequest,
+ current_user: Optional[Dict[str, Any]] = Depends(get_current_user_optional)
+):
+ """更新阿奇索账户"""
+ if not current_user:
+ raise HTTPException(status_code=401, detail="未登录")
+
+ try:
+ from db_manager import db_manager
+
+ # 验证账户归属
+ account = db_manager.get_agiso_account_by_id(account_id)
+ if not account or account["user_id"] != current_user["user_id"]:
+ raise HTTPException(status_code=404, detail="账户不存在")
+
+ # 更新账户
+ success = db_manager.update_agiso_account(
+ account_id=account_id,
+ name=request.name,
+ cookie=request.cookie,
+ authorization=request.authorization
+ )
+
+ if success:
+ return {"success": True, "message": "更新成功"}
+ else:
+ return {"success": False, "message": "更新失败"}
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"更新阿奇索账户失败: {e}")
+ return {"success": False, "message": str(e)}
+
+
+@app.delete("/agiso/accounts/{account_id}")
+async def delete_agiso_account(
+ account_id: int,
+ current_user: Optional[Dict[str, Any]] = Depends(get_current_user_optional)
+):
+ """删除阿奇索账户"""
+ if not current_user:
+ raise HTTPException(status_code=401, detail="未登录")
+
+ try:
+ from db_manager import db_manager
+
+ # 验证账户归属
+ account = db_manager.get_agiso_account_by_id(account_id)
+ if not account or account["user_id"] != current_user["user_id"]:
+ raise HTTPException(status_code=404, detail="账户不存在")
+
+ # 删除账户
+ success = db_manager.delete_agiso_account(account_id)
+
+ if success:
+ return {"success": True, "message": "删除成功"}
+ else:
+ return {"success": False, "message": "删除失败"}
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"删除阿奇索账户失败: {e}")
+ return {"success": False, "message": str(e)}
+
+
+@app.post("/agiso/verify")
+async def verify_agiso_account(
+ account_id: int,
+ current_user: Optional[Dict[str, Any]] = Depends(get_current_user_optional)
+):
+ """验证阿奇索账户有效性"""
+ if not current_user:
+ raise HTTPException(status_code=401, detail="未登录")
+
+ try:
+ from db_manager import db_manager
+
+ # 获取账户信息
+ account = db_manager.get_agiso_account_by_id(account_id)
+ if not account or account["user_id"] != current_user["user_id"]:
+ raise HTTPException(status_code=404, detail="账户不存在")
+
+ # 验证账户
+ from utils.agiso_client import AgisoClient
+ async with AgisoClient(account["cookie"], account["authorization"]) as client:
+ result = await client.verify_account()
+ return result
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"验证阿奇索账户失败: {e}")
+ return {"success": False, "message": str(e)}
+
+
+# ========================= 转卖操作API =========================
+
+@app.post("/resell/publish")
+async def resell_publish(
+ request: ResellRequest,
+ current_user: Optional[Dict[str, Any]] = Depends(get_current_user_optional)
+):
+ """发布转卖商品"""
+ if not current_user:
+ raise HTTPException(status_code=401, detail="未登录")
+
+ try:
+ from db_manager import db_manager
+ from utils.item_publisher import item_publisher
+
+ # 验证阿奇索账户归属
+ account = db_manager.get_agiso_account_by_id(request.agiso_account_id)
+ if not account or account["user_id"] != current_user["user_id"]:
+ return {"success": False, "message": "阿奇索账户不存在"}
+
+ # 执行转卖
+ result = await item_publisher.resell_item(
+ source_item=request.source_item,
+ agiso_account=account,
+ resell_price=request.resell_price,
+ stock=request.stock,
+ description=request.description,
+ user_id=current_user["user_id"]
+ )
+
+ return result
+ except Exception as e:
+ logger.error(f"转卖发布失败: {e}")
+ return {"success": False, "message": str(e)}
+
+
+@app.get("/resell/records")
+async def get_resell_records(
+ limit: int = 50,
+ offset: int = 0,
+ current_user: Optional[Dict[str, Any]] = Depends(get_current_user_optional)
+):
+ """获取转卖记录"""
+ if not current_user:
+ raise HTTPException(status_code=401, detail="未登录")
+
+ try:
+ from db_manager import db_manager
+ records = db_manager.get_resell_records(
+ user_id=current_user["user_id"],
+ limit=limit,
+ offset=offset
+ )
+ return {"success": True, "data": records}
+ except Exception as e:
+ logger.error(f"获取转卖记录失败: {e}")
+ return {"success": False, "data": []}
+
+
+@app.get("/resell/records/{record_id}")
+async def get_resell_record_detail(
+ record_id: int,
+ current_user: Optional[Dict[str, Any]] = Depends(get_current_user_optional)
+):
+ """获取单条转卖记录详情"""
+ if not current_user:
+ raise HTTPException(status_code=401, detail="未登录")
+
+ try:
+ from db_manager import db_manager
+ record = db_manager.get_resell_record_by_id(record_id)
+
+ if not record or record.get("user_id") != current_user["user_id"]:
+ raise HTTPException(status_code=404, detail="记录不存在")
+
+ return {"success": True, "data": record}
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"获取转卖记录详情失败: {e}")
+ return {"success": False, "message": str(e)}
+
+
+@app.delete("/resell/records/{record_id}")
+async def delete_resell_record(
+ record_id: int,
+ current_user: Optional[Dict[str, Any]] = Depends(get_current_user_optional)
+):
+ """删除转卖记录"""
+ if not current_user:
+ raise HTTPException(status_code=401, detail="未登录")
+
+ try:
+ from db_manager import db_manager
+
+ # 验证记录归属
+ record = db_manager.get_resell_record_by_id(record_id)
+ if not record or record.get("user_id") != current_user["user_id"]:
+ raise HTTPException(status_code=404, detail="记录不存在")
+
+ # 删除记录
+ with db_manager.lock:
+ cursor = db_manager.conn.cursor()
+ db_manager._execute_sql(cursor, "DELETE FROM resell_records WHERE id = ?", (record_id,))
+ db_manager.conn.commit()
+
+ return {"success": True, "message": "删除成功"}
+ except HTTPException:
+ raise
+ except Exception as e:
+ logger.error(f"删除转卖记录失败: {e}")
+ return {"success": False, "message": str(e)}
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..be22860
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,81 @@
+# ================================
+# 闲鱼自动回复系统 - Python依赖包
+# ================================
+
+# ==================== 核心Web框架 ====================
+fastapi>=0.111.0
+uvicorn[standard]>=0.29.0
+pydantic>=2.7.0
+
+# ==================== 日志记录 ====================
+loguru>=0.7.0
+
+# ==================== 网络通信 ====================
+websockets>=10.0,<13.0
+aiohttp>=3.9.0
+requests>=2.31.0
+httpx>=0.25.0
+
+# ==================== 配置文件处理 ====================
+PyYAML>=6.0.0
+
+# ==================== JavaScript执行引擎 ====================
+PyExecJS>=1.5.1
+
+# ==================== 协议缓冲区解析 ====================
+blackboxprotobuf>=1.0.1
+
+# ==================== 系统监控 ====================
+psutil>=5.9.0
+
+# ==================== 文件上传支持 ====================
+python-multipart>=0.0.6
+
+# ==================== AI回复引擎 ====================
+openai>=1.65.5
+
+# ==================== 图像处理 ====================
+Pillow>=10.0.0
+qrcode[pil]>=7.4.2
+
+# ==================== 浏览器自动化 ====================
+playwright>=1.40.0
+
+# ==================== 加密和安全 ====================
+PyJWT>=2.8.0
+passlib[bcrypt]>=1.7.4
+cryptography>=41.0.0
+
+# ==================== 时间处理 ====================
+python-dateutil>=2.8.2
+
+# ==================== Excel文件处理 ====================
+pandas>=2.0.0
+openpyxl>=3.1.0
+
+# ==================== 邮件发送 ====================
+email-validator>=2.0.0
+
+# ==================== 数据处理和验证 ====================
+xlsxwriter>=3.1.0
+
+# ==================== 版本说明 ====================
+# 本文件包含闲鱼自动回复系统的所有必需依赖
+# 版本号已经过测试验证,确保兼容性和稳定性
+#
+# Python版本要求: 3.11+
+#
+# 安装命令:
+# pip install --upgrade pip
+# pip install -r requirements.txt
+# playwright install chromium
+# playwright install-deps chromium # Linux系统需要
+#
+# ==================== 内置模块说明 ====================
+# 以下模块是Python内置模块,无需安装:
+# sqlite3, json, base64, hashlib, hmac, time, datetime, os, sys, re, urllib
+# asyncio, threading, pathlib, uuid, random, secrets, traceback, logging
+# collections, itertools, functools, copy, pickle, gzip, zipfile, shutil
+# tempfile, io, csv, xml, html, http, socket, ssl, subprocess, signal
+# inspect, ast, enum, math, decimal, array, queue, contextlib, warnings
+# typing, dataclasses, weakref, gc, platform, stat, glob, fnmatch
\ No newline at end of file
diff --git a/secure_confirm_decrypted.py b/secure_confirm_decrypted.py
new file mode 100644
index 0000000..e970778
--- /dev/null
+++ b/secure_confirm_decrypted.py
@@ -0,0 +1,180 @@
+"""
+自动确认发货模块 - 解密版本
+这是secure_confirm_ultra.py的解密版本,用于自动确认发货功能
+"""
+
+import asyncio
+import json
+import time
+import aiohttp
+from loguru import logger
+from utils.xianyu_utils import generate_sign, trans_cookies
+
+
+class SecureConfirm:
+ """自动确认发货类"""
+
+ def __init__(self, session, cookies_str, cookie_id, main_instance=None):
+ """
+ 初始化确认发货实例
+
+ Args:
+ session: aiohttp会话对象
+ cookies_str: Cookie字符串
+ cookie_id: Cookie ID
+ main_instance: 主实例对象(XianyuLive)
+ """
+ self.session = session
+ self.cookies_str = cookies_str
+ self.cookie_id = cookie_id
+ self.main_instance = main_instance
+
+ # 解析cookies
+ self.cookies = trans_cookies(cookies_str) if cookies_str else {}
+
+ # Token相关属性
+ self.current_token = None
+ self.last_token_refresh_time = 0
+ self.token_refresh_interval = 3600 # 1小时
+
+ def _safe_str(self, obj):
+ """安全字符串转换"""
+ try:
+ return str(obj)
+ except:
+ return "无法转换的对象"
+
+ async def _get_real_item_id(self):
+ """从数据库中获取一个真实的商品ID"""
+ try:
+ from db_manager import db_manager
+
+ # 获取该账号的商品列表
+ items = db_manager.get_items_by_cookie(self.cookie_id)
+ if items:
+ # 返回第一个商品的ID
+ item_id = items[0].get('item_id')
+ if item_id:
+ logger.debug(f"【{self.cookie_id}】获取到真实商品ID: {item_id}")
+ return item_id
+
+ # 如果该账号没有商品,尝试获取任意一个商品ID
+ all_items = db_manager.get_all_items()
+ if all_items:
+ item_id = all_items[0].get('item_id')
+ if item_id:
+ logger.debug(f"【{self.cookie_id}】使用其他账号的商品ID: {item_id}")
+ return item_id
+
+ logger.warning(f"【{self.cookie_id}】数据库中没有找到任何商品ID")
+ return None
+
+ except Exception as e:
+ logger.error(f"【{self.cookie_id}】获取真实商品ID失败: {self._safe_str(e)}")
+ return None
+
+ async def _update_config_cookies(self):
+ """更新数据库中的Cookie配置"""
+ try:
+ from db_manager import db_manager
+ # 更新数据库中的cookies
+ db_manager.update_cookie_value(self.cookie_id, self.cookies_str)
+ logger.debug(f"【{self.cookie_id}】已更新数据库中的Cookie")
+ except Exception as e:
+ logger.error(f"【{self.cookie_id}】更新数据库Cookie失败: {self._safe_str(e)}")
+
+
+ async def auto_confirm(self, order_id, item_id=None, retry_count=0):
+ """自动确认发货 - 使用真实商品ID刷新token"""
+ if retry_count >= 4: # 最多重试3次
+ logger.error("自动确认发货失败,重试次数过多")
+ return {"error": "自动确认发货失败,重试次数过多"}
+
+ # 保存item_id供Token刷新使用
+ if item_id:
+ self._current_item_id = item_id
+ logger.debug(f"【{self.cookie_id}】设置当前商品ID: {item_id}")
+
+ # 确保session已创建
+ if not self.session:
+ raise Exception("Session未创建")
+
+ params = {
+ 'jsv': '2.7.2',
+ 'appKey': '34839810',
+ 't': str(int(time.time()) * 1000),
+ 'sign': '',
+ 'v': '1.0',
+ 'type': 'originaljson',
+ 'accountSite': 'xianyu',
+ 'dataType': 'json',
+ 'timeout': '20000',
+ 'api': 'mtop.taobao.idle.logistic.consign.dummy',
+ 'sessionOption': 'AutoLoginOnly',
+ }
+
+ data_val = '{"orderId":"' + order_id + '", "tradeText":"","picList":[],"newUnconsign":true}'
+ data = {
+ 'data': data_val,
+ }
+
+ # 始终从最新的cookies中获取_m_h5_tk token(刷新后cookies会被更新)
+ token = trans_cookies(self.cookies_str).get('_m_h5_tk', '').split('_')[0] if trans_cookies(self.cookies_str).get('_m_h5_tk') else ''
+
+ if token:
+ logger.info(f"使用cookies中的_m_h5_tk token: {token}")
+ else:
+ logger.warning("cookies中没有找到_m_h5_tk token")
+
+ sign = generate_sign(params['t'], token, data_val)
+ params['sign'] = sign
+
+ try:
+ logger.info(f"【{self.cookie_id}】开始自动确认发货,订单ID: {order_id}")
+ async with self.session.post(
+ 'https://h5api.m.goofish.com/h5/mtop.taobao.idle.logistic.consign.dummy/1.0/',
+ params=params,
+ data=data
+ ) as response:
+ res_json = await response.json()
+
+ # 检查并更新Cookie
+ if 'set-cookie' in response.headers:
+ new_cookies = {}
+ for cookie in response.headers.getall('set-cookie', []):
+ if '=' in cookie:
+ name, value = cookie.split(';')[0].split('=', 1)
+ new_cookies[name.strip()] = value.strip()
+
+ # 更新cookies
+ if new_cookies:
+ self.cookies.update(new_cookies)
+ # 生成新的cookie字符串
+ self.cookies_str = '; '.join([f"{k}={v}" for k, v in self.cookies.items()])
+ # 更新数据库中的Cookie
+ await self._update_config_cookies()
+ logger.debug("已更新Cookie到数据库")
+
+ logger.info(f"【{self.cookie_id}】自动确认发货响应: {res_json}")
+
+ # 检查响应结果
+ if res_json.get('ret') and res_json['ret'][0] == 'SUCCESS::调用成功':
+ logger.info(f"【{self.cookie_id}】✅ 自动确认发货成功,订单ID: {order_id}")
+ return {"success": True, "order_id": order_id}
+ else:
+ error_msg = res_json.get('ret', ['未知错误'])[0] if res_json.get('ret') else '未知错误'
+ logger.warning(f"【{self.cookie_id}】❌ 自动确认发货失败: {error_msg}")
+
+ return await self.auto_confirm(order_id, item_id, retry_count + 1)
+
+
+ except Exception as e:
+ logger.error(f"【{self.cookie_id}】自动确认发货API请求异常: {self._safe_str(e)}")
+ await asyncio.sleep(0.5)
+
+ # 网络异常也进行重试
+ if retry_count < 2:
+ logger.info(f"【{self.cookie_id}】网络异常,准备重试...")
+ return await self.auto_confirm(order_id, item_id, retry_count + 1)
+
+ return {"error": f"网络异常: {self._safe_str(e)}", "order_id": order_id}
diff --git a/secure_confirm_ultra.py b/secure_confirm_ultra.py
new file mode 100644
index 0000000..1d44307
--- /dev/null
+++ b/secure_confirm_ultra.py
@@ -0,0 +1,42 @@
+"""
+自动确认发货模块 - 超级混淆版本
+代码经过多层编码和混淆处理
+"""
+import base64 as LsWYPXmT
+import zlib as oxWwRTDp
+import types as AUdcGvRk
+import binascii as qKAaznVW
+
+
+class pDLWZWoi:
+
+ def __init__(self):
+ self.vrCYrtTq = "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"
+
+ def gdVvQitT(self):
+ step1_var = self.vrCYrtTq[::-1]
+ step2_var = bytes.fromhex(step1_var)
+ step3_var = LsWYPXmT.b64decode(step2_var)
+ step4_var = oxWwRTDp.decompress(step3_var)
+ step5_var = step4_var.decode('utf-8')
+
+ return step5_var
+
+ def CHsKCWCD(self):
+ """创建模块"""
+ decoded_code = self.gdVvQitT()
+ module_obj = AUdcGvRk.ModuleType('secure_confirm')
+ exec(decoded_code, module_obj.__dict__)
+ return module_obj
+
+
+OhPXQtOT = pDLWZWoi()
+
+amBCLCwC = OhPXQtOT.CHsKCWCD()
+
+SecureConfirm = amBCLCwC.SecureConfirm
+
+# 清理所有变量
+del OhPXQtOT
+del amBCLCwC
+del pDLWZWoi
diff --git a/secure_freeshipping_decrypted.py b/secure_freeshipping_decrypted.py
new file mode 100644
index 0000000..a9f786e
--- /dev/null
+++ b/secure_freeshipping_decrypted.py
@@ -0,0 +1,130 @@
+import asyncio
+import time
+from loguru import logger
+from utils.xianyu_utils import trans_cookies, generate_sign
+
+
+class SecureFreeshipping:
+ def __init__(self, session, cookies_str, cookie_id):
+ self.session = session
+ self.cookies_str = cookies_str
+ self.cookie_id = cookie_id
+ self.cookies = trans_cookies(cookies_str) if cookies_str else {}
+
+ # 这些属性将由主类传递
+ self.current_token = None
+ self.last_token_refresh_time = None
+ self.token_refresh_interval = None
+
+ def _safe_str(self, obj):
+ """安全转换为字符串"""
+ try:
+ return str(obj)
+ except:
+ return "无法转换的对象"
+
+ async def update_config_cookies(self):
+ """更新数据库中的cookies"""
+ try:
+ from db_manager import db_manager
+
+ # 更新数据库中的Cookie
+ db_manager.update_config_cookies(self.cookie_id, self.cookies_str)
+ logger.debug(f"【{self.cookie_id}】Cookie已更新到数据库")
+
+ except Exception as e:
+ logger.error(f"【{self.cookie_id}】更新Cookie到数据库失败: {self._safe_str(e)}")
+
+ async def auto_freeshipping(self, order_id, item_id, buyer_id, retry_count=0):
+ """自动免拼发货 - 加密版本"""
+ if retry_count >= 4: # 最多重试3次
+ logger.error("免拼发货发货失败,重试次数过多")
+ return {"error": "免拼发货发货失败,重试次数过多"}
+
+ # 确保session已创建
+ if not self.session:
+ raise Exception("Session未创建")
+
+ params = {
+ 'jsv': '2.7.2',
+ 'appKey': '34839810',
+ 't': str(int(time.time()) * 1000),
+ 'sign': '',
+ 'v': '1.0',
+ 'type': 'originaljson',
+ 'accountSite': 'xianyu',
+ 'dataType': 'json',
+ 'timeout': '20000',
+ 'api': 'mtop.idle.groupon.activity.seller.freeshipping',
+ 'sessionOption': 'AutoLoginOnly',
+ }
+
+ data_val = '{"bizOrderId":"' + order_id + '", "itemId":' + item_id + ',"buyerId":' + buyer_id + '}'
+ data = {
+ 'data': data_val,
+ }
+
+ # 打印参数信息
+ logger.info(f"【{self.cookie_id}】免拼发货请求参数: data_val = {data_val}")
+ logger.info(f"【{self.cookie_id}】参数详情 - order_id: {order_id}, item_id: {item_id}, buyer_id: {buyer_id}")
+
+ # 始终从最新的cookies中获取_m_h5_tk token(刷新后cookies会被更新)
+ token = trans_cookies(self.cookies_str).get('_m_h5_tk', '').split('_')[0] if trans_cookies(self.cookies_str).get('_m_h5_tk') else ''
+
+ if token:
+ logger.info(f"使用cookies中的_m_h5_tk token: {token}")
+ else:
+ logger.warning("cookies中没有找到_m_h5_tk token")
+
+ sign = generate_sign(params['t'], token, data_val)
+ params['sign'] = sign
+
+ try:
+ logger.info(f"【{self.cookie_id}】开始自动免拼发货,订单ID: {order_id}")
+ async with self.session.post(
+ 'https://h5api.m.goofish.com/h5/mtop.idle.groupon.activity.seller.freeshipping/1.0/',
+ params=params,
+ data=data
+ ) as response:
+ res_json = await response.json()
+
+ # 检查并更新Cookie
+ if 'set-cookie' in response.headers:
+ new_cookies = {}
+ for cookie in response.headers.getall('set-cookie', []):
+ if '=' in cookie:
+ name, value = cookie.split(';')[0].split('=', 1)
+ new_cookies[name.strip()] = value.strip()
+
+ # 更新cookies
+ if new_cookies:
+ self.cookies.update(new_cookies)
+ # 生成新的cookie字符串
+ self.cookies_str = '; '.join([f"{k}={v}" for k, v in self.cookies.items()])
+ # 更新数据库中的Cookie
+ await self.update_config_cookies()
+ logger.debug("已更新Cookie到数据库")
+
+ logger.info(f"【{self.cookie_id}】自动免拼发货响应: {res_json}")
+
+ # 检查响应结果
+ if res_json.get('ret') and res_json['ret'][0] == 'SUCCESS::调用成功':
+ logger.info(f"【{self.cookie_id}】✅ 自动免拼发货成功,订单ID: {order_id}")
+ return {"success": True, "order_id": order_id}
+ else:
+ error_msg = res_json.get('ret', ['未知错误'])[0] if res_json.get('ret') else '未知错误'
+ logger.warning(f"【{self.cookie_id}】❌ 自动免拼发货失败: {error_msg}")
+
+ return await self.auto_freeshipping(order_id, item_id, buyer_id, retry_count + 1)
+
+
+ except Exception as e:
+ logger.error(f"【{self.cookie_id}】自动免拼发货API请求异常: {self._safe_str(e)}")
+ await asyncio.sleep(0.5)
+
+ # 网络异常也进行重试
+ if retry_count < 2:
+ logger.info(f"【{self.cookie_id}】网络异常,准备重试...")
+ return await self.auto_freeshipping(order_id, item_id, buyer_id, retry_count + 1)
+
+ return {"error": f"网络异常: {self._safe_str(e)}", "order_id": order_id}
diff --git a/secure_freeshipping_ultra.py b/secure_freeshipping_ultra.py
new file mode 100644
index 0000000..cf69725
--- /dev/null
+++ b/secure_freeshipping_ultra.py
@@ -0,0 +1,43 @@
+"""
+自动免拼发货模块 - 超级混淆版本
+代码经过多层编码和混淆处理
+"""
+import base64 as LsWYPXmT
+import zlib as oxWwRTDp
+import types as AUdcGvRk
+import binascii as qKAaznVW
+
+
+class pDLWZWoi:
+
+ def __init__(self):
+ self.vrCYrtTq = "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"
+
+ def gdVvQitT(self):
+ # 解密过程
+ step1_var = self.vrCYrtTq[::-1]
+ step2_var = bytes.fromhex(step1_var)
+ step3_var = LsWYPXmT.b64decode(step2_var)
+ step4_var = oxWwRTDp.decompress(step3_var)
+ step5_var = step4_var.decode('utf-8')
+
+ return step5_var
+
+ def CHsKCWCD(self):
+ """创建模块"""
+ decoded_code = self.gdVvQitT()
+ module_obj = AUdcGvRk.ModuleType('secure_freeshipping')
+ exec(decoded_code, module_obj.__dict__)
+ return module_obj
+
+
+OhPXQtOT = pDLWZWoi()
+
+amBCLCwC = OhPXQtOT.CHsKCWCD()
+
+SecureFreeshipping = amBCLCwC.SecureFreeshipping
+
+# 清理所有变量
+del OhPXQtOT
+del amBCLCwC
+del pDLWZWoi
diff --git a/static/css/accounts.css b/static/css/accounts.css
new file mode 100644
index 0000000..b934c48
--- /dev/null
+++ b/static/css/accounts.css
@@ -0,0 +1,227 @@
+/* ================================
+ 【账号管理菜单】相关样式
+ ================================ */
+.status-toggle {
+ position: relative;
+ display: inline-block;
+ width: 50px;
+ height: 24px;
+}
+
+.status-toggle input {
+ opacity: 0;
+ width: 0;
+ height: 0;
+}
+
+.status-slider {
+ position: absolute;
+ cursor: pointer;
+ top: 0;
+ left: 0;
+ right: 0;
+ bottom: 0;
+ background-color: #ccc;
+ transition: .4s;
+ border-radius: 24px;
+}
+
+.status-slider:before {
+ position: absolute;
+ content: "";
+ height: 18px;
+ width: 18px;
+ left: 3px;
+ bottom: 3px;
+ background-color: white;
+ transition: .4s;
+ border-radius: 50%;
+}
+
+input:checked + .status-slider {
+ background-color: #10b981;
+}
+
+input:checked + .status-slider:before {
+ transform: translateX(26px);
+}
+
+.status-badge {
+ display: inline-flex;
+ align-items: center;
+ justify-content: center;
+ gap: 0.5rem;
+ padding: 0.25rem 0.5rem;
+ border-radius: 12px;
+ font-size: 0.875rem;
+ font-weight: 500;
+ min-width: 2rem;
+ height: 1.5rem;
+}
+
+.status-badge.enabled {
+ background: #dcfce7;
+ color: #166534;
+ border: 1px solid #bbf7d0;
+}
+
+.status-badge.disabled {
+ background: #fef2f2;
+ color: #991b1b;
+ border: 1px solid #fecaca;
+}
+
+.account-row.disabled {
+ opacity: 0.6;
+ background-color: #f9fafb;
+}
+
+.account-row.disabled .cookie-value {
+ background-color: #f3f4f6;
+}
+
+/* 关键词管理界面的状态提示 */
+.account-badge .badge.bg-warning {
+ animation: pulse 2s infinite;
+}
+
+@keyframes pulse {
+ 0% { opacity: 1; }
+ 50% { opacity: 0.7; }
+ 100% { opacity: 1; }
+}
+
+.disabled-account-notice {
+ background: #fef3c7;
+ border: 1px solid #f59e0b;
+ border-radius: 8px;
+ padding: 0.75rem;
+ margin-bottom: 1rem;
+ color: #92400e;
+}
+
+.disabled-account-notice .bi {
+ color: #f59e0b;
+}
+
+/* 扫码登录按钮特殊样式 */
+.qr-login-btn {
+ background: linear-gradient(135deg, #28a745 0%, #20c997 100%);
+ border: none;
+ box-shadow: 0 4px 15px rgba(40, 167, 69, 0.3);
+ transition: all 0.3s ease;
+ position: relative;
+ overflow: hidden;
+}
+
+.qr-login-btn:hover {
+ transform: translateY(-2px);
+ box-shadow: 0 6px 20px rgba(40, 167, 69, 0.4);
+ background: linear-gradient(135deg, #218838 0%, #1ea085 100%);
+}
+
+.qr-login-btn:active {
+ transform: translateY(0);
+}
+
+.qr-login-btn::before {
+ content: '';
+ position: absolute;
+ top: 0;
+ left: -100%;
+ width: 100%;
+ height: 100%;
+ background: linear-gradient(90deg, transparent, rgba(255,255,255,0.2), transparent);
+ transition: left 0.5s;
+}
+
+.qr-login-btn:hover::before {
+ left: 100%;
+}
+
+/* 二维码容器样式 */
+.qr-code-wrapper {
+ border: 3px solid #28a745;
+ box-shadow: 0 4px 15px rgba(40, 167, 69, 0.2);
+ transition: all 0.3s ease;
+}
+
+.qr-code-wrapper:hover {
+ box-shadow: 0 6px 20px rgba(40, 167, 69, 0.3);
+}
+
+/* 步骤指引样式 */
+.step-item {
+ text-align: center;
+}
+
+.step-number {
+ font-weight: bold;
+ font-size: 14px;
+ box-shadow: 0 2px 8px rgba(40, 167, 69, 0.3);
+}
+
+/* 手动输入按钮样式 */
+.manual-input-btn {
+ transition: all 0.3s ease;
+}
+
+.manual-input-btn:hover {
+ transform: translateY(-1px);
+ box-shadow: 0 4px 12px rgba(108, 117, 125, 0.2);
+}
+
+/* 等待提示样式 */
+.bg-light-warning {
+ background-color: #fff3cd !important;
+}
+
+.qr-loading-tip {
+ animation: pulse-warning 2s infinite;
+}
+
+@keyframes pulse-warning {
+ 0% {
+ opacity: 0.8;
+ }
+ 50% {
+ opacity: 1;
+ }
+ 100% {
+ opacity: 0.8;
+ }
+}
+
+/* 响应式设计 */
+@media (max-width: 768px) {
+ .status-toggle {
+ width: 40px;
+ height: 20px;
+ }
+
+ .status-slider:before {
+ height: 14px;
+ width: 14px;
+ left: 3px;
+ bottom: 3px;
+ }
+
+ input:checked + .status-slider:before {
+ transform: translateX(20px);
+ }
+
+ .qr-login-btn, .manual-input-btn {
+ margin-bottom: 10px;
+ font-size: 0.9rem;
+ }
+
+ .step-item {
+ margin-bottom: 15px;
+ }
+
+ .step-number {
+ width: 25px !important;
+ height: 25px !important;
+ font-size: 12px;
+ }
+}
diff --git a/static/css/admin.css b/static/css/admin.css
new file mode 100644
index 0000000..3ca8980
--- /dev/null
+++ b/static/css/admin.css
@@ -0,0 +1,405 @@
+/* ================================
+ 管理员功能样式 - 用户管理和数据管理
+ ================================ */
+
+/* 用户管理样式 */
+.user-card {
+ transition: transform 0.2s ease, box-shadow 0.2s ease;
+ border: 1px solid var(--border-color);
+ border-radius: 12px;
+}
+
+.user-card:hover {
+ transform: translateY(-2px);
+ box-shadow: var(--shadow-md);
+}
+
+.user-card .card-body {
+ padding: 1.25rem;
+}
+
+.user-card .badge {
+ font-size: 0.75rem;
+ padding: 0.375rem 0.75rem;
+}
+
+/* 数据管理样式 */
+.table-container {
+ max-height: 600px;
+ overflow-y: auto;
+ border: 1px solid var(--border-color);
+ border-radius: 8px;
+}
+
+.table th {
+ position: sticky;
+ top: 0;
+ background: var(--dark-color);
+ color: white;
+ z-index: 10;
+ border: none;
+ font-weight: 600;
+ font-size: 0.875rem;
+ padding: 0.75rem;
+}
+
+.table td {
+ padding: 0.75rem;
+ font-size: 0.875rem;
+ border-bottom: 1px solid var(--border-color);
+ vertical-align: middle;
+}
+
+.table tbody tr:hover {
+ background-color: rgba(79, 70, 229, 0.05);
+}
+
+/* 数据统计卡片 */
+.data-stats {
+ background: linear-gradient(135deg, var(--primary-color) 0%, var(--primary-hover) 100%);
+ color: white;
+ border: none;
+}
+
+.data-stats .card-body {
+ padding: 0.75rem;
+}
+
+/* 表格状态样式 */
+#loadingTable,
+#noTableSelected,
+#noTableData {
+ padding: 3rem 1rem;
+}
+
+#loadingTable .spinner-border {
+ width: 3rem;
+ height: 3rem;
+ border-width: 0.3em;
+}
+
+#noTableSelected i,
+#noTableData i {
+ font-size: 4rem;
+ color: var(--secondary-color);
+ opacity: 0.5;
+}
+
+/* 按钮组样式 */
+.btn-group .btn {
+ border-radius: 0;
+}
+
+.btn-group .btn:first-child {
+ border-top-left-radius: 6px;
+ border-bottom-left-radius: 6px;
+}
+
+.btn-group .btn:last-child {
+ border-top-right-radius: 6px;
+ border-bottom-right-radius: 6px;
+}
+
+/* 表格选择器样式 */
+#tableSelect {
+ border: 2px solid var(--border-color);
+ border-radius: 8px;
+ padding: 0.75rem;
+ font-size: 0.875rem;
+ transition: border-color 0.2s ease;
+}
+
+#tableSelect:focus {
+ border-color: var(--primary-color);
+ box-shadow: 0 0 0 0.2rem rgba(79, 70, 229, 0.25);
+}
+
+/* 记录计数样式 */
+#recordCount {
+ font-size: 1.5rem;
+ font-weight: 700;
+ color: var(--primary-color);
+}
+
+/* 响应式调整 */
+@media (max-width: 768px) {
+ .user-card {
+ margin-bottom: 1rem;
+ }
+
+ .table-container {
+ max-height: 400px;
+ }
+
+ .table th,
+ .table td {
+ padding: 0.5rem;
+ font-size: 0.8rem;
+ }
+
+ .btn-group {
+ flex-direction: column;
+ }
+
+ .btn-group .btn {
+ border-radius: 6px !important;
+ margin-bottom: 0.25rem;
+ }
+}
+
+/* 加载状态动画 */
+@keyframes fadeIn {
+ from {
+ opacity: 0;
+ transform: translateY(10px);
+ }
+ to {
+ opacity: 1;
+ transform: translateY(0);
+ }
+}
+
+.user-card,
+.table-container {
+ animation: fadeIn 0.3s ease-out;
+}
+
+/* 表格滚动条样式 */
+.table-container::-webkit-scrollbar {
+ width: 8px;
+}
+
+.table-container::-webkit-scrollbar-track {
+ background: #f1f1f1;
+ border-radius: 4px;
+}
+
+.table-container::-webkit-scrollbar-thumb {
+ background: var(--secondary-color);
+ border-radius: 4px;
+}
+
+.table-container::-webkit-scrollbar-thumb:hover {
+ background: var(--primary-color);
+}
+
+/* 文本截断样式 */
+.text-truncate-custom {
+ max-width: 200px;
+ white-space: nowrap;
+ overflow: hidden;
+ text-overflow: ellipsis;
+ display: inline-block;
+}
+
+/* 状态徽章样式 */
+.status-badge {
+ font-size: 0.75rem;
+ padding: 0.25rem 0.5rem;
+ border-radius: 12px;
+}
+
+/* 工具提示样式增强 */
+[title] {
+ cursor: help;
+}
+
+/* 空状态图标样式 */
+.empty-state-icon {
+ font-size: 4rem;
+ color: var(--secondary-color);
+ opacity: 0.3;
+ margin-bottom: 1rem;
+}
+
+/* 操作按钮样式 */
+.action-buttons .btn {
+ margin: 0 0.125rem;
+ padding: 0.375rem 0.75rem;
+}
+
+.action-buttons .btn-sm {
+ padding: 0.25rem 0.5rem;
+ font-size: 0.75rem;
+}
+
+/* ================================
+ 系统使用手册样式
+ ================================ */
+.manual-wrapper {
+ display: flex;
+ min-height: 100%;
+}
+
+.manual-sidebar {
+ width: 220px;
+ flex-shrink: 0;
+ background: #fff;
+ border-right: 1px solid var(--border-color);
+ position: sticky;
+ top: 0;
+ height: 100%;
+ overflow-y: auto;
+ align-self: flex-start;
+}
+
+.manual-sidebar-header {
+ padding: 1rem 1.25rem;
+ font-weight: 700;
+ font-size: 0.95rem;
+ color: var(--dark-color);
+ border-bottom: 1px solid var(--border-color);
+ background: #f9fafb;
+}
+
+.manual-nav {
+ display: flex;
+ flex-direction: column;
+ padding: 0.5rem 0;
+}
+
+.manual-nav-link {
+ display: block;
+ padding: 0.6rem 1.25rem;
+ color: var(--secondary-color);
+ text-decoration: none;
+ font-size: 0.875rem;
+ border-left: 3px solid transparent;
+ transition: all 0.2s ease;
+}
+
+.manual-nav-link:hover {
+ color: var(--primary-color);
+ background: rgba(79, 70, 229, 0.04);
+ border-left-color: var(--primary-light);
+}
+
+.manual-nav-link.active {
+ color: var(--primary-color);
+ background: rgba(79, 70, 229, 0.06);
+ border-left-color: var(--primary-color);
+ font-weight: 600;
+}
+
+.manual-content {
+ flex: 1;
+ padding: 2rem 2.5rem;
+}
+
+.manual-section {
+ margin-bottom: 2.5rem;
+ padding-bottom: 2rem;
+ border-bottom: 1px solid #f0f0f0;
+}
+
+.manual-section:last-of-type {
+ border-bottom: none;
+ margin-bottom: 1rem;
+}
+
+.manual-section-title {
+ font-size: 1.35rem;
+ font-weight: 700;
+ color: var(--dark-color);
+ margin-bottom: 0.75rem;
+ padding-bottom: 0.5rem;
+ border-bottom: 2px solid var(--primary-color);
+ display: inline-block;
+}
+
+.manual-desc {
+ color: var(--secondary-color);
+ font-size: 0.95rem;
+ margin-bottom: 1.25rem;
+ line-height: 1.6;
+}
+
+.manual-section h4 {
+ font-size: 1rem;
+ font-weight: 600;
+ color: var(--dark-color);
+ margin-top: 1.25rem;
+ margin-bottom: 0.5rem;
+}
+
+.manual-section ul,
+.manual-section ol {
+ padding-left: 1.5rem;
+ margin-bottom: 0.75rem;
+}
+
+.manual-section li {
+ font-size: 0.9rem;
+ line-height: 1.7;
+ color: #374151;
+ margin-bottom: 0.25rem;
+}
+
+.manual-section li strong {
+ color: var(--dark-color);
+}
+
+.manual-tip,
+.manual-warn {
+ margin-top: 0.75rem;
+ padding: 0.75rem 1rem;
+ border-radius: 8px;
+ font-size: 0.85rem;
+ line-height: 1.5;
+}
+
+.manual-tip {
+ background: #ecfdf5;
+ border: 1px solid #a7f3d0;
+ color: #065f46;
+}
+
+.manual-warn {
+ background: #fef2f2;
+ border: 1px solid #fecaca;
+ color: #991b1b;
+}
+
+.manual-footer {
+ margin-top: 1rem;
+ padding-top: 1rem;
+}
+
+.manual-sidebar::-webkit-scrollbar {
+ width: 5px;
+}
+
+.manual-sidebar::-webkit-scrollbar-track {
+ background: transparent;
+}
+
+.manual-sidebar::-webkit-scrollbar-thumb {
+ background: #d1d5db;
+ border-radius: 3px;
+}
+
+@media (max-width: 992px) {
+ .manual-sidebar {
+ display: none;
+ }
+ .manual-content {
+ padding: 1.5rem;
+ }
+}
+
+/* 统计卡片渐变背景 */
+.stats-card-primary {
+ background: linear-gradient(135deg, var(--primary-color) 0%, var(--primary-hover) 100%);
+}
+
+.stats-card-info {
+ background: linear-gradient(135deg, #17a2b8 0%, #138496 100%);
+}
+
+.stats-card-success {
+ background: linear-gradient(135deg, var(--success-color) 0%, #0d9488 100%);
+}
+
+.stats-card-warning {
+ background: linear-gradient(135deg, var(--warning-color) 0%, #d97706 100%);
+}
diff --git a/static/css/app.css b/static/css/app.css
new file mode 100644
index 0000000..31b8df1
--- /dev/null
+++ b/static/css/app.css
@@ -0,0 +1,13 @@
+@import url('variables.css');
+@import url('layout.css');
+@import url('dashboard.css');
+@import url('logs.css');
+@import url('keywords.css');
+@import url('accounts.css');
+@import url('items.css');
+@import url('notifications.css');
+@import url('components.css');
+@import url('admin.css');
+
+
+
diff --git a/static/css/components.css b/static/css/components.css
new file mode 100644
index 0000000..cf9413d
--- /dev/null
+++ b/static/css/components.css
@@ -0,0 +1,403 @@
+/* ================================
+ 通用卡片样式 - 适用于所有菜单的卡片
+ ================================ */
+.card {
+ background: rgba(255, 255, 255, 0.95);
+ backdrop-filter: blur(10px);
+ border: 1px solid rgba(255, 255, 255, 0.2);
+ border-radius: 16px;
+ box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
+ transition: all 0.3s ease;
+ margin-bottom: 2rem;
+}
+
+.card:hover {
+ transform: translateY(-4px);
+ box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
+}
+
+.card-header {
+ background: linear-gradient(135deg, var(--primary-color), var(--primary-hover));
+ color: white;
+ border: none;
+ border-radius: 16px 16px 0 0 !important;
+ font-weight: 600;
+ font-size: 1.1rem;
+ padding: 1.25rem 1.5rem;
+}
+
+.card-body {
+ padding: 1.5rem;
+}
+
+.btn {
+ border-radius: 10px;
+ font-weight: 500;
+ transition: all 0.3s ease;
+ padding: 0.5rem 1rem;
+}
+
+.btn:hover {
+ transform: translateY(-2px);
+ box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
+}
+
+.btn-primary {
+ background: linear-gradient(135deg, var(--primary-color), var(--primary-hover));
+ border: none;
+}
+
+.btn-success {
+ background: linear-gradient(135deg, var(--success-color), #059669);
+ border: none;
+}
+
+.btn-danger {
+ background: linear-gradient(135deg, var(--danger-color), #dc2626);
+ border: none;
+}
+
+.btn-outline-primary {
+ border: 2px solid var(--primary-color);
+ color: var(--primary-color);
+}
+
+.btn-outline-primary:hover {
+ background: var(--primary-color);
+ border-color: var(--primary-color);
+ color: white;
+}
+
+.btn-outline-success {
+ border: 2px solid var(--success-color);
+ color: var(--success-color);
+}
+
+.btn-outline-success:hover {
+ background: var(--success-color);
+ border-color: var(--success-color);
+ color: white;
+}
+
+.btn-outline-info {
+ border: 2px solid #0dcaf0;
+ color: #0dcaf0;
+}
+
+.btn-outline-info:hover {
+ background: #0dcaf0;
+ border-color: #0dcaf0;
+ color: white;
+}
+
+.btn-outline-danger {
+ border: 2px solid var(--danger-color);
+ color: var(--danger-color);
+}
+
+.btn-outline-danger:hover {
+ background: var(--danger-color);
+ border-color: var(--danger-color);
+ color: white;
+}
+
+/* ================================
+ 通用表格样式 - 适用于所有菜单的表格
+ ================================ */
+.table {
+ margin-bottom: 0;
+ background: transparent;
+}
+
+.table th {
+ border-top: none;
+ border-bottom: 2px solid var(--border-color);
+ font-weight: 600;
+ color: var(--dark-color);
+ background: rgba(79, 70, 229, 0.05);
+ padding: 1rem;
+}
+
+.table td {
+ padding: 1rem;
+ border-bottom: 1px solid var(--border-color);
+ vertical-align: middle;
+}
+
+.table tbody tr:hover {
+ background: rgba(79, 70, 229, 0.02);
+}
+
+.badge {
+ font-weight: 500;
+ padding: 5px 10px;
+}
+
+.form-control:focus {
+ border-color: var(--primary-color);
+ box-shadow: 0 0 0 0.25rem rgba(13, 110, 253, 0.25);
+}
+
+.cookie-value {
+ font-family: 'JetBrains Mono', 'Fira Code', 'Courier New', monospace;
+ font-size: 0.85rem;
+ background: #f8fafc;
+ padding: 0.75rem;
+ border-radius: 8px;
+ border: 1px solid #e5e7eb;
+ word-break: break-all;
+ line-height: 1.4;
+ max-height: 120px;
+ overflow-y: auto;
+ white-space: pre-wrap;
+}
+
+.loading {
+ position: fixed;
+ top: 0;
+ left: 0;
+ right: 0;
+ bottom: 0;
+ background-color: rgba(255,255,255,0.7);
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ z-index: 9999;
+}
+
+.loading-spinner {
+ width: 3rem;
+ height: 3rem;
+}
+
+.keyword-editor {
+ border-radius: 10px;
+ box-shadow: 0 0 10px rgba(0,0,0,0.1);
+}
+
+.modal-content {
+ border-radius: 10px;
+ border: none;
+}
+
+.modal-header {
+ border-bottom: 1px solid rgba(0,0,0,0.05);
+}
+
+.modal-footer {
+ border-top: 1px solid rgba(0,0,0,0.05);
+}
+
+.cookie-id {
+ font-weight: 600;
+ color: var(--primary-color);
+ font-size: 1rem;
+}
+
+.empty-state {
+ text-align: center;
+ padding: 3rem 2rem;
+ color: var(--secondary-color);
+}
+
+.empty-state i {
+ opacity: 0.5;
+}
+
+.form-control, .form-select {
+ border-radius: 10px;
+ border: 2px solid var(--border-color);
+ transition: all 0.3s ease;
+ padding: 0.75rem 1rem;
+}
+
+.form-control:focus, .form-select:focus {
+ border-color: var(--primary-color);
+ box-shadow: 0 0 0 4px rgba(79, 70, 229, 0.1);
+ transform: translateY(-1px);
+}
+
+.form-label {
+ font-weight: 600;
+ color: var(--dark-color);
+ margin-bottom: 0.5rem;
+}
+
+/* ================================
+ 通用模态框样式 - 适用于所有菜单的模态框
+ ================================ */
+.modal-content {
+ border: none;
+ border-radius: 16px;
+ box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
+ backdrop-filter: blur(10px);
+}
+
+.modal-header {
+ background: linear-gradient(135deg, var(--primary-color), var(--primary-hover));
+ color: white;
+ border: none;
+ border-radius: 16px 16px 0 0;
+}
+
+.toast-container {
+ position: fixed;
+ bottom: 20px;
+ right: 20px;
+ z-index: 9999;
+}
+
+.toast {
+ border: none;
+ border-radius: 12px;
+ box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
+ backdrop-filter: blur(10px);
+}
+
+.btn-group .btn {
+ margin-right: 0.25rem;
+}
+
+.btn-group .btn:last-child {
+ margin-right: 0;
+}
+
+@media (max-width: 768px) {
+ .container {
+ margin-top: 1rem;
+ padding: 0 1rem;
+ }
+
+ .card-body {
+ padding: 1rem;
+ }
+
+ .btn {
+ font-size: 0.875rem;
+ padding: 0.375rem 0.75rem;
+ }
+
+ .cookie-value {
+ font-size: 0.75rem;
+ max-height: 80px;
+ }
+
+ .btn-group {
+ flex-direction: column;
+ }
+
+ .btn-group .btn {
+ margin-right: 0;
+ margin-bottom: 0.25rem;
+ }
+
+ /* 移动端商品表格优化 */
+ #itemsTableBody .btn-group {
+ flex-direction: row;
+ }
+
+ #itemsTableBody .btn-group .btn {
+ padding: 0.2rem 0.4rem;
+ font-size: 0.75rem;
+ }
+}
+
+/* ================================
+ API参数提示样式
+ ================================ */
+.param-item {
+ display: flex;
+ align-items: center;
+ padding: 0.25rem 0;
+}
+
+.param-name {
+ background-color: #f8f9fa;
+ color: #495057;
+ padding: 0.2rem 0.4rem;
+ border-radius: 4px;
+ font-family: 'Courier New', monospace;
+ font-size: 0.85rem;
+ font-weight: 500;
+ border: 1px solid #dee2e6;
+ cursor: pointer;
+ transition: all 0.2s ease;
+ min-width: 120px;
+ display: inline-block;
+}
+
+.param-name:hover {
+ background-color: #e9ecef;
+ border-color: #adb5bd;
+ transform: translateY(-1px);
+}
+
+#postParamsHelp,
+#editPostParamsHelp {
+ background-color: #f8f9fa;
+ border: 1px solid #dee2e6;
+ border-radius: 8px;
+ padding: 1rem;
+}
+
+#postParamsHelp .alert,
+#editPostParamsHelp .alert {
+ margin-bottom: 0;
+ border-radius: 6px;
+}
+
+/* 参数项点击效果 */
+.param-name:active {
+ transform: translateY(0);
+ background-color: #dee2e6;
+}
+
+/* ================================
+ API参数提示样式
+ ================================ */
+.param-item {
+ display: flex;
+ align-items: center;
+ padding: 0.25rem 0;
+}
+
+.param-name {
+ background-color: #f8f9fa;
+ color: #495057;
+ padding: 0.2rem 0.4rem;
+ border-radius: 4px;
+ font-family: 'Courier New', monospace;
+ font-size: 0.85rem;
+ font-weight: 500;
+ border: 1px solid #dee2e6;
+ cursor: pointer;
+ transition: all 0.2s ease;
+ min-width: 120px;
+ display: inline-block;
+}
+
+.param-name:hover {
+ background-color: #e9ecef;
+ border-color: #adb5bd;
+ transform: translateY(-1px);
+}
+
+#postParamsHelp,
+#editPostParamsHelp {
+ background-color: #f8f9fa;
+ border: 1px solid #dee2e6;
+ border-radius: 8px;
+ padding: 1rem;
+}
+
+#postParamsHelp .alert,
+#editPostParamsHelp .alert {
+ margin-bottom: 0;
+ border-radius: 6px;
+}
+
+/* 参数项点击效果 */
+.param-name:active {
+ transform: translateY(0);
+ background-color: #dee2e6;
+}
diff --git a/static/css/dashboard.css b/static/css/dashboard.css
new file mode 100644
index 0000000..531c662
--- /dev/null
+++ b/static/css/dashboard.css
@@ -0,0 +1,68 @@
+/* 仪表盘样式 */
+.dashboard-stats {
+ display: grid;
+ grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+ gap: 1.5rem;
+ margin-bottom: 2rem;
+}
+
+/* ================================
+ 【仪表盘菜单】相关样式
+ ================================ */
+.stat-card {
+ background: white;
+ border-radius: 12px;
+ padding: 1.5rem;
+ box-shadow: var(--shadow-sm);
+ border: 1px solid var(--border-color);
+ transition: all 0.3s ease;
+}
+
+.stat-card:hover {
+ transform: translateY(-2px);
+ box-shadow: var(--shadow-md);
+}
+
+.stat-icon {
+ width: 48px;
+ height: 48px;
+ border-radius: 12px;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ font-size: 1.5rem;
+ margin-bottom: 1rem;
+}
+
+.stat-icon.primary {
+ background: rgba(79, 70, 229, 0.1);
+ color: var(--primary-color);
+}
+
+.stat-icon.success {
+ background: rgba(16, 185, 129, 0.1);
+ color: var(--success-color);
+}
+
+.stat-icon.warning {
+ background: rgba(245, 158, 11, 0.1);
+ color: var(--warning-color);
+}
+
+.stat-icon.info {
+ background: rgba(59, 130, 246, 0.1);
+ color: #3b82f6;
+}
+
+.stat-number {
+ font-size: 2rem;
+ font-weight: 700;
+ color: var(--dark-color);
+ margin-bottom: 0.5rem;
+}
+
+.stat-label {
+ color: var(--secondary-color);
+ font-size: 0.875rem;
+ font-weight: 500;
+}
diff --git a/static/css/items.css b/static/css/items.css
new file mode 100644
index 0000000..8c36810
--- /dev/null
+++ b/static/css/items.css
@@ -0,0 +1,52 @@
+/* ================================
+ 【商品管理菜单】表格样式
+ ================================ */
+#itemsTableBody .btn-group {
+ white-space: nowrap;
+}
+
+#itemsTableBody .btn-group .btn {
+ padding: 0.25rem 0.5rem;
+ font-size: 0.875rem;
+ border-radius: 0.25rem;
+}
+
+#itemsTableBody .btn-group .btn:first-child {
+ border-top-right-radius: 0;
+ border-bottom-right-radius: 0;
+}
+
+#itemsTableBody .btn-group .btn:last-child {
+ border-top-left-radius: 0;
+ border-bottom-left-radius: 0;
+ border-left: 0;
+}
+
+#itemsTableBody .btn-group .btn i {
+ font-size: 0.875rem;
+}
+
+/* 表格操作列样式 */
+.table td:last-child {
+ text-align: center;
+ vertical-align: middle;
+ padding: 0.5rem 0.25rem;
+}
+
+/* 表格文本截断优化 */
+.table td {
+ vertical-align: middle;
+}
+
+.table td[title] {
+ cursor: help;
+}
+
+/* 商品表格特定优化 */
+#itemsTableBody td:nth-child(4),
+#itemsTableBody td:nth-child(5) {
+ max-width: 200px;
+ overflow: hidden;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+}
diff --git a/static/css/keywords.css b/static/css/keywords.css
new file mode 100644
index 0000000..cec25df
--- /dev/null
+++ b/static/css/keywords.css
@@ -0,0 +1,403 @@
+/* 关键词管理现代化样式 */
+.keyword-container {
+ background: white;
+ border-radius: 16px;
+ box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+ overflow: hidden;
+ transition: all 0.3s ease;
+}
+
+.keyword-header {
+ background: linear-gradient(135deg, var(--primary-color) 0%, var(--primary-hover) 100%);
+ color: white;
+ padding: 1.5rem 2rem;
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+}
+
+.keyword-header h3 {
+ margin: 0;
+ font-weight: 600;
+ display: flex;
+ align-items: center;
+}
+
+.keyword-header .account-badge {
+ background: rgba(255, 255, 255, 0.2);
+ padding: 0.5rem 1rem;
+ border-radius: 20px;
+ font-size: 0.875rem;
+ font-weight: 500;
+}
+
+.keyword-input-area {
+ padding: 2rem;
+ background: #f8fafc;
+ border-bottom: 1px solid #e5e7eb;
+}
+
+.keyword-input-group {
+ display: grid;
+ grid-template-columns: 1fr 2fr 1fr auto;
+ gap: 1rem;
+ align-items: end;
+}
+
+.input-field {
+ position: relative;
+}
+
+.input-field label {
+ position: absolute;
+ top: -0.5rem;
+ left: 0.75rem;
+ background: #f8fafc;
+ padding: 0 0.5rem;
+ font-size: 0.75rem;
+ font-weight: 500;
+ color: #6b7280;
+ z-index: 1;
+}
+
+.input-field input, .input-field select {
+ width: 100%;
+ padding: 1rem 0.75rem 0.75rem;
+ border: 2px solid #e5e7eb;
+ border-radius: 12px;
+ font-size: 0.875rem;
+ transition: all 0.3s ease;
+ background: white;
+}
+
+.input-field input:focus {
+ outline: none;
+ border-color: #667eea;
+ box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1);
+}
+
+.add-btn {
+ background: linear-gradient(135deg, #10b981 0%, #059669 100%);
+ color: white;
+ border: none;
+ border-radius: 12px;
+ padding: 1rem 1.5rem;
+ font-weight: 600;
+ cursor: pointer;
+ transition: all 0.3s ease;
+ display: flex;
+ align-items: center;
+ gap: 0.5rem;
+}
+
+.add-btn:hover {
+ transform: translateY(-2px);
+ box-shadow: 0 8px 25px rgba(16, 185, 129, 0.3);
+}
+
+.add-btn:active {
+ transform: translateY(0);
+}
+
+/* ================================
+ 【自动回复菜单】相关样式
+ ================================ */
+.keywords-list {
+ padding: 1.5rem 2rem 2rem;
+ max-height: 500px;
+ overflow-y: auto;
+}
+
+.keyword-item {
+ background: white;
+ border: 1px solid #e5e7eb;
+ border-radius: 12px;
+ margin-bottom: 1rem;
+ transition: all 0.3s ease;
+ overflow: hidden;
+}
+
+.keyword-item:hover {
+ border-color: #667eea;
+ box-shadow: 0 4px 12px rgba(102, 126, 234, 0.15);
+ transform: translateY(-1px);
+}
+
+.keyword-item-header {
+ padding: 1rem 1.5rem;
+ background: #f8fafc;
+ border-bottom: 1px solid #e5e7eb;
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+}
+
+.keyword-tag {
+ background: linear-gradient(135deg, var(--primary-color) 0%, var(--primary-hover) 100%);
+ color: white;
+ padding: 0.5rem 1rem;
+ border-radius: 20px;
+ font-size: 0.875rem;
+ font-weight: 500;
+ display: flex;
+ align-items: center;
+ gap: 0.5rem;
+}
+
+.keyword-actions {
+ display: flex;
+ gap: 0.5rem;
+}
+
+.action-btn {
+ width: 36px;
+ height: 36px;
+ border: none;
+ border-radius: 8px;
+ cursor: pointer;
+ transition: all 0.3s ease;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+}
+
+.edit-btn {
+ background: #f3f4f6;
+ color: #6b7280;
+}
+
+.edit-btn:hover {
+ background: #e5e7eb;
+ color: #374151;
+}
+
+.edit-btn-disabled {
+ background: #f9fafb !important;
+ color: #9ca3af !important;
+ cursor: not-allowed !important;
+}
+
+.edit-btn-disabled:hover {
+ background: #f9fafb !important;
+ color: #9ca3af !important;
+}
+
+.delete-btn {
+ background: #fef2f2;
+ color: #ef4444;
+}
+
+.delete-btn:hover {
+ background: #fee2e2;
+ color: #dc2626;
+}
+
+.keyword-content {
+ padding: 1.5rem;
+}
+
+.reply-text {
+ color: #374151;
+ line-height: 1.6;
+ margin: 0;
+ font-size: 0.875rem;
+}
+
+.empty-state {
+ text-align: center;
+ padding: 4rem 2rem;
+ color: #6b7280;
+}
+
+.empty-state i {
+ font-size: 4rem;
+ margin-bottom: 1rem;
+ opacity: 0.5;
+}
+
+.empty-state h3 {
+ margin: 0 0 0.5rem;
+ color: #374151;
+}
+
+.empty-state p {
+ margin: 0 0 2rem;
+ font-size: 0.875rem;
+}
+
+.quick-add-btn {
+ background: linear-gradient(135deg, var(--primary-color) 0%, var(--primary-hover) 100%);
+ color: white;
+ border: none;
+ border-radius: 12px;
+ padding: 0.75rem 1.5rem;
+ font-weight: 500;
+ cursor: pointer;
+ transition: all 0.3s ease;
+}
+
+.quick-add-btn:hover {
+ transform: translateY(-2px);
+ box-shadow: 0 8px 25px rgba(102, 126, 234, 0.3);
+}
+
+/* 账号选择器现代化 */
+.account-selector {
+ background: white;
+ border-radius: 16px;
+ box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+ padding: 2rem;
+ margin-bottom: 2rem;
+}
+
+.selector-header {
+ display: flex;
+ align-items: center;
+ gap: 1rem;
+ margin-bottom: 1.5rem;
+}
+
+.selector-icon {
+ width: 48px;
+ height: 48px;
+ background: linear-gradient(135deg, var(--primary-color) 0%, var(--primary-hover) 100%);
+ border-radius: 12px;
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ color: white;
+ font-size: 1.25rem;
+}
+
+.selector-title {
+ margin: 0;
+ color: #1f2937;
+ font-weight: 600;
+}
+
+.selector-subtitle {
+ margin: 0;
+ color: #6b7280;
+ font-size: 0.875rem;
+}
+
+.account-select-wrapper {
+ position: relative;
+}
+
+.account-select {
+ width: 100%;
+ padding: 1rem 1.25rem;
+ border: 2px solid #e5e7eb;
+ border-radius: 12px;
+ font-size: 1rem;
+ background: white;
+ cursor: pointer;
+ transition: all 0.3s ease;
+}
+
+.account-select:focus {
+ outline: none;
+ border-color: #667eea;
+ box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1);
+}
+
+/* ================================
+ 【自动回复菜单】图片关键词样式
+ ================================ */
+.btn-image {
+ background: linear-gradient(135deg, #28a745, #20c997) !important;
+ border: none !important;
+ margin-left: 10px;
+}
+
+.btn-image:hover {
+ background: linear-gradient(135deg, #218838, #1ea085) !important;
+ transform: translateY(-1px);
+}
+
+.keyword-input-group {
+ display: flex;
+ gap: 15px;
+ align-items: end;
+ flex-wrap: wrap;
+}
+
+.keyword-input-group .add-btn {
+ white-space: nowrap;
+ min-width: auto;
+}
+
+.image-preview {
+ margin-top: 10px;
+}
+
+.preview-container {
+ padding: 10px;
+ border: 2px dashed #ddd;
+ border-radius: 8px;
+ text-align: center;
+ background-color: #f8f9fa;
+}
+
+.keyword-type-badge {
+ display: inline-block;
+ padding: 2px 8px;
+ border-radius: 12px;
+ font-size: 0.75rem;
+ font-weight: 500;
+ margin-left: 8px;
+}
+
+.keyword-type-text {
+ background-color: #e3f2fd;
+ color: #1976d2;
+}
+
+.keyword-type-image {
+ background-color: #f3e5f5;
+ color: #7b1fa2;
+}
+
+/* 关键词列表中的图片预览 */
+.keyword-image-preview {
+ max-width: 60px;
+ max-height: 60px;
+ border-radius: 4px;
+ border: 1px solid #ddd;
+ cursor: pointer;
+}
+
+.keyword-image-preview:hover {
+ border-color: #007bff;
+ transform: scale(1.05);
+ transition: all 0.2s ease;
+}
+
+/* 响应式调整 */
+@media (max-width: 768px) {
+ .keyword-input-group {
+ grid-template-columns: 1fr;
+ gap: 1rem;
+ }
+
+ .keyword-item-header {
+ flex-direction: column;
+ align-items: flex-start;
+ gap: 1rem;
+ }
+
+ .keyword-actions {
+ align-self: flex-end;
+ }
+
+ .keyword-input-group {
+ flex-direction: column;
+ align-items: stretch;
+ }
+
+ .keyword-input-group .add-btn {
+ margin-left: 0;
+ margin-top: 10px;
+ }
+}
diff --git a/static/css/layout.css b/static/css/layout.css
new file mode 100644
index 0000000..9789cf9
--- /dev/null
+++ b/static/css/layout.css
@@ -0,0 +1,202 @@
+/* ================================
+ 通用布局 - 侧边栏和导航
+ ================================ */
+.sidebar {
+ position: fixed;
+ top: 0;
+ left: 0;
+ height: 100vh;
+ width: 250px;
+ background: linear-gradient(135deg, var(--primary-color) 0%, var(--primary-hover) 100%);
+ color: white;
+ z-index: 1000;
+ transition: all 0.3s ease;
+ box-shadow: 2px 0 10px rgba(0,0,0,0.1);
+ display: flex;
+ flex-direction: column;
+ overflow: hidden;
+}
+
+.sidebar-header {
+ padding: 1.5rem 1rem;
+ border-bottom: 1px solid rgba(255,255,255,0.1);
+ flex-shrink: 0;
+}
+
+.sidebar-brand {
+ font-size: 1.25rem;
+ font-weight: 700;
+ color: white;
+ text-decoration: none;
+ display: flex;
+ align-items: center;
+}
+
+.sidebar-nav {
+ padding: 1rem 0;
+ flex: 1;
+ overflow-y: auto;
+ overflow-x: hidden;
+}
+
+/* 侧边栏滚动条样式 */
+.sidebar-nav::-webkit-scrollbar {
+ width: 6px;
+}
+
+.sidebar-nav::-webkit-scrollbar-track {
+ background: rgba(255, 255, 255, 0.1);
+ border-radius: 3px;
+}
+
+.sidebar-nav::-webkit-scrollbar-thumb {
+ background: rgba(255, 255, 255, 0.3);
+ border-radius: 3px;
+ transition: background 0.3s ease;
+}
+
+.sidebar-nav::-webkit-scrollbar-thumb:hover {
+ background: rgba(255, 255, 255, 0.5);
+}
+
+/* Firefox滚动条样式 */
+.sidebar-nav {
+ scrollbar-width: thin;
+ scrollbar-color: rgba(255, 255, 255, 0.3) rgba(255, 255, 255, 0.1);
+}
+
+.nav-item {
+ margin: 0.25rem 0;
+}
+
+.nav-link {
+ display: flex;
+ align-items: center;
+ padding: 0.75rem 1.5rem;
+ color: rgba(255,255,255,0.8);
+ text-decoration: none;
+ transition: all 0.3s ease;
+ border-left: 3px solid transparent;
+}
+
+.nav-link:hover {
+ color: white;
+ background: rgba(255,255,255,0.1);
+ border-left-color: rgba(255,255,255,0.5);
+}
+
+.nav-link.active {
+ color: white;
+ background: rgba(255,255,255,0.15);
+ border-left-color: white;
+}
+
+.nav-link i {
+ margin-right: 0.75rem;
+ width: 20px;
+ text-align: center;
+}
+
+.nav-divider {
+ padding: 0.5rem 1rem;
+ border-top: 1px solid rgba(255,255,255,0.1);
+ margin-top: 0.5rem;
+}
+
+.nav-divider small {
+ font-weight: 500;
+ text-transform: uppercase;
+ letter-spacing: 0.5px;
+}
+
+/* 主内容区域 */
+.main-content {
+ margin-left: 250px;
+ height: 100vh;
+ background: #f8fafc;
+ display: flex;
+ flex-direction: column;
+}
+
+.content-header {
+ background: white;
+ padding: 1.5rem 2rem;
+ border-bottom: 1px solid var(--border-color);
+ box-shadow: var(--shadow-sm);
+ flex-shrink: 0;
+}
+
+.content-body {
+ padding: 2rem;
+}
+
+/* 响应式设计 */
+@media (max-width: 768px) {
+ .sidebar {
+ transform: translateX(-100%);
+ }
+
+ .sidebar.show {
+ transform: translateX(0);
+ }
+
+ .main-content {
+ margin-left: 0;
+ }
+
+ .mobile-toggle {
+ display: block !important;
+ }
+}
+
+.mobile-toggle {
+ display: none;
+ position: fixed;
+ top: 1rem;
+ left: 1rem;
+ z-index: 1001;
+ background: var(--primary-color);
+ color: white;
+ border: none;
+ border-radius: 8px;
+ padding: 0.5rem;
+ box-shadow: var(--shadow-md);
+}
+
+/* 内容区域样式 */
+.content-section {
+ display: none;
+}
+
+.content-section.active {
+ display: flex;
+ flex-direction: column;
+ flex: 1;
+ min-height: 0;
+}
+
+.content-section.active .content-body {
+ flex: 1;
+ min-height: 0;
+ overflow: auto;
+}
+
+/* 全局底部信息 */
+.global-footer {
+ flex-shrink: 0;
+ text-align: center;
+ padding: 0.75rem 2rem;
+ background: none;
+ border-top: 1px solid var(--border-color);
+ font-size: 0.8rem;
+ color: var(--secondary-color);
+}
+
+.global-footer a {
+ color: var(--primary-color);
+ text-decoration: none;
+}
+
+.global-footer a:hover {
+ text-decoration: underline;
+}
diff --git a/static/css/logs.css b/static/css/logs.css
new file mode 100644
index 0000000..f8de02f
--- /dev/null
+++ b/static/css/logs.css
@@ -0,0 +1,147 @@
+/* ================================
+ 【日志管理菜单】相关样式
+ ================================ */
+.log-container {
+ height: 70vh;
+ overflow-y: auto;
+ background-color: #1e1e1e;
+ color: #d4d4d4;
+ font-family: 'Consolas', 'Monaco', 'Courier New', monospace;
+ font-size: 12px;
+ line-height: 1.2;
+ padding: 8px;
+ border-radius: 4px;
+}
+
+.log-entry {
+ margin-bottom: 0px;
+ padding: 1px 0;
+ word-wrap: break-word;
+ white-space: pre-wrap;
+ line-height: 1.2;
+}
+
+.log-entry.DEBUG {
+ color: #9cdcfe;
+}
+
+.log-entry.INFO {
+ color: #4ec9b0;
+}
+
+.log-entry.WARNING {
+ color: #dcdcaa;
+}
+
+.log-entry.ERROR {
+ color: #f48771;
+}
+
+.log-entry.CRITICAL {
+ color: #ff6b6b;
+ font-weight: bold;
+}
+
+.log-timestamp {
+ color: #808080;
+}
+
+.log-level {
+ font-weight: bold;
+ margin: 0 5px;
+}
+
+.log-source {
+ color: #569cd6;
+}
+
+.log-message {
+ color: inherit;
+}
+
+.log-container::-webkit-scrollbar {
+ width: 8px;
+}
+
+.log-container::-webkit-scrollbar-track {
+ background: #2d2d30;
+}
+
+.log-container::-webkit-scrollbar-thumb {
+ background: #464647;
+ border-radius: 4px;
+}
+
+.log-container::-webkit-scrollbar-thumb:hover {
+ background: #5a5a5c;
+}
+
+/* 日志过滤标签样式 */
+.filter-badge {
+ cursor: pointer;
+ transition: all 0.2s;
+ margin-right: 0.5rem;
+ margin-bottom: 0.25rem;
+}
+
+.filter-badge:hover {
+ transform: scale(1.05);
+}
+
+.filter-badge.active {
+ box-shadow: 0 0 0 2px rgba(255,255,255,0.5);
+}
+
+/* 自动刷新指示器 */
+.auto-refresh-indicator {
+ animation: pulse 2s infinite;
+}
+
+@keyframes pulse {
+ 0% { opacity: 1; }
+ 50% { opacity: 0.5; }
+ 100% { opacity: 1; }
+}
+
+/* 日志行悬停效果 */
+.log-entry:hover {
+ background: rgba(255,255,255,0.05);
+}
+
+/* 商品搜索相关样式 */
+.item-card {
+ transition: transform 0.2s;
+ border: none;
+ border-radius: 15px;
+ box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+}
+
+.item-card:hover {
+ transform: translateY(-2px);
+}
+
+.item-image {
+ width: 100%;
+ height: 200px;
+ object-fit: cover;
+ border-radius: 10px;
+}
+
+.price {
+ color: #e74c3c;
+ font-weight: bold;
+ font-size: 1.2em;
+}
+
+.seller-name {
+ color: #6c757d;
+ font-size: 0.9em;
+}
+
+.want-count {
+ margin-top: 10px;
+}
+
+.want-count .badge {
+ font-size: 0.8em;
+}
diff --git a/static/css/notifications.css b/static/css/notifications.css
new file mode 100644
index 0000000..660283f
--- /dev/null
+++ b/static/css/notifications.css
@@ -0,0 +1,83 @@
+/* ================================
+ 【通知渠道菜单】卡片样式
+ ================================ */
+.channel-type-card {
+ cursor: pointer;
+ transition: all 0.3s ease;
+ border: 2px solid transparent;
+ min-height: 180px; /* 设置最小高度,让卡片更紧凑 */
+}
+
+.channel-type-card .card-body {
+ padding: 1rem; /* 减少内边距 */
+}
+
+.channel-type-card .channel-icon {
+ transition: transform 0.3s ease;
+ margin-bottom: 0.75rem !important; /* 减少图标下方间距 */
+}
+
+.channel-type-card .channel-icon i {
+ font-size: 2.2rem !important; /* 减小图标大小 */
+}
+
+.channel-type-card .card-title {
+ font-size: 1.1rem; /* 减小标题字体 */
+ margin-bottom: 0.5rem;
+}
+
+.channel-type-card .card-text {
+ font-size: 0.85rem; /* 减小描述文字 */
+ margin-bottom: 0.75rem;
+}
+
+.channel-type-card .btn {
+ transition: all 0.3s ease;
+ font-size: 0.85rem; /* 减小按钮文字 */
+ padding: 0.375rem 0.75rem; /* 减小按钮内边距 */
+}
+
+.channel-type-card:hover {
+ transform: translateY(-3px); /* 减少悬停位移 */
+ box-shadow: 0 6px 20px rgba(0,0,0,0.12);
+ border-color: var(--bs-primary);
+}
+
+.channel-type-card:hover .channel-icon {
+ transform: scale(1.05); /* 减少悬停缩放 */
+}
+
+.channel-type-card:hover .btn {
+ transform: scale(1.02); /* 减少按钮悬停缩放 */
+}
+
+/* 响应式调整 */
+@media (max-width: 768px) {
+ .channel-type-card {
+ margin-bottom: 10px;
+ min-height: 160px; /* 移动端稍微减小高度 */
+ }
+
+ .channel-type-card .card-body {
+ padding: 0.75rem; /* 移动端减少内边距 */
+ }
+
+ .channel-type-card .channel-icon i {
+ font-size: 2rem !important; /* 移动端图标更小 */
+ }
+
+ .channel-type-card .card-title {
+ font-size: 1rem; /* 移动端标题更小 */
+ }
+
+ .channel-type-card .card-text {
+ font-size: 0.8rem; /* 移动端描述文字更小 */
+ }
+}
+
+/* 大屏幕优化 */
+@media (min-width: 1400px) {
+ .channel-type-card {
+ min-height: 200px; /* 大屏幕稍微增加高度 */
+ }
+}
diff --git a/static/css/variables.css b/static/css/variables.css
new file mode 100644
index 0000000..26bee48
--- /dev/null
+++ b/static/css/variables.css
@@ -0,0 +1,26 @@
+/* ================================
+ 全局变量和基础样式
+ ================================ */
+:root {
+ --primary-color: #4f46e5;
+ --primary-hover: #4338ca;
+ --primary-light: #6366f1;
+ --secondary-color: #6b7280;
+ --success-color: #10b981;
+ --danger-color: #ef4444;
+ --warning-color: #f59e0b;
+ --light-color: #f9fafb;
+ --dark-color: #1f2937;
+ --border-color: #e5e7eb;
+ --shadow-sm: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
+ --shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
+ --shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -2px rgba(0, 0, 0, 0.05);
+ }
+
+ body {
+ font-family: 'Inter', 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+ background: #f8fafc;
+ min-height: 100vh;
+ padding: 0;
+ margin: 0;
+ }
diff --git a/static/data_management.html b/static/data_management.html
new file mode 100644
index 0000000..1fdcb2c
--- /dev/null
+++ b/static/data_management.html
@@ -0,0 +1,556 @@
+
+
+
+
+
+ 数据管理 - 闲鱼自动回复系统
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 表信息
+
+
+
+ 表名: -
+
+
+ 中文名: -
+
+
+ 记录数: -
+
+
+
+
+
+
+
+
+
+
+ 加载中...
+
+
正在加载数据...
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
您确定要删除这条记录吗?
+
+
+ 警告:此操作不可恢复!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
您确定要清空整个表的所有数据吗?
+
+
+ 危险操作:这将删除表中的所有记录,此操作不可恢复!
+
+
表名: -
+
记录数: - 条
+
+
+
+
+
+
+
+
+
+
diff --git a/static/index.html b/static/index.html
new file mode 100644
index 0000000..9a3f6ea
--- /dev/null
+++ b/static/index.html
@@ -0,0 +1,4458 @@
+
+
+
+
+
+ 闲鱼自动回复管理系统
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
仪表盘
+
仪表盘是系统的概览首页,展示系统运行的核心数据和状态。
+
功能说明
+
+ - 统计卡片:顶部展示账号总数、关键词总数、在线账号数、今日订单数等关键指标,帮助您快速了解系统概况。
+ - 账号状态列表:下方以表格形式展示每个闲鱼账号的详细信息,包括账号名称、商品数量、在线状态、今日消息数、今日订单数等。
+ - 快捷操作:每个账号行支持快速查看商品、查看订单、查看回复设置等操作。
+
+
使用步骤
+
+ - 登录系统后默认进入仪表盘页面。
+ - 浏览顶部统计卡片了解整体运行状态。
+ - 查看账号列表,点击操作按钮进行快速导航。
+
+
+
+
+
账号管理
+
管理所有闲鱼Cookie账号,支持添加、删除、启用/禁用、扫码登录等操作。
+
功能说明
+
+ - 添加账号:支持通过Cookie字符串添加账号,也可通过扫码登录方式添加。
+ - 扫码登录:点击"扫码登录"按钮,弹窗显示二维码,使用闲鱼App扫描完成登录,系统自动获取Cookie。
+ - 账号列表:展示所有已添加的账号,支持按状态筛选。
+ - 账号操作:每个账号可进行启用/禁用、开启/关闭自动确认、设置备注、调整暂停时长、删除等操作。
+ - 批量导入:支持批量导入Cookie账号。
+
+
使用步骤
+
+ - 进入"账号管理"页面,点击"添加账号"或"扫码登录"。
+ - 添加成功后,在列表中查看账号信息。
+ - 使用右侧操作按钮管理账号状态和配置。
+ - 定期检查Cookie有效性,及时续期失效的账号。
+
+
+
+ 提示:Cookie过期后需要重新扫码登录,建议定期检查账号状态。
+
+
+
+
+
商品管理
+
管理闲鱼账号发布的商品信息,支持浏览、搜索、筛选和批量操作。
+
功能说明
+
+ - 商品列表:展示所有商品,包含商品标题、图片、价格、所属账号、状态等信息。
+ - 搜索筛选:按关键词、所属账号、商品状态等进行搜索和筛选。
+ - 批量操作:支持批量删除、批量导出商品信息。
+ - 多规格商品:支持展示和管理多规格商品。
+
+
使用步骤
+
+ - 进入"商品管理"页面,系统自动加载所有商品。
+ - 使用搜索框和筛选条件查找目标商品。
+ - 勾选商品进行批量操作或点击单个商品查看详情。
+
+
+
+
+
订单管理
+
查看和管理闲鱼账号的所有订单,支持按账号筛选和搜索。
+
功能说明
+
+ - 订单列表:展示所有订单信息,包括订单号、商品名称、金额、买家信息、订单状态、下单时间等。
+ - 筛选:按所属账号、订单状态等条件筛选订单。
+ - 搜索:支持按订单号或商品关键词搜索。
+ - 订单详情:点击查看订单完整信息。
+
+
使用步骤
+
+ - 进入"订单管理"页面,系统自动加载订单数据。
+ - 使用顶部的账号筛选和搜索框查找目标订单。
+ - 点击订单行查看详细内容。
+
+
+
+
+
自动回复
+
配置关键词自动回复规则,当买家发送的消息匹配关键词时自动回复预设内容。
+
功能说明
+
+ - 按账号配置:为每个闲鱼账号分别配置独立的关键词回复规则。
+ - 关键词管理:支持添加、编辑、删除关键词,设置关键词的匹配模式(精确/模糊)。
+ - 回复内容:支持文本回复和图片回复,可绑定到指定商品。
+ - 默认回复:设置未匹配到关键词时的默认回复内容。
+ - AI智能回复:集成AI大模型,开启后可自动生成回复内容(需在系统设置中配置AI参数)。
+
+
使用步骤
+
+ - 进入"自动回复"页面,选择要配置的账号。
+ - 点击"添加关键词",输入关键词和对应的回复内容。
+ - 可选:绑定到特定商品,设置匹配模式。
+ - 配置默认回复作为兜底回复内容。
+ - 开启自动回复开关,保存配置。
+
+
+
+ 提示:建议为每个账号配置至少3-5个常用关键词,并设置合理的默认回复,以提升回复率。
+
+
+
+
+
AI对话历史
+
查看AI智能回复的对话记录,了解AI与买家的完整交互过程。
+
功能说明
+
+ - 对话列表:展示所有AI参与的对话,包含买家信息、所属账号、对话时间等。
+ - 对话详情:点击查看完整的对话内容,包括买家消息和AI回复。
+ - 搜索:支持按关键词搜索对话内容。
+
+
使用步骤
+
+ - 进入"AI对话历史"页面查看所有AI对话记录。
+ - 点击任意对话查看详细的交互内容。
+ - 通过搜索框快速定位特定对话。
+
+
+
+
+
指定商品回复
+
为特定商品配置独立的回复规则,不同商品可以有不同的自动回复内容。
+
功能说明
+
+ - 商品绑定:选择指定商品并为其配置专属回复内容。
+ - 独立规则:每个商品的回复规则独立于全局关键词规则。
+ - 优先级:指定商品回复的优先级高于通用关键词回复。
+
+
使用步骤
+
+ - 进入"指定商品回复"页面。
+ - 选择需要配置的账号和商品。
+ - 设置该商品对应的回复内容。
+ - 保存配置,当买家咨询该商品时将自动回复设置的内容。
+
+
+
+
+
卡券管理
+
管理数字卡券(如兑换码、卡密等),支持批量导入和自动发货。
+
功能说明
+
+ - 卡券类型:支持普通卡密和API类型的卡券。
+ - 多规格:支持为卡券设置不同规格(面值、类型等)。
+ - 批量导入:支持批量导入卡券数据。
+ - 库存管理:自动统计卡券库存数量。
+ - 图片上传:支持上传卡券相关图片。
+
+
使用步骤
+
+ - 进入"卡券管理"页面,点击"新建卡券"。
+ - 填写卡券名称、类型、规格等信息。
+ - 批量导入卡券内容(兑换码/卡密)。
+ - 关联到自动发货规则,实现购买后自动发货。
+
+
+
+
+
自动发货
+
配置自动发货规则,买家下单付款后自动发送卡券或虚拟商品。
+
功能说明
+
+ - 发货规则:创建规则并关联卡券,设置触发条件。
+ - 商品关联:将发货规则绑定到指定商品。
+ - 自动发送:买家付款后系统自动发送卡券内容到买家聊天窗口。
+ - 库存检查:自动检查卡券库存,库存不足时停止自动发货。
+
+
使用步骤
+
+ - 进入"自动发货"页面,点击"新建规则"。
+ - 选择关联的商品和卡券。
+ - 配置触发条件和发货内容。
+ - 启用规则,保存配置。
+
+
+
+ 提示:请确保卡券库存充足,以免自动发货失败。
+
+
+
+
+
通知渠道
+
配置消息通知渠道,支持通过多种方式接收系统通知。
+
功能说明
+
+ - Webhook:配置Webhook地址,系统将通知发送到指定URL。
+ - Bark:支持Bark推送,在iOS设备上接收通知。
+ - 其他渠道:支持更多自定义通知方式。
+
+
使用步骤
+
+ - 进入"通知渠道"页面,点击"添加渠道"。
+ - 选择渠道类型,填写配置信息。
+ - 保存并测试通知是否正常送达。
+
+
+
+
+
消息通知
+
为每个账号单独配置消息通知规则,当收到新消息时通过通知渠道发送提醒。
+
功能说明
+
+ - 按账号配置:为不同的闲鱼账号设置不同的通知策略。
+ - 通知规则:选择触发通知的事件类型(新消息、新订单等)。
+ - 通知渠道绑定:将通知规则关联到已配置的通知渠道。
+
+
使用步骤
+
+ - 进入"消息通知"页面,选择要配置的账号。
+ - 选择通知触发条件和目标通知渠道。
+ - 保存配置,当触发条件满足时将自动发送通知。
+
+
+
+
+
一键转卖
+
搜索闲鱼平台上的商品,查看商品信息和卖家情况。
+
功能说明
+
+ - 关键词搜索:输入关键词搜索闲鱼平台商品。
+ - 搜索结果:展示商品标题、价格、卖家信息、商品链接等。
+ - 筛选排序:支持按价格、销量等维度排序筛选。
+
+
使用步骤
+
+ - 进入"一键转卖"页面。
+ - 输入搜索关键词,点击搜索。
+ - 浏览搜索结果,点击查看商品详情。
+
+
+
+
+
系统设置
+
配置系统的全局参数,包括主题颜色、AI模型、代理设置、注册开关等。
+
功能说明
+
+ - 主题颜色:调整系统界面主题色。
+ - AI设置:配置AI回复的模型名称、API地址、Prompt提示词等参数。
+ - 代理设置:配置网络代理,用于访问外部API。
+ - 注册开关:控制是否允许新用户通过注册页面自行注册账号。关闭后仅管理员可在用户管理中添加用户。
+
+
使用步骤
+
+ - 进入"系统设置"页面。
+ - 按需调整各项配置参数。
+ - 点击"保存"使配置生效。
+
+
+
+ 提示:修改AI设置后需要重新开启自动回复功能才能生效。
+
+
+
+
+
用户管理
+
管理系统的用户账号,仅管理员可访问。支持添加、编辑、删除用户,以及分配角色。
+
功能说明
+
+ - 用户列表:以表格形式展示所有注册用户的信息(用户名、邮箱、角色、Cookie数、卡券数、注册时间)。
+ - 添加用户:管理员可直接创建新用户,填写用户名、邮箱、密码,并选择角色。
+ - 编辑用户:可修改用户的邮箱、重置密码,或变更角色(角色下拉来自"角色配置"中定义的角色)。
+ - 删除用户:删除用户及其所有关联数据(Cookie、关键词、卡券等),不可恢复。
+
+
使用步骤
+
+ - 使用管理员账号登录系统。
+ - 进入"用户管理"页面查看所有用户。
+ - 点击"添加用户"创建新账号,或点击编辑/删除按钮管理现有用户。
+ - 分配角色前请先在"角色配置"中定义好角色和对应的权限。
+
+
+
+
+
角色配置
+
管理角色和权限,控制不同用户可以访问的系统功能。仅管理员可访问。
+
功能说明
+
+ - 角色管理:支持创建自定义角色(如运营、客服等),内置
admin(全部权限)和 user(基础功能)角色不可删除。
+ - 权限配置:每个角色可独立勾选 18 项系统功能的访问权限,包括仪表盘、账号管理、商品管理、订单管理、自动回复、AI对话历史、指定商品回复、卡券管理、自动发货、通知渠道、消息通知、一键转卖、系统设置、用户管理、系统日志、数据管理、备份导出、备份导入。
+ - 全选/取消:编辑角色时支持一键全选或取消所有权限。
+ - 用户关联:在"用户管理"中为用户分配角色后,该用户将根据角色获得对应的功能访问权限。
+
+
使用步骤
+
+ - 点击左侧菜单"角色配置"进入页面。
+ - 点击"添加角色"输入角色名称创建新角色。
+ - 点击角色的"编辑"按钮,在弹出的窗口中勾选该角色应有的权限。
+ - 点击"保存"使配置生效。
+ - 进入"用户管理"页面,编辑用户时从角色下拉中选择刚创建的角色。
+
+
+
+ 提示:admin 角色拥有全部权限且不可修改。user 角色默认拥有除管理员功能外的所有权限。
+
+
+
+
+
系统日志
+
实时查看系统运行日志,支持日志级别筛选和自动刷新。
+
功能说明
+
+ - 实时日志:实时显示系统运行日志,支持自动滚动到最新。
+ - 级别筛选:按INFO、WARN、ERROR等日志级别筛选显示。
+ - 自动刷新:开启后日志自动更新,适合监控系统运行状态。
+ - 日志搜索:支持关键词搜索日志内容。
+
+
使用步骤
+
+ - 进入"系统日志"页面。
+ - 选择日志级别筛选需要查看的日志。
+ - 开启"自动刷新"实时监控系统运行。
+ - 使用搜索框定位特定日志内容。
+
+
+
+
+
数据管理
+
管理系统的SQLite数据库,支持查看表数据、导出备份、导入恢复。
+
功能说明
+
+ - 数据表浏览:选择数据库表,查看表中的所有数据记录。
+ - 数据导出:将数据库导出为备份文件,支持下载。
+ - 数据导入:导入之前备份的数据库文件,恢复数据。
+ - 记录统计:显示每个表的记录总数。
+
+
使用步骤
+
+ - 进入"数据管理"页面。
+ - 从下拉列表中选择要查看的数据表。
+ - 浏览表数据或执行导出/导入操作。
+ - 定期备份数据库以防数据丢失。
+
+
+
+ 注意:导入数据会覆盖当前数据库,请提前备份。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ | 用户信息 |
+ 账号ID |
+ Cookie值 |
+ 关键词 |
+ 启用/在线 |
+ 默认回复 |
+ AI回复 |
+ 自动确认 |
+ 备注 |
+
+ 暂停时间
+
+ |
+ 添加时间 |
+ Token有效期 |
+ 操作 |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ | ID |
+ 账号 |
+ 买家 |
+ 角色 |
+ 内容 |
+ 意图 |
+ 时间 |
+
+
+
+
+ |
+ 加载中...
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ | 卡券名称 |
+ 类型 |
+ 规格信息 |
+ 数据量 |
+ 延时时间 |
+ 状态 |
+ 创建时间 |
+ 操作 |
+
+
+
+
+
+
+ 暂无卡券数据
+ 点击"添加卡券"开始创建您的第一个卡券
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ | 商品关键字 |
+ 匹配卡券 |
+ 卡券类型 |
+ 发货数量 |
+ 状态 |
+ 已发货次数 |
+ 操作 |
+
+
+
+
+
+
+ 暂无发货规则
+ 点击"添加规则"开始配置自动发货规则
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 选择通知方式:点击下方按钮选择您要配置的通知渠道类型
+
+
+
+
+
+
+
+
+
+
+
QQ通知
+
QQ机器人消息
+
+
+
+
+
+
+
+
+
+
+
+
+
+
钉钉通知
+
钉钉机器人消息
+
+
+
+
+
+
+
+
+
+
+
+
+
+
邮件通知
+
SMTP邮件发送
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Webhook
+
自定义HTTP请求
+
+
+
+
+
+
+
+
+
+
+
+
+
+
微信通知
+
企业微信机器人
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Telegram
+
Telegram机器人
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ | ID |
+ 名称 |
+ 类型 |
+ 配置 |
+ 状态 |
+ 操作 |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ | 账号ID |
+ 通知渠道 |
+ 状态 |
+ 操作 |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 全部
+
+
+ INFO
+
+
+ WARNING
+
+
+ ERROR
+
+
+ DEBUG
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 日志文件:
+ -
+
+
+ 显示行数:
+ -
+
+
+ 当前过滤:
+ 全部
+
+
+
+
+
+
+
+
+
+
+
+ 加载中...
+
+
正在加载日志...
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
功能说明:
+
+ - 查询总页数:输入要获取的页数(1-20页),系统会一次性获取所有页面的数据
+ - 每页显示:前端分页显示的每页商品数量
+ - 数据来源:使用真实的闲鱼数据,通过浏览器自动化技术获取
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
未找到相关商品
+
请尝试使用其他关键词或调整搜索条件
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 加载中...
+
+
正在加载用户信息...
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 说明:在此创建不同的角色并为每个角色分配不同功能权限。
+ admin 用户始终拥有全部权限。用户在"用户管理"中分配角色后将受角色权限限制。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 加载中...
+
+
正在加载数据...
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 关闭后,新用户将无法注册账号,登录页面也不会显示注册链接
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 数据库备份
+
+
直接下载完整的数据库文件,包含所有用户数据和设置
+
+
+
+
+ 推荐方式:完整备份,恢复简单
+
+
+
+
+
+
+
+ 数据库恢复
+
+
上传数据库文件直接替换当前数据库,系统将自动重新加载
+
+
+
+
+
+
+
+ 警告:将覆盖所有当前数据!
+
+
+
+
+
+
+
+
+
+ 系统缓存管理
+
+
如果导入备份后关键字等数据没有立即更新,可以手动刷新系统缓存
+
+
+
+
+
+
+ 注意:导入备份将会覆盖当前系统的所有数据,请谨慎操作!建议在导入前先导出当前数据作为备份。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 生成二维码中...
+
+
正在生成二维码...
+
+
+ 二维码生成较慢,请耐心等待
+
+
+
+
+
![登录二维码]()
+
+
+ 请使用闲鱼APP扫描二维码
+
+
+
+ 扫码后请等待页面提示,系统会自动获取并保存您的账号信息
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 请配置通知渠道信息
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 功能说明:当没有匹配到关键词时,系统会使用默认回复。支持以下变量:
+ {send_user_name} 用户昵称、
+ {send_user_id} 用户ID、
+ {send_message} 用户消息
+
+ 只回复一次:开启后,每个对话只会触发一次默认回复,避免重复回复同一用户。
+
+
+
+
+
+
+ | 账号ID |
+ 状态 |
+ 只回复一次 |
+ 默认回复内容 |
+ 操作 |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 请上传包含"关键词"、"商品ID"、"关键词内容"三列的Excel文件(仅导入文本类型关键词,图片关键词将保留)
+
+
+
+
导入说明:
+
+ - Excel文件必须包含三列:关键词、商品ID、关键词内容
+ - 商品ID可以为空,表示通用关键词
+ - 导入的关键词默认为文本类型
+ - 如果关键词+商品ID组合已存在,将更新关键词内容
+ - 导入只会替换文本类型关键词,图片关键词将被保留
+ - 导入完成后,您的图片关键词仍然存在且正常工作
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
您确定要删除这个用户吗?
+
+
+ 警告:此操作将同时删除该用户的所有数据,包括Cookie、关键词、卡券等,且不可撤销!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
您确定要删除这条记录吗?
+
+
+
+ 警告:此操作不可撤销!
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
![]()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 如何获取阿奇索 Cookie 和 Authorization?
+
+
+ -
+ 打开阿奇索官网
+
+
+ https://aldsidle.agiso.com/
+
+
+ -
+ 登录你的阿奇索账号
+
+ 如果还没使用过阿奇索,需要先用闲鱼账号进行产品绑定授权
+
+ -
+ 打开浏览器开发者工具
+
+ 按 F12 键,或右键页面选择"检查"
+
+ -
+ 找到网络请求
+
+ 选择"网络(Network)"标签,在过滤框中输入 GetUserInfo
+
+ -
+ 刷新页面并复制数据
+
+ 刷新网页,点击获取到的请求,在右侧"请求标头"中找到并复制:
+
+ Cookie 字段的完整内容
+ Authorization 字段的完整内容
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/static/item_search.html b/static/item_search.html
new file mode 100644
index 0000000..0a82510
--- /dev/null
+++ b/static/item_search.html
@@ -0,0 +1,1503 @@
+
+
+
+
+
+ 一键转卖 - 闲鱼管理系统
+
+
+
+
+
+
+
+
+
+
+
+
+ 验证登录状态...
+
+
正在验证登录状态...
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 搜索中...
+
+
正在搜索商品,请稍候...
+
+
+
+
+
+
+
+
+
+
+
没有找到相关商品
+
请尝试使用其他关键词搜索
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
![]()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 如何获取阿奇索 Cookie 和 Authorization?
+
+
+ -
+ 打开阿奇索官网
+
+
+ https://aldsidle.agiso.com/
+
+
+ -
+ 登录你的阿奇索账号
+
+ 如果还没使用过阿奇索,需要先用闲鱼账号进行产品绑定授权
+
+ -
+ 打开浏览器开发者工具
+
+ 按 F12 键,或右键页面选择"检查"
+
+ -
+ 找到网络请求
+
+ 选择"网络(Network)"标签,在过滤框中输入 GetUserInfo
+
+ -
+ 刷新页面并复制数据
+
+ 刷新网页,点击获取到的请求,在右侧"请求标头"中找到并复制:
+
+ Cookie 字段的完整内容
+ Authorization 字段的完整内容
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/static/js/app.js b/static/js/app.js
new file mode 100644
index 0000000..5b743e2
--- /dev/null
+++ b/static/js/app.js
@@ -0,0 +1,10915 @@
+
+// ================================
+// 全局变量和配置
+// ================================
+const apiBase = location.origin;
+let keywordsData = {};
+let currentCookieId = '';
+let editCookieId = '';
+let authToken = localStorage.getItem('auth_token');
+let dashboardData = {
+ accounts: [],
+ totalKeywords: 0
+};
+
+// 账号关键词缓存
+let accountKeywordCache = {};
+let cacheTimestamp = 0;
+const CACHE_DURATION = 30000; // 30秒缓存
+
+// 商品列表搜索和分页相关变量
+let allItemsData = []; // 存储所有商品数据
+let filteredItemsData = []; // 存储过滤后的商品数据
+let currentItemsPage = 1; // 当前页码
+let itemsPerPage = 20; // 每页显示数量
+let totalItemsPages = 0; // 总页数
+let currentSearchKeyword = ''; // 当前搜索关键词
+
+// 订单列表搜索和分页相关变量
+let allOrdersData = []; // 存储所有订单数据
+let filteredOrdersData = []; // 存储过滤后的订单数据
+let currentOrdersPage = 1; // 当前页码
+let ordersPerPage = 20; // 每页显示数量
+let totalOrdersPages = 0; // 总页数
+let currentOrderSearchKeyword = ''; // 当前搜索关键词
+
+// ================================
+// 通用功能 - 菜单切换和导航
+// ================================
+function showSection(sectionName) {
+ // 检查页面权限
+ if (!hasPagePermission(sectionName)) {
+ showToast('您没有权限访问此功能', 'warning');
+ // 跳转到仪表盘
+ sectionName = 'dashboard';
+ }
+
+ console.log('切换到页面:', sectionName); // 调试信息
+
+ // 隐藏所有内容区域
+ document.querySelectorAll('.content-section').forEach(section => {
+ section.classList.remove('active');
+ });
+
+ // 移除所有菜单项的active状态
+ document.querySelectorAll('.nav-link').forEach(link => {
+ link.classList.remove('active');
+ });
+
+ // 显示选中的内容区域
+ const targetSection = document.getElementById(sectionName + '-section');
+ if (targetSection) {
+ targetSection.classList.add('active');
+ console.log('页面已激活:', sectionName + '-section'); // 调试信息
+ } else {
+ console.error('找不到页面元素:', sectionName + '-section'); // 调试信息
+ }
+
+ // 设置对应菜单项为active(修复event.target问题)
+ const menuLinks = document.querySelectorAll('.nav-link');
+ menuLinks.forEach(link => {
+ if (link.onclick && link.onclick.toString().includes(`showSection('${sectionName}')`)) {
+ link.classList.add('active');
+ }
+ });
+
+ // 根据不同section加载对应数据
+ switch(sectionName) {
+ case 'dashboard': // 【仪表盘菜单】
+ loadDashboard();
+ break;
+ case 'accounts': // 【账号管理菜单】
+ loadCookies();
+ break;
+ case 'items': // 【商品管理菜单】
+ loadItems();
+ break;
+ case 'items-reply': // 【商品回复管理菜单】
+ loadItemsReplay();
+ break;
+ case 'orders': // 【订单管理菜单】
+ loadOrders();
+ break;
+ case 'auto-reply': // 【自动回复菜单】
+ refreshAccountList();
+ break;
+ case 'ai-conversation': // 【AI对话历史菜单】
+ loadAIConversations();
+ break;
+ case 'cards': // 【卡券管理菜单】
+ loadCards();
+ break;
+ case 'auto-delivery': // 【自动发货菜单】
+ loadDeliveryRules();
+ break;
+ case 'notification-channels': // 【通知渠道菜单】
+ loadNotificationChannels();
+ break;
+ case 'message-notifications': // 【消息通知菜单】
+ loadMessageNotifications();
+ break;
+ case 'password-settings': // 【密码设置菜单】
+ break;
+ case 'system-settings': // 【系统设置菜单】
+ loadSystemSettings();
+ break;
+ case 'logs': // 【日志管理菜单】
+ // 自动加载系统日志
+ setTimeout(() => {
+ // 检查是否在正确的页面并且元素存在
+ const systemLogContainer = document.getElementById('systemLogContainer');
+ if (systemLogContainer) {
+ console.log('首次进入日志页面,自动加载日志...');
+ loadSystemLogs();
+ }
+ }, 100);
+ break;
+ case 'user-management': // 【用户管理菜单】
+ loadUserManagement();
+ break;
+ case 'data-management': // 【数据管理菜单】
+ loadDataManagement();
+ break;
+ case 'about': // 【系统使用手册】
+ setTimeout(() => initManualNav(), 100);
+ break;
+ case 'role-permissions': // 【权限配置】
+ setTimeout(() => loadRoles(), 100);
+ break;
+ }
+
+ // 如果切换到非日志页面,停止自动刷新
+ if (sectionName !== 'logs' && window.autoRefreshInterval) {
+ clearInterval(window.autoRefreshInterval);
+ window.autoRefreshInterval = null;
+ const button = document.querySelector('#autoRefreshText');
+ const icon = button?.previousElementSibling;
+ if (button) {
+ button.textContent = '开启自动刷新';
+ if (icon) icon.className = 'bi bi-play-circle me-1';
+ }
+ }
+}
+
+// 移动端侧边栏切换
+function toggleSidebar() {
+ document.getElementById('sidebar').classList.toggle('show');
+}
+
+// 系统使用手册 - 侧边导航滚动监听
+function initManualNav() {
+ const scrollContainer = document.querySelector('#about-section .content-body');
+ const navLinks = document.querySelectorAll('.manual-nav-link');
+ if (!scrollContainer || !navLinks.length) return;
+
+ // 点击导航链接平滑滚动
+ navLinks.forEach(link => {
+ link.addEventListener('click', function(e) {
+ e.preventDefault();
+ const targetId = this.getAttribute('href').substring(1);
+ const target = document.getElementById(targetId);
+ if (target) {
+ scrollContainer.scrollTo({
+ top: target.offsetTop - scrollContainer.offsetTop - 20,
+ behavior: 'smooth'
+ });
+ }
+ });
+ });
+
+ // 滚动时高亮当前导航项
+ const sections = document.querySelectorAll('.manual-section');
+ const onScroll = () => {
+ const offset = scrollContainer.scrollTop + 30;
+ let currentId = '';
+ sections.forEach(section => {
+ const sectionTop = section.offsetTop - scrollContainer.offsetTop;
+ if (sectionTop <= offset) {
+ currentId = section.id;
+ }
+ });
+ navLinks.forEach(link => {
+ link.classList.toggle('active', link.getAttribute('href') === '#' + currentId);
+ });
+ };
+ scrollContainer.addEventListener('scroll', onScroll);
+ onScroll();
+}
+
+// ================================
+// 【仪表盘菜单】相关功能
+// ================================
+
+// 加载仪表盘数据
+async function loadDashboard() {
+ try {
+ toggleLoading(true);
+
+ // 获取账号列表
+ const cookiesResponse = await fetch(`${apiBase}/cookies/details`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (cookiesResponse.ok) {
+ const cookiesData = await cookiesResponse.json();
+
+ // 为每个账号获取关键词信息
+ const accountsWithKeywords = await Promise.all(
+ cookiesData.map(async (account) => {
+ try {
+ const keywordsResponse = await fetch(`${apiBase}/keywords/${account.id}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (keywordsResponse.ok) {
+ const keywordsData = await keywordsResponse.json();
+ return {
+ ...account,
+ keywords: keywordsData,
+ keywordCount: keywordsData.length
+ };
+ } else {
+ return {
+ ...account,
+ keywords: [],
+ keywordCount: 0
+ };
+ }
+ } catch (error) {
+ console.error(`获取账号 ${account.id} 关键词失败:`, error);
+ return {
+ ...account,
+ keywords: [],
+ keywordCount: 0
+ };
+ }
+ })
+ );
+
+ dashboardData.accounts = accountsWithKeywords;
+
+ // 计算统计数据
+ let totalKeywords = 0;
+ let activeAccounts = 0;
+ let enabledAccounts = 0;
+
+ accountsWithKeywords.forEach(account => {
+ const keywordCount = account.keywordCount || 0;
+ const isEnabled = account.enabled === undefined ? true : account.enabled;
+
+ if (isEnabled) {
+ enabledAccounts++;
+ totalKeywords += keywordCount;
+ if (keywordCount > 0) {
+ activeAccounts++;
+ }
+ }
+ });
+
+ dashboardData.totalKeywords = totalKeywords;
+
+ // 加载订单数量
+ await loadOrdersCount();
+
+ // 更新仪表盘显示
+ updateDashboardStats(accountsWithKeywords.length, totalKeywords, enabledAccounts);
+ }
+ } catch (error) {
+ console.error('加载仪表盘数据失败:', error);
+ showToast('加载仪表盘数据失败', 'danger');
+ } finally {
+ toggleLoading(false);
+ }
+}
+
+// 加载订单数量
+async function loadOrdersCount() {
+ try {
+ const token = localStorage.getItem('auth_token');
+ const response = await fetch('/admin/orders', {
+ headers: {
+ 'Authorization': `Bearer ${token}`
+ }
+ });
+
+ const data = await response.json();
+ if (data.success) {
+ const ordersCount = data.data ? data.data.length : 0;
+ document.getElementById('totalOrders').textContent = ordersCount;
+ } else {
+ console.error('加载订单数量失败:', data.message);
+ document.getElementById('totalOrders').textContent = '0';
+ }
+ } catch (error) {
+ console.error('加载订单数量失败:', error);
+ document.getElementById('totalOrders').textContent = '0';
+ }
+}
+
+// 更新仪表盘统计数据
+function updateDashboardStats(totalAccounts, totalKeywords, enabledAccounts) {
+ document.getElementById('totalAccounts').textContent = totalAccounts;
+ document.getElementById('totalKeywords').textContent = totalKeywords;
+ document.getElementById('activeAccounts').textContent = enabledAccounts;
+}
+
+// 获取账号关键词数量(带缓存)- 包含普通关键词和商品关键词
+async function getAccountKeywordCount(accountId) {
+ const now = Date.now();
+
+ // 检查缓存
+ if (accountKeywordCache[accountId] && (now - cacheTimestamp) < CACHE_DURATION) {
+ return accountKeywordCache[accountId];
+ }
+
+ try {
+ const response = await fetch(`${apiBase}/keywords/${accountId}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const keywordsData = await response.json();
+ // 现在API返回的是包含普通关键词和商品关键词的完整列表
+ const count = keywordsData.length;
+
+ // 更新缓存
+ accountKeywordCache[accountId] = count;
+ cacheTimestamp = now;
+
+ return count;
+ } else {
+ return 0;
+ }
+ } catch (error) {
+ console.error(`获取账号 ${accountId} 关键词失败:`, error);
+ return 0;
+ }
+}
+
+// 清除关键词缓存
+function clearKeywordCache() {
+ accountKeywordCache = {};
+ cacheTimestamp = 0;
+}
+
+// ================================
+// 【自动回复菜单】相关功能
+// ================================
+
+// 刷新账号列表(用于自动回复页面)
+async function refreshAccountList() {
+ try {
+ toggleLoading(true);
+
+ // 获取账号列表
+ const response = await fetch(`${apiBase}/cookies/details`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const accounts = await response.json();
+ const select = document.getElementById('accountSelect');
+ select.innerHTML = '';
+
+ // 为每个账号获取关键词数量
+ const accountsWithKeywords = await Promise.all(
+ accounts.map(async (account) => {
+ try {
+ const keywordsResponse = await fetch(`${apiBase}/keywords/${account.id}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (keywordsResponse.ok) {
+ const keywordsData = await keywordsResponse.json();
+ return {
+ ...account,
+ keywords: keywordsData,
+ keywordCount: keywordsData.length
+ };
+ } else {
+ return {
+ ...account,
+ keywordCount: 0
+ };
+ }
+ } catch (error) {
+ console.error(`获取账号 ${account.id} 关键词失败:`, error);
+ return {
+ ...account,
+ keywordCount: 0
+ };
+ }
+ })
+ );
+
+ // 渲染账号选项(显示所有账号,但标识禁用状态)
+ if (accountsWithKeywords.length === 0) {
+ select.innerHTML = '';
+ return;
+ }
+
+ // 分组显示:先显示启用的账号,再显示禁用的账号
+ const enabledAccounts = accountsWithKeywords.filter(account => {
+ const enabled = account.enabled === undefined ? true : account.enabled;
+ console.log(`账号 ${account.id} 过滤状态: enabled=${account.enabled}, 判断为启用=${enabled}`); // 调试信息
+ return enabled;
+ });
+ const disabledAccounts = accountsWithKeywords.filter(account => {
+ const enabled = account.enabled === undefined ? true : account.enabled;
+ return !enabled;
+ });
+
+ // 渲染启用的账号
+ enabledAccounts.forEach(account => {
+ const option = document.createElement('option');
+ option.value = account.id;
+
+ // 根据关键词数量显示不同的图标和样式
+ let icon = '📝';
+ let status = '';
+ if (account.keywordCount === 0) {
+ icon = '⚪';
+ status = ' (未配置)';
+ } else if (account.keywordCount >= 5) {
+ icon = '🟢';
+ status = ` (${account.keywordCount} 个关键词)`;
+ } else {
+ icon = '🟡';
+ status = ` (${account.keywordCount} 个关键词)`;
+ }
+
+ option.textContent = `${icon} ${account.id}${status}`;
+ select.appendChild(option);
+ });
+
+ // 如果有禁用的账号,添加分隔线和禁用账号
+ if (disabledAccounts.length > 0) {
+ // 添加分隔线
+ const separatorOption = document.createElement('option');
+ separatorOption.disabled = true;
+ separatorOption.textContent = `--- 禁用账号 (${disabledAccounts.length} 个) ---`;
+ select.appendChild(separatorOption);
+
+ // 渲染禁用的账号
+ disabledAccounts.forEach(account => {
+ const option = document.createElement('option');
+ option.value = account.id;
+
+ // 禁用账号使用特殊图标和样式
+ let icon = '🔴';
+ let status = '';
+ if (account.keywordCount === 0) {
+ status = ' (未配置) [已禁用]';
+ } else {
+ status = ` (${account.keywordCount} 个关键词) [已禁用]`;
+ }
+
+ option.textContent = `${icon} ${account.id}${status}`;
+ option.style.color = '#6b7280';
+ option.style.fontStyle = 'italic';
+ select.appendChild(option);
+ });
+ }
+
+ console.log('账号列表刷新完成,关键词统计:', accountsWithKeywords.map(a => ({id: a.id, keywords: a.keywordCount})));
+ } else {
+ showToast('获取账号列表失败', 'danger');
+ }
+ } catch (error) {
+ console.error('刷新账号列表失败:', error);
+ showToast('刷新账号列表失败', 'danger');
+ } finally {
+ toggleLoading(false);
+ }
+}
+
+// 只刷新关键词列表(不重新加载商品列表等其他数据)
+async function refreshKeywordsList() {
+ if (!currentCookieId) {
+ console.warn('没有选中的账号,无法刷新关键词列表');
+ return;
+ }
+
+ try {
+ const response = await fetch(`${apiBase}/keywords-with-item-id/${currentCookieId}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ console.log('刷新关键词列表,从服务器获取的数据:', data);
+
+ // 更新缓存数据
+ keywordsData[currentCookieId] = data;
+
+ // 只重新渲染关键词列表
+ renderKeywordsList(data);
+
+ // 清除关键词缓存
+ clearKeywordCache();
+ } else {
+ console.error('刷新关键词列表失败:', response.status);
+ showToast('刷新关键词列表失败', 'danger');
+ }
+ } catch (error) {
+ console.error('刷新关键词列表失败:', error);
+ showToast('刷新关键词列表失败', 'danger');
+ }
+}
+
+// 加载账号关键词
+async function loadAccountKeywords() {
+ const accountId = document.getElementById('accountSelect').value;
+ const keywordManagement = document.getElementById('keywordManagement');
+
+ if (!accountId) {
+ keywordManagement.style.display = 'none';
+ return;
+ }
+
+ try {
+ toggleLoading(true);
+ currentCookieId = accountId;
+
+ // 获取账号详情以检查状态
+ const accountResponse = await fetch(`${apiBase}/cookies/details`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ let accountStatus = true; // 默认启用
+ if (accountResponse.ok) {
+ const accounts = await accountResponse.json();
+ const currentAccount = accounts.find(acc => acc.id === accountId);
+ accountStatus = currentAccount ? (currentAccount.enabled === undefined ? true : currentAccount.enabled) : true;
+ console.log(`加载关键词时账号 ${accountId} 状态: enabled=${currentAccount?.enabled}, accountStatus=${accountStatus}`); // 调试信息
+ }
+
+ const response = await fetch(`${apiBase}/keywords-with-item-id/${accountId}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ console.log('从服务器获取的关键词数据:', data); // 调试信息
+
+ // 后端返回的是 [{keyword, reply, item_id, type, image_url}, ...] 格式,直接使用
+ const formattedData = data;
+
+ console.log('格式化后的关键词数据:', formattedData); // 调试信息
+ keywordsData[accountId] = formattedData;
+ renderKeywordsList(formattedData);
+
+ // 加载商品列表
+ await loadItemsList(accountId);
+
+ // 更新账号徽章显示
+ updateAccountBadge(accountId, accountStatus);
+
+ keywordManagement.style.display = 'block';
+ } else {
+ showToast('加载关键词失败', 'danger');
+ }
+ } catch (error) {
+ console.error('加载关键词失败:', error);
+ showToast('加载关键词失败', 'danger');
+ } finally {
+ toggleLoading(false);
+ }
+}
+
+// 更新账号徽章显示
+function updateAccountBadge(accountId, isEnabled) {
+ const badge = document.getElementById('currentAccountBadge');
+ if (!badge) return;
+
+ const statusIcon = isEnabled ? '🟢' : '🔴';
+ const statusText = isEnabled ? '启用' : '禁用';
+ const statusClass = isEnabled ? 'bg-success' : 'bg-warning';
+
+ badge.innerHTML = `
+
+ ${statusIcon} ${accountId}
+
+
+ 状态: ${statusText}
+ ${!isEnabled ? ' (配置的关键词不会参与自动回复)' : ''}
+
+ `;
+}
+
+// 显示添加关键词表单
+function showAddKeywordForm() {
+ const form = document.getElementById('addKeywordForm');
+ form.style.display = form.style.display === 'none' ? 'block' : 'none';
+
+ if (form.style.display === 'block') {
+ document.getElementById('newKeyword').focus();
+ }
+}
+
+// 加载商品列表
+async function loadItemsList(accountId) {
+ try {
+ const response = await fetch(`${apiBase}/items/${accountId}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ const items = data.items || [];
+
+ // 更新商品选择下拉框
+ const selectElement = document.getElementById('newItemIdSelect');
+ if (selectElement) {
+ // 清空现有选项(保留第一个默认选项)
+ selectElement.innerHTML = '';
+
+ // 添加商品选项
+ items.forEach(item => {
+ const option = document.createElement('option');
+ option.value = item.item_id;
+ option.textContent = `${item.item_id} - ${item.item_title}`;
+ selectElement.appendChild(option);
+ });
+ }
+
+ console.log(`加载了 ${items.length} 个商品到选择列表`);
+ } else {
+ console.warn('加载商品列表失败:', response.status);
+ }
+ } catch (error) {
+ console.error('加载商品列表时发生错误:', error);
+ }
+}
+
+
+
+// 添加或更新关键词
+async function addKeyword() {
+ const keyword = document.getElementById('newKeyword').value.trim();
+ const reply = document.getElementById('newReply').value.trim();
+ const itemId = document.getElementById('newItemIdSelect').value.trim();
+
+ if (!keyword) {
+ showToast('请填写关键词', 'warning');
+ return;
+ }
+
+ if (!currentCookieId) {
+ showToast('请先选择账号', 'warning');
+ return;
+ }
+
+ // 检查是否为编辑模式
+ const isEditMode = typeof window.editingIndex !== 'undefined';
+ const actionText = isEditMode ? '更新' : '添加';
+
+ try {
+ toggleLoading(true);
+
+ // 获取当前关键词列表
+ let currentKeywords = [...(keywordsData[currentCookieId] || [])];
+
+ // 如果是编辑模式,先移除原关键词
+ if (isEditMode) {
+ currentKeywords.splice(window.editingIndex, 1);
+ }
+
+ // 准备要保存的关键词列表(只包含文本类型的关键字)
+ let textKeywords = currentKeywords.filter(item => (item.type || 'text') === 'text');
+
+ // 如果是编辑模式,先移除原关键词
+ if (isEditMode && typeof window.editingIndex !== 'undefined') {
+ // 需要重新计算在文本关键字中的索引
+ const originalKeyword = keywordsData[currentCookieId][window.editingIndex];
+ const textIndex = textKeywords.findIndex(item =>
+ item.keyword === originalKeyword.keyword &&
+ (item.item_id || '') === (originalKeyword.item_id || '')
+ );
+ if (textIndex !== -1) {
+ textKeywords.splice(textIndex, 1);
+ }
+ }
+
+ // 检查关键词是否已存在(考虑商品ID,检查所有类型的关键词)
+ const allKeywords = keywordsData[currentCookieId] || [];
+ const existingKeyword = allKeywords.find(item =>
+ item.keyword === keyword &&
+ (item.item_id || '') === (itemId || '')
+ );
+ if (existingKeyword) {
+ const itemIdText = itemId ? `(商品ID: ${itemId})` : '(通用关键词)';
+ const typeText = existingKeyword.type === 'image' ? '图片' : '文本';
+ showToast(`关键词 "${keyword}" ${itemIdText} 已存在(${typeText}关键词),请使用其他关键词或商品ID`, 'warning');
+ toggleLoading(false);
+ return;
+ }
+
+ // 添加新关键词或更新的关键词
+ const newKeyword = {
+ keyword: keyword,
+ reply: reply,
+ item_id: itemId || ''
+ };
+ textKeywords.push(newKeyword);
+
+ const response = await fetch(`${apiBase}/keywords-with-item-id/${currentCookieId}`, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify({
+ keywords: textKeywords
+ })
+ });
+
+ if (response.ok) {
+ showToast(`✨ 关键词 "${keyword}" ${actionText}成功!`, 'success');
+
+ // 清空输入框并重置样式
+ const keywordInput = document.getElementById('newKeyword');
+ const replyInput = document.getElementById('newReply');
+ const selectElement = document.getElementById('newItemIdSelect');
+ const addBtn = document.querySelector('.add-btn');
+
+ keywordInput.value = '';
+ replyInput.value = '';
+ if (selectElement) {
+ selectElement.value = '';
+ }
+ keywordInput.style.borderColor = '#e5e7eb';
+ replyInput.style.borderColor = '#e5e7eb';
+ addBtn.style.opacity = '0.7';
+ addBtn.style.transform = 'scale(0.95)';
+
+ // 如果是编辑模式,重置编辑状态
+ if (isEditMode) {
+ delete window.editingIndex;
+ delete window.originalKeyword;
+
+ // 恢复添加按钮
+ addBtn.innerHTML = '添加';
+ addBtn.style.background = 'linear-gradient(135deg, #10b981 0%, #059669 100%)';
+
+ // 移除取消按钮
+ const cancelBtn = document.getElementById('cancelEditBtn');
+ if (cancelBtn) {
+ cancelBtn.remove();
+ }
+ }
+
+ // 聚焦到关键词输入框,方便连续添加
+ setTimeout(() => {
+ keywordInput.focus();
+ }, 100);
+
+ // 只刷新关键词列表,不重新加载整个界面
+ await refreshKeywordsList();
+ } else {
+ try {
+ const errorData = await response.json();
+ const errorMessage = errorData.detail || '关键词添加失败';
+ console.error('关键词添加失败:', errorMessage);
+
+ // 检查是否是重复关键词的错误
+ if (errorMessage.includes('关键词已存在') || errorMessage.includes('关键词重复') || errorMessage.includes('UNIQUE constraint')) {
+ showToast(`❌ 关键词重复:${errorMessage}`, 'warning');
+ } else {
+ showToast(`❌ ${errorMessage}`, 'danger');
+ }
+ } catch (parseError) {
+ // 如果无法解析JSON,使用原始文本
+ const errorText = await response.text();
+ console.error('关键词添加失败:', errorText);
+ showToast('❌ 关键词添加失败', 'danger');
+ }
+ }
+ } catch (error) {
+ console.error('添加关键词失败:', error);
+ showToast('添加关键词失败', 'danger');
+ } finally {
+ toggleLoading(false);
+ }
+}
+
+// 渲染现代化关键词列表
+function renderKeywordsList(keywords) {
+ console.log('渲染关键词列表:', keywords); // 调试信息
+ const container = document.getElementById('keywordsList');
+
+ if (!container) {
+ console.error('找不到关键词列表容器元素');
+ return;
+ }
+
+ container.innerHTML = '';
+
+ if (!keywords || keywords.length === 0) {
+ console.log('关键词列表为空,显示空状态');
+ container.innerHTML = `
+
+
+
还没有关键词
+
添加第一个关键词,让您的闲鱼店铺自动回复客户消息
+
+
+ `;
+ return;
+ }
+
+ console.log(`开始渲染 ${keywords.length} 个关键词`);
+
+ keywords.forEach((item, index) => {
+ console.log(`渲染关键词 ${index + 1}:`, item); // 调试信息
+
+ const keywordItem = document.createElement('div');
+ keywordItem.className = 'keyword-item';
+
+ // 判断关键词类型
+ const keywordType = item.type || 'text'; // 默认为文本类型
+ const isImageType = keywordType === 'image';
+
+ // 类型标识
+ const typeBadge = isImageType ?
+ ' 图片' :
+ ' 文本';
+
+ // 商品ID显示
+ const itemIdDisplay = item.item_id ?
+ ` 商品ID: ${item.item_id}` :
+ ' 通用关键词';
+
+ // 内容显示
+ let contentDisplay = '';
+ if (isImageType) {
+ // 图片类型显示图片预览
+ const imageUrl = item.reply || item.image_url || '';
+ contentDisplay = imageUrl ?
+ `
+

+
+
用户发送关键词时将回复此图片
+
点击图片查看大图
+
+
` :
+ '图片加载失败
';
+ } else {
+ // 文本类型显示文本内容
+ contentDisplay = `${item.reply || ''}
`;
+ }
+
+ keywordItem.innerHTML = `
+
+
+ ${contentDisplay}
+
+ `;
+ container.appendChild(keywordItem);
+ });
+
+ console.log('关键词列表渲染完成');
+}
+
+// 聚焦到关键词输入框
+function focusKeywordInput() {
+ document.getElementById('newKeyword').focus();
+}
+
+// 编辑关键词 - 改进版本
+function editKeyword(index) {
+ const keywords = keywordsData[currentCookieId] || [];
+ const keyword = keywords[index];
+
+ if (!keyword) {
+ showToast('关键词不存在', 'warning');
+ return;
+ }
+
+ // 将关键词信息填入输入框
+ document.getElementById('newKeyword').value = keyword.keyword;
+ document.getElementById('newReply').value = keyword.reply;
+
+ // 设置商品ID选择框
+ const selectElement = document.getElementById('newItemIdSelect');
+ if (selectElement) {
+ selectElement.value = keyword.item_id || '';
+ }
+
+ // 设置编辑模式标识
+ window.editingIndex = index;
+ window.originalKeyword = keyword.keyword;
+ window.originalItemId = keyword.item_id || '';
+
+ // 更新按钮文本和样式
+ const addBtn = document.querySelector('.add-btn');
+ addBtn.innerHTML = '更新';
+ addBtn.style.background = 'linear-gradient(135deg, #f59e0b 0%, #d97706 100%)';
+
+ // 显示取消按钮
+ showCancelEditButton();
+
+ // 聚焦到关键词输入框并选中文本
+ setTimeout(() => {
+ const keywordInput = document.getElementById('newKeyword');
+ keywordInput.focus();
+ keywordInput.select();
+ }, 100);
+
+ showToast('📝 编辑模式:修改后点击"更新"按钮保存', 'info');
+}
+
+// 显示取消编辑按钮
+function showCancelEditButton() {
+ // 检查是否已存在取消按钮
+ if (document.getElementById('cancelEditBtn')) {
+ return;
+ }
+
+ const addBtn = document.querySelector('.add-btn');
+ const cancelBtn = document.createElement('button');
+ cancelBtn.id = 'cancelEditBtn';
+ cancelBtn.className = 'btn btn-outline-secondary';
+ cancelBtn.style.marginLeft = '0.5rem';
+ cancelBtn.innerHTML = '取消';
+ cancelBtn.onclick = cancelEdit;
+
+ addBtn.parentNode.appendChild(cancelBtn);
+}
+
+// 取消编辑
+function cancelEdit() {
+ // 清空输入框
+ document.getElementById('newKeyword').value = '';
+ document.getElementById('newReply').value = '';
+
+ // 清空商品ID选择框
+ const selectElement = document.getElementById('newItemIdSelect');
+ if (selectElement) {
+ selectElement.value = '';
+ }
+
+ // 重置编辑状态
+ delete window.editingIndex;
+ delete window.originalKeyword;
+ delete window.originalItemId;
+
+ // 恢复添加按钮
+ const addBtn = document.querySelector('.add-btn');
+ addBtn.innerHTML = '添加';
+ addBtn.style.background = 'linear-gradient(135deg, #10b981 0%, #059669 100%)';
+
+ // 移除取消按钮
+ const cancelBtn = document.getElementById('cancelEditBtn');
+ if (cancelBtn) {
+ cancelBtn.remove();
+ }
+
+ showToast('已取消编辑', 'info');
+}
+
+// 删除关键词
+async function deleteKeyword(cookieId, index) {
+ if (!confirm('确定要删除这个关键词吗?')) {
+ return;
+ }
+
+ try {
+ toggleLoading(true);
+
+ // 使用新的删除API
+ const response = await fetch(`${apiBase}/keywords/${cookieId}/${index}`, {
+ method: 'DELETE',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ showToast('关键词删除成功', 'success');
+ // 只刷新关键词列表,不重新加载整个界面
+ await refreshKeywordsList();
+ } else {
+ const errorText = await response.text();
+ console.error('关键词删除失败:', errorText);
+ showToast('关键词删除失败', 'danger');
+ }
+ } catch (error) {
+ console.error('删除关键词失败:', error);
+ showToast('删除关键词删除失败', 'danger');
+ } finally {
+ toggleLoading(false);
+ }
+}
+
+// 显示/隐藏加载动画
+function toggleLoading(show) {
+ document.getElementById('loading').classList.toggle('d-none', !show);
+}
+
+// ================================
+// 通用工具函数
+// ================================
+
+// 显示提示消息
+function showToast(message, type = 'success') {
+ const toastContainer = document.querySelector('.toast-container');
+ const toast = document.createElement('div');
+ toast.className = `toast align-items-center text-white bg-${type} border-0`;
+ toast.setAttribute('role', 'alert');
+ toast.setAttribute('aria-live', 'assertive');
+ toast.setAttribute('aria-atomic', 'true');
+
+ toast.innerHTML = `
+
+ `;
+
+ toastContainer.appendChild(toast);
+ const bsToast = new bootstrap.Toast(toast, { delay: 3000 });
+ bsToast.show();
+
+ // 自动移除
+ toast.addEventListener('hidden.bs.toast', () => {
+ toast.remove();
+ });
+}
+
+// 错误处理
+async function handleApiError(err) {
+ console.error(err);
+ showToast(err.message || '操作失败', 'danger');
+ toggleLoading(false);
+}
+
+// API请求包装
+async function fetchJSON(url, opts = {}) {
+ toggleLoading(true);
+ try {
+ // 添加认证头
+ if (authToken) {
+ opts.headers = opts.headers || {};
+ opts.headers['Authorization'] = `Bearer ${authToken}`;
+ }
+
+ const res = await fetch(url, opts);
+ if (res.status === 401) {
+ // 未授权,跳转到登录页面
+ localStorage.removeItem('auth_token');
+ window.location.href = '/';
+ return;
+ }
+ if (!res.ok) {
+ let errorMessage = `HTTP ${res.status}`;
+ try {
+ const errorText = await res.text();
+ if (errorText) {
+ // 尝试解析JSON错误信息
+ try {
+ const errorJson = JSON.parse(errorText);
+ errorMessage = errorJson.detail || errorJson.message || errorText;
+ } catch {
+ errorMessage = errorText;
+ }
+ }
+ } catch {
+ errorMessage = `HTTP ${res.status} ${res.statusText}`;
+ }
+ throw new Error(errorMessage);
+ }
+ const data = await res.json();
+ toggleLoading(false);
+ return data;
+ } catch (err) {
+ handleApiError(err);
+ throw err;
+ }
+}
+
+// ================================
+// 【账号管理菜单】相关功能
+// ================================
+
+// 加载Cookie列表
+async function loadCookies() {
+ try {
+ toggleLoading(true);
+ const tbody = document.querySelector('#cookieTable tbody');
+ tbody.innerHTML = '';
+
+ const cookieDetails = await fetchJSON(apiBase + '/cookies/details');
+
+ if (cookieDetails.length === 0) {
+ tbody.innerHTML = `
+
+
+
+ 暂无账号
+ 请添加新的闲鱼账号开始使用
+ |
+
+ `;
+ return;
+ }
+
+ // 获取在线状态
+ let onlineStatusMap = {};
+ try {
+ const statusResp = await fetch(`${apiBase}/cookies/online-status`, {
+ headers: { 'Authorization': `Bearer ${authToken}` }
+ });
+ if (statusResp.ok) {
+ const statusData = await statusResp.json();
+ onlineStatusMap = statusData.status || {};
+ }
+ } catch (e) {}
+
+ // 为每个账号获取关键词数量和默认回复设置并渲染
+ const accountsWithKeywords = await Promise.all(
+ cookieDetails.map(async (cookie) => {
+ try {
+ // 获取关键词数量
+ const keywordsResponse = await fetch(`${apiBase}/keywords/${cookie.id}`, {
+ headers: { 'Authorization': `Bearer ${authToken}` }
+ });
+
+ let keywordCount = 0;
+ if (keywordsResponse.ok) {
+ const keywordsData = await keywordsResponse.json();
+ keywordCount = keywordsData.length;
+ }
+
+ // 获取默认回复设置
+ const defaultReplyResponse = await fetch(`${apiBase}/default-replies/${cookie.id}`, {
+ headers: { 'Authorization': `Bearer ${authToken}` }
+ });
+
+ let defaultReply = { enabled: false, reply_content: '' };
+ if (defaultReplyResponse.ok) {
+ defaultReply = await defaultReplyResponse.json();
+ }
+
+ // 获取AI回复设置
+ const aiReplyResponse = await fetch(`${apiBase}/ai-reply-settings/${cookie.id}`, {
+ headers: { 'Authorization': `Bearer ${authToken}` }
+ });
+
+ let aiReply = { ai_enabled: false, model_name: 'qwen-plus' };
+ if (aiReplyResponse.ok) {
+ aiReply = await aiReplyResponse.json();
+ }
+
+ return {
+ ...cookie,
+ keywordCount: keywordCount,
+ defaultReply: defaultReply,
+ aiReply: aiReply
+ };
+ } catch (error) {
+ return {
+ ...cookie,
+ keywordCount: 0,
+ defaultReply: { enabled: false, reply_content: '' },
+ aiReply: { ai_enabled: false, model_name: 'qwen-plus' }
+ };
+ }
+ })
+ );
+
+ accountsWithKeywords.forEach(cookie => {
+ // 使用数据库中的实际状态,默认为启用
+ const isEnabled = cookie.enabled === undefined ? true : cookie.enabled;
+
+ // 获取在线状态
+ const onlineInfo = onlineStatusMap[cookie.id] || {};
+ const connStatus = onlineInfo.status || (isEnabled ? 'unknown' : 'disabled');
+ const isOnline = connStatus === 'online';
+
+ // 在线状态标签
+ let statusLabel = '';
+ if (!isEnabled) {
+ statusLabel = '已禁用';
+ } else if (isOnline) {
+ statusLabel = '在线';
+ } else {
+ statusLabel = '离线';
+ }
+
+ console.log(`账号 ${cookie.id} 状态: enabled=${cookie.enabled}, isEnabled=${isEnabled}, online=${isOnline}`);
+
+ const tr = document.createElement('tr');
+ tr.className = `account-row ${isEnabled ? 'enabled' : 'disabled'}`;
+ if (!isOnline && isEnabled) {
+ tr.style.background = '#fff5f5';
+ }
+ // 默认回复状态标签
+ const defaultReplyBadge = cookie.defaultReply.enabled ?
+ '启用' :
+ '禁用';
+
+ // AI回复状态标签
+ const aiReplyBadge = cookie.aiReply.ai_enabled ?
+ 'AI启用' :
+ 'AI禁用';
+
+ // 自动确认发货状态(默认开启)
+ const autoConfirm = cookie.auto_confirm === undefined ? true : cookie.auto_confirm;
+
+ // 构建用户信息显示
+ const nickname = cookie.nickname || '';
+ const avatarUrl = cookie.avatar_url || '';
+ const userInfoHtml = `
+
+ ${avatarUrl ?
+ `

+
+
+
` :
+ `
+
+
`
+ }
+
+ ${nickname || '未知用户'}
+ ${cookie.id}
+
+
+ `;
+
+ tr.innerHTML = `
+
+ ${userInfoHtml}
+ |
+
+
+ ${cookie.id}
+
+ |
+
+
+ ${cookie.value || '未设置'}
+
+ |
+
+
+ ${cookie.keywordCount} 个关键词
+
+ |
+
+
+
+
+
+
+
+
+ ${statusLabel}
+
+ |
+
+ ${defaultReplyBadge}
+ |
+
+ ${aiReplyBadge}
+ |
+
+
+
+
+
+
+
+ |
+
+
+ |
+
+
+
+ ${cookie.pause_duration || 10}分钟
+
+
+ |
+
+ ${cookie.created_at ? formatDateTime(cookie.created_at) : '-'}
+ |
+
+ ${cookie.expire_hours_left !== null && cookie.expire_hours_left !== undefined ?
+ `
+
+ ${cookie.expire_hours_left > 0 ? cookie.expire_hours_left + '小时' : '已过期'}
+
+ ${cookie.expire_at ? `${cookie.expire_at}` : ''}
+ ` :
+ '-'
+ }
+ |
+
+
+
+
+
+
+
+
+ |
+ `;
+ tbody.appendChild(tr);
+ });
+
+ // 为Cookie值添加点击复制功能
+ document.querySelectorAll('.cookie-value').forEach(element => {
+ element.style.cursor = 'pointer';
+ element.addEventListener('click', function() {
+ const cookieValue = this.textContent;
+ if (cookieValue && cookieValue !== '未设置') {
+ navigator.clipboard.writeText(cookieValue).then(() => {
+ showToast('Cookie已复制到剪贴板', 'success');
+ }).catch(() => {
+ showToast('复制失败,请手动复制', 'error');
+ });
+ }
+ });
+ });
+
+ // 重新初始化工具提示
+ initTooltips();
+
+ } catch (err) {
+ // 错误已在fetchJSON中处理
+ } finally {
+ toggleLoading(false);
+ }
+}
+
+// 复制Cookie
+function copyCookie(id, value) {
+ if (!value || value === '未设置') {
+ showToast('该账号暂无Cookie值', 'warning');
+ return;
+ }
+
+ navigator.clipboard.writeText(value).then(() => {
+ showToast(`账号 "${id}" 的Cookie已复制到剪贴板`, 'success');
+ }).catch(() => {
+ // 降级方案:创建临时文本框
+ const textArea = document.createElement('textarea');
+ textArea.value = value;
+ document.body.appendChild(textArea);
+ textArea.select();
+ try {
+ document.execCommand('copy');
+ showToast(`账号 "${id}" 的Cookie已复制到剪贴板`, 'success');
+ } catch (err) {
+ showToast('复制失败,请手动复制', 'error');
+ }
+ document.body.removeChild(textArea);
+ });
+}
+
+// 删除Cookie
+async function delCookie(id) {
+ if (!confirm(`确定要删除账号 "${id}" 吗?此操作不可恢复。`)) return;
+
+ try {
+ await fetchJSON(apiBase + `/cookies/${id}`, { method: 'DELETE' });
+ showToast(`账号 "${id}" 已删除`, 'success');
+ loadCookies();
+ } catch (err) {
+ // 错误已在fetchJSON中处理
+ }
+}
+
+// 内联编辑Cookie
+function editCookieInline(id, currentValue) {
+ const row = event.target.closest('tr');
+ const cookieValueCell = row.querySelector('.cookie-value');
+ const originalContent = cookieValueCell.innerHTML;
+
+ // 存储原始数据到全局变量,避免HTML注入问题
+ window.editingCookieData = {
+ id: id,
+ originalContent: originalContent,
+ originalValue: currentValue || ''
+ };
+
+ // 创建编辑界面容器
+ const editContainer = document.createElement('div');
+ editContainer.className = 'd-flex gap-2';
+
+ // 创建输入框
+ const input = document.createElement('input');
+ input.type = 'text';
+ input.className = 'form-control form-control-sm';
+ input.id = `edit-${id}`;
+ input.value = currentValue || '';
+ input.placeholder = '输入新的Cookie值';
+
+ // 创建保存按钮
+ const saveBtn = document.createElement('button');
+ saveBtn.className = 'btn btn-sm btn-success';
+ saveBtn.title = '保存';
+ saveBtn.innerHTML = '';
+ saveBtn.onclick = () => saveCookieInline(id);
+
+ // 创建取消按钮
+ const cancelBtn = document.createElement('button');
+ cancelBtn.className = 'btn btn-sm btn-secondary';
+ cancelBtn.title = '取消';
+ cancelBtn.innerHTML = '';
+ cancelBtn.onclick = () => cancelCookieEdit(id);
+
+ // 组装编辑界面
+ editContainer.appendChild(input);
+ editContainer.appendChild(saveBtn);
+ editContainer.appendChild(cancelBtn);
+
+ // 替换原内容
+ cookieValueCell.innerHTML = '';
+ cookieValueCell.appendChild(editContainer);
+
+ // 聚焦输入框
+ input.focus();
+ input.select();
+
+ // 添加键盘事件监听
+ input.addEventListener('keydown', function(e) {
+ if (e.key === 'Enter') {
+ e.preventDefault();
+ saveCookieInline(id);
+ } else if (e.key === 'Escape') {
+ e.preventDefault();
+ cancelCookieEdit(id);
+ }
+ });
+
+ // 禁用该行的其他按钮
+ const actionButtons = row.querySelectorAll('.btn-group button');
+ actionButtons.forEach(btn => btn.disabled = true);
+}
+
+// 保存内联编辑的Cookie
+async function saveCookieInline(id) {
+ const input = document.getElementById(`edit-${id}`);
+ const newValue = input.value.trim();
+
+ if (!newValue) {
+ showToast('Cookie值不能为空', 'warning');
+ return;
+ }
+
+ try {
+ toggleLoading(true);
+
+ await fetchJSON(apiBase + `/cookies/${id}`, {
+ method: 'PUT',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({
+ id: id,
+ value: newValue
+ })
+ });
+
+ showToast(`账号 "${id}" Cookie已更新`, 'success');
+ loadCookies(); // 重新加载列表
+
+ } catch (err) {
+ console.error('Cookie更新失败:', err);
+ showToast(`Cookie更新失败: ${err.message || '未知错误'}`, 'danger');
+ // 恢复原内容
+ cancelCookieEdit(id);
+ } finally {
+ toggleLoading(false);
+ }
+}
+
+// 取消Cookie编辑
+function cancelCookieEdit(id) {
+ if (!window.editingCookieData || window.editingCookieData.id !== id) {
+ console.error('编辑数据不存在');
+ return;
+ }
+
+ const row = document.querySelector(`#edit-${id}`).closest('tr');
+ const cookieValueCell = row.querySelector('.cookie-value');
+
+ // 恢复原内容
+ cookieValueCell.innerHTML = window.editingCookieData.originalContent;
+
+ // 恢复按钮状态
+ const actionButtons = row.querySelectorAll('.btn-group button');
+ actionButtons.forEach(btn => btn.disabled = false);
+
+ // 清理全局数据
+ delete window.editingCookieData;
+}
+
+
+
+// 切换账号启用/禁用状态
+async function toggleAccountStatus(accountId, enabled) {
+ try {
+ toggleLoading(true);
+
+ // 这里需要调用后端API来更新账号状态
+ // 由于当前后端可能没有enabled字段,我们先在前端模拟
+ // 实际项目中需要后端支持
+
+ const response = await fetch(`${apiBase}/cookies/${accountId}/status`, {
+ method: 'PUT',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify({ enabled: enabled })
+ });
+
+ if (response.ok) {
+ showToast(`账号 "${accountId}" 已${enabled ? '启用' : '禁用'}`, 'success');
+
+ // 清除相关缓存,确保数据一致性
+ clearKeywordCache();
+
+ // 更新界面显示
+ updateAccountRowStatus(accountId, enabled);
+
+ // 同时更新在线状态显示
+ prevOnlineStatus[accountId] = enabled ? 'offline' : 'disabled';
+
+ // 刷新自动回复页面的账号列表
+ refreshAccountList();
+
+ // 如果禁用的账号在自动回复页面被选中,更新显示
+ const accountSelect = document.getElementById('accountSelect');
+ if (accountSelect && accountSelect.value === accountId) {
+ if (!enabled) {
+ // 更新徽章显示禁用状态
+ updateAccountBadge(accountId, false);
+ showToast('账号已禁用,配置的关键词不会参与自动回复', 'warning');
+ } else {
+ // 更新徽章显示启用状态
+ updateAccountBadge(accountId, true);
+ showToast('账号已启用,配置的关键词将参与自动回复', 'success');
+ }
+ }
+
+ } else {
+ // 如果后端不支持,先在前端模拟
+ console.warn('后端暂不支持账号状态切换,使用前端模拟');
+ showToast(`账号 "${accountId}" 已${enabled ? '启用' : '禁用'} (前端模拟)`, enabled ? 'success' : 'warning');
+ updateAccountRowStatus(accountId, enabled);
+ }
+
+ } catch (error) {
+ console.error('切换账号状态失败:', error);
+
+ // 后端不支持时的降级处理
+ showToast(`账号 "${accountId}" 已${enabled ? '启用' : '禁用'} (本地模拟)`, enabled ? 'success' : 'warning');
+ updateAccountRowStatus(accountId, enabled);
+
+ // 恢复切换按钮状态
+ const toggle = document.querySelector(`input[onchange*="${accountId}"]`);
+ if (toggle) {
+ toggle.checked = enabled;
+ }
+ } finally {
+ toggleLoading(false);
+ }
+}
+
+// 更新账号行的状态显示
+function updateAccountRowStatus(accountId, enabled) {
+ const toggle = document.querySelector(`input[onchange*="${accountId}"]`);
+ if (!toggle) return;
+
+ const row = toggle.closest('tr');
+ const statusBadge = row.querySelector('.status-badge');
+ const actionButtons = row.querySelectorAll('.btn-group .btn:not(.btn-outline-info):not(.btn-outline-danger)');
+
+ // 更新行样式
+ row.className = `account-row ${enabled ? 'enabled' : 'disabled'}`;
+
+ // 更新状态徽章
+ statusBadge.className = `status-badge ${enabled ? 'enabled' : 'disabled'}`;
+ statusBadge.title = enabled ? '账号已启用' : '账号已禁用';
+ statusBadge.innerHTML = `
+
+ `;
+
+ // 更新按钮状态(只禁用编辑Cookie按钮,其他按钮保持可用)
+ actionButtons.forEach(btn => {
+ if (btn.onclick && btn.onclick.toString().includes('editCookieInline')) {
+ btn.disabled = !enabled;
+ }
+ // 设置自动回复按钮始终可用,但更新提示文本
+ if (btn.onclick && btn.onclick.toString().includes('goToAutoReply')) {
+ btn.title = enabled ? '设置自动回复' : '配置关键词 (账号已禁用)';
+ }
+ });
+
+ // 更新切换按钮的提示
+ const label = toggle.closest('.status-toggle');
+ label.title = enabled ? '点击禁用' : '点击启用';
+}
+
+// 切换自动确认发货状态
+async function toggleAutoConfirm(accountId, enabled) {
+ try {
+ toggleLoading(true);
+
+ const response = await fetch(`${apiBase}/cookies/${accountId}/auto-confirm`, {
+ method: 'PUT',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify({ auto_confirm: enabled })
+ });
+
+ if (response.ok) {
+ const result = await response.json();
+ showToast(result.message, 'success');
+
+ // 更新界面显示
+ updateAutoConfirmRowStatus(accountId, enabled);
+ } else {
+ const error = await response.json();
+ showToast(error.detail || '更新自动确认发货设置失败', 'error');
+
+ // 恢复切换按钮状态
+ const toggle = document.querySelector(`input[onchange*="toggleAutoConfirm('${accountId}'"]`);
+ if (toggle) {
+ toggle.checked = !enabled;
+ }
+ }
+
+ } catch (error) {
+ console.error('切换自动确认发货状态失败:', error);
+ showToast('网络错误,请稍后重试', 'error');
+
+ // 恢复切换按钮状态
+ const toggle = document.querySelector(`input[onchange*="toggleAutoConfirm('${accountId}'"]`);
+ if (toggle) {
+ toggle.checked = !enabled;
+ }
+ } finally {
+ toggleLoading(false);
+ }
+}
+
+// 更新自动确认发货行状态
+function updateAutoConfirmRowStatus(accountId, enabled) {
+ const row = document.querySelector(`tr:has(input[onchange*="toggleAutoConfirm('${accountId}'"])`);
+ if (!row) return;
+
+ const statusBadge = row.querySelector('.status-badge:has(i.bi-truck, i.bi-truck-flatbed)');
+ const toggle = row.querySelector(`input[onchange*="toggleAutoConfirm('${accountId}'"]`);
+
+ if (statusBadge && toggle) {
+ // 更新状态徽章
+ statusBadge.className = `status-badge ${enabled ? 'enabled' : 'disabled'}`;
+ statusBadge.title = enabled ? '自动确认发货已开启' : '自动确认发货已关闭';
+ statusBadge.innerHTML = `
+
+ `;
+
+ // 更新切换按钮的提示
+ const label = toggle.closest('.status-toggle');
+ label.title = enabled ? '点击关闭自动确认发货' : '点击开启自动确认发货';
+ }
+}
+
+// 跳转到自动回复页面并选择指定账号
+function goToAutoReply(accountId) {
+ // 切换到自动回复页面
+ showSection('auto-reply');
+
+ // 设置账号选择器的值
+ setTimeout(() => {
+ const accountSelect = document.getElementById('accountSelect');
+ if (accountSelect) {
+ accountSelect.value = accountId;
+ // 触发change事件来加载关键词
+ loadAccountKeywords();
+ }
+ }, 100);
+
+ showToast(`已切换到自动回复页面,账号 "${accountId}" 已选中`, 'info');
+}
+
+
+
+
+
+// 登出功能
+async function logout() {
+ try {
+ if (authToken) {
+ await fetch('/logout', {
+ method: 'POST',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+ }
+ localStorage.removeItem('auth_token');
+ window.location.href = '/';
+ } catch (err) {
+ console.error('登出失败:', err);
+ localStorage.removeItem('auth_token');
+ window.location.href = '/';
+ }
+}
+
+// 检查认证状态
+async function checkAuth() {
+ if (!authToken) {
+ window.location.href = '/';
+ return false;
+ }
+
+ try {
+ const response = await fetch('/verify', {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+ const result = await response.json();
+
+ if (!result.authenticated) {
+ localStorage.removeItem('auth_token');
+ window.location.href = '/';
+ return false;
+ }
+
+ // 检查是否为管理员,显示管理员菜单和功能
+ if (result.is_admin === true) {
+ const adminMenuSection = document.getElementById('adminMenuSection');
+ if (adminMenuSection) {
+ adminMenuSection.style.display = 'block';
+ }
+
+ // 显示备份管理功能
+ const backupManagement = document.getElementById('backup-management');
+ if (backupManagement) {
+ backupManagement.style.display = 'block';
+ }
+
+ // 显示注册设置功能
+ const registrationSettings = document.getElementById('registration-settings');
+ if (registrationSettings) {
+ registrationSettings.style.display = 'block';
+ }
+ }
+
+ return true;
+ } catch (err) {
+ localStorage.removeItem('auth_token');
+ window.location.href = '/';
+ return false;
+ }
+}
+
+// ================================
+// Cookie 在线状态轮询监控
+// ================================
+let cookieMonitorInterval = null;
+let prevOnlineStatus = {};
+
+function startCookieMonitor() {
+ if (cookieMonitorInterval) return;
+ // 每30秒检查一次Cookie在线状态
+ cookieMonitorInterval = setInterval(async () => {
+ try {
+ const resp = await fetch(`${apiBase}/cookies/online-status`, {
+ headers: { 'Authorization': `Bearer ${authToken}` }
+ });
+ if (!resp.ok) return;
+ const data = await resp.json();
+ const status = data.status || {};
+
+ for (const [cookieId, info] of Object.entries(status)) {
+ const prev = prevOnlineStatus[cookieId];
+ const curr = info.status;
+
+ // 从在线变为离线,触发通知
+ if (prev === 'online' && curr === 'offline') {
+ showToast(`账号 "${cookieId}" 已离线,请重新扫码登录`, 'warning');
+ // 尝试发送浏览器通知
+ if ('Notification' in window && Notification.permission === 'granted') {
+ new Notification('闲鱼账号离线', {
+ body: `账号 "${cookieId}" 连接已断开,请及时重新登录`,
+ icon: '/favicon.ico'
+ });
+ }
+ }
+ prevOnlineStatus[cookieId] = curr;
+ }
+
+ // 如果当前在账号管理页面,刷新在线状态显示(免刷新列表)
+ const accountsSection = document.getElementById('accounts-section');
+ if (accountsSection && accountsSection.classList.contains('active')) {
+ const statusResp = await fetch(`${apiBase}/cookies/online-status`, {
+ headers: { 'Authorization': `Bearer ${authToken}` }
+ });
+ if (statusResp.ok) {
+ const sd = await statusResp.json();
+ const stMap = sd.status || {};
+ document.querySelectorAll('#cookieTable tbody tr').forEach(row => {
+ const idEl = row.querySelector('.cookie-id strong');
+ if (!idEl) return;
+ const cid = idEl.textContent.trim();
+ const info = stMap[cid] || {};
+ const isOnline = info.status === 'online';
+ const isEnabled = info.status !== 'disabled';
+ if (!isEnabled) return;
+ const existingBadge = row.querySelector('.online-status-badge');
+ if (existingBadge) {
+ existingBadge.className = `badge online-status-badge ${isOnline ? 'bg-success' : 'bg-danger'}`;
+ existingBadge.innerHTML = isOnline ? '在线' : '离线';
+ }
+ if (!isOnline) {
+ row.style.background = '#fff5f5';
+ } else {
+ row.style.background = '';
+ }
+ });
+ }
+ }
+ } catch (e) {}
+ }, 30000);
+
+ // 请求浏览器通知权限
+ if ('Notification' in window && Notification.permission === 'default') {
+ Notification.requestPermission();
+ }
+}
+
+// 初始化事件监听
+document.addEventListener('DOMContentLoaded', async () => {
+ // 首先检查认证状态
+ const isAuthenticated = await checkAuth();
+ if (!isAuthenticated) return;
+ // 添加Cookie表单提交
+ document.getElementById('addForm').addEventListener('submit', async (e) => {
+ e.preventDefault();
+ const id = document.getElementById('cookieId').value.trim();
+ const value = document.getElementById('cookieValue').value.trim();
+
+ if (!id || !value) return;
+
+ try {
+ await fetchJSON(apiBase + '/cookies', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ id, value })
+ });
+
+ document.getElementById('cookieId').value = '';
+ document.getElementById('cookieValue').value = '';
+ showToast(`账号 "${id}" 添加成功`);
+ loadCookies();
+ } catch (err) {
+ // 错误已在fetchJSON中处理
+ }
+ });
+
+ // 增强的键盘快捷键和用户体验
+ document.getElementById('newKeyword')?.addEventListener('keypress', function(e) {
+ if (e.key === 'Enter') {
+ e.preventDefault();
+ document.getElementById('newReply').focus();
+ }
+ });
+
+ document.getElementById('newReply')?.addEventListener('keypress', function(e) {
+ if (e.key === 'Enter') {
+ e.preventDefault();
+ addKeyword();
+ }
+ });
+
+ // ESC键取消编辑
+ document.addEventListener('keydown', function(e) {
+ if (e.key === 'Escape' && typeof window.editingIndex !== 'undefined') {
+ e.preventDefault();
+ cancelEdit();
+ }
+ });
+
+ // 输入框实时验证和提示
+ document.getElementById('newKeyword')?.addEventListener('input', function(e) {
+ const value = e.target.value.trim();
+ const addBtn = document.querySelector('.add-btn');
+ const replyInput = document.getElementById('newReply');
+
+ if (value.length > 0) {
+ e.target.style.borderColor = '#10b981';
+ // 只要关键词有内容就可以添加,不需要回复内容
+ addBtn.style.opacity = '1';
+ addBtn.style.transform = 'scale(1)';
+ } else {
+ e.target.style.borderColor = '#e5e7eb';
+ addBtn.style.opacity = '0.7';
+ addBtn.style.transform = 'scale(0.95)';
+ }
+ });
+
+ document.getElementById('newReply')?.addEventListener('input', function(e) {
+ const value = e.target.value.trim();
+ const keywordInput = document.getElementById('newKeyword');
+
+ // 回复内容可以为空,只需要关键词有内容即可
+ if (value.length > 0) {
+ e.target.style.borderColor = '#10b981';
+ } else {
+ e.target.style.borderColor = '#e5e7eb';
+ }
+
+ // 按钮状态只依赖关键词是否有内容
+ const addBtn = document.querySelector('.add-btn');
+ if (keywordInput.value.trim().length > 0) {
+ addBtn.style.opacity = '1';
+ addBtn.style.transform = 'scale(1)';
+ } else {
+ addBtn.style.opacity = '0.7';
+ addBtn.style.transform = 'scale(0.95)';
+ }
+ });
+
+ // 初始加载仪表盘
+ loadDashboard();
+
+ // 初始化图片关键词事件监听器
+ initImageKeywordEventListeners();
+
+ // 初始化卡券图片文件选择器
+ initCardImageFileSelector();
+
+ // 初始化编辑卡券图片文件选择器
+ initEditCardImageFileSelector();
+
+ // 初始化工具提示
+ initTooltips();
+
+ // 初始化商品搜索功能
+ initItemsSearch();
+
+ // 初始化商品搜索界面功能
+ initItemSearch();
+
+ // 点击侧边栏外部关闭移动端菜单
+ document.addEventListener('click', function(e) {
+ const sidebar = document.getElementById('sidebar');
+ const toggle = document.querySelector('.mobile-toggle');
+
+ if (window.innerWidth <= 768 &&
+ !sidebar.contains(e.target) &&
+ !toggle.contains(e.target) &&
+ sidebar.classList.contains('show')) {
+ sidebar.classList.remove('show');
+ }
+ });
+
+ // 启动Cookie在线状态监控
+ startCookieMonitor();
+
+ // 初始化用户权限和角色数据
+ setTimeout(async () => {
+ await loadMyPermissions();
+ loadRolesForSelect();
+ }, 500);
+});
+
+// ==================== 默认回复管理功能 ====================
+
+// 打开默认回复管理器
+async function openDefaultReplyManager() {
+ try {
+ await loadDefaultReplies();
+ const modal = new bootstrap.Modal(document.getElementById('defaultReplyModal'));
+ modal.show();
+ } catch (error) {
+ console.error('打开默认回复管理器失败:', error);
+ showToast('打开默认回复管理器失败', 'danger');
+ }
+}
+
+// 加载默认回复列表
+async function loadDefaultReplies() {
+ try {
+ // 获取所有账号
+ const accountsResponse = await fetch(`${apiBase}/cookies`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (!accountsResponse.ok) {
+ throw new Error('获取账号列表失败');
+ }
+
+ const accounts = await accountsResponse.json();
+
+ // 获取所有默认回复设置
+ const repliesResponse = await fetch(`${apiBase}/default-replies`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ let defaultReplies = {};
+ if (repliesResponse.ok) {
+ defaultReplies = await repliesResponse.json();
+ }
+
+ renderDefaultRepliesList(accounts, defaultReplies);
+ } catch (error) {
+ console.error('加载默认回复列表失败:', error);
+ showToast('加载默认回复列表失败', 'danger');
+ }
+}
+
+// 渲染默认回复列表
+function renderDefaultRepliesList(accounts, defaultReplies) {
+ const tbody = document.getElementById('defaultReplyTableBody');
+ tbody.innerHTML = '';
+
+ if (accounts.length === 0) {
+ tbody.innerHTML = `
+
+
+
+ 暂无账号数据
+ 请先添加账号
+ |
+
+ `;
+ return;
+ }
+
+ accounts.forEach(accountId => {
+ const replySettings = defaultReplies[accountId] || { enabled: false, reply_content: '', reply_once: false };
+ const tr = document.createElement('tr');
+
+ // 状态标签
+ const statusBadge = replySettings.enabled ?
+ '启用' :
+ '禁用';
+
+ // 只回复一次标签
+ const replyOnceBadge = replySettings.reply_once ?
+ '是' :
+ '否';
+
+ // 回复内容预览
+ let contentPreview = replySettings.reply_content || '未设置';
+ if (contentPreview.length > 50) {
+ contentPreview = contentPreview.substring(0, 50) + '...';
+ }
+
+ tr.innerHTML = `
+
+ ${accountId}
+ |
+ ${statusBadge} |
+ ${replyOnceBadge} |
+
+
+ ${contentPreview}
+
+ |
+
+
+
+
+ ${replySettings.reply_once ? `
+
+ ` : ''}
+
+ |
+ `;
+
+ tbody.appendChild(tr);
+ });
+}
+
+// 编辑默认回复
+async function editDefaultReply(accountId) {
+ try {
+ // 获取当前设置
+ const response = await fetch(`${apiBase}/default-replies/${accountId}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ let settings = { enabled: false, reply_content: '', reply_once: false };
+ if (response.ok) {
+ settings = await response.json();
+ }
+
+ // 填充编辑表单
+ document.getElementById('editAccountId').value = accountId;
+ document.getElementById('editAccountIdDisplay').value = accountId;
+ document.getElementById('editDefaultReplyEnabled').checked = settings.enabled;
+ document.getElementById('editReplyContent').value = settings.reply_content || '';
+ document.getElementById('editReplyOnce').checked = settings.reply_once || false;
+
+ // 根据启用状态显示/隐藏内容输入框
+ toggleReplyContentVisibility();
+
+ // 显示编辑模态框
+ const modal = new bootstrap.Modal(document.getElementById('editDefaultReplyModal'));
+ modal.show();
+ } catch (error) {
+ console.error('获取默认回复设置失败:', error);
+ showToast('获取默认回复设置失败', 'danger');
+ }
+}
+
+// 切换回复内容输入框的显示/隐藏
+function toggleReplyContentVisibility() {
+ const enabled = document.getElementById('editDefaultReplyEnabled').checked;
+ const contentGroup = document.getElementById('editReplyContentGroup');
+ contentGroup.style.display = enabled ? 'block' : 'none';
+}
+
+// 保存默认回复设置
+async function saveDefaultReply() {
+ try {
+ const accountId = document.getElementById('editAccountId').value;
+ const enabled = document.getElementById('editDefaultReplyEnabled').checked;
+ const replyContent = document.getElementById('editReplyContent').value;
+ const replyOnce = document.getElementById('editReplyOnce').checked;
+
+ if (enabled && !replyContent.trim()) {
+ showToast('启用默认回复时必须设置回复内容', 'warning');
+ return;
+ }
+
+ const data = {
+ enabled: enabled,
+ reply_content: enabled ? replyContent : null,
+ reply_once: replyOnce
+ };
+
+ const response = await fetch(`${apiBase}/default-replies/${accountId}`, {
+ method: 'PUT',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`,
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify(data)
+ });
+
+ if (response.ok) {
+ showToast('默认回复设置保存成功', 'success');
+ bootstrap.Modal.getInstance(document.getElementById('editDefaultReplyModal')).hide();
+ loadDefaultReplies(); // 刷新列表
+ loadCookies(); // 刷新账号列表以更新默认回复状态显示
+ } else {
+ const error = await response.text();
+ showToast(`保存失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('保存默认回复设置失败:', error);
+ showToast('保存默认回复设置失败', 'danger');
+ }
+}
+
+// 测试默认回复(占位函数)
+function testDefaultReply(accountId) {
+ showToast('测试功能开发中...', 'info');
+}
+
+// 清空默认回复记录
+async function clearDefaultReplyRecords(accountId) {
+ if (!confirm(`确定要清空账号 "${accountId}" 的默认回复记录吗?\n\n清空后,该账号将可以重新对之前回复过的对话进行默认回复。`)) {
+ return;
+ }
+
+ try {
+ const response = await fetch(`${apiBase}/default-replies/${accountId}/clear-records`, {
+ method: 'POST',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`,
+ 'Content-Type': 'application/json'
+ }
+ });
+
+ if (response.ok) {
+ showToast(`账号 "${accountId}" 的默认回复记录已清空`, 'success');
+ loadDefaultReplies(); // 刷新列表
+ } else {
+ const error = await response.text();
+ showToast(`清空失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('清空默认回复记录失败:', error);
+ showToast('清空默认回复记录失败', 'danger');
+ }
+}
+
+// ==================== API密钥显隐切换 ====================
+
+function toggleApiKeyVisibility() {
+ const input = document.getElementById('aiApiKey');
+ const icon = document.getElementById('aiApiKeyToggleIcon');
+ if (input.type === 'password') {
+ input.type = 'text';
+ icon.className = 'bi bi-eye-slash';
+ } else {
+ input.type = 'password';
+ icon.className = 'bi bi-eye';
+ }
+}
+
+// ==================== AI回复配置相关函数 ====================
+
+// 配置AI回复
+async function configAIReply(accountId) {
+ try {
+ // 获取当前AI回复设置
+ const settings = await fetchJSON(`${apiBase}/ai-reply-settings/${accountId}`);
+
+ // 填充表单
+ document.getElementById('aiConfigAccountId').value = accountId;
+ document.getElementById('aiConfigAccountIdDisplay').value = accountId;
+ document.getElementById('aiReplyEnabled').checked = settings.ai_enabled;
+ // 处理模型名称
+ const modelSelect = document.getElementById('aiModelName');
+ const customModelInput = document.getElementById('customModelName');
+ const modelName = settings.model_name;
+ // 检查是否是预设模型
+ const presetModels = ['qwen-plus', 'qwen-turbo', 'qwen-max', 'gpt-3.5-turbo', 'gpt-4'];
+ if (presetModels.includes(modelName)) {
+ modelSelect.value = modelName;
+ customModelInput.style.display = 'none';
+ customModelInput.value = '';
+ } else {
+ // 自定义模型
+ modelSelect.value = 'custom';
+ customModelInput.style.display = 'block';
+ customModelInput.value = modelName;
+ }
+ document.getElementById('aiBaseUrl').value = settings.base_url;
+ document.getElementById('aiApiKey').value = settings.api_key;
+ document.getElementById('maxDiscountPercent').value = settings.max_discount_percent;
+ document.getElementById('maxDiscountAmount').value = settings.max_discount_amount;
+ document.getElementById('maxBargainRounds').value = settings.max_bargain_rounds;
+ document.getElementById('customPrompts').value = settings.custom_prompts;
+ document.getElementById('aiRefundPolicy').value = settings.refund_policy || 'allow';
+
+ // 切换设置显示状态
+ toggleAIReplySettings();
+
+ // 显示模态框
+ const modal = new bootstrap.Modal(document.getElementById('aiReplyConfigModal'));
+ modal.show();
+
+ } catch (error) {
+ console.error('获取AI回复设置失败:', error);
+ showToast('获取AI回复设置失败', 'danger');
+ }
+}
+
+// 切换AI回复设置显示
+function toggleAIReplySettings() {
+ const enabled = document.getElementById('aiReplyEnabled').checked;
+ const settingsDiv = document.getElementById('aiReplySettings');
+ const bargainSettings = document.getElementById('bargainSettings');
+ const promptSettings = document.getElementById('promptSettings');
+ const testArea = document.getElementById('testArea');
+
+ const refundPolicyCard = document.getElementById('refundPolicyCard');
+ if (enabled) {
+ settingsDiv.style.display = 'block';
+ if (refundPolicyCard) refundPolicyCard.style.display = 'block';
+ bargainSettings.style.display = 'block';
+ promptSettings.style.display = 'block';
+ testArea.style.display = 'block';
+ } else {
+ settingsDiv.style.display = 'none';
+ if (refundPolicyCard) refundPolicyCard.style.display = 'none';
+ bargainSettings.style.display = 'none';
+ promptSettings.style.display = 'none';
+ testArea.style.display = 'none';
+ }
+}
+
+// 保存AI回复配置
+async function saveAIReplyConfig() {
+ try {
+ const accountId = document.getElementById('aiConfigAccountId').value;
+ const enabled = document.getElementById('aiReplyEnabled').checked;
+
+ // 如果启用AI回复,验证必填字段
+ if (enabled) {
+ const apiKey = document.getElementById('aiApiKey').value.trim();
+ if (!apiKey) {
+ showToast('请输入API密钥', 'warning');
+ return;
+ }
+
+ // 验证自定义提示词格式
+ const customPrompts = document.getElementById('customPrompts').value.trim();
+ if (customPrompts) {
+ try {
+ JSON.parse(customPrompts);
+ } catch (e) {
+ showToast('自定义提示词格式错误,请检查JSON格式', 'warning');
+ return;
+ }
+ }
+ }
+// 获取模型名称
+ let modelName = document.getElementById('aiModelName').value;
+ if (modelName === 'custom') {
+ const customModelName = document.getElementById('customModelName').value.trim();
+ if (!customModelName) {
+ showToast('请输入自定义模型名称', 'warning');
+ return;
+ }
+ modelName = customModelName;
+ }
+ // 构建设置对象
+ const settings = {
+ ai_enabled: enabled,
+ model_name: modelName,
+ api_key: document.getElementById('aiApiKey').value,
+ base_url: document.getElementById('aiBaseUrl').value,
+ max_discount_percent: parseInt(document.getElementById('maxDiscountPercent').value),
+ max_discount_amount: parseInt(document.getElementById('maxDiscountAmount').value),
+ max_bargain_rounds: parseInt(document.getElementById('maxBargainRounds').value),
+ custom_prompts: document.getElementById('customPrompts').value,
+ refund_policy: document.getElementById('aiRefundPolicy').value
+ };
+
+ // 保存设置
+ const response = await fetch(`${apiBase}/ai-reply-settings/${accountId}`, {
+ method: 'PUT',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify(settings)
+ });
+
+ if (response.ok) {
+ showToast('AI回复配置保存成功', 'success');
+ bootstrap.Modal.getInstance(document.getElementById('aiReplyConfigModal')).hide();
+ loadCookies(); // 刷新账号列表以更新AI回复状态显示
+ } else {
+ const error = await response.text();
+ showToast(`保存失败: ${error}`, 'danger');
+ }
+
+ } catch (error) {
+ console.error('保存AI回复配置失败:', error);
+ showToast('保存AI回复配置失败', 'danger');
+ }
+}
+
+// 测试AI回复
+async function testAIReply() {
+ try {
+ const accountId = document.getElementById('aiConfigAccountId').value;
+ const testMessage = document.getElementById('testMessage').value.trim();
+ const testItemPrice = document.getElementById('testItemPrice').value;
+
+ if (!testMessage) {
+ showToast('请输入测试消息', 'warning');
+ return;
+ }
+
+ // 构建测试数据
+ const testData = {
+ message: testMessage,
+ item_title: '测试商品',
+ item_price: parseFloat(testItemPrice) || 100,
+ item_desc: '这是一个用于测试AI回复功能的商品'
+ };
+
+ // 显示加载状态
+ const testResult = document.getElementById('testResult');
+ const testReplyContent = document.getElementById('testReplyContent');
+ testResult.style.display = 'block';
+ testReplyContent.innerHTML = ' 正在生成AI回复...';
+
+ // 调用测试API
+ const response = await fetch(`${apiBase}/ai-reply-test/${accountId}`, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify(testData)
+ });
+
+ if (response.ok) {
+ const result = await response.json();
+ testReplyContent.innerHTML = result.reply;
+ showToast('AI回复测试成功', 'success');
+ } else {
+ const error = await response.text();
+ testReplyContent.innerHTML = `测试失败: ${error}`;
+ showToast(`测试失败: ${error}`, 'danger');
+ }
+
+ } catch (error) {
+ console.error('测试AI回复失败:', error);
+ const testReplyContent = document.getElementById('testReplyContent');
+ testReplyContent.innerHTML = `测试失败: ${error.message}`;
+ showToast('测试AI回复失败', 'danger');
+ }
+}
+
+// 切换自定义模型输入框的显示/隐藏
+function toggleCustomModelInput() {
+ const modelSelect = document.getElementById('aiModelName');
+ const customModelInput = document.getElementById('customModelName');
+ if (modelSelect.value === 'custom') {
+ customModelInput.style.display = 'block';
+ customModelInput.focus();
+ } else {
+ customModelInput.style.display = 'none';
+ customModelInput.value = '';
+ }
+}
+
+// 监听默认回复启用状态变化
+document.addEventListener('DOMContentLoaded', function() {
+ const enabledCheckbox = document.getElementById('editDefaultReplyEnabled');
+ if (enabledCheckbox) {
+ enabledCheckbox.addEventListener('change', toggleReplyContentVisibility);
+ }
+});
+
+// ================================
+// 【外发配置菜单】相关功能
+// ================================
+
+// 外发配置类型配置
+const outgoingConfigs = {
+ smtp: {
+ title: 'SMTP邮件配置',
+ description: '配置SMTP服务器用于发送注册验证码等邮件通知',
+ icon: 'bi-envelope-fill',
+ color: 'primary',
+ fields: [
+ {
+ id: 'smtp_server',
+ label: 'SMTP服务器',
+ type: 'text',
+ placeholder: 'smtp.qq.com',
+ required: true,
+ help: '邮箱服务商的SMTP服务器地址,如:smtp.qq.com、smtp.gmail.com'
+ },
+ {
+ id: 'smtp_port',
+ label: 'SMTP端口',
+ type: 'number',
+ placeholder: '587',
+ required: true,
+ help: '通常为587(TLS)或465(SSL)'
+ },
+ {
+ id: 'smtp_user',
+ label: '发件邮箱',
+ type: 'email',
+ placeholder: 'your-email@qq.com',
+ required: true,
+ help: '用于发送邮件的邮箱地址'
+ },
+ {
+ id: 'smtp_password',
+ label: '邮箱密码/授权码',
+ type: 'password',
+ placeholder: '输入密码或授权码',
+ required: true,
+ help: '邮箱密码或应用专用密码(QQ邮箱需要授权码)'
+ },
+ {
+ id: 'smtp_from',
+ label: '发件人显示名(可选)',
+ type: 'text',
+ placeholder: '闲鱼自动回复系统',
+ required: false,
+ help: '邮件发件人显示的名称,留空则使用邮箱地址'
+ },
+ {
+ id: 'smtp_use_tls',
+ label: '启用TLS',
+ type: 'select',
+ options: [
+ { value: 'true', text: '是' },
+ { value: 'false', text: '否' }
+ ],
+ required: true,
+ help: '是否启用TLS加密(推荐开启)'
+ },
+ {
+ id: 'smtp_use_ssl',
+ label: '启用SSL',
+ type: 'select',
+ options: [
+ { value: 'true', text: '是' },
+ { value: 'false', text: '否' }
+ ],
+ required: true,
+ help: '是否启用SSL加密(与TLS二选一)'
+ }
+ ]
+ }
+};
+
+// AI回复全局默认配置定义
+const aiDefaultConfigs = {
+ ai_default_enabled: {
+ label: '启用AI回复',
+ type: 'switch',
+ default: false,
+ help: '启用后,新添加的账号将默认开启AI回复功能'
+ },
+ ai_default_model: {
+ label: '默认AI模型',
+ type: 'text',
+ default: 'qwen-plus',
+ placeholder: 'deepseek-v4-flash',
+ help: '全局默认使用的AI模型,直接输入模型名称'
+ },
+ ai_default_base_url: {
+ label: '默认API地址',
+ type: 'text',
+ default: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+ placeholder: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+ help: 'AI接口的Base URL'
+ },
+ ai_default_api_key: {
+ label: '默认API密钥',
+ type: 'text',
+ default: '',
+ placeholder: '请输入API密钥',
+ help: '全局默认API密钥,各账号可单独覆盖'
+ },
+ ai_default_max_discount_percent: {
+ label: '最大优惠百分比',
+ type: 'number',
+ default: 10,
+ placeholder: '10',
+ help: 'AI议价时允许的最大优惠百分比'
+ },
+ ai_default_max_discount_amount: {
+ label: '最大优惠金额(元)',
+ type: 'number',
+ default: 100,
+ placeholder: '100',
+ help: 'AI议价时允许的最大优惠金额'
+ },
+ ai_default_max_bargain_rounds: {
+ label: '最大议价轮数',
+ type: 'number',
+ default: 3,
+ placeholder: '3',
+ help: 'AI与买家进行议价的最大轮数'
+ },
+ ai_default_prompts: {
+ label: '自定义提示词 (JSON格式)',
+ type: 'textarea',
+ default: '',
+ placeholder: '留空使用系统默认,或参考示例填写',
+ help: '留空使用系统默认。自定义各场景的回复指令(JSON格式),字段说明:\nclassify = 意图分类\nprice = 砍价议价\nrefund = 退款退货\ntech = 技术咨询\ndefault = 其他'
+ },
+ ai_default_refund_policy: {
+ label: '退款策略',
+ type: 'select',
+ default: 'allow',
+ options: [
+ { value: 'allow', text: '可以退 - 引导用户操作退款' },
+ { value: 'disallow', text: '不可以退 - AI说明原因' }
+ ],
+ help: '用户要求退款时AI的回复策略'
+ }
+};
+
+// ================================
+// 【通知渠道菜单】相关功能
+// ================================
+
+// 通知渠道类型配置
+const channelTypeConfigs = {
+ qq: {
+ title: 'QQ通知',
+ description: '需要添加QQ号 3668943488 为好友才能正常接收消息通知',
+ icon: 'bi-chat-dots-fill',
+ color: 'primary',
+ fields: [
+ {
+ id: 'qq_number',
+ label: '接收QQ号码',
+ type: 'text',
+ placeholder: '输入QQ号码',
+ required: true,
+ help: '用于接收通知消息的QQ号码'
+ }
+ ]
+ },
+ dingtalk: {
+ title: '钉钉通知',
+ description: '请设置钉钉机器人Webhook URL,支持自定义机器人和群机器人',
+ icon: 'bi-bell-fill',
+ color: 'info',
+ fields: [
+ {
+ id: 'webhook_url',
+ label: '钉钉机器人Webhook URL',
+ type: 'url',
+ placeholder: 'https://oapi.dingtalk.com/robot/send?access_token=...',
+ required: true,
+ help: '钉钉机器人的Webhook地址'
+ },
+ {
+ id: 'secret',
+ label: '加签密钥(可选)',
+ type: 'text',
+ placeholder: '输入加签密钥',
+ required: false,
+ help: '如果机器人开启了加签验证,请填写密钥'
+ }
+ ]
+ },
+ email: {
+ title: '邮件通知',
+ description: '通过SMTP服务器发送邮件通知,支持各种邮箱服务商',
+ icon: 'bi-envelope-fill',
+ color: 'success',
+ fields: [
+ {
+ id: 'smtp_server',
+ label: 'SMTP服务器',
+ type: 'text',
+ placeholder: 'smtp.gmail.com',
+ required: true,
+ help: '邮箱服务商的SMTP服务器地址'
+ },
+ {
+ id: 'smtp_port',
+ label: 'SMTP端口',
+ type: 'number',
+ placeholder: '587',
+ required: true,
+ help: '通常为587(TLS)或465(SSL)'
+ },
+ {
+ id: 'email_user',
+ label: '发送邮箱',
+ type: 'email',
+ placeholder: 'your-email@gmail.com',
+ required: true,
+ help: '用于发送通知的邮箱地址'
+ },
+ {
+ id: 'email_password',
+ label: '邮箱密码/授权码',
+ type: 'password',
+ placeholder: '输入密码或授权码',
+ required: true,
+ help: '邮箱密码或应用专用密码'
+ },
+ {
+ id: 'recipient_email',
+ label: '接收邮箱',
+ type: 'email',
+ placeholder: 'recipient@example.com',
+ required: true,
+ help: '用于接收通知的邮箱地址'
+ }
+ ]
+ },
+ webhook: {
+ title: 'Webhook通知',
+ description: '通过HTTP POST请求发送通知到自定义的Webhook地址',
+ icon: 'bi-link-45deg',
+ color: 'warning',
+ fields: [
+ {
+ id: 'webhook_url',
+ label: 'Webhook URL',
+ type: 'url',
+ placeholder: 'https://your-server.com/webhook',
+ required: true,
+ help: '接收通知的Webhook地址'
+ },
+ {
+ id: 'http_method',
+ label: 'HTTP方法',
+ type: 'select',
+ options: [
+ { value: 'POST', text: 'POST' },
+ { value: 'PUT', text: 'PUT' }
+ ],
+ required: true,
+ help: '发送请求使用的HTTP方法'
+ },
+ {
+ id: 'headers',
+ label: '自定义请求头(可选)',
+ type: 'textarea',
+ placeholder: '{"Authorization": "Bearer token", "Content-Type": "application/json"}',
+ required: false,
+ help: 'JSON格式的自定义请求头'
+ }
+ ]
+ },
+ wechat: {
+ title: '微信通知',
+ description: '通过企业微信机器人发送通知消息',
+ icon: 'bi-wechat',
+ color: 'success',
+ fields: [
+ {
+ id: 'webhook_url',
+ label: '企业微信机器人Webhook URL',
+ type: 'url',
+ placeholder: 'https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=...',
+ required: true,
+ help: '企业微信群机器人的Webhook地址'
+ }
+ ]
+ },
+ telegram: {
+ title: 'Telegram通知',
+ description: '通过Telegram机器人发送通知消息',
+ icon: 'bi-telegram',
+ color: 'primary',
+ fields: [
+ {
+ id: 'bot_token',
+ label: 'Bot Token',
+ type: 'text',
+ placeholder: '123456789:ABCdefGHIjklMNOpqrsTUVwxyz',
+ required: true,
+ help: '从@BotFather获取的机器人Token'
+ },
+ {
+ id: 'chat_id',
+ label: 'Chat ID',
+ type: 'text',
+ placeholder: '123456789 或 @channel_name',
+ required: true,
+ help: '接收消息的用户ID或频道名'
+ }
+ ]
+ }
+};
+
+// 显示添加渠道模态框
+function showAddChannelModal(type) {
+ const config = channelTypeConfigs[type];
+ if (!config) {
+ showToast('不支持的通知渠道类型', 'danger');
+ return;
+ }
+
+ // 设置模态框标题和描述
+ document.getElementById('addChannelModalTitle').textContent = `添加${config.title}`;
+ document.getElementById('channelTypeDescription').innerHTML = config.description;
+ document.getElementById('channelType').value = type;
+
+ // 生成配置字段
+ const fieldsContainer = document.getElementById('channelConfigFields');
+ fieldsContainer.innerHTML = '';
+
+ config.fields.forEach(field => {
+ const fieldHtml = generateFieldHtml(field, '');
+ fieldsContainer.insertAdjacentHTML('beforeend', fieldHtml);
+ });
+
+ // 显示模态框
+ const modal = new bootstrap.Modal(document.getElementById('addChannelModal'));
+ modal.show();
+}
+
+// 生成表单字段HTML
+function generateFieldHtml(field, prefix) {
+ const fieldId = prefix + field.id;
+ let inputHtml = '';
+
+ switch (field.type) {
+ case 'select':
+ inputHtml = `';
+ break;
+ case 'textarea':
+ inputHtml = ``;
+ break;
+ default:
+ inputHtml = ``;
+ }
+
+ return `
+
+
+ ${inputHtml}
+ ${field.help ? `${field.help}` : ''}
+
+ `;
+}
+
+// 保存通知渠道
+async function saveNotificationChannel() {
+ const type = document.getElementById('channelType').value;
+ const name = document.getElementById('channelName').value;
+ const enabled = document.getElementById('channelEnabled').checked;
+
+ if (!name.trim()) {
+ showToast('请输入渠道名称', 'warning');
+ return;
+ }
+
+ const config = channelTypeConfigs[type];
+ if (!config) {
+ showToast('无效的渠道类型', 'danger');
+ return;
+ }
+
+ // 收集配置数据
+ const configData = {};
+ let hasError = false;
+
+ config.fields.forEach(field => {
+ const element = document.getElementById(field.id);
+ const value = element.value.trim();
+
+ if (field.required && !value) {
+ showToast(`请填写${field.label}`, 'warning');
+ hasError = true;
+ return;
+ }
+
+ if (value) {
+ configData[field.id] = value;
+ }
+ });
+
+ if (hasError) return;
+
+ try {
+ const response = await fetch(`${apiBase}/notification-channels`, {
+ method: 'POST',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`,
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify({
+ name: name,
+ type: type,
+ config: JSON.stringify(configData),
+ enabled: enabled
+ })
+ });
+
+ if (response.ok) {
+ showToast('通知渠道添加成功', 'success');
+ const modal = bootstrap.Modal.getInstance(document.getElementById('addChannelModal'));
+ modal.hide();
+ loadNotificationChannels();
+ } else {
+ const error = await response.text();
+ showToast(`添加失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('添加通知渠道失败:', error);
+ showToast('添加通知渠道失败', 'danger');
+ }
+}
+
+// 加载通知渠道列表
+async function loadNotificationChannels() {
+ try {
+ const response = await fetch(`${apiBase}/notification-channels`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (!response.ok) {
+ throw new Error('获取通知渠道失败');
+ }
+
+ const channels = await response.json();
+ renderNotificationChannels(channels);
+ } catch (error) {
+ console.error('加载通知渠道失败:', error);
+ showToast('加载通知渠道失败', 'danger');
+ }
+}
+
+// 渲染通知渠道列表
+function renderNotificationChannels(channels) {
+ const tbody = document.getElementById('channelsTableBody');
+ tbody.innerHTML = '';
+
+ if (channels.length === 0) {
+ tbody.innerHTML = `
+
+
+
+ 暂无通知渠道
+ 点击上方按钮添加通知渠道
+ |
+
+ `;
+ return;
+ }
+
+ channels.forEach(channel => {
+ const tr = document.createElement('tr');
+
+ const statusBadge = channel.enabled ?
+ '启用' :
+ '禁用';
+
+ // 获取渠道类型配置(处理类型映射)
+ let channelType = channel.type;
+ if (channelType === 'ding_talk') {
+ channelType = 'dingtalk'; // 兼容旧的类型名
+ }
+ const typeConfig = channelTypeConfigs[channelType];
+ const typeDisplay = typeConfig ? typeConfig.title : channel.type;
+ const typeColor = typeConfig ? typeConfig.color : 'secondary';
+
+ // 解析并显示配置信息
+ let configDisplay = '';
+ try {
+ const configData = JSON.parse(channel.config || '{}');
+ const configEntries = Object.entries(configData);
+
+ if (configEntries.length > 0) {
+ configDisplay = configEntries.map(([key, value]) => {
+ // 隐藏敏感信息
+ if (key.includes('password') || key.includes('token') || key.includes('secret')) {
+ return `${key}: ****`;
+ }
+ // 截断过长的值
+ const displayValue = value.length > 30 ? value.substring(0, 30) + '...' : value;
+ return `${key}: ${displayValue}`;
+ }).join('
');
+ } else {
+ configDisplay = channel.config || '无配置';
+ }
+ } catch (e) {
+ // 兼容旧格式
+ configDisplay = channel.config || '无配置';
+ if (configDisplay.length > 30) {
+ configDisplay = configDisplay.substring(0, 30) + '...';
+ }
+ }
+
+ tr.innerHTML = `
+ ${channel.id} |
+
+
+
+ ${channel.name}
+
+ |
+ ${typeDisplay} |
+ ${configDisplay} |
+ ${statusBadge} |
+
+
+
+
+
+ |
+ `;
+
+ tbody.appendChild(tr);
+ });
+}
+
+
+
+// 删除通知渠道
+async function deleteNotificationChannel(channelId) {
+ if (!confirm('确定要删除这个通知渠道吗?')) {
+ return;
+ }
+
+ try {
+ const response = await fetch(`${apiBase}/notification-channels/${channelId}`, {
+ method: 'DELETE',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ showToast('通知渠道删除成功', 'success');
+ loadNotificationChannels();
+ } else {
+ const error = await response.text();
+ showToast(`删除失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('删除通知渠道失败:', error);
+ showToast('删除通知渠道失败', 'danger');
+ }
+}
+
+// 编辑通知渠道
+async function editNotificationChannel(channelId) {
+ try {
+ // 获取渠道详情
+ const response = await fetch(`${apiBase}/notification-channels`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (!response.ok) {
+ throw new Error('获取通知渠道失败');
+ }
+
+ const channels = await response.json();
+ const channel = channels.find(c => c.id === channelId);
+
+ if (!channel) {
+ showToast('通知渠道不存在', 'danger');
+ return;
+ }
+
+ // 处理类型映射
+ let channelType = channel.type;
+ if (channelType === 'ding_talk') {
+ channelType = 'dingtalk'; // 兼容旧的类型名
+ }
+
+ const config = channelTypeConfigs[channelType];
+ if (!config) {
+ showToast('不支持的渠道类型', 'danger');
+ return;
+ }
+
+ // 填充基本信息
+ document.getElementById('editChannelId').value = channel.id;
+ document.getElementById('editChannelType').value = channelType; // 使用映射后的类型
+ document.getElementById('editChannelName').value = channel.name;
+ document.getElementById('editChannelEnabled').checked = channel.enabled;
+
+ // 解析配置数据
+ let configData = {};
+ try {
+ configData = JSON.parse(channel.config || '{}');
+ } catch (e) {
+ // 兼容旧格式(直接字符串)
+ if (channel.type === 'qq') {
+ configData = { qq_number: channel.config };
+ } else if (channel.type === 'dingtalk' || channel.type === 'ding_talk') {
+ configData = { webhook_url: channel.config };
+ } else {
+ configData = { config: channel.config };
+ }
+ }
+
+ // 生成编辑字段
+ const fieldsContainer = document.getElementById('editChannelConfigFields');
+ fieldsContainer.innerHTML = '';
+
+ config.fields.forEach(field => {
+ const fieldHtml = generateFieldHtml(field, 'edit_');
+ fieldsContainer.insertAdjacentHTML('beforeend', fieldHtml);
+
+ // 填充现有值
+ const element = document.getElementById('edit_' + field.id);
+ if (element && configData[field.id]) {
+ element.value = configData[field.id];
+ }
+ });
+
+ // 显示编辑模态框
+ const modal = new bootstrap.Modal(document.getElementById('editChannelModal'));
+ modal.show();
+ } catch (error) {
+ console.error('编辑通知渠道失败:', error);
+ showToast('编辑通知渠道失败', 'danger');
+ }
+}
+
+// 更新通知渠道
+async function updateNotificationChannel() {
+ const channelId = document.getElementById('editChannelId').value;
+ const type = document.getElementById('editChannelType').value;
+ const name = document.getElementById('editChannelName').value;
+ const enabled = document.getElementById('editChannelEnabled').checked;
+
+ if (!name.trim()) {
+ showToast('请输入渠道名称', 'warning');
+ return;
+ }
+
+ const config = channelTypeConfigs[type];
+ if (!config) {
+ showToast('无效的渠道类型', 'danger');
+ return;
+ }
+
+ // 收集配置数据
+ const configData = {};
+ let hasError = false;
+
+ config.fields.forEach(field => {
+ const element = document.getElementById('edit_' + field.id);
+ const value = element.value.trim();
+
+ if (field.required && !value) {
+ showToast(`请填写${field.label}`, 'warning');
+ hasError = true;
+ return;
+ }
+
+ if (value) {
+ configData[field.id] = value;
+ }
+ });
+
+ if (hasError) return;
+
+ try {
+ const response = await fetch(`${apiBase}/notification-channels/${channelId}`, {
+ method: 'PUT',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`,
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify({
+ name: name,
+ config: JSON.stringify(configData),
+ enabled: enabled
+ })
+ });
+
+ if (response.ok) {
+ showToast('通知渠道更新成功', 'success');
+ const modal = bootstrap.Modal.getInstance(document.getElementById('editChannelModal'));
+ modal.hide();
+ loadNotificationChannels();
+ } else {
+ const error = await response.text();
+ showToast(`更新失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('更新通知渠道失败:', error);
+ showToast('更新通知渠道失败', 'danger');
+ }
+}
+
+// ================================
+// 【消息通知菜单】相关功能
+// ================================
+
+// 加载消息通知配置
+async function loadMessageNotifications() {
+ try {
+ // 获取所有账号
+ const accountsResponse = await fetch(`${apiBase}/cookies`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (!accountsResponse.ok) {
+ throw new Error('获取账号列表失败');
+ }
+
+ const accounts = await accountsResponse.json();
+
+ // 获取所有通知配置
+ const notificationsResponse = await fetch(`${apiBase}/message-notifications`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ let notifications = {};
+ if (notificationsResponse.ok) {
+ notifications = await notificationsResponse.json();
+ }
+
+ renderMessageNotifications(accounts, notifications);
+ } catch (error) {
+ console.error('加载消息通知配置失败:', error);
+ showToast('加载消息通知配置失败', 'danger');
+ }
+}
+
+// 渲染消息通知配置
+function renderMessageNotifications(accounts, notifications) {
+ const tbody = document.getElementById('notificationsTableBody');
+ tbody.innerHTML = '';
+
+ if (accounts.length === 0) {
+ tbody.innerHTML = `
+
+
+
+ 暂无账号数据
+ 请先添加账号
+ |
+
+ `;
+ return;
+ }
+
+ accounts.forEach(accountId => {
+ const accountNotifications = notifications[accountId] || [];
+ const tr = document.createElement('tr');
+
+ let channelsList = '';
+ if (accountNotifications.length > 0) {
+ channelsList = accountNotifications.map(n =>
+ `${n.channel_name}`
+ ).join('');
+ } else {
+ channelsList = '未配置';
+ }
+
+ const status = accountNotifications.some(n => n.enabled) ?
+ '启用' :
+ '禁用';
+
+ tr.innerHTML = `
+ ${accountId} |
+ ${channelsList} |
+ ${status} |
+
+
+
+ ${accountNotifications.length > 0 ? `
+
+ ` : ''}
+
+ |
+ `;
+
+ tbody.appendChild(tr);
+ });
+}
+
+// 配置账号通知
+async function configAccountNotification(accountId) {
+ try {
+ // 获取所有通知渠道
+ const channelsResponse = await fetch(`${apiBase}/notification-channels`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (!channelsResponse.ok) {
+ throw new Error('获取通知渠道失败');
+ }
+
+ const channels = await channelsResponse.json();
+
+ if (channels.length === 0) {
+ showToast('请先添加通知渠道', 'warning');
+ return;
+ }
+
+ // 获取当前账号的通知配置
+ const notificationResponse = await fetch(`${apiBase}/message-notifications/${accountId}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ let currentNotifications = [];
+ if (notificationResponse.ok) {
+ currentNotifications = await notificationResponse.json();
+ }
+
+ // 填充表单
+ document.getElementById('configAccountId').value = accountId;
+ document.getElementById('displayAccountId').value = accountId;
+
+ // 填充通知渠道选项
+ const channelSelect = document.getElementById('notificationChannel');
+ channelSelect.innerHTML = '';
+
+ // 获取当前配置的第一个通知渠道(如果存在)
+ const currentNotification = currentNotifications.length > 0 ? currentNotifications[0] : null;
+
+ channels.forEach(channel => {
+ if (channel.enabled) {
+ const option = document.createElement('option');
+ option.value = channel.id;
+ option.textContent = `${channel.name} (${channel.config})`;
+ if (currentNotification && currentNotification.channel_id === channel.id) {
+ option.selected = true;
+ }
+ channelSelect.appendChild(option);
+ }
+ });
+
+ // 设置启用状态
+ document.getElementById('notificationEnabled').checked =
+ currentNotification ? currentNotification.enabled : true;
+
+ // 显示配置模态框
+ const modal = new bootstrap.Modal(document.getElementById('configNotificationModal'));
+ modal.show();
+ } catch (error) {
+ console.error('配置账号通知失败:', error);
+ showToast('配置账号通知失败', 'danger');
+ }
+}
+
+// 删除账号通知配置
+async function deleteAccountNotification(accountId) {
+ if (!confirm(`确定要删除账号 ${accountId} 的通知配置吗?`)) {
+ return;
+ }
+
+ try {
+ const response = await fetch(`${apiBase}/message-notifications/account/${accountId}`, {
+ method: 'DELETE',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ showToast('通知配置删除成功', 'success');
+ loadMessageNotifications();
+ } else {
+ const error = await response.text();
+ showToast(`删除失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('删除通知配置失败:', error);
+ showToast('删除通知配置失败', 'danger');
+ }
+}
+
+// 保存账号通知配置
+async function saveAccountNotification() {
+ const accountId = document.getElementById('configAccountId').value;
+ const channelId = document.getElementById('notificationChannel').value;
+ const enabled = document.getElementById('notificationEnabled').checked;
+
+ if (!channelId) {
+ showToast('请选择通知渠道', 'warning');
+ return;
+ }
+
+ try {
+ const response = await fetch(`${apiBase}/message-notifications/${accountId}`, {
+ method: 'POST',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`,
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify({
+ channel_id: parseInt(channelId),
+ enabled: enabled
+ })
+ });
+
+ if (response.ok) {
+ showToast('通知配置保存成功', 'success');
+ const modal = bootstrap.Modal.getInstance(document.getElementById('configNotificationModal'));
+ modal.hide();
+ loadMessageNotifications();
+ } else {
+ const error = await response.text();
+ showToast(`保存失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('保存通知配置失败:', error);
+ showToast('保存通知配置失败', 'danger');
+ }
+}
+
+// ================================
+// 【卡券管理菜单】相关功能
+// ================================
+
+// 加载卡券列表
+async function loadCards() {
+ try {
+ const response = await fetch(`${apiBase}/cards`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const cards = await response.json();
+ renderCardsList(cards);
+ updateCardsStats(cards);
+ } else {
+ showToast('加载卡券列表失败', 'danger');
+ }
+ } catch (error) {
+ console.error('加载卡券列表失败:', error);
+ showToast('加载卡券列表失败', 'danger');
+ }
+}
+
+// 渲染卡券列表
+function renderCardsList(cards) {
+ const tbody = document.getElementById('cardsTableBody');
+
+ if (cards.length === 0) {
+ tbody.innerHTML = `
+
+
+
+ 暂无卡券数据
+ 点击"添加卡券"开始创建您的第一个卡券
+ |
+
+ `;
+ return;
+ }
+
+ tbody.innerHTML = '';
+
+ cards.forEach(card => {
+ const tr = document.createElement('tr');
+
+ // 类型标签
+ let typeBadge = '';
+ switch(card.type) {
+ case 'api':
+ typeBadge = 'API接口';
+ break;
+ case 'text':
+ typeBadge = '固定文字';
+ break;
+ case 'data':
+ typeBadge = '批量数据';
+ break;
+ case 'image':
+ typeBadge = '图片';
+ break;
+ }
+
+ // 状态标签
+ const statusBadge = card.enabled ?
+ '启用' :
+ '禁用';
+
+ // 数据量显示
+ let dataCount = '-';
+ if (card.type === 'data' && card.data_content) {
+ const lines = card.data_content.split('\n').filter(line => line.trim());
+ dataCount = lines.length;
+ } else if (card.type === 'api') {
+ dataCount = '∞';
+ } else if (card.type === 'text') {
+ dataCount = '1';
+ } else if (card.type === 'image') {
+ dataCount = '1';
+ }
+
+ // 延时时间显示
+ const delayDisplay = card.delay_seconds > 0 ?
+ `${card.delay_seconds}秒` :
+ '立即';
+
+ // 规格信息显示
+ let specDisplay = '普通卡券';
+ if (card.is_multi_spec && card.spec_name && card.spec_value) {
+ specDisplay = `${card.spec_name}: ${card.spec_value}`;
+ }
+
+ tr.innerHTML = `
+
+ ${card.name}
+ ${card.description ? `${card.description}` : ''}
+ |
+ ${typeBadge} |
+ ${specDisplay} |
+ ${dataCount} |
+ ${delayDisplay} |
+ ${statusBadge} |
+
+ ${formatDateTime(card.created_at)}
+ |
+
+
+
+
+
+
+ |
+ `;
+
+ tbody.appendChild(tr);
+ });
+}
+
+// 更新卡券统计
+function updateCardsStats(cards) {
+ const totalCards = cards.length;
+ const apiCards = cards.filter(card => card.type === 'api').length;
+ const textCards = cards.filter(card => card.type === 'text').length;
+ const dataCards = cards.filter(card => card.type === 'data').length;
+
+ document.getElementById('totalCards').textContent = totalCards;
+ document.getElementById('apiCards').textContent = apiCards;
+ document.getElementById('textCards').textContent = textCards;
+ document.getElementById('dataCards').textContent = dataCards;
+}
+
+// 显示添加卡券模态框
+function showAddCardModal() {
+ document.getElementById('addCardForm').reset();
+ toggleCardTypeFields();
+ const modal = new bootstrap.Modal(document.getElementById('addCardModal'));
+ modal.show();
+}
+
+// 切换卡券类型字段显示
+function toggleCardTypeFields() {
+ const cardType = document.getElementById('cardType').value;
+
+ document.getElementById('apiFields').style.display = cardType === 'api' ? 'block' : 'none';
+ document.getElementById('textFields').style.display = cardType === 'text' ? 'block' : 'none';
+ document.getElementById('dataFields').style.display = cardType === 'data' ? 'block' : 'none';
+ document.getElementById('imageFields').style.display = cardType === 'image' ? 'block' : 'none';
+
+ // 如果是API类型,初始化API方法监听
+ if (cardType === 'api') {
+ toggleApiParamsHelp();
+ // 添加API方法变化监听
+ const apiMethodSelect = document.getElementById('apiMethod');
+ if (apiMethodSelect) {
+ apiMethodSelect.removeEventListener('change', toggleApiParamsHelp);
+ apiMethodSelect.addEventListener('change', toggleApiParamsHelp);
+ }
+ }
+}
+
+// 切换API参数提示显示
+function toggleApiParamsHelp() {
+ const apiMethod = document.getElementById('apiMethod').value;
+ const postParamsHelp = document.getElementById('postParamsHelp');
+
+ if (postParamsHelp) {
+ postParamsHelp.style.display = apiMethod === 'POST' ? 'block' : 'none';
+
+ // 如果显示参数提示,添加点击事件
+ if (apiMethod === 'POST') {
+ initParamClickHandlers('apiParams', 'postParamsHelp');
+ }
+ }
+}
+
+// 初始化参数点击处理器
+function initParamClickHandlers(textareaId, containerId) {
+ const container = document.getElementById(containerId);
+ const textarea = document.getElementById(textareaId);
+
+ if (!container || !textarea) return;
+
+ // 移除现有的点击事件监听器
+ const paramNames = container.querySelectorAll('.param-name');
+ paramNames.forEach(paramName => {
+ paramName.removeEventListener('click', handleParamClick);
+ });
+
+ // 添加新的点击事件监听器
+ paramNames.forEach(paramName => {
+ paramName.addEventListener('click', function() {
+ handleParamClick(this, textarea);
+ });
+ });
+}
+
+// 处理参数点击事件
+function handleParamClick(paramElement, textarea) {
+ const paramName = paramElement.textContent.trim();
+ const paramValue = `{${paramName}}`;
+
+ try {
+ // 获取当前textarea的值
+ let currentValue = textarea.value.trim();
+
+ // 如果当前值为空或不是有效的JSON,创建新的JSON对象
+ if (!currentValue || currentValue === '{}') {
+ const newJson = {};
+ newJson[paramName] = paramValue;
+ textarea.value = JSON.stringify(newJson, null, 2);
+ } else {
+ // 尝试解析现有的JSON
+ let jsonObj;
+ try {
+ jsonObj = JSON.parse(currentValue);
+ } catch (e) {
+ // 如果解析失败,创建新的JSON对象
+ jsonObj = {};
+ }
+
+ // 添加新参数
+ jsonObj[paramName] = paramValue;
+
+ // 更新textarea
+ textarea.value = JSON.stringify(jsonObj, null, 2);
+ }
+
+ // 触发change事件
+ textarea.dispatchEvent(new Event('change'));
+
+ // 显示成功提示
+ showToast(`已添加参数: ${paramName}`, 'success');
+
+ } catch (error) {
+ console.error('添加参数时出错:', error);
+ showToast('添加参数失败', 'danger');
+ }
+}
+
+// 切换多规格字段显示
+function toggleMultiSpecFields() {
+ const isMultiSpec = document.getElementById('isMultiSpec').checked;
+ document.getElementById('multiSpecFields').style.display = isMultiSpec ? 'block' : 'none';
+}
+
+// 初始化卡券图片文件选择器
+function initCardImageFileSelector() {
+ const fileInput = document.getElementById('cardImageFile');
+ if (fileInput) {
+ fileInput.addEventListener('change', function(e) {
+ const file = e.target.files[0];
+ if (file) {
+ // 验证文件类型
+ if (!file.type.startsWith('image/')) {
+ showToast('❌ 请选择图片文件,当前文件类型:' + file.type, 'warning');
+ e.target.value = '';
+ hideCardImagePreview();
+ return;
+ }
+
+ // 验证文件大小(5MB)
+ if (file.size > 5 * 1024 * 1024) {
+ showToast('❌ 图片文件大小不能超过 5MB,当前文件大小:' + (file.size / 1024 / 1024).toFixed(1) + 'MB', 'warning');
+ e.target.value = '';
+ hideCardImagePreview();
+ return;
+ }
+
+ // 验证图片尺寸
+ validateCardImageDimensions(file, e.target);
+ } else {
+ hideCardImagePreview();
+ }
+ });
+ }
+}
+
+// 验证卡券图片尺寸
+function validateCardImageDimensions(file, inputElement) {
+ const img = new Image();
+ const url = URL.createObjectURL(file);
+
+ img.onload = function() {
+ const width = this.naturalWidth;
+ const height = this.naturalHeight;
+
+ // 释放对象URL
+ URL.revokeObjectURL(url);
+
+ // 检查图片尺寸
+ const maxDimension = 4096;
+ const maxPixels = 8 * 1024 * 1024; // 8M像素
+ const totalPixels = width * height;
+
+ if (width > maxDimension || height > maxDimension) {
+ showToast(`❌ 图片尺寸过大:${width}x${height},最大允许:${maxDimension}x${maxDimension}像素`, 'warning');
+ inputElement.value = '';
+ hideCardImagePreview();
+ return;
+ }
+
+ if (totalPixels > maxPixels) {
+ showToast(`❌ 图片像素总数过大:${(totalPixels / 1024 / 1024).toFixed(1)}M像素,最大允许:8M像素`, 'warning');
+ inputElement.value = '';
+ hideCardImagePreview();
+ return;
+ }
+
+ // 尺寸检查通过,显示预览和提示信息
+ showCardImagePreview(file);
+
+ // 如果图片较大,提示会被压缩
+ if (width > 2048 || height > 2048) {
+ showToast(`ℹ️ 图片尺寸较大(${width}x${height}),上传时将自动压缩以优化性能`, 'info');
+ } else {
+ showToast(`✅ 图片尺寸合适(${width}x${height}),可以上传`, 'success');
+ }
+ };
+
+ img.onerror = function() {
+ URL.revokeObjectURL(url);
+ showToast('❌ 无法读取图片文件,请选择有效的图片', 'warning');
+ inputElement.value = '';
+ hideCardImagePreview();
+ };
+
+ img.src = url;
+}
+
+// 显示卡券图片预览
+function showCardImagePreview(file) {
+ const reader = new FileReader();
+ reader.onload = function(e) {
+ const previewContainer = document.getElementById('cardImagePreview');
+ const previewImg = document.getElementById('cardPreviewImg');
+
+ previewImg.src = e.target.result;
+ previewContainer.style.display = 'block';
+ };
+ reader.readAsDataURL(file);
+}
+
+// 隐藏卡券图片预览
+function hideCardImagePreview() {
+ const previewContainer = document.getElementById('cardImagePreview');
+ if (previewContainer) {
+ previewContainer.style.display = 'none';
+ }
+}
+
+// 初始化编辑卡券图片文件选择器
+function initEditCardImageFileSelector() {
+ const fileInput = document.getElementById('editCardImageFile');
+ if (fileInput) {
+ fileInput.addEventListener('change', function(e) {
+ const file = e.target.files[0];
+ if (file) {
+ // 验证文件类型
+ if (!file.type.startsWith('image/')) {
+ showToast('❌ 请选择图片文件,当前文件类型:' + file.type, 'warning');
+ e.target.value = '';
+ hideEditCardImagePreview();
+ return;
+ }
+
+ // 验证文件大小(5MB)
+ if (file.size > 5 * 1024 * 1024) {
+ showToast('❌ 图片文件大小不能超过 5MB,当前文件大小:' + (file.size / 1024 / 1024).toFixed(1) + 'MB', 'warning');
+ e.target.value = '';
+ hideEditCardImagePreview();
+ return;
+ }
+
+ // 验证图片尺寸
+ validateEditCardImageDimensions(file, e.target);
+ } else {
+ hideEditCardImagePreview();
+ }
+ });
+ }
+}
+
+// 验证编辑卡券图片尺寸
+function validateEditCardImageDimensions(file, inputElement) {
+ const img = new Image();
+ const url = URL.createObjectURL(file);
+
+ img.onload = function() {
+ const width = this.naturalWidth;
+ const height = this.naturalHeight;
+
+ URL.revokeObjectURL(url);
+
+ // 检查尺寸限制
+ if (width > 4096 || height > 4096) {
+ showToast(`❌ 图片尺寸过大(${width}x${height}),最大支持 4096x4096 像素`, 'warning');
+ inputElement.value = '';
+ hideEditCardImagePreview();
+ return;
+ }
+
+ // 显示图片预览
+ showEditCardImagePreview(file);
+
+ // 如果图片较大,提示会被压缩
+ if (width > 2048 || height > 2048) {
+ showToast(`ℹ️ 图片尺寸较大(${width}x${height}),上传时将自动压缩以优化性能`, 'info');
+ } else {
+ showToast(`✅ 图片尺寸合适(${width}x${height}),可以上传`, 'success');
+ }
+ };
+
+ img.onerror = function() {
+ URL.revokeObjectURL(url);
+ showToast('❌ 无法读取图片文件,请选择有效的图片', 'warning');
+ inputElement.value = '';
+ hideEditCardImagePreview();
+ };
+
+ img.src = url;
+}
+
+// 显示编辑卡券图片预览
+function showEditCardImagePreview(file) {
+ const reader = new FileReader();
+ reader.onload = function(e) {
+ const previewImg = document.getElementById('editCardPreviewImg');
+ const previewContainer = document.getElementById('editCardImagePreview');
+
+ if (previewImg && previewContainer) {
+ previewImg.src = e.target.result;
+ previewContainer.style.display = 'block';
+ }
+ };
+ reader.readAsDataURL(file);
+}
+
+// 隐藏编辑卡券图片预览
+function hideEditCardImagePreview() {
+ const previewContainer = document.getElementById('editCardImagePreview');
+ if (previewContainer) {
+ previewContainer.style.display = 'none';
+ }
+}
+
+// 切换编辑多规格字段显示
+function toggleEditMultiSpecFields() {
+ const checkbox = document.getElementById('editIsMultiSpec');
+ const fieldsDiv = document.getElementById('editMultiSpecFields');
+
+ if (!checkbox) {
+ console.error('编辑多规格开关元素未找到');
+ return;
+ }
+
+ if (!fieldsDiv) {
+ console.error('编辑多规格字段容器未找到');
+ return;
+ }
+
+ const isMultiSpec = checkbox.checked;
+ const displayStyle = isMultiSpec ? 'block' : 'none';
+
+ console.log('toggleEditMultiSpecFields - 多规格状态:', isMultiSpec);
+ console.log('toggleEditMultiSpecFields - 设置显示样式:', displayStyle);
+
+ fieldsDiv.style.display = displayStyle;
+
+ // 验证设置是否生效
+ console.log('toggleEditMultiSpecFields - 实际显示样式:', fieldsDiv.style.display);
+}
+
+// 清空添加卡券表单
+function clearAddCardForm() {
+ try {
+ // 安全地清空表单字段
+ const setElementValue = (id, value) => {
+ const element = document.getElementById(id);
+ if (element) {
+ if (element.type === 'checkbox') {
+ element.checked = value;
+ } else {
+ element.value = value;
+ }
+ } else {
+ console.warn(`Element with id '${id}' not found`);
+ }
+ };
+
+ const setElementDisplay = (id, display) => {
+ const element = document.getElementById(id);
+ if (element) {
+ element.style.display = display;
+ } else {
+ console.warn(`Element with id '${id}' not found`);
+ }
+ };
+
+ // 清空基本字段
+ setElementValue('cardName', '');
+ setElementValue('cardType', 'text');
+ setElementValue('cardDescription', '');
+ setElementValue('cardDelaySeconds', '0');
+ setElementValue('isMultiSpec', false);
+ setElementValue('specName', '');
+ setElementValue('specValue', '');
+
+ // 隐藏多规格字段
+ setElementDisplay('multiSpecFields', 'none');
+
+ // 清空类型相关字段
+ setElementValue('textContent', '');
+ setElementValue('dataContent', '');
+ setElementValue('apiUrl', '');
+ setElementValue('apiMethod', 'GET');
+ setElementValue('apiHeaders', '');
+ setElementValue('apiParams', '');
+ setElementValue('apiTimeout', '10');
+
+ // 重置字段显示
+ toggleCardTypeFields();
+ } catch (error) {
+ console.error('清空表单时出错:', error);
+ }
+}
+
+// 保存卡券
+async function saveCard() {
+ try {
+ const cardType = document.getElementById('cardType').value;
+ const cardName = document.getElementById('cardName').value;
+
+ if (!cardType || !cardName) {
+ showToast('请填写必填字段', 'warning');
+ return;
+ }
+
+ // 检查多规格设置
+ const isMultiSpec = document.getElementById('isMultiSpec').checked;
+ const specName = document.getElementById('specName').value;
+ const specValue = document.getElementById('specValue').value;
+
+ // 验证多规格字段
+ if (isMultiSpec && (!specName || !specValue)) {
+ showToast('多规格卡券必须填写规格名称和规格值', 'warning');
+ return;
+ }
+
+ const cardData = {
+ name: cardName,
+ type: cardType,
+ description: document.getElementById('cardDescription').value,
+ delay_seconds: parseInt(document.getElementById('cardDelaySeconds').value) || 0,
+ enabled: true,
+ is_multi_spec: isMultiSpec,
+ spec_name: isMultiSpec ? specName : null,
+ spec_value: isMultiSpec ? specValue : null
+ };
+
+ // 根据类型添加特定配置
+ switch(cardType) {
+ case 'api':
+ // 验证和解析JSON字段
+ let headers = '{}';
+ let params = '{}';
+
+ try {
+ const headersInput = document.getElementById('apiHeaders').value.trim();
+ if (headersInput) {
+ JSON.parse(headersInput); // 验证JSON格式
+ headers = headersInput;
+ }
+ } catch (e) {
+ showToast('请求头格式错误,请输入有效的JSON', 'warning');
+ return;
+ }
+
+ try {
+ const paramsInput = document.getElementById('apiParams').value.trim();
+ if (paramsInput) {
+ JSON.parse(paramsInput); // 验证JSON格式
+ params = paramsInput;
+ }
+ } catch (e) {
+ showToast('请求参数格式错误,请输入有效的JSON', 'warning');
+ return;
+ }
+
+ cardData.api_config = {
+ url: document.getElementById('apiUrl').value,
+ method: document.getElementById('apiMethod').value,
+ timeout: parseInt(document.getElementById('apiTimeout').value),
+ headers: headers,
+ params: params
+ };
+ break;
+ case 'text':
+ cardData.text_content = document.getElementById('textContent').value;
+ break;
+ case 'data':
+ cardData.data_content = document.getElementById('dataContent').value;
+ break;
+ case 'image':
+ // 处理图片上传
+ const imageFile = document.getElementById('cardImageFile').files[0];
+ if (!imageFile) {
+ showToast('请选择图片文件', 'warning');
+ return;
+ }
+
+ // 上传图片
+ const formData = new FormData();
+ formData.append('image', imageFile);
+
+ const uploadResponse = await fetch(`${apiBase}/upload-image`, {
+ method: 'POST',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: formData
+ });
+
+ if (!uploadResponse.ok) {
+ const errorData = await uploadResponse.json();
+ showToast(`图片上传失败: ${errorData.detail || '未知错误'}`, 'danger');
+ return;
+ }
+
+ const uploadResult = await uploadResponse.json();
+ cardData.image_url = uploadResult.image_url;
+ break;
+ }
+
+ const response = await fetch(`${apiBase}/cards`, {
+ method: 'POST',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`,
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify(cardData)
+ });
+
+ if (response.ok) {
+ showToast('卡券保存成功', 'success');
+ bootstrap.Modal.getInstance(document.getElementById('addCardModal')).hide();
+ // 清空表单
+ clearAddCardForm();
+ loadCards();
+ } else {
+ let errorMessage = '保存失败';
+ try {
+ const errorData = await response.json();
+ errorMessage = errorData.error || errorData.detail || errorMessage;
+ } catch (e) {
+ // 如果不是JSON格式,尝试获取文本
+ try {
+ const errorText = await response.text();
+ errorMessage = errorText || errorMessage;
+ } catch (e2) {
+ errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+ }
+ }
+ showToast(`保存失败: ${errorMessage}`, 'danger');
+ }
+ } catch (error) {
+ console.error('保存卡券失败:', error);
+ showToast(`网络错误: ${error.message}`, 'danger');
+ }
+}
+// ================================
+// 【自动发货菜单】相关功能
+// ================================
+
+// 加载发货规则列表
+async function loadDeliveryRules() {
+ try {
+ const response = await fetch(`${apiBase}/delivery-rules`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const rules = await response.json();
+ renderDeliveryRulesList(rules);
+ updateDeliveryStats(rules);
+
+ // 同时加载卡券列表用于下拉选择
+ loadCardsForSelect();
+ } else {
+ showToast('加载发货规则失败', 'danger');
+ }
+ } catch (error) {
+ console.error('加载发货规则失败:', error);
+ showToast('加载发货规则失败', 'danger');
+ }
+}
+
+// 渲染发货规则列表
+function renderDeliveryRulesList(rules) {
+ const tbody = document.getElementById('deliveryRulesTableBody');
+
+ if (rules.length === 0) {
+ tbody.innerHTML = `
+
+
+
+ 暂无发货规则
+ 点击"添加规则"开始配置自动发货规则
+ |
+
+ `;
+ return;
+ }
+
+ tbody.innerHTML = '';
+
+ rules.forEach(rule => {
+ const tr = document.createElement('tr');
+
+ // 状态标签
+ const statusBadge = rule.enabled ?
+ '启用' :
+ '禁用';
+
+ // 卡券类型标签
+ let cardTypeBadge = '未知';
+ if (rule.card_type) {
+ switch(rule.card_type) {
+ case 'api':
+ cardTypeBadge = 'API接口';
+ break;
+ case 'text':
+ cardTypeBadge = '固定文字';
+ break;
+ case 'data':
+ cardTypeBadge = '批量数据';
+ break;
+ case 'image':
+ cardTypeBadge = '图片';
+ break;
+ }
+ }
+
+ tr.innerHTML = `
+
+ ${rule.keyword}
+ ${rule.description ? `${rule.description}` : ''}
+ |
+
+
+ ${rule.card_name || '未知卡券'}
+ ${rule.is_multi_spec && rule.spec_name && rule.spec_value ?
+ ` ${rule.spec_name}: ${rule.spec_value}` :
+ ''}
+
+ |
+ ${cardTypeBadge} |
+
+ ${rule.delivery_count || 1}
+ |
+ ${statusBadge} |
+
+ ${rule.delivery_times || 0}
+ |
+
+
+
+
+
+
+ |
+ `;
+
+ tbody.appendChild(tr);
+ });
+}
+
+// 更新发货统计
+function updateDeliveryStats(rules) {
+ const totalRules = rules.length;
+ const activeRules = rules.filter(rule => rule.enabled).length;
+ const todayDeliveries = 0; // 需要从后端获取今日发货统计
+ const totalDeliveries = rules.reduce((sum, rule) => sum + (rule.delivery_times || 0), 0);
+
+ document.getElementById('totalRules').textContent = totalRules;
+ document.getElementById('activeRules').textContent = activeRules;
+ document.getElementById('todayDeliveries').textContent = todayDeliveries;
+ document.getElementById('totalDeliveries').textContent = totalDeliveries;
+}
+
+// 显示添加发货规则模态框
+function showAddDeliveryRuleModal() {
+ document.getElementById('addDeliveryRuleForm').reset();
+ loadCardsForSelect(); // 加载卡券选项
+ const modal = new bootstrap.Modal(document.getElementById('addDeliveryRuleModal'));
+ modal.show();
+}
+
+// 加载卡券列表用于下拉选择
+async function loadCardsForSelect() {
+ try {
+ const response = await fetch(`${apiBase}/cards`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const cards = await response.json();
+ const select = document.getElementById('selectedCard');
+
+ // 清空现有选项
+ select.innerHTML = '';
+
+ cards.forEach(card => {
+ if (card.enabled) { // 只显示启用的卡券
+ const option = document.createElement('option');
+ option.value = card.id;
+
+ // 构建显示文本
+ let displayText = card.name;
+
+ // 添加类型信息
+ let typeText;
+ switch(card.type) {
+ case 'api':
+ typeText = 'API';
+ break;
+ case 'text':
+ typeText = '固定文字';
+ break;
+ case 'data':
+ typeText = '批量数据';
+ break;
+ case 'image':
+ typeText = '图片';
+ break;
+ default:
+ typeText = '未知类型';
+ }
+ displayText += ` (${typeText})`;
+
+ // 添加规格信息
+ if (card.is_multi_spec && card.spec_name && card.spec_value) {
+ displayText += ` [${card.spec_name}:${card.spec_value}]`;
+ }
+
+ option.textContent = displayText;
+ select.appendChild(option);
+ }
+ });
+ }
+ } catch (error) {
+ console.error('加载卡券选项失败:', error);
+ }
+}
+
+// 保存发货规则
+async function saveDeliveryRule() {
+ try {
+ const keyword = document.getElementById('productKeyword').value;
+ const cardId = document.getElementById('selectedCard').value;
+ const deliveryCount = document.getElementById('deliveryCount').value;
+ const enabled = document.getElementById('ruleEnabled').checked;
+ const description = document.getElementById('ruleDescription').value;
+
+ if (!keyword || !cardId) {
+ showToast('请填写必填字段', 'warning');
+ return;
+ }
+
+ const ruleData = {
+ keyword: keyword,
+ card_id: parseInt(cardId),
+ delivery_count: parseInt(deliveryCount),
+ enabled: enabled,
+ description: description
+ };
+
+ const response = await fetch(`${apiBase}/delivery-rules`, {
+ method: 'POST',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`,
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify(ruleData)
+ });
+
+ if (response.ok) {
+ showToast('发货规则保存成功', 'success');
+ bootstrap.Modal.getInstance(document.getElementById('addDeliveryRuleModal')).hide();
+ loadDeliveryRules();
+ } else {
+ const error = await response.text();
+ showToast(`保存失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('保存发货规则失败:', error);
+ showToast('保存发货规则失败', 'danger');
+ }
+}
+
+// 编辑卡券
+async function editCard(cardId) {
+ try {
+ // 获取卡券详情
+ const response = await fetch(`${apiBase}/cards/${cardId}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const card = await response.json();
+
+ // 填充编辑表单
+ document.getElementById('editCardId').value = card.id;
+ document.getElementById('editCardName').value = card.name;
+ document.getElementById('editCardType').value = card.type;
+ document.getElementById('editCardDescription').value = card.description || '';
+ document.getElementById('editCardDelaySeconds').value = card.delay_seconds || 0;
+ document.getElementById('editCardEnabled').checked = card.enabled;
+
+ // 填充多规格字段
+ const isMultiSpec = card.is_multi_spec || false;
+ document.getElementById('editIsMultiSpec').checked = isMultiSpec;
+ document.getElementById('editSpecName').value = card.spec_name || '';
+ document.getElementById('editSpecValue').value = card.spec_value || '';
+
+ // 添加调试日志
+ console.log('编辑卡券 - 多规格状态:', isMultiSpec);
+ console.log('编辑卡券 - 规格名称:', card.spec_name);
+ console.log('编辑卡券 - 规格值:', card.spec_value);
+
+ // 根据类型填充特定字段
+ if (card.type === 'api' && card.api_config) {
+ document.getElementById('editApiUrl').value = card.api_config.url || '';
+ document.getElementById('editApiMethod').value = card.api_config.method || 'GET';
+ document.getElementById('editApiTimeout').value = card.api_config.timeout || 10;
+ document.getElementById('editApiHeaders').value = card.api_config.headers || '{}';
+ document.getElementById('editApiParams').value = card.api_config.params || '{}';
+ } else if (card.type === 'text') {
+ document.getElementById('editTextContent').value = card.text_content || '';
+ } else if (card.type === 'data') {
+ document.getElementById('editDataContent').value = card.data_content || '';
+ } else if (card.type === 'image') {
+ // 处理图片类型
+ const currentImagePreview = document.getElementById('editCurrentImagePreview');
+ const currentImg = document.getElementById('editCurrentImg');
+ const noImageText = document.getElementById('editNoImageText');
+
+ if (card.image_url) {
+ // 显示当前图片
+ currentImg.src = card.image_url;
+ currentImagePreview.style.display = 'block';
+ noImageText.style.display = 'none';
+ } else {
+ // 没有图片
+ currentImagePreview.style.display = 'none';
+ noImageText.style.display = 'block';
+ }
+
+ // 清空文件选择器和预览
+ document.getElementById('editCardImageFile').value = '';
+ document.getElementById('editCardImagePreview').style.display = 'none';
+ }
+
+ // 显示对应的字段
+ toggleEditCardTypeFields();
+
+ // 使用延迟调用确保DOM更新完成后再显示多规格字段
+ setTimeout(() => {
+ console.log('延迟调用 toggleEditMultiSpecFields');
+ toggleEditMultiSpecFields();
+
+ // 验证多规格字段是否正确显示
+ const multiSpecElement = document.getElementById('editMultiSpecFields');
+ const isChecked = document.getElementById('editIsMultiSpec').checked;
+ console.log('多规格元素存在:', !!multiSpecElement);
+ console.log('多规格开关状态:', isChecked);
+ console.log('多规格字段显示状态:', multiSpecElement ? multiSpecElement.style.display : 'element not found');
+ }, 100);
+
+ // 显示模态框
+ const modal = new bootstrap.Modal(document.getElementById('editCardModal'));
+ modal.show();
+ } else {
+ showToast('获取卡券详情失败', 'danger');
+ }
+ } catch (error) {
+ console.error('获取卡券详情失败:', error);
+ showToast('获取卡券详情失败', 'danger');
+ }
+}
+
+// 切换编辑卡券类型字段显示
+function toggleEditCardTypeFields() {
+ const cardType = document.getElementById('editCardType').value;
+
+ document.getElementById('editApiFields').style.display = cardType === 'api' ? 'block' : 'none';
+ document.getElementById('editTextFields').style.display = cardType === 'text' ? 'block' : 'none';
+ document.getElementById('editDataFields').style.display = cardType === 'data' ? 'block' : 'none';
+ document.getElementById('editImageFields').style.display = cardType === 'image' ? 'block' : 'none';
+
+ // 如果是API类型,初始化API方法监听
+ if (cardType === 'api') {
+ toggleEditApiParamsHelp();
+ // 添加API方法变化监听
+ const editApiMethodSelect = document.getElementById('editApiMethod');
+ if (editApiMethodSelect) {
+ editApiMethodSelect.removeEventListener('change', toggleEditApiParamsHelp);
+ editApiMethodSelect.addEventListener('change', toggleEditApiParamsHelp);
+ }
+ }
+}
+
+// 切换编辑API参数提示显示
+function toggleEditApiParamsHelp() {
+ const apiMethod = document.getElementById('editApiMethod').value;
+ const editPostParamsHelp = document.getElementById('editPostParamsHelp');
+
+ if (editPostParamsHelp) {
+ editPostParamsHelp.style.display = apiMethod === 'POST' ? 'block' : 'none';
+
+ // 如果显示参数提示,添加点击事件
+ if (apiMethod === 'POST') {
+ initParamClickHandlers('editApiParams', 'editPostParamsHelp');
+ }
+ }
+}
+
+// 更新卡券
+async function updateCard() {
+ try {
+ const cardId = document.getElementById('editCardId').value;
+ const cardType = document.getElementById('editCardType').value;
+ const cardName = document.getElementById('editCardName').value;
+
+ if (!cardType || !cardName) {
+ showToast('请填写必填字段', 'warning');
+ return;
+ }
+
+ // 检查多规格设置
+ const isMultiSpec = document.getElementById('editIsMultiSpec').checked;
+ const specName = document.getElementById('editSpecName').value;
+ const specValue = document.getElementById('editSpecValue').value;
+
+ // 验证多规格字段
+ if (isMultiSpec && (!specName || !specValue)) {
+ showToast('多规格卡券必须填写规格名称和规格值', 'warning');
+ return;
+ }
+
+ const cardData = {
+ name: cardName,
+ type: cardType,
+ description: document.getElementById('editCardDescription').value,
+ delay_seconds: parseInt(document.getElementById('editCardDelaySeconds').value) || 0,
+ enabled: document.getElementById('editCardEnabled').checked,
+ is_multi_spec: isMultiSpec,
+ spec_name: isMultiSpec ? specName : null,
+ spec_value: isMultiSpec ? specValue : null
+ };
+
+ // 根据类型添加特定配置
+ switch(cardType) {
+ case 'api':
+ // 验证和解析JSON字段
+ let headers = '{}';
+ let params = '{}';
+
+ try {
+ const headersInput = document.getElementById('editApiHeaders').value.trim();
+ if (headersInput) {
+ JSON.parse(headersInput);
+ headers = headersInput;
+ }
+ } catch (e) {
+ showToast('请求头格式错误,请输入有效的JSON', 'warning');
+ return;
+ }
+
+ try {
+ const paramsInput = document.getElementById('editApiParams').value.trim();
+ if (paramsInput) {
+ JSON.parse(paramsInput);
+ params = paramsInput;
+ }
+ } catch (e) {
+ showToast('请求参数格式错误,请输入有效的JSON', 'warning');
+ return;
+ }
+
+ cardData.api_config = {
+ url: document.getElementById('editApiUrl').value,
+ method: document.getElementById('editApiMethod').value,
+ timeout: parseInt(document.getElementById('editApiTimeout').value),
+ headers: headers,
+ params: params
+ };
+ break;
+ case 'text':
+ cardData.text_content = document.getElementById('editTextContent').value;
+ break;
+ case 'data':
+ cardData.data_content = document.getElementById('editDataContent').value;
+ break;
+ case 'image':
+ // 处理图片类型 - 如果有新图片则上传,否则保持原有图片
+ const imageFile = document.getElementById('editCardImageFile').files[0];
+ if (imageFile) {
+ // 有新图片,需要上传
+ await updateCardWithImage(cardId, cardData, imageFile);
+ return; // 提前返回,因为上传图片是异步的
+ }
+ // 没有新图片,保持原有配置,继续正常更新流程
+ break;
+ }
+
+ const response = await fetch(`${apiBase}/cards/${cardId}`, {
+ method: 'PUT',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`,
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify(cardData)
+ });
+
+ if (response.ok) {
+ showToast('卡券更新成功', 'success');
+ bootstrap.Modal.getInstance(document.getElementById('editCardModal')).hide();
+ loadCards();
+ } else {
+ const error = await response.text();
+ showToast(`更新失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('更新卡券失败:', error);
+ showToast('更新卡券失败', 'danger');
+ }
+}
+
+// 更新带图片的卡券
+async function updateCardWithImage(cardId, cardData, imageFile) {
+ try {
+ // 创建FormData对象
+ const formData = new FormData();
+
+ // 添加图片文件
+ formData.append('image', imageFile);
+
+ // 添加卡券数据
+ Object.keys(cardData).forEach(key => {
+ if (cardData[key] !== null && cardData[key] !== undefined) {
+ if (typeof cardData[key] === 'object') {
+ formData.append(key, JSON.stringify(cardData[key]));
+ } else {
+ formData.append(key, cardData[key]);
+ }
+ }
+ });
+
+ const response = await fetch(`${apiBase}/cards/${cardId}/image`, {
+ method: 'PUT',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ // 不设置Content-Type,让浏览器自动设置multipart/form-data
+ },
+ body: formData
+ });
+
+ if (response.ok) {
+ showToast('卡券更新成功', 'success');
+ bootstrap.Modal.getInstance(document.getElementById('editCardModal')).hide();
+ loadCards();
+ } else {
+ const error = await response.text();
+ showToast(`更新失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('更新带图片的卡券失败:', error);
+ showToast('更新卡券失败', 'danger');
+ }
+}
+
+
+
+// 测试卡券(占位函数)
+function testCard(cardId) {
+ showToast('测试功能开发中...', 'info');
+}
+
+// 删除卡券
+async function deleteCard(cardId) {
+ if (confirm('确定要删除这个卡券吗?删除后无法恢复!')) {
+ try {
+ const response = await fetch(`${apiBase}/cards/${cardId}`, {
+ method: 'DELETE',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ showToast('卡券删除成功', 'success');
+ loadCards();
+ } else {
+ const error = await response.text();
+ showToast(`删除失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('删除卡券失败:', error);
+ showToast('删除卡券失败', 'danger');
+ }
+ }
+}
+
+// 编辑发货规则
+async function editDeliveryRule(ruleId) {
+ try {
+ // 获取发货规则详情
+ const response = await fetch(`${apiBase}/delivery-rules/${ruleId}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const rule = await response.json();
+
+ // 填充编辑表单
+ document.getElementById('editRuleId').value = rule.id;
+ document.getElementById('editProductKeyword').value = rule.keyword;
+ document.getElementById('editDeliveryCount').value = rule.delivery_count || 1;
+ document.getElementById('editRuleEnabled').checked = rule.enabled;
+ document.getElementById('editRuleDescription').value = rule.description || '';
+
+ // 加载卡券选项并设置当前选中的卡券
+ await loadCardsForEditSelect();
+ document.getElementById('editSelectedCard').value = rule.card_id;
+
+ // 显示模态框
+ const modal = new bootstrap.Modal(document.getElementById('editDeliveryRuleModal'));
+ modal.show();
+ } else {
+ showToast('获取发货规则详情失败', 'danger');
+ }
+ } catch (error) {
+ console.error('获取发货规则详情失败:', error);
+ showToast('获取发货规则详情失败', 'danger');
+ }
+}
+
+// 加载卡券列表用于编辑时的下拉选择
+async function loadCardsForEditSelect() {
+ try {
+ const response = await fetch(`${apiBase}/cards`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const cards = await response.json();
+ const select = document.getElementById('editSelectedCard');
+
+ // 清空现有选项
+ select.innerHTML = '';
+
+ cards.forEach(card => {
+ if (card.enabled) { // 只显示启用的卡券
+ const option = document.createElement('option');
+ option.value = card.id;
+
+ // 构建显示文本
+ let displayText = card.name;
+
+ // 添加类型信息
+ let typeText;
+ switch(card.type) {
+ case 'api':
+ typeText = 'API';
+ break;
+ case 'text':
+ typeText = '固定文字';
+ break;
+ case 'data':
+ typeText = '批量数据';
+ break;
+ case 'image':
+ typeText = '图片';
+ break;
+ default:
+ typeText = '未知类型';
+ }
+ displayText += ` (${typeText})`;
+
+ // 添加规格信息
+ if (card.is_multi_spec && card.spec_name && card.spec_value) {
+ displayText += ` [${card.spec_name}:${card.spec_value}]`;
+ }
+
+ option.textContent = displayText;
+ select.appendChild(option);
+ }
+ });
+ }
+ } catch (error) {
+ console.error('加载卡券选项失败:', error);
+ }
+}
+
+// 更新发货规则
+async function updateDeliveryRule() {
+ try {
+ const ruleId = document.getElementById('editRuleId').value;
+ const keyword = document.getElementById('editProductKeyword').value;
+ const cardId = document.getElementById('editSelectedCard').value;
+ const deliveryCount = document.getElementById('editDeliveryCount').value;
+ const enabled = document.getElementById('editRuleEnabled').checked;
+ const description = document.getElementById('editRuleDescription').value;
+
+ if (!keyword || !cardId) {
+ showToast('请填写必填字段', 'warning');
+ return;
+ }
+
+ const ruleData = {
+ keyword: keyword,
+ card_id: parseInt(cardId),
+ delivery_count: parseInt(deliveryCount),
+ enabled: enabled,
+ description: description
+ };
+
+ const response = await fetch(`${apiBase}/delivery-rules/${ruleId}`, {
+ method: 'PUT',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`,
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify(ruleData)
+ });
+
+ if (response.ok) {
+ showToast('发货规则更新成功', 'success');
+ bootstrap.Modal.getInstance(document.getElementById('editDeliveryRuleModal')).hide();
+ loadDeliveryRules();
+ } else {
+ const error = await response.text();
+ showToast(`更新失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('更新发货规则失败:', error);
+ showToast('更新发货规则失败', 'danger');
+ }
+}
+
+// 测试发货规则(占位函数)
+function testDeliveryRule(ruleId) {
+ showToast('测试功能开发中...', 'info');
+}
+
+// 删除发货规则
+async function deleteDeliveryRule(ruleId) {
+ if (confirm('确定要删除这个发货规则吗?删除后无法恢复!')) {
+ try {
+ const response = await fetch(`${apiBase}/delivery-rules/${ruleId}`, {
+ method: 'DELETE',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ showToast('发货规则删除成功', 'success');
+ loadDeliveryRules();
+ } else {
+ const error = await response.text();
+ showToast(`删除失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('删除发货规则失败:', error);
+ showToast('删除发货规则失败', 'danger');
+ }
+ }
+}
+
+
+
+// ==================== 系统设置功能 ====================
+
+// 主题颜色映射
+const themeColors = {
+ blue: '#4f46e5',
+ green: '#10b981',
+ purple: '#8b5cf6',
+ red: '#ef4444',
+ orange: '#f59e0b'
+};
+
+// 加载用户设置
+async function loadUserSettings() {
+ try {
+ const response = await fetch(`${apiBase}/user-settings`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const settings = await response.json();
+
+ // 设置主题颜色
+ if (settings.theme_color && settings.theme_color.value) {
+ document.getElementById('themeColor').value = settings.theme_color.value;
+ applyThemeColor(settings.theme_color.value);
+ }
+ }
+ } catch (error) {
+ console.error('加载用户设置失败:', error);
+ }
+}
+
+// 应用主题颜色
+function applyThemeColor(colorName) {
+ const color = themeColors[colorName];
+ if (color) {
+ document.documentElement.style.setProperty('--primary-color', color);
+
+ // 计算hover颜色(稍微深一点)
+ const hoverColor = adjustBrightness(color, -20);
+ document.documentElement.style.setProperty('--primary-hover', hoverColor);
+
+ // 计算浅色版本(用于某些UI元素)
+ const lightColor = adjustBrightness(color, 10);
+ document.documentElement.style.setProperty('--primary-light', lightColor);
+ }
+}
+
+// 调整颜色亮度
+function adjustBrightness(hex, percent) {
+ const num = parseInt(hex.replace("#", ""), 16);
+ const amt = Math.round(2.55 * percent);
+ const R = (num >> 16) + amt;
+ const G = (num >> 8 & 0x00FF) + amt;
+ const B = (num & 0x0000FF) + amt;
+ return "#" + (0x1000000 + (R < 255 ? R < 1 ? 0 : R : 255) * 0x10000 +
+ (G < 255 ? G < 1 ? 0 : G : 255) * 0x100 +
+ (B < 255 ? B < 1 ? 0 : B : 255)).toString(16).slice(1);
+}
+
+// 主题表单提交处理
+document.addEventListener('DOMContentLoaded', function() {
+ const themeForm = document.getElementById('themeForm');
+ if (themeForm) {
+ themeForm.addEventListener('submit', async function(e) {
+ e.preventDefault();
+
+ const selectedColor = document.getElementById('themeColor').value;
+
+ try {
+ const response = await fetch(`${apiBase}/user-settings/theme_color`, {
+ method: 'PUT',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`,
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify({
+ value: selectedColor,
+ description: '主题颜色'
+ })
+ });
+
+ if (response.ok) {
+ applyThemeColor(selectedColor);
+ showToast('主题颜色应用成功', 'success');
+ } else {
+ const error = await response.text();
+ showToast(`主题设置失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('主题设置失败:', error);
+ showToast('主题设置失败', 'danger');
+ }
+ });
+ }
+
+ // 密码表单提交处理
+ const passwordForm = document.getElementById('passwordForm');
+ if (passwordForm) {
+ passwordForm.addEventListener('submit', async function(e) {
+ e.preventDefault();
+
+ const currentPassword = document.getElementById('currentPassword').value;
+ const newPassword = document.getElementById('newPassword').value;
+ const confirmPassword = document.getElementById('confirmPassword').value;
+
+ if (newPassword !== confirmPassword) {
+ showToast('新密码和确认密码不匹配', 'warning');
+ return;
+ }
+
+ if (newPassword.length < 6) {
+ showToast('新密码长度至少6位', 'warning');
+ return;
+ }
+
+ try {
+ const response = await fetch(`${apiBase}/change-admin-password`, {
+ method: 'POST',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`,
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify({
+ current_password: currentPassword,
+ new_password: newPassword
+ })
+ });
+
+ if (response.ok) {
+ const result = await response.json();
+ if (result.success) {
+ showToast('密码更新成功,请重新登录', 'success');
+ passwordForm.reset();
+ // 3秒后跳转到登录页面
+ setTimeout(() => {
+ localStorage.removeItem('auth_token');
+ window.location.href = '/login.html';
+ }, 3000);
+ } else {
+ showToast(`密码更新失败: ${result.message}`, 'danger');
+ }
+ } else {
+ const error = await response.text();
+ showToast(`密码更新失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('密码更新失败:', error);
+ showToast('密码更新失败', 'danger');
+ }
+ });
+ }
+
+ // 页面加载时加载用户设置
+ loadUserSettings();
+});
+
+// ==================== 备份管理功能 ====================
+
+// 下载数据库备份
+async function downloadDatabaseBackup() {
+ try {
+ showToast('正在准备数据库备份,请稍候...', 'info');
+
+ const response = await fetch(`${apiBase}/admin/backup/download`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ // 获取文件名
+ const contentDisposition = response.headers.get('content-disposition');
+ let filename = 'xianyu_backup.db';
+ if (contentDisposition) {
+ const filenameMatch = contentDisposition.match(/filename="(.+)"/);
+ if (filenameMatch) {
+ filename = filenameMatch[1];
+ }
+ }
+
+ // 下载文件
+ const blob = await response.blob();
+ const url = window.URL.createObjectURL(blob);
+ const a = document.createElement('a');
+ a.href = url;
+ a.download = filename;
+ document.body.appendChild(a);
+ a.click();
+ document.body.removeChild(a);
+ window.URL.revokeObjectURL(url);
+
+ showToast('数据库备份下载成功', 'success');
+ } else {
+ const error = await response.text();
+ showToast(`下载失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('下载数据库备份失败:', error);
+ showToast('下载数据库备份失败', 'danger');
+ }
+}
+
+// 上传数据库备份
+async function uploadDatabaseBackup() {
+ const fileInput = document.getElementById('databaseFile');
+ const file = fileInput.files[0];
+
+ if (!file) {
+ showToast('请选择数据库文件', 'warning');
+ return;
+ }
+
+ if (!file.name.endsWith('.db')) {
+ showToast('只支持.db格式的数据库文件', 'warning');
+ return;
+ }
+
+ // 文件大小检查(限制100MB)
+ if (file.size > 100 * 1024 * 1024) {
+ showToast('数据库文件大小不能超过100MB', 'warning');
+ return;
+ }
+
+ if (!confirm('恢复数据库将完全替换当前所有数据,包括所有用户、Cookie、卡券等信息。\n\n此操作不可撤销!\n\n确定要继续吗?')) {
+ return;
+ }
+
+ try {
+ showToast('正在上传并恢复数据库,请稍候...', 'info');
+
+ const formData = new FormData();
+ formData.append('backup_file', file);
+
+ const response = await fetch(`${apiBase}/admin/backup/upload`, {
+ method: 'POST',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: formData
+ });
+
+ if (response.ok) {
+ const result = await response.json();
+ showToast(`数据库恢复成功!包含 ${result.user_count} 个用户`, 'success');
+
+ // 清空文件选择
+ fileInput.value = '';
+
+ // 提示用户刷新页面
+ setTimeout(() => {
+ if (confirm('数据库已恢复,建议刷新页面以加载新数据。是否立即刷新?')) {
+ window.location.reload();
+ }
+ }, 2000);
+
+ } else {
+ const error = await response.json();
+ showToast(`恢复失败: ${error.detail}`, 'danger');
+ }
+ } catch (error) {
+ console.error('上传数据库备份失败:', error);
+ showToast('上传数据库备份失败', 'danger');
+ }
+}
+
+// 导出备份(JSON格式,兼容旧版本)
+async function exportBackup() {
+ try {
+ showToast('正在导出备份,请稍候...', 'info');
+
+ const response = await fetch(`${apiBase}/backup/export`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const backupData = await response.json();
+
+ // 生成文件名
+ const now = new Date();
+ const timestamp = now.getFullYear() +
+ String(now.getMonth() + 1).padStart(2, '0') +
+ String(now.getDate()).padStart(2, '0') + '_' +
+ String(now.getHours()).padStart(2, '0') +
+ String(now.getMinutes()).padStart(2, '0') +
+ String(now.getSeconds()).padStart(2, '0');
+ const filename = `xianyu_backup_${timestamp}.json`;
+
+ // 创建下载链接
+ const blob = new Blob([JSON.stringify(backupData, null, 2)], { type: 'application/json' });
+ const url = window.URL.createObjectURL(blob);
+ const a = document.createElement('a');
+ a.href = url;
+ a.download = filename;
+ document.body.appendChild(a);
+ a.click();
+ document.body.removeChild(a);
+ window.URL.revokeObjectURL(url);
+
+ showToast('备份导出成功', 'success');
+ } else {
+ const error = await response.text();
+ showToast(`导出失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('导出备份失败:', error);
+ showToast('导出备份失败', 'danger');
+ }
+}
+
+// 导入备份
+async function importBackup() {
+ const fileInput = document.getElementById('backupFile');
+ const file = fileInput.files[0];
+
+ if (!file) {
+ showToast('请选择备份文件', 'warning');
+ return;
+ }
+
+ if (!file.name.endsWith('.json')) {
+ showToast('只支持JSON格式的备份文件', 'warning');
+ return;
+ }
+
+ if (!confirm('导入备份将覆盖当前所有数据,确定要继续吗?')) {
+ return;
+ }
+
+ try {
+ showToast('正在导入备份,请稍候...', 'info');
+
+ const formData = new FormData();
+ formData.append('file', file);
+
+ const response = await fetch(`${apiBase}/backup/import`, {
+ method: 'POST',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: formData
+ });
+
+ if (response.ok) {
+ showToast('备份导入成功!正在刷新数据...', 'success');
+
+ // 清空文件选择
+ fileInput.value = '';
+
+ // 清除前端缓存
+ clearKeywordCache();
+
+ // 延迟一下再刷新数据,确保后端缓存已更新
+ setTimeout(async () => {
+ try {
+ // 如果当前在关键字管理页面,重新加载数据
+ if (currentCookieId) {
+ await loadAccountKeywords();
+ }
+
+ // 刷新仪表盘数据
+ if (document.getElementById('dashboard-section').classList.contains('active')) {
+ await loadDashboard();
+ }
+
+ // 刷新账号列表
+ if (document.getElementById('accounts-section').classList.contains('active')) {
+ await loadCookies();
+ }
+
+ showToast('数据刷新完成!', 'success');
+ } catch (error) {
+ console.error('刷新数据失败:', error);
+ showToast('备份导入成功,但数据刷新失败,请手动刷新页面', 'warning');
+ }
+ }, 1000);
+ } else {
+ const error = await response.text();
+ showToast(`导入失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('导入备份失败:', error);
+ showToast('导入备份失败', 'danger');
+ }
+}
+
+// 刷新系统缓存
+async function reloadSystemCache() {
+ try {
+ showToast('正在刷新系统缓存...', 'info');
+
+ const response = await fetch(`${apiBase}/system/reload-cache`, {
+ method: 'POST',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const result = await response.json();
+ showToast('系统缓存刷新成功!关键字等数据已更新', 'success');
+
+ // 清除前端缓存
+ clearKeywordCache();
+
+ // 如果当前在关键字管理页面,重新加载数据
+ if (currentCookieId) {
+ setTimeout(() => {
+ loadAccountKeywords();
+ }, 500);
+ }
+ } else {
+ const error = await response.text();
+ showToast(`刷新缓存失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('刷新系统缓存失败:', error);
+ showToast('刷新系统缓存失败', 'danger');
+ }
+}
+
+// ================================
+// 【商品管理菜单】相关功能
+// ================================
+
+// 切换商品多规格状态
+async function toggleItemMultiSpec(cookieId, itemId, isMultiSpec) {
+ try {
+ const response = await fetch(`${apiBase}/items/${encodeURIComponent(cookieId)}/${encodeURIComponent(itemId)}/multi-spec`, {
+ method: 'PUT',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify({
+ is_multi_spec: isMultiSpec
+ })
+ });
+
+ if (response.ok) {
+ showToast(`${isMultiSpec ? '开启' : '关闭'}多规格成功`, 'success');
+ // 刷新商品列表
+ await refreshItemsData();
+ } else {
+ const errorData = await response.json();
+ throw new Error(errorData.error || '操作失败');
+ }
+ } catch (error) {
+ console.error('切换多规格状态失败:', error);
+ showToast(`切换多规格状态失败: ${error.message}`, 'danger');
+ }
+}
+
+// 切换商品多数量发货状态
+async function toggleItemMultiQuantityDelivery(cookieId, itemId, multiQuantityDelivery) {
+ try {
+ const response = await fetch(`${apiBase}/items/${encodeURIComponent(cookieId)}/${encodeURIComponent(itemId)}/multi-quantity-delivery`, {
+ method: 'PUT',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify({
+ multi_quantity_delivery: multiQuantityDelivery
+ })
+ });
+
+ if (response.ok) {
+ showToast(`${multiQuantityDelivery ? '开启' : '关闭'}多数量发货成功`, 'success');
+ // 刷新商品列表
+ await refreshItemsData();
+ } else {
+ const errorData = await response.json();
+ throw new Error(errorData.error || '操作失败');
+ }
+ } catch (error) {
+ console.error('切换多数量发货状态失败:', error);
+ showToast(`切换多数量发货状态失败: ${error.message}`, 'danger');
+ }
+}
+
+// 加载商品列表
+async function loadItems() {
+ try {
+ // 先加载Cookie列表用于筛选
+ await loadCookieFilter('itemCookieFilter');
+
+ // 加载商品列表
+ await refreshItemsData();
+ } catch (error) {
+ console.error('加载商品列表失败:', error);
+ showToast('加载商品列表失败', 'danger');
+ }
+}
+
+// 只刷新商品数据,不重新加载筛选器
+async function refreshItemsData() {
+ try {
+ const selectedCookie = document.getElementById('itemCookieFilter').value;
+ if (selectedCookie) {
+ await loadItemsByCookie();
+ } else {
+ await loadAllItems();
+ }
+ } catch (error) {
+ console.error('刷新商品数据失败:', error);
+ showToast('刷新商品数据失败', 'danger');
+ }
+}
+
+// 加载Cookie筛选选项
+async function loadCookieFilter(id) {
+ try {
+ const response = await fetch(`${apiBase}/cookies/details`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const accounts = await response.json();
+ const select = document.getElementById(id);
+
+ // 保存当前选择的值
+ const currentValue = select.value;
+
+ // 清空现有选项(保留"所有账号")
+ select.innerHTML = '';
+
+ if (accounts.length === 0) {
+ const option = document.createElement('option');
+ option.value = '';
+ option.textContent = '❌ 暂无账号';
+ option.disabled = true;
+ select.appendChild(option);
+ return;
+ }
+
+ // 分组显示:先显示启用的账号,再显示禁用的账号
+ const enabledAccounts = accounts.filter(account => {
+ const enabled = account.enabled === undefined ? true : account.enabled;
+ return enabled;
+ });
+ const disabledAccounts = accounts.filter(account => {
+ const enabled = account.enabled === undefined ? true : account.enabled;
+ return !enabled;
+ });
+
+ // 添加启用的账号
+ enabledAccounts.forEach(account => {
+ const option = document.createElement('option');
+ option.value = account.id;
+ option.textContent = `🟢 ${account.id}`;
+ select.appendChild(option);
+ });
+
+ // 添加禁用的账号
+ if (disabledAccounts.length > 0) {
+ // 添加分隔线
+ if (enabledAccounts.length > 0) {
+ const separator = document.createElement('option');
+ separator.value = '';
+ separator.textContent = '────────────────';
+ separator.disabled = true;
+ select.appendChild(separator);
+ }
+
+ disabledAccounts.forEach(account => {
+ const option = document.createElement('option');
+ option.value = account.id;
+ option.textContent = `🔴 ${account.id} (已禁用)`;
+ select.appendChild(option);
+ });
+ }
+
+ // 恢复之前选择的值
+ if (currentValue) {
+ select.value = currentValue;
+ }
+ }
+ } catch (error) {
+ console.error('加载Cookie列表失败:', error);
+ showToast('加载账号列表失败', 'danger');
+ }
+}
+
+// 加载所有商品
+async function loadAllItems() {
+ try {
+ const response = await fetch(`${apiBase}/items`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ displayItems(data.items);
+ } else {
+ throw new Error('获取商品列表失败');
+ }
+ } catch (error) {
+ console.error('加载商品列表失败:', error);
+ showToast('加载商品列表失败', 'danger');
+ }
+}
+
+// 按Cookie加载商品
+async function loadItemsByCookie() {
+ const cookieId = document.getElementById('itemCookieFilter').value;
+
+ if (!cookieId) {
+ await loadAllItems();
+ return;
+ }
+
+ try {
+ const response = await fetch(`${apiBase}/items/cookie/${encodeURIComponent(cookieId)}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ displayItems(data.items);
+ } else {
+ throw new Error('获取商品列表失败');
+ }
+ } catch (error) {
+ console.error('加载商品列表失败:', error);
+ showToast('加载商品列表失败', 'danger');
+ }
+}
+
+// 显示商品列表
+function displayItems(items) {
+ // 存储所有商品数据
+ allItemsData = items || [];
+
+ // 应用搜索过滤
+ applyItemsFilter();
+
+ // 显示当前页数据
+ displayCurrentPageItems();
+
+ // 更新分页控件
+ updateItemsPagination();
+}
+
+// 应用搜索过滤
+function applyItemsFilter() {
+ const searchKeyword = currentSearchKeyword.toLowerCase().trim();
+
+ if (!searchKeyword) {
+ filteredItemsData = [...allItemsData];
+ } else {
+ filteredItemsData = allItemsData.filter(item => {
+ const title = (item.item_title || '').toLowerCase();
+ const detail = getItemDetailText(item.item_detail || '').toLowerCase();
+ return title.includes(searchKeyword) || detail.includes(searchKeyword);
+ });
+ }
+
+ // 重置到第一页
+ currentItemsPage = 1;
+
+ // 计算总页数
+ totalItemsPages = Math.ceil(filteredItemsData.length / itemsPerPage);
+
+ // 更新搜索统计
+ updateItemsSearchStats();
+}
+
+// 获取商品详情的纯文本内容
+function getItemDetailText(itemDetail) {
+ if (!itemDetail) return '';
+
+ try {
+ // 尝试解析JSON
+ const detail = JSON.parse(itemDetail);
+ if (detail.content) {
+ return detail.content;
+ }
+ return itemDetail;
+ } catch (e) {
+ // 如果不是JSON格式,直接返回原文本
+ return itemDetail;
+ }
+}
+
+// 显示当前页的商品数据
+function displayCurrentPageItems() {
+ const tbody = document.getElementById('itemsTableBody');
+
+ if (!filteredItemsData || filteredItemsData.length === 0) {
+ tbody.innerHTML = '| 暂无商品数据 |
';
+ resetItemsSelection();
+ return;
+ }
+
+ // 计算当前页的数据范围
+ const startIndex = (currentItemsPage - 1) * itemsPerPage;
+ const endIndex = startIndex + itemsPerPage;
+ const currentPageItems = filteredItemsData.slice(startIndex, endIndex);
+
+ const itemsHtml = currentPageItems.map(item => {
+ // 处理商品标题显示
+ let itemTitleDisplay = item.item_title || '未设置';
+ if (itemTitleDisplay.length > 30) {
+ itemTitleDisplay = itemTitleDisplay.substring(0, 30) + '...';
+ }
+
+ // 处理商品详情显示
+ let itemDetailDisplay = '未设置';
+ if (item.item_detail) {
+ const detailText = getItemDetailText(item.item_detail);
+ itemDetailDisplay = detailText.substring(0, 50) + (detailText.length > 50 ? '...' : '');
+ }
+
+ // 多规格状态显示
+ const isMultiSpec = item.is_multi_spec;
+ const multiSpecDisplay = isMultiSpec ?
+ '多规格' :
+ '普通';
+
+ // 多数量发货状态显示
+ const isMultiQuantityDelivery = item.multi_quantity_delivery;
+ const multiQuantityDeliveryDisplay = isMultiQuantityDelivery ?
+ '已开启' :
+ '已关闭';
+
+ return `
+
+ |
+
+ |
+ ${escapeHtml(item.cookie_id)} |
+ ${escapeHtml(item.item_id)} |
+ ${escapeHtml(itemTitleDisplay)} |
+ ${escapeHtml(itemDetailDisplay)} |
+ ${escapeHtml(item.item_price || '未设置')} |
+ ${multiSpecDisplay} |
+ ${multiQuantityDeliveryDisplay} |
+ ${formatDateTime(item.updated_at)} |
+
+
+
+
+
+
+
+ |
+
+ `;
+ }).join('');
+
+ // 更新表格内容
+ tbody.innerHTML = itemsHtml;
+
+ // 重置选择状态
+ resetItemsSelection();
+}
+
+// 重置商品选择状态
+function resetItemsSelection() {
+ const selectAllCheckbox = document.getElementById('selectAllItems');
+ if (selectAllCheckbox) {
+ selectAllCheckbox.checked = false;
+ selectAllCheckbox.indeterminate = false;
+ }
+ updateBatchDeleteButton();
+}
+
+// 商品搜索过滤函数
+function filterItems() {
+ const searchInput = document.getElementById('itemSearchInput');
+ currentSearchKeyword = searchInput ? searchInput.value : '';
+
+ // 应用过滤
+ applyItemsFilter();
+
+ // 显示当前页数据
+ displayCurrentPageItems();
+
+ // 更新分页控件
+ updateItemsPagination();
+}
+
+// 更新搜索统计信息
+function updateItemsSearchStats() {
+ const statsElement = document.getElementById('itemSearchStats');
+ const statsTextElement = document.getElementById('itemSearchStatsText');
+
+ if (!statsElement || !statsTextElement) return;
+
+ if (currentSearchKeyword) {
+ statsTextElement.textContent = `搜索"${currentSearchKeyword}",找到 ${filteredItemsData.length} 个商品`;
+ statsElement.style.display = 'block';
+ } else {
+ statsElement.style.display = 'none';
+ }
+}
+
+// 更新分页控件
+function updateItemsPagination() {
+ const paginationElement = document.getElementById('itemsPagination');
+ const pageInfoElement = document.getElementById('itemsPageInfo');
+ const totalPagesElement = document.getElementById('itemsTotalPages');
+ const pageInputElement = document.getElementById('itemsPageInput');
+
+ if (!paginationElement) return;
+
+ // 分页控件总是显示
+ paginationElement.style.display = 'block';
+
+ // 更新页面信息
+ const startIndex = (currentItemsPage - 1) * itemsPerPage + 1;
+ const endIndex = Math.min(currentItemsPage * itemsPerPage, filteredItemsData.length);
+
+ if (pageInfoElement) {
+ pageInfoElement.textContent = `显示第 ${startIndex}-${endIndex} 条,共 ${filteredItemsData.length} 条记录`;
+ }
+
+ if (totalPagesElement) {
+ totalPagesElement.textContent = totalItemsPages;
+ }
+
+ if (pageInputElement) {
+ pageInputElement.value = currentItemsPage;
+ pageInputElement.max = totalItemsPages;
+ }
+
+ // 更新分页按钮状态
+ updateItemsPaginationButtons();
+}
+
+// 更新分页按钮状态
+function updateItemsPaginationButtons() {
+ const firstPageBtn = document.getElementById('itemsFirstPage');
+ const prevPageBtn = document.getElementById('itemsPrevPage');
+ const nextPageBtn = document.getElementById('itemsNextPage');
+ const lastPageBtn = document.getElementById('itemsLastPage');
+
+ if (firstPageBtn) firstPageBtn.disabled = currentItemsPage <= 1;
+ if (prevPageBtn) prevPageBtn.disabled = currentItemsPage <= 1;
+ if (nextPageBtn) nextPageBtn.disabled = currentItemsPage >= totalItemsPages;
+ if (lastPageBtn) lastPageBtn.disabled = currentItemsPage >= totalItemsPages;
+}
+
+// 跳转到指定页面
+function goToItemsPage(page) {
+ if (page < 1 || page > totalItemsPages) return;
+
+ currentItemsPage = page;
+ displayCurrentPageItems();
+ updateItemsPagination();
+}
+
+// 处理页面输入框的回车事件
+function handleItemsPageInput(event) {
+ if (event.key === 'Enter') {
+ const pageInput = event.target;
+ const page = parseInt(pageInput.value);
+
+ if (page >= 1 && page <= totalItemsPages) {
+ goToItemsPage(page);
+ } else {
+ pageInput.value = currentItemsPage;
+ }
+ }
+}
+
+// 改变每页显示数量
+function changeItemsPageSize() {
+ const pageSizeSelect = document.getElementById('itemsPageSize');
+ if (!pageSizeSelect) return;
+
+ itemsPerPage = parseInt(pageSizeSelect.value);
+
+ // 重新计算总页数
+ totalItemsPages = Math.ceil(filteredItemsData.length / itemsPerPage);
+
+ // 调整当前页码,确保不超出范围
+ if (currentItemsPage > totalItemsPages) {
+ currentItemsPage = Math.max(1, totalItemsPages);
+ }
+
+ // 重新显示数据
+ displayCurrentPageItems();
+ updateItemsPagination();
+}
+
+// 初始化商品搜索功能
+function initItemsSearch() {
+ // 初始化分页大小
+ const pageSizeSelect = document.getElementById('itemsPageSize');
+ if (pageSizeSelect) {
+ itemsPerPage = parseInt(pageSizeSelect.value) || 20;
+ pageSizeSelect.addEventListener('change', changeItemsPageSize);
+ }
+
+ // 初始化搜索输入框事件监听器
+ const searchInput = document.getElementById('itemSearchInput');
+ if (searchInput) {
+ // 使用防抖来避免频繁搜索
+ let searchTimeout;
+ searchInput.addEventListener('input', function() {
+ clearTimeout(searchTimeout);
+ searchTimeout = setTimeout(() => {
+ filterItems();
+ }, 300); // 300ms 防抖延迟
+ });
+ }
+
+ // 初始化页面输入框事件监听器
+ const pageInput = document.getElementById('itemsPageInput');
+ if (pageInput) {
+ pageInput.addEventListener('keydown', handleItemsPageInput);
+ }
+}
+
+// 刷新商品列表
+async function refreshItems() {
+ await refreshItemsData();
+ showToast('商品列表已刷新', 'success');
+}
+
+// 获取商品信息
+async function getAllItemsFromAccount() {
+ const cookieSelect = document.getElementById('itemCookieFilter');
+ const selectedCookieId = cookieSelect.value;
+ const pageNumber = parseInt(document.getElementById('pageNumber').value) || 1;
+
+ if (!selectedCookieId) {
+ showToast('请先选择一个账号', 'warning');
+ return;
+ }
+
+ if (pageNumber < 1) {
+ showToast('页码必须大于0', 'warning');
+ return;
+ }
+
+ // 显示加载状态
+ const button = event.target;
+ const originalText = button.innerHTML;
+ button.innerHTML = '获取中...';
+ button.disabled = true;
+
+ try {
+ const response = await fetch(`${apiBase}/items/get-by-page`, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify({
+ cookie_id: selectedCookieId,
+ page_number: pageNumber,
+ page_size: 20
+ })
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ if (data.success) {
+ showToast(`成功获取第${pageNumber}页 ${data.current_count} 个商品,请查看控制台日志`, 'success');
+ // 刷新商品列表(保持筛选器选择)
+ await refreshItemsData();
+ } else {
+ showToast(data.message || '获取商品信息失败', 'danger');
+ }
+ } else {
+ throw new Error(`HTTP ${response.status}`);
+ }
+ } catch (error) {
+ console.error('获取商品信息失败:', error);
+ showToast('获取商品信息失败', 'danger');
+ } finally {
+ // 恢复按钮状态
+ button.innerHTML = originalText;
+ button.disabled = false;
+ }
+}
+
+// 获取所有页商品信息
+async function getAllItemsFromAccountAll() {
+ const cookieSelect = document.getElementById('itemCookieFilter');
+ const selectedCookieId = cookieSelect.value;
+
+ if (!selectedCookieId) {
+ showToast('请先选择一个账号', 'warning');
+ return;
+ }
+
+ // 显示加载状态
+ const button = event.target;
+ const originalText = button.innerHTML;
+ button.innerHTML = '获取中...';
+ button.disabled = true;
+
+ try {
+ const response = await fetch(`${apiBase}/items/get-all-from-account`, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify({
+ cookie_id: selectedCookieId
+ })
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ if (data.success) {
+ const message = data.total_pages ?
+ `成功获取 ${data.total_count} 个商品(共${data.total_pages}页),请查看控制台日志` :
+ `成功获取商品信息,请查看控制台日志`;
+ showToast(message, 'success');
+ // 刷新商品列表(保持筛选器选择)
+ await refreshItemsData();
+ } else {
+ showToast(data.message || '获取商品信息失败', 'danger');
+ }
+ } else {
+ throw new Error(`HTTP ${response.status}`);
+ }
+ } catch (error) {
+ console.error('获取商品信息失败:', error);
+ showToast('获取商品信息失败', 'danger');
+ } finally {
+ // 恢复按钮状态
+ button.innerHTML = originalText;
+ button.disabled = false;
+ }
+}
+
+
+
+// 编辑商品详情
+async function editItem(cookieId, itemId) {
+ try {
+ const response = await fetch(`${apiBase}/items/${encodeURIComponent(cookieId)}/${encodeURIComponent(itemId)}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ const item = data.item;
+
+ // 填充表单
+ document.getElementById('editItemCookieId').value = item.cookie_id;
+ document.getElementById('editItemId').value = item.item_id;
+ document.getElementById('editItemCookieIdDisplay').value = item.cookie_id;
+ document.getElementById('editItemIdDisplay').value = item.item_id;
+ document.getElementById('editItemPriceDisplay').value = item.item_price || '未设置';
+ document.getElementById('editItemTitle').value = item.item_title || '';
+ document.getElementById('editItemPrice').value = item.item_price || '';
+ document.getElementById('editItemDesc').value = item.item_description || '';
+ document.getElementById('editItemDetail').value = item.item_detail || '';
+
+ // 显示模态框
+ const modal = new bootstrap.Modal(document.getElementById('editItemModal'));
+ modal.show();
+ } else {
+ throw new Error('获取商品详情失败');
+ }
+ } catch (error) {
+ console.error('获取商品详情失败:', error);
+ showToast('获取商品详情失败', 'danger');
+ }
+}
+
+// 保存商品详情
+async function saveItemDetail() {
+ const cookieId = document.getElementById('editItemCookieId').value;
+ const itemId = document.getElementById('editItemId').value;
+ const itemTitle = document.getElementById('editItemTitle').value.trim();
+ const itemPrice = document.getElementById('editItemPrice').value.trim();
+ const itemDesc = document.getElementById('editItemDesc').value.trim();
+ const itemDetail = document.getElementById('editItemDetail').value.trim();
+
+ try {
+ const response = await fetch(`${apiBase}/items/${encodeURIComponent(cookieId)}/${encodeURIComponent(itemId)}`, {
+ method: 'PUT',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify({
+ item_title: itemTitle,
+ item_price: itemPrice,
+ item_description: itemDesc,
+ item_detail: itemDetail
+ })
+ });
+
+ if (response.ok) {
+ const result = await response.json();
+ let msg = result.message || '商品更新成功';
+ if (result.sync_result) {
+ msg += ' | ' + result.sync_result;
+ }
+ showToast(msg, result.sync_success ? 'success' : 'warning');
+
+ // 关闭模态框
+ const modal = bootstrap.Modal.getInstance(document.getElementById('editItemModal'));
+ modal.hide();
+
+ // 刷新列表(保持筛选器选择)
+ await refreshItemsData();
+ } else {
+ const error = await response.text();
+ showToast(`更新失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('更新商品详情失败:', error);
+ showToast('更新商品详情失败', 'danger');
+ }
+}
+
+// 删除商品信息
+async function deleteItem(cookieId, itemId, itemTitle) {
+ try {
+ // 确认删除
+ const confirmed = confirm(`确定要删除商品信息吗?\n\n商品ID: ${itemId}\n商品标题: ${itemTitle || '未设置'}\n\n此操作不可撤销!`);
+ if (!confirmed) {
+ return;
+ }
+
+ const response = await fetch(`${apiBase}/items/${encodeURIComponent(cookieId)}/${encodeURIComponent(itemId)}`, {
+ method: 'DELETE',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ showToast('商品信息删除成功', 'success');
+ // 刷新列表(保持筛选器选择)
+ await refreshItemsData();
+ } else {
+ const error = await response.text();
+ showToast(`删除失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('删除商品信息失败:', error);
+ showToast('删除商品信息失败', 'danger');
+ }
+}
+
+// 批量删除商品信息
+async function batchDeleteItems() {
+ try {
+ // 获取所有选中的复选框
+ const checkboxes = document.querySelectorAll('input[name="itemCheckbox"]:checked');
+ if (checkboxes.length === 0) {
+ showToast('请选择要删除的商品', 'warning');
+ return;
+ }
+
+ // 确认删除
+ const confirmed = confirm(`确定要删除选中的 ${checkboxes.length} 个商品信息吗?\n\n此操作不可撤销!`);
+ if (!confirmed) {
+ return;
+ }
+
+ // 构造删除列表
+ const itemsToDelete = Array.from(checkboxes).map(checkbox => {
+ const row = checkbox.closest('tr');
+ return {
+ cookie_id: checkbox.dataset.cookieId,
+ item_id: checkbox.dataset.itemId
+ };
+ });
+
+ const response = await fetch(`${apiBase}/items/batch`, {
+ method: 'DELETE',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify({ items: itemsToDelete })
+ });
+
+ if (response.ok) {
+ const result = await response.json();
+ showToast(`批量删除完成: 成功 ${result.success_count} 个,失败 ${result.failed_count} 个`, 'success');
+ // 刷新列表(保持筛选器选择)
+ await refreshItemsData();
+ } else {
+ const error = await response.text();
+ showToast(`批量删除失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('批量删除商品信息失败:', error);
+ showToast('批量删除商品信息失败', 'danger');
+ }
+}
+
+// 全选/取消全选
+function toggleSelectAll(selectAllCheckbox) {
+ const checkboxes = document.querySelectorAll('input[name="itemCheckbox"]');
+ checkboxes.forEach(checkbox => {
+ checkbox.checked = selectAllCheckbox.checked;
+ });
+ updateBatchDeleteButton();
+}
+
+// 更新全选状态
+function updateSelectAllState() {
+ const checkboxes = document.querySelectorAll('input[name="itemCheckbox"]');
+ const checkedCheckboxes = document.querySelectorAll('input[name="itemCheckbox"]:checked');
+ const selectAllCheckbox = document.getElementById('selectAllItems');
+
+ if (checkboxes.length === 0) {
+ selectAllCheckbox.checked = false;
+ selectAllCheckbox.indeterminate = false;
+ } else if (checkedCheckboxes.length === checkboxes.length) {
+ selectAllCheckbox.checked = true;
+ selectAllCheckbox.indeterminate = false;
+ } else if (checkedCheckboxes.length > 0) {
+ selectAllCheckbox.checked = false;
+ selectAllCheckbox.indeterminate = true;
+ } else {
+ selectAllCheckbox.checked = false;
+ selectAllCheckbox.indeterminate = false;
+ }
+
+ updateBatchDeleteButton();
+}
+
+// 更新批量删除按钮状态
+function updateBatchDeleteButton() {
+ const checkedCheckboxes = document.querySelectorAll('input[name="itemCheckbox"]:checked');
+ const batchDeleteBtn = document.getElementById('batchDeleteBtn');
+
+ if (checkedCheckboxes.length > 0) {
+ batchDeleteBtn.disabled = false;
+ batchDeleteBtn.innerHTML = ` 批量删除 (${checkedCheckboxes.length})`;
+ } else {
+ batchDeleteBtn.disabled = true;
+ batchDeleteBtn.innerHTML = ' 批量删除';
+ }
+}
+
+// 格式化日期时间
+function formatDateTime(dateString) {
+ if (!dateString) return '未知';
+ const utcString = dateString.endsWith('Z') ? dateString : dateString + 'Z';
+ const date = new Date(utcString);
+ return date.toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' });
+}
+
+// HTML转义函数
+function escapeHtml(text) {
+ if (!text) return '';
+ const div = document.createElement('div');
+ div.textContent = text;
+ return div.innerHTML;
+}
+
+// ================================
+// 【商品回复管理菜单】相关功能
+// ================================
+
+// 加载商品回复列表
+async function loadItemsReplay() {
+ try {
+ // 先加载Cookie列表用于筛选
+ await loadCookieFilter('itemReplayCookieFilter');
+ await loadCookieFilterPlus('editReplyCookieIdSelect');
+ // 加载商品列表
+ await refreshItemsReplayData();
+ } catch (error) {
+ console.error('加载商品列表失败:', error);
+ showToast('加载商品列表失败', 'danger');
+ }
+}
+
+// 只刷新商品回复数据,不重新加载筛选器
+async function refreshItemsReplayData() {
+ try {
+ const selectedCookie = document.getElementById('itemCookieFilter').value;
+ if (selectedCookie) {
+ await loadItemsReplayByCookie();
+ } else {
+ await loadAllItemReplays();
+ }
+ } catch (error) {
+ console.error('刷新商品数据失败:', error);
+ showToast('刷新商品数据失败', 'danger');
+ }
+}
+
+// 加载Cookie筛选选项添加弹框中使用
+async function loadCookieFilterPlus(id) {
+ try {
+ const response = await fetch(`${apiBase}/cookies/details`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const accounts = await response.json();
+ const select = document.getElementById(id);
+
+ // 保存当前选择的值
+ const currentValue = select.value;
+
+ // 清空现有选项(保留"所有账号")
+ select.innerHTML = '';
+
+ if (accounts.length === 0) {
+ const option = document.createElement('option');
+ option.value = '';
+ option.textContent = '❌ 暂无账号';
+ option.disabled = true;
+ select.appendChild(option);
+ return;
+ }
+
+ // 分组显示:先显示启用的账号,再显示禁用的账号
+ const enabledAccounts = accounts.filter(account => {
+ const enabled = account.enabled === undefined ? true : account.enabled;
+ return enabled;
+ });
+ const disabledAccounts = accounts.filter(account => {
+ const enabled = account.enabled === undefined ? true : account.enabled;
+ return !enabled;
+ });
+
+ // 添加启用的账号
+ enabledAccounts.forEach(account => {
+ const option = document.createElement('option');
+ option.value = account.id;
+ option.textContent = `🟢 ${account.id}`;
+ select.appendChild(option);
+ });
+
+ // 添加禁用的账号
+ if (disabledAccounts.length > 0) {
+ // 添加分隔线
+ if (enabledAccounts.length > 0) {
+ const separator = document.createElement('option');
+ separator.value = '';
+ separator.textContent = '────────────────';
+ separator.disabled = true;
+ select.appendChild(separator);
+ }
+
+ disabledAccounts.forEach(account => {
+ const option = document.createElement('option');
+ option.value = account.id;
+ option.textContent = `🔴 ${account.id} (已禁用)`;
+ select.appendChild(option);
+ });
+ }
+
+ // 恢复之前选择的值
+ if (currentValue) {
+ select.value = currentValue;
+ }
+ }
+ } catch (error) {
+ console.error('加载Cookie列表失败:', error);
+ showToast('加载账号列表失败', 'danger');
+ }
+}
+
+// 刷新商品回复列表
+async function refreshItemReplayS() {
+ await refreshItemsReplayData();
+ showToast('商品列表已刷新', 'success');
+}
+
+// 加载所有商品回复
+async function loadAllItemReplays() {
+ try {
+ const response = await fetch(`${apiBase}/itemReplays`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ displayItemReplays(data.items);
+ } else {
+ throw new Error('获取商品列表失败');
+ }
+ } catch (error) {
+ console.error('加载商品列表失败:', error);
+ showToast('加载商品列表失败', 'danger');
+ }
+}
+
+// 按Cookie加载商品回复
+async function loadItemsReplayByCookie() {
+ const cookieId = document.getElementById('itemReplayCookieFilter').value;
+ if (!cookieId) {
+ await loadAllItemReplays();
+ return;
+ }
+
+ try {
+ const response = await fetch(`${apiBase}/itemReplays/cookie/${encodeURIComponent(cookieId)}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ displayItemReplays(data.items);
+ } else {
+ throw new Error('获取商品列表失败');
+ }
+ } catch (error) {
+ console.error('加载商品列表失败:', error);
+ showToast('加载商品列表失败', 'danger');
+ }
+}
+
+// 显示商品回复列表
+function displayItemReplays(items) {
+ const tbody = document.getElementById('itemReplaysTableBody');
+
+ if (!items || items.length === 0) {
+ tbody.innerHTML = '| 暂无商品数据 |
';
+ // 重置选择状态
+ const selectAllCheckbox = document.getElementById('selectAllItems');
+ if (selectAllCheckbox) {
+ selectAllCheckbox.checked = false;
+ selectAllCheckbox.indeterminate = false;
+ }
+ updateBatchDeleteButton();
+ return;
+ }
+
+ const itemsHtml = items.map(item => {
+ // 处理商品标题显示
+ let itemTitleDisplay = item.item_title || '未设置';
+ if (itemTitleDisplay.length > 30) {
+ itemTitleDisplay = itemTitleDisplay.substring(0, 30) + '...';
+ }
+
+ // 处理商品详情显示
+ let itemDetailDisplay = '未设置';
+ if (item.item_detail) {
+ try {
+ // 尝试解析JSON并提取有用信息
+ const detail = JSON.parse(item.item_detail);
+ if (detail.content) {
+ itemDetailDisplay = detail.content.substring(0, 50) + (detail.content.length > 50 ? '...' : '');
+ } else {
+ // 如果是纯文本或其他格式,直接显示前50个字符
+ itemDetailDisplay = item.item_detail.substring(0, 50) + (item.item_detail.length > 50 ? '...' : '');
+ }
+ } catch (e) {
+ // 如果不是JSON格式,直接显示前50个字符
+ itemDetailDisplay = item.item_detail.substring(0, 50) + (item.item_detail.length > 50 ? '...' : '');
+ }
+ }
+
+ return `
+
+ |
+
+ |
+ ${escapeHtml(item.cookie_id)} |
+ ${escapeHtml(item.item_id)} |
+ ${escapeHtml(itemTitleDisplay)} |
+ ${escapeHtml(itemDetailDisplay)} |
+ ${escapeHtml(item.reply_content)} |
+ ${formatDateTime(item.updated_at)} |
+
+
+
+
+
+ |
+
+ `;
+ }).join('');
+
+ // 更新表格内容
+ tbody.innerHTML = itemsHtml;
+
+ // 重置选择状态
+ const selectAllCheckbox = document.getElementById('selectAllItems');
+ if (selectAllCheckbox) {
+ selectAllCheckbox.checked = false;
+ selectAllCheckbox.indeterminate = false;
+ }
+ updateBatchDeleteButton();
+}
+
+// 显示添加弹框
+async function showItemReplayEdit(){
+ // 显示模态框
+ const modal = new bootstrap.Modal(document.getElementById('editItemReplyModal'));
+ document.getElementById('editReplyCookieIdSelect').value = '';
+ document.getElementById('editReplyItemIdSelect').value = '';
+ document.getElementById('editReplyItemIdSelect').disabled = true
+ document.getElementById('editItemReplyContent').value = '';
+ document.getElementById('itemReplayTitle').textContent = '添加商品回复';
+ modal.show();
+}
+
+// 当账号变化时加载对应商品
+async function onCookieChangeForReply() {
+ const cookieId = document.getElementById('editReplyCookieIdSelect').value;
+ const itemSelect = document.getElementById('editReplyItemIdSelect');
+
+ itemSelect.innerHTML = '';
+ if (!cookieId) {
+ itemSelect.disabled = true; // 禁用选择框
+ return;
+ } else {
+ itemSelect.disabled = false; // 启用选择框
+ }
+
+ const response = await fetch(`${apiBase}/items/cookie/${encodeURIComponent(cookieId)}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+ try {
+ if (response.ok) {
+ const data = await response.json();
+ data.items.forEach(item => {
+ const opt = document.createElement('option');
+ opt.value = item.item_id;
+ opt.textContent = `${item.item_id} - ${item.item_title || '无标题'}`;
+ itemSelect.appendChild(opt);
+ });
+ } else {
+ throw new Error('获取商品列表失败');
+ }
+ }catch (error) {
+ console.error('加载商品列表失败:', error);
+ showToast('加载商品列表失败', 'danger');
+ }
+}
+
+// 编辑商品回复
+async function editItemReply(cookieId, itemId) {
+ try {
+ const response = await fetch(`${apiBase}/item-reply/${encodeURIComponent(cookieId)}/${encodeURIComponent(itemId)}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+ if (response.ok) {
+ const data = await response.json();
+ document.getElementById('itemReplayTitle').textContent = '编辑商品回复';
+ // 填充表单
+ document.getElementById('editReplyCookieIdSelect').value = data.cookie_id;
+ let res = await onCookieChangeForReply()
+ document.getElementById('editReplyItemIdSelect').value = data.item_id;
+ document.getElementById('editItemReplyContent').value = data.reply_content || '';
+
+ } else if (response.status === 404) {
+ // 如果没有记录,则填充空白内容(用于添加)
+// document.getElementById('editReplyCookieIdSelect').value = data.cookie_id;
+// document.getElementById('editReplyItemIdSelect').value = data.item_id;
+// document.getElementById('editItemReplyContent').value = data.reply_content || '';
+ } else {
+ throw new Error('获取商品回复失败');
+ }
+
+ // 显示模态框
+ const modal = new bootstrap.Modal(document.getElementById('editItemReplyModal'));
+ modal.show();
+
+ } catch (error) {
+ console.error('获取商品回复失败:', error);
+ showToast('获取商品回复失败', 'danger');
+ }
+}
+
+// 保存商品回复
+async function saveItemReply() {
+ const cookieId = document.getElementById('editReplyCookieIdSelect').value;
+ const itemId = document.getElementById('editReplyItemIdSelect').value;
+ const replyContent = document.getElementById('editItemReplyContent').value.trim();
+
+ console.log(cookieId)
+ console.log(itemId)
+ console.log(replyContent)
+ if (!cookieId) {
+ showToast('请选择账号', 'warning');
+ return;
+ }
+
+ if (!itemId) {
+ showToast('请选择商品', 'warning');
+ return;
+ }
+
+ if (!replyContent) {
+ showToast('请输入商品回复内容', 'warning');
+ return;
+ }
+
+ try {
+ const response = await fetch(`${apiBase}/item-reply/${encodeURIComponent(cookieId)}/${encodeURIComponent(itemId)}`, {
+ method: 'PUT',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify({
+ reply_content: replyContent
+ })
+ });
+
+ if (response.ok) {
+ showToast('商品回复保存成功', 'success');
+
+ // 关闭模态框
+ const modal = bootstrap.Modal.getInstance(document.getElementById('editItemReplyModal'));
+ modal.hide();
+
+ // 可选:刷新数据
+ await refreshItemsReplayData?.();
+ } else {
+ const error = await response.text();
+ showToast(`保存失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('保存商品回复失败:', error);
+ showToast('保存商品回复失败', 'danger');
+ }
+}
+
+// 删除商品回复
+async function deleteItemReply(cookieId, itemId, itemTitle) {
+ try {
+ const confirmed = confirm(`确定要删除该商品的自动回复吗?\n\n商品ID: ${itemId}\n商品标题: ${itemTitle || '未设置'}\n\n此操作不可撤销!`);
+ if (!confirmed) return;
+
+ const response = await fetch(`${apiBase}/item-reply/${encodeURIComponent(cookieId)}/${encodeURIComponent(itemId)}`, {
+ method: 'DELETE',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ showToast('商品回复删除成功', 'success');
+ await loadItemsReplayByCookie?.(); // 如果你有刷新商品列表的函数
+ } else {
+ const error = await response.text();
+ showToast(`删除失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('删除商品回复失败:', error);
+ showToast('删除商品回复失败', 'danger');
+ }
+}
+
+// 批量删除商品回复
+async function batchDeleteItemReplies() {
+ try {
+ const checkboxes = document.querySelectorAll('input[name="itemCheckbox"]:checked');
+ if (checkboxes.length === 0) {
+ showToast('请选择要删除回复的商品', 'warning');
+ return;
+ }
+
+ const confirmed = confirm(`确定要删除选中商品的自动回复吗?\n共 ${checkboxes.length} 个商品\n\n此操作不可撤销!`);
+ if (!confirmed) return;
+
+ const itemsToDelete = Array.from(checkboxes).map(checkbox => ({
+ cookie_id: checkbox.dataset.cookieId,
+ item_id: checkbox.dataset.itemId
+ }));
+
+ const response = await fetch(`${apiBase}/item-reply/batch`, {
+ method: 'DELETE',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify({ items: itemsToDelete })
+ });
+
+ if (response.ok) {
+ const result = await response.json();
+ showToast(`批量删除回复完成: 成功 ${result.success_count} 个,失败 ${result.failed_count} 个`, 'success');
+ await loadItemsReplayByCookie?.();
+ } else {
+ const error = await response.text();
+ showToast(`批量删除失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('批量删除商品回复失败:', error);
+ showToast('批量删除商品回复失败', 'danger');
+ }
+}
+
+// ================================
+// 【日志管理菜单】相关功能
+// ================================
+
+window.autoRefreshInterval = null;
+window.allLogs = [];
+window.filteredLogs = [];
+
+// 刷新日志
+async function refreshLogs() {
+ try {
+ const logLinesElement = document.getElementById('logLines');
+ if (!logLinesElement) {
+ console.warn('logLines 元素不存在');
+ showToast('页面元素缺失,请刷新页面', 'warning');
+ return;
+ }
+
+ const lines = logLinesElement.value;
+
+ const response = await fetch(`${apiBase}/logs?lines=${lines}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ window.allLogs = data.logs || [];
+ window.filteredLogs = window.allLogs; // 不再过滤,直接显示所有日志
+ displayLogs();
+ updateLogStats();
+ showToast('日志已刷新', 'success');
+ } else {
+ throw new Error(`HTTP ${response.status}`);
+ }
+ } catch (error) {
+ console.error('刷新日志失败:', error);
+ showToast(`刷新日志失败: ${error.message}`, 'danger');
+ }
+}
+
+
+
+// 显示日志
+function displayLogs() {
+ const container = document.getElementById('logContainer');
+
+ // 检查容器是否存在
+ if (!container) {
+ // 只在特定页面显示警告,避免在其他页面产生无用的警告
+ const currentPath = window.location.pathname;
+ if (currentPath.includes('log') || currentPath.includes('admin')) {
+ console.warn('logContainer 元素不存在,无法显示日志');
+ }
+ return;
+ }
+
+ if (!window.filteredLogs || window.filteredLogs.length === 0) {
+ container.innerHTML = `
+
+ `;
+ return;
+ }
+
+ const logsHtml = window.filteredLogs.map(log => {
+ const timestamp = formatLogTimestamp(log.timestamp);
+ const levelClass = log.level || 'INFO';
+
+ return `
+
+ ${timestamp}
+ [${log.level}]
+ ${log.source}:
+ ${escapeHtml(log.message)}
+
+ `;
+ }).join('');
+
+ container.innerHTML = logsHtml;
+
+ // 滚动到底部
+ container.scrollTop = container.scrollHeight;
+}
+
+// 格式化日志时间戳
+function formatLogTimestamp(timestamp) {
+ if (!timestamp) return '';
+ const date = new Date(timestamp);
+ return date.toLocaleString('zh-CN', {
+ year: 'numeric',
+ month: '2-digit',
+ day: '2-digit',
+ hour: '2-digit',
+ minute: '2-digit',
+ second: '2-digit',
+ fractionalSecondDigits: 3,
+ timeZone: 'Asia/Shanghai'
+ });
+}
+
+// 更新日志统计信息
+function updateLogStats() {
+ const logCountElement = document.getElementById('logCount');
+ const lastUpdateElement = document.getElementById('lastUpdate');
+
+ if (logCountElement) {
+ const count = window.filteredLogs ? window.filteredLogs.length : 0;
+ logCountElement.textContent = `${count} 条日志`;
+ }
+
+ if (lastUpdateElement) {
+ lastUpdateElement.textContent = new Date().toLocaleTimeString('zh-CN');
+ }
+}
+
+// 清空日志显示
+function clearLogsDisplay() {
+ window.allLogs = [];
+ window.filteredLogs = [];
+ document.getElementById('logContainer').innerHTML = `
+
+ `;
+ updateLogStats();
+ showToast('日志显示已清空', 'info');
+}
+
+// 切换自动刷新
+function toggleAutoRefresh() {
+ const button = document.querySelector('#autoRefreshText');
+ const icon = button.previousElementSibling;
+
+ if (window.autoRefreshInterval) {
+ // 停止自动刷新
+ clearInterval(window.autoRefreshInterval);
+ window.autoRefreshInterval = null;
+ button.textContent = '开启自动刷新';
+ icon.className = 'bi bi-play-circle me-1';
+ showToast('自动刷新已停止', 'info');
+ } else {
+ // 开启自动刷新
+ window.autoRefreshInterval = setInterval(refreshLogs, 5000); // 每5秒刷新一次
+ button.textContent = '停止自动刷新';
+ icon.className = 'bi bi-pause-circle me-1';
+ showToast('自动刷新已开启(每5秒)', 'success');
+
+ // 立即刷新一次
+ refreshLogs();
+ }
+}
+
+// 清空服务器日志
+async function clearLogsServer() {
+ if (!confirm('确定要清空服务器端的所有日志吗?此操作不可恢复!')) {
+ return;
+ }
+
+ try {
+ const response = await fetch(`${apiBase}/logs/clear`, {
+ method: 'POST',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ if (data.success) {
+ window.allLogs = [];
+ window.filteredLogs = [];
+ displayLogs();
+ updateLogStats();
+ showToast('服务器日志已清空', 'success');
+ } else {
+ showToast(data.message || '清空失败', 'danger');
+ }
+ } else {
+ throw new Error(`HTTP ${response.status}`);
+ }
+ } catch (error) {
+ console.error('清空服务器日志失败:', error);
+ showToast('清空服务器日志失败', 'danger');
+ }
+}
+
+// 显示日志统计信息
+async function showLogStats() {
+ try {
+ const response = await fetch(`${apiBase}/logs/stats`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ if (data.success) {
+ const stats = data.stats;
+
+ let statsHtml = `
+
+
+
总体统计
+
+ - 总日志数: ${stats.total_logs}
+ - 最大容量: ${stats.max_capacity}
+ - 使用率: ${((stats.total_logs / stats.max_capacity) * 100).toFixed(1)}%
+
+
+
+
级别分布
+
+ `;
+
+ for (const [level, count] of Object.entries(stats.level_counts || {})) {
+ const percentage = ((count / stats.total_logs) * 100).toFixed(1);
+ statsHtml += `- ${level}: ${count} (${percentage}%)
`;
+ }
+
+ statsHtml += `
+
+
+
+
+
+
来源分布
+
+ `;
+
+ const sources = Object.entries(stats.source_counts || {});
+ sources.forEach(([source, count], index) => {
+ if (index % 2 === 0) statsHtml += '
';
+ const percentage = ((count / stats.total_logs) * 100).toFixed(1);
+ statsHtml += `- ${source}: ${count} (${percentage}%)
`;
+ if (index % 2 === 1 || index === sources.length - 1) statsHtml += '
';
+ });
+
+ statsHtml += `
+
+
+
+ `;
+
+ // 显示模态框
+ const modalHtml = `
+
+ `;
+
+ // 移除旧的模态框
+ const oldModal = document.getElementById('logStatsModal');
+ if (oldModal) oldModal.remove();
+
+ // 添加新的模态框
+ document.body.insertAdjacentHTML('beforeend', modalHtml);
+
+ // 显示模态框
+ const modal = new bootstrap.Modal(document.getElementById('logStatsModal'));
+ modal.show();
+
+ } else {
+ showToast(data.message || '获取统计信息失败', 'danger');
+ }
+ } else {
+ throw new Error(`HTTP ${response.status}`);
+ }
+ } catch (error) {
+ console.error('获取日志统计失败:', error);
+ showToast('获取日志统计失败', 'danger');
+ }
+}
+
+// ==================== 导入导出功能 ====================
+
+// 导出关键词
+async function exportKeywords() {
+ if (!currentCookieId) {
+ showToast('请先选择账号', 'warning');
+ return;
+ }
+
+ try {
+ const response = await fetch(`${apiBase}/keywords-export/${currentCookieId}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ // 创建下载链接
+ const blob = await response.blob();
+ const url = window.URL.createObjectURL(blob);
+ const a = document.createElement('a');
+ a.href = url;
+
+ // 根据当前账号是否有数据来设置文件名和提示
+ const currentKeywords = keywordsData[currentCookieId] || [];
+ const hasData = currentKeywords.length > 0;
+
+ if (hasData) {
+ a.download = `keywords_${currentCookieId}_${new Date().getTime()}.xlsx`;
+ showToast('关键词导出成功!', 'success');
+ } else {
+ a.download = `keywords_template_${currentCookieId}_${new Date().getTime()}.xlsx`;
+ showToast('导入模板导出成功!模板中包含示例数据供参考', 'success');
+ }
+
+ document.body.appendChild(a);
+ a.click();
+ document.body.removeChild(a);
+ window.URL.revokeObjectURL(url);
+ } else {
+ const error = await response.json();
+ showToast(`导出失败: ${error.detail}`, 'error');
+ }
+ } catch (error) {
+ console.error('导出关键词失败:', error);
+ showToast('导出关键词失败', 'error');
+ }
+}
+
+// 显示导入模态框
+function showImportModal() {
+ if (!currentCookieId) {
+ showToast('请先选择账号', 'warning');
+ return;
+ }
+
+ const modal = new bootstrap.Modal(document.getElementById('importKeywordsModal'));
+ modal.show();
+}
+
+// 导入关键词
+async function importKeywords() {
+ if (!currentCookieId) {
+ showToast('请先选择账号', 'warning');
+ return;
+ }
+
+ const fileInput = document.getElementById('importFileInput');
+ const file = fileInput.files[0];
+
+ if (!file) {
+ showToast('请选择要导入的Excel文件', 'warning');
+ return;
+ }
+
+ try {
+ // 显示进度条
+ const progressDiv = document.getElementById('importProgress');
+ const progressBar = progressDiv.querySelector('.progress-bar');
+ progressDiv.style.display = 'block';
+ progressBar.style.width = '30%';
+
+ const formData = new FormData();
+ formData.append('file', file);
+
+ const response = await fetch(`${apiBase}/keywords-import/${currentCookieId}`, {
+ method: 'POST',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: formData
+ });
+
+ progressBar.style.width = '70%';
+
+ if (response.ok) {
+ const result = await response.json();
+ progressBar.style.width = '100%';
+
+ setTimeout(() => {
+ progressDiv.style.display = 'none';
+ progressBar.style.width = '0%';
+
+ // 关闭模态框
+ const modal = bootstrap.Modal.getInstance(document.getElementById('importKeywordsModal'));
+ modal.hide();
+
+ // 清空文件输入
+ fileInput.value = '';
+
+ // 重新加载关键词列表
+ loadAccountKeywords(currentCookieId);
+
+ showToast(`导入成功!新增: ${result.added}, 更新: ${result.updated}`, 'success');
+ }, 500);
+ } else {
+ const error = await response.json();
+ progressDiv.style.display = 'none';
+ progressBar.style.width = '0%';
+ showToast(`导入失败: ${error.detail}`, 'error');
+ }
+ } catch (error) {
+ console.error('导入关键词失败:', error);
+ document.getElementById('importProgress').style.display = 'none';
+ document.querySelector('#importProgress .progress-bar').style.width = '0%';
+ showToast('导入关键词失败', 'error');
+ }
+}
+
+// ========================= 账号添加相关函数 =========================
+
+// 切换手动输入表单显示/隐藏
+function toggleManualInput() {
+ const manualForm = document.getElementById('manualInputForm');
+ if (manualForm.style.display === 'none') {
+ manualForm.style.display = 'block';
+ // 清空表单
+ document.getElementById('addForm').reset();
+ } else {
+ manualForm.style.display = 'none';
+ }
+}
+
+// ========================= 扫码登录相关函数 =========================
+
+let qrCodeCheckInterval = null;
+let qrCodeSessionId = null;
+
+// 显示扫码登录模态框
+function showQRCodeLogin() {
+ const modal = new bootstrap.Modal(document.getElementById('qrCodeLoginModal'));
+ modal.show();
+
+ // 模态框显示后生成二维码
+ modal._element.addEventListener('shown.bs.modal', function () {
+ generateQRCode();
+ });
+
+ // 模态框关闭时清理定时器
+ modal._element.addEventListener('hidden.bs.modal', function () {
+ clearQRCodeCheck();
+ });
+}
+
+// 刷新二维码(兼容旧函数名)
+async function refreshQRCode() {
+ await generateQRCode();
+}
+
+// 生成二维码
+async function generateQRCode() {
+ try {
+ showQRCodeLoading();
+
+ const response = await fetch(`${apiBase}/qr-login/generate`, {
+ method: 'POST',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`,
+ 'Content-Type': 'application/json'
+ }
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ if (data.success) {
+ qrCodeSessionId = data.session_id;
+ showQRCodeImage(data.qr_code_url);
+ startQRCodeCheck();
+ } else {
+ showQRCodeError(data.message || '生成二维码失败');
+ }
+ } else {
+ showQRCodeError('生成二维码失败');
+ }
+ } catch (error) {
+ console.error('生成二维码失败:', error);
+ showQRCodeError('网络错误,请重试');
+ }
+}
+
+// 显示二维码加载状态
+function showQRCodeLoading() {
+ document.getElementById('qrCodeContainer').style.display = 'block';
+ document.getElementById('qrCodeImage').style.display = 'none';
+ document.getElementById('statusText').textContent = '正在生成二维码,请耐心等待...';
+ document.getElementById('statusSpinner').style.display = 'none';
+
+ // 隐藏验证容器
+ const verificationContainer = document.getElementById('verificationContainer');
+ if (verificationContainer) {
+ verificationContainer.style.display = 'none';
+ }
+}
+
+// 显示二维码图片
+function showQRCodeImage(qrCodeUrl) {
+ document.getElementById('qrCodeContainer').style.display = 'none';
+ document.getElementById('qrCodeImage').style.display = 'block';
+ document.getElementById('qrCodeImg').src = qrCodeUrl;
+ document.getElementById('statusText').textContent = '等待扫码...';
+ document.getElementById('statusSpinner').style.display = 'none';
+}
+
+// 显示二维码错误
+function showQRCodeError(message) {
+ document.getElementById('qrCodeContainer').innerHTML = `
+
+ `;
+ document.getElementById('qrCodeImage').style.display = 'none';
+ document.getElementById('statusText').textContent = '生成失败';
+ document.getElementById('statusSpinner').style.display = 'none';
+}
+
+// 开始检查二维码状态
+function startQRCodeCheck() {
+ if (qrCodeCheckInterval) {
+ clearInterval(qrCodeCheckInterval);
+ }
+
+ document.getElementById('statusSpinner').style.display = 'inline-block';
+ document.getElementById('statusText').textContent = '等待扫码...';
+
+ qrCodeCheckInterval = setInterval(checkQRCodeStatus, 2000); // 每2秒检查一次
+}
+
+// 检查二维码状态
+async function checkQRCodeStatus() {
+ if (!qrCodeSessionId) return;
+
+ try {
+ const response = await fetch(`${apiBase}/qr-login/check/${qrCodeSessionId}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+
+ switch (data.status) {
+ case 'waiting':
+ document.getElementById('statusText').textContent = '等待扫码...';
+ break;
+ case 'scanned':
+ document.getElementById('statusText').textContent = '已扫码,请在手机上确认...';
+ break;
+ case 'success':
+ document.getElementById('statusText').textContent = '登录成功!';
+ document.getElementById('statusSpinner').style.display = 'none';
+ clearQRCodeCheck();
+ handleQRCodeSuccess(data);
+ break;
+ case 'expired':
+ document.getElementById('statusText').textContent = '二维码已过期';
+ document.getElementById('statusSpinner').style.display = 'none';
+ clearQRCodeCheck();
+ showQRCodeError('二维码已过期,请刷新重试');
+ break;
+ case 'cancelled':
+ document.getElementById('statusText').textContent = '用户取消登录';
+ document.getElementById('statusSpinner').style.display = 'none';
+ clearQRCodeCheck();
+ break;
+ case 'verification_required':
+ document.getElementById('statusText').textContent = '需要手机验证';
+ document.getElementById('statusSpinner').style.display = 'none';
+ clearQRCodeCheck();
+ showVerificationRequired(data);
+ break;
+ }
+ }
+ } catch (error) {
+ console.error('检查二维码状态失败:', error);
+ }
+}
+
+// 显示需要验证的提示
+function showVerificationRequired(data) {
+ if (data.verification_url) {
+ // 隐藏二维码区域
+ document.getElementById('qrCodeContainer').style.display = 'none';
+ document.getElementById('qrCodeImage').style.display = 'none';
+
+ // 显示验证提示
+ const verificationHtml = `
+
+
+
+
+
账号需要手机验证
+
+
+ 检测到账号存在风控,需要进行手机验证才能完成登录
+
+
+
+
+
+ 验证步骤:
+ 1. 点击上方按钮打开验证页面
+ 2. 按照页面提示完成手机验证
+ 3. 验证完成后,重新扫码登录
+
+
+
+ `;
+
+ // 创建验证提示容器
+ let verificationContainer = document.getElementById('verificationContainer');
+ if (!verificationContainer) {
+ verificationContainer = document.createElement('div');
+ verificationContainer.id = 'verificationContainer';
+ document.querySelector('#qrCodeLoginModal .modal-body').appendChild(verificationContainer);
+ }
+
+ verificationContainer.innerHTML = verificationHtml;
+ verificationContainer.style.display = 'block';
+
+ // 显示Toast提示
+ showToast('账号需要手机验证,请按照提示完成验证', 'warning');
+ }
+}
+
+// 处理扫码成功
+function handleQRCodeSuccess(data) {
+ if (data.account_info) {
+ const { account_id, is_new_account } = data.account_info;
+
+ if (is_new_account) {
+ showToast(`新账号添加成功!账号ID: ${account_id}`, 'success');
+ } else {
+ showToast(`账号Cookie已更新!账号ID: ${account_id}`, 'success');
+ }
+
+ // 关闭模态框
+ setTimeout(() => {
+ const modal = bootstrap.Modal.getInstance(document.getElementById('qrCodeLoginModal'));
+ modal.hide();
+
+ // 刷新账号列表
+ loadCookies();
+ }, 2000);
+ }
+}
+
+// 清理二维码检查
+function clearQRCodeCheck() {
+ if (qrCodeCheckInterval) {
+ clearInterval(qrCodeCheckInterval);
+ qrCodeCheckInterval = null;
+ }
+ qrCodeSessionId = null;
+}
+
+// 刷新二维码
+function refreshQRCode() {
+ clearQRCodeCheck();
+ generateQRCode();
+}
+
+// ==================== 图片关键词管理功能 ====================
+
+// 显示添加图片关键词模态框
+function showAddImageKeywordModal() {
+ if (!currentCookieId) {
+ showToast('请先选择账号', 'warning');
+ return;
+ }
+
+ // 加载商品列表到图片关键词模态框
+ loadItemsListForImageKeyword();
+
+ // 显示模态框
+ const modal = new bootstrap.Modal(document.getElementById('addImageKeywordModal'));
+ modal.show();
+
+ // 清空表单
+ document.getElementById('imageKeyword').value = '';
+ document.getElementById('imageItemIdSelect').value = '';
+ document.getElementById('imageFile').value = '';
+ hideImagePreview();
+}
+
+// 为图片关键词模态框加载商品列表
+async function loadItemsListForImageKeyword() {
+ try {
+ const response = await fetch(`${apiBase}/items/${currentCookieId}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ const items = data.items || [];
+
+ // 更新商品选择下拉框
+ const selectElement = document.getElementById('imageItemIdSelect');
+ if (selectElement) {
+ // 清空现有选项(保留第一个默认选项)
+ selectElement.innerHTML = '';
+
+ // 添加商品选项
+ items.forEach(item => {
+ const option = document.createElement('option');
+ option.value = item.item_id;
+ option.textContent = `${item.item_id} - ${item.item_title}`;
+ selectElement.appendChild(option);
+ });
+ }
+
+ console.log(`为图片关键词加载了 ${items.length} 个商品到选择列表`);
+ } else {
+ console.warn('加载商品列表失败:', response.status);
+ }
+ } catch (error) {
+ console.error('加载商品列表时发生错误:', error);
+ }
+}
+
+// 处理图片文件选择事件监听器
+function initImageKeywordEventListeners() {
+ const imageFileInput = document.getElementById('imageFile');
+ if (imageFileInput && !imageFileInput.hasEventListener) {
+ imageFileInput.addEventListener('change', function(e) {
+ const file = e.target.files[0];
+ if (file) {
+ // 验证文件类型
+ if (!file.type.startsWith('image/')) {
+ showToast('请选择图片文件', 'warning');
+ e.target.value = '';
+ hideImagePreview();
+ return;
+ }
+
+ // 验证文件大小(5MB)
+ if (file.size > 5 * 1024 * 1024) {
+ showToast('❌ 图片文件大小不能超过 5MB,当前文件大小:' + (file.size / 1024 / 1024).toFixed(1) + 'MB', 'warning');
+ e.target.value = '';
+ hideImagePreview();
+ return;
+ }
+
+ // 验证图片尺寸
+ validateImageDimensions(file, e.target);
+ } else {
+ hideImagePreview();
+ }
+ });
+ imageFileInput.hasEventListener = true;
+ }
+}
+
+// 验证图片尺寸
+function validateImageDimensions(file, inputElement) {
+ const img = new Image();
+ const url = URL.createObjectURL(file);
+
+ img.onload = function() {
+ const width = this.naturalWidth;
+ const height = this.naturalHeight;
+
+ // 释放对象URL
+ URL.revokeObjectURL(url);
+
+ // 检查图片尺寸
+ const maxDimension = 4096;
+ const maxPixels = 8 * 1024 * 1024; // 8M像素
+ const totalPixels = width * height;
+
+ if (width > maxDimension || height > maxDimension) {
+ showToast(`❌ 图片尺寸过大:${width}x${height},最大允许:${maxDimension}x${maxDimension}像素`, 'warning');
+ inputElement.value = '';
+ hideImagePreview();
+ return;
+ }
+
+ if (totalPixels > maxPixels) {
+ showToast(`❌ 图片像素总数过大:${(totalPixels / 1024 / 1024).toFixed(1)}M像素,最大允许:8M像素`, 'warning');
+ inputElement.value = '';
+ hideImagePreview();
+ return;
+ }
+
+ // 尺寸检查通过,显示预览和提示信息
+ showImagePreview(file);
+
+ // 如果图片较大,提示会被压缩
+ if (width > 2048 || height > 2048) {
+ showToast(`ℹ️ 图片尺寸较大(${width}x${height}),上传时将自动压缩以优化性能`, 'info');
+ } else {
+ showToast(`✅ 图片尺寸合适(${width}x${height}),可以上传`, 'success');
+ }
+ };
+
+ img.onerror = function() {
+ URL.revokeObjectURL(url);
+ showToast('❌ 无法读取图片文件,请选择有效的图片', 'warning');
+ inputElement.value = '';
+ hideImagePreview();
+ };
+
+ img.src = url;
+}
+
+// 显示图片预览
+function showImagePreview(file) {
+ const reader = new FileReader();
+ reader.onload = function(e) {
+ const previewContainer = document.getElementById('imagePreview');
+ const previewImg = document.getElementById('previewImg');
+
+ previewImg.src = e.target.result;
+ previewContainer.style.display = 'block';
+ };
+ reader.readAsDataURL(file);
+}
+
+// 隐藏图片预览
+function hideImagePreview() {
+ const previewContainer = document.getElementById('imagePreview');
+ if (previewContainer) {
+ previewContainer.style.display = 'none';
+ }
+}
+
+// 添加图片关键词
+async function addImageKeyword() {
+ const keyword = document.getElementById('imageKeyword').value.trim();
+ const itemId = document.getElementById('imageItemIdSelect').value.trim();
+ const fileInput = document.getElementById('imageFile');
+ const file = fileInput.files[0];
+
+ if (!keyword) {
+ showToast('请填写关键词', 'warning');
+ return;
+ }
+
+ if (!file) {
+ showToast('请选择图片文件', 'warning');
+ return;
+ }
+
+ if (!currentCookieId) {
+ showToast('请先选择账号', 'warning');
+ return;
+ }
+
+ try {
+ toggleLoading(true);
+
+ // 创建FormData对象
+ const formData = new FormData();
+ formData.append('keyword', keyword);
+ formData.append('item_id', itemId || '');
+ formData.append('image', file);
+
+ const response = await fetch(`${apiBase}/keywords/${currentCookieId}/image`, {
+ method: 'POST',
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: formData
+ });
+
+ if (response.ok) {
+ showToast(`✨ 图片关键词 "${keyword}" 添加成功!`, 'success');
+
+ // 关闭模态框
+ const modal = bootstrap.Modal.getInstance(document.getElementById('addImageKeywordModal'));
+ modal.hide();
+
+ // 只刷新关键词列表,不重新加载整个界面
+ await refreshKeywordsList();
+ } else {
+ try {
+ const errorData = await response.json();
+ let errorMessage = errorData.detail || '图片关键词添加失败';
+
+ // 根据不同的错误类型提供更友好的提示
+ if (errorMessage.includes('关键词') && (errorMessage.includes('已存在') || errorMessage.includes('重复'))) {
+ errorMessage = `❌ 关键词重复:${errorMessage}`;
+ } else if (errorMessage.includes('图片尺寸过大')) {
+ errorMessage = '❌ 图片尺寸过大,请选择尺寸较小的图片(建议不超过4096x4096像素)';
+ } else if (errorMessage.includes('图片像素总数过大')) {
+ errorMessage = '❌ 图片像素总数过大,请选择分辨率较低的图片';
+ } else if (errorMessage.includes('图片数据验证失败')) {
+ errorMessage = '❌ 图片格式不支持或文件损坏,请选择JPG、PNG、GIF格式的图片';
+ } else if (errorMessage.includes('图片保存失败')) {
+ errorMessage = '❌ 图片保存失败,请检查图片格式和大小后重试';
+ } else if (errorMessage.includes('文件大小超过限制')) {
+ errorMessage = '❌ 图片文件过大,请选择小于5MB的图片';
+ } else if (errorMessage.includes('不支持的图片格式')) {
+ errorMessage = '❌ 不支持的图片格式,请选择JPG、PNG、GIF格式的图片';
+ } else if (response.status === 413) {
+ errorMessage = '❌ 图片文件过大,请选择小于5MB的图片';
+ } else if (response.status === 400) {
+ errorMessage = `❌ 请求参数错误:${errorMessage}`;
+ } else if (response.status === 500) {
+ errorMessage = '❌ 服务器内部错误,请稍后重试';
+ }
+
+ console.error('图片关键词添加失败:', errorMessage);
+ showToast(errorMessage, 'danger');
+ } catch (e) {
+ // 如果不是JSON格式,使用文本
+ const errorText = await response.text();
+ console.error('图片关键词添加失败:', errorText);
+
+ let friendlyMessage = '图片关键词添加失败';
+ if (response.status === 413) {
+ friendlyMessage = '❌ 图片文件过大,请选择小于5MB的图片';
+ } else if (response.status === 400) {
+ friendlyMessage = '❌ 图片格式不正确或参数错误,请检查后重试';
+ } else if (response.status === 500) {
+ friendlyMessage = '❌ 服务器内部错误,请稍后重试';
+ }
+
+ showToast(friendlyMessage, 'danger');
+ }
+ }
+ } catch (error) {
+ console.error('添加图片关键词失败:', error);
+ showToast('添加图片关键词失败', 'danger');
+ } finally {
+ toggleLoading(false);
+ }
+}
+
+// 显示图片模态框
+function showImageModal(imageUrl) {
+ // 创建模态框HTML
+ const modalHtml = `
+
+
+
+
+
+

+
+
+
+
+ `;
+
+ // 移除已存在的模态框
+ const existingModal = document.getElementById('imageViewModal');
+ if (existingModal) {
+ existingModal.remove();
+ }
+
+ // 添加新模态框
+ document.body.insertAdjacentHTML('beforeend', modalHtml);
+
+ // 显示模态框
+ const modal = new bootstrap.Modal(document.getElementById('imageViewModal'));
+ modal.show();
+
+ // 模态框关闭后移除DOM元素
+ document.getElementById('imageViewModal').addEventListener('hidden.bs.modal', function() {
+ this.remove();
+ });
+}
+
+// 编辑图片关键词(不允许修改)
+function editImageKeyword(index) {
+ showToast('图片关键词不允许修改,请删除后重新添加', 'warning');
+}
+
+// 修改导出关键词函数,使用后端导出API
+async function exportKeywords() {
+ if (!currentCookieId) {
+ showToast('请先选择账号', 'warning');
+ return;
+ }
+
+ try {
+ toggleLoading(true);
+
+ // 使用后端导出API
+ const response = await fetch(`${apiBase}/keywords-export/${currentCookieId}`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ // 获取文件blob
+ const blob = await response.blob();
+
+ // 从响应头获取文件名
+ const contentDisposition = response.headers.get('Content-Disposition');
+ let fileName = `关键词数据_${currentCookieId}_${new Date().toISOString().slice(0, 10)}.xlsx`;
+
+ if (contentDisposition) {
+ const fileNameMatch = contentDisposition.match(/filename\*=UTF-8''(.+)/);
+ if (fileNameMatch) {
+ fileName = decodeURIComponent(fileNameMatch[1]);
+ }
+ }
+
+ // 创建下载链接
+ const url = window.URL.createObjectURL(blob);
+ const a = document.createElement('a');
+ a.style.display = 'none';
+ a.href = url;
+ a.download = fileName;
+ document.body.appendChild(a);
+ a.click();
+
+ // 清理
+ window.URL.revokeObjectURL(url);
+ document.body.removeChild(a);
+
+ showToast('✅ 关键词导出成功', 'success');
+ } else {
+ const errorText = await response.text();
+ console.error('导出关键词失败:', errorText);
+ showToast('导出关键词失败', 'danger');
+ }
+ } catch (error) {
+ console.error('导出关键词失败:', error);
+ showToast('导出关键词失败', 'danger');
+ } finally {
+ toggleLoading(false);
+ }
+}
+
+// ==================== 备注管理功能 ====================
+
+// 编辑备注
+function editRemark(cookieId, currentRemark) {
+ console.log('editRemark called:', cookieId, currentRemark); // 调试信息
+ const remarkCell = document.querySelector(`[data-cookie-id="${cookieId}"] .remark-display`);
+ if (!remarkCell) {
+ console.log('remarkCell not found'); // 调试信息
+ return;
+ }
+
+ // 创建输入框
+ const input = document.createElement('input');
+ input.type = 'text';
+ input.className = 'form-control form-control-sm';
+ input.value = currentRemark || '';
+ input.placeholder = '请输入备注...';
+ input.style.fontSize = '0.875rem';
+ input.maxLength = 100; // 限制备注长度
+
+ // 保存原始内容和原始值
+ const originalContent = remarkCell.innerHTML;
+ const originalValue = currentRemark || '';
+
+ // 标记是否已经进行了编辑
+ let hasChanged = false;
+ let isProcessing = false; // 防止重复处理
+
+ // 替换为输入框
+ remarkCell.innerHTML = '';
+ remarkCell.appendChild(input);
+
+ // 监听输入变化
+ input.addEventListener('input', () => {
+ hasChanged = input.value.trim() !== originalValue;
+ });
+
+ // 保存函数
+ const saveRemark = async () => {
+ console.log('saveRemark called, isProcessing:', isProcessing, 'hasChanged:', hasChanged); // 调试信息
+ if (isProcessing) return; // 防止重复调用
+
+ const newRemark = input.value.trim();
+ console.log('newRemark:', newRemark, 'originalValue:', originalValue); // 调试信息
+
+ // 如果没有变化,直接恢复显示
+ if (!hasChanged || newRemark === originalValue) {
+ console.log('No changes detected, restoring original content'); // 调试信息
+ remarkCell.innerHTML = originalContent;
+ return;
+ }
+
+ isProcessing = true;
+
+ try {
+ const response = await fetch(`${apiBase}/cookies/${cookieId}/remark`, {
+ method: 'PUT',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify({ remark: newRemark })
+ });
+
+ if (response.ok) {
+ // 更新显示
+ remarkCell.innerHTML = `
+
+ `;
+ showToast('备注更新成功', 'success');
+ } else {
+ const errorData = await response.json();
+ showToast(`备注更新失败: ${errorData.detail || '未知错误'}`, 'danger');
+ // 恢复原始内容
+ remarkCell.innerHTML = originalContent;
+ }
+ } catch (error) {
+ console.error('更新备注失败:', error);
+ showToast('备注更新失败', 'danger');
+ // 恢复原始内容
+ remarkCell.innerHTML = originalContent;
+ } finally {
+ isProcessing = false;
+ }
+ };
+
+ // 取消函数
+ const cancelEdit = () => {
+ if (isProcessing) return;
+ remarkCell.innerHTML = originalContent;
+ };
+
+ // 延迟绑定blur事件,避免立即触发
+ setTimeout(() => {
+ input.addEventListener('blur', saveRemark);
+ }, 100);
+
+ // 绑定键盘事件
+ input.addEventListener('keydown', (e) => {
+ if (e.key === 'Enter') {
+ e.preventDefault();
+ saveRemark();
+ } else if (e.key === 'Escape') {
+ e.preventDefault();
+ cancelEdit();
+ }
+ });
+
+ // 聚焦并选中文本
+ input.focus();
+ input.select();
+}
+
+// 编辑暂停时间
+function editPauseDuration(cookieId, currentDuration) {
+ console.log('editPauseDuration called:', cookieId, currentDuration); // 调试信息
+ const pauseCell = document.querySelector(`[data-cookie-id="${cookieId}"] .pause-duration-display`);
+ if (!pauseCell) {
+ console.log('pauseCell not found'); // 调试信息
+ return;
+ }
+
+ // 创建输入框
+ const input = document.createElement('input');
+ input.type = 'number';
+ input.className = 'form-control form-control-sm';
+ input.value = currentDuration || 10;
+ input.placeholder = '请输入暂停时间...';
+ input.style.fontSize = '0.875rem';
+ input.min = 1;
+ input.max = 60;
+ input.step = 1;
+
+ // 保存原始内容和原始值
+ const originalContent = pauseCell.innerHTML;
+ const originalValue = currentDuration || 10;
+
+ // 标记是否已经进行了编辑
+ let hasChanged = false;
+ let isProcessing = false; // 防止重复处理
+
+ // 替换为输入框
+ pauseCell.innerHTML = '';
+ pauseCell.appendChild(input);
+
+ // 监听输入变化
+ input.addEventListener('input', () => {
+ const newValue = parseInt(input.value) || 10;
+ hasChanged = newValue !== originalValue;
+ });
+
+ // 保存函数
+ const savePauseDuration = async () => {
+ console.log('savePauseDuration called, isProcessing:', isProcessing, 'hasChanged:', hasChanged); // 调试信息
+ if (isProcessing) return; // 防止重复调用
+
+ const newDuration = parseInt(input.value) || 10;
+ console.log('newDuration:', newDuration, 'originalValue:', originalValue); // 调试信息
+
+ // 验证范围
+ if (newDuration < 1 || newDuration > 60) {
+ showToast('暂停时间必须在1-60分钟之间', 'warning');
+ input.focus();
+ return;
+ }
+
+ // 如果没有变化,直接恢复显示
+ if (!hasChanged || newDuration === originalValue) {
+ console.log('No changes detected, restoring original content'); // 调试信息
+ pauseCell.innerHTML = originalContent;
+ return;
+ }
+
+ isProcessing = true;
+
+ try {
+ const response = await fetch(`${apiBase}/cookies/${cookieId}/pause-duration`, {
+ method: 'PUT',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify({ pause_duration: newDuration })
+ });
+
+ if (response.ok) {
+ // 更新显示
+ pauseCell.innerHTML = `
+
+ ${newDuration}分钟
+
+ `;
+ showToast('暂停时间更新成功', 'success');
+ } else {
+ const errorData = await response.json();
+ showToast(`暂停时间更新失败: ${errorData.detail || '未知错误'}`, 'danger');
+ // 恢复原始内容
+ pauseCell.innerHTML = originalContent;
+ }
+ } catch (error) {
+ console.error('更新暂停时间失败:', error);
+ showToast('暂停时间更新失败', 'danger');
+ // 恢复原始内容
+ pauseCell.innerHTML = originalContent;
+ } finally {
+ isProcessing = false;
+ }
+ };
+
+ // 取消函数
+ const cancelEdit = () => {
+ if (isProcessing) return;
+ pauseCell.innerHTML = originalContent;
+ };
+
+ // 延迟绑定blur事件,避免立即触发
+ setTimeout(() => {
+ input.addEventListener('blur', savePauseDuration);
+ }, 100);
+
+ // 绑定键盘事件
+ input.addEventListener('keydown', (e) => {
+ if (e.key === 'Enter') {
+ e.preventDefault();
+ savePauseDuration();
+ } else if (e.key === 'Escape') {
+ e.preventDefault();
+ cancelEdit();
+ }
+ });
+
+ // 聚焦并选中文本
+ input.focus();
+ input.select();
+}
+
+// ==================== 工具提示初始化 ====================
+
+// 初始化工具提示
+function initTooltips() {
+ // 初始化所有工具提示
+ const tooltipTriggerList = [].slice.call(document.querySelectorAll('[data-bs-toggle="tooltip"]'));
+ tooltipTriggerList.map(function (tooltipTriggerEl) {
+ return new bootstrap.Tooltip(tooltipTriggerEl);
+ });
+}
+
+// ==================== 系统设置功能 ====================
+
+// 加载系统设置
+async function loadSystemSettings() {
+ console.log('加载系统设置');
+
+ // 通过验证接口获取用户信息(更可靠)
+ try {
+ const response = await fetch(`${apiBase}/verify`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const result = await response.json();
+ const isAdmin = result.is_admin === true;
+
+ console.log('用户信息:', result, '是否管理员:', isAdmin);
+
+ // 显示/隐藏注册设置、外发配置和AI默认配置(仅管理员可见)
+ const registrationSettings = document.getElementById('registration-settings');
+ const outgoingConfigs = document.getElementById('outgoing-configs');
+ const aiDefaultsConfigs = document.getElementById('ai-defaults-configs');
+ if (registrationSettings) {
+ registrationSettings.style.display = isAdmin ? 'block' : 'none';
+ }
+ if (outgoingConfigs) {
+ outgoingConfigs.style.display = isAdmin ? 'block' : 'none';
+ }
+ if (aiDefaultsConfigs) {
+ aiDefaultsConfigs.style.display = isAdmin ? 'block' : 'none';
+ }
+
+ // 如果是管理员,加载注册设置和外发配置
+ if (isAdmin) {
+ await loadRegistrationSettings();
+ await loadOutgoingConfigs();
+ await loadAIDefaultsConfigs();
+ }
+ }
+ } catch (error) {
+ console.error('获取用户信息失败:', error);
+ // 出错时隐藏管理员功能
+ const registrationSettings = document.getElementById('registration-settings');
+ if (registrationSettings) {
+ registrationSettings.style.display = 'none';
+ }
+ }
+}
+
+// 加载外发配置
+async function loadOutgoingConfigs() {
+ try {
+ const response = await fetch('/system-settings', {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const settings = await response.json();
+
+ // 渲染外发配置界面
+ renderOutgoingConfigs(settings);
+ }
+ } catch (error) {
+ console.error('加载外发配置失败:', error);
+ showToast('加载外发配置失败', 'danger');
+ }
+}
+
+// 渲染外发配置界面
+function renderOutgoingConfigs(settings) {
+ const container = document.getElementById('outgoing-configs');
+ if (!container) return;
+
+ let html = '';
+
+ // 渲染SMTP配置
+ const smtpConfig = outgoingConfigs.smtp;
+ html += `
+
+
+
+
+
${smtpConfig.description}
+
+
+
+
`;
+
+ html += '
';
+ container.innerHTML = html;
+
+ // 绑定表单提交事件
+ const form = document.getElementById('smtp-config-form');
+ if (form) {
+ form.addEventListener('submit', saveOutgoingConfigs);
+ }
+}
+
+// 生成外发配置字段HTML
+function generateOutgoingFieldHtml(field, value) {
+ switch (field.type) {
+ case 'select':
+ let options = '';
+ field.options.forEach(option => {
+ const selected = value === option.value ? 'selected' : '';
+ options += ``;
+ });
+ return ``;
+
+ case 'password':
+ return ``;
+
+ case 'number':
+ return ``;
+
+ case 'email':
+ return ``;
+
+ default:
+ return ``;
+ }
+}
+
+// 保存外发配置
+async function saveOutgoingConfigs(event) {
+ event.preventDefault();
+
+ const form = event.target;
+ const formData = new FormData(form);
+ const configs = {};
+
+ // 收集表单数据
+ for (let [key, value] of formData.entries()) {
+ configs[key] = value;
+ }
+
+ try {
+ // 逐个保存配置项
+ for (const [key, value] of Object.entries(configs)) {
+ const response = await fetch(`/system-settings/${key}`, {
+ method: 'PUT',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify({
+ key: key,
+ value: value,
+ description: `SMTP配置 - ${key}`
+ })
+ });
+
+ if (!response.ok) {
+ throw new Error(`保存${key}失败`);
+ }
+ }
+
+ showToast('外发配置保存成功', 'success');
+
+ // 重新加载配置
+ await loadOutgoingConfigs();
+
+ } catch (error) {
+ console.error('保存外发配置失败:', error);
+ showToast('保存外发配置失败: ' + error.message, 'danger');
+ }
+}
+
+// ==================== AI回复全局默认配置 ====================
+
+// 加载AI回复全局默认配置
+async function loadAIDefaultsConfigs() {
+ try {
+ const response = await fetch('/system-settings', {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const settings = await response.json();
+ renderAIDefaultsConfigs(settings);
+ }
+ } catch (error) {
+ console.error('加载AI默认配置失败:', error);
+ showToast('加载AI默认配置失败', 'danger');
+ }
+}
+
+// 渲染AI回复全局默认配置界面
+function renderAIDefaultsConfigs(settings) {
+ const container = document.getElementById('ai-defaults-configs');
+ if (!container) return;
+
+ let html = `
+
+
+
+
+
配置AI回复的全局默认值。各账号可单独覆盖这些设置。
+
+
+ 自定义提示词示例:{"classify":"判断用户意图","price":"你是个砍价高手,坚决不让步","tech":"你是个技术顾问","refund":"先安抚再引导走退款流程","default":"热情的卖家"}
+
+
+
+
+
+
`;
+
+ container.innerHTML = html;
+}
+
+// 保存AI回复全局默认配置
+async function saveAIDefaultsConfigs() {
+ const form = document.getElementById('ai-defaults-form');
+ if (!form) return;
+
+ const configs = {};
+
+ // 从DOM直接读取每个字段
+ const fieldKeys = Object.keys(aiDefaultConfigs);
+ fieldKeys.forEach(key => {
+ const config = aiDefaultConfigs[key];
+ const el = document.getElementById(key);
+ if (!el) return;
+ if (config.type === 'switch') {
+ configs[key] = el.checked ? 'true' : 'false';
+ } else {
+ configs[key] = el.value;
+ }
+ });
+
+ try {
+ const response = await fetch('/system-settings/ai-defaults', {
+ method: 'PUT',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify(configs)
+ });
+
+ if (response.ok) {
+ showToast('AI全局默认配置保存成功', 'success');
+ await loadAIDefaultsConfigs();
+ } else {
+ let errorMsg = '保存失败';
+ try {
+ const errorData = await response.json();
+ errorMsg = errorData.detail || JSON.stringify(errorData);
+ } catch {
+ errorMsg = await response.text() || `HTTP ${response.status}`;
+ }
+ throw new Error(errorMsg);
+ }
+ } catch (error) {
+ console.error('保存AI默认配置失败:', error);
+ showToast('保存AI默认配置失败: ' + error.message, 'danger');
+ }
+}
+
+// ==================== AI对话历史功能 ====================
+
+let aiConvCurrentPage = 1;
+const aiConvPageSize = 20;
+
+// 加载AI对话历史
+async function loadAIConversations() {
+ // 加载账号筛选下拉框
+ const cookieFilter = document.getElementById('aiConvCookieFilter');
+ if (cookieFilter && cookieFilter.options.length <= 1) {
+ await loadCookieFilter('aiConvCookieFilter');
+ }
+ aiConvCurrentPage = 1;
+ await fetchAIConversations();
+}
+
+// 切换AI对话历史页码
+async function changeAIConvPage(delta) {
+ const newPage = aiConvCurrentPage + delta;
+ if (newPage < 1) return;
+ aiConvCurrentPage = newPage;
+ await fetchAIConversations();
+}
+
+// 获取AI对话历史数据
+async function fetchAIConversations() {
+ const tbody = document.getElementById('aiConvTbody');
+ if (!tbody) return;
+
+ tbody.innerHTML = '| 加载中... |
';
+
+ const cookieFilter = document.getElementById('aiConvCookieFilter');
+ const userFilter = document.getElementById('aiConvUserFilter');
+ const itemFilter = document.getElementById('aiConvItemFilter');
+
+ const cookieId = cookieFilter ? cookieFilter.value : '';
+ const userId = userFilter ? userFilter.value.trim() : '';
+ const itemId = itemFilter ? itemFilter.value.trim() : '';
+
+ let url = `/ai-conversations?page=${aiConvCurrentPage}&page_size=${aiConvPageSize}`;
+ if (cookieId) url += `&cookie_id=${encodeURIComponent(cookieId)}`;
+ if (userId) url += `&buyer_id=${encodeURIComponent(userId)}`;
+ if (itemId) url += `&item_id=${encodeURIComponent(itemId)}`;
+
+ try {
+ const response = await fetch(url, {
+ headers: { 'Authorization': `Bearer ${authToken}` }
+ });
+
+ if (!response.ok) {
+ tbody.innerHTML = '| 加载失败 |
';
+ return;
+ }
+
+ const result = await response.json();
+ displayAIConversations(result);
+ } catch (error) {
+ console.error('获取AI对话历史失败:', error);
+ tbody.innerHTML = '| 加载失败: ' + error.message + ' |
';
+ }
+}
+
+// 渲染AI对话历史
+function displayAIConversations(result) {
+ const tbody = document.getElementById('aiConvTbody');
+ const totalCount = document.getElementById('aiConvTotalCount');
+ const pageInfo = document.getElementById('aiConvPageInfo');
+ const pagination = document.getElementById('aiConvPagination');
+
+ if (!tbody) return;
+
+ const data = result.data || [];
+ const total = result.total || 0;
+ const page = result.page || 1;
+ const totalPages = result.total_pages || 1;
+ aiConvCurrentPage = page;
+
+ if (totalCount) totalCount.textContent = total;
+ if (pageInfo) pageInfo.textContent = `第 ${page}/${totalPages} 页,共 ${total} 条`;
+
+ if (data.length === 0) {
+ tbody.innerHTML = '| 暂无对话记录 |
';
+ } else {
+ let html = '';
+ data.forEach(row => {
+ const roleLabel = row.role === 'assistant'
+ ? 'AI'
+ : '用户';
+ const intentLabel = row.intent
+ ? `${row.intent}`
+ : '-';
+ const content = row.content || '';
+ const shortContent = content.length > 80 ? content.substring(0, 80) + '...' : content;
+ const time = row.created_at ? formatDateTime(row.created_at) : '';
+
+ html += `
+ | ${row.id} |
+ ${escapeHtml(row.cookie_id || '')} |
+ ${escapeHtml(row.user_id || '')} |
+ ${roleLabel} |
+ ${escapeHtml(shortContent)} |
+ ${intentLabel} |
+ ${time} |
+
`;
+ });
+ tbody.innerHTML = html;
+ }
+
+ // 更新分页
+ if (pagination) {
+ const prevLi = pagination.children[0];
+ const nextLi = pagination.children[1];
+ if (prevLi) {
+ prevLi.className = 'page-item' + (page <= 1 ? ' disabled' : '');
+ }
+ if (nextLi) {
+ nextLi.className = 'page-item' + (page >= totalPages ? ' disabled' : '');
+ }
+ }
+}
+
+// 简单的转义函数
+function escapeHtml(str) {
+ if (!str) return '';
+ const div = document.createElement('div');
+ div.textContent = str;
+ return div.innerHTML;
+}
+
+// 填入提示词示例
+function fillPromptExample() {
+ const example = JSON.stringify({
+ "classify": "判断用户意图,返回price/tech/refund/default之一",
+ "price": "你是个砍价高手,语气坚定,最多给5%优惠",
+ "tech": "你是个技术顾问,专业简洁地解答产品问题",
+ "refund": "先安抚用户情绪,再引导走平台退款流程",
+ "default": "你是个热情的卖家,友好回答各类咨询"
+ }, null, 2);
+ const textarea = document.getElementById('ai_default_prompts');
+ if (textarea) textarea.value = example;
+ // 也更新账号配置里的提示词
+ const modalTextarea = document.getElementById('customPrompts');
+ if (modalTextarea) modalTextarea.value = example;
+}
+
+// 加载注册设置
+async function loadRegistrationSettings() {
+ try {
+ const response = await fetch('/registration-status');
+ if (response.ok) {
+ const data = await response.json();
+ const checkbox = document.getElementById('registrationEnabled');
+ if (checkbox) {
+ checkbox.checked = data.enabled;
+ }
+ }
+ } catch (error) {
+ console.error('加载注册设置失败:', error);
+ showToast('加载注册设置失败', 'danger');
+ }
+}
+
+// 更新注册设置
+async function updateRegistrationSettings() {
+ const checkbox = document.getElementById('registrationEnabled');
+ const statusDiv = document.getElementById('registrationStatus');
+ const statusText = document.getElementById('registrationStatusText');
+
+ if (!checkbox) return;
+
+ const enabled = checkbox.checked;
+
+ try {
+ const response = await fetch('/registration-settings', {
+ method: 'PUT',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify({ enabled: enabled })
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ showToast(data.message, 'success');
+
+ // 显示状态信息
+ if (statusDiv && statusText) {
+ statusText.textContent = data.message;
+ statusDiv.style.display = 'block';
+
+ // 3秒后隐藏状态信息
+ setTimeout(() => {
+ statusDiv.style.display = 'none';
+ }, 3000);
+ }
+ } else {
+ const errorData = await response.json();
+ showToast(`更新失败: ${errorData.detail || '未知错误'}`, 'danger');
+ }
+ } catch (error) {
+ console.error('更新注册设置失败:', error);
+ showToast('更新注册设置失败', 'danger');
+ }
+}
+
+// ================================
+// 订单管理功能
+// ================================
+
+// 加载订单列表
+async function loadOrders() {
+ try {
+ // 先加载Cookie列表用于筛选(同时缓存订单数据)
+ await loadOrderCookieFilter();
+
+ // 应用筛选并显示
+ filterOrders();
+ } catch (error) {
+ console.error('加载订单列表失败:', error);
+ showToast('加载订单列表失败', 'danger');
+ }
+}
+
+// 只刷新订单数据,不重新加载筛选器
+async function refreshOrdersData() {
+ try {
+ const selectedCookie = document.getElementById('orderCookieFilter').value;
+ if (selectedCookie) {
+ // 按cookie筛选时需要重新请求
+ const response = await fetch(`${apiBase}/admin/orders`, {
+ headers: { 'Authorization': `Bearer ${authToken}` }
+ });
+ const data = await response.json();
+ if (data.success) {
+ allOrdersData = (data.data || []).filter(order => order.cookie_id === selectedCookie);
+ allOrdersData.sort((a, b) => new Date(b.created_at) - new Date(a.created_at));
+ }
+ }
+ // 否则使用 loadOrderCookieFilter 已缓存的数据
+ filterOrders();
+ } catch (error) {
+ console.error('刷新订单数据失败:', error);
+ showToast('刷新订单数据失败', 'danger');
+ }
+}
+
+// 加载Cookie筛选选项
+async function loadOrderCookieFilter() {
+ try {
+ const response = await fetch(`${apiBase}/admin/orders`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ const data = await response.json();
+ if (data.success && data.data) {
+ // 提取唯一的cookie_id
+ const cookieIds = [...new Set(data.data.map(order => order.cookie_id).filter(id => id))];
+
+ const select = document.getElementById('orderCookieFilter');
+ if (select) {
+ select.innerHTML = '';
+
+ cookieIds.forEach(cookieId => {
+ const option = document.createElement('option');
+ option.value = cookieId;
+ option.textContent = cookieId;
+ select.appendChild(option);
+ });
+ }
+
+ // 缓存数据供后续使用
+ allOrdersData = data.data;
+ allOrdersData.sort((a, b) => new Date(b.created_at) - new Date(a.created_at));
+ }
+ } catch (error) {
+ console.error('加载Cookie选项失败:', error);
+ }
+}
+
+// 加载所有订单
+async function loadAllOrders() {
+ try {
+ const response = await fetch(`${apiBase}/admin/orders`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ const data = await response.json();
+ if (data.success) {
+ allOrdersData = data.data || [];
+ // 按创建时间倒序排列
+ allOrdersData.sort((a, b) => new Date(b.created_at) - new Date(a.created_at));
+
+ // 应用当前筛选条件
+ filterOrders();
+ } else {
+ console.error('加载订单失败:', data.message);
+ showToast('加载订单数据失败: ' + data.message, 'danger');
+ }
+ } catch (error) {
+ console.error('加载订单失败:', error);
+ showToast('加载订单数据失败,请检查网络连接', 'danger');
+ }
+}
+
+// 根据Cookie加载订单
+async function loadOrdersByCookie() {
+ const selectedCookie = document.getElementById('orderCookieFilter').value;
+ if (!selectedCookie) {
+ // 没有选中cookie,使用缓存的全量数据
+ await loadOrderCookieFilter();
+ filterOrders();
+ return;
+ }
+
+ try {
+ const response = await fetch(`${apiBase}/admin/orders`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ const data = await response.json();
+ if (data.success) {
+ // 筛选指定Cookie的订单
+ allOrdersData = (data.data || []).filter(order => order.cookie_id === selectedCookie);
+ // 按创建时间倒序排列
+ allOrdersData.sort((a, b) => new Date(b.created_at) - new Date(a.created_at));
+
+ // 应用当前筛选条件
+ filterOrders();
+ } else {
+ console.error('加载订单失败:', data.message);
+ showToast('加载订单数据失败: ' + data.message, 'danger');
+ }
+ } catch (error) {
+ console.error('加载订单失败:', error);
+ showToast('加载订单数据失败,请检查网络连接', 'danger');
+ }
+}
+
+// 筛选订单
+function filterOrders() {
+ const searchKeyword = document.getElementById('orderSearchInput')?.value.toLowerCase() || '';
+ const statusFilter = document.getElementById('orderStatusFilter')?.value || '';
+
+ filteredOrdersData = allOrdersData.filter(order => {
+ // 搜索关键词筛选(订单ID、商品ID或商品名称)
+ const matchesSearch = !searchKeyword ||
+ (order.order_id && order.order_id.toLowerCase().includes(searchKeyword)) ||
+ (order.item_id && order.item_id.toLowerCase().includes(searchKeyword)) ||
+ (order.item_title && order.item_title.toLowerCase().includes(searchKeyword));
+
+ // 发货状态筛选
+ const deliveryStatus = order.delivery_status || 'pending';
+ const matchesStatus = !statusFilter || deliveryStatus === statusFilter;
+
+ return matchesSearch && matchesStatus;
+ });
+
+ currentOrderSearchKeyword = searchKeyword;
+ currentOrdersPage = 1; // 重置到第一页
+
+ updateOrdersDisplay();
+}
+
+// 更新订单显示
+function updateOrdersDisplay() {
+ displayOrders();
+ updateOrdersPagination();
+ updateOrdersSearchStats();
+}
+
+// 显示订单列表
+function displayOrders() {
+ const tbody = document.getElementById('ordersTableBody');
+ if (!tbody) return;
+
+ if (filteredOrdersData.length === 0) {
+ tbody.innerHTML = `
+
+ |
+
+ ${currentOrderSearchKeyword ? '没有找到匹配的订单' : '暂无订单数据'}
+ |
+
+ `;
+ return;
+ }
+
+ // 计算分页
+ totalOrdersPages = Math.ceil(filteredOrdersData.length / ordersPerPage);
+ const startIndex = (currentOrdersPage - 1) * ordersPerPage;
+ const endIndex = startIndex + ordersPerPage;
+ const pageOrders = filteredOrdersData.slice(startIndex, endIndex);
+
+ // 生成表格行
+ tbody.innerHTML = pageOrders.map(order => createOrderRow(order)).join('');
+}
+
+// 创建订单行HTML
+function createOrderRow(order) {
+ const statusClass = getOrderStatusClass(order.order_status);
+ const statusText = getOrderStatusText(order.order_status);
+ const deliveryStatus = order.delivery_status || 'pending';
+ const deliveryStatusClass = getDeliveryStatusClass(deliveryStatus);
+ const deliveryStatusText = getDeliveryStatusText(deliveryStatus);
+
+ // 判断是否显示重新发货按钮
+ const showRetryBtn = deliveryStatus === 'failed' || deliveryStatus === 'pending';
+
+ return `
+
+ |
+
+ |
+
+
+ ${order.order_id}
+
+ |
+
+
+ ${order.item_title || order.item_id || '-'}
+
+ |
+
+
+ ${order.buyer_name || order.buyer_id || '-'}
+
+ |
+
+ ${order.spec_name && order.spec_value ?
+ `${order.spec_name}: ${order.spec_value}` :
+ '-'
+ }
+ |
+ ${order.quantity || '-'} |
+
+ ¥${order.amount || '0.00'}
+ |
+
+ ${deliveryStatusText}
+ |
+
+
+ ${order.cookie_id || '-'}
+
+ |
+
+ ${formatDateTime(order.created_at) || '-'}
+ |
+
+
+
+
+
+
+ |
+
+ `;
+}
+
+// 获取订单状态样式类
+function getOrderStatusClass(status) {
+ const statusMap = {
+ 'processing': 'bg-warning text-dark',
+ 'processed': 'bg-info text-white',
+ 'completed': 'bg-success text-white',
+ 'unknown': 'bg-secondary text-white'
+ };
+ return statusMap[status] || 'bg-secondary text-white';
+}
+
+// 获取订单状态文本
+function getOrderStatusText(status) {
+ const statusMap = {
+ 'processing': '处理中',
+ 'processed': '已处理',
+ 'completed': '已完成',
+ 'unknown': '未知'
+ };
+ return statusMap[status] || '未知';
+}
+
+// 获取发货状态样式类
+function getDeliveryStatusClass(status) {
+ const statusMap = {
+ 'pending': 'bg-secondary text-white',
+ 'delivered': 'bg-success text-white',
+ 'failed': 'bg-danger text-white',
+ 'not_triggered': 'bg-warning text-dark'
+ };
+ return statusMap[status] || 'bg-secondary text-white';
+}
+
+// 获取发货状态文本
+function getDeliveryStatusText(status) {
+ const statusMap = {
+ 'pending': '待发货',
+ 'delivered': '已发货',
+ 'failed': '发货失败',
+ 'not_triggered': '未触发'
+ };
+ return statusMap[status] || '未知';
+}
+
+// 重新发货
+async function retryOrderDelivery(orderId) {
+ if (!confirm(`确定要对订单 ${orderId} 重新发货吗?`)) {
+ return;
+ }
+
+ const authToken = localStorage.getItem('auth_token');
+
+ try {
+ const response = await fetch(`${apiBase}/orders/${orderId}/retry-delivery`, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ const result = await response.json();
+
+ if (response.ok && result.success) {
+ showToast('重新发货成功', 'success');
+ // 刷新订单列表
+ await refreshOrdersData();
+ } else {
+ showToast(result.detail || result.message || '重新发货失败', 'danger');
+ }
+ } catch (error) {
+ console.error('重新发货失败:', error);
+ showToast('重新发货失败: ' + error.message, 'danger');
+ }
+}
+
+// 更新订单分页
+function updateOrdersPagination() {
+ const pageInfo = document.getElementById('ordersPageInfo');
+ const pageInput = document.getElementById('ordersPageInput');
+ const totalPagesSpan = document.getElementById('ordersTotalPages');
+
+ if (pageInfo) {
+ const startIndex = (currentOrdersPage - 1) * ordersPerPage + 1;
+ const endIndex = Math.min(currentOrdersPage * ordersPerPage, filteredOrdersData.length);
+ pageInfo.textContent = `显示第 ${startIndex}-${endIndex} 条,共 ${filteredOrdersData.length} 条记录`;
+ }
+
+ if (pageInput) {
+ pageInput.value = currentOrdersPage;
+ }
+
+ if (totalPagesSpan) {
+ totalPagesSpan.textContent = totalOrdersPages;
+ }
+
+ // 更新分页按钮状态
+ const firstPageBtn = document.getElementById('ordersFirstPage');
+ const prevPageBtn = document.getElementById('ordersPrevPage');
+ const nextPageBtn = document.getElementById('ordersNextPage');
+ const lastPageBtn = document.getElementById('ordersLastPage');
+
+ if (firstPageBtn) firstPageBtn.disabled = currentOrdersPage === 1;
+ if (prevPageBtn) prevPageBtn.disabled = currentOrdersPage === 1;
+ if (nextPageBtn) nextPageBtn.disabled = currentOrdersPage === totalOrdersPages || totalOrdersPages === 0;
+ if (lastPageBtn) lastPageBtn.disabled = currentOrdersPage === totalOrdersPages || totalOrdersPages === 0;
+}
+
+// 更新搜索统计信息
+function updateOrdersSearchStats() {
+ const searchStats = document.getElementById('orderSearchStats');
+ const searchStatsText = document.getElementById('orderSearchStatsText');
+
+ if (searchStats && searchStatsText) {
+ if (currentOrderSearchKeyword) {
+ searchStatsText.textContent = `搜索 "${currentOrderSearchKeyword}" 找到 ${filteredOrdersData.length} 个结果`;
+ searchStats.style.display = 'block';
+ } else {
+ searchStats.style.display = 'none';
+ }
+ }
+}
+
+// 跳转到指定页面
+function goToOrdersPage(page) {
+ if (page < 1 || page > totalOrdersPages) return;
+
+ currentOrdersPage = page;
+ updateOrdersDisplay();
+}
+
+// 初始化订单搜索功能
+function initOrdersSearch() {
+ // 初始化分页大小
+ const pageSizeSelect = document.getElementById('ordersPageSize');
+ if (pageSizeSelect) {
+ ordersPerPage = parseInt(pageSizeSelect.value) || 20;
+ pageSizeSelect.addEventListener('change', changeOrdersPageSize);
+ }
+
+ // 初始化搜索输入框事件监听器
+ const searchInput = document.getElementById('orderSearchInput');
+ if (searchInput) {
+ // 使用防抖来避免频繁搜索
+ let searchTimeout;
+ searchInput.addEventListener('input', function() {
+ clearTimeout(searchTimeout);
+ searchTimeout = setTimeout(() => {
+ filterOrders();
+ }, 300); // 300ms 防抖延迟
+ });
+ }
+
+ // 初始化页面输入框事件监听器
+ const pageInput = document.getElementById('ordersPageInput');
+ if (pageInput) {
+ pageInput.addEventListener('keydown', handleOrdersPageInput);
+ }
+}
+
+// 处理分页大小变化
+function changeOrdersPageSize() {
+ const pageSizeSelect = document.getElementById('ordersPageSize');
+ if (pageSizeSelect) {
+ ordersPerPage = parseInt(pageSizeSelect.value) || 20;
+ currentOrdersPage = 1; // 重置到第一页
+ updateOrdersDisplay();
+ }
+}
+
+// 处理页面输入
+function handleOrdersPageInput(event) {
+ if (event.key === 'Enter') {
+ const pageInput = document.getElementById('ordersPageInput');
+ if (pageInput) {
+ const page = parseInt(pageInput.value);
+ if (page >= 1 && page <= totalOrdersPages) {
+ goToOrdersPage(page);
+ } else {
+ pageInput.value = currentOrdersPage; // 恢复当前页码
+ showToast('页码超出范围', 'warning');
+ }
+ }
+ }
+}
+
+// 刷新订单列表
+async function refreshOrders() {
+ await refreshOrdersData();
+ showToast('订单列表已刷新', 'success');
+}
+
+// 清空订单筛选条件
+function clearOrderFilters() {
+ const searchInput = document.getElementById('orderSearchInput');
+ const statusFilter = document.getElementById('orderStatusFilter');
+ const cookieFilter = document.getElementById('orderCookieFilter');
+
+ if (searchInput) searchInput.value = '';
+ if (statusFilter) statusFilter.value = '';
+ if (cookieFilter) cookieFilter.value = '';
+
+ filterOrders();
+ showToast('筛选条件已清空', 'info');
+}
+
+// 显示订单详情
+async function showOrderDetail(orderId) {
+ try {
+ const order = allOrdersData.find(o => o.order_id === orderId);
+ if (!order) {
+ showToast('订单不存在', 'warning');
+ return;
+ }
+
+ // 创建模态框内容
+ const modalContent = `
+
+
+
+
+
+
+
+
基本信息
+
+ | 订单ID | ${order.order_id} |
+ | 商品名称 | ${order.item_title || order.item_id || '未知'} |
+ | 买家 | ${order.buyer_name ? order.buyer_name + ' (' + (order.buyer_id || '') + ')' : (order.buyer_id || '未知')} |
+ | Cookie账号 | ${order.cookie_id || '未知'} |
+ | 订单状态 | ${getOrderStatusText(order.order_status)} |
+ | 发货状态 | ${getDeliveryStatusText(order.delivery_status || 'pending')} |
+
+
+
+
商品信息
+
+ | 规格名称 | ${order.spec_name || '无'} |
+ | 规格值 | ${order.spec_value || '无'} |
+ | 数量 | ${order.quantity || '1'} |
+ | 金额 | ¥${order.amount || '0.00'} |
+
+
+
+
+
+
时间信息
+
+ | 创建时间 | ${formatDateTime(order.created_at)} |
+ | 更新时间 | ${formatDateTime(order.updated_at)} |
+
+
+
+
+
+
商品详情
+
+
+
+ 加载中...
+
+
正在加载商品详情...
+
+
+
+
+
+
+
+
+
+ `;
+
+ // 移除已存在的模态框
+ const existingModal = document.getElementById('orderDetailModal');
+ if (existingModal) {
+ existingModal.remove();
+ }
+
+ // 添加新模态框到页面
+ document.body.insertAdjacentHTML('beforeend', modalContent);
+
+ // 显示模态框
+ const modal = new bootstrap.Modal(document.getElementById('orderDetailModal'));
+ modal.show();
+
+ // 异步加载商品详情
+ if (order.item_id) {
+ loadItemDetailForOrder(order.item_id, order.cookie_id, order);
+ }
+
+ } catch (error) {
+ console.error('显示订单详情失败:', error);
+ showToast('显示订单详情失败', 'danger');
+ }
+}
+
+// 为订单加载商品详情
+async function loadItemDetailForOrder(itemId, cookieId, orderInfo = null) {
+ try {
+ const token = localStorage.getItem('auth_token');
+
+ // 尝试从数据库获取商品信息
+ let response = await fetch(`${apiBase}/items/${cookieId}/${itemId}`, {
+ headers: {
+ 'Authorization': `Bearer ${token}`
+ }
+ });
+
+ const content = document.getElementById('itemDetailContent');
+ if (!content) return;
+
+ if (response.ok) {
+ const data = await response.json();
+ const item = data.item;
+
+ content.innerHTML = `
+
+
+
${item.item_title || '商品标题未知'}
+
${item.item_description || '暂无描述'}
+
+
+ 分类:${item.item_category || '未知'}
+
+
+ 价格:${item.item_price || '未知'}
+
+
+ ${item.item_detail ? `
+
+
详情:
+
+ ${item.item_detail}
+
+
+ ` : ''}
+
+
+ `;
+ } else {
+ // 商品详情不存在时,显示订单自身的商品信息
+ let fallbackHtml = '';
+ fallbackHtml += '
订单商品信息
';
+ if (orderInfo) {
+ fallbackHtml += '
';
+ if (orderInfo.item_title) {
+ fallbackHtml += `| 商品名称 | ${orderInfo.item_title} |
`;
+ }
+ fallbackHtml += `| 商品ID | ${orderInfo.item_id || '-'} |
`;
+ if (orderInfo.spec_name || orderInfo.spec_value) {
+ fallbackHtml += `| 规格 | ${orderInfo.spec_name || ''} ${orderInfo.spec_value || ''} |
`;
+ }
+ if (orderInfo.quantity) {
+ fallbackHtml += `| 数量 | ${orderInfo.quantity} |
`;
+ }
+ if (orderInfo.amount) {
+ fallbackHtml += `| 金额 | ¥${orderInfo.amount} |
`;
+ }
+ fallbackHtml += '
';
+ fallbackHtml += '
商品详细信息未同步,请在"商品管理"中获取商品信息';
+ } else {
+ fallbackHtml += '
暂无商品信息
';
+ }
+ fallbackHtml += '
';
+ content.innerHTML = fallbackHtml;
+ }
+ } catch (error) {
+ console.error('加载商品详情失败:', error);
+ const content = document.getElementById('itemDetailContent');
+ if (content) {
+ content.innerHTML = `
+
+
+ 加载商品详情失败:${error.message}
+
+ `;
+ }
+ }
+}
+
+// 删除订单
+async function deleteOrder(orderId) {
+ try {
+ const confirmed = confirm(`确定要删除订单吗?\n\n订单ID: ${orderId}\n\n此操作不可撤销!`);
+ if (!confirmed) {
+ return;
+ }
+
+ const response = await fetch(`${apiBase}/admin/data/orders/delete`, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify({ record_id: orderId })
+ });
+
+ if (response.ok) {
+ showToast('订单删除成功', 'success');
+ // 刷新列表
+ await refreshOrdersData();
+ } else {
+ const error = await response.text();
+ showToast(`删除失败: ${error}`, 'danger');
+ }
+ } catch (error) {
+ console.error('删除订单失败:', error);
+ showToast('删除订单失败', 'danger');
+ }
+}
+
+// 批量删除订单
+async function batchDeleteOrders() {
+ const checkboxes = document.querySelectorAll('.order-checkbox:checked');
+ if (checkboxes.length === 0) {
+ showToast('请先选择要删除的订单', 'warning');
+ return;
+ }
+
+ const orderIds = Array.from(checkboxes).map(cb => cb.value);
+ const confirmed = confirm(`确定要删除选中的 ${orderIds.length} 个订单吗?\n\n此操作不可撤销!`);
+
+ if (!confirmed) return;
+
+ try {
+ let successCount = 0;
+ let failCount = 0;
+
+ for (const orderId of orderIds) {
+ try {
+ const response = await fetch(`${apiBase}/admin/data/orders/delete`, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${authToken}`
+ },
+ body: JSON.stringify({ record_id: orderId })
+ });
+
+ if (response.ok) {
+ successCount++;
+ } else {
+ failCount++;
+ }
+ } catch (error) {
+ failCount++;
+ }
+ }
+
+ if (successCount > 0) {
+ showToast(`成功删除 ${successCount} 个订单${failCount > 0 ? `,${failCount} 个失败` : ''}`,
+ failCount > 0 ? 'warning' : 'success');
+ await refreshOrdersData();
+ } else {
+ showToast('批量删除失败', 'danger');
+ }
+
+ } catch (error) {
+ console.error('批量删除订单失败:', error);
+ showToast('批量删除订单失败', 'danger');
+ }
+}
+
+// 切换全选订单
+function toggleSelectAllOrders(checkbox) {
+ const orderCheckboxes = document.querySelectorAll('.order-checkbox');
+ orderCheckboxes.forEach(cb => {
+ cb.checked = checkbox.checked;
+ });
+
+ updateBatchDeleteOrdersButton();
+}
+
+// 更新批量删除按钮状态
+function updateBatchDeleteOrdersButton() {
+ const checkboxes = document.querySelectorAll('.order-checkbox:checked');
+ const batchDeleteBtn = document.getElementById('batchDeleteOrdersBtn');
+
+ if (batchDeleteBtn) {
+ batchDeleteBtn.disabled = checkboxes.length === 0;
+ }
+}
+
+// 格式化日期时间
+function formatDateTime(dateString) {
+ if (!dateString) return '未知时间';
+
+ try {
+ const utcString = dateString.endsWith('Z') ? dateString : dateString + 'Z';
+ const date = new Date(utcString);
+ return date.toLocaleString('zh-CN', {
+ timeZone: 'Asia/Shanghai',
+ year: 'numeric',
+ month: '2-digit',
+ day: '2-digit',
+ hour: '2-digit',
+ minute: '2-digit'
+ });
+ } catch (error) {
+ return dateString;
+ }
+}
+
+// 页面加载完成后初始化订单搜索功能
+document.addEventListener('DOMContentLoaded', function() {
+ // 延迟初始化,确保DOM完全加载
+ setTimeout(() => {
+ initOrdersSearch();
+
+ // 绑定复选框变化事件
+ document.addEventListener('change', function(e) {
+ if (e.target.classList.contains('order-checkbox')) {
+ updateBatchDeleteOrdersButton();
+ }
+ });
+ }, 100);
+});
+
+// ================================
+// 用户管理功能
+// ================================
+
+// 加载用户管理页面
+async function loadUserManagement() {
+ console.log('加载用户管理页面');
+
+ // 检查管理员权限
+ try {
+ const response = await fetch(`${apiBase}/verify`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const result = await response.json();
+ if (!result.is_admin) {
+ showToast('您没有权限访问用户管理功能', 'danger');
+ showSection('dashboard'); // 跳转回仪表盘
+ return;
+ }
+ } else {
+ showToast('权限验证失败', 'danger');
+ return;
+ }
+ } catch (error) {
+ console.error('权限验证失败:', error);
+ showToast('权限验证失败', 'danger');
+ return;
+ }
+
+ // 加载数据
+ await loadUserSystemStats();
+ await loadUsers();
+}
+
+// 加载用户系统统计信息
+async function loadUserSystemStats() {
+ try {
+ const token = localStorage.getItem('auth_token');
+
+ // 获取用户统计
+ const usersResponse = await fetch('/admin/users', {
+ headers: {
+ 'Authorization': `Bearer ${token}`
+ }
+ });
+
+ if (usersResponse.ok) {
+ const usersData = await usersResponse.json();
+ document.getElementById('totalUsers').textContent = usersData.users.length;
+ }
+
+ // 获取Cookie统计
+ const cookiesResponse = await fetch(`${apiBase}/admin/data/cookies`, {
+ headers: {
+ 'Authorization': `Bearer ${token}`
+ }
+ });
+
+ if (cookiesResponse.ok) {
+ const cookiesData = await cookiesResponse.json();
+ document.getElementById('totalUserCookies').textContent = cookiesData.data ? cookiesData.data.length : 0;
+ }
+
+ // 获取卡券统计
+ const cardsResponse = await fetch(`${apiBase}/admin/data/cards`, {
+ headers: {
+ 'Authorization': `Bearer ${token}`
+ }
+ });
+
+ if (cardsResponse.ok) {
+ const cardsData = await cardsResponse.json();
+ document.getElementById('totalUserCards').textContent = cardsData.data ? cardsData.data.length : 0;
+ }
+
+ } catch (error) {
+ console.error('加载系统统计失败:', error);
+ }
+}
+
+// 加载用户列表
+async function loadUsers() {
+ const loadingDiv = document.getElementById('loadingUsers');
+ const usersListDiv = document.getElementById('usersList');
+ const noUsersDiv = document.getElementById('noUsers');
+
+ // 显示加载状态
+ loadingDiv.style.display = 'block';
+ usersListDiv.style.display = 'none';
+ noUsersDiv.style.display = 'none';
+
+ try {
+ const token = localStorage.getItem('auth_token');
+ const response = await fetch('/admin/users', {
+ headers: {
+ 'Authorization': `Bearer ${token}`
+ }
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ loadingDiv.style.display = 'none';
+
+ if (data.users && data.users.length > 0) {
+ usersListDiv.style.display = 'block';
+ displayUsers(data.users);
+ } else {
+ noUsersDiv.style.display = 'block';
+ }
+ } else {
+ throw new Error('获取用户列表失败');
+ }
+ } catch (error) {
+ console.error('加载用户列表失败:', error);
+ loadingDiv.style.display = 'none';
+ noUsersDiv.style.display = 'block';
+ showToast('加载用户列表失败', 'danger');
+ }
+}
+
+// 显示用户列表(表格形式)
+function displayUsers(users) {
+ const usersListDiv = document.getElementById('usersList');
+ usersListDiv.innerHTML = `
+
+
+
+
+ | 用户名 |
+ 邮箱 |
+ 角色 |
+ Cookie数 |
+ 卡券数 |
+ 注册时间 |
+ 操作 |
+
+
+
+
+
+ `;
+
+ const tbody = document.getElementById('usersTableBody');
+ users.forEach(user => {
+ const role = user.role || (user.username === 'admin' ? 'admin' : 'user');
+ const roleLabels = { 'admin': '管理员', 'user': '普通用户' };
+ const roleDisplay = roleLabels[role] || role;
+ const isAdmin = role === 'admin';
+ const tr = document.createElement('tr');
+ tr.innerHTML = `
+ ${user.username} |
+ ${user.email || '未设置'} |
+ ${roleDisplay} |
+ ${user.cookie_count || 0} |
+ ${user.card_count || 0} |
+ ${formatDateTime(user.created_at)} |
+
+ ${!isAdmin ? `
+
+
+ ` : '-'}
+ |
+ `;
+ tbody.appendChild(tr);
+ });
+}
+
+// 全局变量用于存储当前要删除的用户信息
+let currentDeleteUserId = null;
+let currentDeleteUserName = null;
+let deleteUserModal = null;
+
+// 删除用户
+function deleteUser(userId, username) {
+ if (username === 'admin') {
+ showToast('不能删除管理员账号', 'warning');
+ return;
+ }
+
+ // 存储要删除的用户信息
+ currentDeleteUserId = userId;
+ currentDeleteUserName = username;
+
+ // 初始化模态框(如果还没有初始化)
+ if (!deleteUserModal) {
+ deleteUserModal = new bootstrap.Modal(document.getElementById('deleteUserModal'));
+ }
+
+ // 显示确认模态框
+ deleteUserModal.show();
+}
+
+// 确认删除用户
+async function confirmDeleteUser() {
+ if (!currentDeleteUserId) return;
+
+ try {
+ const token = localStorage.getItem('auth_token');
+
+ const response = await fetch(`/admin/users/${currentDeleteUserId}`, {
+ method: 'DELETE',
+ headers: {
+ 'Authorization': `Bearer ${token}`
+ }
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ deleteUserModal.hide();
+ showToast(data.message || '用户删除成功', 'success');
+
+ // 刷新页面数据
+ await loadUserSystemStats();
+ await loadUsers();
+ } else {
+ const errorData = await response.json();
+ showToast(`删除失败: ${errorData.detail || '未知错误'}`, 'danger');
+ }
+ } catch (error) {
+ console.error('删除用户失败:', error);
+ showToast('删除用户失败', 'danger');
+ } finally {
+ // 清理状态
+ currentDeleteUserId = null;
+ currentDeleteUserName = null;
+ }
+}
+
+// 刷新用户列表
+async function refreshUsers() {
+ await loadUserSystemStats();
+ await loadUsers();
+ showToast('用户列表已刷新', 'success');
+}
+
+// 添加用户
+let addUserModal = null;
+
+function showAddUserModal() {
+ document.getElementById('addUserUsername').value = '';
+ document.getElementById('addUserEmail').value = '';
+ document.getElementById('addUserPassword').value = '';
+
+ // 填充角色下拉
+ const roleSelect = document.getElementById('addUserRole');
+ roleSelect.innerHTML = '';
+ const roleLabels = { 'admin': '管理员', 'user': '普通用户' };
+ const allRoles = window.allRoles || ['user', 'admin'];
+ allRoles.forEach(r => {
+ const opt = document.createElement('option');
+ opt.value = r;
+ opt.textContent = roleLabels[r] || r;
+ roleSelect.appendChild(opt);
+ });
+
+ if (!addUserModal) {
+ addUserModal = new bootstrap.Modal(document.getElementById('addUserModal'));
+ }
+ addUserModal.show();
+}
+
+async function confirmAddUser() {
+ const username = document.getElementById('addUserUsername').value.trim();
+ const email = document.getElementById('addUserEmail').value.trim();
+ const password = document.getElementById('addUserPassword').value.trim();
+ const role = document.getElementById('addUserRole').value;
+
+ if (!username || !email || !password) {
+ showToast('请填写完整信息', 'warning');
+ return;
+ }
+ if (username.length < 2) {
+ showToast('用户名至少2个字符', 'warning');
+ return;
+ }
+ if (password.length < 6) {
+ showToast('密码至少6位', 'warning');
+ return;
+ }
+
+ try {
+ const token = localStorage.getItem('auth_token');
+ const response = await fetch('/admin/users', {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${token}`
+ },
+ body: JSON.stringify({ username, email, password, role })
+ });
+
+ const data = await response.json();
+ if (response.ok) {
+ addUserModal.hide();
+ showToast(data.message || '用户创建成功', 'success');
+ await refreshUsers();
+ } else {
+ showToast(data.detail || '创建失败', 'danger');
+ }
+ } catch (error) {
+ console.error('创建用户失败:', error);
+ showToast('创建用户失败', 'danger');
+ }
+}
+
+// 编辑用户
+let editUserModal = null;
+let currentEditUserId = null;
+
+function showEditUserModal(userId, username, email, currentRole) {
+ currentEditUserId = userId;
+ document.getElementById('editUserUsername').value = username;
+ document.getElementById('editUserEmail').value = email || '';
+ document.getElementById('editUserPassword').value = '';
+
+ // 填充角色下拉
+ const roleSelect = document.getElementById('editUserRole');
+ roleSelect.innerHTML = '';
+ const roleLabels = { 'admin': '管理员', 'user': '普通用户' };
+ const allRoles = window.allRoles || ['user', 'admin'];
+ allRoles.forEach(r => {
+ const opt = document.createElement('option');
+ opt.value = r;
+ opt.textContent = roleLabels[r] || r;
+ if (r === currentRole) opt.selected = true;
+ roleSelect.appendChild(opt);
+ });
+
+ if (!editUserModal) {
+ editUserModal = new bootstrap.Modal(document.getElementById('editUserModal'));
+ }
+ editUserModal.show();
+}
+
+async function confirmEditUser() {
+ if (!currentEditUserId) return;
+
+ const email = document.getElementById('editUserEmail').value.trim();
+ const password = document.getElementById('editUserPassword').value.trim();
+ const role = document.getElementById('editUserRole').value;
+
+ if (!email && !password && !role) {
+ showToast('请填写要修改的字段', 'warning');
+ return;
+ }
+ if (password && password.length < 6) {
+ showToast('密码至少6位', 'warning');
+ return;
+ }
+
+ const body = {};
+ if (email) body.email = email;
+ if (password) body.password = password;
+ if (role) body.role = role;
+
+ try {
+ const token = localStorage.getItem('auth_token');
+ const response = await fetch(`/admin/users/${currentEditUserId}`, {
+ method: 'PUT',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${token}`
+ },
+ body: JSON.stringify(body)
+ });
+
+ const data = await response.json();
+ if (response.ok) {
+ editUserModal.hide();
+ showToast(data.message || '用户信息已更新', 'success');
+ await refreshUsers();
+ } else {
+ showToast(data.detail || '更新失败', 'danger');
+ }
+ } catch (error) {
+ console.error('更新用户失败:', error);
+ showToast('更新用户失败', 'danger');
+ } finally {
+ currentEditUserId = null;
+ }
+}
+
+// ================================
+// 角色权限配置
+// ================================
+
+// 权限定义(所有系统功能)
+const ALL_PERMISSION_NAMES = {
+ 'dashboard': '仪表盘',
+ 'accounts': '账号管理',
+ 'items': '商品管理',
+ 'orders': '订单管理',
+ 'auto_reply': '自动回复',
+ 'ai_conversation': 'AI对话历史',
+ 'items_reply': '指定商品回复',
+ 'cards': '卡券管理',
+ 'auto_delivery': '自动发货',
+ 'notification_channels': '通知渠道',
+ 'message_notifications': '消息通知',
+ 'item_search': '商品搜索',
+ 'password_settings': '密码设置',
+ 'system_settings': '系统设置',
+ 'user_management': '用户管理',
+ 'system_logs': '系统日志',
+ 'data_management': '数据管理',
+ 'export_backup': '备份导出',
+ 'import_backup': '备份导入',
+};
+
+// 当前用户的页面权限缓存
+let userPagePermissions = {};
+let isAdminUser = false;
+
+// 加载当前用户的权限
+async function loadMyPermissions() {
+ try {
+ const resp = await fetch('/my-permissions', {
+ headers: { 'Authorization': `Bearer ${authToken}` }
+ });
+ const data = await resp.json();
+ if (data.success) {
+ isAdminUser = (data.role === 'admin');
+ userPagePermissions = data.permissions || {};
+ }
+ } catch (e) {}
+}
+
+// 检查是否有页面权限
+function hasPagePermission(sectionName) {
+ if (isAdminUser) return true;
+ // 映射 section 名到权限名
+ const permMap = {
+ 'dashboard': 'dashboard',
+ 'accounts': 'accounts',
+ 'items': 'items',
+ 'orders': 'orders',
+ 'auto-reply': 'auto_reply',
+ 'ai-conversation': 'ai_conversation',
+ 'items-reply': 'items_reply',
+ 'cards': 'cards',
+ 'auto-delivery': 'auto_delivery',
+ 'notification-channels': 'notification_channels',
+ 'message-notifications': 'message_notifications',
+ 'item-search': 'item_search',
+ 'password-settings': 'password_settings',
+ 'system-settings': 'system_settings',
+ 'user-management': 'user_management',
+ 'logs': 'system_logs',
+ 'data-management': 'data_management',
+ };
+ const permKey = permMap[sectionName];
+ if (!permKey) return true; // about, role-permissions 等页面不限制
+ return userPagePermissions[permKey] === true;
+}
+
+let currentEditRoleName = null;
+let rolesData = {};
+
+async function loadRoles() {
+ try {
+ const token = localStorage.getItem('auth_token');
+ const resp = await fetch('/admin/permissions', {
+ headers: { 'Authorization': `Bearer ${token}` }
+ });
+ const data = await resp.json();
+ if (data.success && data.roles) {
+ rolesData = data.roles;
+ renderRoles(rolesData);
+ } else {
+ // API返回失败,使用默认角色
+ rolesData = {
+ 'admin': Object.fromEntries(Object.keys(ALL_PERMISSION_NAMES).map(k => [k, true])),
+ 'user': Object.fromEntries(Object.keys(ALL_PERMISSION_NAMES).map(k => [k, !['user_management','system_logs','data_management','system_settings','export_backup','import_backup'].includes(k)]))
+ };
+ renderRoles(rolesData);
+ }
+ } catch (e) {
+ console.error('加载角色失败:', e);
+ // 网络错误也使用默认角色
+ const container = document.getElementById('rolesList');
+ if (container) container.innerHTML = '加载角色配置失败,请检查网络连接
';
+ }
+}
+
+function renderRoles(roles) {
+ const container = document.getElementById('rolesList');
+ const noRoles = document.getElementById('noRoles');
+ const roleNames = Object.keys(roles);
+
+ // 确保默认角色存在
+ if (!roleNames.includes('admin')) roleNames.unshift('admin');
+ if (!roleNames.includes('user') && roleNames.indexOf('admin') === -1) {
+ roleNames.push('user');
+ } else if (!roleNames.includes('user')) {
+ roleNames.push('user');
+ }
+
+ if (roleNames.length === 0) {
+ container.innerHTML = '';
+ noRoles.style.display = 'block';
+ return;
+ }
+ noRoles.style.display = 'none';
+
+ container.innerHTML = `
+
+
+
+
+ | 角色名称 |
+ 权限 |
+ 操作 |
+
+
+
+
+
+ `;
+
+ const tbody = document.getElementById('rolesTableBody');
+ roleNames.forEach(name => {
+ const perms = roles[name] || {};
+ let permList;
+ if (name === 'admin') {
+ permList = '全部权限';
+ } else {
+ permList = Object.entries(ALL_PERMISSION_NAMES)
+ .filter(([k]) => perms[k] === true)
+ .map(([, v]) => `${v}`)
+ .join('') || '无权限';
+ }
+
+ const roleLabels = { 'admin': '管理员', 'user': '普通用户' };
+ const displayName = roleLabels[name] || name;
+ const isBuiltin = (name === 'admin' || name === 'user');
+ const tr = document.createElement('tr');
+ tr.innerHTML = `
+ ${displayName} ${isBuiltin ? '内置' : ''} |
+ ${permList} |
+
+
+ ${!isBuiltin ? `
+
+ ` : ''}
+ |
+ `;
+ tbody.appendChild(tr);
+ });
+}
+
+// 添加角色
+let addRoleModal = null;
+
+function showAddRoleModal() {
+ document.getElementById('newRoleName').value = '';
+ if (!addRoleModal) {
+ addRoleModal = new bootstrap.Modal(document.getElementById('addRoleModal'));
+ }
+ addRoleModal.show();
+}
+
+async function confirmAddRole() {
+ const name = document.getElementById('newRoleName').value.trim();
+ if (!name) {
+ showToast('请输入角色名称', 'warning');
+ return;
+ }
+ if (rolesData[name] !== undefined) {
+ showToast(`角色 "${name}" 已存在`, 'warning');
+ return;
+ }
+
+ // 新增角色默认无权限
+ const newRoles = { ...rolesData, [name]: {} };
+ await saveRoles(newRoles);
+ addRoleModal.hide();
+}
+
+// 编辑角色
+let editRoleModal = null;
+
+const ADMIN_PERMS = ['user_management', 'system_logs', 'data_management', 'system_settings', 'export_backup', 'import_backup'];
+
+function showEditRoleModal(name) {
+ currentEditRoleName = name;
+ const roleLabels = { 'admin': '管理员', 'user': '普通用户' };
+ document.getElementById('editRoleTitle').textContent = `角色:${roleLabels[name] || name}`;
+
+ const perms = rolesData[name] || {};
+ const isAdminRole = (name === 'admin');
+ const isBuiltin = (name === 'admin' || name === 'user');
+ document.getElementById('deleteRoleBtn').style.display = isBuiltin ? 'none' : 'inline-block';
+
+ const permContainer = document.getElementById('editRolePermissions');
+ permContainer.innerHTML = Object.entries(ALL_PERMISSION_NAMES).map(([key, label]) => {
+ // admin 角色默认全部勾选且不可修改
+ if (isAdminRole) {
+ return `
+
+
+
+
+ `;
+ }
+ const checked = perms[key] === true;
+ return `
+
+
+
+
+ `;
+ }).join('');
+
+ if (!editRoleModal) {
+ editRoleModal = new bootstrap.Modal(document.getElementById('editRoleModal'));
+ }
+ editRoleModal.show();
+}
+
+// 全选/取消全选权限
+function checkAllPermissions(checked) {
+ if (currentEditRoleName === 'admin') return; // admin 不可修改
+ Object.keys(ALL_PERMISSION_NAMES).forEach(key => {
+ const el = document.getElementById(`perm_${key}`);
+ if (el && !el.disabled) el.checked = checked;
+ });
+}
+
+// user 角色默认非管理权限全开
+function getDefaultUserPerms() {
+ const perms = {};
+ Object.keys(ALL_PERMISSION_NAMES).forEach(key => {
+ perms[key] = !ADMIN_PERMS.includes(key);
+ });
+ return perms;
+}
+
+async function confirmEditRole() {
+ if (!currentEditRoleName) return;
+ const newPerms = {};
+ Object.keys(ALL_PERMISSION_NAMES).forEach(key => {
+ newPerms[key] = document.getElementById(`perm_${key}`).checked;
+ });
+
+ const newRoles = { ...rolesData, [currentEditRoleName]: newPerms };
+ await saveRoles(newRoles);
+ editRoleModal.hide();
+ currentEditRoleName = null;
+}
+
+// 直接从表格删除自定义角色
+function deleteCustomRole(name) {
+ if (!confirm(`确定删除角色 "${name}" 吗?拥有该角色的用户需要重新分配角色。`)) return;
+ const newRoles = { ...rolesData };
+ delete newRoles[name];
+ saveRoles(newRoles);
+}
+
+async function confirmDeleteRole() {
+ if (!currentEditRoleName) return;
+ if (!confirm(`确定删除角色 "${currentEditRoleName}" 吗?拥有该角色的用户需要重新分配角色。`)) return;
+
+ const newRoles = { ...rolesData };
+ delete newRoles[currentEditRoleName];
+ await saveRoles(newRoles);
+ editRoleModal.hide();
+ currentEditRoleName = null;
+}
+
+async function saveRoles(roles) {
+ try {
+ const token = localStorage.getItem('auth_token');
+ const resp = await fetch('/admin/permissions', {
+ method: 'PUT',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${token}`
+ },
+ body: JSON.stringify({ roles })
+ });
+ const data = await resp.json();
+ if (data.success) {
+ showToast('权限配置已保存', 'success');
+ rolesData = roles;
+ renderRoles(roles);
+ // 刷新用户管理页的角色下拉
+ if (typeof loadRolesForSelect === 'function') loadRolesForSelect();
+ } else {
+ showToast(data.detail || '保存失败', 'danger');
+ }
+ } catch (e) {
+ showToast('保存失败', 'danger');
+ }
+}
+
+// 加载角色下拉(供用户管理编辑使用)
+async function loadRolesForSelect() {
+ try {
+ const token = localStorage.getItem('auth_token');
+ const resp = await fetch('/admin/permissions', {
+ headers: { 'Authorization': `Bearer ${token}` }
+ });
+ const data = await resp.json();
+ if (data.success) {
+ window.allRoles = Object.keys(data.roles || {});
+ if (!window.allRoles.includes('user')) window.allRoles.push('user');
+ if (!window.allRoles.includes('admin')) window.allRoles.unshift('admin');
+ }
+ } catch (e) {}
+}
+
+// ================================
+// 数据管理功能
+// ================================
+
+// 全局变量
+let currentTable = '';
+let currentData = [];
+
+// 表的中文描述
+const tableDescriptions = {
+ 'users': '用户表',
+ 'cookies': 'Cookie账号表',
+ 'cookie_status': 'Cookie状态表',
+ 'keywords': '关键字表',
+ 'item_replay': '指定商品回复表',
+ 'default_replies': '默认回复表',
+ 'default_reply_records': '默认回复记录表',
+ 'ai_reply_settings': 'AI回复设置表',
+ 'ai_conversations': 'AI对话历史表',
+ 'ai_item_cache': 'AI商品信息缓存表',
+ 'item_info': '商品信息表',
+ 'message_notifications': '消息通知表',
+ 'cards': '卡券表',
+ 'delivery_rules': '发货规则表',
+ 'notification_channels': '通知渠道表',
+ 'user_settings': '用户设置表',
+ 'system_settings': '系统设置表',
+ 'email_verifications': '邮箱验证表',
+ 'captcha_codes': '验证码表',
+ 'orders': '订单表'
+};
+
+// 加载数据管理页面
+async function loadDataManagement() {
+ console.log('加载数据管理页面');
+
+ // 检查管理员权限
+ try {
+ const response = await fetch(`${apiBase}/verify`, {
+ headers: {
+ 'Authorization': `Bearer ${authToken}`
+ }
+ });
+
+ if (response.ok) {
+ const result = await response.json();
+ if (!result.is_admin) {
+ showToast('您没有权限访问数据管理功能', 'danger');
+ showSection('dashboard'); // 跳转回仪表盘
+ return;
+ }
+ } else {
+ showToast('权限验证失败', 'danger');
+ return;
+ }
+ } catch (error) {
+ console.error('权限验证失败:', error);
+ showToast('权限验证失败', 'danger');
+ return;
+ }
+
+ // 重置状态
+ currentTable = '';
+ currentData = [];
+
+ // 重置界面
+ showNoTableSelected();
+
+ // 重置表格选择器
+ const tableSelect = document.getElementById('tableSelect');
+ if (tableSelect) {
+ tableSelect.value = '';
+ }
+}
+
+// 显示未选择表格状态
+function showNoTableSelected() {
+ document.getElementById('loadingTable').style.display = 'none';
+ document.getElementById('noTableSelected').style.display = 'block';
+ document.getElementById('noTableData').style.display = 'none';
+ document.getElementById('tableContainer').style.display = 'none';
+
+ // 重置统计信息
+ document.getElementById('recordCount').textContent = '-';
+ document.getElementById('tableTitle').innerHTML = ' 数据表';
+
+ // 禁用按钮
+ document.getElementById('clearBtn').disabled = true;
+}
+
+// 显示加载状态
+function showLoading() {
+ document.getElementById('loadingTable').style.display = 'block';
+ document.getElementById('noTableSelected').style.display = 'none';
+ document.getElementById('noTableData').style.display = 'none';
+ document.getElementById('tableContainer').style.display = 'none';
+}
+
+// 显示无数据状态
+function showNoData() {
+ document.getElementById('loadingTable').style.display = 'none';
+ document.getElementById('noTableSelected').style.display = 'none';
+ document.getElementById('noTableData').style.display = 'block';
+ document.getElementById('tableContainer').style.display = 'none';
+}
+
+// 加载表数据
+async function loadTableData() {
+ const tableSelect = document.getElementById('tableSelect');
+ const selectedTable = tableSelect.value;
+
+ if (!selectedTable) {
+ showNoTableSelected();
+ return;
+ }
+
+ currentTable = selectedTable;
+ showLoading();
+
+ const token = localStorage.getItem('auth_token');
+
+ try {
+ const response = await fetch(`/admin/data/${selectedTable}`, {
+ headers: {
+ 'Authorization': `Bearer ${token}`
+ }
+ });
+
+ const data = await response.json();
+
+ if (data.success) {
+ currentData = data.data;
+ displayTableData(data.data, data.columns);
+ updateTableInfo(selectedTable, data.data.length);
+ } else {
+ showToast('加载数据失败: ' + data.message, 'danger');
+ showNoData();
+ }
+ } catch (error) {
+ console.error('加载数据失败:', error);
+ showToast('加载数据失败', 'danger');
+ showNoData();
+ }
+}
+
+// 显示表格数据
+function displayTableData(data, columns) {
+ if (!data || data.length === 0) {
+ showNoData();
+ return;
+ }
+
+ // 显示表格容器
+ document.getElementById('loadingTable').style.display = 'none';
+ document.getElementById('noTableSelected').style.display = 'none';
+ document.getElementById('noTableData').style.display = 'none';
+ document.getElementById('tableContainer').style.display = 'block';
+
+ // 生成表头(添加操作列)
+ const tableHeaders = document.getElementById('tableHeaders');
+ const headerHtml = columns.map(col => `${col} | `).join('') + '操作 | ';
+ tableHeaders.innerHTML = headerHtml;
+
+ // 生成表格内容(添加删除按钮)
+ const tableBody = document.getElementById('tableBody');
+ tableBody.innerHTML = data.map((row, index) => {
+ const dataCells = columns.map(col => {
+ let value = row[col];
+ if (value === null || value === undefined) {
+ value = 'NULL';
+ } else if (typeof value === 'string' && value.length > 50) {
+ value = `${escapeHtml(value.substring(0, 50))}...`;
+ } else {
+ value = escapeHtml(String(value));
+ }
+ return `${value} | `;
+ }).join('');
+
+ // 添加操作列(删除按钮)
+ const recordId = row.id || row.user_id || index;
+ const actionCell = `
+
+ | `;
+
+ return `${dataCells}${actionCell}
`;
+ }).join('');
+}
+
+// HTML转义函数
+function escapeHtml(text) {
+ const div = document.createElement('div');
+ div.textContent = text;
+ return div.innerHTML;
+}
+
+// 更新表格信息
+function updateTableInfo(tableName, recordCount) {
+ const description = tableDescriptions[tableName] || tableName;
+ document.getElementById('tableTitle').innerHTML = ` ${description}`;
+ document.getElementById('recordCount').textContent = recordCount;
+
+ // 启用清空按钮
+ document.getElementById('clearBtn').disabled = false;
+}
+
+// 刷新表格数据
+function refreshTableData() {
+ if (currentTable) {
+ loadTableData();
+ showToast('数据已刷新', 'success');
+ } else {
+ showToast('请先选择数据表', 'warning');
+ }
+}
+
+// 导出表格数据
+async function exportTableData() {
+ if (!currentTable || !currentData || currentData.length === 0) {
+ showToast('没有可导出的数据', 'warning');
+ return;
+ }
+
+ try {
+ const token = localStorage.getItem('auth_token');
+ const response = await fetch(`/admin/data/${currentTable}/export`, {
+ headers: {
+ 'Authorization': `Bearer ${token}`
+ }
+ });
+
+ if (response.ok) {
+ const blob = await response.blob();
+ const url = window.URL.createObjectURL(blob);
+ const a = document.createElement('a');
+ a.style.display = 'none';
+ a.href = url;
+ a.download = `${currentTable}_${new Date().toISOString().slice(0, 10)}.xlsx`;
+ document.body.appendChild(a);
+ a.click();
+ window.URL.revokeObjectURL(url);
+ document.body.removeChild(a);
+
+ showToast('数据导出成功', 'success');
+ } else {
+ showToast('导出失败', 'danger');
+ }
+ } catch (error) {
+ console.error('导出数据失败:', error);
+ showToast('导出数据失败', 'danger');
+ }
+}
+
+// 清空表格数据
+async function clearTableData() {
+ if (!currentTable) {
+ showToast('请先选择数据表', 'warning');
+ return;
+ }
+
+ const description = tableDescriptions[currentTable] || currentTable;
+ const confirmed = confirm(`确定要清空 "${description}" 的所有数据吗?\n\n此操作不可撤销!`);
+
+ if (!confirmed) return;
+
+ try {
+ const token = localStorage.getItem('auth_token');
+ const response = await fetch(`/admin/data/${currentTable}/clear`, {
+ method: 'POST',
+ headers: {
+ 'Authorization': `Bearer ${token}`
+ }
+ });
+
+ if (response.ok) {
+ const data = await response.json();
+ showToast(data.message || '数据清空成功', 'success');
+ // 重新加载数据
+ loadTableData();
+ } else {
+ const errorData = await response.json();
+ showToast(`清空失败: ${errorData.detail || '未知错误'}`, 'danger');
+ }
+ } catch (error) {
+ console.error('清空数据失败:', error);
+ showToast('清空数据失败', 'danger');
+ }
+}
+
+// 删除记录相关变量
+let currentDeleteId = null;
+let deleteRecordModal = null;
+
+// 初始化删除记录模态框
+function initDeleteRecordModal() {
+ if (!deleteRecordModal) {
+ deleteRecordModal = new bootstrap.Modal(document.getElementById('deleteRecordModal'));
+ }
+}
+
+// 通过索引删除记录
+function deleteRecordByIndex(index) {
+ console.log('deleteRecordByIndex被调用,index:', index);
+ console.log('currentData:', currentData);
+ console.log('当前currentTable:', currentTable);
+
+ if (!currentData || index >= currentData.length) {
+ console.error('无效的索引或数据不存在');
+ showToast('删除失败:数据不存在', 'danger');
+ return;
+ }
+
+ const record = currentData[index];
+ console.log('获取到的record:', record);
+
+ deleteRecord(record, index);
+}
+
+// 删除记录
+function deleteRecord(record, index) {
+ console.log('deleteRecord被调用');
+ console.log('record:', record);
+ console.log('index:', index);
+ console.log('当前currentTable:', currentTable);
+
+ initDeleteRecordModal();
+
+ // 尝试多种方式获取记录ID
+ currentDeleteId = record.id || record.user_id || record.cookie_id || record.keyword_id ||
+ record.card_id || record.item_id || record.order_id || index;
+
+ console.log('设置currentDeleteId为:', currentDeleteId);
+ console.log('record的所有字段:', Object.keys(record));
+ console.log('record的所有值:', record);
+
+ // 显示记录信息
+ const deleteRecordInfo = document.getElementById('deleteRecordInfo');
+ deleteRecordInfo.innerHTML = '';
+
+ Object.keys(record).forEach(key => {
+ const div = document.createElement('div');
+ div.innerHTML = `${key}: ${record[key] || '-'}`;
+ deleteRecordInfo.appendChild(div);
+ });
+
+ deleteRecordModal.show();
+}
+
+// 确认删除记录
+async function confirmDeleteRecord() {
+ console.log('confirmDeleteRecord被调用');
+ console.log('currentDeleteId:', currentDeleteId);
+ console.log('currentTable:', currentTable);
+
+ if (!currentDeleteId || !currentTable) {
+ console.error('缺少必要参数:', { currentDeleteId, currentTable });
+ showToast('删除失败:缺少必要参数', 'danger');
+ return;
+ }
+
+ try {
+ const token = localStorage.getItem('auth_token');
+ const url = `/admin/data/${currentTable}/${currentDeleteId}`;
+ console.log('发送删除请求到:', url);
+
+ const response = await fetch(url, {
+ method: 'DELETE',
+ headers: {
+ 'Authorization': `Bearer ${token}`
+ }
+ });
+
+ console.log('删除响应状态:', response.status);
+
+ if (response.ok) {
+ const data = await response.json();
+ console.log('删除成功响应:', data);
+ deleteRecordModal.hide();
+ showToast(data.message || '删除成功', 'success');
+ loadTableData(); // 重新加载数据
+ } else {
+ const errorData = await response.json();
+ console.error('删除失败响应:', errorData);
+ showToast(`删除失败: ${errorData.detail || '未知错误'}`, 'danger');
+ }
+ } catch (error) {
+ console.error('删除记录失败:', error);
+ showToast('删除记录失败: ' + error.message, 'danger');
+ }
+}
+
+// ================================
+// 系统日志管理功能
+// ================================
+let logAutoRefreshInterval = null;
+let currentLogLevel = '';
+
+// 加载系统日志
+async function loadSystemLogs() {
+ const token = localStorage.getItem('auth_token');
+ const lines = document.getElementById('logLines').value;
+ const level = currentLogLevel;
+
+ const loadingDiv = document.getElementById('loadingSystemLogs');
+ const logContainer = document.getElementById('systemLogContainer');
+ const noLogsDiv = document.getElementById('noSystemLogs');
+
+ loadingDiv.style.display = 'block';
+ logContainer.style.display = 'none';
+ noLogsDiv.style.display = 'none';
+
+ let url = `/admin/logs?lines=${lines}`;
+ if (level) {
+ url += `&level=${level}`;
+ }
+
+ try {
+ const response = await fetch(url, {
+ headers: {
+ 'Authorization': `Bearer ${token}`
+ }
+ });
+
+ const data = await response.json();
+ loadingDiv.style.display = 'none';
+
+ if (data.logs && data.logs.length > 0) {
+ displaySystemLogs(data.logs);
+ updateLogInfo(data);
+ logContainer.style.display = 'block';
+ } else {
+ noLogsDiv.style.display = 'block';
+ }
+
+ // 更新最后更新时间
+ document.getElementById('logLastUpdate').textContent =
+ '最后更新: ' + new Date().toLocaleTimeString('zh-CN');
+ } catch (error) {
+ console.error('加载日志失败:', error);
+ loadingDiv.style.display = 'none';
+ noLogsDiv.style.display = 'block';
+ showToast('加载日志失败', 'danger');
+ }
+}
+
+// 显示系统日志
+function displaySystemLogs(logs) {
+ const logContainer = document.getElementById('systemLogContainer');
+ logContainer.innerHTML = '';
+
+ // 反转日志数组,让最新的日志显示在最上面
+ const reversedLogs = [...logs].reverse();
+
+ reversedLogs.forEach(log => {
+ const logLine = document.createElement('div');
+ logLine.className = 'log-entry';
+
+ // 根据日志级别添加颜色类
+ if (/\|\s*INFO\s*\|/.test(log)) {
+ logLine.classList.add('INFO');
+ } else if (/\|\s*WARNING\s*\|/.test(log)) {
+ logLine.classList.add('WARNING');
+ } else if (/\|\s*ERROR\s*\|/.test(log)) {
+ logLine.classList.add('ERROR');
+ } else if (/\|\s*DEBUG\s*\|/.test(log)) {
+ logLine.classList.add('DEBUG');
+ } else if (/\|\s*CRITICAL\s*\|/.test(log)) {
+ logLine.classList.add('CRITICAL');
+ }
+
+ logLine.textContent = log;
+ logContainer.appendChild(logLine);
+ });
+
+ // 自动滚动到顶部(显示最新日志)
+ scrollLogToTop();
+}
+
+// 更新日志信息
+function updateLogInfo(data) {
+ document.getElementById('logFileName').textContent = data.log_file || '-';
+ document.getElementById('logDisplayLines').textContent = data.total_lines || '-';
+}
+
+// 按级别过滤日志
+function filterLogsByLevel(level) {
+ currentLogLevel = level;
+
+ // 更新过滤按钮状态
+ document.querySelectorAll('.filter-badge').forEach(badge => {
+ badge.classList.remove('active');
+ });
+ document.querySelector(`[data-level="${level}"]`).classList.add('active');
+
+ // 更新当前过滤显示
+ const filterText = level ? level.toUpperCase() : '全部';
+ document.getElementById('logCurrentFilter').textContent = filterText;
+
+ // 重新加载日志
+ loadSystemLogs();
+}
+
+// 切换日志自动刷新
+function toggleLogAutoRefresh() {
+ const autoRefresh = document.getElementById('autoRefreshLogs');
+ const label = document.getElementById('autoRefreshLogLabel');
+ const icon = document.getElementById('autoRefreshLogIcon');
+
+ if (autoRefresh.checked) {
+ // 开启自动刷新
+ logAutoRefreshInterval = setInterval(loadSystemLogs, 5000); // 每5秒刷新
+ label.textContent = '开启 (5s)';
+ icon.style.display = 'inline';
+ icon.classList.add('auto-refresh-indicator');
+ } else {
+ // 关闭自动刷新
+ if (logAutoRefreshInterval) {
+ clearInterval(logAutoRefreshInterval);
+ logAutoRefreshInterval = null;
+ }
+ label.textContent = '关闭';
+ icon.style.display = 'none';
+ icon.classList.remove('auto-refresh-indicator');
+ }
+}
+
+// 滚动到日志顶部
+function scrollLogToTop() {
+ const logContainer = document.getElementById('systemLogContainer');
+ logContainer.scrollTop = 0;
+}
+
+// 滚动到日志底部
+function scrollLogToBottom() {
+ const logContainer = document.getElementById('systemLogContainer');
+ logContainer.scrollTop = logContainer.scrollHeight;
+}
+
+// ================================
+// 商品搜索功能
+// ================================
+let searchResultsData = [];
+let currentSearchPage = 1;
+let searchPageSize = 20;
+let totalSearchPages = 0;
+
+// 初始化商品搜索功能
+function initItemSearch() {
+ const searchForm = document.getElementById('itemSearchForm');
+ if (searchForm) {
+ searchForm.addEventListener('submit', handleItemSearch);
+ }
+}
+
+// 处理商品搜索
+async function handleItemSearch(event) {
+ event.preventDefault();
+
+ const keyword = document.getElementById('searchKeyword').value.trim();
+ const totalPages = parseInt(document.getElementById('searchTotalPages').value) || 1;
+ const pageSize = parseInt(document.getElementById('searchPageSize').value) || 20;
+
+ if (!keyword) {
+ showToast('请输入搜索关键词', 'warning');
+ return;
+ }
+
+ // 显示搜索状态
+ showSearchStatus(true);
+ hideSearchResults();
+
+ try {
+ // 检查是否有有效的cookies账户
+ const cookiesCheckResponse = await fetch('/cookies/check', {
+ headers: {
+ 'Authorization': `Bearer ${localStorage.getItem('auth_token')}`
+ }
+ });
+
+ if (cookiesCheckResponse.ok) {
+ const cookiesData = await cookiesCheckResponse.json();
+ if (!cookiesData.hasValidCookies) {
+ showToast('搜索失败:系统中不存在有效的账户信息。请先在Cookie管理中添加有效的闲鱼账户。', 'warning');
+ showSearchStatus(false);
+ return;
+ }
+ }
+
+ const token = localStorage.getItem('auth_token');
+ const response = await fetch('/items/search_multiple', {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ 'Authorization': `Bearer ${token}`
+ },
+ body: JSON.stringify({
+ keyword: keyword,
+ total_pages: totalPages
+ })
+ });
+
+ console.log('API响应状态:', response.status);
+
+ if (response.ok) {
+ const data = await response.json();
+ console.log('API返回的完整数据:', data);
+
+ // 修复字段名:使用data.data而不是data.items
+ searchResultsData = data.data || [];
+ originalSearchResultsData = []; // 重置排序原始数据
+ currentSortType = 'default'; // 重置排序类型
+ console.log('设置searchResultsData:', searchResultsData);
+ console.log('searchResultsData长度:', searchResultsData.length);
+
+ searchPageSize = pageSize;
+ currentSearchPage = 1;
+ totalSearchPages = Math.ceil(searchResultsData.length / searchPageSize);
+
+ if (data.error) {
+ showToast(`搜索完成,但遇到问题: ${data.error}`, 'warning');
+ }
+
+ showSearchStatus(false);
+ displaySearchResults();
+ updateSearchStats(data);
+ } else {
+ const errorData = await response.json();
+ showSearchStatus(false);
+ showToast(`搜索失败: ${errorData.detail || '未知错误'}`, 'danger');
+ showNoSearchResults();
+ }
+ } catch (error) {
+ console.error('搜索商品失败:', error);
+ showSearchStatus(false);
+ showToast('搜索商品失败', 'danger');
+ showNoSearchResults();
+ }
+}
+
+// 显示搜索状态
+function showSearchStatus(isSearching) {
+ const statusDiv = document.getElementById('searchStatus');
+ const progressDiv = document.getElementById('searchProgress');
+
+ if (isSearching) {
+ statusDiv.style.display = 'block';
+ progressDiv.textContent = '正在搜索商品数据...';
+ } else {
+ statusDiv.style.display = 'none';
+ }
+}
+
+// 隐藏搜索结果
+function hideSearchResults() {
+ document.getElementById('searchResults').style.display = 'none';
+ document.getElementById('searchResultStats').style.display = 'none';
+ document.getElementById('noSearchResults').style.display = 'none';
+}
+
+// ========================= 排序功能 =========================
+let currentSortType = 'default';
+let originalSearchResultsData = [];
+
+// 排序搜索结果
+function sortResults(sortType) {
+ currentSortType = sortType;
+
+ // 更新按钮状态
+ document.querySelectorAll('#searchResults .btn-group .btn').forEach(btn => {
+ btn.classList.remove('active');
+ });
+
+ const activeBtn = {
+ 'default': 'sortDefault',
+ 'want_desc': 'sortWantDesc',
+ 'want_asc': 'sortWantAsc',
+ 'price_asc': 'sortPriceAsc',
+ 'price_desc': 'sortPriceDesc'
+ }[sortType];
+
+ if (activeBtn) {
+ document.getElementById(activeBtn).classList.add('active');
+ }
+
+ // 保存原始数据(第一次排序时)
+ if (originalSearchResultsData.length === 0) {
+ originalSearchResultsData = [...searchResultsData];
+ }
+
+ // 获取要排序的数据
+ let dataToSort = [...originalSearchResultsData];
+
+ // 解析价格为数字
+ function parsePrice(priceStr) {
+ if (!priceStr) return 0;
+ const num = parseFloat(priceStr.replace(/[¥¥,,]/g, ''));
+ return isNaN(num) ? 0 : num;
+ }
+
+ // 解析想要人数
+ function parseWantCount(item) {
+ return item.want_count || 0;
+ }
+
+ // 执行排序
+ switch (sortType) {
+ case 'want_desc':
+ dataToSort.sort((a, b) => parseWantCount(b) - parseWantCount(a));
+ break;
+ case 'want_asc':
+ dataToSort.sort((a, b) => parseWantCount(a) - parseWantCount(b));
+ break;
+ case 'price_asc':
+ dataToSort.sort((a, b) => parsePrice(a.price) - parsePrice(b.price));
+ break;
+ case 'price_desc':
+ dataToSort.sort((a, b) => parsePrice(b.price) - parsePrice(a.price));
+ break;
+ default:
+ // 默认排序:按想要人数降序
+ dataToSort.sort((a, b) => parseWantCount(b) - parseWantCount(a));
+ break;
+ }
+
+ // 更新数据并重新显示
+ searchResultsData = dataToSort;
+ currentSearchPage = 1;
+ displaySearchResults();
+}
+
+// 显示搜索结果
+function displaySearchResults() {
+ if (searchResultsData.length === 0) {
+ showNoSearchResults();
+ return;
+ }
+
+ const startIndex = (currentSearchPage - 1) * searchPageSize;
+ const endIndex = startIndex + searchPageSize;
+ const pageItems = searchResultsData.slice(startIndex, endIndex);
+
+ const container = document.getElementById('searchResultsContainer');
+ container.innerHTML = '';
+
+ pageItems.forEach(item => {
+ const itemCard = createItemCard(item);
+ container.appendChild(itemCard);
+ });
+
+ updateSearchPagination();
+ document.getElementById('searchResults').style.display = 'block';
+}
+
+// 创建商品卡片
+function createItemCard(item) {
+ console.log('createItemCard被调用,item数据:', item);
+ console.log('item的所有字段:', Object.keys(item));
+
+ const col = document.createElement('div');
+ col.className = 'col-md-6 col-lg-4 col-xl-3 mb-4';
+
+ // 修复字段映射:使用main_image而不是image_url
+ const imageUrl = item.main_image || item.image_url || 'https://via.placeholder.com/200x200?text=图片加载失败';
+ const wantCount = item.want_count || 0;
+
+ console.log('处理后的数据:', {
+ title: item.title,
+ price: item.price,
+ seller_name: item.seller_name,
+ imageUrl: imageUrl,
+ wantCount: wantCount,
+ url: item.item_url || item.url
+ });
+
+ col.innerHTML = `
+
+
})
+
+
+ ${escapeHtml(item.title.length > 50 ? item.title.substring(0, 50) + '...' : item.title)}
+
+
+ ${escapeHtml(item.price)}
+
+
+
+ ${escapeHtml(item.seller_name)}
+
+ ${wantCount > 0 ? `
+
+ ${wantCount}人想要
+
` : ''}
+
+
+
+ `;
+
+ return col;
+}
+
+// 更新搜索统计
+function updateSearchStats(data) {
+ document.getElementById('totalItemsFound').textContent = searchResultsData.length;
+ document.getElementById('totalPagesSearched').textContent = data.total_pages || 0;
+ document.getElementById('currentDisplayPage').textContent = currentSearchPage;
+ document.getElementById('totalDisplayPages').textContent = totalSearchPages;
+ document.getElementById('searchResultStats').style.display = 'block';
+}
+
+// 更新搜索分页
+function updateSearchPagination() {
+ const paginationContainer = document.getElementById('searchPagination');
+ paginationContainer.innerHTML = '';
+
+ if (totalSearchPages <= 1) return;
+
+ const pagination = document.createElement('nav');
+ pagination.innerHTML = `
+
+ `;
+
+ paginationContainer.appendChild(pagination);
+}
+
+// 生成搜索分页页码
+function generateSearchPageNumbers() {
+ let pageNumbers = '';
+ const maxVisiblePages = 5;
+ let startPage = Math.max(1, currentSearchPage - Math.floor(maxVisiblePages / 2));
+ let endPage = Math.min(totalSearchPages, startPage + maxVisiblePages - 1);
+
+ if (endPage - startPage + 1 < maxVisiblePages) {
+ startPage = Math.max(1, endPage - maxVisiblePages + 1);
+ }
+
+ for (let i = startPage; i <= endPage; i++) {
+ pageNumbers += `
+
+ ${i}
+
+ `;
+ }
+
+ return pageNumbers;
+}
+
+// 切换搜索页面
+function changeSearchPage(page) {
+ if (page < 1 || page > totalSearchPages || page === currentSearchPage) return;
+
+ currentSearchPage = page;
+ displaySearchResults();
+ updateSearchStats({ total_pages: document.getElementById('totalPagesSearched').textContent });
+}
+
+// 显示无搜索结果
+function showNoSearchResults() {
+ document.getElementById('noSearchResults').style.display = 'block';
+ document.getElementById('searchResults').style.display = 'none';
+ document.getElementById('searchResultStats').style.display = 'none';
+}
+
+// 导出搜索结果
+function exportSearchResults() {
+ if (searchResultsData.length === 0) {
+ showToast('没有可导出的搜索结果', 'warning');
+ return;
+ }
+
+ try {
+ // 准备导出数据
+ const exportData = searchResultsData.map(item => ({
+ '商品标题': item.title,
+ '价格': item.price,
+ '卖家': item.seller_name,
+ '想要人数': item.want_count || 0,
+ '商品链接': item.url,
+ '图片链接': item.image_url
+ }));
+
+ // 转换为CSV格式
+ const headers = Object.keys(exportData[0]);
+ const csvContent = [
+ headers.join(','),
+ ...exportData.map(row => headers.map(header => `"${row[header] || ''}"`).join(','))
+ ].join('\n');
+
+ // 创建下载链接
+ const blob = new Blob(['\ufeff' + csvContent], { type: 'text/csv;charset=utf-8;' });
+ const link = document.createElement('a');
+ const url = URL.createObjectURL(blob);
+ link.setAttribute('href', url);
+ link.setAttribute('download', `商品搜索结果_${new Date().toISOString().slice(0, 10)}.csv`);
+ link.style.visibility = 'hidden';
+ document.body.appendChild(link);
+ link.click();
+ document.body.removeChild(link);
+
+ showToast('搜索结果导出成功', 'success');
+ } catch (error) {
+ console.error('导出搜索结果失败:', error);
+ showToast('导出搜索结果失败', 'danger');
+ }
+}
diff --git a/static/lib/bootstrap-icons/bootstrap-icons.css b/static/lib/bootstrap-icons/bootstrap-icons.css
new file mode 100644
index 0000000..efd644a
--- /dev/null
+++ b/static/lib/bootstrap-icons/bootstrap-icons.css
@@ -0,0 +1,2078 @@
+/*!
+ * Bootstrap Icons v1.10.5 (https://icons.getbootstrap.com/)
+ * Copyright 2019-2023 The Bootstrap Authors
+ * Licensed under MIT (https://github.com/twbs/icons/blob/main/LICENSE)
+ */
+
+@font-face {
+ font-display: block;
+ font-family: "bootstrap-icons";
+ src: url("./fonts/bootstrap-icons.woff2?1bb88866b4085542c8ed5fb61b9393dd") format("woff2"),
+url("./fonts/bootstrap-icons.woff?1bb88866b4085542c8ed5fb61b9393dd") format("woff");
+}
+
+.bi::before,
+[class^="bi-"]::before,
+[class*=" bi-"]::before {
+ display: inline-block;
+ font-family: bootstrap-icons !important;
+ font-style: normal;
+ font-weight: normal !important;
+ font-variant: normal;
+ text-transform: none;
+ line-height: 1;
+ vertical-align: -.125em;
+ -webkit-font-smoothing: antialiased;
+ -moz-osx-font-smoothing: grayscale;
+}
+
+.bi-123::before { content: "\f67f"; }
+.bi-alarm-fill::before { content: "\f101"; }
+.bi-alarm::before { content: "\f102"; }
+.bi-align-bottom::before { content: "\f103"; }
+.bi-align-center::before { content: "\f104"; }
+.bi-align-end::before { content: "\f105"; }
+.bi-align-middle::before { content: "\f106"; }
+.bi-align-start::before { content: "\f107"; }
+.bi-align-top::before { content: "\f108"; }
+.bi-alt::before { content: "\f109"; }
+.bi-app-indicator::before { content: "\f10a"; }
+.bi-app::before { content: "\f10b"; }
+.bi-archive-fill::before { content: "\f10c"; }
+.bi-archive::before { content: "\f10d"; }
+.bi-arrow-90deg-down::before { content: "\f10e"; }
+.bi-arrow-90deg-left::before { content: "\f10f"; }
+.bi-arrow-90deg-right::before { content: "\f110"; }
+.bi-arrow-90deg-up::before { content: "\f111"; }
+.bi-arrow-bar-down::before { content: "\f112"; }
+.bi-arrow-bar-left::before { content: "\f113"; }
+.bi-arrow-bar-right::before { content: "\f114"; }
+.bi-arrow-bar-up::before { content: "\f115"; }
+.bi-arrow-clockwise::before { content: "\f116"; }
+.bi-arrow-counterclockwise::before { content: "\f117"; }
+.bi-arrow-down-circle-fill::before { content: "\f118"; }
+.bi-arrow-down-circle::before { content: "\f119"; }
+.bi-arrow-down-left-circle-fill::before { content: "\f11a"; }
+.bi-arrow-down-left-circle::before { content: "\f11b"; }
+.bi-arrow-down-left-square-fill::before { content: "\f11c"; }
+.bi-arrow-down-left-square::before { content: "\f11d"; }
+.bi-arrow-down-left::before { content: "\f11e"; }
+.bi-arrow-down-right-circle-fill::before { content: "\f11f"; }
+.bi-arrow-down-right-circle::before { content: "\f120"; }
+.bi-arrow-down-right-square-fill::before { content: "\f121"; }
+.bi-arrow-down-right-square::before { content: "\f122"; }
+.bi-arrow-down-right::before { content: "\f123"; }
+.bi-arrow-down-short::before { content: "\f124"; }
+.bi-arrow-down-square-fill::before { content: "\f125"; }
+.bi-arrow-down-square::before { content: "\f126"; }
+.bi-arrow-down-up::before { content: "\f127"; }
+.bi-arrow-down::before { content: "\f128"; }
+.bi-arrow-left-circle-fill::before { content: "\f129"; }
+.bi-arrow-left-circle::before { content: "\f12a"; }
+.bi-arrow-left-right::before { content: "\f12b"; }
+.bi-arrow-left-short::before { content: "\f12c"; }
+.bi-arrow-left-square-fill::before { content: "\f12d"; }
+.bi-arrow-left-square::before { content: "\f12e"; }
+.bi-arrow-left::before { content: "\f12f"; }
+.bi-arrow-repeat::before { content: "\f130"; }
+.bi-arrow-return-left::before { content: "\f131"; }
+.bi-arrow-return-right::before { content: "\f132"; }
+.bi-arrow-right-circle-fill::before { content: "\f133"; }
+.bi-arrow-right-circle::before { content: "\f134"; }
+.bi-arrow-right-short::before { content: "\f135"; }
+.bi-arrow-right-square-fill::before { content: "\f136"; }
+.bi-arrow-right-square::before { content: "\f137"; }
+.bi-arrow-right::before { content: "\f138"; }
+.bi-arrow-up-circle-fill::before { content: "\f139"; }
+.bi-arrow-up-circle::before { content: "\f13a"; }
+.bi-arrow-up-left-circle-fill::before { content: "\f13b"; }
+.bi-arrow-up-left-circle::before { content: "\f13c"; }
+.bi-arrow-up-left-square-fill::before { content: "\f13d"; }
+.bi-arrow-up-left-square::before { content: "\f13e"; }
+.bi-arrow-up-left::before { content: "\f13f"; }
+.bi-arrow-up-right-circle-fill::before { content: "\f140"; }
+.bi-arrow-up-right-circle::before { content: "\f141"; }
+.bi-arrow-up-right-square-fill::before { content: "\f142"; }
+.bi-arrow-up-right-square::before { content: "\f143"; }
+.bi-arrow-up-right::before { content: "\f144"; }
+.bi-arrow-up-short::before { content: "\f145"; }
+.bi-arrow-up-square-fill::before { content: "\f146"; }
+.bi-arrow-up-square::before { content: "\f147"; }
+.bi-arrow-up::before { content: "\f148"; }
+.bi-arrows-angle-contract::before { content: "\f149"; }
+.bi-arrows-angle-expand::before { content: "\f14a"; }
+.bi-arrows-collapse::before { content: "\f14b"; }
+.bi-arrows-expand::before { content: "\f14c"; }
+.bi-arrows-fullscreen::before { content: "\f14d"; }
+.bi-arrows-move::before { content: "\f14e"; }
+.bi-aspect-ratio-fill::before { content: "\f14f"; }
+.bi-aspect-ratio::before { content: "\f150"; }
+.bi-asterisk::before { content: "\f151"; }
+.bi-at::before { content: "\f152"; }
+.bi-award-fill::before { content: "\f153"; }
+.bi-award::before { content: "\f154"; }
+.bi-back::before { content: "\f155"; }
+.bi-backspace-fill::before { content: "\f156"; }
+.bi-backspace-reverse-fill::before { content: "\f157"; }
+.bi-backspace-reverse::before { content: "\f158"; }
+.bi-backspace::before { content: "\f159"; }
+.bi-badge-3d-fill::before { content: "\f15a"; }
+.bi-badge-3d::before { content: "\f15b"; }
+.bi-badge-4k-fill::before { content: "\f15c"; }
+.bi-badge-4k::before { content: "\f15d"; }
+.bi-badge-8k-fill::before { content: "\f15e"; }
+.bi-badge-8k::before { content: "\f15f"; }
+.bi-badge-ad-fill::before { content: "\f160"; }
+.bi-badge-ad::before { content: "\f161"; }
+.bi-badge-ar-fill::before { content: "\f162"; }
+.bi-badge-ar::before { content: "\f163"; }
+.bi-badge-cc-fill::before { content: "\f164"; }
+.bi-badge-cc::before { content: "\f165"; }
+.bi-badge-hd-fill::before { content: "\f166"; }
+.bi-badge-hd::before { content: "\f167"; }
+.bi-badge-tm-fill::before { content: "\f168"; }
+.bi-badge-tm::before { content: "\f169"; }
+.bi-badge-vo-fill::before { content: "\f16a"; }
+.bi-badge-vo::before { content: "\f16b"; }
+.bi-badge-vr-fill::before { content: "\f16c"; }
+.bi-badge-vr::before { content: "\f16d"; }
+.bi-badge-wc-fill::before { content: "\f16e"; }
+.bi-badge-wc::before { content: "\f16f"; }
+.bi-bag-check-fill::before { content: "\f170"; }
+.bi-bag-check::before { content: "\f171"; }
+.bi-bag-dash-fill::before { content: "\f172"; }
+.bi-bag-dash::before { content: "\f173"; }
+.bi-bag-fill::before { content: "\f174"; }
+.bi-bag-plus-fill::before { content: "\f175"; }
+.bi-bag-plus::before { content: "\f176"; }
+.bi-bag-x-fill::before { content: "\f177"; }
+.bi-bag-x::before { content: "\f178"; }
+.bi-bag::before { content: "\f179"; }
+.bi-bar-chart-fill::before { content: "\f17a"; }
+.bi-bar-chart-line-fill::before { content: "\f17b"; }
+.bi-bar-chart-line::before { content: "\f17c"; }
+.bi-bar-chart-steps::before { content: "\f17d"; }
+.bi-bar-chart::before { content: "\f17e"; }
+.bi-basket-fill::before { content: "\f17f"; }
+.bi-basket::before { content: "\f180"; }
+.bi-basket2-fill::before { content: "\f181"; }
+.bi-basket2::before { content: "\f182"; }
+.bi-basket3-fill::before { content: "\f183"; }
+.bi-basket3::before { content: "\f184"; }
+.bi-battery-charging::before { content: "\f185"; }
+.bi-battery-full::before { content: "\f186"; }
+.bi-battery-half::before { content: "\f187"; }
+.bi-battery::before { content: "\f188"; }
+.bi-bell-fill::before { content: "\f189"; }
+.bi-bell::before { content: "\f18a"; }
+.bi-bezier::before { content: "\f18b"; }
+.bi-bezier2::before { content: "\f18c"; }
+.bi-bicycle::before { content: "\f18d"; }
+.bi-binoculars-fill::before { content: "\f18e"; }
+.bi-binoculars::before { content: "\f18f"; }
+.bi-blockquote-left::before { content: "\f190"; }
+.bi-blockquote-right::before { content: "\f191"; }
+.bi-book-fill::before { content: "\f192"; }
+.bi-book-half::before { content: "\f193"; }
+.bi-book::before { content: "\f194"; }
+.bi-bookmark-check-fill::before { content: "\f195"; }
+.bi-bookmark-check::before { content: "\f196"; }
+.bi-bookmark-dash-fill::before { content: "\f197"; }
+.bi-bookmark-dash::before { content: "\f198"; }
+.bi-bookmark-fill::before { content: "\f199"; }
+.bi-bookmark-heart-fill::before { content: "\f19a"; }
+.bi-bookmark-heart::before { content: "\f19b"; }
+.bi-bookmark-plus-fill::before { content: "\f19c"; }
+.bi-bookmark-plus::before { content: "\f19d"; }
+.bi-bookmark-star-fill::before { content: "\f19e"; }
+.bi-bookmark-star::before { content: "\f19f"; }
+.bi-bookmark-x-fill::before { content: "\f1a0"; }
+.bi-bookmark-x::before { content: "\f1a1"; }
+.bi-bookmark::before { content: "\f1a2"; }
+.bi-bookmarks-fill::before { content: "\f1a3"; }
+.bi-bookmarks::before { content: "\f1a4"; }
+.bi-bookshelf::before { content: "\f1a5"; }
+.bi-bootstrap-fill::before { content: "\f1a6"; }
+.bi-bootstrap-reboot::before { content: "\f1a7"; }
+.bi-bootstrap::before { content: "\f1a8"; }
+.bi-border-all::before { content: "\f1a9"; }
+.bi-border-bottom::before { content: "\f1aa"; }
+.bi-border-center::before { content: "\f1ab"; }
+.bi-border-inner::before { content: "\f1ac"; }
+.bi-border-left::before { content: "\f1ad"; }
+.bi-border-middle::before { content: "\f1ae"; }
+.bi-border-outer::before { content: "\f1af"; }
+.bi-border-right::before { content: "\f1b0"; }
+.bi-border-style::before { content: "\f1b1"; }
+.bi-border-top::before { content: "\f1b2"; }
+.bi-border-width::before { content: "\f1b3"; }
+.bi-border::before { content: "\f1b4"; }
+.bi-bounding-box-circles::before { content: "\f1b5"; }
+.bi-bounding-box::before { content: "\f1b6"; }
+.bi-box-arrow-down-left::before { content: "\f1b7"; }
+.bi-box-arrow-down-right::before { content: "\f1b8"; }
+.bi-box-arrow-down::before { content: "\f1b9"; }
+.bi-box-arrow-in-down-left::before { content: "\f1ba"; }
+.bi-box-arrow-in-down-right::before { content: "\f1bb"; }
+.bi-box-arrow-in-down::before { content: "\f1bc"; }
+.bi-box-arrow-in-left::before { content: "\f1bd"; }
+.bi-box-arrow-in-right::before { content: "\f1be"; }
+.bi-box-arrow-in-up-left::before { content: "\f1bf"; }
+.bi-box-arrow-in-up-right::before { content: "\f1c0"; }
+.bi-box-arrow-in-up::before { content: "\f1c1"; }
+.bi-box-arrow-left::before { content: "\f1c2"; }
+.bi-box-arrow-right::before { content: "\f1c3"; }
+.bi-box-arrow-up-left::before { content: "\f1c4"; }
+.bi-box-arrow-up-right::before { content: "\f1c5"; }
+.bi-box-arrow-up::before { content: "\f1c6"; }
+.bi-box-seam::before { content: "\f1c7"; }
+.bi-box::before { content: "\f1c8"; }
+.bi-braces::before { content: "\f1c9"; }
+.bi-bricks::before { content: "\f1ca"; }
+.bi-briefcase-fill::before { content: "\f1cb"; }
+.bi-briefcase::before { content: "\f1cc"; }
+.bi-brightness-alt-high-fill::before { content: "\f1cd"; }
+.bi-brightness-alt-high::before { content: "\f1ce"; }
+.bi-brightness-alt-low-fill::before { content: "\f1cf"; }
+.bi-brightness-alt-low::before { content: "\f1d0"; }
+.bi-brightness-high-fill::before { content: "\f1d1"; }
+.bi-brightness-high::before { content: "\f1d2"; }
+.bi-brightness-low-fill::before { content: "\f1d3"; }
+.bi-brightness-low::before { content: "\f1d4"; }
+.bi-broadcast-pin::before { content: "\f1d5"; }
+.bi-broadcast::before { content: "\f1d6"; }
+.bi-brush-fill::before { content: "\f1d7"; }
+.bi-brush::before { content: "\f1d8"; }
+.bi-bucket-fill::before { content: "\f1d9"; }
+.bi-bucket::before { content: "\f1da"; }
+.bi-bug-fill::before { content: "\f1db"; }
+.bi-bug::before { content: "\f1dc"; }
+.bi-building::before { content: "\f1dd"; }
+.bi-bullseye::before { content: "\f1de"; }
+.bi-calculator-fill::before { content: "\f1df"; }
+.bi-calculator::before { content: "\f1e0"; }
+.bi-calendar-check-fill::before { content: "\f1e1"; }
+.bi-calendar-check::before { content: "\f1e2"; }
+.bi-calendar-date-fill::before { content: "\f1e3"; }
+.bi-calendar-date::before { content: "\f1e4"; }
+.bi-calendar-day-fill::before { content: "\f1e5"; }
+.bi-calendar-day::before { content: "\f1e6"; }
+.bi-calendar-event-fill::before { content: "\f1e7"; }
+.bi-calendar-event::before { content: "\f1e8"; }
+.bi-calendar-fill::before { content: "\f1e9"; }
+.bi-calendar-minus-fill::before { content: "\f1ea"; }
+.bi-calendar-minus::before { content: "\f1eb"; }
+.bi-calendar-month-fill::before { content: "\f1ec"; }
+.bi-calendar-month::before { content: "\f1ed"; }
+.bi-calendar-plus-fill::before { content: "\f1ee"; }
+.bi-calendar-plus::before { content: "\f1ef"; }
+.bi-calendar-range-fill::before { content: "\f1f0"; }
+.bi-calendar-range::before { content: "\f1f1"; }
+.bi-calendar-week-fill::before { content: "\f1f2"; }
+.bi-calendar-week::before { content: "\f1f3"; }
+.bi-calendar-x-fill::before { content: "\f1f4"; }
+.bi-calendar-x::before { content: "\f1f5"; }
+.bi-calendar::before { content: "\f1f6"; }
+.bi-calendar2-check-fill::before { content: "\f1f7"; }
+.bi-calendar2-check::before { content: "\f1f8"; }
+.bi-calendar2-date-fill::before { content: "\f1f9"; }
+.bi-calendar2-date::before { content: "\f1fa"; }
+.bi-calendar2-day-fill::before { content: "\f1fb"; }
+.bi-calendar2-day::before { content: "\f1fc"; }
+.bi-calendar2-event-fill::before { content: "\f1fd"; }
+.bi-calendar2-event::before { content: "\f1fe"; }
+.bi-calendar2-fill::before { content: "\f1ff"; }
+.bi-calendar2-minus-fill::before { content: "\f200"; }
+.bi-calendar2-minus::before { content: "\f201"; }
+.bi-calendar2-month-fill::before { content: "\f202"; }
+.bi-calendar2-month::before { content: "\f203"; }
+.bi-calendar2-plus-fill::before { content: "\f204"; }
+.bi-calendar2-plus::before { content: "\f205"; }
+.bi-calendar2-range-fill::before { content: "\f206"; }
+.bi-calendar2-range::before { content: "\f207"; }
+.bi-calendar2-week-fill::before { content: "\f208"; }
+.bi-calendar2-week::before { content: "\f209"; }
+.bi-calendar2-x-fill::before { content: "\f20a"; }
+.bi-calendar2-x::before { content: "\f20b"; }
+.bi-calendar2::before { content: "\f20c"; }
+.bi-calendar3-event-fill::before { content: "\f20d"; }
+.bi-calendar3-event::before { content: "\f20e"; }
+.bi-calendar3-fill::before { content: "\f20f"; }
+.bi-calendar3-range-fill::before { content: "\f210"; }
+.bi-calendar3-range::before { content: "\f211"; }
+.bi-calendar3-week-fill::before { content: "\f212"; }
+.bi-calendar3-week::before { content: "\f213"; }
+.bi-calendar3::before { content: "\f214"; }
+.bi-calendar4-event::before { content: "\f215"; }
+.bi-calendar4-range::before { content: "\f216"; }
+.bi-calendar4-week::before { content: "\f217"; }
+.bi-calendar4::before { content: "\f218"; }
+.bi-camera-fill::before { content: "\f219"; }
+.bi-camera-reels-fill::before { content: "\f21a"; }
+.bi-camera-reels::before { content: "\f21b"; }
+.bi-camera-video-fill::before { content: "\f21c"; }
+.bi-camera-video-off-fill::before { content: "\f21d"; }
+.bi-camera-video-off::before { content: "\f21e"; }
+.bi-camera-video::before { content: "\f21f"; }
+.bi-camera::before { content: "\f220"; }
+.bi-camera2::before { content: "\f221"; }
+.bi-capslock-fill::before { content: "\f222"; }
+.bi-capslock::before { content: "\f223"; }
+.bi-card-checklist::before { content: "\f224"; }
+.bi-card-heading::before { content: "\f225"; }
+.bi-card-image::before { content: "\f226"; }
+.bi-card-list::before { content: "\f227"; }
+.bi-card-text::before { content: "\f228"; }
+.bi-caret-down-fill::before { content: "\f229"; }
+.bi-caret-down-square-fill::before { content: "\f22a"; }
+.bi-caret-down-square::before { content: "\f22b"; }
+.bi-caret-down::before { content: "\f22c"; }
+.bi-caret-left-fill::before { content: "\f22d"; }
+.bi-caret-left-square-fill::before { content: "\f22e"; }
+.bi-caret-left-square::before { content: "\f22f"; }
+.bi-caret-left::before { content: "\f230"; }
+.bi-caret-right-fill::before { content: "\f231"; }
+.bi-caret-right-square-fill::before { content: "\f232"; }
+.bi-caret-right-square::before { content: "\f233"; }
+.bi-caret-right::before { content: "\f234"; }
+.bi-caret-up-fill::before { content: "\f235"; }
+.bi-caret-up-square-fill::before { content: "\f236"; }
+.bi-caret-up-square::before { content: "\f237"; }
+.bi-caret-up::before { content: "\f238"; }
+.bi-cart-check-fill::before { content: "\f239"; }
+.bi-cart-check::before { content: "\f23a"; }
+.bi-cart-dash-fill::before { content: "\f23b"; }
+.bi-cart-dash::before { content: "\f23c"; }
+.bi-cart-fill::before { content: "\f23d"; }
+.bi-cart-plus-fill::before { content: "\f23e"; }
+.bi-cart-plus::before { content: "\f23f"; }
+.bi-cart-x-fill::before { content: "\f240"; }
+.bi-cart-x::before { content: "\f241"; }
+.bi-cart::before { content: "\f242"; }
+.bi-cart2::before { content: "\f243"; }
+.bi-cart3::before { content: "\f244"; }
+.bi-cart4::before { content: "\f245"; }
+.bi-cash-stack::before { content: "\f246"; }
+.bi-cash::before { content: "\f247"; }
+.bi-cast::before { content: "\f248"; }
+.bi-chat-dots-fill::before { content: "\f249"; }
+.bi-chat-dots::before { content: "\f24a"; }
+.bi-chat-fill::before { content: "\f24b"; }
+.bi-chat-left-dots-fill::before { content: "\f24c"; }
+.bi-chat-left-dots::before { content: "\f24d"; }
+.bi-chat-left-fill::before { content: "\f24e"; }
+.bi-chat-left-quote-fill::before { content: "\f24f"; }
+.bi-chat-left-quote::before { content: "\f250"; }
+.bi-chat-left-text-fill::before { content: "\f251"; }
+.bi-chat-left-text::before { content: "\f252"; }
+.bi-chat-left::before { content: "\f253"; }
+.bi-chat-quote-fill::before { content: "\f254"; }
+.bi-chat-quote::before { content: "\f255"; }
+.bi-chat-right-dots-fill::before { content: "\f256"; }
+.bi-chat-right-dots::before { content: "\f257"; }
+.bi-chat-right-fill::before { content: "\f258"; }
+.bi-chat-right-quote-fill::before { content: "\f259"; }
+.bi-chat-right-quote::before { content: "\f25a"; }
+.bi-chat-right-text-fill::before { content: "\f25b"; }
+.bi-chat-right-text::before { content: "\f25c"; }
+.bi-chat-right::before { content: "\f25d"; }
+.bi-chat-square-dots-fill::before { content: "\f25e"; }
+.bi-chat-square-dots::before { content: "\f25f"; }
+.bi-chat-square-fill::before { content: "\f260"; }
+.bi-chat-square-quote-fill::before { content: "\f261"; }
+.bi-chat-square-quote::before { content: "\f262"; }
+.bi-chat-square-text-fill::before { content: "\f263"; }
+.bi-chat-square-text::before { content: "\f264"; }
+.bi-chat-square::before { content: "\f265"; }
+.bi-chat-text-fill::before { content: "\f266"; }
+.bi-chat-text::before { content: "\f267"; }
+.bi-chat::before { content: "\f268"; }
+.bi-check-all::before { content: "\f269"; }
+.bi-check-circle-fill::before { content: "\f26a"; }
+.bi-check-circle::before { content: "\f26b"; }
+.bi-check-square-fill::before { content: "\f26c"; }
+.bi-check-square::before { content: "\f26d"; }
+.bi-check::before { content: "\f26e"; }
+.bi-check2-all::before { content: "\f26f"; }
+.bi-check2-circle::before { content: "\f270"; }
+.bi-check2-square::before { content: "\f271"; }
+.bi-check2::before { content: "\f272"; }
+.bi-chevron-bar-contract::before { content: "\f273"; }
+.bi-chevron-bar-down::before { content: "\f274"; }
+.bi-chevron-bar-expand::before { content: "\f275"; }
+.bi-chevron-bar-left::before { content: "\f276"; }
+.bi-chevron-bar-right::before { content: "\f277"; }
+.bi-chevron-bar-up::before { content: "\f278"; }
+.bi-chevron-compact-down::before { content: "\f279"; }
+.bi-chevron-compact-left::before { content: "\f27a"; }
+.bi-chevron-compact-right::before { content: "\f27b"; }
+.bi-chevron-compact-up::before { content: "\f27c"; }
+.bi-chevron-contract::before { content: "\f27d"; }
+.bi-chevron-double-down::before { content: "\f27e"; }
+.bi-chevron-double-left::before { content: "\f27f"; }
+.bi-chevron-double-right::before { content: "\f280"; }
+.bi-chevron-double-up::before { content: "\f281"; }
+.bi-chevron-down::before { content: "\f282"; }
+.bi-chevron-expand::before { content: "\f283"; }
+.bi-chevron-left::before { content: "\f284"; }
+.bi-chevron-right::before { content: "\f285"; }
+.bi-chevron-up::before { content: "\f286"; }
+.bi-circle-fill::before { content: "\f287"; }
+.bi-circle-half::before { content: "\f288"; }
+.bi-circle-square::before { content: "\f289"; }
+.bi-circle::before { content: "\f28a"; }
+.bi-clipboard-check::before { content: "\f28b"; }
+.bi-clipboard-data::before { content: "\f28c"; }
+.bi-clipboard-minus::before { content: "\f28d"; }
+.bi-clipboard-plus::before { content: "\f28e"; }
+.bi-clipboard-x::before { content: "\f28f"; }
+.bi-clipboard::before { content: "\f290"; }
+.bi-clock-fill::before { content: "\f291"; }
+.bi-clock-history::before { content: "\f292"; }
+.bi-clock::before { content: "\f293"; }
+.bi-cloud-arrow-down-fill::before { content: "\f294"; }
+.bi-cloud-arrow-down::before { content: "\f295"; }
+.bi-cloud-arrow-up-fill::before { content: "\f296"; }
+.bi-cloud-arrow-up::before { content: "\f297"; }
+.bi-cloud-check-fill::before { content: "\f298"; }
+.bi-cloud-check::before { content: "\f299"; }
+.bi-cloud-download-fill::before { content: "\f29a"; }
+.bi-cloud-download::before { content: "\f29b"; }
+.bi-cloud-drizzle-fill::before { content: "\f29c"; }
+.bi-cloud-drizzle::before { content: "\f29d"; }
+.bi-cloud-fill::before { content: "\f29e"; }
+.bi-cloud-fog-fill::before { content: "\f29f"; }
+.bi-cloud-fog::before { content: "\f2a0"; }
+.bi-cloud-fog2-fill::before { content: "\f2a1"; }
+.bi-cloud-fog2::before { content: "\f2a2"; }
+.bi-cloud-hail-fill::before { content: "\f2a3"; }
+.bi-cloud-hail::before { content: "\f2a4"; }
+.bi-cloud-haze-fill::before { content: "\f2a6"; }
+.bi-cloud-haze::before { content: "\f2a7"; }
+.bi-cloud-haze2-fill::before { content: "\f2a8"; }
+.bi-cloud-lightning-fill::before { content: "\f2a9"; }
+.bi-cloud-lightning-rain-fill::before { content: "\f2aa"; }
+.bi-cloud-lightning-rain::before { content: "\f2ab"; }
+.bi-cloud-lightning::before { content: "\f2ac"; }
+.bi-cloud-minus-fill::before { content: "\f2ad"; }
+.bi-cloud-minus::before { content: "\f2ae"; }
+.bi-cloud-moon-fill::before { content: "\f2af"; }
+.bi-cloud-moon::before { content: "\f2b0"; }
+.bi-cloud-plus-fill::before { content: "\f2b1"; }
+.bi-cloud-plus::before { content: "\f2b2"; }
+.bi-cloud-rain-fill::before { content: "\f2b3"; }
+.bi-cloud-rain-heavy-fill::before { content: "\f2b4"; }
+.bi-cloud-rain-heavy::before { content: "\f2b5"; }
+.bi-cloud-rain::before { content: "\f2b6"; }
+.bi-cloud-slash-fill::before { content: "\f2b7"; }
+.bi-cloud-slash::before { content: "\f2b8"; }
+.bi-cloud-sleet-fill::before { content: "\f2b9"; }
+.bi-cloud-sleet::before { content: "\f2ba"; }
+.bi-cloud-snow-fill::before { content: "\f2bb"; }
+.bi-cloud-snow::before { content: "\f2bc"; }
+.bi-cloud-sun-fill::before { content: "\f2bd"; }
+.bi-cloud-sun::before { content: "\f2be"; }
+.bi-cloud-upload-fill::before { content: "\f2bf"; }
+.bi-cloud-upload::before { content: "\f2c0"; }
+.bi-cloud::before { content: "\f2c1"; }
+.bi-clouds-fill::before { content: "\f2c2"; }
+.bi-clouds::before { content: "\f2c3"; }
+.bi-cloudy-fill::before { content: "\f2c4"; }
+.bi-cloudy::before { content: "\f2c5"; }
+.bi-code-slash::before { content: "\f2c6"; }
+.bi-code-square::before { content: "\f2c7"; }
+.bi-code::before { content: "\f2c8"; }
+.bi-collection-fill::before { content: "\f2c9"; }
+.bi-collection-play-fill::before { content: "\f2ca"; }
+.bi-collection-play::before { content: "\f2cb"; }
+.bi-collection::before { content: "\f2cc"; }
+.bi-columns-gap::before { content: "\f2cd"; }
+.bi-columns::before { content: "\f2ce"; }
+.bi-command::before { content: "\f2cf"; }
+.bi-compass-fill::before { content: "\f2d0"; }
+.bi-compass::before { content: "\f2d1"; }
+.bi-cone-striped::before { content: "\f2d2"; }
+.bi-cone::before { content: "\f2d3"; }
+.bi-controller::before { content: "\f2d4"; }
+.bi-cpu-fill::before { content: "\f2d5"; }
+.bi-cpu::before { content: "\f2d6"; }
+.bi-credit-card-2-back-fill::before { content: "\f2d7"; }
+.bi-credit-card-2-back::before { content: "\f2d8"; }
+.bi-credit-card-2-front-fill::before { content: "\f2d9"; }
+.bi-credit-card-2-front::before { content: "\f2da"; }
+.bi-credit-card-fill::before { content: "\f2db"; }
+.bi-credit-card::before { content: "\f2dc"; }
+.bi-crop::before { content: "\f2dd"; }
+.bi-cup-fill::before { content: "\f2de"; }
+.bi-cup-straw::before { content: "\f2df"; }
+.bi-cup::before { content: "\f2e0"; }
+.bi-cursor-fill::before { content: "\f2e1"; }
+.bi-cursor-text::before { content: "\f2e2"; }
+.bi-cursor::before { content: "\f2e3"; }
+.bi-dash-circle-dotted::before { content: "\f2e4"; }
+.bi-dash-circle-fill::before { content: "\f2e5"; }
+.bi-dash-circle::before { content: "\f2e6"; }
+.bi-dash-square-dotted::before { content: "\f2e7"; }
+.bi-dash-square-fill::before { content: "\f2e8"; }
+.bi-dash-square::before { content: "\f2e9"; }
+.bi-dash::before { content: "\f2ea"; }
+.bi-diagram-2-fill::before { content: "\f2eb"; }
+.bi-diagram-2::before { content: "\f2ec"; }
+.bi-diagram-3-fill::before { content: "\f2ed"; }
+.bi-diagram-3::before { content: "\f2ee"; }
+.bi-diamond-fill::before { content: "\f2ef"; }
+.bi-diamond-half::before { content: "\f2f0"; }
+.bi-diamond::before { content: "\f2f1"; }
+.bi-dice-1-fill::before { content: "\f2f2"; }
+.bi-dice-1::before { content: "\f2f3"; }
+.bi-dice-2-fill::before { content: "\f2f4"; }
+.bi-dice-2::before { content: "\f2f5"; }
+.bi-dice-3-fill::before { content: "\f2f6"; }
+.bi-dice-3::before { content: "\f2f7"; }
+.bi-dice-4-fill::before { content: "\f2f8"; }
+.bi-dice-4::before { content: "\f2f9"; }
+.bi-dice-5-fill::before { content: "\f2fa"; }
+.bi-dice-5::before { content: "\f2fb"; }
+.bi-dice-6-fill::before { content: "\f2fc"; }
+.bi-dice-6::before { content: "\f2fd"; }
+.bi-disc-fill::before { content: "\f2fe"; }
+.bi-disc::before { content: "\f2ff"; }
+.bi-discord::before { content: "\f300"; }
+.bi-display-fill::before { content: "\f301"; }
+.bi-display::before { content: "\f302"; }
+.bi-distribute-horizontal::before { content: "\f303"; }
+.bi-distribute-vertical::before { content: "\f304"; }
+.bi-door-closed-fill::before { content: "\f305"; }
+.bi-door-closed::before { content: "\f306"; }
+.bi-door-open-fill::before { content: "\f307"; }
+.bi-door-open::before { content: "\f308"; }
+.bi-dot::before { content: "\f309"; }
+.bi-download::before { content: "\f30a"; }
+.bi-droplet-fill::before { content: "\f30b"; }
+.bi-droplet-half::before { content: "\f30c"; }
+.bi-droplet::before { content: "\f30d"; }
+.bi-earbuds::before { content: "\f30e"; }
+.bi-easel-fill::before { content: "\f30f"; }
+.bi-easel::before { content: "\f310"; }
+.bi-egg-fill::before { content: "\f311"; }
+.bi-egg-fried::before { content: "\f312"; }
+.bi-egg::before { content: "\f313"; }
+.bi-eject-fill::before { content: "\f314"; }
+.bi-eject::before { content: "\f315"; }
+.bi-emoji-angry-fill::before { content: "\f316"; }
+.bi-emoji-angry::before { content: "\f317"; }
+.bi-emoji-dizzy-fill::before { content: "\f318"; }
+.bi-emoji-dizzy::before { content: "\f319"; }
+.bi-emoji-expressionless-fill::before { content: "\f31a"; }
+.bi-emoji-expressionless::before { content: "\f31b"; }
+.bi-emoji-frown-fill::before { content: "\f31c"; }
+.bi-emoji-frown::before { content: "\f31d"; }
+.bi-emoji-heart-eyes-fill::before { content: "\f31e"; }
+.bi-emoji-heart-eyes::before { content: "\f31f"; }
+.bi-emoji-laughing-fill::before { content: "\f320"; }
+.bi-emoji-laughing::before { content: "\f321"; }
+.bi-emoji-neutral-fill::before { content: "\f322"; }
+.bi-emoji-neutral::before { content: "\f323"; }
+.bi-emoji-smile-fill::before { content: "\f324"; }
+.bi-emoji-smile-upside-down-fill::before { content: "\f325"; }
+.bi-emoji-smile-upside-down::before { content: "\f326"; }
+.bi-emoji-smile::before { content: "\f327"; }
+.bi-emoji-sunglasses-fill::before { content: "\f328"; }
+.bi-emoji-sunglasses::before { content: "\f329"; }
+.bi-emoji-wink-fill::before { content: "\f32a"; }
+.bi-emoji-wink::before { content: "\f32b"; }
+.bi-envelope-fill::before { content: "\f32c"; }
+.bi-envelope-open-fill::before { content: "\f32d"; }
+.bi-envelope-open::before { content: "\f32e"; }
+.bi-envelope::before { content: "\f32f"; }
+.bi-eraser-fill::before { content: "\f330"; }
+.bi-eraser::before { content: "\f331"; }
+.bi-exclamation-circle-fill::before { content: "\f332"; }
+.bi-exclamation-circle::before { content: "\f333"; }
+.bi-exclamation-diamond-fill::before { content: "\f334"; }
+.bi-exclamation-diamond::before { content: "\f335"; }
+.bi-exclamation-octagon-fill::before { content: "\f336"; }
+.bi-exclamation-octagon::before { content: "\f337"; }
+.bi-exclamation-square-fill::before { content: "\f338"; }
+.bi-exclamation-square::before { content: "\f339"; }
+.bi-exclamation-triangle-fill::before { content: "\f33a"; }
+.bi-exclamation-triangle::before { content: "\f33b"; }
+.bi-exclamation::before { content: "\f33c"; }
+.bi-exclude::before { content: "\f33d"; }
+.bi-eye-fill::before { content: "\f33e"; }
+.bi-eye-slash-fill::before { content: "\f33f"; }
+.bi-eye-slash::before { content: "\f340"; }
+.bi-eye::before { content: "\f341"; }
+.bi-eyedropper::before { content: "\f342"; }
+.bi-eyeglasses::before { content: "\f343"; }
+.bi-facebook::before { content: "\f344"; }
+.bi-file-arrow-down-fill::before { content: "\f345"; }
+.bi-file-arrow-down::before { content: "\f346"; }
+.bi-file-arrow-up-fill::before { content: "\f347"; }
+.bi-file-arrow-up::before { content: "\f348"; }
+.bi-file-bar-graph-fill::before { content: "\f349"; }
+.bi-file-bar-graph::before { content: "\f34a"; }
+.bi-file-binary-fill::before { content: "\f34b"; }
+.bi-file-binary::before { content: "\f34c"; }
+.bi-file-break-fill::before { content: "\f34d"; }
+.bi-file-break::before { content: "\f34e"; }
+.bi-file-check-fill::before { content: "\f34f"; }
+.bi-file-check::before { content: "\f350"; }
+.bi-file-code-fill::before { content: "\f351"; }
+.bi-file-code::before { content: "\f352"; }
+.bi-file-diff-fill::before { content: "\f353"; }
+.bi-file-diff::before { content: "\f354"; }
+.bi-file-earmark-arrow-down-fill::before { content: "\f355"; }
+.bi-file-earmark-arrow-down::before { content: "\f356"; }
+.bi-file-earmark-arrow-up-fill::before { content: "\f357"; }
+.bi-file-earmark-arrow-up::before { content: "\f358"; }
+.bi-file-earmark-bar-graph-fill::before { content: "\f359"; }
+.bi-file-earmark-bar-graph::before { content: "\f35a"; }
+.bi-file-earmark-binary-fill::before { content: "\f35b"; }
+.bi-file-earmark-binary::before { content: "\f35c"; }
+.bi-file-earmark-break-fill::before { content: "\f35d"; }
+.bi-file-earmark-break::before { content: "\f35e"; }
+.bi-file-earmark-check-fill::before { content: "\f35f"; }
+.bi-file-earmark-check::before { content: "\f360"; }
+.bi-file-earmark-code-fill::before { content: "\f361"; }
+.bi-file-earmark-code::before { content: "\f362"; }
+.bi-file-earmark-diff-fill::before { content: "\f363"; }
+.bi-file-earmark-diff::before { content: "\f364"; }
+.bi-file-earmark-easel-fill::before { content: "\f365"; }
+.bi-file-earmark-easel::before { content: "\f366"; }
+.bi-file-earmark-excel-fill::before { content: "\f367"; }
+.bi-file-earmark-excel::before { content: "\f368"; }
+.bi-file-earmark-fill::before { content: "\f369"; }
+.bi-file-earmark-font-fill::before { content: "\f36a"; }
+.bi-file-earmark-font::before { content: "\f36b"; }
+.bi-file-earmark-image-fill::before { content: "\f36c"; }
+.bi-file-earmark-image::before { content: "\f36d"; }
+.bi-file-earmark-lock-fill::before { content: "\f36e"; }
+.bi-file-earmark-lock::before { content: "\f36f"; }
+.bi-file-earmark-lock2-fill::before { content: "\f370"; }
+.bi-file-earmark-lock2::before { content: "\f371"; }
+.bi-file-earmark-medical-fill::before { content: "\f372"; }
+.bi-file-earmark-medical::before { content: "\f373"; }
+.bi-file-earmark-minus-fill::before { content: "\f374"; }
+.bi-file-earmark-minus::before { content: "\f375"; }
+.bi-file-earmark-music-fill::before { content: "\f376"; }
+.bi-file-earmark-music::before { content: "\f377"; }
+.bi-file-earmark-person-fill::before { content: "\f378"; }
+.bi-file-earmark-person::before { content: "\f379"; }
+.bi-file-earmark-play-fill::before { content: "\f37a"; }
+.bi-file-earmark-play::before { content: "\f37b"; }
+.bi-file-earmark-plus-fill::before { content: "\f37c"; }
+.bi-file-earmark-plus::before { content: "\f37d"; }
+.bi-file-earmark-post-fill::before { content: "\f37e"; }
+.bi-file-earmark-post::before { content: "\f37f"; }
+.bi-file-earmark-ppt-fill::before { content: "\f380"; }
+.bi-file-earmark-ppt::before { content: "\f381"; }
+.bi-file-earmark-richtext-fill::before { content: "\f382"; }
+.bi-file-earmark-richtext::before { content: "\f383"; }
+.bi-file-earmark-ruled-fill::before { content: "\f384"; }
+.bi-file-earmark-ruled::before { content: "\f385"; }
+.bi-file-earmark-slides-fill::before { content: "\f386"; }
+.bi-file-earmark-slides::before { content: "\f387"; }
+.bi-file-earmark-spreadsheet-fill::before { content: "\f388"; }
+.bi-file-earmark-spreadsheet::before { content: "\f389"; }
+.bi-file-earmark-text-fill::before { content: "\f38a"; }
+.bi-file-earmark-text::before { content: "\f38b"; }
+.bi-file-earmark-word-fill::before { content: "\f38c"; }
+.bi-file-earmark-word::before { content: "\f38d"; }
+.bi-file-earmark-x-fill::before { content: "\f38e"; }
+.bi-file-earmark-x::before { content: "\f38f"; }
+.bi-file-earmark-zip-fill::before { content: "\f390"; }
+.bi-file-earmark-zip::before { content: "\f391"; }
+.bi-file-earmark::before { content: "\f392"; }
+.bi-file-easel-fill::before { content: "\f393"; }
+.bi-file-easel::before { content: "\f394"; }
+.bi-file-excel-fill::before { content: "\f395"; }
+.bi-file-excel::before { content: "\f396"; }
+.bi-file-fill::before { content: "\f397"; }
+.bi-file-font-fill::before { content: "\f398"; }
+.bi-file-font::before { content: "\f399"; }
+.bi-file-image-fill::before { content: "\f39a"; }
+.bi-file-image::before { content: "\f39b"; }
+.bi-file-lock-fill::before { content: "\f39c"; }
+.bi-file-lock::before { content: "\f39d"; }
+.bi-file-lock2-fill::before { content: "\f39e"; }
+.bi-file-lock2::before { content: "\f39f"; }
+.bi-file-medical-fill::before { content: "\f3a0"; }
+.bi-file-medical::before { content: "\f3a1"; }
+.bi-file-minus-fill::before { content: "\f3a2"; }
+.bi-file-minus::before { content: "\f3a3"; }
+.bi-file-music-fill::before { content: "\f3a4"; }
+.bi-file-music::before { content: "\f3a5"; }
+.bi-file-person-fill::before { content: "\f3a6"; }
+.bi-file-person::before { content: "\f3a7"; }
+.bi-file-play-fill::before { content: "\f3a8"; }
+.bi-file-play::before { content: "\f3a9"; }
+.bi-file-plus-fill::before { content: "\f3aa"; }
+.bi-file-plus::before { content: "\f3ab"; }
+.bi-file-post-fill::before { content: "\f3ac"; }
+.bi-file-post::before { content: "\f3ad"; }
+.bi-file-ppt-fill::before { content: "\f3ae"; }
+.bi-file-ppt::before { content: "\f3af"; }
+.bi-file-richtext-fill::before { content: "\f3b0"; }
+.bi-file-richtext::before { content: "\f3b1"; }
+.bi-file-ruled-fill::before { content: "\f3b2"; }
+.bi-file-ruled::before { content: "\f3b3"; }
+.bi-file-slides-fill::before { content: "\f3b4"; }
+.bi-file-slides::before { content: "\f3b5"; }
+.bi-file-spreadsheet-fill::before { content: "\f3b6"; }
+.bi-file-spreadsheet::before { content: "\f3b7"; }
+.bi-file-text-fill::before { content: "\f3b8"; }
+.bi-file-text::before { content: "\f3b9"; }
+.bi-file-word-fill::before { content: "\f3ba"; }
+.bi-file-word::before { content: "\f3bb"; }
+.bi-file-x-fill::before { content: "\f3bc"; }
+.bi-file-x::before { content: "\f3bd"; }
+.bi-file-zip-fill::before { content: "\f3be"; }
+.bi-file-zip::before { content: "\f3bf"; }
+.bi-file::before { content: "\f3c0"; }
+.bi-files-alt::before { content: "\f3c1"; }
+.bi-files::before { content: "\f3c2"; }
+.bi-film::before { content: "\f3c3"; }
+.bi-filter-circle-fill::before { content: "\f3c4"; }
+.bi-filter-circle::before { content: "\f3c5"; }
+.bi-filter-left::before { content: "\f3c6"; }
+.bi-filter-right::before { content: "\f3c7"; }
+.bi-filter-square-fill::before { content: "\f3c8"; }
+.bi-filter-square::before { content: "\f3c9"; }
+.bi-filter::before { content: "\f3ca"; }
+.bi-flag-fill::before { content: "\f3cb"; }
+.bi-flag::before { content: "\f3cc"; }
+.bi-flower1::before { content: "\f3cd"; }
+.bi-flower2::before { content: "\f3ce"; }
+.bi-flower3::before { content: "\f3cf"; }
+.bi-folder-check::before { content: "\f3d0"; }
+.bi-folder-fill::before { content: "\f3d1"; }
+.bi-folder-minus::before { content: "\f3d2"; }
+.bi-folder-plus::before { content: "\f3d3"; }
+.bi-folder-symlink-fill::before { content: "\f3d4"; }
+.bi-folder-symlink::before { content: "\f3d5"; }
+.bi-folder-x::before { content: "\f3d6"; }
+.bi-folder::before { content: "\f3d7"; }
+.bi-folder2-open::before { content: "\f3d8"; }
+.bi-folder2::before { content: "\f3d9"; }
+.bi-fonts::before { content: "\f3da"; }
+.bi-forward-fill::before { content: "\f3db"; }
+.bi-forward::before { content: "\f3dc"; }
+.bi-front::before { content: "\f3dd"; }
+.bi-fullscreen-exit::before { content: "\f3de"; }
+.bi-fullscreen::before { content: "\f3df"; }
+.bi-funnel-fill::before { content: "\f3e0"; }
+.bi-funnel::before { content: "\f3e1"; }
+.bi-gear-fill::before { content: "\f3e2"; }
+.bi-gear-wide-connected::before { content: "\f3e3"; }
+.bi-gear-wide::before { content: "\f3e4"; }
+.bi-gear::before { content: "\f3e5"; }
+.bi-gem::before { content: "\f3e6"; }
+.bi-geo-alt-fill::before { content: "\f3e7"; }
+.bi-geo-alt::before { content: "\f3e8"; }
+.bi-geo-fill::before { content: "\f3e9"; }
+.bi-geo::before { content: "\f3ea"; }
+.bi-gift-fill::before { content: "\f3eb"; }
+.bi-gift::before { content: "\f3ec"; }
+.bi-github::before { content: "\f3ed"; }
+.bi-globe::before { content: "\f3ee"; }
+.bi-globe2::before { content: "\f3ef"; }
+.bi-google::before { content: "\f3f0"; }
+.bi-graph-down::before { content: "\f3f1"; }
+.bi-graph-up::before { content: "\f3f2"; }
+.bi-grid-1x2-fill::before { content: "\f3f3"; }
+.bi-grid-1x2::before { content: "\f3f4"; }
+.bi-grid-3x2-gap-fill::before { content: "\f3f5"; }
+.bi-grid-3x2-gap::before { content: "\f3f6"; }
+.bi-grid-3x2::before { content: "\f3f7"; }
+.bi-grid-3x3-gap-fill::before { content: "\f3f8"; }
+.bi-grid-3x3-gap::before { content: "\f3f9"; }
+.bi-grid-3x3::before { content: "\f3fa"; }
+.bi-grid-fill::before { content: "\f3fb"; }
+.bi-grid::before { content: "\f3fc"; }
+.bi-grip-horizontal::before { content: "\f3fd"; }
+.bi-grip-vertical::before { content: "\f3fe"; }
+.bi-hammer::before { content: "\f3ff"; }
+.bi-hand-index-fill::before { content: "\f400"; }
+.bi-hand-index-thumb-fill::before { content: "\f401"; }
+.bi-hand-index-thumb::before { content: "\f402"; }
+.bi-hand-index::before { content: "\f403"; }
+.bi-hand-thumbs-down-fill::before { content: "\f404"; }
+.bi-hand-thumbs-down::before { content: "\f405"; }
+.bi-hand-thumbs-up-fill::before { content: "\f406"; }
+.bi-hand-thumbs-up::before { content: "\f407"; }
+.bi-handbag-fill::before { content: "\f408"; }
+.bi-handbag::before { content: "\f409"; }
+.bi-hash::before { content: "\f40a"; }
+.bi-hdd-fill::before { content: "\f40b"; }
+.bi-hdd-network-fill::before { content: "\f40c"; }
+.bi-hdd-network::before { content: "\f40d"; }
+.bi-hdd-rack-fill::before { content: "\f40e"; }
+.bi-hdd-rack::before { content: "\f40f"; }
+.bi-hdd-stack-fill::before { content: "\f410"; }
+.bi-hdd-stack::before { content: "\f411"; }
+.bi-hdd::before { content: "\f412"; }
+.bi-headphones::before { content: "\f413"; }
+.bi-headset::before { content: "\f414"; }
+.bi-heart-fill::before { content: "\f415"; }
+.bi-heart-half::before { content: "\f416"; }
+.bi-heart::before { content: "\f417"; }
+.bi-heptagon-fill::before { content: "\f418"; }
+.bi-heptagon-half::before { content: "\f419"; }
+.bi-heptagon::before { content: "\f41a"; }
+.bi-hexagon-fill::before { content: "\f41b"; }
+.bi-hexagon-half::before { content: "\f41c"; }
+.bi-hexagon::before { content: "\f41d"; }
+.bi-hourglass-bottom::before { content: "\f41e"; }
+.bi-hourglass-split::before { content: "\f41f"; }
+.bi-hourglass-top::before { content: "\f420"; }
+.bi-hourglass::before { content: "\f421"; }
+.bi-house-door-fill::before { content: "\f422"; }
+.bi-house-door::before { content: "\f423"; }
+.bi-house-fill::before { content: "\f424"; }
+.bi-house::before { content: "\f425"; }
+.bi-hr::before { content: "\f426"; }
+.bi-hurricane::before { content: "\f427"; }
+.bi-image-alt::before { content: "\f428"; }
+.bi-image-fill::before { content: "\f429"; }
+.bi-image::before { content: "\f42a"; }
+.bi-images::before { content: "\f42b"; }
+.bi-inbox-fill::before { content: "\f42c"; }
+.bi-inbox::before { content: "\f42d"; }
+.bi-inboxes-fill::before { content: "\f42e"; }
+.bi-inboxes::before { content: "\f42f"; }
+.bi-info-circle-fill::before { content: "\f430"; }
+.bi-info-circle::before { content: "\f431"; }
+.bi-info-square-fill::before { content: "\f432"; }
+.bi-info-square::before { content: "\f433"; }
+.bi-info::before { content: "\f434"; }
+.bi-input-cursor-text::before { content: "\f435"; }
+.bi-input-cursor::before { content: "\f436"; }
+.bi-instagram::before { content: "\f437"; }
+.bi-intersect::before { content: "\f438"; }
+.bi-journal-album::before { content: "\f439"; }
+.bi-journal-arrow-down::before { content: "\f43a"; }
+.bi-journal-arrow-up::before { content: "\f43b"; }
+.bi-journal-bookmark-fill::before { content: "\f43c"; }
+.bi-journal-bookmark::before { content: "\f43d"; }
+.bi-journal-check::before { content: "\f43e"; }
+.bi-journal-code::before { content: "\f43f"; }
+.bi-journal-medical::before { content: "\f440"; }
+.bi-journal-minus::before { content: "\f441"; }
+.bi-journal-plus::before { content: "\f442"; }
+.bi-journal-richtext::before { content: "\f443"; }
+.bi-journal-text::before { content: "\f444"; }
+.bi-journal-x::before { content: "\f445"; }
+.bi-journal::before { content: "\f446"; }
+.bi-journals::before { content: "\f447"; }
+.bi-joystick::before { content: "\f448"; }
+.bi-justify-left::before { content: "\f449"; }
+.bi-justify-right::before { content: "\f44a"; }
+.bi-justify::before { content: "\f44b"; }
+.bi-kanban-fill::before { content: "\f44c"; }
+.bi-kanban::before { content: "\f44d"; }
+.bi-key-fill::before { content: "\f44e"; }
+.bi-key::before { content: "\f44f"; }
+.bi-keyboard-fill::before { content: "\f450"; }
+.bi-keyboard::before { content: "\f451"; }
+.bi-ladder::before { content: "\f452"; }
+.bi-lamp-fill::before { content: "\f453"; }
+.bi-lamp::before { content: "\f454"; }
+.bi-laptop-fill::before { content: "\f455"; }
+.bi-laptop::before { content: "\f456"; }
+.bi-layer-backward::before { content: "\f457"; }
+.bi-layer-forward::before { content: "\f458"; }
+.bi-layers-fill::before { content: "\f459"; }
+.bi-layers-half::before { content: "\f45a"; }
+.bi-layers::before { content: "\f45b"; }
+.bi-layout-sidebar-inset-reverse::before { content: "\f45c"; }
+.bi-layout-sidebar-inset::before { content: "\f45d"; }
+.bi-layout-sidebar-reverse::before { content: "\f45e"; }
+.bi-layout-sidebar::before { content: "\f45f"; }
+.bi-layout-split::before { content: "\f460"; }
+.bi-layout-text-sidebar-reverse::before { content: "\f461"; }
+.bi-layout-text-sidebar::before { content: "\f462"; }
+.bi-layout-text-window-reverse::before { content: "\f463"; }
+.bi-layout-text-window::before { content: "\f464"; }
+.bi-layout-three-columns::before { content: "\f465"; }
+.bi-layout-wtf::before { content: "\f466"; }
+.bi-life-preserver::before { content: "\f467"; }
+.bi-lightbulb-fill::before { content: "\f468"; }
+.bi-lightbulb-off-fill::before { content: "\f469"; }
+.bi-lightbulb-off::before { content: "\f46a"; }
+.bi-lightbulb::before { content: "\f46b"; }
+.bi-lightning-charge-fill::before { content: "\f46c"; }
+.bi-lightning-charge::before { content: "\f46d"; }
+.bi-lightning-fill::before { content: "\f46e"; }
+.bi-lightning::before { content: "\f46f"; }
+.bi-link-45deg::before { content: "\f470"; }
+.bi-link::before { content: "\f471"; }
+.bi-linkedin::before { content: "\f472"; }
+.bi-list-check::before { content: "\f473"; }
+.bi-list-nested::before { content: "\f474"; }
+.bi-list-ol::before { content: "\f475"; }
+.bi-list-stars::before { content: "\f476"; }
+.bi-list-task::before { content: "\f477"; }
+.bi-list-ul::before { content: "\f478"; }
+.bi-list::before { content: "\f479"; }
+.bi-lock-fill::before { content: "\f47a"; }
+.bi-lock::before { content: "\f47b"; }
+.bi-mailbox::before { content: "\f47c"; }
+.bi-mailbox2::before { content: "\f47d"; }
+.bi-map-fill::before { content: "\f47e"; }
+.bi-map::before { content: "\f47f"; }
+.bi-markdown-fill::before { content: "\f480"; }
+.bi-markdown::before { content: "\f481"; }
+.bi-mask::before { content: "\f482"; }
+.bi-megaphone-fill::before { content: "\f483"; }
+.bi-megaphone::before { content: "\f484"; }
+.bi-menu-app-fill::before { content: "\f485"; }
+.bi-menu-app::before { content: "\f486"; }
+.bi-menu-button-fill::before { content: "\f487"; }
+.bi-menu-button-wide-fill::before { content: "\f488"; }
+.bi-menu-button-wide::before { content: "\f489"; }
+.bi-menu-button::before { content: "\f48a"; }
+.bi-menu-down::before { content: "\f48b"; }
+.bi-menu-up::before { content: "\f48c"; }
+.bi-mic-fill::before { content: "\f48d"; }
+.bi-mic-mute-fill::before { content: "\f48e"; }
+.bi-mic-mute::before { content: "\f48f"; }
+.bi-mic::before { content: "\f490"; }
+.bi-minecart-loaded::before { content: "\f491"; }
+.bi-minecart::before { content: "\f492"; }
+.bi-moisture::before { content: "\f493"; }
+.bi-moon-fill::before { content: "\f494"; }
+.bi-moon-stars-fill::before { content: "\f495"; }
+.bi-moon-stars::before { content: "\f496"; }
+.bi-moon::before { content: "\f497"; }
+.bi-mouse-fill::before { content: "\f498"; }
+.bi-mouse::before { content: "\f499"; }
+.bi-mouse2-fill::before { content: "\f49a"; }
+.bi-mouse2::before { content: "\f49b"; }
+.bi-mouse3-fill::before { content: "\f49c"; }
+.bi-mouse3::before { content: "\f49d"; }
+.bi-music-note-beamed::before { content: "\f49e"; }
+.bi-music-note-list::before { content: "\f49f"; }
+.bi-music-note::before { content: "\f4a0"; }
+.bi-music-player-fill::before { content: "\f4a1"; }
+.bi-music-player::before { content: "\f4a2"; }
+.bi-newspaper::before { content: "\f4a3"; }
+.bi-node-minus-fill::before { content: "\f4a4"; }
+.bi-node-minus::before { content: "\f4a5"; }
+.bi-node-plus-fill::before { content: "\f4a6"; }
+.bi-node-plus::before { content: "\f4a7"; }
+.bi-nut-fill::before { content: "\f4a8"; }
+.bi-nut::before { content: "\f4a9"; }
+.bi-octagon-fill::before { content: "\f4aa"; }
+.bi-octagon-half::before { content: "\f4ab"; }
+.bi-octagon::before { content: "\f4ac"; }
+.bi-option::before { content: "\f4ad"; }
+.bi-outlet::before { content: "\f4ae"; }
+.bi-paint-bucket::before { content: "\f4af"; }
+.bi-palette-fill::before { content: "\f4b0"; }
+.bi-palette::before { content: "\f4b1"; }
+.bi-palette2::before { content: "\f4b2"; }
+.bi-paperclip::before { content: "\f4b3"; }
+.bi-paragraph::before { content: "\f4b4"; }
+.bi-patch-check-fill::before { content: "\f4b5"; }
+.bi-patch-check::before { content: "\f4b6"; }
+.bi-patch-exclamation-fill::before { content: "\f4b7"; }
+.bi-patch-exclamation::before { content: "\f4b8"; }
+.bi-patch-minus-fill::before { content: "\f4b9"; }
+.bi-patch-minus::before { content: "\f4ba"; }
+.bi-patch-plus-fill::before { content: "\f4bb"; }
+.bi-patch-plus::before { content: "\f4bc"; }
+.bi-patch-question-fill::before { content: "\f4bd"; }
+.bi-patch-question::before { content: "\f4be"; }
+.bi-pause-btn-fill::before { content: "\f4bf"; }
+.bi-pause-btn::before { content: "\f4c0"; }
+.bi-pause-circle-fill::before { content: "\f4c1"; }
+.bi-pause-circle::before { content: "\f4c2"; }
+.bi-pause-fill::before { content: "\f4c3"; }
+.bi-pause::before { content: "\f4c4"; }
+.bi-peace-fill::before { content: "\f4c5"; }
+.bi-peace::before { content: "\f4c6"; }
+.bi-pen-fill::before { content: "\f4c7"; }
+.bi-pen::before { content: "\f4c8"; }
+.bi-pencil-fill::before { content: "\f4c9"; }
+.bi-pencil-square::before { content: "\f4ca"; }
+.bi-pencil::before { content: "\f4cb"; }
+.bi-pentagon-fill::before { content: "\f4cc"; }
+.bi-pentagon-half::before { content: "\f4cd"; }
+.bi-pentagon::before { content: "\f4ce"; }
+.bi-people-fill::before { content: "\f4cf"; }
+.bi-people::before { content: "\f4d0"; }
+.bi-percent::before { content: "\f4d1"; }
+.bi-person-badge-fill::before { content: "\f4d2"; }
+.bi-person-badge::before { content: "\f4d3"; }
+.bi-person-bounding-box::before { content: "\f4d4"; }
+.bi-person-check-fill::before { content: "\f4d5"; }
+.bi-person-check::before { content: "\f4d6"; }
+.bi-person-circle::before { content: "\f4d7"; }
+.bi-person-dash-fill::before { content: "\f4d8"; }
+.bi-person-dash::before { content: "\f4d9"; }
+.bi-person-fill::before { content: "\f4da"; }
+.bi-person-lines-fill::before { content: "\f4db"; }
+.bi-person-plus-fill::before { content: "\f4dc"; }
+.bi-person-plus::before { content: "\f4dd"; }
+.bi-person-square::before { content: "\f4de"; }
+.bi-person-x-fill::before { content: "\f4df"; }
+.bi-person-x::before { content: "\f4e0"; }
+.bi-person::before { content: "\f4e1"; }
+.bi-phone-fill::before { content: "\f4e2"; }
+.bi-phone-landscape-fill::before { content: "\f4e3"; }
+.bi-phone-landscape::before { content: "\f4e4"; }
+.bi-phone-vibrate-fill::before { content: "\f4e5"; }
+.bi-phone-vibrate::before { content: "\f4e6"; }
+.bi-phone::before { content: "\f4e7"; }
+.bi-pie-chart-fill::before { content: "\f4e8"; }
+.bi-pie-chart::before { content: "\f4e9"; }
+.bi-pin-angle-fill::before { content: "\f4ea"; }
+.bi-pin-angle::before { content: "\f4eb"; }
+.bi-pin-fill::before { content: "\f4ec"; }
+.bi-pin::before { content: "\f4ed"; }
+.bi-pip-fill::before { content: "\f4ee"; }
+.bi-pip::before { content: "\f4ef"; }
+.bi-play-btn-fill::before { content: "\f4f0"; }
+.bi-play-btn::before { content: "\f4f1"; }
+.bi-play-circle-fill::before { content: "\f4f2"; }
+.bi-play-circle::before { content: "\f4f3"; }
+.bi-play-fill::before { content: "\f4f4"; }
+.bi-play::before { content: "\f4f5"; }
+.bi-plug-fill::before { content: "\f4f6"; }
+.bi-plug::before { content: "\f4f7"; }
+.bi-plus-circle-dotted::before { content: "\f4f8"; }
+.bi-plus-circle-fill::before { content: "\f4f9"; }
+.bi-plus-circle::before { content: "\f4fa"; }
+.bi-plus-square-dotted::before { content: "\f4fb"; }
+.bi-plus-square-fill::before { content: "\f4fc"; }
+.bi-plus-square::before { content: "\f4fd"; }
+.bi-plus::before { content: "\f4fe"; }
+.bi-power::before { content: "\f4ff"; }
+.bi-printer-fill::before { content: "\f500"; }
+.bi-printer::before { content: "\f501"; }
+.bi-puzzle-fill::before { content: "\f502"; }
+.bi-puzzle::before { content: "\f503"; }
+.bi-question-circle-fill::before { content: "\f504"; }
+.bi-question-circle::before { content: "\f505"; }
+.bi-question-diamond-fill::before { content: "\f506"; }
+.bi-question-diamond::before { content: "\f507"; }
+.bi-question-octagon-fill::before { content: "\f508"; }
+.bi-question-octagon::before { content: "\f509"; }
+.bi-question-square-fill::before { content: "\f50a"; }
+.bi-question-square::before { content: "\f50b"; }
+.bi-question::before { content: "\f50c"; }
+.bi-rainbow::before { content: "\f50d"; }
+.bi-receipt-cutoff::before { content: "\f50e"; }
+.bi-receipt::before { content: "\f50f"; }
+.bi-reception-0::before { content: "\f510"; }
+.bi-reception-1::before { content: "\f511"; }
+.bi-reception-2::before { content: "\f512"; }
+.bi-reception-3::before { content: "\f513"; }
+.bi-reception-4::before { content: "\f514"; }
+.bi-record-btn-fill::before { content: "\f515"; }
+.bi-record-btn::before { content: "\f516"; }
+.bi-record-circle-fill::before { content: "\f517"; }
+.bi-record-circle::before { content: "\f518"; }
+.bi-record-fill::before { content: "\f519"; }
+.bi-record::before { content: "\f51a"; }
+.bi-record2-fill::before { content: "\f51b"; }
+.bi-record2::before { content: "\f51c"; }
+.bi-reply-all-fill::before { content: "\f51d"; }
+.bi-reply-all::before { content: "\f51e"; }
+.bi-reply-fill::before { content: "\f51f"; }
+.bi-reply::before { content: "\f520"; }
+.bi-rss-fill::before { content: "\f521"; }
+.bi-rss::before { content: "\f522"; }
+.bi-rulers::before { content: "\f523"; }
+.bi-save-fill::before { content: "\f524"; }
+.bi-save::before { content: "\f525"; }
+.bi-save2-fill::before { content: "\f526"; }
+.bi-save2::before { content: "\f527"; }
+.bi-scissors::before { content: "\f528"; }
+.bi-screwdriver::before { content: "\f529"; }
+.bi-search::before { content: "\f52a"; }
+.bi-segmented-nav::before { content: "\f52b"; }
+.bi-server::before { content: "\f52c"; }
+.bi-share-fill::before { content: "\f52d"; }
+.bi-share::before { content: "\f52e"; }
+.bi-shield-check::before { content: "\f52f"; }
+.bi-shield-exclamation::before { content: "\f530"; }
+.bi-shield-fill-check::before { content: "\f531"; }
+.bi-shield-fill-exclamation::before { content: "\f532"; }
+.bi-shield-fill-minus::before { content: "\f533"; }
+.bi-shield-fill-plus::before { content: "\f534"; }
+.bi-shield-fill-x::before { content: "\f535"; }
+.bi-shield-fill::before { content: "\f536"; }
+.bi-shield-lock-fill::before { content: "\f537"; }
+.bi-shield-lock::before { content: "\f538"; }
+.bi-shield-minus::before { content: "\f539"; }
+.bi-shield-plus::before { content: "\f53a"; }
+.bi-shield-shaded::before { content: "\f53b"; }
+.bi-shield-slash-fill::before { content: "\f53c"; }
+.bi-shield-slash::before { content: "\f53d"; }
+.bi-shield-x::before { content: "\f53e"; }
+.bi-shield::before { content: "\f53f"; }
+.bi-shift-fill::before { content: "\f540"; }
+.bi-shift::before { content: "\f541"; }
+.bi-shop-window::before { content: "\f542"; }
+.bi-shop::before { content: "\f543"; }
+.bi-shuffle::before { content: "\f544"; }
+.bi-signpost-2-fill::before { content: "\f545"; }
+.bi-signpost-2::before { content: "\f546"; }
+.bi-signpost-fill::before { content: "\f547"; }
+.bi-signpost-split-fill::before { content: "\f548"; }
+.bi-signpost-split::before { content: "\f549"; }
+.bi-signpost::before { content: "\f54a"; }
+.bi-sim-fill::before { content: "\f54b"; }
+.bi-sim::before { content: "\f54c"; }
+.bi-skip-backward-btn-fill::before { content: "\f54d"; }
+.bi-skip-backward-btn::before { content: "\f54e"; }
+.bi-skip-backward-circle-fill::before { content: "\f54f"; }
+.bi-skip-backward-circle::before { content: "\f550"; }
+.bi-skip-backward-fill::before { content: "\f551"; }
+.bi-skip-backward::before { content: "\f552"; }
+.bi-skip-end-btn-fill::before { content: "\f553"; }
+.bi-skip-end-btn::before { content: "\f554"; }
+.bi-skip-end-circle-fill::before { content: "\f555"; }
+.bi-skip-end-circle::before { content: "\f556"; }
+.bi-skip-end-fill::before { content: "\f557"; }
+.bi-skip-end::before { content: "\f558"; }
+.bi-skip-forward-btn-fill::before { content: "\f559"; }
+.bi-skip-forward-btn::before { content: "\f55a"; }
+.bi-skip-forward-circle-fill::before { content: "\f55b"; }
+.bi-skip-forward-circle::before { content: "\f55c"; }
+.bi-skip-forward-fill::before { content: "\f55d"; }
+.bi-skip-forward::before { content: "\f55e"; }
+.bi-skip-start-btn-fill::before { content: "\f55f"; }
+.bi-skip-start-btn::before { content: "\f560"; }
+.bi-skip-start-circle-fill::before { content: "\f561"; }
+.bi-skip-start-circle::before { content: "\f562"; }
+.bi-skip-start-fill::before { content: "\f563"; }
+.bi-skip-start::before { content: "\f564"; }
+.bi-slack::before { content: "\f565"; }
+.bi-slash-circle-fill::before { content: "\f566"; }
+.bi-slash-circle::before { content: "\f567"; }
+.bi-slash-square-fill::before { content: "\f568"; }
+.bi-slash-square::before { content: "\f569"; }
+.bi-slash::before { content: "\f56a"; }
+.bi-sliders::before { content: "\f56b"; }
+.bi-smartwatch::before { content: "\f56c"; }
+.bi-snow::before { content: "\f56d"; }
+.bi-snow2::before { content: "\f56e"; }
+.bi-snow3::before { content: "\f56f"; }
+.bi-sort-alpha-down-alt::before { content: "\f570"; }
+.bi-sort-alpha-down::before { content: "\f571"; }
+.bi-sort-alpha-up-alt::before { content: "\f572"; }
+.bi-sort-alpha-up::before { content: "\f573"; }
+.bi-sort-down-alt::before { content: "\f574"; }
+.bi-sort-down::before { content: "\f575"; }
+.bi-sort-numeric-down-alt::before { content: "\f576"; }
+.bi-sort-numeric-down::before { content: "\f577"; }
+.bi-sort-numeric-up-alt::before { content: "\f578"; }
+.bi-sort-numeric-up::before { content: "\f579"; }
+.bi-sort-up-alt::before { content: "\f57a"; }
+.bi-sort-up::before { content: "\f57b"; }
+.bi-soundwave::before { content: "\f57c"; }
+.bi-speaker-fill::before { content: "\f57d"; }
+.bi-speaker::before { content: "\f57e"; }
+.bi-speedometer::before { content: "\f57f"; }
+.bi-speedometer2::before { content: "\f580"; }
+.bi-spellcheck::before { content: "\f581"; }
+.bi-square-fill::before { content: "\f582"; }
+.bi-square-half::before { content: "\f583"; }
+.bi-square::before { content: "\f584"; }
+.bi-stack::before { content: "\f585"; }
+.bi-star-fill::before { content: "\f586"; }
+.bi-star-half::before { content: "\f587"; }
+.bi-star::before { content: "\f588"; }
+.bi-stars::before { content: "\f589"; }
+.bi-stickies-fill::before { content: "\f58a"; }
+.bi-stickies::before { content: "\f58b"; }
+.bi-sticky-fill::before { content: "\f58c"; }
+.bi-sticky::before { content: "\f58d"; }
+.bi-stop-btn-fill::before { content: "\f58e"; }
+.bi-stop-btn::before { content: "\f58f"; }
+.bi-stop-circle-fill::before { content: "\f590"; }
+.bi-stop-circle::before { content: "\f591"; }
+.bi-stop-fill::before { content: "\f592"; }
+.bi-stop::before { content: "\f593"; }
+.bi-stoplights-fill::before { content: "\f594"; }
+.bi-stoplights::before { content: "\f595"; }
+.bi-stopwatch-fill::before { content: "\f596"; }
+.bi-stopwatch::before { content: "\f597"; }
+.bi-subtract::before { content: "\f598"; }
+.bi-suit-club-fill::before { content: "\f599"; }
+.bi-suit-club::before { content: "\f59a"; }
+.bi-suit-diamond-fill::before { content: "\f59b"; }
+.bi-suit-diamond::before { content: "\f59c"; }
+.bi-suit-heart-fill::before { content: "\f59d"; }
+.bi-suit-heart::before { content: "\f59e"; }
+.bi-suit-spade-fill::before { content: "\f59f"; }
+.bi-suit-spade::before { content: "\f5a0"; }
+.bi-sun-fill::before { content: "\f5a1"; }
+.bi-sun::before { content: "\f5a2"; }
+.bi-sunglasses::before { content: "\f5a3"; }
+.bi-sunrise-fill::before { content: "\f5a4"; }
+.bi-sunrise::before { content: "\f5a5"; }
+.bi-sunset-fill::before { content: "\f5a6"; }
+.bi-sunset::before { content: "\f5a7"; }
+.bi-symmetry-horizontal::before { content: "\f5a8"; }
+.bi-symmetry-vertical::before { content: "\f5a9"; }
+.bi-table::before { content: "\f5aa"; }
+.bi-tablet-fill::before { content: "\f5ab"; }
+.bi-tablet-landscape-fill::before { content: "\f5ac"; }
+.bi-tablet-landscape::before { content: "\f5ad"; }
+.bi-tablet::before { content: "\f5ae"; }
+.bi-tag-fill::before { content: "\f5af"; }
+.bi-tag::before { content: "\f5b0"; }
+.bi-tags-fill::before { content: "\f5b1"; }
+.bi-tags::before { content: "\f5b2"; }
+.bi-telegram::before { content: "\f5b3"; }
+.bi-telephone-fill::before { content: "\f5b4"; }
+.bi-telephone-forward-fill::before { content: "\f5b5"; }
+.bi-telephone-forward::before { content: "\f5b6"; }
+.bi-telephone-inbound-fill::before { content: "\f5b7"; }
+.bi-telephone-inbound::before { content: "\f5b8"; }
+.bi-telephone-minus-fill::before { content: "\f5b9"; }
+.bi-telephone-minus::before { content: "\f5ba"; }
+.bi-telephone-outbound-fill::before { content: "\f5bb"; }
+.bi-telephone-outbound::before { content: "\f5bc"; }
+.bi-telephone-plus-fill::before { content: "\f5bd"; }
+.bi-telephone-plus::before { content: "\f5be"; }
+.bi-telephone-x-fill::before { content: "\f5bf"; }
+.bi-telephone-x::before { content: "\f5c0"; }
+.bi-telephone::before { content: "\f5c1"; }
+.bi-terminal-fill::before { content: "\f5c2"; }
+.bi-terminal::before { content: "\f5c3"; }
+.bi-text-center::before { content: "\f5c4"; }
+.bi-text-indent-left::before { content: "\f5c5"; }
+.bi-text-indent-right::before { content: "\f5c6"; }
+.bi-text-left::before { content: "\f5c7"; }
+.bi-text-paragraph::before { content: "\f5c8"; }
+.bi-text-right::before { content: "\f5c9"; }
+.bi-textarea-resize::before { content: "\f5ca"; }
+.bi-textarea-t::before { content: "\f5cb"; }
+.bi-textarea::before { content: "\f5cc"; }
+.bi-thermometer-half::before { content: "\f5cd"; }
+.bi-thermometer-high::before { content: "\f5ce"; }
+.bi-thermometer-low::before { content: "\f5cf"; }
+.bi-thermometer-snow::before { content: "\f5d0"; }
+.bi-thermometer-sun::before { content: "\f5d1"; }
+.bi-thermometer::before { content: "\f5d2"; }
+.bi-three-dots-vertical::before { content: "\f5d3"; }
+.bi-three-dots::before { content: "\f5d4"; }
+.bi-toggle-off::before { content: "\f5d5"; }
+.bi-toggle-on::before { content: "\f5d6"; }
+.bi-toggle2-off::before { content: "\f5d7"; }
+.bi-toggle2-on::before { content: "\f5d8"; }
+.bi-toggles::before { content: "\f5d9"; }
+.bi-toggles2::before { content: "\f5da"; }
+.bi-tools::before { content: "\f5db"; }
+.bi-tornado::before { content: "\f5dc"; }
+.bi-trash-fill::before { content: "\f5dd"; }
+.bi-trash::before { content: "\f5de"; }
+.bi-trash2-fill::before { content: "\f5df"; }
+.bi-trash2::before { content: "\f5e0"; }
+.bi-tree-fill::before { content: "\f5e1"; }
+.bi-tree::before { content: "\f5e2"; }
+.bi-triangle-fill::before { content: "\f5e3"; }
+.bi-triangle-half::before { content: "\f5e4"; }
+.bi-triangle::before { content: "\f5e5"; }
+.bi-trophy-fill::before { content: "\f5e6"; }
+.bi-trophy::before { content: "\f5e7"; }
+.bi-tropical-storm::before { content: "\f5e8"; }
+.bi-truck-flatbed::before { content: "\f5e9"; }
+.bi-truck::before { content: "\f5ea"; }
+.bi-tsunami::before { content: "\f5eb"; }
+.bi-tv-fill::before { content: "\f5ec"; }
+.bi-tv::before { content: "\f5ed"; }
+.bi-twitch::before { content: "\f5ee"; }
+.bi-twitter::before { content: "\f5ef"; }
+.bi-type-bold::before { content: "\f5f0"; }
+.bi-type-h1::before { content: "\f5f1"; }
+.bi-type-h2::before { content: "\f5f2"; }
+.bi-type-h3::before { content: "\f5f3"; }
+.bi-type-italic::before { content: "\f5f4"; }
+.bi-type-strikethrough::before { content: "\f5f5"; }
+.bi-type-underline::before { content: "\f5f6"; }
+.bi-type::before { content: "\f5f7"; }
+.bi-ui-checks-grid::before { content: "\f5f8"; }
+.bi-ui-checks::before { content: "\f5f9"; }
+.bi-ui-radios-grid::before { content: "\f5fa"; }
+.bi-ui-radios::before { content: "\f5fb"; }
+.bi-umbrella-fill::before { content: "\f5fc"; }
+.bi-umbrella::before { content: "\f5fd"; }
+.bi-union::before { content: "\f5fe"; }
+.bi-unlock-fill::before { content: "\f5ff"; }
+.bi-unlock::before { content: "\f600"; }
+.bi-upc-scan::before { content: "\f601"; }
+.bi-upc::before { content: "\f602"; }
+.bi-upload::before { content: "\f603"; }
+.bi-vector-pen::before { content: "\f604"; }
+.bi-view-list::before { content: "\f605"; }
+.bi-view-stacked::before { content: "\f606"; }
+.bi-vinyl-fill::before { content: "\f607"; }
+.bi-vinyl::before { content: "\f608"; }
+.bi-voicemail::before { content: "\f609"; }
+.bi-volume-down-fill::before { content: "\f60a"; }
+.bi-volume-down::before { content: "\f60b"; }
+.bi-volume-mute-fill::before { content: "\f60c"; }
+.bi-volume-mute::before { content: "\f60d"; }
+.bi-volume-off-fill::before { content: "\f60e"; }
+.bi-volume-off::before { content: "\f60f"; }
+.bi-volume-up-fill::before { content: "\f610"; }
+.bi-volume-up::before { content: "\f611"; }
+.bi-vr::before { content: "\f612"; }
+.bi-wallet-fill::before { content: "\f613"; }
+.bi-wallet::before { content: "\f614"; }
+.bi-wallet2::before { content: "\f615"; }
+.bi-watch::before { content: "\f616"; }
+.bi-water::before { content: "\f617"; }
+.bi-whatsapp::before { content: "\f618"; }
+.bi-wifi-1::before { content: "\f619"; }
+.bi-wifi-2::before { content: "\f61a"; }
+.bi-wifi-off::before { content: "\f61b"; }
+.bi-wifi::before { content: "\f61c"; }
+.bi-wind::before { content: "\f61d"; }
+.bi-window-dock::before { content: "\f61e"; }
+.bi-window-sidebar::before { content: "\f61f"; }
+.bi-window::before { content: "\f620"; }
+.bi-wrench::before { content: "\f621"; }
+.bi-x-circle-fill::before { content: "\f622"; }
+.bi-x-circle::before { content: "\f623"; }
+.bi-x-diamond-fill::before { content: "\f624"; }
+.bi-x-diamond::before { content: "\f625"; }
+.bi-x-octagon-fill::before { content: "\f626"; }
+.bi-x-octagon::before { content: "\f627"; }
+.bi-x-square-fill::before { content: "\f628"; }
+.bi-x-square::before { content: "\f629"; }
+.bi-x::before { content: "\f62a"; }
+.bi-youtube::before { content: "\f62b"; }
+.bi-zoom-in::before { content: "\f62c"; }
+.bi-zoom-out::before { content: "\f62d"; }
+.bi-bank::before { content: "\f62e"; }
+.bi-bank2::before { content: "\f62f"; }
+.bi-bell-slash-fill::before { content: "\f630"; }
+.bi-bell-slash::before { content: "\f631"; }
+.bi-cash-coin::before { content: "\f632"; }
+.bi-check-lg::before { content: "\f633"; }
+.bi-coin::before { content: "\f634"; }
+.bi-currency-bitcoin::before { content: "\f635"; }
+.bi-currency-dollar::before { content: "\f636"; }
+.bi-currency-euro::before { content: "\f637"; }
+.bi-currency-exchange::before { content: "\f638"; }
+.bi-currency-pound::before { content: "\f639"; }
+.bi-currency-yen::before { content: "\f63a"; }
+.bi-dash-lg::before { content: "\f63b"; }
+.bi-exclamation-lg::before { content: "\f63c"; }
+.bi-file-earmark-pdf-fill::before { content: "\f63d"; }
+.bi-file-earmark-pdf::before { content: "\f63e"; }
+.bi-file-pdf-fill::before { content: "\f63f"; }
+.bi-file-pdf::before { content: "\f640"; }
+.bi-gender-ambiguous::before { content: "\f641"; }
+.bi-gender-female::before { content: "\f642"; }
+.bi-gender-male::before { content: "\f643"; }
+.bi-gender-trans::before { content: "\f644"; }
+.bi-headset-vr::before { content: "\f645"; }
+.bi-info-lg::before { content: "\f646"; }
+.bi-mastodon::before { content: "\f647"; }
+.bi-messenger::before { content: "\f648"; }
+.bi-piggy-bank-fill::before { content: "\f649"; }
+.bi-piggy-bank::before { content: "\f64a"; }
+.bi-pin-map-fill::before { content: "\f64b"; }
+.bi-pin-map::before { content: "\f64c"; }
+.bi-plus-lg::before { content: "\f64d"; }
+.bi-question-lg::before { content: "\f64e"; }
+.bi-recycle::before { content: "\f64f"; }
+.bi-reddit::before { content: "\f650"; }
+.bi-safe-fill::before { content: "\f651"; }
+.bi-safe2-fill::before { content: "\f652"; }
+.bi-safe2::before { content: "\f653"; }
+.bi-sd-card-fill::before { content: "\f654"; }
+.bi-sd-card::before { content: "\f655"; }
+.bi-skype::before { content: "\f656"; }
+.bi-slash-lg::before { content: "\f657"; }
+.bi-translate::before { content: "\f658"; }
+.bi-x-lg::before { content: "\f659"; }
+.bi-safe::before { content: "\f65a"; }
+.bi-apple::before { content: "\f65b"; }
+.bi-microsoft::before { content: "\f65d"; }
+.bi-windows::before { content: "\f65e"; }
+.bi-behance::before { content: "\f65c"; }
+.bi-dribbble::before { content: "\f65f"; }
+.bi-line::before { content: "\f660"; }
+.bi-medium::before { content: "\f661"; }
+.bi-paypal::before { content: "\f662"; }
+.bi-pinterest::before { content: "\f663"; }
+.bi-signal::before { content: "\f664"; }
+.bi-snapchat::before { content: "\f665"; }
+.bi-spotify::before { content: "\f666"; }
+.bi-stack-overflow::before { content: "\f667"; }
+.bi-strava::before { content: "\f668"; }
+.bi-wordpress::before { content: "\f669"; }
+.bi-vimeo::before { content: "\f66a"; }
+.bi-activity::before { content: "\f66b"; }
+.bi-easel2-fill::before { content: "\f66c"; }
+.bi-easel2::before { content: "\f66d"; }
+.bi-easel3-fill::before { content: "\f66e"; }
+.bi-easel3::before { content: "\f66f"; }
+.bi-fan::before { content: "\f670"; }
+.bi-fingerprint::before { content: "\f671"; }
+.bi-graph-down-arrow::before { content: "\f672"; }
+.bi-graph-up-arrow::before { content: "\f673"; }
+.bi-hypnotize::before { content: "\f674"; }
+.bi-magic::before { content: "\f675"; }
+.bi-person-rolodex::before { content: "\f676"; }
+.bi-person-video::before { content: "\f677"; }
+.bi-person-video2::before { content: "\f678"; }
+.bi-person-video3::before { content: "\f679"; }
+.bi-person-workspace::before { content: "\f67a"; }
+.bi-radioactive::before { content: "\f67b"; }
+.bi-webcam-fill::before { content: "\f67c"; }
+.bi-webcam::before { content: "\f67d"; }
+.bi-yin-yang::before { content: "\f67e"; }
+.bi-bandaid-fill::before { content: "\f680"; }
+.bi-bandaid::before { content: "\f681"; }
+.bi-bluetooth::before { content: "\f682"; }
+.bi-body-text::before { content: "\f683"; }
+.bi-boombox::before { content: "\f684"; }
+.bi-boxes::before { content: "\f685"; }
+.bi-dpad-fill::before { content: "\f686"; }
+.bi-dpad::before { content: "\f687"; }
+.bi-ear-fill::before { content: "\f688"; }
+.bi-ear::before { content: "\f689"; }
+.bi-envelope-check-fill::before { content: "\f68b"; }
+.bi-envelope-check::before { content: "\f68c"; }
+.bi-envelope-dash-fill::before { content: "\f68e"; }
+.bi-envelope-dash::before { content: "\f68f"; }
+.bi-envelope-exclamation-fill::before { content: "\f691"; }
+.bi-envelope-exclamation::before { content: "\f692"; }
+.bi-envelope-plus-fill::before { content: "\f693"; }
+.bi-envelope-plus::before { content: "\f694"; }
+.bi-envelope-slash-fill::before { content: "\f696"; }
+.bi-envelope-slash::before { content: "\f697"; }
+.bi-envelope-x-fill::before { content: "\f699"; }
+.bi-envelope-x::before { content: "\f69a"; }
+.bi-explicit-fill::before { content: "\f69b"; }
+.bi-explicit::before { content: "\f69c"; }
+.bi-git::before { content: "\f69d"; }
+.bi-infinity::before { content: "\f69e"; }
+.bi-list-columns-reverse::before { content: "\f69f"; }
+.bi-list-columns::before { content: "\f6a0"; }
+.bi-meta::before { content: "\f6a1"; }
+.bi-nintendo-switch::before { content: "\f6a4"; }
+.bi-pc-display-horizontal::before { content: "\f6a5"; }
+.bi-pc-display::before { content: "\f6a6"; }
+.bi-pc-horizontal::before { content: "\f6a7"; }
+.bi-pc::before { content: "\f6a8"; }
+.bi-playstation::before { content: "\f6a9"; }
+.bi-plus-slash-minus::before { content: "\f6aa"; }
+.bi-projector-fill::before { content: "\f6ab"; }
+.bi-projector::before { content: "\f6ac"; }
+.bi-qr-code-scan::before { content: "\f6ad"; }
+.bi-qr-code::before { content: "\f6ae"; }
+.bi-quora::before { content: "\f6af"; }
+.bi-quote::before { content: "\f6b0"; }
+.bi-robot::before { content: "\f6b1"; }
+.bi-send-check-fill::before { content: "\f6b2"; }
+.bi-send-check::before { content: "\f6b3"; }
+.bi-send-dash-fill::before { content: "\f6b4"; }
+.bi-send-dash::before { content: "\f6b5"; }
+.bi-send-exclamation-fill::before { content: "\f6b7"; }
+.bi-send-exclamation::before { content: "\f6b8"; }
+.bi-send-fill::before { content: "\f6b9"; }
+.bi-send-plus-fill::before { content: "\f6ba"; }
+.bi-send-plus::before { content: "\f6bb"; }
+.bi-send-slash-fill::before { content: "\f6bc"; }
+.bi-send-slash::before { content: "\f6bd"; }
+.bi-send-x-fill::before { content: "\f6be"; }
+.bi-send-x::before { content: "\f6bf"; }
+.bi-send::before { content: "\f6c0"; }
+.bi-steam::before { content: "\f6c1"; }
+.bi-terminal-dash::before { content: "\f6c3"; }
+.bi-terminal-plus::before { content: "\f6c4"; }
+.bi-terminal-split::before { content: "\f6c5"; }
+.bi-ticket-detailed-fill::before { content: "\f6c6"; }
+.bi-ticket-detailed::before { content: "\f6c7"; }
+.bi-ticket-fill::before { content: "\f6c8"; }
+.bi-ticket-perforated-fill::before { content: "\f6c9"; }
+.bi-ticket-perforated::before { content: "\f6ca"; }
+.bi-ticket::before { content: "\f6cb"; }
+.bi-tiktok::before { content: "\f6cc"; }
+.bi-window-dash::before { content: "\f6cd"; }
+.bi-window-desktop::before { content: "\f6ce"; }
+.bi-window-fullscreen::before { content: "\f6cf"; }
+.bi-window-plus::before { content: "\f6d0"; }
+.bi-window-split::before { content: "\f6d1"; }
+.bi-window-stack::before { content: "\f6d2"; }
+.bi-window-x::before { content: "\f6d3"; }
+.bi-xbox::before { content: "\f6d4"; }
+.bi-ethernet::before { content: "\f6d5"; }
+.bi-hdmi-fill::before { content: "\f6d6"; }
+.bi-hdmi::before { content: "\f6d7"; }
+.bi-usb-c-fill::before { content: "\f6d8"; }
+.bi-usb-c::before { content: "\f6d9"; }
+.bi-usb-fill::before { content: "\f6da"; }
+.bi-usb-plug-fill::before { content: "\f6db"; }
+.bi-usb-plug::before { content: "\f6dc"; }
+.bi-usb-symbol::before { content: "\f6dd"; }
+.bi-usb::before { content: "\f6de"; }
+.bi-boombox-fill::before { content: "\f6df"; }
+.bi-displayport::before { content: "\f6e1"; }
+.bi-gpu-card::before { content: "\f6e2"; }
+.bi-memory::before { content: "\f6e3"; }
+.bi-modem-fill::before { content: "\f6e4"; }
+.bi-modem::before { content: "\f6e5"; }
+.bi-motherboard-fill::before { content: "\f6e6"; }
+.bi-motherboard::before { content: "\f6e7"; }
+.bi-optical-audio-fill::before { content: "\f6e8"; }
+.bi-optical-audio::before { content: "\f6e9"; }
+.bi-pci-card::before { content: "\f6ea"; }
+.bi-router-fill::before { content: "\f6eb"; }
+.bi-router::before { content: "\f6ec"; }
+.bi-thunderbolt-fill::before { content: "\f6ef"; }
+.bi-thunderbolt::before { content: "\f6f0"; }
+.bi-usb-drive-fill::before { content: "\f6f1"; }
+.bi-usb-drive::before { content: "\f6f2"; }
+.bi-usb-micro-fill::before { content: "\f6f3"; }
+.bi-usb-micro::before { content: "\f6f4"; }
+.bi-usb-mini-fill::before { content: "\f6f5"; }
+.bi-usb-mini::before { content: "\f6f6"; }
+.bi-cloud-haze2::before { content: "\f6f7"; }
+.bi-device-hdd-fill::before { content: "\f6f8"; }
+.bi-device-hdd::before { content: "\f6f9"; }
+.bi-device-ssd-fill::before { content: "\f6fa"; }
+.bi-device-ssd::before { content: "\f6fb"; }
+.bi-displayport-fill::before { content: "\f6fc"; }
+.bi-mortarboard-fill::before { content: "\f6fd"; }
+.bi-mortarboard::before { content: "\f6fe"; }
+.bi-terminal-x::before { content: "\f6ff"; }
+.bi-arrow-through-heart-fill::before { content: "\f700"; }
+.bi-arrow-through-heart::before { content: "\f701"; }
+.bi-badge-sd-fill::before { content: "\f702"; }
+.bi-badge-sd::before { content: "\f703"; }
+.bi-bag-heart-fill::before { content: "\f704"; }
+.bi-bag-heart::before { content: "\f705"; }
+.bi-balloon-fill::before { content: "\f706"; }
+.bi-balloon-heart-fill::before { content: "\f707"; }
+.bi-balloon-heart::before { content: "\f708"; }
+.bi-balloon::before { content: "\f709"; }
+.bi-box2-fill::before { content: "\f70a"; }
+.bi-box2-heart-fill::before { content: "\f70b"; }
+.bi-box2-heart::before { content: "\f70c"; }
+.bi-box2::before { content: "\f70d"; }
+.bi-braces-asterisk::before { content: "\f70e"; }
+.bi-calendar-heart-fill::before { content: "\f70f"; }
+.bi-calendar-heart::before { content: "\f710"; }
+.bi-calendar2-heart-fill::before { content: "\f711"; }
+.bi-calendar2-heart::before { content: "\f712"; }
+.bi-chat-heart-fill::before { content: "\f713"; }
+.bi-chat-heart::before { content: "\f714"; }
+.bi-chat-left-heart-fill::before { content: "\f715"; }
+.bi-chat-left-heart::before { content: "\f716"; }
+.bi-chat-right-heart-fill::before { content: "\f717"; }
+.bi-chat-right-heart::before { content: "\f718"; }
+.bi-chat-square-heart-fill::before { content: "\f719"; }
+.bi-chat-square-heart::before { content: "\f71a"; }
+.bi-clipboard-check-fill::before { content: "\f71b"; }
+.bi-clipboard-data-fill::before { content: "\f71c"; }
+.bi-clipboard-fill::before { content: "\f71d"; }
+.bi-clipboard-heart-fill::before { content: "\f71e"; }
+.bi-clipboard-heart::before { content: "\f71f"; }
+.bi-clipboard-minus-fill::before { content: "\f720"; }
+.bi-clipboard-plus-fill::before { content: "\f721"; }
+.bi-clipboard-pulse::before { content: "\f722"; }
+.bi-clipboard-x-fill::before { content: "\f723"; }
+.bi-clipboard2-check-fill::before { content: "\f724"; }
+.bi-clipboard2-check::before { content: "\f725"; }
+.bi-clipboard2-data-fill::before { content: "\f726"; }
+.bi-clipboard2-data::before { content: "\f727"; }
+.bi-clipboard2-fill::before { content: "\f728"; }
+.bi-clipboard2-heart-fill::before { content: "\f729"; }
+.bi-clipboard2-heart::before { content: "\f72a"; }
+.bi-clipboard2-minus-fill::before { content: "\f72b"; }
+.bi-clipboard2-minus::before { content: "\f72c"; }
+.bi-clipboard2-plus-fill::before { content: "\f72d"; }
+.bi-clipboard2-plus::before { content: "\f72e"; }
+.bi-clipboard2-pulse-fill::before { content: "\f72f"; }
+.bi-clipboard2-pulse::before { content: "\f730"; }
+.bi-clipboard2-x-fill::before { content: "\f731"; }
+.bi-clipboard2-x::before { content: "\f732"; }
+.bi-clipboard2::before { content: "\f733"; }
+.bi-emoji-kiss-fill::before { content: "\f734"; }
+.bi-emoji-kiss::before { content: "\f735"; }
+.bi-envelope-heart-fill::before { content: "\f736"; }
+.bi-envelope-heart::before { content: "\f737"; }
+.bi-envelope-open-heart-fill::before { content: "\f738"; }
+.bi-envelope-open-heart::before { content: "\f739"; }
+.bi-envelope-paper-fill::before { content: "\f73a"; }
+.bi-envelope-paper-heart-fill::before { content: "\f73b"; }
+.bi-envelope-paper-heart::before { content: "\f73c"; }
+.bi-envelope-paper::before { content: "\f73d"; }
+.bi-filetype-aac::before { content: "\f73e"; }
+.bi-filetype-ai::before { content: "\f73f"; }
+.bi-filetype-bmp::before { content: "\f740"; }
+.bi-filetype-cs::before { content: "\f741"; }
+.bi-filetype-css::before { content: "\f742"; }
+.bi-filetype-csv::before { content: "\f743"; }
+.bi-filetype-doc::before { content: "\f744"; }
+.bi-filetype-docx::before { content: "\f745"; }
+.bi-filetype-exe::before { content: "\f746"; }
+.bi-filetype-gif::before { content: "\f747"; }
+.bi-filetype-heic::before { content: "\f748"; }
+.bi-filetype-html::before { content: "\f749"; }
+.bi-filetype-java::before { content: "\f74a"; }
+.bi-filetype-jpg::before { content: "\f74b"; }
+.bi-filetype-js::before { content: "\f74c"; }
+.bi-filetype-jsx::before { content: "\f74d"; }
+.bi-filetype-key::before { content: "\f74e"; }
+.bi-filetype-m4p::before { content: "\f74f"; }
+.bi-filetype-md::before { content: "\f750"; }
+.bi-filetype-mdx::before { content: "\f751"; }
+.bi-filetype-mov::before { content: "\f752"; }
+.bi-filetype-mp3::before { content: "\f753"; }
+.bi-filetype-mp4::before { content: "\f754"; }
+.bi-filetype-otf::before { content: "\f755"; }
+.bi-filetype-pdf::before { content: "\f756"; }
+.bi-filetype-php::before { content: "\f757"; }
+.bi-filetype-png::before { content: "\f758"; }
+.bi-filetype-ppt::before { content: "\f75a"; }
+.bi-filetype-psd::before { content: "\f75b"; }
+.bi-filetype-py::before { content: "\f75c"; }
+.bi-filetype-raw::before { content: "\f75d"; }
+.bi-filetype-rb::before { content: "\f75e"; }
+.bi-filetype-sass::before { content: "\f75f"; }
+.bi-filetype-scss::before { content: "\f760"; }
+.bi-filetype-sh::before { content: "\f761"; }
+.bi-filetype-svg::before { content: "\f762"; }
+.bi-filetype-tiff::before { content: "\f763"; }
+.bi-filetype-tsx::before { content: "\f764"; }
+.bi-filetype-ttf::before { content: "\f765"; }
+.bi-filetype-txt::before { content: "\f766"; }
+.bi-filetype-wav::before { content: "\f767"; }
+.bi-filetype-woff::before { content: "\f768"; }
+.bi-filetype-xls::before { content: "\f76a"; }
+.bi-filetype-xml::before { content: "\f76b"; }
+.bi-filetype-yml::before { content: "\f76c"; }
+.bi-heart-arrow::before { content: "\f76d"; }
+.bi-heart-pulse-fill::before { content: "\f76e"; }
+.bi-heart-pulse::before { content: "\f76f"; }
+.bi-heartbreak-fill::before { content: "\f770"; }
+.bi-heartbreak::before { content: "\f771"; }
+.bi-hearts::before { content: "\f772"; }
+.bi-hospital-fill::before { content: "\f773"; }
+.bi-hospital::before { content: "\f774"; }
+.bi-house-heart-fill::before { content: "\f775"; }
+.bi-house-heart::before { content: "\f776"; }
+.bi-incognito::before { content: "\f777"; }
+.bi-magnet-fill::before { content: "\f778"; }
+.bi-magnet::before { content: "\f779"; }
+.bi-person-heart::before { content: "\f77a"; }
+.bi-person-hearts::before { content: "\f77b"; }
+.bi-phone-flip::before { content: "\f77c"; }
+.bi-plugin::before { content: "\f77d"; }
+.bi-postage-fill::before { content: "\f77e"; }
+.bi-postage-heart-fill::before { content: "\f77f"; }
+.bi-postage-heart::before { content: "\f780"; }
+.bi-postage::before { content: "\f781"; }
+.bi-postcard-fill::before { content: "\f782"; }
+.bi-postcard-heart-fill::before { content: "\f783"; }
+.bi-postcard-heart::before { content: "\f784"; }
+.bi-postcard::before { content: "\f785"; }
+.bi-search-heart-fill::before { content: "\f786"; }
+.bi-search-heart::before { content: "\f787"; }
+.bi-sliders2-vertical::before { content: "\f788"; }
+.bi-sliders2::before { content: "\f789"; }
+.bi-trash3-fill::before { content: "\f78a"; }
+.bi-trash3::before { content: "\f78b"; }
+.bi-valentine::before { content: "\f78c"; }
+.bi-valentine2::before { content: "\f78d"; }
+.bi-wrench-adjustable-circle-fill::before { content: "\f78e"; }
+.bi-wrench-adjustable-circle::before { content: "\f78f"; }
+.bi-wrench-adjustable::before { content: "\f790"; }
+.bi-filetype-json::before { content: "\f791"; }
+.bi-filetype-pptx::before { content: "\f792"; }
+.bi-filetype-xlsx::before { content: "\f793"; }
+.bi-1-circle-fill::before { content: "\f796"; }
+.bi-1-circle::before { content: "\f797"; }
+.bi-1-square-fill::before { content: "\f798"; }
+.bi-1-square::before { content: "\f799"; }
+.bi-2-circle-fill::before { content: "\f79c"; }
+.bi-2-circle::before { content: "\f79d"; }
+.bi-2-square-fill::before { content: "\f79e"; }
+.bi-2-square::before { content: "\f79f"; }
+.bi-3-circle-fill::before { content: "\f7a2"; }
+.bi-3-circle::before { content: "\f7a3"; }
+.bi-3-square-fill::before { content: "\f7a4"; }
+.bi-3-square::before { content: "\f7a5"; }
+.bi-4-circle-fill::before { content: "\f7a8"; }
+.bi-4-circle::before { content: "\f7a9"; }
+.bi-4-square-fill::before { content: "\f7aa"; }
+.bi-4-square::before { content: "\f7ab"; }
+.bi-5-circle-fill::before { content: "\f7ae"; }
+.bi-5-circle::before { content: "\f7af"; }
+.bi-5-square-fill::before { content: "\f7b0"; }
+.bi-5-square::before { content: "\f7b1"; }
+.bi-6-circle-fill::before { content: "\f7b4"; }
+.bi-6-circle::before { content: "\f7b5"; }
+.bi-6-square-fill::before { content: "\f7b6"; }
+.bi-6-square::before { content: "\f7b7"; }
+.bi-7-circle-fill::before { content: "\f7ba"; }
+.bi-7-circle::before { content: "\f7bb"; }
+.bi-7-square-fill::before { content: "\f7bc"; }
+.bi-7-square::before { content: "\f7bd"; }
+.bi-8-circle-fill::before { content: "\f7c0"; }
+.bi-8-circle::before { content: "\f7c1"; }
+.bi-8-square-fill::before { content: "\f7c2"; }
+.bi-8-square::before { content: "\f7c3"; }
+.bi-9-circle-fill::before { content: "\f7c6"; }
+.bi-9-circle::before { content: "\f7c7"; }
+.bi-9-square-fill::before { content: "\f7c8"; }
+.bi-9-square::before { content: "\f7c9"; }
+.bi-airplane-engines-fill::before { content: "\f7ca"; }
+.bi-airplane-engines::before { content: "\f7cb"; }
+.bi-airplane-fill::before { content: "\f7cc"; }
+.bi-airplane::before { content: "\f7cd"; }
+.bi-alexa::before { content: "\f7ce"; }
+.bi-alipay::before { content: "\f7cf"; }
+.bi-android::before { content: "\f7d0"; }
+.bi-android2::before { content: "\f7d1"; }
+.bi-box-fill::before { content: "\f7d2"; }
+.bi-box-seam-fill::before { content: "\f7d3"; }
+.bi-browser-chrome::before { content: "\f7d4"; }
+.bi-browser-edge::before { content: "\f7d5"; }
+.bi-browser-firefox::before { content: "\f7d6"; }
+.bi-browser-safari::before { content: "\f7d7"; }
+.bi-c-circle-fill::before { content: "\f7da"; }
+.bi-c-circle::before { content: "\f7db"; }
+.bi-c-square-fill::before { content: "\f7dc"; }
+.bi-c-square::before { content: "\f7dd"; }
+.bi-capsule-pill::before { content: "\f7de"; }
+.bi-capsule::before { content: "\f7df"; }
+.bi-car-front-fill::before { content: "\f7e0"; }
+.bi-car-front::before { content: "\f7e1"; }
+.bi-cassette-fill::before { content: "\f7e2"; }
+.bi-cassette::before { content: "\f7e3"; }
+.bi-cc-circle-fill::before { content: "\f7e6"; }
+.bi-cc-circle::before { content: "\f7e7"; }
+.bi-cc-square-fill::before { content: "\f7e8"; }
+.bi-cc-square::before { content: "\f7e9"; }
+.bi-cup-hot-fill::before { content: "\f7ea"; }
+.bi-cup-hot::before { content: "\f7eb"; }
+.bi-currency-rupee::before { content: "\f7ec"; }
+.bi-dropbox::before { content: "\f7ed"; }
+.bi-escape::before { content: "\f7ee"; }
+.bi-fast-forward-btn-fill::before { content: "\f7ef"; }
+.bi-fast-forward-btn::before { content: "\f7f0"; }
+.bi-fast-forward-circle-fill::before { content: "\f7f1"; }
+.bi-fast-forward-circle::before { content: "\f7f2"; }
+.bi-fast-forward-fill::before { content: "\f7f3"; }
+.bi-fast-forward::before { content: "\f7f4"; }
+.bi-filetype-sql::before { content: "\f7f5"; }
+.bi-fire::before { content: "\f7f6"; }
+.bi-google-play::before { content: "\f7f7"; }
+.bi-h-circle-fill::before { content: "\f7fa"; }
+.bi-h-circle::before { content: "\f7fb"; }
+.bi-h-square-fill::before { content: "\f7fc"; }
+.bi-h-square::before { content: "\f7fd"; }
+.bi-indent::before { content: "\f7fe"; }
+.bi-lungs-fill::before { content: "\f7ff"; }
+.bi-lungs::before { content: "\f800"; }
+.bi-microsoft-teams::before { content: "\f801"; }
+.bi-p-circle-fill::before { content: "\f804"; }
+.bi-p-circle::before { content: "\f805"; }
+.bi-p-square-fill::before { content: "\f806"; }
+.bi-p-square::before { content: "\f807"; }
+.bi-pass-fill::before { content: "\f808"; }
+.bi-pass::before { content: "\f809"; }
+.bi-prescription::before { content: "\f80a"; }
+.bi-prescription2::before { content: "\f80b"; }
+.bi-r-circle-fill::before { content: "\f80e"; }
+.bi-r-circle::before { content: "\f80f"; }
+.bi-r-square-fill::before { content: "\f810"; }
+.bi-r-square::before { content: "\f811"; }
+.bi-repeat-1::before { content: "\f812"; }
+.bi-repeat::before { content: "\f813"; }
+.bi-rewind-btn-fill::before { content: "\f814"; }
+.bi-rewind-btn::before { content: "\f815"; }
+.bi-rewind-circle-fill::before { content: "\f816"; }
+.bi-rewind-circle::before { content: "\f817"; }
+.bi-rewind-fill::before { content: "\f818"; }
+.bi-rewind::before { content: "\f819"; }
+.bi-train-freight-front-fill::before { content: "\f81a"; }
+.bi-train-freight-front::before { content: "\f81b"; }
+.bi-train-front-fill::before { content: "\f81c"; }
+.bi-train-front::before { content: "\f81d"; }
+.bi-train-lightrail-front-fill::before { content: "\f81e"; }
+.bi-train-lightrail-front::before { content: "\f81f"; }
+.bi-truck-front-fill::before { content: "\f820"; }
+.bi-truck-front::before { content: "\f821"; }
+.bi-ubuntu::before { content: "\f822"; }
+.bi-unindent::before { content: "\f823"; }
+.bi-unity::before { content: "\f824"; }
+.bi-universal-access-circle::before { content: "\f825"; }
+.bi-universal-access::before { content: "\f826"; }
+.bi-virus::before { content: "\f827"; }
+.bi-virus2::before { content: "\f828"; }
+.bi-wechat::before { content: "\f829"; }
+.bi-yelp::before { content: "\f82a"; }
+.bi-sign-stop-fill::before { content: "\f82b"; }
+.bi-sign-stop-lights-fill::before { content: "\f82c"; }
+.bi-sign-stop-lights::before { content: "\f82d"; }
+.bi-sign-stop::before { content: "\f82e"; }
+.bi-sign-turn-left-fill::before { content: "\f82f"; }
+.bi-sign-turn-left::before { content: "\f830"; }
+.bi-sign-turn-right-fill::before { content: "\f831"; }
+.bi-sign-turn-right::before { content: "\f832"; }
+.bi-sign-turn-slight-left-fill::before { content: "\f833"; }
+.bi-sign-turn-slight-left::before { content: "\f834"; }
+.bi-sign-turn-slight-right-fill::before { content: "\f835"; }
+.bi-sign-turn-slight-right::before { content: "\f836"; }
+.bi-sign-yield-fill::before { content: "\f837"; }
+.bi-sign-yield::before { content: "\f838"; }
+.bi-ev-station-fill::before { content: "\f839"; }
+.bi-ev-station::before { content: "\f83a"; }
+.bi-fuel-pump-diesel-fill::before { content: "\f83b"; }
+.bi-fuel-pump-diesel::before { content: "\f83c"; }
+.bi-fuel-pump-fill::before { content: "\f83d"; }
+.bi-fuel-pump::before { content: "\f83e"; }
+.bi-0-circle-fill::before { content: "\f83f"; }
+.bi-0-circle::before { content: "\f840"; }
+.bi-0-square-fill::before { content: "\f841"; }
+.bi-0-square::before { content: "\f842"; }
+.bi-rocket-fill::before { content: "\f843"; }
+.bi-rocket-takeoff-fill::before { content: "\f844"; }
+.bi-rocket-takeoff::before { content: "\f845"; }
+.bi-rocket::before { content: "\f846"; }
+.bi-stripe::before { content: "\f847"; }
+.bi-subscript::before { content: "\f848"; }
+.bi-superscript::before { content: "\f849"; }
+.bi-trello::before { content: "\f84a"; }
+.bi-envelope-at-fill::before { content: "\f84b"; }
+.bi-envelope-at::before { content: "\f84c"; }
+.bi-regex::before { content: "\f84d"; }
+.bi-text-wrap::before { content: "\f84e"; }
+.bi-sign-dead-end-fill::before { content: "\f84f"; }
+.bi-sign-dead-end::before { content: "\f850"; }
+.bi-sign-do-not-enter-fill::before { content: "\f851"; }
+.bi-sign-do-not-enter::before { content: "\f852"; }
+.bi-sign-intersection-fill::before { content: "\f853"; }
+.bi-sign-intersection-side-fill::before { content: "\f854"; }
+.bi-sign-intersection-side::before { content: "\f855"; }
+.bi-sign-intersection-t-fill::before { content: "\f856"; }
+.bi-sign-intersection-t::before { content: "\f857"; }
+.bi-sign-intersection-y-fill::before { content: "\f858"; }
+.bi-sign-intersection-y::before { content: "\f859"; }
+.bi-sign-intersection::before { content: "\f85a"; }
+.bi-sign-merge-left-fill::before { content: "\f85b"; }
+.bi-sign-merge-left::before { content: "\f85c"; }
+.bi-sign-merge-right-fill::before { content: "\f85d"; }
+.bi-sign-merge-right::before { content: "\f85e"; }
+.bi-sign-no-left-turn-fill::before { content: "\f85f"; }
+.bi-sign-no-left-turn::before { content: "\f860"; }
+.bi-sign-no-parking-fill::before { content: "\f861"; }
+.bi-sign-no-parking::before { content: "\f862"; }
+.bi-sign-no-right-turn-fill::before { content: "\f863"; }
+.bi-sign-no-right-turn::before { content: "\f864"; }
+.bi-sign-railroad-fill::before { content: "\f865"; }
+.bi-sign-railroad::before { content: "\f866"; }
+.bi-building-add::before { content: "\f867"; }
+.bi-building-check::before { content: "\f868"; }
+.bi-building-dash::before { content: "\f869"; }
+.bi-building-down::before { content: "\f86a"; }
+.bi-building-exclamation::before { content: "\f86b"; }
+.bi-building-fill-add::before { content: "\f86c"; }
+.bi-building-fill-check::before { content: "\f86d"; }
+.bi-building-fill-dash::before { content: "\f86e"; }
+.bi-building-fill-down::before { content: "\f86f"; }
+.bi-building-fill-exclamation::before { content: "\f870"; }
+.bi-building-fill-gear::before { content: "\f871"; }
+.bi-building-fill-lock::before { content: "\f872"; }
+.bi-building-fill-slash::before { content: "\f873"; }
+.bi-building-fill-up::before { content: "\f874"; }
+.bi-building-fill-x::before { content: "\f875"; }
+.bi-building-fill::before { content: "\f876"; }
+.bi-building-gear::before { content: "\f877"; }
+.bi-building-lock::before { content: "\f878"; }
+.bi-building-slash::before { content: "\f879"; }
+.bi-building-up::before { content: "\f87a"; }
+.bi-building-x::before { content: "\f87b"; }
+.bi-buildings-fill::before { content: "\f87c"; }
+.bi-buildings::before { content: "\f87d"; }
+.bi-bus-front-fill::before { content: "\f87e"; }
+.bi-bus-front::before { content: "\f87f"; }
+.bi-ev-front-fill::before { content: "\f880"; }
+.bi-ev-front::before { content: "\f881"; }
+.bi-globe-americas::before { content: "\f882"; }
+.bi-globe-asia-australia::before { content: "\f883"; }
+.bi-globe-central-south-asia::before { content: "\f884"; }
+.bi-globe-europe-africa::before { content: "\f885"; }
+.bi-house-add-fill::before { content: "\f886"; }
+.bi-house-add::before { content: "\f887"; }
+.bi-house-check-fill::before { content: "\f888"; }
+.bi-house-check::before { content: "\f889"; }
+.bi-house-dash-fill::before { content: "\f88a"; }
+.bi-house-dash::before { content: "\f88b"; }
+.bi-house-down-fill::before { content: "\f88c"; }
+.bi-house-down::before { content: "\f88d"; }
+.bi-house-exclamation-fill::before { content: "\f88e"; }
+.bi-house-exclamation::before { content: "\f88f"; }
+.bi-house-gear-fill::before { content: "\f890"; }
+.bi-house-gear::before { content: "\f891"; }
+.bi-house-lock-fill::before { content: "\f892"; }
+.bi-house-lock::before { content: "\f893"; }
+.bi-house-slash-fill::before { content: "\f894"; }
+.bi-house-slash::before { content: "\f895"; }
+.bi-house-up-fill::before { content: "\f896"; }
+.bi-house-up::before { content: "\f897"; }
+.bi-house-x-fill::before { content: "\f898"; }
+.bi-house-x::before { content: "\f899"; }
+.bi-person-add::before { content: "\f89a"; }
+.bi-person-down::before { content: "\f89b"; }
+.bi-person-exclamation::before { content: "\f89c"; }
+.bi-person-fill-add::before { content: "\f89d"; }
+.bi-person-fill-check::before { content: "\f89e"; }
+.bi-person-fill-dash::before { content: "\f89f"; }
+.bi-person-fill-down::before { content: "\f8a0"; }
+.bi-person-fill-exclamation::before { content: "\f8a1"; }
+.bi-person-fill-gear::before { content: "\f8a2"; }
+.bi-person-fill-lock::before { content: "\f8a3"; }
+.bi-person-fill-slash::before { content: "\f8a4"; }
+.bi-person-fill-up::before { content: "\f8a5"; }
+.bi-person-fill-x::before { content: "\f8a6"; }
+.bi-person-gear::before { content: "\f8a7"; }
+.bi-person-lock::before { content: "\f8a8"; }
+.bi-person-slash::before { content: "\f8a9"; }
+.bi-person-up::before { content: "\f8aa"; }
+.bi-scooter::before { content: "\f8ab"; }
+.bi-taxi-front-fill::before { content: "\f8ac"; }
+.bi-taxi-front::before { content: "\f8ad"; }
+.bi-amd::before { content: "\f8ae"; }
+.bi-database-add::before { content: "\f8af"; }
+.bi-database-check::before { content: "\f8b0"; }
+.bi-database-dash::before { content: "\f8b1"; }
+.bi-database-down::before { content: "\f8b2"; }
+.bi-database-exclamation::before { content: "\f8b3"; }
+.bi-database-fill-add::before { content: "\f8b4"; }
+.bi-database-fill-check::before { content: "\f8b5"; }
+.bi-database-fill-dash::before { content: "\f8b6"; }
+.bi-database-fill-down::before { content: "\f8b7"; }
+.bi-database-fill-exclamation::before { content: "\f8b8"; }
+.bi-database-fill-gear::before { content: "\f8b9"; }
+.bi-database-fill-lock::before { content: "\f8ba"; }
+.bi-database-fill-slash::before { content: "\f8bb"; }
+.bi-database-fill-up::before { content: "\f8bc"; }
+.bi-database-fill-x::before { content: "\f8bd"; }
+.bi-database-fill::before { content: "\f8be"; }
+.bi-database-gear::before { content: "\f8bf"; }
+.bi-database-lock::before { content: "\f8c0"; }
+.bi-database-slash::before { content: "\f8c1"; }
+.bi-database-up::before { content: "\f8c2"; }
+.bi-database-x::before { content: "\f8c3"; }
+.bi-database::before { content: "\f8c4"; }
+.bi-houses-fill::before { content: "\f8c5"; }
+.bi-houses::before { content: "\f8c6"; }
+.bi-nvidia::before { content: "\f8c7"; }
+.bi-person-vcard-fill::before { content: "\f8c8"; }
+.bi-person-vcard::before { content: "\f8c9"; }
+.bi-sina-weibo::before { content: "\f8ca"; }
+.bi-tencent-qq::before { content: "\f8cb"; }
+.bi-wikipedia::before { content: "\f8cc"; }
+.bi-alphabet-uppercase::before { content: "\f2a5"; }
+.bi-alphabet::before { content: "\f68a"; }
+.bi-amazon::before { content: "\f68d"; }
+.bi-arrows-collapse-vertical::before { content: "\f690"; }
+.bi-arrows-expand-vertical::before { content: "\f695"; }
+.bi-arrows-vertical::before { content: "\f698"; }
+.bi-arrows::before { content: "\f6a2"; }
+.bi-ban-fill::before { content: "\f6a3"; }
+.bi-ban::before { content: "\f6b6"; }
+.bi-bing::before { content: "\f6c2"; }
+.bi-cake::before { content: "\f6e0"; }
+.bi-cake2::before { content: "\f6ed"; }
+.bi-cookie::before { content: "\f6ee"; }
+.bi-copy::before { content: "\f759"; }
+.bi-crosshair::before { content: "\f769"; }
+.bi-crosshair2::before { content: "\f794"; }
+.bi-emoji-astonished-fill::before { content: "\f795"; }
+.bi-emoji-astonished::before { content: "\f79a"; }
+.bi-emoji-grimace-fill::before { content: "\f79b"; }
+.bi-emoji-grimace::before { content: "\f7a0"; }
+.bi-emoji-grin-fill::before { content: "\f7a1"; }
+.bi-emoji-grin::before { content: "\f7a6"; }
+.bi-emoji-surprise-fill::before { content: "\f7a7"; }
+.bi-emoji-surprise::before { content: "\f7ac"; }
+.bi-emoji-tear-fill::before { content: "\f7ad"; }
+.bi-emoji-tear::before { content: "\f7b2"; }
+.bi-envelope-arrow-down-fill::before { content: "\f7b3"; }
+.bi-envelope-arrow-down::before { content: "\f7b8"; }
+.bi-envelope-arrow-up-fill::before { content: "\f7b9"; }
+.bi-envelope-arrow-up::before { content: "\f7be"; }
+.bi-feather::before { content: "\f7bf"; }
+.bi-feather2::before { content: "\f7c4"; }
+.bi-floppy-fill::before { content: "\f7c5"; }
+.bi-floppy::before { content: "\f7d8"; }
+.bi-floppy2-fill::before { content: "\f7d9"; }
+.bi-floppy2::before { content: "\f7e4"; }
+.bi-gitlab::before { content: "\f7e5"; }
+.bi-highlighter::before { content: "\f7f8"; }
+.bi-marker-tip::before { content: "\f802"; }
+.bi-nvme-fill::before { content: "\f803"; }
+.bi-nvme::before { content: "\f80c"; }
+.bi-opencollective::before { content: "\f80d"; }
+.bi-pci-card-network::before { content: "\f8cd"; }
+.bi-pci-card-sound::before { content: "\f8ce"; }
+.bi-radar::before { content: "\f8cf"; }
+.bi-send-arrow-down-fill::before { content: "\f8d0"; }
+.bi-send-arrow-down::before { content: "\f8d1"; }
+.bi-send-arrow-up-fill::before { content: "\f8d2"; }
+.bi-send-arrow-up::before { content: "\f8d3"; }
+.bi-sim-slash-fill::before { content: "\f8d4"; }
+.bi-sim-slash::before { content: "\f8d5"; }
+.bi-sourceforge::before { content: "\f8d6"; }
+.bi-substack::before { content: "\f8d7"; }
+.bi-threads-fill::before { content: "\f8d8"; }
+.bi-threads::before { content: "\f8d9"; }
+.bi-transparency::before { content: "\f8da"; }
+.bi-twitter-x::before { content: "\f8db"; }
+.bi-type-h4::before { content: "\f8dc"; }
+.bi-type-h5::before { content: "\f8dd"; }
+.bi-type-h6::before { content: "\f8de"; }
+.bi-backpack-fill::before { content: "\f8df"; }
+.bi-backpack::before { content: "\f8e0"; }
+.bi-backpack2-fill::before { content: "\f8e1"; }
+.bi-backpack2::before { content: "\f8e2"; }
+.bi-backpack3-fill::before { content: "\f8e3"; }
+.bi-backpack3::before { content: "\f8e4"; }
+.bi-backpack4-fill::before { content: "\f8e5"; }
+.bi-backpack4::before { content: "\f8e6"; }
+.bi-brilliance::before { content: "\f8e7"; }
+.bi-cake-fill::before { content: "\f8e8"; }
+.bi-cake2-fill::before { content: "\f8e9"; }
+.bi-duffle-fill::before { content: "\f8ea"; }
+.bi-duffle::before { content: "\f8eb"; }
+.bi-exposure::before { content: "\f8ec"; }
+.bi-gender-neuter::before { content: "\f8ed"; }
+.bi-highlights::before { content: "\f8ee"; }
+.bi-luggage-fill::before { content: "\f8ef"; }
+.bi-luggage::before { content: "\f8f0"; }
+.bi-mailbox-flag::before { content: "\f8f1"; }
+.bi-mailbox2-flag::before { content: "\f8f2"; }
+.bi-noise-reduction::before { content: "\f8f3"; }
+.bi-passport-fill::before { content: "\f8f4"; }
+.bi-passport::before { content: "\f8f5"; }
+.bi-person-arms-up::before { content: "\f8f6"; }
+.bi-person-raised-hand::before { content: "\f8f7"; }
+.bi-person-standing-dress::before { content: "\f8f8"; }
+.bi-person-standing::before { content: "\f8f9"; }
+.bi-person-walking::before { content: "\f8fa"; }
+.bi-person-wheelchair::before { content: "\f8fb"; }
+.bi-shadows::before { content: "\f8fc"; }
+.bi-suitcase-fill::before { content: "\f8fd"; }
+.bi-suitcase-lg-fill::before { content: "\f8fe"; }
+.bi-suitcase-lg::before { content: "\f8ff"; }
+.bi-suitcase::before { content: "\f900"; }
+.bi-suitcase2-fill::before { content: "\f901"; }
+.bi-suitcase2::before { content: "\f902"; }
+.bi-vignette::before { content: "\f903"; }
diff --git a/static/lib/bootstrap-icons/fonts/bootstrap-icons.woff b/static/lib/bootstrap-icons/fonts/bootstrap-icons.woff
new file mode 100644
index 0000000000000000000000000000000000000000..ce6152bc9a417c75ea7c7198f4ebf6b230cea27a
GIT binary patch
literal 176196
zcmZ6ScRW@9AICMQ5UCs4TswPr?Y-x-B!0bBEhG=a#>rh6c$c5)zWjpVdexfS=d&nEtDQ<^TWDG%-^l
zA-QxN;IhDG%Jz;c$k0Ss3}9+Ntqg3B7069Q9G=-f2iO}D67fwE60a!xe*!Je?txAu
zB$5Fnmqp7-$mk0tyIEA8I@%*hE<5uAeZUM7sfVQ>l%4_*VAep*0&JX@pWmQ)`pgID
za}EJ!hLMo4UA4b)Ztw2t0OX#Yl8``V0e1b~Gi8Bi_5sgHE{9G5eXPL7cH_Y%HxK(~
zjsOF4m*jy5>FOtet$*(6?L%@oT#kf96nHElQT$=lx&avuj}ea_|9&F!__M=fq}R?3
z``7qR1^5~aWI(|fme{Q2jUJc#3cX%&^{$9$xhpF_RU%ikRgG60nr4JVqUm>XePIHHZ
zJMzYN;9vtX)~6#c5=I+H|4lPO?yk|^VN9qb<esZQ3@z=;=U(g65uir^>0+D
zTWSJIH%LhrGX0%MB2NT<9*J)pO>IsekUNKo?`$}K>hhLj$xE=%vGi(wu9Num)0b1b
z;sEcX+~e=8wJW$g;Zt|JHg9YvO>yo@anOo_nVqE3O*4+shmywnX5ypP)kcD&
zXDgRRb*jyunLZjdsJ37>)g0CKHMcRf7}fW+kT*5l`>>K1RH9H^zEZ$qd^Vc9BDz->
zq;k{9u()7kc!hqil%bHU=$q>shT^EAKdv~2JdF}j*U}*4Sd+QYtH5sH*wII>F=@s5
zMa!;HX+<;URU___ntf(FBO%pFf~N0Ao>Z#|n)Qqzt5uo{W-Rze@9&|HAAT}-8?mZ3
z2rc+oa?>?;0@q@ZK1#b6F;N_5IyqvvLRW3GZX`Rp>6$$8X}_@9HG87`-29^O%E|{B
zoY;M1%f#Z0?vhtBrE!J1D|UO?GWpd~6Rri#R5B~jhC&7H?9zA3Cc8z)5;oS!g9WSN
zyQ#+lp*0Gc*(C$Ri>nm7k;l-`iWarxk>nNr-NfUd(1;e}ksmIUcbq9WW?^??nw&u=`?(AJ|HWeQ3*&{#83bQL8
zVO^r$yMKm0e^~z0ZI|cR|^5&jXv%2S~
z;!5@&RkO)Ong6PMQ29*3!D{QC;_(ZGLh9xB20rGCzRIjWHFu5A%Fhj1#V77L#EQ>c
zy`xWKGLnHXkSa(q>2t}i_h%@VH4ikK&Z1gOK`+TJ3^$d4DEIS6JNB6ep$1l4br)uhj
z?-U01%6VjoT#j7qb2s-w5J72)XP6`y!7I@hba;J6bL
zINIc7EA5#g-KVybl={Re9p+S)>O3R5nMUfAV~L!nsFCl?Bm{P9(S)vVeK{F
z$sKnJ6H`pL>n&f9u9{vGk?q@Dpswm!lMGL5?Nz9nJ$-gAdQI;qj@vmdExa%M=R>#5
zJ*i($-~GZq6Ag}$AI)-lH(9kdzAqQt()`u-sc{``z5!tD@&%(dZehJLax_(vctIPJc
zAna<&e_5=%?fafYg$~En-dR(VB^cCrj`R67WZFAV)UFH2PWD%Lugjgpg^u;tQmm;o
z;)QB-*Wiu4Lbd#B!TX_&Lt&2IwaonRq@zFS~V5zs6~M|B2akR=?!wX9vHU_YF^yr=1Tb
zTh|r$U&t>Bc_%mWPbF^Lx9GN6FY_8}WSr_NE9GD8ZX_@J*w`_>;^AG}C_9z8A>?0M
zLcHG?Y<<(eykyz6exfX{WOb$f#QM(Ih@^L)4aL}y{O^fIsxs{AN<$+{SwZmN9r+1ZqqUcnU6N5>iRt1
zO|FFbOimeYI3K(_89iI5X=L^&IGH~C<5xfJ5kI+l?h{@g>d|^Kc{WE?7qNlrsr&9|
zvw{@bB;WWf`!}v3d^&t1MRp@`Y$jke^FZNn>D}SSbI$Ne;RVC3g5%*3FT1wvje&p8
z$5p2=;1@qjan_C~yq|oCIfsX*wocjo@%)z;N*|7G9Z%kyKNCDR4{vO3pIzSE_CL{S
zsch}C*clDI8D3t#zIu2P5<2@;dN(%2d$z51_u%AO2>
z)1lO}lZr&v{rJQ4uovM&iu2j~1BcFMw=SAkSE7&pguM>`7QdT&`c$zqeoy$=>zwPN
zGJA>Vh;S~b*kQOgeCngvKCtU~Vi{JGy*RtId3+T1(r$_FsN>w>qUd5O{7>ta;^C)r
z&DOq)weYRh8Es#tZIk-X?h-3$7X#`h}Q
z914W6v|P7~DsLP6lm747L&l$xn{CIR+1)AA+Yao#582&sDn@0u4g5*|=k|*xj5_?a
zjlKV`JNr?J?RNHdzgW+yE?!^x^Y{TojGb`^MR8q%FAzN0@
zH`1L$6?#p4GfX|5$cm6At{Dc;ceP!ze>1nr0{lxM{9VCM5+6#MzZ-Svdno<$-9g83
zg|hoS#t!ZZ7kAq9F4_vmCPjr?k2-29Y}ROkJFhvE|B_XJu*QY{eQ}5gxv#){ty6ic
z{sE@~Yjmf*R{#@@X2%aNJtjuG_re{?bNpMQhgM9iJm24X!9(~B-kQvPc_82a#kVf{%@C;@2Nx>ZR>lxj`BI_t;ss6vUjr`dtRzj_oO>E=N9U?Jl-jGWX}n2
zjn&DYv-o$l{{0rf>-6Myl_=d##VzVCj;)7swrWM5Beg3Qd+F!jAmR~yrs92i(&D{(
z;yt~!v1_KXeI8%ZtwYDYO8Uf3KRAde|6Ou8d&U}8elg5?b1{lM=SiKg#Pyr1JYG<|V)~D=^XOhw!c~sOr;i%HifhtBzt$iR8aK~K&sFTqnm@GsV?HZ6m%L~QZ+AXx{WJ31
z>VbR)jSyAxYu6lyC5TM4&`Qssqz}ckYW$$M+`XX4nLj!Io_|@15AZC#>(&)lVY0^5
z_`R&+(He{Y_sp&MI{uBf!E@PLg`eg->ngmIt?wm&Klpp%<#?*ZJeJwZGB!TDuzDQS
zQslXCavT<>Qh3*ORmjQRomKX`x|f$VLvqKwSEP$)i_~n2XP;Hor1ZZ26Xrcs(8K23
z88g;G>QSB*lfBeqYr8z%<&r(gW0`4-gJIz%^f7g_F7SIlRMfvbr;)na7n}dSo-pO!
zowl9-vA$!)X3}RWE!o?gpI_uSP_Z~cUh}bebjE4(v;Rcn
z+VnoE@7H&yXRh8-o)r6^<)6e)gs+G1r^s)75$~5-Y@!fqfR+`?5;E6fQt77oHY6;j
z5}y||ich6(2>8dzj%64-MshC&-T4JmLQJaeEPN
zeAifgUAyM>DeNbqI7Ox-%VWT(pm^BS%d9QSMcAUCM0_N5MIbn`8J_v6-*~ZjXU%M%
z!MCMB$)-@Ka%^ICq+{i_8QjLTyq3DSXJmeb+&6E1-owxp6e
zCb=slpV3W@`c+Loqn;ejTrcxxo|ZT$4DOZR$a7PM>bT2hUo64iHpWbHHW)^*B78>W)qkOEz
z(F}iPjKs5O2HuZ#e%mJtcBtc$qT*;T6p?v$Rz6O-+Y@~E-4)jzTSobIu5
zzkX{EPhpxNH)$IY(YF{L^}QKdURLC`JkbzWRK$Fj(Y&fK+
zfwTVYu@lBnX~kcPi;Ks?XSHFUE@nKbLgzZRFb~CS8HC>@cS-6je>lHj?fBO^VcU06
z@a9{ql}hoKj3`rjm|#)*ybrFsds#aXD~`G^?96GV+z-Xw@3u@BSx0866=O1Zu*Cw-
zqHr^!T%@TP%#h1WzkgWEEV=4I5d$)b&9^+G09(wrNRM+R1acQmAhXnq<1(DF#r%sf
z+zKI3sOW?!7jGI08{ipL>Zj0>OxRI@#}b>~m^#3OxkuIdb+sfDt2m3CkhVI-^%==%
zSN6quoK<%qY0=4i6K3QJ(pJ4VF(Xf_I%&rh{*2fZW%>wK&NXV#zp7Q8yb}axCN{k^
z)r5I+j%xQ0;beL&qfF^wp3qUV{&a0$Y?VOK1~Q3bRJDH_7u0R}awGz2&N-^v|43^u
zX~!HMN^FWXwS#%`j2iaKYRN+vGjYc~fpkTh^G)d^4oGw8UR_3_wmkcyJdO-+899PQ
znseG=tD$
zC{Cl>GJAv<#)x7NbXJ8s5Z%>WOEY4%n|Yn@z~_kWI<8F_eOmgcDp=85WDT37c7GC%
zyC+bwsFoP=Vgv$vgigEf>;@kux~sZ2WIWUELsc;sr6Oy1_G&ViwfZns97W?uKd7W;
ze?M-adpvSP4%UcC6Lyw{QxMk-TyrwywFEI$JVhNy1ufUN8O>UPiB-}?jz|SH*ZK@<
ztQEU6D}0kMo;-4b+~=r<_iJi>!c-|1#S=pkM!Jv+8m`qD@mLI*?C#Z~Y9tj~wLw3R
zb|}xH3GQdlkwno=q=KqzZpHv+f^$&`KHCF(GvWlhhMj;edgH=S-q(vhAr%Z)G-1)0
z3GPJ^xFP|TF(QnNW2?65r_)+Td2<$JBIBTYjTyPx>lkm!qG@CtSG8t8o%VX7H&an4
zvPI3cHA5JC{HWhT>x^Tu1V@EGVknA0wiv9SP6rrqV#pTl`)F^uqSA~zT6stV&P1&D
z?V_d(toB`E$h#4HSOH1~x@Zd5oX^l$v4a(0j}80jad89~Rzl|V+0fEIOWcn?Roc1j
ziztog0WNp-=moS!bgL=@^SO|V&tV9VAO#W>K!Of1gt=p>>{J+-TM{H>Lg;}25(wM{
z0-Io$Az)yDxmN&44RlxlFkB57B?=^60VoM1vwj02`8G{Tn02ZV!K6}ZyAES0?
zjjk|#2IiBSE6gJHZWQ=&5PnhRpbUK8GToWFjc8qR!Aw6*8s}r1ya4*V1fs9Asj#hED~@Q
zOu^u=7BDFWbQ0J=ClhoiK}TF0aQdMjOa~zo2)+M<|INq-;bjm~fKUib)~A5*HV84`
zE|W39U~3KFV7y`AaoojmNsC)xlBRmC)vb`?CNW=#P7AI>nDkUPEnN?%GA_aT)Oz5N
zI4uN$kP(C)oB-t02jfwo!wov=+JMsy4octvZ9~w03E25i7eZgJAh@4e(4GQzF77Q0
zLS_*9{|CXHdrJdQj|-gE4LS!XAa2SIOe@j>r^SNPWLyZ{dN+qKiK)Tby4+5#n56eT
zBTzy5@`gK1#!3!C70f{V6QC7-vV3n9Pv3XUsX?30$Rl%o|k$-Vmv
zJ80_y_HY~}vQVC$Xmm{spA&~bsb=EYqGhnkRKDyHOe;EMu#s3GAPWSjfj|}lB~Oh}
z-rt2rtS#%4jqlu|M+~$BFci-gd<+^K5o>|3DJu&U0V5YM;?c_cat1*1Dga2t@L43a*-YY&Hx|-S}6fYuLmTVfaEQ}SOknH&;VxA10%#=0Ue}b_;fS^C7O$8
z6W72h8@y+akh`Z#7WfZJ-#h$3ETteB|2WH*J0dVBl5%0$3;<&w-~m7c0Q3Q{g%B~k
z13+%fH#vQ1L|~d8+0HI4&<+92BETF5%zW%OxjweYO?z(o-k*~Qkw;bd$2CqMWCuEQ
z$#x{-fpN@0hd<$Q)&gJ%vPA@1X_4)Gc|*D2A_|PV4VZbrxE^3!5)k+V1cJb>P{2q8
z3|7=Pxlphp27nv@j0Z-UgGpc?$FBis0>A;FT>&`$<5vLC1wc9eaa0R;1pRRorPI(rKPfEG5y7@R&P{Bcic2lXBynO02Fxmhe04+<@$0ml`M<@xQY+xFdoa
zqA52PY{lx*!!h5cPu~HBg4ki)0rs2!sWg2^*9GdEf5;2UmbnPTKW0{F#O4E4vRN+`
zU`qmE0k6`u~kh@4{E^4vUF^d=XdhDJ*=5hAwT
z%vpdz52R*jXecDMcV`feW!Eu8Zk#v(uq152d$k+Mh>kO<14+pbdb#
zmQ8+ql>zG|gum70?C-`}k_5sweGyy1amLU&eX0yqDO2Ry2Dt&yOQ
zaGcfm;O3uBOW*>90~8)WOxgHD(@Z%5nNl%7mZ(oG-E~1SS}qS0{VInF2+W8)L#!-8
zC!5BOMC@jZGv1N$7IgAG=8=$a&k_E~&f=(A#
zGaeLhMU763(`Di2Z+tuyUAp#4+pcmbR9msKl7c%Pm1rZfY-lbc8kkV(^JM#;<@gb%
zi_qPlET?Sl*McAcYo7mVb>Qg@Oaq?YZA$RzwFIADB~aKvd0bh!!!>|T^w5t&0g?s2
zHk9B?MajW0YbTabx)wsX4rYW=iJ8Lm+Td^qIQ$2~aZ$JPKd1{pqBGs
zLIRvXsPYXMdICaS{F8%+I<$>lVwJz-ldv5d6|YLy{0PAa$6DPPo_CoDF3UAeR#b<<
zHaoB=!9U?SdL!V6i6=bavDBxPB`{Q0PI6_VR6WCVs4`FKVLsc7#6f}`N|h&En@axV
zE^K#g3;?qz)q^lys_DigrUoBon9s65aWHR{kfSS&Qcd>Yj24mZ*WF?oMtjLY*8bZI&A=>
z5ikx=s;%o>(P1Z8rsH*Cet}
z!{LV4c18%omfx3h@MNO*h&b`eml-}9QW$JMo|YXzf;vDd_%@JOBY
zUul8HP7#uzJoVV-v62m-RN#vBRoX2bXA$qXbHM}_+&p7&%mO&*)Fa?YdxAqCNYteu+V*tWyAj|}z
z|9?;)fREm0AT(>lKt~>Q%)n_S7;qW~I1Oxk6ai%RZNWXJfthMB;|A{WCp(zY1vBv(
zly3V9VCERi+ypa>;2bF^ka?yDWF}vO`{D!kw(7<_d5e7kk+jEH8XMrnq9
zfySRc)n_^S5hb^sD;P-Bl-yl
z`oL7Vg@wD@Dd`pj2M=2g0A$K7{Jy!J5+O}+pz6eSG3l|z!&0
zzV}D?#{f%#(e8J<`~VfyjGiRva^Hv%Dojt1bh&H97{#I|PrCd~!U)AI6AQuJ8HPe|
z*M>iWg5|}}WMt_n?=O702V{34eVHzi5Ig(-Zyx+U&rA>_W+h;+H!hIM!iZ
zUMbi0J>Wc&@l%(SpL+QNu7R(IrSQ5VofHe|=lO5Uy
zg&dR^P#*DW`QvKgs0}SoVCOnPvS3j5zea7KaaV|ZNOE}^f^!?v0i_$1U|y{;oY{ZE
z2dqYUwOH~;`Lt^DBzXZjfTKKg-To6}aAg9>su7AxcNLDB(OESHWHXm-JpE?@TXUk+
z2T*XJd}KSykje*FIc%1hQhA`{f+d)%0dqAtw!o|zL**d;&=;?E%_m|&NdpCVO3Wvc
zK#2n-3zV0jph0>2YFBF_6_iL&5?}3_OvHk#Oi&^~!M@s6KV~Cc&iXX5B-Iuo@d;hZ-Db~-ecE$^X~Aux5s5qS)L`+yhPGg|-{
z+BBBuK*v!u1U+8@K*f)51TIp5q$B_tV(@E*ywG^Xyf<>^@1fg=-ZA(&VF0w^01yKJ
zw;23yPhMz5Yu+15Ti^(q;-F%OvH;wJpuaH!hBRD_%=6=$(z7gRrJuMuah5g)-^$7h
zy{Lh!ou6sZ9M#4`w>NnJn9T>h2+MgBa-0a=UY3r*7pz0jhO)fSXg|0b)tLd!_|7$T
z#DGu?K5H6+mJjBI2Jgew_D{6|gH9dMs}O@vIfI}@!%fsWPgQB?ylJ1E)2kG-lJ5;0=b^?yN!>p!OebRs}U4|J+P*q;x=
zXb@V*AjiBHjT0KPWV1g`?M;zF=F1j^aJ>HV{xs_Kv-R)zy5;+ARE#&=$~e{Q-_`5#
zb%%D_Xc%vpY#?Kh*+>hcgp-6u%*UyMDKp5t{eq5hf^0%#+Q+G!DM`pY)qGhVuRpIp
zvwA&i{VHGg8Gc&nFy3>~gEMjwo(9R%rH3CjNux32{nL6@NKT6+%B*KFu}VW?Hx@0M
zQKF==@w^O5U*BH;2#;s(pVrX`67pxHU#^*2M?6>DWaFn#Z^R1NUI>Rc48XfnS8RFY>TS5nj<29iI2lax1y>_zOhXU&a
z-J}H>RF`5c2kE#VGLu)!kSJsFb$UZZxl(uxct3t%R3{u*`^OBe*0bP5?#L4!)3R_z
zST3p4Rt=^LY;Uty9v)F++gEqlqYs9XnZm*pk@#j!yo1mQwu?19L9TLDbi1x39@}LT
z`bsWqjD#E?!Nd2LMM2&8SoT0dJ%nfA);U#Ly|eb8MJmonCKfgFgXbcAh!JnxmOLeU
z?7)c}Jz~sA3}0rC_-7r3RbF_{76}V`DS&k3v?O-(!c&%iAkd-?c&I}srtKsMEwJsx
zWJ&DPMTo8nV>?P)RmeBb%qr{J%h4UZEe7P92RAG6FQf_3E1lSm>1-uh|8OX*w~G_G
zltv)_VDv<5dg`&qk7etS&-O{cD@_*if%B_gw)g`DtlZ4WBynrT8Qm3}tVmvVUa)XZosn5h^@})14kbjv1A732Qr(9m}y+PXB11C>GJK{bw
z3KYB;w^6=SwZlT%yKw>$Y2@d7?5FtQ#rPTOvXlQ^0BQn|)#U41S^k?)=bL=Q9UkBl
zDjTkrAF4rfbOuuonGxpwyA!5OlYPJ+bJ%2O^4<9~3aT(y3)!L{gC}G@sEvbGZpg+2
zcmnTkmW)XyW53xcjhLkbeTZn!tchBIJNLVR%19=s)oaLo5dXpb-8RizQ0GO8szm2nG!7}%!q&I{+RZIec3=n2P^SMY$HCG(I2ZBzs?@d
zGO5c#f65bx_-98HEkEJ?9sJAi67UaQh5~HCdsE04P?;4rb)OOTn7R{sV7s9{bszw2
z3DAw;IAF`7v~5))JD3-tpGxLHJhzL(d<#7S?o7pB;B$B4(VB~_1rHa$&&K_}%2kCL
z!y#z5qY`?voP9s;pXg
zhfd0r3@3M4?m8{PIU4q5YglEuv^;PL%s;w~;}YK~z$OV1vX!ki^w0H%ke=Jl=p)EEmqR+eSR5XtH
z?J)0s%+KLsm3J0}IXD`P&XHo3*A~m!I8Hpyb;O3^k4o_PmULltjs5AUo5E5NpBu_x+6DZe(Uxm^R8_x#
zw`m1GtoMnuSY^q4Bha$X1~}SORflY_ak`ymJRvM`Q{P~}vUCle+$V2Z|!hiQn?Fz2ySzyolk3a
zQPb#qFmPrx)1w9ak{LrBJ$vHwc|$W;RgI4yC?KsbrcgktbZ@xcWeH~82c|pc^dM-_PVhemW$!9AadUD|nIU`|dYKM&*^E}wL
zwI+31Z_!ABg(vst_AO4Rwt-A-TJK#c%iT@^c)-~>?%%Pu)}Mm`uE_dy
zOe04$0`97w
zg~tnQT%6!UTKTpA9EB;7SDmu+^={vQ1$X1&1?Q9lLTtlyQUUn9FfsYkQ2y~~1W(aL+j5eVW|rIp8`)CUlRkIrypN)Z!m
zDq0TaWAlhn^EudlRRQ#MgaJj#&
z2!cqWC@@A@3PB3k{2Ps4y_#BYTZSMs1u~SC{l2%QLJ&ga&c>+B^5;^d<45F+M&MHD
zzvX{aL4A3lE~*~lnQZj^z#Q|@$Mz3AW+*VShqqf^z}moA
ztob>qI$^6V5yI6)VPTxWB%JV(m)^84?IXhI4?~PtZKNAtw+)}Qrg8)BIdE-?X}bye
z=k1AOt1{x%zqFY{N!k>h&ih+_N)HGaCB5>|&S3&lDuLufT#>-loG$rYKCNVk2XN_R
zTnF4^{T4Zi?`E;C%Vf&>!A$)3euI-IIPi}UvND-&gZuQxqnz7+?0N-Fxdm=U244?1
z4$dJbJ@qbuqcU5JfXm$7$Q6i)tR(N>nQ2{`gEDUQkb`R8ZXvTmecD-n=E}pCRrptb
zqxg?&tC7H8Jy|0KY>mb_mq^EB$#3%EJxrgfDf{KBIFMH|-c2(?O&1O(yjs(Ubb=tH
z?@Rm_B?Y5`V6-k9w65`jUFu+$8`w4RUsn=n`9V0NDc1RZpZk9RcLJO;#gb=&@g+Uw
z%8J2Ai7Z2lp#X(xt+^u~p4i3V2mlxYfEv@ev#icAP$2ChmmLkba(X~P4HPZ7t&n4M
z=T6{jAQ}!t&~~D*%oQR@8EcV|bOeI!!+V+r`>k!dM8pMulODL_|8J=SF5UiH8h}g2|CZV;
zmeN^rGmBTZ1G4WB=0Xji!j10sVu4MIwfH%CLw2ybA2{wvF$|n`>hZ)6h(*XL^ymR+
zoSxXOlWcWczu`9b?MgS=1yr(prAYGSjUhSU3d(m+rt#fmh4f)
zV7eRrgR~+$M`Q3G6S2xhIt7mC9dG1=RE=QeBnRp@ip%g|C^GwugtI7Y+bR9(YwwM{{+@;co$Ti54{)zC4WpUAfOnwXA$s`(H==~8uwBg$R9FUfc!3*c;d~#w&vV~Q
z@7z;g%j)7wlH00fP+;$#34Cah(7f|Ghc|f9Ue~Md;?m23h^xT=_i1Xrk-|A<$#ze;
zjP4+n2JLJ!o@!}kV>4=IX=(XM!MDWB)kdoZk-N`6-qu;ufTp(m_4v`Y=&!bWlk->Z
z*&77PMfg*`7riaj6a9i-Y3=ij<(1XQ{m-A>9y{+>k&*S)HD6rVsv(GGqtic)G!fQE
zGvUn_XPe;{C)sQ_{;5*kn7vi_nQe;g`k5_On7E~y>2
zHDcskZoA@}=#!QgaK*!KB6H?Or4H>#VeqTpRS^jOtaL7aE3QZAFMGk|Rw9m8wmMIT7jZ`Gy#258NoBjYFqUdx2J1D^nV;1Xvxq@>I>fwCXzI%Qm$xd
z|6XEX|L*x3T|)2l_y$w--LGx8@2fCASK_6qnL|`%CNNcg){(kYNw0Dwe;zWnb=I&L
z`grSDw%iU8J?)xXG5++_IQOGD!`gEMU+9;Bv&kgdkw`ATTUP^d{X#z{qAFiLHL96N
zC4U7^V`t>Sa}V~gyF`wPY6+eD?)=j4N?UtA{Ne9`;cNG0rDLa^d#@6IIFLRrq0r^n
z)nb>`IdsI*elyVCR<&hnoP9p`OIBI~eez^e_;-c>x7dqHE%bZt=!eaB3lH$N63gx$
zm#(j!D_0I~R7*|%OO5!+nBO~4as03k_hg77&Bc|j5SA)7xt#vu@*C=KdgVJ5a{M<`
zO7MwP$;U#L^#6WG-|r)Zk24Pj=2(?AncPFy27ax?!yOBM72a4c8l%28#hLizCL*U^
z_V>(76`RJ*(u5LNFaIlk&R4hM#DoP~GsV|f1TdwPDPP(ty5}z+spgbYea#FDR1PvEWIKCmxu658vSD#-Q^Kno8NoCeU>i0CtA+n*E^#EG=
z*QkfQyZXiZZD()cbGEZv7+zAYzaQ8*O&;zaA@_`8yZsi^t{tb9KB$mS4gZk)$_n;b
zV5Jm=m!*0hl_dUsV4iTAae3fH$AvrPYiR4NSp8r2bBmmfk_Q(BBQ@DtP2QAI{su|$
z!Uk6tqt1wq4yLxh?QEXz2oF0SCe|R^ZbFUiqWF;ww9#;d`eRD@P
zZuu_p>9hfp?haOmAnv20*5`BjU`w(`Xq+pD*HG}qD(B#*@l_8Iu^-$+!k3PJ@EZK(
zCA$}FgR1#tHk4hwr??Q9f8{aiDhZS%B`+P}@hR(8`QJO65!l9;tfWufUyJWEo7}na
z<7T<3@`KFpKl69V)B{)bQMI~l2(}=_&(cJ7*y&>M%SWgV+ONK6c|$&m6;sib*{K4#
z!SMa{JHc3cW^vhxbdsgP)Lo-$<@6}(YTh)%{>FkH-1Yb5x92jf70UXc!+*WIz=rw$@eu*O7oD_E^3$qBTJU%9hSna27mO+n&Tf(7Ch<>ak5-q>-oJI`kfsiH)}
zFA!za_UFI3eo^)~$lM@S*OMS8)~*;qc5hX^H`eb%LEHU%s`fB>C1U9E#^_Fr!^4*B
zfF~*|r01=lDy$M69l3&vii3S;MPAhn8W{B-E8Vn}j?V2k>J6ldvW}L#b2a80ZiXJ-+uCv%I34dsjWFq$C!aX*9r;
z_Q84o^|KFl{rcAm3Ll*#p|`GBNs>g(^&U^<{tOiyT>gAI1o8G^DlOMTmwY^bO5v7!
zd?lzFe%s$0KY1NFWJAhb^6QF6&AY#QbJdo^srpVUId{5Wzbj>9(rM
zjz7evQMc$nd>Y`aii17UX3vCr#T5^X_%v3U3ty|!?V%sMl8L+F_~qWQ<+_8b%l)s}
zL`iBgInNZzKLr7qz?Wpd^>ZKJ^|2uB9Aa#fB>8ckFkwik*vv!7r+j~oB=4K~l07Xc
zCA6aPWpY#U-QWF2>Fh$5)>bxislc(uzdej}dmpBpTBX(X!Vb>oM(<$rzQz6ZZ+^EX
zE2PuI`ZQ_aFy($cP^2M
zFLZv(hF)^Mv`d4~5J}}_mbK5bPJ8p~rwAOW?0?8s^6Sz2Z&LXh`(M|XRR^chJ=6OS
zpsfm5yBEozM{XuLhJi1{tnN^Ko>`|<34tZd7^Y=U#uGi$1(rQq)Y4i#;g5J%D8IXn
zw5e=DU3HeoPi#!HdTUm^-|Ki8A1a0>ZZc&RC1)7jK2xgIPBp##xhkshYwdIeq+xF~
z?UTiV#3qH
zUu@(ywHe;+EvG?6t?ggcxE~#9Qokpesd93I7;nfkdM*FnW30>G0zu=R_Ohlu<^9*<
zh@@RZRBn;*%gg1HZig>Fv*Z4K4!1SMSNnd{8pFpxS>=@=>g;0@G16)(Z#mD>Cpoo$
zBv@#}w=y1Q&K^-=D;_;8SHEO4(Q_+$;?@b4Q@LahmtvHNeiFOue4|kvlTzUmOSD^2
zVzlIHjN*5DrcUL^^;6>hK%tuP-H(DlVoD30&D6^VxnieHoDsz?=$OqKpK&h!q(7u%
z(U{U=q`OX>dE%eROKn+$^D*w0NXJy}0Oqe_^Ti8VPVYT+|LnbVe%O0HuqAWw_lbtd
z#g@QJhk{QHYMEU6OU!>#DTK2*AD7s{_HXu7B#hlJzm(t$wTu=dkU;FN)V2gSxXWt)
zT`PoJnA&9XZr4C9lW^`mX)3E1qPQY?W9np(!zE`w4s52Pd(?7q?_l^#)HTAx@YUJAAWje
zE5pllw~Wr?3RC@rJykosG3nJDMjMWm%WT&L&p4ZI3N~LOFG+r$EMex1r;VZ4nz|us
zz%)X7IBJGuan*=g&CJbPDZR07jdUtY_u|w?_l~2N4VW8mt)b-(~
zr$5>(zUWArO14|G=^L@6S;2#x{kplsMz=z*^@#PzItS@!Ck}iJf(2>~A&hMkzpw7<
zM1~*SO0p5(lbsB+&V`=oxpxD>`^BWb7q8zVyO-^m%4d2Kwt@}G4_Ym5C(B^r+
zdp$C?YV6#}rIz`QE+ly4d(gA3ph}FufwPr`Fn?7sdzxn2UUiyc<2}puNF?G#kfnmu
zwdQ~sX>;wnhqqszNl_U2Tsxcb8k+f-!JqMO+IFWxYTx)-AKL;y3OZ2LzBAz9d_buX
z6qPo6dH1E9{eye$MuicRRVr`peh60l&d~7VO{?m&13yPDBZOSj_+UVek)1kvvq9Hf
zsO1CRe^!vc5ymwBfM)A!p!&B&>d7Gsnyu3vr?sR5ygBrCdqT?X$QlJ&bbkj5E?Q=3P5x@pApk25LTL;OA%+|Jp1
zPcBH$uE$I<_dzjYzfF8tIs5x$m_Lb(>E+IcvcnJb?-?vMNxl{RKKWd!Xz_0Ugwn0n
zoy?K42@PRba(X1yF6PmasOH7?E8UOW-Y7q_2@O#v4U24hJSpXKQ?yCwJ#Hn#kV9%+
zU*iLYk`}++{B(xf>;;Cb!BwsqS+V+$tO_m0bk}89xdKWyF0b@3m#=iN?-6vGcd?k#
zU~vlcC?t=bzw$3UwYa8rq%b)mkfz1>I0Al_{NAdFX`KA-jlnE`Wc2IuZ-*0C86=hI
zvNhtvThk?E`xLZ7Ug?oOcaczq;!H+Jhglcf>%>+xmv6B>N#cC+nyP|#?-OUHYr)4_
z-R~}?Ec=&Dq^BPg)>V`xhD?gZra$ZXd_5(`9$v(0PipWd>a4rA$#G$&-ObaBxt;cg
z*E8vW$3Jr?{^W10#;uYj2^||Z|21duVq-8z#YVcdNh`tWUJL%Q`ZM3Vp+P6fST?*t
zJ7;|7kxzCNi-->Z-dc9n8t=m6-?pCs1
zt#Ey6^|Ym1I5DI>QLA2$(_%zWT%s=#AsVA@D6MZ7pX+xNEIHaRabSH9V?13Fc&WNj
zdGCXDrS4mUF;;KMW<+|@@`D(DGhxXlTz|zkiQO>Ap|FO9o;4S+Z6tZFSCX--O@4Rh~E2yo!X^y)>9jDGGQh
zd)Sz`TkG_OquQ&jO8-ywr&$Z4rE!8OO+(g$=gmjB{M(kUx|R1HDoH(2cX}F02oWp}
z#y|=FQ3i>(+DG+He6L|T@`Qe|HQfEaXX2g6De^m*ZVw|+ly+YkR%s=E{e}mcSbW|0
zX^e+$a*D#ek2TUf1hu4ZFN`Vme@fDPHTn{XaO&T_d!MiCc0^j7>v5Dn=TCX~ox3Kr
z675oUOVmKv3v^vugW}b@O%?%rh87JQIBg@vZoZGNV+a{%c;ViQyG)_x#d-3chK}3&2*8-DW;fL
zIWAQWpVs-MC|B1$F#i$>iSXMpMVgyBS|<9d-6ad?4%VAizFM5`cDXkD_&C*<#XkEIGl?XN~MJ;{U8+Y&&}aO5)SU;2kTG4R`Y@PKJ<4l6+Q^{wXtwxx1dt6$QA(Ds
zgLo-wV(RvviG~p-2RspsE=`1CmP}<`*38yS;y_p6#ipi-8VWL%s!9BRezye_=dY@Q
z4t7tA^?}F9JnGJzY8lDU#NtOY&e65yHtRKICugz)dvO|Km#zDTKFN$_pJ{dXE)6p?%=rPXsxu1mF!yHQ4zX@NQC?FdGw2=8sJQP>x)OBzmPKD
z6zV`MA4jEFl1sV+wY3F8%f_yqX~q2eY4whj-(uY?DD+wE%5x9(Z7KMY})ly7q8F01kz77@E`37@Lc;u~a@*C#yB#t*I0xJIUdxffxG
zQ{QC6dUaz`iF?D6;)mlo9?^;;qI9@E#H?s2eDge+RMjd+Y4E*Yv=WXDG5EO*xy=3PXKCtus5Mz>=n@Sxb>peo6UEO%(Ze?O@}j=vlFd;;Y35RzvA?Q|yRFTD8o
zixAxc)Eb)Wc0u#^;e2G$r8P1s)1N|#;tJ{#UvJ_7=`fZ1R@^lI_
zWJrK3maNN>t6Xsp*F8n9zRZb<6k>oVmnl~~KB6NC^8=R@v&Z^LFY7b1>8%cSlZ56h
zy7^2|u%LzkkB0>dV7wB!nnHJE8{iA{p{g^cjMJUm+*H5_
z`#Q5^cfioZMt}6{+>t!E%goQO%Sz7szX6!a=_q@3Ch5CKSM`LGST|5=Z*KFz@_8
zaU|)uzF<{ihd8~jM|*j3x}^YGOIjN10}t;R;V>D5DXQwO3E)iDR&$d86LX(WnQPD~
z_HJvMtsPDx@nlxsRg?{s%!#s*@%tOXpYZ-@0xh843u9PA6B}y(3`0d2>+4&C4i#G(
zMx1Toj5cpyh;^3-dJeT_l;xq;TvP>6lRTsfM%ww-CA9O&T%Xp=zcxt
z4i)|e+f=L2+YeD;as!&s(o#RcBC!OM#qw>j`ItCuqg%9#AqTAd7-uroRW_ANFi4Zm
zh+F6srszuRe63)(|2~|HEh59e_~EE+gQk$8lc!eHkZ!(HZS}f-e&@5Qh~oiKZD%Lv
z15XhRrBd?O=jINcuXb!N%5UW3a8Ho`i=&xyBSzEI-lW4|)W#3;3N|B_-NW;Z)!*F9$Q0>&h0Tmh8ILOe<_6l?G!!ZdV-`@hed7J53{fxUitA{U`LX
zOatM&^|5^abRSEulZT^g;}c{ppT^DozL(`=IWz2Hxh#D=x%z1?mN7^s5@8ZhBf4{J
zjMa&pf*r>DU#GC>aoopJw8_T3ESIl0r!Zogi)EA)6P4z%F-i>kSBls&`D5`gy>b7_
zx0(BRqJQO3CRe>8mlLq6(hev?6UlqUQgt~pHM#0(?iJKN`@2`pqGFjSQ-`u~dx4uQ
zHYMpt*-SHXH18D${uS@^sDC9BDipd29+oTVk0(=Os*7cm9Fyg0j2grKl@W|j^2zw#
z1pmq;!5Z>=yhK8^sw>Bh9f}
zW3WuCaw?E-6qy4Nr154HNvQa?u{&>M^`ID+lj+m
zoa>wF@XWv;$S&_qE*pl+MUugs`wG$CJ26V)Qx6J6A`nwS3F**;?5o3LrZs@b9{C#G&FA0LZQ2Z#F
zgrgu7*34nsx>>k?ulAL@sz>G+rZzm9OUrrm&y-c3SU2b$ubKX_L6x&b7?}&`;}**9X5w!V#Yc)KC3~0D*yIKVeB#z
zp{+xg75z?xJy?7AvM~OCmep4v=s5lIIGH_4{P3R86zngIQ=h}$g@?aw);>lS^xi_Pb29`1v&$kwkp!DR}R5F#ctMdGK_%a4rnup(wL4
z4hvV~9On=)z5eJphqo$}HLjc!{vt*Z@;R^pboD$i{hKUi7XZUWEEm+lh5F3_pw<^u
z`6+B9aHzAscx})vuVs3g^Q#8!=I~(t1ZVhNTyBJBe69dMVpiEwBV2Jq_`Hf{-mMte
zpzppL>18N)n_hP7B`=|}=F+=iWM*pjZ-4+By0pG7=>~}K#{Fm(4erXWBg=R*v*U%o
zCz7zqwJ;k~uu$TDkHwm2Q^!0qyP1ZZr{U-<(!Rq2PhrIP_tmxIhigaID}kCgOY8CC
zMkjVHN=u^T8@NgqL;gh9imUH;tFBjZf4+9GTw9-Aze@E)d3~w2R4z5w>Xh!dnlW>D
z#xxA875HH|ACgjLXTkVf2!$F@a8{y;E3HZW&PkC*{iNrT&hBi}tEg(lYtH6pD?2;w
zR*S57%3NikS(#HjJZmn%*&p5(hPUAo5~)yj2lG*c9al=|taMW9^w$WTC3#(NJFV_(;1$j=_&0Mxy42!cwf-Y8WR+g2*2MxC8KodGp8&ccjx81u(1=b`m8
z%?Z*Td%JGT(vp4Li(6jI7G3Ouk*x7CSc^S~-FECfWzyaBX&T>8p*~Ys5LSefxMHk7
zh$N2CS&&5-vOIRI_e+>%)TY=5Fi|V-p`daFxZd2~7$e
zl}OF)R!yaf64h#vqENNgI-6S1J8TLwU5i0keC@n&NVrZo!&Zs$DAxkm(dZZj^X{ar
zvy*o0e2rkXh6%d$t%Os92Lxv{S|zv0%iBe~I6`;`&jp~+wxhXtez^|BsFCIQ5a{5U
zVP&P_n~$4*W#u!q)(~3rnR1b@Ig%3P!;B2-5Mek)%qkT0AS$T`;RMmo@);nHH^E-K
zLwFU=66NSM`;5mlLxKf1Z)MAR*!t8f;yOchCj_>~n&w%dS_1S+YG`?y7G0(g?4k_B
zrfh46EKfHK-Lnp9wrs|iDG^$}{*%kYON3Vl4+)P5@BVINBFO}UFP`qCYg%yOXhBM7
zK|oOFvgM?BuOD$zcP>qAq5&~O%7_`~LbQ`g(8fw7aFA{nbSUAn@eyILv)K&+F2F(s^+2!>-4wQ2(GxqxrJ2R
zIEmXdX?OYwg)jCK&Lrr3GA^x>Q8sbG+jc;dG*g!yRdO|KYjw?)R7cj?eH+Cuz;+j&
zqnhFTibi$E;S2z6#W=vm;~5LiAIU{gp@~98SuSb%p;E*fU{pG!Yb9A0sgh_iqb5NY
z1(0n`*JeP-^?LXKG6D<=Sw>FCGEtj3E0}CD`em~DG8l1upYTTEhptpM>tm7V$+`yHNxOU{hyUz@WijGkN8qJM4_OTm!
zu^YEgoIcxb^P8tM?83E2u;8nijk=xLoobGw3wG00&=OxNJeZHTCreCDfdrQ%a?W>h
z3Q){C2_L;8efm+sNrIk$hAAFhu{h9m9ReXno5Oi^BD`R{e(FX32magoj4GDjmE!Q@_g-i__oD~|Gd
zJ9gj4?ku6-IDNXrz9o#na)^y#0D^Srmd2m5>D4suEOjZT{>s>UJTPA_%P%*B$G!MV
z=$T{{NCQw*X>kH5;sDST6e)+JF08VV0D>@#drp>(L4K8Vn!6coAaJyq^88B@mOlZW
zA48k-y&2TH^75A}I6O8p`H(2fwRIJnXK!ME-`gBb2h-=d6njlvxy)>?
z6NIm@W#cVO-;ktpW?yz)&;9zqLH;V;Gy^jtQLF6gnjIY|k;rfjgId=vRjQTh(lfV&
zVY`LxX4i`%?>gOuVWb@duI0cW$SHfiqiUL?`|FLZ#=vI8@%DnS%yPTk$s>#Q0kNMh
zU`yl5}a(>|oYnxO?pa@ek$T{E9Z`IMJ3_{z!Roxi)LX
zF?sKH?KOpZZ?I1XQ52Lq&f!z*_JMO7Lv-djPkAOGT)CSkRHf^<+PdFN7gG0=Zf8HL
zzD!ce=2ql5ea|Pm<%1-St=Zc0<^(D}CmWp-f_3_Iqqco|W8>Tbd;Qc)rcrJHFVDMh
zRJdu+Okx=o2bsH8Q|C*G=k4kjDSF!Q4EU3*z=FTI9LRT-J7uuXG&5?(U`VOjeL0Q)
zC#vg?t{>qmZ{J-2_D5V44NVn^XdAZY*`@`js&;)weKp4gJ$Ng^5#cnhyX_Bh{HF=&
z@_cmtbkVI!vy;nW%ge*ErUDjmGXgBARxTmbhN0<*uJwsM8TGxx$lwZoK*n-|>kxlO
z-!#~=;#cp-!6FY$=1uDY7qh%6Z0>T6H0c-zc?JRyNo)$-Q{)n!(%^rCdJW%rtxcRk
zdw4_O>b3+35z*1z;1)e@S6hkxV}Prvo0etJ)zxrQQ!|k
zItv^+hB-Dytw5si{U3XrF0;4-3!YtXM
zW&%#enF*{o+W`1pzPc)v0y`*a)OqU)rM{(G2FLBT{b-Nw*>LLi>knlREi;%;>_O8g2X3on
z1p4<*A!X4weF(;xgD96wUUSLljV008Y}r4ol_5?ik`
zZQC>~5)E!f#3Hl+-YvfCc)qENUQ{nTkVL8kLq`Aoc{%Qaj+m{vWoQSO)|)d&E9v9CpPS#~0tUSQO+eiV}=vpx#b%4NB@
z`>CDyTb}2-e=*PyuZYT?6SziT0*_;`xEx>C&615*cPv%lXVg;kL(g_)Su&^wwpJLr
zcqOW~uB%QUa$|9z)37(WMz|Sm#nI%3qqp<)KW?i3-F
z3vH;zXHELOf!Q$LezQ(^BL+Yj(0}ce9r*j7^NRJ#Y6bp&wA!v#NTu>&P?4Zf;P8P$
z&94V_iQ1)Bd+E7*?kTio3T=57;J`g9x_w5DqzF*~f_(=f)pi9Ss6NL5iaDTj6WjDX
z_ngcjYUdE&cxi2WmhEdWrMHL9mLW0R+yCllPyY~ywS9Bm)BnbBHy;9wL;bu`kl$J0
zT@T04t$k=hQ<`=sS^$F(tO9ZVbxOvc8tL+%pG=(3BAi1Vej$#C_wC0sFUinIc}fR}
zXi$_i1~(&RcR;p3(^*oi0Fz<`EGd?5+4lF5Fs#KM34(yQaV@-%Q}JQUhgD*HE@gdP
z5Zrq14){4I4E5bvhT=VYXWAbIZ9kd(E!&y|@teY7h<|4SAAZUW#(-bHH3fZI0~d<%
zP!!tuN5#7~-snGDZ`aR;S2J(O)xpexnZQCn$vTTDs7spoP4wC7
zy8bi*`ivgT1i{Q((fhI{tn-_1bdV1DZY%LDjPk;M$wSs=!`^cX@}s%>)!0|u}6
zbof*uhjT`w&OS6MWI7xt&x065z*g=~qRe|>)CqsW5KSy05|-FLA!Cth`;+6rw6+~t
zU7JFQ^Agsn{>!~6Fvy*OxtQyP?2D7C-yN-qR3;WaEPt2_Ynk;hV+9U)zr|vpX&YAq
zZG5dz#ba1!s8>s(<;>1HmRPD@7_M!b!|<5y&-hWP6v4+3osqXKPUq>|O?nwrogq-h
zIlXp)IRwuSfi#Kf|KTa5@gu`vjmTVoADPQTaE2!|&?Fm&?1-W%b(F(8oHS568k699
zE&A8%AR6`TWLPdSbJ-E$+H{q8nm-|%Vdmj*y>vXjznt#MDI^2fNc-gFp6pKPzO$@8_gLL`;I4^?DQ
zBSeykCaLIWRwZ($Hd~TZMRp=pvXocq#}}&yE0u%Q#pAjm%AyEkBVyPZF7+a!rF(Tn
zC2;=}K_cPQvS+D#gbnPYx*d||1hpFdIh+KvfL??;Wg-$PFI&&RYAT#vYz7EtO?S2Q^9UzB!
z=uVJb+nlLWh3L^qTvVsf`ivPLsV0)x?uMcmcH5$qRF9+>JF27+%sGd--6-K0Cq~JT
zH6q!%B!0&>WydjX&p!x1zGs_`Bb)!K17xT!h`tDa3soRR2T4IxrS9pLNF+%#HQRvV
zfuJH$#Lr7w$(4v?2GW2QOb#s=!QVV0iT%>PNS|Z_VXk%<-e5DJTmrXu7nVxR#b#;g
zUAbsZL{mux_&uU)$cicj6$!%`&a0bEo_4Ug`O;KOrz2)$67A_OeqE8OJ}BXV%<{EK
z!Pxq`q~Goom(%^DO24Gi!fK}PywDPaO^%;ubd>TM52YG3QRLeJOT=!>6u3HmFaq*t*bFvI@}Fn3sQ3I3`>t
z+yb(CpYST-HR$VP$<18}6Jl+hWGll_&r{5e1!pu({<)E)H!zDo7-5z<}+wQpCzCCv55BXOY2%MhXnbDFFxWTC>rbJ|sJ@8C4
zk-+IyMqu^@qI+I^d+e{i`u00+b8e6PL-X$2$BEtGlq?Ss`wje~EHUf7%wK7wSLrkU
z1wqi$*!mUd={v$fpl}yxd{j7zmQDJi{6qizwsS$a7UF*xTzug>|5YI(S=m3)Tzr%ToX?X+5F+wHSl
z!jPW3#SH-pVz~VnQ1wDEaFn0R#cq2biy4eu271EPK=FIAFAOm(kgX^=LE_m#)OkKE
z%G3@}xXq&kH@13gqm1mlc%PrMV3FeeS3u_{iidycFxyO{H=jniJ(C8!&6jx#T_b#3
zfK}d@aSaAZKj8%uNusPtx7~(&XGr%lt#u!cug)*Ps-bg=6jU0GIjG^+C|2He)R^aK(M5c)7R9Jo~T{R
zGy8svsL%10Zp++@vov%iwfQ9}ivz;3Sh>4!fO;1@y;l-HaTf+m-qjAn?JJ=noDS(2
zl&@QH%@`XAG&9jpc%0$ML8xU1?Ts=1bL_+JXRA%IX?qN
zaMNM})Jp}-!aVE5@XT$l`ghXA?8MB32Ab^KG12qevGuC=a*^7hyfyK*#?Q6~cZ&1)
zRhD<@fN-1eJ*@wj4ENytIO$AmVClYFYl8-cLX>p-J0mC@VPPKTZPI81nm~h7bDy3&
zKLMA**)NL4CNxHk$IqP`?3q**=GY$YliI+10c@!=pQ7`IF(|o0Mc|Isi3WeluYj>t
z9)%*S|Kk7m$RmoX4#Ti|NiZ~X`D)U=;8>~$85npr9h84OhoC5roI}?0SocH1MIi>7
ztP9t}c<)v={!R0wp}RWGMt}nh+NHVR(`J@Q9)@;Fvp-lkLDQxH{VR+NLEFX&;MLoR
ze?<~W)PnKZ10q!irysl{IEidrVOt7&hw6r6l|Q4-;k|BfJ>HwIOQNOS=2@2a-$hlr
z-c(*MN$DqPgr;^gn*`W#bZo%BD
z+!4WoPH-Z8Rm51(4NTF`_Ku6XJdy=xnO4P3ywCOuiD|PG_xUa&>ne@ZsN2RJd0y(2
ze9g9e-weyvy?2_9qEW4VP_bZu5q(>&7`=d}6At%jN&TDI#~U0EWpQdX(0Q5h^E
za!kDD=9`~ajKFpRRjGP*WUIfnV^}cMAqQ_2RhcS|-PJ6$92=#|T%{zdPV9J&=3E19
zOOX{(5uG!^z^8y~!&S`I#x_ta#bN3>LFWnE@noKDWC94|ba~WNbVFC>4oV6&ETUQl
zRiuM44BAMd>MH(iE;yChq@nALWVYhYZ?e4>{*G*rSwR<2kKpW9H!T#mT^X)0VX8Y#
z2#+Is`l?@JwUBzLnpUn*>nG#6=r!n1B_%wzwMH^maVXsasu&9V(arhN>~h>hwp-|O
zC6TDB={#2ok1resJL8%HJROSL;G%Zmn=&FuuGnXr4zNOhlPZcRE>vHuY8PK%Xr>k(7zlNC%^&HCA{jQi8m;+=M6((cE6L%=-QrmLTCkMv&u1^A0{SuT
zmI|^lLhB|vN;ffqTepM$QIH~TU5xABk?WA50chKl+Li=EKF`t1DHg>ibCRw(Rzy5=
zh`djwsH^g~@f*jp}zU0xb>;
z-w-y1Bf>G^6j%=T73Onsj9A#1HQ8dh`ayI$6xSW$9sy#)Hf&5N5CsjKc87M_j)?x#
zKC?L3wgT`a?sDEyWSmZuZ>2<$7$lbJMoT5Db+9UXdPh>)Qnfi3$mOQ*0o&@jBS-$s
zv6@5;#f)9ijN$<3r%InSNKh|pR@DKuVMt$NE8g{3l;OiKYi{RYqBU1s_kQQ>h~Bnk>m8A);LI4U^K6*D(zd>_|zrm7j*U4ad+u
zVu)%3x-(t;Lsb^VzN|>1q(E0^s0vjHNJy>cR39OvC8K*@2K!UigF1zB%rXVTUIhsR
z1-dAiKxyMEwhoO4%2Nhoj4Io6WaygyC{wN{$@Pac8-`Gd|1{Gg20uQh;|HQM@Qs`lPQ!@$G0?uBD6CEE4m9!X
z(0c1p^ah3=?(*3mPz8tMC>cPVPBHnF3uaP}#TsH(gKWJTI=NV>G)l5L$zCTv+hz^C
z%}_@IF;e72Vpm8gP#JAiHrkrzDdd*)f#~fJ#nZGFd;69aYyRYx9X3GTcKg5gh>r6Y>L$(X4{v2N!$Bx;0
zc<2L77Js`2E$v>`(gyo+j-KO+sge5~R7Q@NsBs!rZ~|=;yv28=W6K6l5S9w#xzx2b
zc6cs-`W0w1nxa!ebX}zy#Tl*@31C-rRWsNfS$&>+g|_(zMlBF@2W@kA&}&2t-GP>B
zTAGP^LK?b(4&N)meZo2BKuwrgo`yASu9D)tRl@HLkY|Xdcn_Vir@kx?Bf0_xc6vi4
zlTk;ECnApX%VUVAw&r(0%dLR5t$@9W``ut(i#4&I^b(rT9_=I>s9LdqZL@s`nFadO
z7(ZLx@|JJycF!F2u4^V$+i~n_azj$FUDvK8->8%ytdwh8?(%DI?QWiV?Xvqy%bjih
zKy%i$@)Lx?F8FzI$DJcq_|PfQQcxHr4uUn!g4PX9ss58{EC1$mj7C4!ihFWt$%JQ^H?X
z<;U=i$7J;}o-{|^<=*S8-gbIOH&j*^xSLx}z1{q#JoK^GD+}o!w(~=;rh8kh5HEGZ&%
zl9KwIqKZ_3nj=YyFoivZ`_HKo+!I+BDCYI+Y@Hrf7U9mWolAq|$zW-AZm!Wz^!U+%8>2J-l80gVJ&Y$IL$#vz`uU7PyX5OnP_nO)t
zNNE@+1}treM>tTbytyf>3YhowZ&zh`^>4Wkw}^jz68;6HUqtt9PJ76-Um
zV973zL~8DhW+6cH>WLVBfj7!~_rQ!4Xf1@18eEiR<
z{)P)k(^%!Pjzi_0*CJmu&1%&&ML*Jq%KrBMqB#}Uhab1>4#|Wq%&?U}L*?#GsNJE8
zzHcI}{-jV}dpg02ajux0r!J{SP
zZo<6qa0X!FzIK>g0XN0y_BZ-_3)e>{gD4FkeAPr+|M{Mfp4y|$7HPaRk;Xg>754#3
zSo-WN4}XEO-^-&rF{AWQq~|a>e-9H=L@}nY;PIU-@KlTobgV*a+@2hDigOyB_U7L7
z8;>e5K8_I3B
zDf+VFo99@CvZ=8pC0`rVqJy&h-&IADzK-<_>wwh>HT8>_bl7weQ^;FPAs4F!%x+MW
z8%*u{KcbnkqLbJ=XZpkS|Bb2r4kGzGn%Oex*Ck0&zXsn==UFI=<(?A`2#aatZkI3E
z_fvfnWlbgABK$4$qq~UjYHiAxb!69h}PSYr|IHGuod*Sgf
zz#D!3Y=(5^BR-AT>lceZfgyne3@TkSFMie3zNvnlM=Mk&$IM2J|e`cvd8mM66FrI)aUB34rSL${6i3&obDQ1WrL$(%-MCb@IAu!
z3a=G@80h|fmJ1=>`Fud#l#n^SI|VZ-$w*1__ZQec-E7xb{wT>xplP_|Rwu8(R?(|vxh26oRS~mWJu}y!`N3Lx#cu6L{D+GfY`u*_i{3|IGF>^lTR>iat0tr
z|1(i>SL8G{j2{hNzQeCVe*e*wtX-_4Qy(F=oL9|Q@+@QJb6CZ5jGf!t+dGd9)=gke
zU0mhX!Wk2`+%+oU3goTc=0P&F&A5n(xWp#q@2Hf`m#EE0<{fvw(e(Z1!l6>L1b@43
zJu=Ox?!M<#T=7gVY*c<>%{G%8Y`gL)d=CF+TyuBbT5Mi;G7hYgD2kCAm0>LN-$4%@
z2AGyX7ETrS9biUAcVk9$q*ZYXcTs_!J$9MqQkx@oP^U3e3<_By~;IiApTRiXUv$E3=kciMHZ~iipey(4nugvpQGuwj?&LJXP9)>wAgN|bJ%rG~+lWEAePMc&O0
z-%*~q8Pi?n$L17Xado8;0v#*ysR|?Z0#N%WQbML5JIVZfvWthEGEfreS+auoI!5+x
z#kSu)coqJhOW%b;!FFWj;#b2*gGV2I^h1y0IjKC#
z&L4dg_h(Ma&_SR2Ld13q$Jo9slJrJlhefEoRCqaP)$bP`5*|)l_y>hg2tOe_Dg3PP
zi^AuG&kMgSd{KB>_zGzLW|n{^DgMK)b@**Y>rpcNjAh@5x(a;sQ`o1TcQMt@I{Zc$
zPnZ{Sg!GP(<`EJd!4$oP!t>X=N?HUiyqbCr3L^+~osa+;2K)s9|2x1hbv+>D;y;E@
z1doOn|9a@->pHq1^;-75-q6>u$cujkTzCS%F!aG#vI6DmMu1QwCKiOyD$InmrPxk4Dm&xl_2>0jwew*-vjOR}X9}zw-d`kFv;j_ZO68<%C`+qF2
zd-Ky7RXpd(j-cF2f+0#@j;@f=UrpQ7I42qB4oobMRduCIp2pMz41QLE!6Z!A(+eyf
z+1mg6tU_zdCkjgljiUWf`mCiExx-n+0y&P+(Iq%A#BhrUyW!$j|6yN2W$NoduFZN=OoluzxjGW#
z_Rx6t-_iWhWBH^5$b~pRhH}lB0BNNW{KHQg|P3o($
z4QKsz)`l}nYTR;u|D?X!kLLHVegEmkJXdHwqb7M#2SWRr&tcg6?ngrV8qMkY;{!sY$
z!q_{_^y+2__!P{u$f5!1i@?A9M@Pn5`c*75GY$t{0tp4&v7XL0pIT
zhe}y*GO_J~*bbLIcwb4&=tFr^&p9mc_9emI%U)+P)?-3-0A&QFj9t}GD)fv0d6Go`
z6&KrP_O(HQLLDw}2EP2d(j#S6UO&%c+Q
zbh8s&%ix;kp|GCFpOoWTN%U;n6HB!?zqGtH!;wBIIR^iDj(_F<<{y8`KS%|St{FIy
z>^UPPWS3H89T=1YADjG37x)MN8^jZ?uzW$YxjiO?EK^=HRgi3kq9G2(y10A<6ZKKJ
z=)fyyadG9jvuu&&xpw=pZTQ*61EDRr&mV^P=v=$SpTJ?Tc7dVje-$lNE1BnpJgLa~p?oq)(V3<9$MZ$~MxM(BKfpPhBR6
zd7HZeo!cMT^fuf3^F`OWlUrOC56Wei!9GM^nr=v1+#Ql*H$$S%$R@*Co4ah?zlVOA
zj%}eYrm3zQ>x<*z_LgDhuzgk8p4AwPIn?s@P#Bj5dd{Z_igA*yGun@&tK5e)_k^~`
z!bkSDb<~2X^UX^#bq4(i&Z$r8i?fYMhx_96B^36dc6SMe&gBC*)b1|7ueiVP4
zr>P41qSzmtUcI`i()Ewa^2gU{+RpR(T9;B^hj#j7buK=9h}G#meCXlH^&VIY@_N2+UrCZlNAp`)&G@jg{m-!Dn;
zhYym7;-O&8glg>dkFUeu$1lk8mPmg_)x|9l{&e+csF?1#Jg9$uQ2X9BKRmV8)xB#h
zw(pR|(=DVs6k|HjCDA+#o^ViggRb^OQ-hAv6nm=Pz4(HDJ~&TS=uM*ZEC#$h
zD~UJJdsNkC10`vw?1Pg_r`@c4Iur>!QrC^=byk}`luLEA>K$ALygicMHP3^+!f499
zF{5$E6CsP50M;x4_;!b?y>S?}pT6<@V>d1Xe7m~e@JsLmA5RQJ7Q*l`eER7;252Ss
zLkb}(rIfL0AQUd|#LT3fWImejLk+w_3|taFc;hkJH1PYq0pj
z6}GN&-0Kf@vI-NvNRCAu0?O%%yIk74Nw3pS`fH?z>AOJwl71(X#g8b;4a(JckgvH$
zh7Y{h-0T{go5AL$(cRqC;l${6yN`9d|7({V6vahJy}2zZx2w{kD7M?|#_fvKzFCzX
zXfzt$%vFuXRWlx(`d2lM9&KE8bE7fy3;ga;p_n6l9&7;IHKUi>R6U+&LrwER#Ow~+
z_ApAdf4be~R=1bgiV=@J!$nYibP4p)0|scLn}BwrsBYN`jbl`haZDB4`m3=!Z<@7d
z4j!DbXM^nIYiD#+(sM+j=NA(*?lL79QrmpDUL7Z
znXU68V7ZvWj;psg?7um7=W<~$#1rlnhk~oSGOue64_KSgcXx(T;HtX&hAyy*DWvL3q+q~gQ?dqE*4`At3rkCbauQ5
z#bAgx3P{q=6I&%Q4?0H808cnn>F(({SeeaNHWeHxWA
zrBW^5dt3OUG{zWr5>$yLC
zbdBx9h({r(Zl}0SS~9d}+K>bmFVaPOd=O2G7s+5L9})vE&}$f%F0i!4?6AXSQXUh{
z=Le_12eQdzQlg&~@u=eU=OrrD(9cnoJ`dxVDw92t$J4UX-!rkWvqKfWcBBwoNmvt?
zhbzRU0M}?UrF7I_^noiDj|r!Rmq0&uPIw27+p?6UJU)7XC3orn(~uOShgaw4lL7jr
z7n!nWvHaEfaKO6@FE)YUM^DGXl_5
z2_}a_-%k2j5X5VE0~~6Uf6Q_CW!@-1#y{S}+vdmlM?v1cXXr~WE0(u2^c`uaJRy}U
z%J$F9a6ST7_-Ww|o{M0jT)hbBj|)xX%BV0d8(+9WVhsE>7LISbIlF=N7@FVZ*z+5h
zSD}zd{9iVY9bmfw9AH}l95~i2Bm{>mf3}GanzMfMSUR4^bwmU+$hCpuXN0prZMF=E
zQ3>^XpV7@BqqpFYU_JmOEl(@6$#1FL|AN^u;2uu3;=R;2vr3KxrBZ;6AWD)5+FQ#p
zO$Yl+w6jG`eNf`3*d*AagV2B)r4pu!me_ZHIBb+<*9Ah_-nYWTn}Y4eg7oiWw9+zLi^lTX)BaYw(~T7n#V+p5i)n<^q=U>(
znr-TkbS2abAu9{VTL)y-cu=|c)y3jlzyng8cnaEVuU)`vkZY|P{MWWE^HUc&m<#6Hp)>FduEPEDD&e2`pIKeVv
zp$7=edCGICtph*09Tih1Vag-m7S8Z*b(3~y9k_wZ;*!JbeYUYMCJSWg39y0nHhb`B
zJ;r=X@fRe;2n{2g4;4`%;ms>+w|dT@&4U$1A-_yq|LR4JioWIOW+So;su{MY(`32!
z6-AXqvApPriiC6BwZrvT33Xfab^o2vFK8ku&4-?=8)9>*zv4&9VokA?#)0_*hh#}6
zrXL(Sbig1A(G)6?VCEM@kq~_@k`y9IG+8XmQhc&vYa*CLOoa%-cfL(JK%ZB!{F@0b
zOcGbc;{-i~Ac7|eQVXzEXGOpbwI*WhvW!u4|TM5p~FVHm+h=aKrju1``
zETR41sINFOSmD>+e7s4BsJN;_6+$Ezx?tI%K6OBBHB|wSJqr`N7`4FD3`GD=K(W79
z)RL<=Lq(%h5@EQl7|~w2sWs#ZxU}7)H6IJE}+xNAZoomuyv&
zC6HtVsK9zX7>m^8=a={)%nO=v{A4Yk;T6jqK
zLE(MEM};SaeKKPBOz*hoS6YCa3JYFd;CScLi4(^C1q}Kj~;^i{glfr=@mCpAUc7%CkRQ%l{;bI#eg=qVzWe&Lw!D6ZzkPkl*||M1_5bM?tVff|=3ac${4*GM*2*UlL^q
zi2pG^`(r{l0(kr_yueicaQ^We8;P7}M~>f$$cQQOk0UubCHZ_tO6~&U4{t}f1dyWWJZwBiFlOo`mHGjihL?RW8X}Pcy;0Y5h(WcrxAblK^BMv
zRKvCi$G?RmqoyckdHvD0X~X9XrtsuBVDPuIDuHG}-L!@4>v4~ptqrmS1xB|ngcZO?
z)$K+@F{mU{9fo;|Rid(C&)mN(ss#R}!*4zi>bhn^A4dUGmFlu=+PWGLVwK(2Jyo&b
z>qZ#1gzJPGaIf}Df`zs_3zTJ1i&>Icmb3=W@Qbdv-e12|V4njGNHI5{Zq}-bXvvCa
zS5GCaTgry6-g)gM;_~O9{;6ggsz_9yQb!c2U4Qw(`V9>`wy!%fm{;=w*M#LPfzB|>
z6F{R2WmUvp?}UhXao2Q3sfw=o0n-($ilR&P)y>tqCze~wt+M!>s(j9H9OH9}%C~ij
znqkLWLhNyuYMf0h_PY5V9QjmetWw;}A@#MkGk0LNX-Cu?j$ngs
z;67qfqS?+fj;#@Df*rJ-eB|zOC)U$RM4dZZbvBJiR9S!UZe3Q?u}9Fx;tr`RV6Ro}
zg&wiR6!SvIO58K@Sd
zlnlvK+HjegPS+54Akjy58q4zTuDsmX3B86u|niCSbcE_(Vh&8{a#phrFPk6sU_J2Rg(yo6q
zNC%DnY%Rped`2S{-3_#Sj_u%xDK3rxr|M@lW0ePf0|DFlI)gTk183iQJbg}-p%>IW
zpQix8`1LH~AiI~s@kN~7!xRMaqZeOTla(D)dw!5+cGB6A!IFwehwb6lF>?h=Qv3f?
z_byP9UB!XmyYK(Y%$ND{y_Z>)l~t8lmD$}@UDaJ#nORM%yVZ@PmQ<4Xs0B!(OCSjv
zgwVA3S^_Mf#qg12{27V?e_Rg{J9%JM6@$91G
z-DQT>M%?@U`LZgry1Ff-uJ_OP;zq=c8xc2dM4aAJU=v=)-O9a{dw}~m_ZjXy_xovj
zE2!T2nY>U_`UxTO!K#>(3h1)ZU0zZ6zrEZPKDAfoB{W)jV;Q2ib5Kg4ojy#$HrB|Q5v6|)s44QgE;l0Fvo*)Y!%
zon#}`%R|dk5nq=<&!b8A;A4K-Z#|)Ny_&ldbp8)>KhOOS+*i0i+KI;1LKk6TaS9Nn
zFSE)tlr@})uK0+TI`5}h!-?qZ-%qec`u9$nH%3vo@&$X&l-E>!K0@hQ
zwB++dj42+A6)HFpQhh2`(;(uCZMCkCNhM1VLi&j%PZCcU>JKuQB6fTtT%d(Uoph^e*ag=u*nW}K4Wg^I
ztx}c2ps@-s011e8+;WCzHC9CPL`be$jELbyJ3bhPFR3MMIA5q;%ukd
zUvkN@wN`&QW?Dy>TOUuee+iQLr7*WXf>wVS$Q{u-YhL}EFLC`~JhlFklXQJljsDUT
zb`+J~2=)0WZ*tVre>0ZtXqeu9smI@biXnWNf@Qf_!sUP+skN~_M2X*p;rB#D`KKr^
z8L-ixeLAoqetc=w_;XR&CQN}&t1K^bC11D7&T$e|U|`wJIY1z-5v~MT?hvU#dGv0(
z<1{fvC}ujr?v1%>6+dODlW`BP(cjR_DC|0^YT~9u?%_pAJTJ;6nnU7;rP4g+|Ax(Z
zd!6NRZIw!Nvj)fWbceS|QVbUm^dO$r2*(U4@dmlq)qYhjg3-^E-!99e3~L`
zo^ID^Yg=@SSoAN<#|{8*3xX6+^6?fyBy)!)VV(cn^lMo(HQ|oG%g5sB5PLR59^$ct
zMBt))4dGh)Rp2G8kH+=mD^-brW|$)mtKYzRqI~maW$H;)>Pg71!csE?QHxx4KxR
z;oz{J?$pV2=V%A4zRvW(Qr-is3YqP{12%TF9%s#e2W(2=J79ZgU?J~1D_a)j;lQ;c
ztK7?hSKi3o!@U>RL&{BBer%9YFna}K7&H_5y$-GdMO(pX_g1iEWvkheLCCpY!|!!i
z1ev8CX}7{!aQ)CeWoi9ZX})4~7w9TYNO2aolBS~oaINK~gNv4{8h^j{mOWH1?R(uG
zSyFD@zXxf(=Qg_Acb8!q@Nbjt&Jjb!Y{s}buNo(evfPR|rlr_$3Dx@vYl4Sf2s=Y<
zh$6uld?M;v9u7s6q+)n*PStgIw;Jr=Ghhbl0S_S_F{i{7w*u1WJ>17>PKi`GymsD~
zM5|!8XWM2P{`5=D&;M;67=
z*+E>|BGGh7(lsJ(4A5bIkX~}xct#?5;|pMD8(-A(L<-jfF}-~sTgMyEeBpJvOF{k{
z(4hL=Cay52+)EatuJa4I5~+|GZ)$d??#;kqDOa@Z*s?!dwCqgI&6H>6FezA}>e?P%
zaw){VU*-DoT6)m;rHmPQ1f%1GU~~XTr@2I8eVSBbkO3S;AG-R?>=c78TaFYep6yl(
zn5~RLI_dDaLJUV(GcU+Y6w^?YE#YceU5%^*Gz`59^jR(rCt85_
z0j9vt0~y#ER<-glCUo{1xb#P6+orRE%i>+O?RawhroRQV(e1^aT44+6``t$jLm=X^
z<=O?8sXne%g03g>w<(e_Wk`9tRSLRPkn}p;7FMF;*jCo7n*VsP)v7v~DilOR-0NCv
zZebl;yFWX@`pQ7Wi|RdX17y$wnn2&YA5FAav6Zc|>K&a+%ZFMm)L*9-;NLe9qPcL9wTel&nxvN#N};v0d*RAm6Yb&zl%CJRam&1JxBvl+)V
zj?pi^NO5e?T0~30o1Y806QnyZp(88ZC0a8YlLMe72owNu=d{DibPB3N>j~pfag6qV
z96ma9UFZ>9{0_9j#iD@THcc|ugWpV}Lwco$R!_ed_@;5aHT5{d`}$oNliJKLjfrb<
zVKsWBVH9ikOyp@@6UjGlBN&EAt`LbxSsnB*|FB~VWQrF`0zX9rTi|7QSSXu?g6S;0
zXTiaPvLI@@%nQfWiXj=IqEDJcG9_Y8>WT;dMN@9nR>bVE;z)2KeWny=j#{#0!K7{E;JUe~4ej<-t55VoOr=+_{{t$c7>N
zhf+%_6Ug#
zB=(%4TQr08i1S{>%Mss~0pTo^7LdQgGy7GAFM0!uwoN?^QGm&3oSrRd!
z8E!&9u|jpJc-^gspx-{h{kC68Ju<4nB24-BhSlTp{YTrKUu1nR;Fh#QimE@fcsSVSSjd<5y^Jxd0q`rApV8Y&l%kC~Trmb6Gz-*yaqYp+#G@lyRs{E;ph_&W
zsO}bQ(CBn}{KF@ogqEIN6W}q-X>?GKR4$==THHZey@REQ^CxuSt2B>aFf*454)ANJ
z2i@||c%A}+36T(xk7C6&RknkU0zfZN#D76h;Yof5?YG)CfJJ}5Tslx1|L!I;(SrxE)mEoYW;=0|+|
zejr~YIihO@2!B0im-F-GYjZ}<%w=HuH%!MgUE>;x@RkLmglj8mscx@Sr`~+`Yh^8`
zDslZ)1zEcnG}u#^eYXjU6%3qx2J0$Klz`^SL7IuJ9XfQzAj$(Kz-cr|F<&ar=gT%U
z07fuPC;M_G6aGCsj7YD#TTyeW{F;hx)h1T#>7uIGt|l+)rs10Aqg&G~^6wzOW6h*P
z+{rDe7Bpa1aeIt>v@*G0UCF^#VTrDWtTemLfsViou*KUXnix*cq89n5u(p~-;F_=
z*Cl~mWl8P$T<#OYh;nMdoHZGkl3s#NtVws>_{i3@NXnkhh_WXI`7qIQB6PwJl{&u=
z3FVl)DS(FYvcbBMV_@&u=)I2)!`D-xM1E{*Bymwr9keOgc$x{vY|g39;V
zP{7uROvl=D*?=KptY<^uzK(?WuvVHXl^v%HyA-aLN9Ef(2^O{u!_?Q;aVgn4u*Og<
z-A+^EvRJ%`XH8mLkxQf%8-rob$YSv2`C$x;)0L_$e{CCXRbsfA0?Kt@?0yCJ_N{O<
zO`0q^i>=S;#&Fi`cf4ks&MzJG{bFFM)2UyNRTDaxaF<~MbR3G>X$)gHEdpPbG
z>3E%XQ|Wtv4V+zQHs~w^8)lu32d!$dHaF2L7<1wtM2#Vyo^A}%AJFIZ{9LZN4-j;3
zPS;Agf~groZl9uqW?|KAlSBwHG|d1E>YpCQB(JO2@4oxg;-b0?7VL5-msemgfWMrT
zU)LqYF3Ls3g{I$98-;Ryg-yFZgWh@LI*8d)x!d`&+VcF^^X$zJ0
zy)_bhPR1#=WS^{YM^Llq`!tAyA_t(1L8whpN<;U`VPrTT!6Z&$i7)uUHo7by!|}Ew
zafn$THm0~{V08myY&R%w&(ewOL2RC#KaIU^9^pT2SZGg1^+D87`(O3rO%xxM{n0UZ
z-cV1UR*lVd1ZI7CDAF*Xu5J{JXSZWWIl+$|?&aLgn45Gb+Dp!Hl{#Gc_v~|FRLY
zv`OUESlV6@volQS*ygD*<7{==W4C-u)HS?(e>4!Yr!6D-G*bY?{V3-Q3J%u@^XOs)%G1Bo!?@Pm^W=jvsb4a8#z+kL!BPEdzmlh54I)Z
z?@d)#?0N}39J*{+Z${6D^4f&_4g55>arf-5r)C>E@4$bPN%y07vqn`7E8f@z=FWM1
zJT{2oWrkK&K$&)GC%tn7XU~=$c6q4BXZx;ud$#W|$6I5IA~y1_8-Hay0w?9}l{=wqs-0U>ac`&%jX<{bm_I3!wFQ61Y6l*rZ78y}
zpDB|DkB99Uvtvc}!F1Z=k?D=e_R__@Fq4R12{Apy^D-YpXTl$}oYt+f{Xt1=dE0q~
z<{8BiqO+qohK`4t^3hbSMKJ;EvGlA!CbU^W&vDXk>(in^8q}>d@6%cmH%4j4yiaaJ
z{br=^o{Bdq+2^j3IKTAXC(as&AznzQu!lM3W(wM3n{r(m>-7dPbZS5n=
z>}+TJLRSBA%rPvI^MWruuH|0OJqRuGlAf~h)tbKVWXf_dZQ)&Nv~G+XXuq=+0sq|h
zCvC=jNtHoIlBIt(?nC>-ZE5{w^eo+YK-295tGS#k>9TGX@;4ZgVp~eFB+I6zBi__Z
z{~E3}yv!c9ZP;nI{BD_ycQqpGmi_zH7{1UAH-NEQ@&?7fWad71G2`$JV_986$`mI0
zm}qcVY9>EfdxngtMB@2@xPy*4#fC|XXqEOG@n+Izmy{b!pEx~AOSYjct$;Sn`?8p-yq?aXpzY4W?u64*mnZgoqMel>!2`bnaz>+9-J!#b`;
z8J5vnS9Q`d;&vUQ57rCY1qwy(L`J4jsq$dLmpC3l(7!l^zRp2AC5ULccx^VloG#hx
z@}wVM__N(;d}rtui`KV2mGBPw4zux;SsL8IeV;?4TrWKvu8sgv)5bRR!0lVC*cd!RjY>+>(JlnBf4#;}Q7fje{;r
zdYq79=(D^5bfb&(T5iKJ_8R^x)+X{+q5xs
z0utr<&}RB!WG+2RSLhh=bsN`WNcuMvO;i3gezjo4*NmvR=CbH7LY<91O@HaT=vfSA
zi5Xfk|1?%J53wNuHiC*X0o^(-nn*E}&}p-?6tw#>aGs%MbE5@Nox|qbK(
z;Exe7<5FeI>36!#EfB;&*gT8-Y%JY`FwC#bQ%uFjHb(z>u!7gN;Q}QrEF4z&RLZQh
zusnoA&N13-_^k0Me`QrB->fkr*V#{6pj_Z-Y%VY0rxornchxvtrMUjV;FYZz?lo+;
zlsMax3)cv1_@Tt99_GbQwgIbI-od?vyB{sb(c9A*I0)O*37a}_pbY={5GA7(qg+&
z8_)tB2F8yTUB;Nu|MvM=W!}WSdzUCMp!215yk<%X9E)TzZErrN;;rqNsM~3IDIISg
zjpN=4p0;o1NRY>LG_3bL$1Twqj&SNJkVR~PFF=LGTANsRuc?IMKasupnOds`{~iw|
ziDN-$wie;fuuPFv<38_KMTX5|<;lr*t#;hC&e9y`J#p!MVcB8)KW_b4WpV~OTE_s=fR!oRi3%nTfOTHfIgYsI2=n0NAzA{Jj@cV0p0
zgEMx1LNxS8bwixU+iu~0%ccCD`2G^~+LNpvxDQ7-LVCmC@SvBr(`gg~3EgImXtaE2
zH{59#{%sCI`@`eU80w=)N7!Kb?B$u6JbT)2h-cx6dvdTLpL=xb)o)}918nMkgVzf5
zdCC%uFSr*tkK=q7eY!DS*LpMs6>wVeW4Ksfp!IQ(8lc&v9R
zZJ(<>KOnI$wYz;K{pH*(sv&$)HIzGYZ?jxYA=>fduO5KI1_VmdCuAMa2#r0fThcF2
zy?W|fAzVTXkC?S*C@%ZJ746jEKZxJwjvs%@r#NWy1IR8+Jv!B3G{sG9j8Wk0eXvDn
z?dJF1d?
zgI|*!p$8?pSdisH(NN|ygu^+M8tq9t%A9kC#l6OP0cF}A?jZC~u8-x~y8v<~cne
zn*k1dE1}bK!#odO*gk0MMx|*vjq=A^xl$?Ds$EsP0S^>i1yP!-UG;gHimK-)7CKnN
zu(L3+S(qr;<>vKv?)^DT+krcpvw$oyIFClTGkm*amhx^JYeBBil!*(Gxq-E>`)P;B
z$7D->uS9gUYp9@HcR^W}UQQ3`hE!zvA*o=n?-~W^9(s_F`|O)@H2cc%@3z@2Ar4ZV
z0e!UTbg}^X@9%wYS2Z>a_2CGj`!_ZQfHEI?h>b`aA#}DK^6eto!x@|nV`U5aH0QfA
zkUsr(kU=U@$$}Pz@6e*|-?CUZMb6?utn|~i&DUN3DM|fGztu@wivdotR`4h76gPdjMni4OX
z>a--PMp>cLnN^;zQbh>NMMD*(Y1I^Y=`~4hzZGcuT}i`b$(l5W(YkVoAC{wJKX(^*
z4oBQPVIzNVkZ7v{jm1>9TCl(`s+)pnNnVciO@;@|6)_eT8Z9S2znzM9=w`OK
z7QrryXTwc!ZCKMDU_(p8pU%EBYaS41TWeH1@=FJ2DEa_DLP(d^(~X0Y|9&-B$f-rI
zcuNE*z{oj^fxf}BQ~SU=&fzdeVS2ajx4zbU>QMu@Y_(CPTBc3Vggw(lfw
zXYkm`aeJCGl;O5#ut8SauJ0_c1}ymPiR=ZD`yQ7E-oogY!)Onp^lW_WHdGG2D(NB-
zZ<9*5pOFi?3@YmxIUW;SK+B*w7+-@ix0owhX-1iH)@4at7gS+gl;q9WLi$ge;wcgS
znIt)%Vldsi-|Bgw<1wMLO}3t^@YVijKAD}P=S%P%LcjRs%)~r=h!Y;hEw0~D+8%8S
zO<#~F?iF9X?Ja;1DZ|K{5w?i^&^xEy%S$1BYsaTL?Ox6*Rp&xgr@EWCE89*4@m8xsRD-i)F4
zkRje82)BsFj_^tk{cmOB^_y|L4Z-bylzbRMyi%O_a-gmBLt6{R;NBoAH_~!|*=rMI
z0@{F9!cBCZ2H~Ej&@-cz1r`KHE0`V$q*@!ZwdRTMCJViLN<2%0Tc){99JMA3Hgg*l
z&RLE#1MRT|iPVTJepexqu+B2$8RwYJJG~~*gbjx1tne^4RAGRqe@YaYABz1G#Z6JE
z3*ryi1cAbKAHziiqArNeK|xj`e>k?WKy!g!M^`=s%P(jl0kHeVYIVDVCR(cH-^LWX
zD|Di`2GIYT(Hg$L`af6Smu&p+pq6-$&KQIG`Ab_g{p;t>ttDEYMbqmqo~A)nPGG8?
z(euF|XABvKmhYE?0MCeq294^!nr1yz7RO{mNA&j3)&SnP+4(VgF4L3yV{e)DF9aaE@)FV0QS5f*HlN8Hdu?^
z#TxVrDoaWEh(DhOTAe7=6#y0f`_#1bjd%;}_>9^hpWSxxd^S+cd5QG=MY}uWyLFcP
zmac)twAdI4HwFX#TlUN3BHxHslQgUFEoi~^!w7FSp|Gv51~vQgZ!UL{#c+Z66wmxhzBOXs#@nx
zVdQ9kc$m~Ku)rtipymS+YuVr$6?Qwi7=>?bi%FZR&
z%c`HLesL@*ws7v;=5RsA;GYCLxe`XJobYE<(5DxJKMnp8)~RCPcKcyN!b<}UkjNY~
z;IQ}E$`|~^z)K9G^9=I+*qRyV$M6F|tSi!4K@^2gN(-k?Z!%y@Y$~l_Cr@KEz%1}f
zbWY~FGz~DQ#tRE<2eddw#-xQU3BN7>Dso*&5$o3rUl@rZ8-k>vP_toba!&G@VX6{PQ}_MNv?ju;=0b2`%p!_4)ZV_~&TmSTvpY
z|6B9-hqk70Jf}A1RzAcX$y!~TMlWI1-HhY>
zYnDcrnr!8OHHH!*)Lv%Qyeg+9zs6p-#VRuoTDD)bqCy@9#DX@cNmxHEwWj
zW(j!x`q+x@crZ!a21xoc6SInKHr-5%)_BeSIs@{z)9K$Ii`&xtR2yy!ZCnbZJ(n)?c=3utWa{v=5!p@5PmqCvBYg1X`
zl`XTxvn)%it?2F%lAS~TPjr(wq++|(s%ux^(A14w?tTrfR!d&B>XoW+O*3=3SYCO!
zz!%Gtm3(EgZ1I{=wDN^g*0rclN4e&2*(%%o)>+*<@w;@Tynh!o`k}e#{{-4&47Bp~
z&>}O{%Iy5~q*TaTMML8)zjZ}kGqbLx{7w654F6bJ>$h%Sl+*rKM{ZI)^76jX8xpP0
zL%-P(ztYraxZmZtRJPvkeD<2y9ksB33Ev%e)m`|0NKcjaeB
zrOI^|^W#`QoZwubDMrRniPCJeWd+mm^>I3ob;5yaCt*@l6dikAw|+nni7Av=9hYZ)
z+3E-BGJ%VoNh+ukU#k`OS7^_gV|UbqL=Iy;Cg>P4!FA{e62|p~2VtP|!Cv2u>e^v3
z5u6WkJN?ym*aU1C426oU1O-Hr(EZk)s_O=Q+%AEJLPVh^7p%q=*I&_STrpp^!9c9b
zn+cF7**hLmO(~EQmHkD}F?s2TCKp=e`s(!b>J_VX0!pN=*uFm;+vddeKMFIAQ0Tjx
z5fp+6Kpd#McI@S~8ZW7Zc+C)eS993gl35iq-t8t9n`eCKd{z!cgF+r*cL;xYxrP$aGo=3!ubx5!wpeX!+c
z{prg%QASH8v|HGd%dBofdx?)8N-*O`d0A4Fylv+-Rm9Q+3SSZhg}+)fcu5wDa7?7|
zktCNs%`3c6nkb2;F36HlEEfynp4hR>ZgYv;C=KA+>qo=v5~22OuOBs}pK)y{&Oa=b
z%V0ki71kD;C&ve_45!4cnj#nNf=Wcw03-=^#V!n9O2~#fXxF`LD#eTzWyo=YE+;ag
zDxUNslw>hUhyR^TK`aAG;NLO}DT(G70=zHNs%|4;ejo@WbRi|qhGPENEntVuaHM0i
zp)vaeY>6x^MX|ViqAjDeVkmUOKOfV(ahy7U9<^bb&Di}eQ{nmiSp6?U6UqrPFWM6&
z30P7Q`JzKRVRS6B+nngf&a?6N<=ksA7n}nFZolWH$6IJBAhMqro&f_v=Ud6>knw9P
zGB4N5vSOF#aeRhB+Jc(`)|KN+LA^e}M71+Q2fb0&Y+KOG1MQ^N5O4Uo5;rHjz;vjj!^_)UC*V}
zhL+GtC;Me0yn}Gri=Wkr{~T5^N+Ia;Jg*312^gOUhNx;NKNLlj`0IjWN#rF0&lF+6
z=2Hy&v?vx}3>Tme>ZS;TxWJ1bjr{{Tx)~e)!m)i6439Xr55fJ$GzySqzn-sUPhK*?VRg;uWg5Syj20KjhGl?;y
zO4m0HM@ZTn9C-hrRhax*h8-5r>B^naD8o+No+g=t%vQu0Vn1Sz_Zzn4`kk7QiO#S?
zYchcU&JhhtF+q=OFb-)a6dB9D+@4lrn44QsaBRD?%FS~JW6@(-)E(XYOwe;gD>Q)q
z+z>-FDd#Xh<_;+~mR-6%#YQtzw<6Xk_A0h{C#@Z|6(fL|^4T}IC7cN!V%ho=tVc!g@^PN~HjAhCL-vA*Z^2)N0zCbsXsUn+Q#`0h
zmbB+U5f0a7u_ztaz9p)rcv=!yq@pPA$rVNEv}}pW%{rH?UtUkwFAoB?%YNTjjn6k<
zFPY-;Hhy&lKPARyl`T=ad5;K+2;7oRi^=&^oIA!fz~N`$lZkcc{f46?zS?SJ&*#38
z#J{f@v1wyFg7aG>0ZXVCDcs+37R4xLF^iTj{*wqgl=!dUomU~=4t)>aES{6ZtMOAW
z$4z_k(rE}ht{9hl66&9Cw~$!>MJ2kLshd2o^j{w~*Q%kM8O6@d+YeunXY*OLw2hjs?MdP*S5}?(J#?wX-?gUAy>BcDD
zbS@53fcNQ)F_A@R6-Io;;&R!7
z|9)7)Gc-2)%R=O&O=Tqm)ehdz59G<`WYNYqN0RPk%lczt;q1e%v_`2h&@ie){oQaV2Hua{=m%l5HumGGn{V3T`(FfEQv|t}!A0#r
z5yGD0q!H+d;vWg3DE^@+roR0?xT?Tk$m>P!t5lvbK}|`9`2ePPMZEW3Nt5mu#rp-}
zHw1z2^#s`v)_8u6SHix+eHGpSzqeT)Op0J!zL@?2DI{MQ{{D~s-(xj%x}3Fz0rio-s@Yc5?Vc`~B
zxiNVfYp2D&X%F-PZ{W%=^ZY&c@Zn2tN}iJ3HXw!V48KX&2GS<^nNj-#SFRF*_e=P-
z8l=BK{ZHdX6Q6&5F*^PyNa0=eWEf@itlb5&JeE69?7#@C;EK
z@SMdxM^`^?OS5kacnU)iaQyweI>>t?NXqSa??Xwkzdv~z_Os_GO)|J31>*pbQ@IqSC6dL>E{2g)Ab6Xq-&OW9%E%2
z!qavCW_|S_y(fuvA~f(OJfX$(YP1oyun@A%fo%1ki`Gu-cK0ah
zC