refactor: refactor stable diffusion service, add service pool support

chore: add sub dir support for OSS
refactor: add midjourney pool implementation, add translate prompt for mj drawing
2025-10-25 19:33:44 +08:00 · 2023-12-14 16:48:54 +08:00 · 2023-12-13 17:02:49 +08:00 · 2023-12-13 16:38:27 +08:00 · 2023-12-13 09:49:55 +08:00 · 2023-12-12 18:33:24 +08:00
308 changed files with 29598 additions and 4951 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -0,0 +1,196 @@
+# 更新日志
+## v3.2.1
+* 功能优化：切换角色和模型的时候自动创建新的对话
+* Bug修复：修复文件上传失败No such file bug
+* 功能新增：MidJourney 绘画页面新增提示词翻译功能，新增多个绘画参数
+* Bug修复：[PC端对话在刷新后异常](https://github.com/yangjian102621/chatgpt-plus/issues/59)
+* 功能新增：增加 arm64 架构打包脚本
+* 功能新增：支持 dall-e3 绘图的 API 地址自定义配置
+* 功能新增：新增虎皮椒支付功能接入，支持微信和支付宝通道
+
+## v3.2.0
+* 功能新增：新增邀请注册功能
+* 功能优化：增加中间件自动对HTTP请求的参数去掉首尾空格
+* 功能优化：增加中间件自动为大图片生成缩略图
+* 功能优化：MidJourney 页面图片加载优化，实现图片预览懒加载
+* 功能新增：新增 DALL-E-3 绘画支持，并作为对话页面默认绘画插件
+* Bug修复：修复阿里云 OSS 域名设置不起做用的bug
+* Bug修复：修复MidJourney绘图失败后重复添加到队列的问题
+
+## v3.1.9
+* 功能新增：增加讯飞星火大模型 v3.0 支持
+* 功能新增：新增找回密码功能
+* 功能新增：支持 Markdown 代码复制功能
+* Bug修复: xxl-job 任务调度失败的 Bug
+* 功能优化：优化前端页面菜单图标，使用自定义图标替换 icon-font
+* Bug修复：Stable-Diffusion 绘画成功之后没有扣减用户画图次数
+* 功能优化：优化会员充值页面 ItemList 组件
+* 功能优化：给首页 Logo 增加链接
+* Bug修复：[新建会话时，提示"请输入合法的手机号" ](https://github.com/yangjian102621/chatgpt-plus/issues/51)
+* Bug修复：聊天上下文失效问题
+* 功能优化：关闭注册时显示联系管理员二维码
+* 功能优化：移除 leveldb 依赖，使用 redis 替换相应的功能
+* Bug修复：后台启用用户 VIP 不生效问题
+* 功能优化：充值支付页面的支付说明文字可以后台配置
+* Bug修复：ChatGLM，百度文心，科大讯飞模型输出代码不换行问题
+
+## v3.1.8
+
+1. 功能新增：新增会员套餐充值，点卡充值，订单系统，集成支付宝支付通道
+2. Bug修复：修复 MidJourney API 参数版本更新导致调用失败问题
+3. Bug修复：修复 Stable Diffusion 调用后没有更新绘图调用次数问题
+4. Bug修复：修复七牛云上传报错 expired token
+5. Bug修复：修复高权重模型导致的对话次数为负数的漏洞
+6. 功能优化：将聊天报错信息定义为统一常量，方便修改
+7. 功能优化：优化 markdown 表格显示样式，覆写 Element-Plus 表格样式
+8. 功能优化：增加倒数计时组件，定期自动清理未支付的订单
+
+## v3.1.7
+
+1. 功能新增：支持文心4.0 AI 模型
+2. 功能新增：可以在管理后台为用户绑定指定的 AI 模型，如只给某个用户使用 GPT-4 模型
+3. 功能新增：模型新增权重字段，不同的模型每次调用耗费的点数可以设置不同，比如GPT4是GPT3.5的10倍
+4. 功能新增：新增系统配置关闭 AI 模型的函数功能
+5. 功能优化：优化 MidJourney 专业绘画页面图片预览样式
+
+## v3.1.6
+
+1. 功能新增：新增AI 绘画照片墙功能页面，供用户查看所有的 AI 绘画作品
+2. 功能新增：新增 AI 角色应用功能页面，用户可以添加自己感兴趣的应用
+3. 功能优化：优化瀑布流组件的页面布局
+4. 功能优化：新注册用户成功之后自动登录
+5. 功能优化：优化更新对话标题的操作体验，绑定回车事件
+
+## v3.1.5
+
+1. 功能新增：新增百度文心一言大模型 API 接入支持
+2. 功能新增：新增科大讯飞星火大模型 API 接入支持
+3. 功能重构：将 chat_handler 的所有功能实现放入单独的包中
+4. 功能新增：新增系统配置 `enabled_function` 用于启用和关闭函数功能
+5. Bug修复：修复管理后台更新 API Key 失败的 Bug
+6. Bug修复：修复新建的对话无法更新对话标题的 Bug
+7. 功能优化：其他一些小的体验优化工作
+
+## v3.1.4
+
+1. 功能新增：新增阿里云 OSS 图片上传实现，目前已支持本地存储，七牛云，Minio和阿里云 OSS 四种存储介质。
+2. 功能新增：**增加 Stable Diffusion 绘画功能页面**。
+3. 功能重构：将 [chatgpt-plus-exts](https://github.com/yangjian102621/chatgpt-plus-exts) 合并到本项目，部署更加简单，无需部署两个项目了。
+4. Bug修复：修复[用户注册报错BUG #37](https://github.com/yangjian102621/chatgpt-plus/issues/37)。
+5. Bug修复：修复 MidJourney API 接口升级导致图片文保存失败的 Bug。
+6. 功能优化：增加阿里云短信服务配置项 `Sign` 和 `CodeTempId` 用来配置自己的短信签名和短信验证码模版 ID。
+7. 功能优化：添加系统配置用来设置自定义的众筹微信收款二维码。
+8. 功能优化：优化绘画页面的弹窗样式和页面布局。
+
+## v3.1.3
+
+1. 页面重构：重后 Home 页面，拆分成聊天，MJ绘画，SD 绘画，应用广场等多个功能菜单。
+2. 功能新增：新增 MidJourney 专业绘画页面，开放更高级的 MJ 绘画姿势。
+3. 功能优化：采用队列的方式控制绘画任务并发，简化任务回调通知逻辑，给任务回调加锁。
+4. 功能优化：精简用户表字段，删除用户名和昵称，只保留手机号。
+5. 功能优化：优化文件上传服务工厂实现，只创建激活的 Uploader 服务，节省资源。
+6. Bug修复：修复 JWT token 有效期计算错误的 Bug。
+
+## v3.1.2
+
+1. 功能新增：新增七牛云 OSS 实现，目前已支持三种文件上传服务：Local, Minio, QiNiu OSS。
+2. 功能新增：新增桌面版，使用 electron 套壳网页版。
+3. Bug修复：自动去除众筹核销时候转账单号中的空格，防止复制的时候多复制了空格。
+4. 功能优化：ChatPlus.vue 页面支持通过 chat_id path variable 来定位到指定的聊天。
+5. 功能优化：取消导出聊天页面的授权验证
+6. 功能优化：所有路由跳转都使用绝对路径
+
+## v3.1.1
+
+紧急修复版本，采用弹窗的方式显示验证码，解决验证码在低分辨率下被掩盖的Bug
+
+## v3.1.0(大版本更新)
+
+1. 功能重构：将聊天模型独立拆分，以便支持多平台模型，目前已经内置支持 OPenAI，Azure 以及
+   ChatGLM，用户可以在这两个平台的模型中随意切换，体验不同的模型聊天。
+2. 功能重构：重写系统 API 授权机制，使用 JWT 替换传统的 session 会话授权，使得 API 授权变得更加灵活。
+3. 功能重构：重构文件夹上传服务，支持多种文件上传存储handler，目前已经实现本地存储和 minio oss 存储。
+4. 功能优化：更新头像自动删除旧的图片资源。
+5. 功能优化：将应用日志在终端输出的同时存盘，方便 docker 部署查看日志。
+6. 功能新增：允许用户配置自己的 OPenAI，Azure 以及 ChatGLM API KEY。
+7. 功能优化：优化移动版的行为验证码样式，修复低分辨率显示器验证码被遮挡的 Bug
+8. 升级 gin, element-plus，redis 组件到最新版本。
+9. Bug修复：修复若干已知的的 Bug
+
+## v3.0.7
+
+1. 聊天主界面：新增聊天引导页面，介绍产品功能
+2. 功能重构：拆分项目，将函数插件以及微信机器人，MidJourney 机器人等功能拆分新项目独立部署。
+3. 功能新增：新增 MidJourney AI 绘画支持，当识别到用户的绘画需求时，自动调用 MidJourney 绘画函数进行绘画。
+4. 功能新增：支持导出聊天记录为 PDF 文件。
+5. 功能优化：在后台 dashboard 页面新增统计今日众筹收入。
+6. 功能优化：支持用户设置默认的 GPT 模型
+7. Bug修复：修复若干已知的的 Bug
+
+## v3.0.6
+
+1. 管理后台：新增用户名和手机号码搜索功能
+2. 管理后台：新增重置用户密码功能
+3. 管理后台：支持关闭注册功能，新增添加用户功能，适用于内部使用场景
+4. 管理后台：新增仪表盘页面，统计当天的新增用户，新增会话数据，以及 Token 消耗
+5. Bug修复：修复注册页面验证码不显示 Bug
+6. Bug修复：优化上下文 Token 计算算法，修复聊天上下文超出限制时循环发送消息的 Bug
+7. 功能修正：允许用户使用手机号码登录
+8. 功能优化：更新系统配置后同步更新服务端内存变量数据
+9. 功能优化：优化打包脚本，减少容器镜像大小
+
+## v3.0.5
+
+重磅功能更新！！！ 新增函数插件支持，可以轻松地接入你的第三方插件服务，ChatGPT 自动帮您调用对应的函数完成任务。
+
+1. 新增函数功能支持，全球早报，今日头条和微博热搜等插件服务，您也可以接入自己的第三方服务。
+2. 集成微信机器人模块，可以通过微信个人收款码来完成充值，无需接入微信支付功能也可以完成收款功能。
+3. 用户注册添加短信验证码功能，引入交互安全认证服务，有效防刷短信。
+4. 支持配置聊天上下文深度，精确统计每轮对话所消耗的总 TOKEN 数量。
+5. 修复已知的 Bug。
+
+## v3.0.4
+
+1. 调整项目目录结构，移除其他语言 API 目录
+2. 修复 nodejs apple M1 跨平台打包，运行报错 exec format error
+3. 增加用户 token 消耗统计功能
+
+## v3.0.3
+
+1. 优化启动参数接收处理，支持环境变量传参
+2. 修复 PC 端聊天界面出现滚动条的 Bug
+3. 修正前端 user_init_call 字段错误和用户注册初始化头像路径问题
+4. 更改 docker 构建镜像的基础镜像，改用作者的阿里云镜像，这样打包更快一些。
+
+## v3.0.2
+
+1. Feat：新增移动端的聊天和用户设置功能
+2. Fix: 修复 markdown 换行符解析的 Bug
+3. Feat: 新增头像上传功能
+4. Docs: 增加容器部署支持，支持 docker-compose 一键部署
+5. Fix: 增加全局错误处理 handler，修复业务处理异常导致服务退出的 Bug
+
+## v3.0.1
+
+1. 紧急修复前端 Home 组件路由被后台管理 Home 组件路由覆盖的 Bug。
+2. 增加 docker-compose 部署脚本
+
+## v3.0.0
+
+全新的重构版本！！！
+新版的系统前后端都进行大改动的重构，后端还是用的 Gin Web 框架，但是作者整合了 fx 自动注入框架，整个后端应用结构非常简洁，特别适合二次开发。
+另外，数据存储用 MySQL 替换了 leveldb, 因为要对 C 端，后期会涉及到很多业务数据查询统计，leveldb 已经完全不够用了。
+前后台技术架构还是基于 `Vue3 + Element-Plus` ，但是页面风格已经全部变了，几乎所有页面样式代码都重写了，希望会你是希望的风格！
+
+此次重构改版主要是为了后面功能的扩展准备了。
+
+新版本已经实现的功能如下：
+
+1. 引入用户体系，新增用户注册和登录功能。
+2. 聊天页面改版，实现了跟 ChatGPT 官方版本一致的聊天体验。
+3. 创建会话的时候可以选择聊天角色和模型。
+4. 新增聊天设置功能，用户可以导入自己的 API KEY
+5. 保存聊天记录，支持聊天上下文。
+6. 重构后台管理模块，更友好，扩展性更好的后台管理系统。
+7. 引入 ip2region 组件，记录用户的登录IP和地址。
+8. 支持会话搜索过滤。
--- a/README.md
+++ b/README.md
@@ -1,44 +1,76 @@
 # ChatGPT-Plus

-**ChatGPT-PLUS** 是基于 OpenAI API 实现的 ChatGPT 聊天系统。主要有如下特性：
+**ChatGPT-PLUS** 基于 AI 大语言模型 API 实现的 AI 助手全套开源解决方案，自带运营管理后台，开箱即用。集成了 OpenAI, Azure,
+ChatGLM,讯飞星火，文心一言等多个平台的大语言模型。集成了 MidJourney 和 Stable Diffusion AI绘画功能。主要有如下特性：

 * 完整的开源系统，前端应用和后台管理系统皆可开箱即用。
-* 聊天体验跟 ChatGPT 官方版本完全一致。
-* 内置了各种预训练好的角色，比如小红书写手，英语翻译大师，苏格拉底，孔子，乔布斯，周报助手等。轻松满足你的各种聊天和应用需求。
+* 基于 Websocket 实现，完美的打字机体验。
+* 内置了各种预训练好的角色应用，比如小红书写手，英语翻译大师，苏格拉底，孔子，乔布斯，周报助手等。轻松满足你的各种聊天和应用需求。
+* 支持 OPenAI，Azure，文心一言，讯飞星火，清华 ChatGLM等多个大语言模型。
+* 支持 MidJourney / Stable Diffusion AI 绘画集成，开箱即用。
+* 支持使用个人微信二维码作为充值收费的支付渠道，无需企业支付通道。
+* 已集成支付宝支付功能，支持多种会员套餐和点卡购买功能。
+* 集成插件 API 功能，可结合大语言模型的 function 功能开发各种强大的插件，已内置实现了微博热搜，今日头条，今日早报和 AI
+  绘画函数插件。
+
+## 关于部署镜像申明
+
+由于目前部署人数越来越多，本人的阿里云镜像仓库流量不够支撑大家使用了。所以从 v3.2.0 版本开始，一键部署脚本和部署镜像将只提供给 **[付费技术交流群]** 内用户使用。
+代码依旧是全部开源的，大家可自行编译打包镜像。

 ## 功能截图

-### 1.PC 端聊天界面
+### PC 端聊天界面

-![ChatGPT Chat Page](docs/imgs/gpt.gif)
+![ChatGPT Chat Page](/docs/imgs/gpt.gif)

-### 2. 新版聊天界面
+### AI 对话界面

-![ChatGPT new Chat Page](docs/imgs/chat-new.png)
+![ChatGPT new Chat Page](/docs/imgs/chat-new.png)

-### 3. 用户设置
+### MidJourney 专业绘画界面

-![ChatGPT user profle](docs/imgs/user_profile.png)
+![mid-journey](/docs/imgs/mj_image.jpg)

-### 4. 登录页面
+### Stable-Diffusion 专业绘画页面

-![ChatGPT Login](docs/imgs/login.png)
+![Stable-Diffusion](/docs/imgs/sd_image.jpg)
+![Stable-Diffusion](/docs/imgs/sd_image_detail.jpg)

-### 5. 管理后台
+### 绘图作品展

-![ChatGPT admin](docs/imgs/admin_config.png)
+![ChatGPT image_list](/docs/imgs/image-list.png)

-![ChatGPT admin](docs/imgs/admin_user.png)
+### AI应用列表

-### 6. 移动端 Web 页面
+![ChatGPT-app-list](/docs/imgs/app-list.jpg)
+
+### 会员充值
+
+![会员充值](/docs/imgs/member.png)
+
+### 自动调用函数插件
+
+![ChatGPT function plugin](/docs/imgs/plugin.png)
+![ChatGPT function plugin](/docs/imgs/mj.jpg)
+
+### 管理后台
+
+![ChatGPT admin](/docs/imgs/admin_dashboard.png)
+![ChatGPT admin](/docs/imgs/admin_config.jpg)
+![ChatGPT admin](/docs/imgs/admin_models.jpg)
+![ChatGPT admin](/docs/imgs/admin_user.png)
+
+### 移动端 Web 页面

 ![Mobile chat list](/docs/imgs/mobile_chat_list.png)
 ![Mobile chat session](/docs/imgs/mobile_chat_session.png)
-![Mobile chat setting](/docs/imgs/mobile_chat_setting.png)
+![Mobile chat setting](/docs/imgs/mobile_user_profile.png)
+![Mobile chat setting](/docs/imgs/mobile_pay.png)

 ### 7. 体验地址

-> 免费体验地址：[https://www.chat-plus.net/chat](https://www.chat-plus.net/chat) <br/>
+> 免费体验地址：[https://ai.r9it.com/chat](https://ai.r9it.com/chat) <br/>
 > **注意：请合法使用，禁止输出任何敏感、不友好或违规的内容！！！**

 ## 使用须知
@@ -46,319 +78,34 @@
 1. 本项目基于 MIT 协议，免费开放全部源代码，可以作为个人学习使用或者商用。
 2. 如需商用必须保留版权信息，请自觉遵守。确保合法合规使用，在运营过程中产生的一切任何后果自负，与作者无关。

-## 项目介绍
-
-这一套完整的系统，包括前端聊天应用和一个后台管理系统。系统有用户鉴权，你可以自己使用，也可以部署直接给 C 端用户提供
-ChatGPT 的服务。
-
-### 项目的技术架构
-
-新版的系统前后端都进行大改动的重构，后端还是用的 Gin Web 框架，但是作者整合了 fx 自动注入框架，整个后端应用结构非常简洁，特别适合二次开发。
-另外，数据存储用 MySQL 替换了 leveldb, 因为要对 C 端，后期会涉及到很多业务数据查询统计，leveldb 已经完全不够用了。
-
-> Gin + fx + MySQL
-
-3.0 版本之后会陆续添加其他语言的 API 实现，比如 PHP，Java 等。考虑到作者精力有限，api 目录已经添加了，有兴趣的同学自主去认领各自擅长的语言去实现。
-
-前端的框架还是:
-
-> Vue3 + Element-Plus
-
-前后台的页面风格已经全部变了，几乎所有页面样式代码都重写了。逻辑代码还是沿用之前的，毕竟功能没有太大的变化。
-
-此次重构改版主要是为了后面功能的扩展准备了。
-
-新版本已经实现的功能如下：
-
-1. 引入用户体系，新增用户注册和登录功能。
-2. 聊天页面改版，实现了跟 ChatGPT 官方版本一致的聊天体验。
-3. 创建会话的时候可以选择聊天角色和模型。
-4. 新增聊天设置功能，用户可以导入自己的 API KEY
-5. 保存聊天记录，支持聊天上下文。
-6. 重构后台管理模块，更友好，扩展性更好的后台管理系统。
-7. 引入 ip2region 组件，记录用户的登录IP和地址。
-8. 支持会话搜索过滤。

 ## 项目地址

 * Github 地址：https://github.com/yangjian102621/chatgpt-plus
 * 码云地址：https://gitee.com/blackfox/chatgpt-plus

+## 客户端下载
+
+目前已经支持 Win/Linux/Mac/Android 客户端，下载地址为：https://github.com/yangjian102621/chatgpt-plus/releases/tag/v3.1.2
+
 ## TODOLIST
+* [ ] 支持基于知识库的 AI 问答
+* [ ] 会员邀请注册推广功能
+* [ ] 微信支付功能

-* [ ] 整合 Midjourney AI 绘画 API
-* [ ] 开发移动端聊天页面
-* [ ] 接入微信支付功能
-* [ ] 接入语音和 TTS API，支持语音聊天
-* [ ] 开发手机 App 客户端
+## 项目文档

-## Docker 快速部署
+详细的部署和开发文档请参考 [**ChatGPT-Plus 文档**](https://ai.r9it.com/docs/)。

-V3.0.0 版本以后已经支持使用容器部署了，跳过所有的繁琐的环境准备，一条命令就可以轻松部署上线。
+加微信进入微信讨论群可获取 **一键部署脚本（添加好友时请注明来自Github!!!）。**

-### 1. 导入数据库
-
-首先我们需要创建一个 MySQL 容器，并导入初始数据库。
-
-```shell
-cd docker/mysql
-# 创建 mysql 容器
-docker-compose up -d
-# 导入数据库
-docker exec -i chatgpt-plus-mysql sh -c 'exec mysql -uroot -p12345678' < ../../database/chatgpt_plus.sql
-```
-
-如果你本地已经安装了 MySQL 服务，那么你只需手动导入数据库即可。
-
-```shell
-# 连接数据库
-mysql -u username -p password
-# 导入数据库
-source database/chatgpt_plus.sql
-```
-
-### 2. 修改配置文档
-
-修改配置文档 `docker/conf/config.toml` 配置文档，修改代理地址和管理员密码：
-
-```toml
-Listen = "0.0.0.0:5678"
-ProxyURL = ["YOUR_PROXY_URL"] # 替换成你本地代理，如：http://127.0.0.1:7777
-#ProxyURL = "" 如果你的服务器本身就在墙外，那么你直接留空就好了
-MysqlDns = "root:12345678@tcp(172.22.11.200:3307)/chatgpt_plus?charset=utf8&parseTime=True&loc=Local"
-[Session]
-  SecretKey = "azyehq3ivunjhbntz78isj00i4hz2mt9xtddysfucxakadq4qbfrt0b7q3lnvg80"
-  Name = "CHAT_SESSION_ID"
-  Path = "/"
-  Domain = ""
-  MaxAge = 86400
-  Secure = false
-  HttpOnly = false
-  SameSite = 2
-
-[Manager]
-  Username = "admin"
-  Password = "admin123" # 如果是生产环境的话，这里管理员的密码记得修改
-```
-
-修改 nginx 配置文档 `docker/conf/nginx/conf.d/chatgpt-plus.conf`，把后端转发的地址改成当前主机的内网 IP 地址。
-
-```shell
- # 这里配置后端 API 的转发
-location /api/ {
-       proxy_http_version 1.1;
-       proxy_connect_timeout 300s;
-       proxy_read_timeout 300s;
-       proxy_send_timeout 12s;
-       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 Upgrade $http_upgrade;
-       proxy_set_header Connection $connection_upgrade;
-       proxy_pass http://172.28.173.76:6789; # 这里改成后端服务的内网 IP 地址
-}
-```
-
-### 3. 启动应用
-
-```shell
-cd docker
-docker-compose up -d
-```
-
-* 前端访问地址：http://localhost:8080/chat
-* 后台管理地址：http://localhost:8080/admin
-* 移动端地址：http://localhost:8080/mobile
-
-> 注意：你得访问后台管理系统 http://localhost:8080/admin
-> 输入你前面配置文档中设置的管理员用户名和密码登录。
-> 然后进入 `API KEY 管理` 菜单，添加一个 OpenAI 的 API KEY 才可以正常开启 AI 对话。
-
-## 手动安装部署
-
-由于本项目采用的是前后端分离的开发方式，所以部署也需要前后端分开部署。我这里以 linux 系统为例，演示一下部署过程：
-
-### 1. 导入数据库
-
-请参考容器部署的[导入数据](#1-导入数据库)。
-
-### 2. 修改配置文档
-
-先拷贝项目中的 `api/config.sample.toml` 配置文档，修改代理地址和管理员密码：
-
-如何修改请参考[修改配置文档](#2-修改配置文档)
-
-### 3. 运行后端程序
-
-你可以自己编译或者直接下载我打包好的后端程序运行。
-
-```shell
-# 1. 下载程序，你也可以自己编译
-wget https://github.com/yangjian102621/chatgpt-plus/releases/download/v3.0.0/chatgpt-v3-amd64-linux
-# 2. 添加执行权限
-chmod +x chatgpt-v3-amd64-linux
-# 3. 运行程序，如果配置文档不在当前目录，注意指定配置文档
-./chatgpt-v3-amd64-linux
-```
-
-### 4. 前端部署
-
-前端是 Vue 项目编译好静态资源文件，同样你也可以直接下载我编译好的文件解压。
-
-```shell
-# 1. 下载程序
-wget https://github.com/yangjian102621/chatgpt-plus/releases/download/v3.0.0/dist.tar.gz
-# 2. 解压
-tar -xf dist.tar.gz
-```
-
-### 5. 配置 Nginx 服务
-
-前端程序需要搭载 Web 服务器才可以运行，这里我们选择 Nginx，先安装：
-
-```shell
-sudo apt install nginx -y
-```
-
-建立 Nginx 配置文件：
-
-```conf
-server {
-    listen  443 ssl;
-    server_name  www.chatgpt.com; #替换成你自己的域名
-
-    ssl_certificate     xxx.pem;  # 替换成自己的 SSL 证书
-    ssl_certificate_key  xxx.key;
-    ssl_session_timeout  5m;
-    ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4;
-    ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
-    ssl_prefer_server_ciphers on;
-    
-    # 日志地址
-    access_log  /var/log/chatgpt/access.log;
-    error_log /var/log/chatgpt/error.log;
-    
-    index index.html;
-    root /var/www/chatgpt/dist; # 这里改成前端静态页面的地址
-
-    location / {
-        try_files $uri $uri/ /index.html;
-        
-         # 后端 API 的转发
-        location /api/ {
-                proxy_http_version 1.1;
-                proxy_connect_timeout 300s;
-                proxy_read_timeout 300s;
-                proxy_send_timeout 12s;
-                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 Upgrade $http_upgrade;
-                proxy_set_header Connection $connection_upgrade;
-                proxy_pass http://172.28.173.76:6789; # 这里改成后端服务的内网 IP 地址
-        }
-
-        # 静态资源转发
-        location /static/ {
-            proxy_pass http://172.28.173.76:6789; # 这里改成后端服务的内网 IP 地址
-        }
-    }
-    
-}
-```
-
-配置好之后重启 Nginx，然后 []
-
-![add API Key](docs/imgs/apikey_add.png)
-
-最后登录前端聊天页面 [http://www.chatgpt.com/admin](http://www.chatgpt.com/admin)
-你可以注册新用户，也可以使用系统默认有个账号：`geekmaster/12345678` 登录聊天。
-
-祝你使用愉快！！！
-
-## 本地开发调试
-
-本地开发同样要分别运行前端和后端程序。
-
-### 运行后端程序
-
-1. 同样你首先要 [导入数据库](#1-导入数据库)
-2. 然后 [修改配置文档](#2-修改配置文档)
-3. 运行后端程序：
-
-    ```shell
-    cd api 
-    # 1. 先下载依赖
-    go mod tidy
-    # 2. 运行程序
-    go run main.go
-    # 如果你安装了 fresh 可以使用 fresh 实现热启动
-    fresh -c fresh.conf
-    ```
-
-### 运行前端程序
-
-同样先拷贝配置文档：
-
-```shell
-cd web
-cp .env.production .env.development
-```
-
-编辑 `.env.development` 文件，修改后端 API 的访问路径：
-
-```ini
-VUE_APP_API_HOST=http://localhost:5678
-VUE_APP_WS_HOST=ws://localhost:5678
-```
-
-配置好了之后就可以运行前端应用了：
-
-```
-# 安装依赖
-npm install
-# 运行
-npm run dev
-```
-
-* 前端页面：http://localhost:8888/chat
-* 后台管理页面：http://localhost:8888/admin
-
-## 项目打包
-
-由于本项目是采用异构开发的方式，所项目打包分成两步：首先编译后端程序，然后再打包前端应用。
-
-### 打包前端
-
-```shell
-cd web
-npm run build
-```
-
-### 打包后端
-
-你可以根据个人需求将项目打包成 windows/linux/darwin 平台项目。
-
-```shell
-cd api
-# for all platforms
-make all
-# for linux only
-make linux
-```
-
-打包后的可执行文件在 `bin` 目录下。
+![微信名片](docs/imgs/wx.png)

 ## 参与贡献

 个人的力量始终有限，任何形式的贡献都是欢迎的，包括但不限于贡献代码，优化文档，提交 issue 和 PR 等。
-**尤其是新版本的开发计划比较大，包括各种语言的后端 API 实现，本人精力有限，希望借助社区的力量来完成这些 API 的开发。**

-如果有兴趣的话，也可以加微信进入微信讨论群（**添加好友时请注明来自Github!!!**）。
-
-![微信名片](docs/imgs/wx.png)
-
-#### 特此声明：不接受在微信或者微信群给开发者提 Bug，有问题或者优化建议请提交 Issue 和 PR。非常感谢您的配合！
+#### 特此声明：由于个人时间有限，不接受在微信或者微信群给开发者提 Bug，有问题或者优化建议请提交 Issue 和 PR。非常感谢您的配合！

 ### Commit 类型

@@ -374,6 +121,9 @@ make linux

 如果你觉得这个项目对你有帮助，并且情况允许的话，可以请作者喝杯咖啡，非常感谢你的支持～

-![微信打赏](docs/imgs/wechat-pay.png)
+![打赏](docs/imgs/donate.png)
+
+![Star History Chart](https://api.star-history.com/svg?repos=yangjian102621/chatgpt-plus&type=Date)
+


--- a/api/.gitignore
+++ b/api/.gitignore
@@ -16,4 +16,6 @@ tmp
 bin
 data
 config.toml
-static/upload
+static/upload 
+storage.json
+certs/alipay/*
--- a/api/Makefile
+++ b/api/Makefile
@@ -1,19 +1,14 @@
 SHELL=/usr/bin/env bash
-NAME := chatgpt-v3
-all: window linux darwin
+NAME := chatgpt-plus
+all: amd64 arm64

+amd64:
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o bin/$(NAME)-linux main.go
+.PHONY: amd64

-window:
-	CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -o bin/$(NAME)-amd64.exe main.go
-.PHONY: window
-
-linux:
-	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o bin/$(NAME)-amd64-linux main.go
-.PHONY: linux
-
-darwin:
-	CGO_ENABLED=1 GOOS=darwin GOARCH=amd64 go build -o bin/$(NAME)-amd64-darwin main.go
-.PHONY: darwin
+arm64:
+	CGO_ENABLED=0 GOOS=linux GOARCH=arm64 GOARM=7 go build -o bin/$(NAME)-linux main.go
+.PHONY: arm64

 clean:
 	rm -rf bin/$(NAME)-*
--- a/api/config.sample.toml
+++ b/api/config.sample.toml
@@ -1,17 +1,85 @@
 Listen = "0.0.0.0:5678"
-ProxyURL = "YOUR_PROXY_URL"
-MysqlDns = "mysql_user:mysql_pass@tcp(localhost:3306)/chatgpt_plus?charset=utf8&parseTime=True&loc=Local"
+ProxyURL = "" # 如 http://127.0.0.1:7777
+MysqlDns = "root:12345678@tcp(172.22.11.200:3307)/chatgpt_plus?charset=utf8&parseTime=True&loc=Local"
+StaticDir = "./static" # 静态资源的目录
+StaticUrl = "/static" # 静态资源访问 URL
+AesEncryptKey = ""
+WeChatBot = false

 [Session]
-  SecretKey = "azyehq3ivunjhbntz78isj00i4hz2mt9xtddysfucxakadq4qbfrt0b7q3lnvg80"
-  Name = "CHAT_SESSION_ID"
-  Path = "/"
-  Domain = ""
+  SecretKey = "azyehq3ivunjhbntz78isj00i4hz2mt9xtddysfucxakadq4qbfrt0b7q3lnvg80" # 注意：这个是 JWT Token 授权密钥，生产环境请务必更换
  MaxAge = 86400
-  Secure = false
-  HttpOnly = false
-  SameSite = 2

 [Manager]
  Username = "admin"
-  Password = "admin123"
+  Password = "admin123" # 如果是生产环境的话，这里管理员的密码记得修改
+
+[Redis] # redis 配置信息
+  Host = "localhost"
+  Port = 6379
+  Password = ""
+  DB = 0
+
+[ApiConfig] # 微博热搜，今日头条等函数服务 API 配置，此为第三方插件服务，如需使用请联系作者开通
+  ApiURL = ""
+  AppId = ""
+  Token = ""
+
+[SmsConfig] # 阿里云短信服务配置
+  AccessKey = ""
+  AccessSecret = ""
+  Product = "Dysmsapi"
+  Domain = "dysmsapi.aliyuncs.com"
+  Sign = ""
+  CodeTempId = ""
+
+[OSS] # OSS 配置，用于存储 MJ 绘画图片
+   Active = "local" # 默认使用本地文件存储引擎
+   [OSS.Local]
+     BasePath = "./static/upload" # 本地文件上传根路径
+     BaseURL = "http://localhost:5678/static/upload" # 本地上传文件根 URL 如果是线上，则直接设置为 /static/upload 即可
+   [OSS.Minio]
+     Endpoint = "" # 如 172.22.11.200:9000
+     AccessKey = "" # 自己去 Minio 控制台去创建一个 Access Key
+     AccessSecret = ""
+     Bucket = "chatgpt-plus" # 替换为你自己创建的 Bucket，注意要给 Bucket 设置公开的读权限，否则会出现图片无法显示。
+     UseSSL = false
+     Domain = "" # 地址必须是能够通过公网访问的，否则会出现图片无法显示。
+   [OSS.QiNiu] # 七牛云 OSS 配置
+       Zone = "z2" # 区域，z0：华东，z1: 华北，na0：北美，as0：新加坡
+       AccessKey = ""
+       AccessSecret = ""
+       Bucket = ""
+       Domain = "" # OSS Bucket 所绑定的域名，如 https://img.r9it.com
+
+[MjConfig]
+  Enabled = false
+  UserToken = ""
+  BotToken = ""
+  GuildId = ""
+  ChanelId = ""
+
+[SdConfig]
+  Enabled = false
+  ApiURL = "http://172.22.11.200:7860"
+  ApiKey = ""
+  Txt2ImgJsonPath = "res/text2img.json"
+
+[XXLConfig] # xxl-job 配置，需要你部署 XXL-JOB 定时任务工具，用来定期清理未支付订单和清理过期 VIP，如果你没有启用支付服务，则该服务也无需启动
+  Enabled = false # 是否启用 XXL JOB 服务
+  ServerAddr = "http://172.22.11.47:8080/xxl-job-admin" # xxl-job-admin 管理地址
+  ExecutorIp = "172.22.11.47" # 执行器 IP 地址
+  ExecutorPort = "9999" # 执行器服务端口
+  AccessToken = "xxl-job-api-token" # 执行器 API 通信 token
+  RegistryKey = "chatgpt-plus" # 任务注册 key
+
+[AlipayConfig]
+  Enabled = false # 启用支付宝支付通道
+  SandBox = false # 是否启用沙盒模式
+  UserId = "2088721020750581" # 商户ID
+  AppId = "9021000131658023" # App Id
+  PrivateKey = "certs/alipay/privateKey.txt" # 应用私钥
+  PublicKey = "certs/alipay/appPublicCert.crt" # 应用公钥证书
+  AlipayPublicKey = "certs/alipay/alipayPublicCert.crt" # 支付宝公钥证书
+  RootCert = "certs/alipay/alipayRootCert.crt" # 支付宝根证书
+  NotifyURL = "http://r9it.com:6004/api/payment/alipay/notify" # 支付异步回调地址
--- a/api/core/app_server.go
+++ b/api/core/app_server.go
@@ -1,60 +1,71 @@
 package core

 import (
+	"bytes"
 	"chatplus/core/types"
+	"chatplus/service/fun"
 	"chatplus/store/model"
 	"chatplus/utils"
 	"chatplus/utils/resp"
 	"context"
-	"github.com/gin-contrib/sessions"
-	"github.com/gin-contrib/sessions/cookie"
-	"github.com/gin-contrib/sessions/memstore"
-	"github.com/gin-contrib/sessions/redis"
+	"fmt"
 	"github.com/gin-gonic/gin"
+	"github.com/go-redis/redis/v8"
+	"github.com/golang-jwt/jwt/v5"
+	"github.com/nfnt/resize"
 	"gorm.io/gorm"
+	"image"
+	"image/jpeg"
 	"io"
+	"log"
 	"net/http"
+	"os"
 	"runtime/debug"
 	"strings"
+	"time"
 )

 type AppServer struct {
 	Debug        bool
 	Config       *types.AppConfig
 	Engine       *gin.Engine
-	ChatContexts *types.LMap[string, []types.Message] // 聊天上下文 Map [chatId] => []Message
-	ChatConfig   *types.ChatConfig                    // 聊天配置
+	ChatContexts *types.LMap[string, []interface{}] // 聊天上下文 Map [chatId] => []Message
+
+	ChatConfig *types.ChatConfig   // chat config cache
+	SysConfig  *types.SystemConfig // system config cache

 	// 保存 Websocket 会话 UserId, 每个 UserId 只能连接一次
 	// 防止第三方直接连接 socket 调用 OpenAI API
-	ChatSession   *types.LMap[string, types.ChatSession]  //map[sessionId]UserId
+	ChatSession   *types.LMap[string, *types.ChatSession] //map[sessionId]UserId
 	ChatClients   *types.LMap[string, *types.WsClient]    // map[sessionId]Websocket 连接集合
 	ReqCancelFunc *types.LMap[string, context.CancelFunc] // HttpClient 请求取消 handle function
+	Functions     map[string]fun.Function
 }

-func NewServer(appConfig *types.AppConfig) *AppServer {
+func NewServer(appConfig *types.AppConfig, functions map[string]fun.Function) *AppServer {
 	gin.SetMode(gin.ReleaseMode)
 	gin.DefaultWriter = io.Discard
 	return &AppServer{
 		Debug:         false,
 		Config:        appConfig,
 		Engine:        gin.Default(),
-		ChatContexts:  types.NewLMap[string, []types.Message](),
-		ChatSession:   types.NewLMap[string, types.ChatSession](),
+		ChatContexts:  types.NewLMap[string, []interface{}](),
+		ChatSession:   types.NewLMap[string, *types.ChatSession](),
 		ChatClients:   types.NewLMap[string, *types.WsClient](),
 		ReqCancelFunc: types.NewLMap[string, context.CancelFunc](),
+		Functions:     functions,
 	}
 }

-func (s *AppServer) Init(debug bool) {
+func (s *AppServer) Init(debug bool, client *redis.Client) {
 	if debug { // 调试模式允许跨域请求 API
 		s.Debug = debug
 		logger.Info("Enabled debug mode")
-		s.Engine.Use(corsMiddleware())
 	}
-
-	s.Engine.Use(sessionMiddleware(s.Config))
-	s.Engine.Use(authorizeMiddleware(s))
+	s.Engine.Use(corsMiddleware())
+	s.Engine.Use(staticResourceMiddleware())
+	s.Engine.Use(authorizeMiddleware(s, client))
+	s.Engine.Use(parameterHandlerMiddleware())
 	s.Engine.Use(errorHandler)
 	// 添加静态资源访问
 	s.Engine.Static("/static", s.Config.StaticDir)
@@ -62,12 +73,22 @@ func (s *AppServer) Init(debug bool) {

 func (s *AppServer) Run(db *gorm.DB) error {
 	// load chat config from database
-	var config model.Config
-	res := db.Where("marker", "chat").First(&config)
+	var chatConfig model.Config
+	res := db.Where("marker", "chat").First(&chatConfig)
 	if res.Error != nil {
 		return res.Error
 	}
-	err := utils.JsonDecode(config.Config, &s.ChatConfig)
+	err := utils.JsonDecode(chatConfig.Config, &s.ChatConfig)
+	if err != nil {
+		return err
+	}
+	// load system configs
+	var sysConfig model.Config
+	res = db.Where("marker", "system").First(&sysConfig)
+	if res.Error != nil {
+		return res.Error
+	}
+	err = utils.JsonDecode(sysConfig.Config, &s.SysConfig)
 	if err != nil {
 		return err
 	}
@@ -89,42 +110,6 @@ func errorHandler(c *gin.Context) {
 	c.Next()
 }

-// 会话处理
-func sessionMiddleware(config *types.AppConfig) gin.HandlerFunc {
-	// encrypt the cookie
-	var store sessions.Store
-	var err error
-	switch config.Session.Driver {
-	case types.SessionDriverMem:
-		store = memstore.NewStore([]byte(config.Session.SecretKey))
-		break
-	case types.SessionDriverRedis:
-		store, err = redis.NewStore(10, "tcp", config.Redis.Url(), config.Redis.Password, []byte(config.Session.SecretKey))
-		if err != nil {
-			logger.Fatal(err)
-		}
-		break
-	case types.SessionDriverCookie:
-		store = cookie.NewStore([]byte(config.Session.SecretKey))
-		break
-	default:
-		config.Session.Driver = types.SessionDriverCookie
-		store = cookie.NewStore([]byte(config.Session.SecretKey))
-	}
-
-	logger.Info("Session driver: ", config.Session.Driver)
-
-	store.Options(sessions.Options{
-		Path:     config.Session.Path,
-		Domain:   config.Session.Domain,
-		MaxAge:   config.Session.MaxAge,
-		Secure:   config.Session.Secure,
-		HttpOnly: config.Session.HttpOnly,
-		SameSite: config.Session.SameSite,
-	})
-	return sessions.Sessions(config.Session.Name, store)
-}
-
 // 跨域中间件设置
 func corsMiddleware() gin.HandlerFunc {
 	return func(c *gin.Context) {
@@ -135,7 +120,7 @@ func corsMiddleware() gin.HandlerFunc {
 			c.Header("Access-Control-Allow-Origin", origin)
 			c.Header("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE, UPDATE")
 			//允许跨域设置可以返回其他子段，可以自定义字段
-			c.Header("Access-Control-Allow-Headers", "Authorization, Content-Length, Content-Type, ChatGPT-TOKEN, ADMIN-SESSION-TOKEN")
+			c.Header("Access-Control-Allow-Headers", "Authorization, Content-Length, Content-Type, Chat-Token, Admin-Authorization")
 			// 允许浏览器（客户端）可以解析的头部 （重要）
 			c.Header("Access-Control-Expose-Headers", "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers")
 			//设置缓存时间
@@ -159,41 +144,201 @@ func corsMiddleware() gin.HandlerFunc {
 }

 // 用户授权验证
-func authorizeMiddleware(s *AppServer) gin.HandlerFunc {
+func authorizeMiddleware(s *AppServer, client *redis.Client) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		if c.Request.URL.Path == "/api/user/login" ||
+			c.Request.URL.Path == "/api/user/resetPass" ||
 			c.Request.URL.Path == "/api/admin/login" ||
 			c.Request.URL.Path == "/api/user/register" ||
-			strings.HasPrefix(c.Request.URL.Path, "/api/verify/") ||
+			c.Request.URL.Path == "/api/chat/history" ||
+			c.Request.URL.Path == "/api/chat/detail" ||
+			c.Request.URL.Path == "/api/role/list" ||
+			c.Request.URL.Path == "/api/mj/jobs" ||
+			c.Request.URL.Path == "/api/invite/hits" ||
+			c.Request.URL.Path == "/api/sd/jobs" ||
+			strings.HasPrefix(c.Request.URL.Path, "/test/") ||
+			strings.HasPrefix(c.Request.URL.Path, "/api/sms/") ||
+			strings.HasPrefix(c.Request.URL.Path, "/api/captcha/") ||
+			strings.HasPrefix(c.Request.URL.Path, "/api/payment/") ||
 			strings.HasPrefix(c.Request.URL.Path, "/static/") ||
 			c.Request.URL.Path == "/api/admin/config/get" {
 			c.Next()
 			return
 		}

-		// WebSocket 连接请求验证
-		if c.Request.URL.Path == "/api/chat" {
-			sessionId := c.Query("sessionId")
-			session := s.ChatSession.Get(sessionId)
-			if session.ClientIP == c.ClientIP() {
-				c.Next()
-			} else {
-				c.Abort()
-			}
+		var tokenString string
+		if strings.Contains(c.Request.URL.Path, "/api/admin/") { // 后台管理 API
+			tokenString = c.GetHeader(types.AdminAuthHeader)
+		} else if c.Request.URL.Path == "/api/chat/new" {
+			tokenString = c.Query("token")
+		} else {
+			tokenString = c.GetHeader(types.UserAuthHeader)
+		}
+		if tokenString == "" {
+			resp.ERROR(c, "You should put Authorization in request headers")
+			c.Abort()
 			return
 		}
-		session := sessions.Default(c)
-		var value interface{}
-		if strings.Contains(c.Request.URL.Path, "/api/admin/") { // 后台管理 API
-			value = session.Get(types.SessionAdmin)
-		} else {
-			value = session.Get(types.SessionUser)
-		}
-		if value != nil {
-			c.Next()
-		} else {
-			resp.NotAuth(c)
+
+		token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
+			if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
+				return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
+			}
+
+			return []byte(s.Config.Session.SecretKey), nil
+		})
+
+		if err != nil {
+			resp.NotAuth(c, fmt.Sprintf("Error with parse auth token: %v", err))
 			c.Abort()
+			return
+		}
+
+		claims, ok := token.Claims.(jwt.MapClaims)
+		if !ok || !token.Valid {
+			resp.NotAuth(c, "Token is invalid")
+			c.Abort()
+			return
+		}
+
+		expr := utils.IntValue(utils.InterfaceToString(claims["expired"]), 0)
+		if expr > 0 && int64(expr) < time.Now().Unix() {
+			resp.NotAuth(c, "Token is expired")
+			c.Abort()
+			return
+		}
+
+		key := fmt.Sprintf("users/%v", claims["user_id"])
+		if _, err := client.Get(context.Background(), key).Result(); err != nil {
+			resp.NotAuth(c, "Token is not found in redis")
+			c.Abort()
+			return
+		}
+		c.Set(types.LoginUserID, claims["user_id"])
+	}
+}
+
+// 统一参数处理
+func parameterHandlerMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// GET 参数处理
+		params := c.Request.URL.Query()
+		for key, values := range params {
+			for i, value := range values {
+				params[key][i] = strings.TrimSpace(value)
+			}
+		}
+		// update get parameters
+		c.Request.URL.RawQuery = params.Encode()
+		// skip file upload requests
+		contentType := c.Request.Header.Get("Content-Type")
+		if strings.Contains(contentType, "multipart/form-data") {
+			c.Next()
+			return
+		}
+
+		if strings.Contains(contentType, "application/json") {
+			// process POST JSON request body
+			bodyBytes, err := io.ReadAll(c.Request.Body)
+			if err != nil {
+				c.Next()
+				return
+			}
+
+			// 还原请求体
+			c.Request.Body = io.NopCloser(bytes.NewBuffer(bodyBytes))
+			// 将请求体解析为 JSON
+			var jsonData map[string]interface{}
+			if err := c.ShouldBindJSON(&jsonData); err != nil {
+				c.Next()
+				return
+			}
+
+			// 对 JSON 数据中的字符串值去除两端空格
+			trimJSONStrings(jsonData)
+			// 更新请求体
+			c.Request.Body = io.NopCloser(bytes.NewBufferString(utils.JsonEncode(jsonData)))
+		}
+
+		c.Next()
+	}
+}
+
+// 递归对 JSON 数据中的字符串值去除两端空格
+func trimJSONStrings(data interface{}) {
+	switch v := data.(type) {
+	case map[string]interface{}:
+		for key, value := range v {
+			switch valueType := value.(type) {
+			case string:
+				v[key] = strings.TrimSpace(valueType)
+			case map[string]interface{}, []interface{}:
+				trimJSONStrings(value)
+			}
+		}
+	case []interface{}:
+		for i, value := range v {
+			switch valueType := value.(type) {
+			case string:
+				v[i] = strings.TrimSpace(valueType)
+			case map[string]interface{}, []interface{}:
+				trimJSONStrings(value)
+			}
 		}
 	}
 }
+
+// 静态资源中间件
+func staticResourceMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+
+		url := c.Request.URL.String()
+		// 拦截生成缩略图请求
+		if strings.HasPrefix(url, "/static/") && strings.Contains(url, "?imageView2") {
+			r := strings.SplitAfter(url, "imageView2")
+			size := strings.Split(r[1], "/")
+			if len(size) != 8 {
+				c.String(http.StatusNotFound, "invalid thumb args")
+				return
+			}
+			with := utils.IntValue(size[3], 0)
+			height := utils.IntValue(size[5], 0)
+			quality := utils.IntValue(size[7], 75)
+
+			// 打开图片文件
+			filePath := strings.TrimLeft(c.Request.URL.Path, "/")
+			file, err := os.Open(filePath)
+			if err != nil {
+				c.String(http.StatusNotFound, "Image not found")
+				return
+			}
+			defer file.Close()
+
+			// 解码图片
+			img, _, err := image.Decode(file)
+			if err != nil {
+				c.String(http.StatusInternalServerError, "Error decoding image")
+				return
+			}
+
+			var newImg image.Image
+			if height == 0 || with == 0 {
+				// 固定宽度，高度自适应
+				newImg = resize.Resize(uint(with), uint(height), img, resize.Lanczos3)
+			} else {
+				// 生成缩略图
+				newImg = resize.Thumbnail(uint(with), uint(height), img, resize.Lanczos3)
+			}
+			var buffer bytes.Buffer
+			err = jpeg.Encode(&buffer, newImg, &jpeg.Options{Quality: quality})
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			// 直接输出图像数据流
+			c.Data(http.StatusOK, "image/jpeg", buffer.Bytes())
+			return
+		}
+		c.Next()
+	}
+}
--- a/api/core/config.go
+++ b/api/core/config.go
@@ -5,7 +5,6 @@ import (
 	"chatplus/core/types"
 	logger2 "chatplus/logger"
 	"chatplus/utils"
-	"net/http"
 	"os"

 	"github.com/BurntSushi/toml"
@@ -23,16 +22,19 @@ func NewDefaultConfig() *types.AppConfig {
 		Redis:         types.RedisConfig{Host: "localhost", Port: 6379, Password: ""},
 		AesEncryptKey: utils.RandString(24),
 		Session: types.Session{
-			Driver:    types.SessionDriverCookie,
 			SecretKey: utils.RandString(64),
-			Name:      "CHAT_PLUS_SESSION",
-			Domain:    "",
-			Path:      "/",
 			MaxAge:    86400,
-			Secure:    true,
-			HttpOnly:  false,
-			SameSite:  http.SameSiteLaxMode,
 		},
+		ApiConfig: types.ChatPlusApiConfig{},
+		OSS: types.OSSConfig{
+			Active: "local",
+			Local: types.LocalStorageConfig{
+				BaseURL:  "http://localhost/5678/static/upload",
+				BasePath: "./static/upload",
+			},
+		},
+		WeChatBot:    false,
+		AlipayConfig: types.AlipayConfig{Enabled: false, SandBox: false},
 	}
 }

--- a/api/core/types/chat.go
+++ b/api/core/types/chat.go
@@ -2,17 +2,18 @@ package types

 // ApiRequest API 请求实体
 type ApiRequest struct {
-	Model       string    `json:"model"`
-	Temperature float32   `json:"temperature"`
-	MaxTokens   int       `json:"max_tokens"`
-	Stream      bool      `json:"stream"`
-	Messages    []Message `json:"messages"`
+	Model       string        `json:"model,omitempty"` // 兼容百度文心一言
+	Temperature float32       `json:"temperature"`
+	MaxTokens   int           `json:"max_tokens,omitempty"` // 兼容百度文心一言
+	Stream      bool          `json:"stream"`
+	Messages    []interface{} `json:"messages,omitempty"`
+	Prompt      []interface{} `json:"prompt,omitempty"` // 兼容 ChatGLM
+	Functions   []Function    `json:"functions,omitempty"`
 }

 type Message struct {
-	Role         string       `json:"role"`
-	Content      string       `json:"content"`
-	FunctionCall FunctionCall `json:"function_call"`
+	Role    string `json:"role"`
+	Content string `json:"content"`
 }

 type ApiResponse struct {
@@ -21,18 +22,32 @@ type ApiResponse struct {

 // ChoiceItem API 响应实体
 type ChoiceItem struct {
-	Delta        Message `json:"delta"`
-	FinishReason string  `json:"finish_reason"`
+	Delta        Delta  `json:"delta"`
+	FinishReason string `json:"finish_reason"`
+}
+
+type Delta struct {
+	Role         string       `json:"role"`
+	Name         string       `json:"name"`
+	Content      interface{}  `json:"content"`
+	FunctionCall FunctionCall `json:"function_call,omitempty"`
 }

 // ChatSession 聊天会话对象
 type ChatSession struct {
-	SessionId string `json:"session_id"`
-	ClientIP  string `json:"client_ip"` // 客户端 IP
-	Username  string `json:"username"`  // 当前登录的 username
-	UserId    uint   `json:"user_id"`   // 当前登录的 user ID
-	ChatId    string `json:"chat_id"`   // 客户端聊天会话 ID, 多会话模式专用字段
-	Model     string `json:"model"`     // GPT 模型
+	SessionId string    `json:"session_id"`
+	ClientIP  string    `json:"client_ip"` // 客户端 IP
+	Username  string    `json:"username"`  // 当前登录的 username
+	UserId    uint      `json:"user_id"`   // 当前登录的 user ID
+	ChatId    string    `json:"chat_id"`   // 客户端聊天会话 ID, 多会话模式专用字段
+	Model     ChatModel `json:"model"`     // GPT 模型
+}
+
+type ChatModel struct {
+	Id       uint     `json:"id"`
+	Platform Platform `json:"platform"`
+	Value    string   `json:"value"`
+	Weight   int      `json:"weight"`
 }

 type ApiError struct {
@@ -46,3 +61,17 @@ type ApiError struct {

 const PromptMsg = "prompt" // prompt message
 const ReplyMsg = "reply"   // reply message
+const MjMsg = "mj"
+
+var ModelToTokens = map[string]int{
+	"gpt-3.5-turbo":     4096,
+	"gpt-3.5-turbo-16k": 16384,
+	"gpt-4":             8192,
+	"gpt-4-32k":         32768,
+	"chatglm_pro":       32768, // 清华智普
+	"chatglm_std":       16384,
+	"chatglm_lite":      4096,
+	"ernie_bot_turbo":   8192, // 文心一言
+	"general":           8192, // 科大讯飞
+	"general2":          8192,
+}
--- a/api/core/types/client.go
+++ b/api/core/types/client.go
@@ -6,18 +6,14 @@ import (
 	"sync"
 )

-var ErrConClosed = errors.New("connection closed")
-
-type Client interface {
-	Close()
-}
+var ErrConClosed = errors.New("connection Closed")

 // WsClient websocket client
 type WsClient struct {
 	Conn   *websocket.Conn
 	lock   sync.Mutex
 	mt     int
-	closed bool
+	Closed bool
 }

 func NewWsClient(conn *websocket.Conn) *WsClient {
@@ -25,7 +21,7 @@ func NewWsClient(conn *websocket.Conn) *WsClient {
 		Conn:   conn,
 		lock:   sync.Mutex{},
 		mt:     2, // fixed bug for 'Invalid UTF-8 in text frame'
-		closed: false,
+		Closed: false,
 	}
 }

@@ -33,15 +29,25 @@ func (wc *WsClient) Send(message []byte) error {
 	wc.lock.Lock()
 	defer wc.lock.Unlock()

-	if wc.closed {
+	if wc.Closed {
 		return ErrConClosed
 	}

 	return wc.Conn.WriteMessage(wc.mt, message)
 }

+func (wc *WsClient) SendJson(value interface{}) error {
+	wc.lock.Lock()
+	defer wc.lock.Unlock()
+
+	if wc.Closed {
+		return ErrConClosed
+	}
+	return wc.Conn.WriteJSON(value)
+}
+
 func (wc *WsClient) Receive() (int, []byte, error) {
-	if wc.closed {
+	if wc.Closed {
 		return 0, nil, ErrConClosed
 	}

@@ -52,10 +58,10 @@ func (wc *WsClient) Close() {
 	wc.lock.Lock()
 	defer wc.lock.Unlock()

-	if wc.closed {
+	if wc.Closed {
 		return
 	}

 	_ = wc.Conn.Close()
-	wc.closed = true
+	wc.Closed = true
 }
--- a/api/core/types/config.go
+++ b/api/core/types/config.go
@@ -2,22 +2,50 @@ package types

 import (
 	"fmt"
-	"net/http"
 )

 type AppConfig struct {
-	Path      string `toml:"-"`
-	Listen    string
-	Session   Session
-	ProxyURL  string
-	MysqlDns  string      // mysql 连接地址
-	Manager   Manager     // 后台管理员账户信息
-	StaticDir string      // 静态资源目录
-	StaticUrl string      // 静态资源 URL
-	Redis     RedisConfig // redis 连接信息
-
+	Path          string `toml:"-"`
+	Listen        string
+	Session       Session
+	ProxyURL      string
+	MysqlDns      string            // mysql 连接地址
+	Manager       Manager           // 后台管理员账户信息
+	StaticDir     string            // 静态资源目录
+	StaticUrl     string            // 静态资源 URL
+	Redis         RedisConfig       // redis 连接信息
+	ApiConfig     ChatPlusApiConfig // ChatPlus API authorization configs
 	AesEncryptKey string
-	SmsConfig     AliYunSmsConfig // 短信发送配置
+	SmsConfig     AliYunSmsConfig         // AliYun send message service config
+	OSS           OSSConfig               // OSS config
+	MjConfigs     []MidJourneyConfig      // mj AI draw service pool
+	WeChatBot     bool                    // 是否启用微信机器人
+	SdConfigs     []StableDiffusionConfig // sd AI draw service pool
+
+	XXLConfig     XXLConfig
+	AlipayConfig  AlipayConfig
+	HuPiPayConfig HuPiPayConfig
+}
+
+type ChatPlusApiConfig struct {
+	ApiURL string
+	AppId  string
+	Token  string
+}
+
+type MidJourneyConfig struct {
+	Enabled   bool
+	UserToken string
+	BotToken  string
+	GuildId   string // Server ID
+	ChanelId  string // Chanel ID
+}
+
+type StableDiffusionConfig struct {
+	Enabled         bool
+	ApiURL          string
+	ApiKey          string
+	Txt2ImgJsonPath string
 }

 type AliYunSmsConfig struct {
@@ -25,12 +53,45 @@ type AliYunSmsConfig struct {
 	AccessSecret string
 	Product      string
 	Domain       string
+	Sign         string // 短信签名
+	CodeTempId   string // 验证码短信模板 ID
+}
+
+type AlipayConfig struct {
+	Enabled         bool   // 是否启用该支付通道
+	SandBox         bool   // 是否沙盒环境
+	AppId           string // 应用 ID
+	UserId          string // 支付宝用户 ID
+	PrivateKey      string // 用户私钥文件路径
+	PublicKey       string // 用户公钥文件路径
+	AlipayPublicKey string // 支付宝公钥文件路径
+	RootCert        string // Root 秘钥路径
+	NotifyURL       string // 异步通知回调
+}
+
+type HuPiPayConfig struct { //虎皮椒第四方支付配置
+	Enabled   bool   // 是否启用该支付通道
+	Name      string // 支付名称，如：wechat/alipay
+	AppId     string // App ID
+	AppSecret string // app 密钥
+	NotifyURL string // 异步通知回调
+	PayURL    string // 支付网关
+}
+
+type XXLConfig struct { // XXL 任务调度配置
+	Enabled      bool
+	ServerAddr   string
+	ExecutorIp   string
+	ExecutorPort string
+	AccessToken  string
+	RegistryKey  string
 }

 type RedisConfig struct {
 	Host     string
 	Port     int
 	Password string
+	DB       int
 }

 func (c RedisConfig) Url() string {
@@ -43,43 +104,63 @@ type Manager struct {
 	Password string `json:"password"`
 }

-type SessionDriver string
-
-const (
-	SessionDriverMem    = SessionDriver("mem")
-	SessionDriverRedis  = SessionDriver("redis")
-	SessionDriverCookie = SessionDriver("cookie")
-)
-
-// Session configs struct
-type Session struct {
-	Driver    SessionDriver // session 存储驱动 mem|cookie|redis
-	SecretKey string        // session encryption key
-	Name      string
-	Path      string
-	Domain    string
-	MaxAge    int
-	Secure    bool
-	HttpOnly  bool
-	SameSite  http.SameSite
-}
-
 // ChatConfig 系统默认的聊天配置
 type ChatConfig struct {
-	ApiURL        string  `json:"api_url,omitempty"`
-	Model         string  `json:"model"` // 默认模型
-	Temperature   float32 `json:"temperature"`
-	MaxTokens     int     `json:"max_tokens"`
-	EnableContext bool    `json:"enable_context"` // 是否开启聊天上下文
-	EnableHistory bool    `json:"enable_history"` // 是否允许保存聊天记录
-	ApiKey        string  `json:"api_key"`        // OpenAI  API key
+	OpenAI  ModelAPIConfig `json:"open_ai"`
+	Azure   ModelAPIConfig `json:"azure"`
+	ChatGML ModelAPIConfig `json:"chat_gml"`
+	Baidu   ModelAPIConfig `json:"baidu"`
+	XunFei  ModelAPIConfig `json:"xun_fei"`
+
+	EnableContext bool   `json:"enable_context"` // 是否开启聊天上下文
+	EnableHistory bool   `json:"enable_history"` // 是否允许保存聊天记录
+	ContextDeep   int    `json:"context_deep"`   // 上下文深度
+	DallApiURL    string `json:"dall_api_url"`   // dall-e3 绘图 API 地址
+	DallImgNum    int    `json:"dall_img_num"`   // dall-e3 出图数量
+}
+
+type Platform string
+
+const OpenAI = Platform("OpenAI")
+const Azure = Platform("Azure")
+const ChatGLM = Platform("ChatGLM")
+const Baidu = Platform("Baidu")
+const XunFei = Platform("XunFei")
+
+// UserChatConfig 用户的聊天配置
+type UserChatConfig struct {
+	ApiKeys map[Platform]string `json:"api_keys"`
+}
+
+type InviteReward struct {
+	ChatCalls int `json:"chat_calls"`
+	ImgCalls  int `json:"img_calls"`
+}
+
+type ModelAPIConfig struct {
+	ApiURL      string  `json:"api_url,omitempty"`
+	Temperature float32 `json:"temperature"`
+	MaxTokens   int     `json:"max_tokens"`
+	ApiKey      string  `json:"api_key"`
 }

 type SystemConfig struct {
-	Title         string   `json:"title"`
-	AdminTitle    string   `json:"admin_title"`
-	Models        []string `json:"models"`
-	UserInitCalls int      `json:"user_init_calls"` // 新用户注册默认总送多少次调用
+	Title            string   `json:"title"`
+	AdminTitle       string   `json:"admin_title"`
+	Models           []string `json:"models"`
+	InitChatCalls    int      `json:"init_chat_calls"`     // 新用户注册赠送对话次数
+	InitImgCalls     int      `json:"init_img_calls"`      // 新用户注册赠送绘图次数
+	VipMonthCalls    int      `json:"vip_month_calls"`     // 会员每个赠送的调用次数
+	EnabledRegister  bool     `json:"enabled_register"`    // 是否启用注册功能，关闭注册功能之后将无法注册
+	EnabledMsg       bool     `json:"enabled_msg"`         // 是否启用短信验证码服务
+	RewardImg        string   `json:"reward_img"`          // 众筹收款二维码地址
+	EnabledFunction  bool     `json:"enabled_function"`    // 启用 API 函数功能
+	EnabledReward    bool     `json:"enabled_reward"`      // 启用众筹功能
+	EnabledAlipay    bool     `json:"enabled_alipay"`      // 是否启用支付宝支付通道
+	OrderPayTimeout  int      `json:"order_pay_timeout"`   //订单支付超时时间
+	DefaultModels    []string `json:"default_models"`      // 默认开通的 AI 模型
+	OrderPayInfoText string   `json:"order_pay_info_text"` // 订单支付页面说明文字
+	InviteChatCalls  int      `json:"invite_chat_calls"`   // 邀请用户注册奖励对话次数
+	InviteImgCalls   int      `json:"invite_img_calls"`    // 邀请用户注册奖励绘图次数
+	ForceInvite      bool     `json:"force_invite"`        // 是否强制必须使用邀请码才能注册
 }
-
-const UserInitCalls = 1000
--- a/api/core/types/function.go
+++ b/api/core/types/function.go
@@ -6,13 +6,87 @@ type FunctionCall struct {
 }

 type Function struct {
-	Name        string
-	Description string
-	Parameters  []Parameter
+	Name        string     `json:"name"`
+	Description string     `json:"description"`
+	Parameters  Parameters `json:"parameters"`
 }

-type Parameter struct {
-	Type       string
-	Required   []string
-	Properties map[string]interface{}
+type Parameters struct {
+	Type       string              `json:"type"`
+	Required   []string            `json:"required"`
+	Properties map[string]Property `json:"properties"`
+}
+
+type Property struct {
+	Type        string `json:"type"`
+	Description string `json:"description"`
+}
+
+const (
+	FuncZaoBao   = "zao_bao"    // 每日早报
+	FuncHeadLine = "headline"   // 今日头条
+	FuncWeibo    = "weibo_hot"  // 微博热搜
+	FuncImage    = "draw_image" // AI 绘画
+)
+
+var InnerFunctions = []Function{
+	{
+		Name:        FuncZaoBao,
+		Description: "每日早报，获取当天全球的热门新闻事件列表",
+		Parameters: Parameters{
+
+			Type: "object",
+			Properties: map[string]Property{
+				"text": {
+					Type:        "string",
+					Description: "",
+				},
+			},
+			Required: []string{},
+		},
+	},
+	{
+		Name:        FuncWeibo,
+		Description: "新浪微博热搜榜，微博当日热搜榜单",
+		Parameters: Parameters{
+			Type: "object",
+			Properties: map[string]Property{
+				"text": {
+					Type:        "string",
+					Description: "",
+				},
+			},
+			Required: []string{},
+		},
+	},
+
+	{
+		Name:        FuncHeadLine,
+		Description: "今日头条，给用户推荐当天的头条新闻，周榜热文",
+		Parameters: Parameters{
+			Type: "object",
+			Properties: map[string]Property{
+				"text": {
+					Type:        "string",
+					Description: "",
+				},
+			},
+			Required: []string{},
+		},
+	},
+
+	{
+		Name:        FuncImage,
+		Description: "AI 绘画工具，根据输入的绘图描述用 AI 工具进行绘画",
+		Parameters: Parameters{
+			Type: "object",
+			Properties: map[string]Property{
+				"prompt": {
+					Type:        "string",
+					Description: "提示词，如果该参数中有中文的话，则需要翻译成英文。",
+				},
+			},
+			Required: []string{},
+		},
+	},
 }
--- a/api/core/types/locked_map.go
+++ b/api/core/types/locked_map.go
@@ -9,7 +9,7 @@ type MKey interface {
 	string | int
 }
 type MValue interface {
-	*WsClient | ChatSession | []Message | context.CancelFunc
+	*WsClient | *ChatSession | context.CancelFunc | []interface{}
 }
 type LMap[K MKey, T MValue] struct {
 	lock sync.RWMutex
--- a/api/core/types/order.go
+++ b/api/core/types/order.go
@@ -0,0 +1,17 @@
+package types
+
+type OrderStatus int
+
+const (
+	OrderNotPaid     = OrderStatus(0)
+	OrderScanned     = OrderStatus(1) // 已扫码
+	OrderPaidSuccess = OrderStatus(2)
+)
+
+type OrderRemark struct {
+	Days     int     `json:"days"`  // 有效期
+	Calls    int     `json:"calls"` // 增加调用次数
+	Name     string  `json:"name"`  // 产品名称
+	Price    float64 `json:"price"`
+	Discount float64 `json:"discount"`
+}
--- a/api/core/types/oss.go
+++ b/api/core/types/oss.go
@@ -0,0 +1,41 @@
+package types
+
+type OSSConfig struct {
+	Active string
+	Local  LocalStorageConfig
+	Minio  MiniOssConfig
+	QiNiu  QiNiuOssConfig
+	AliYun AliYunOssConfig
+}
+type MiniOssConfig struct {
+	Endpoint     string
+	AccessKey    string
+	AccessSecret string
+	Bucket       string
+	SubDir       string
+	UseSSL       bool
+	Domain       string
+}
+
+type QiNiuOssConfig struct {
+	Zone         string
+	AccessKey    string
+	AccessSecret string
+	Bucket       string
+	SubDir       string
+	Domain       string
+}
+
+type AliYunOssConfig struct {
+	Endpoint     string
+	AccessKey    string
+	AccessSecret string
+	Bucket       string
+	SubDir       string
+	Domain       string
+}
+
+type LocalStorageConfig struct {
+	BasePath string
+	BaseURL  string
+}
--- a/api/core/types/session.go
+++ b/api/core/types/session.go
@@ -1,6 +1,14 @@
 package types

-const SessionName = "ChatGPT-TOKEN"
-const SessionUser = "SESSION_USER"        // 存储用户信息的 session key
-const SessionAdmin = "SESSION_ADMIN"      //存储管理员信息的 session key
-const LoginUserCache = "LOGIN_USER_CACHE" // 已登录用户缓存
+const LoginUserID = "LOGIN_USER_ID"
+const LoginUserCache = "LOGIN_USER_CACHE"
+
+const UserAuthHeader = "Authorization"
+const AdminAuthHeader = "Admin-Authorization"
+const ChatTokenHeader = "Chat-Token"
+
+// Session configs struct
+type Session struct {
+	SecretKey string
+	MaxAge    int
+}
--- a/api/core/types/task.go
+++ b/api/core/types/task.go
@@ -0,0 +1,55 @@
+package types
+
+// TaskType 任务类别
+type TaskType string
+
+func (t TaskType) String() string {
+	return string(t)
+}
+
+const (
+	TaskImage     = TaskType("image")
+	TaskUpscale   = TaskType("upscale")
+	TaskVariation = TaskType("variation")
+)
+
+// MjTask MidJourney 任务
+type MjTask struct {
+	Id          int      `json:"id"`
+	SessionId   string   `json:"session_id"`
+	Type        TaskType `json:"type"`
+	UserId      int      `json:"user_id"`
+	Prompt      string   `json:"prompt,omitempty"`
+	Index       int      `json:"index,omitempty"`
+	MessageId   string   `json:"message_id,omitempty"`
+	MessageHash string   `json:"message_hash,omitempty"`
+	RetryCount  int      `json:"retry_count"`
+}
+
+type SdTask struct {
+	Id         int          `json:"id"` // job 数据库ID
+	SessionId  string       `json:"session_id"`
+	Type       TaskType     `json:"type"`
+	UserId     int          `json:"user_id"`
+	Prompt     string       `json:"prompt,omitempty"`
+	Params     SdTaskParams `json:"params"`
+	RetryCount int          `json:"retry_count"`
+}
+
+type SdTaskParams struct {
+	TaskId         string  `json:"task_id"`
+	Prompt         string  `json:"prompt"`          // 提示词
+	NegativePrompt string  `json:"negative_prompt"` // 反向提示词
+	Steps          int     `json:"steps"`           // 迭代步数，默认20
+	Sampler        string  `json:"sampler"`         // 采样器
+	FaceFix        bool    `json:"face_fix"`        // 面部修复
+	CfgScale       float32 `json:"cfg_scale"`       //引导系数，默认 7
+	Seed           int64   `json:"seed"`            // 随机数种子
+	Height         int     `json:"height"`
+	Width          int     `json:"width"`
+	HdFix          bool    `json:"hd_fix"`         // 启用高清修复
+	HdRedrawRate   float32 `json:"hd_redraw_rate"` // 高清修复重绘幅度
+	HdScale        int     `json:"hd_scale"`       // 放大倍数
+	HdScaleAlg     string  `json:"hd_scale_alg"`   // 放大算法
+	HdSteps        int     `json:"hd_steps"`       // 高清修复迭代步数
+}
--- a/api/core/types/web.go
+++ b/api/core/types/web.go
@@ -12,8 +12,8 @@ type BizVo struct {

 // WsMessage Websocket message
 type WsMessage struct {
-	Type    WsMsgType `json:"type"` // 消息类别，start, end
-	Content string    `json:"content"`
+	Type    WsMsgType   `json:"type"` // 消息类别，start, end, img
+	Content interface{} `json:"content"`
 }
 type WsMsgType string

@@ -21,6 +21,7 @@ const (
 	WsStart  = WsMsgType("start")
 	WsMiddle = WsMsgType("middle")
 	WsEnd    = WsMsgType("end")
+	WsMjImg  = WsMsgType("mj")
 )

 type BizCode int
@@ -33,4 +34,5 @@ const (
 	OkMsg       = "Success"
 	ErrorMsg    = "系统开小差了"
 	InvalidArgs = "非法参数或参数解析失败"
+	NoData      = "No Data"
 )
--- a/api/go.mod
+++ b/api/go.mod
@@ -5,38 +5,79 @@ go 1.19
 require (
 	github.com/BurntSushi/toml v1.1.0
 	github.com/aliyun/alibaba-cloud-sdk-go v1.62.405
-	github.com/gin-contrib/sessions v0.0.5
-	github.com/gin-gonic/gin v1.9.0
+	github.com/aliyun/aliyun-oss-go-sdk v2.2.9+incompatible
+	github.com/bwmarrin/discordgo v0.27.1
+	github.com/eatmoreapple/openwechat v1.2.1
+	github.com/gin-gonic/gin v1.9.1
+	github.com/go-redis/redis/v8 v8.11.5
+	github.com/golang-jwt/jwt/v5 v5.0.0
 	github.com/gorilla/websocket v1.5.0
+	github.com/imroc/req/v3 v3.37.2
 	github.com/lionsoul2014/ip2region/binding/golang v0.0.0-20230415042440-a5e3d8259ae0
+	github.com/minio/minio-go/v7 v7.0.62
 	github.com/pkoukk/tiktoken-go v0.1.1-0.20230418101013-cae809389480
-	github.com/syndtr/goleveldb v1.0.0
+	github.com/qiniu/go-sdk/v7 v7.17.1
+	github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
+	github.com/smartwalle/alipay/v3 v3.2.15
 	go.uber.org/zap v1.23.0
+	gopkg.in/natefinch/lumberjack.v2 v2.2.1
 	gorm.io/driver/mysql v1.4.7
 )

+require github.com/xxl-job/xxl-job-executor-go v1.2.0
+
 require (
-	github.com/boj/redistore v0.0.0-20180917114910-cd5dcc76aeff // indirect
-	github.com/bytedance/sonic v1.8.0 // indirect
+	github.com/andybalholm/brotli v1.0.4 // indirect
+	github.com/bytedance/sonic v1.9.1 // indirect
+	github.com/cespare/xxhash/v2 v2.1.2 // indirect
 	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
+	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/dlclark/regexp2 v1.8.1 // indirect
+	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
+	github.com/gaukas/godicttls v0.0.3 // indirect
+	github.com/go-basic/ipv4 v1.0.0 // indirect
 	github.com/go-sql-driver/mysql v1.7.0 // indirect
-	github.com/goccy/go-json v0.10.0 // indirect
-	github.com/gomodule/redigo v2.0.0+incompatible // indirect
+	github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/golang/mock v1.6.0 // indirect
+	github.com/google/pprof v0.0.0-20230602150820-91b7bce49751 // indirect
+	github.com/google/uuid v1.3.0 // indirect
+	github.com/hashicorp/errwrap v1.1.0 // indirect
+	github.com/hashicorp/go-multierror v1.1.1 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af // indirect
-	github.com/klauspost/cpuid/v2 v2.0.9 // indirect
+	github.com/klauspost/compress v1.16.7 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.5 // indirect
+	github.com/minio/md5-simd v1.1.2 // indirect
+	github.com/minio/sha256-simd v1.0.1 // indirect
+	github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646
+	github.com/onsi/ginkgo/v2 v2.10.0 // indirect
 	github.com/opentracing/opentracing-go v1.2.1-0.20220228012449-10b1cf09e00b // indirect
-	github.com/pelletier/go-toml/v2 v2.0.6 // indirect
-	github.com/quasoft/memstore v0.0.0-20191010062613-2bce066d2b0b // indirect
+	github.com/pelletier/go-toml/v2 v2.0.8 // indirect
+	github.com/quic-go/qpack v0.4.0 // indirect
+	github.com/quic-go/qtls-go1-19 v0.3.2 // indirect
+	github.com/quic-go/qtls-go1-20 v0.2.2 // indirect
+	github.com/quic-go/quic-go v0.35.1 // indirect
+	github.com/refraction-networking/utls v1.3.2 // indirect
+	github.com/rs/xid v1.5.0 // indirect
+	github.com/sirupsen/logrus v1.9.3 // indirect
+	github.com/smartwalle/ncrypto v1.0.2 // indirect
+	github.com/smartwalle/ngx v1.0.6 // indirect
+	github.com/smartwalle/nsign v1.0.8 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	go.uber.org/dig v1.16.1 // indirect
-	golang.org/x/arch v0.0.0-20210923205945-b76863e36670 // indirect
-	golang.org/x/net v0.9.0 // indirect
-	golang.org/x/text v0.9.0 // indirect
-	google.golang.org/protobuf v1.28.1 // indirect
-	gopkg.in/ini.v1 v1.66.2 // indirect
+	golang.org/x/arch v0.3.0 // indirect
+	golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1 // indirect
+	golang.org/x/mod v0.11.0 // indirect
+	golang.org/x/net v0.14.0 // indirect
+	golang.org/x/sync v0.3.0 // indirect
+	golang.org/x/text v0.12.0 // indirect
+	golang.org/x/time v0.3.0 // indirect
+	golang.org/x/tools v0.10.0 // indirect
+	google.golang.org/protobuf v1.30.0 // indirect
+	gopkg.in/ini.v1 v1.67.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

@@ -44,21 +85,17 @@ require (
 	github.com/gin-contrib/sse v0.1.0 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.11.2 // indirect
-	github.com/golang/snappy v0.0.1 // indirect
-	github.com/gorilla/context v1.1.1 // indirect
-	github.com/gorilla/securecookie v1.1.1 // indirect
-	github.com/gorilla/sessions v1.2.1 // indirect
+	github.com/go-playground/validator/v10 v10.14.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/leodido/go-urn v1.2.1 // indirect
-	github.com/mattn/go-isatty v0.0.17 // indirect
+	github.com/leodido/go-urn v1.2.4 // indirect
+	github.com/mattn/go-isatty v0.0.19 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/ugorji/go/codec v1.2.9 // indirect
+	github.com/ugorji/go/codec v1.2.11 // indirect
 	go.uber.org/atomic v1.9.0 // indirect
 	go.uber.org/fx v1.19.3
 	go.uber.org/multierr v1.6.0 // indirect
-	golang.org/x/crypto v0.6.0
-	golang.org/x/sys v0.7.0 // indirect
+	golang.org/x/crypto v0.12.0
+	golang.org/x/sys v0.11.0 // indirect
 	gorm.io/gorm v1.25.1
 )
--- a/api/go.sum
+++ b/api/go.sum
@@ -2,60 +2,90 @@ github.com/BurntSushi/toml v1.1.0 h1:ksErzDEI1khOiGPgpwuI7x2ebx/uXQNw7xJpn9Eq1+I
 github.com/BurntSushi/toml v1.1.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
 github.com/aliyun/alibaba-cloud-sdk-go v1.62.405 h1:cKNFQmeCQFN0WNfjScKoVrGi7vXxTVbkCvCqSrOf+P4=
 github.com/aliyun/alibaba-cloud-sdk-go v1.62.405/go.mod h1:Api2AkmMgGaSUAhmk76oaFObkoeCPc/bKAqcyplPODs=
+github.com/aliyun/aliyun-oss-go-sdk v2.2.9+incompatible h1:Sg/2xHwDrioHpxTN6WMiwbXTpUEinBpHsN7mG21Rc2k=
+github.com/aliyun/aliyun-oss-go-sdk v2.2.9+incompatible/go.mod h1:T/Aws4fEfogEE9v+HPhhw+CntffsBHJ8nXQCwKr0/g8=
+github.com/andybalholm/brotli v1.0.4 h1:V7DdXeJtZscaqfNuAdSRuRFzuiKlHSC/Zh3zl9qY3JY=
+github.com/andybalholm/brotli v1.0.4/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
 github.com/benbjohnson/clock v1.3.0 h1:ip6w0uFQkncKQ979AypyG0ER7mqUSBdKLOgAle/AT8A=
-github.com/boj/redistore v0.0.0-20180917114910-cd5dcc76aeff h1:RmdPFa+slIr4SCBg4st/l/vZWVe9QJKMXGO60Bxbe04=
-github.com/boj/redistore v0.0.0-20180917114910-cd5dcc76aeff/go.mod h1:+RTT1BOk5P97fT2CiHkbFQwkK3mjsFAP6zCYV2aXtjw=
+github.com/bwmarrin/discordgo v0.27.1 h1:ib9AIc/dom1E/fSIulrBwnez0CToJE113ZGt4HoliGY=
+github.com/bwmarrin/discordgo v0.27.1/go.mod h1:NJZpH+1AfhIcyQsPeuBKsUtYrRnjkyu0kIVMCHkZtRY=
 github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM=
-github.com/bytedance/sonic v1.8.0 h1:ea0Xadu+sHlu7x5O3gKhRpQ1IKiMrSiHttPF0ybECuA=
-github.com/bytedance/sonic v1.8.0/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U=
+github.com/bytedance/sonic v1.9.1 h1:6iJ6NqdoxCDr6mbY8h18oSO+cShGSMRGCEo7F2h0x8s=
+github.com/bytedance/sonic v1.9.1/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U=
+github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
+github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
 github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 h1:qSGYFH7+jGhDF8vLC+iwCD4WpbV1EBDSzWkJODFLams=
 github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
+github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
 github.com/dlclark/regexp2 v1.8.1 h1:6Lcdwya6GjPUNsBct8Lg/yRPwMhABj269AAzdGSiR+0=
 github.com/dlclark/regexp2 v1.8.1/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
-github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/gin-contrib/sessions v0.0.5 h1:CATtfHmLMQrMNpJRgzjWXD7worTh7g7ritsQfmF+0jE=
-github.com/gin-contrib/sessions v0.0.5/go.mod h1:vYAuaUPqie3WUSsft6HUlCjlwwoJQs97miaG2+7neKY=
+github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/eatmoreapple/openwechat v1.2.1 h1:ez4oqF/Y2NSEX/DbPV8lvj7JlfkYqvieeo4awx5lzfU=
+github.com/eatmoreapple/openwechat v1.2.1/go.mod h1:61HOzTyvLobGdgWhL68jfGNwTJEv0mhQ1miCXQrvWU8=
+github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
+github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
+github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
+github.com/gaukas/godicttls v0.0.3 h1:YNDIf0d9adcxOijiLrEzpfZGAkNwLRzPaG6OjU7EITk=
+github.com/gaukas/godicttls v0.0.3/go.mod h1:l6EenT4TLWgTdwslVb4sEMOCf7Bv0JAK67deKr9/NCI=
 github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
 github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
-github.com/gin-gonic/gin v1.9.0 h1:OjyFBKICoexlu99ctXNR2gg+c5pKrKMuyjgARg9qeY8=
-github.com/gin-gonic/gin v1.9.0/go.mod h1:W1Me9+hsUSyj3CePGrd1/QrKJMSJ1Tu/0hFEH89961k=
+github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
+github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU=
+github.com/go-basic/ipv4 v1.0.0 h1:gjyFAa1USC1hhXTkPOwBWDPfMcUaIM+tvo1XzV9EZxs=
+github.com/go-basic/ipv4 v1.0.0/go.mod h1:etLBnaxbidQfuqE6wgZQfs38nEWNmzALkxDZe4xY8Dg=
+github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ=
+github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
+github.com/go-playground/locales v0.14.0/go.mod h1:sawfccIbzZTqEDETgFXqTho0QybSa7l++s0DH+LDiLs=
 github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
 github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
+github.com/go-playground/universal-translator v0.18.0/go.mod h1:UvRDBj+xPUEGrFYl+lu/H90nyDXpg0fqeB/AQUGNTVA=
 github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
 github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
-github.com/go-playground/validator/v10 v10.11.2 h1:q3SHpufmypg+erIExEKUmsgmhDTyhcJ38oeKGACXohU=
-github.com/go-playground/validator/v10 v10.11.2/go.mod h1:NieE624vt4SCTJtD87arVLvdmjPAeV8BQlHtMnw9D7s=
+github.com/go-playground/validator/v10 v10.8.0/go.mod h1:9JhgTzTaE31GZDpH/HSvHiRJrJ3iKAgqqH0Bl/Ocjdk=
+github.com/go-playground/validator/v10 v10.14.0 h1:vgvQWe3XCz3gIeFDm/HnTIbj6UGmg/+t63MyGU2n5js=
+github.com/go-playground/validator/v10 v10.14.0/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
+github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI=
+github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo=
 github.com/go-sql-driver/mysql v1.7.0 h1:ueSltNNllEqE3qcWBTD0iQd3IpL/6U+mJxLkazJ7YPc=
 github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
-github.com/goccy/go-json v0.10.0 h1:mXKd9Qw4NuzShiRlOXKews24ufknHO7gx30lsDyokKA=
-github.com/goccy/go-json v0.10.0/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
+github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
 github.com/goji/httpauth v0.0.0-20160601135302-2da839ab0f4d/go.mod h1:nnjvkQ9ptGaCkuDUx6wNykzzlUixGxvkme+H/lnzb+A=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang-jwt/jwt/v5 v5.0.0 h1:1n1XNM9hk7O9mnQoNBGolZvzebBQ7p93ULHRc28XJUE=
+github.com/golang-jwt/jwt/v5 v5.0.0/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
+github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
+github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
-github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/gomodule/redigo v2.0.0+incompatible h1:K/R+8tc58AaqLkqG2Ol3Qk+DR/TlNuhuh457pBFPtt0=
-github.com/gomodule/redigo v2.0.0+incompatible/go.mod h1:B4C85qUVwatsJoIUNIfCRsp7qO0iAmpGFZ4EELWSbC4=
-github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
+github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/gorilla/context v1.1.1 h1:AWwleXJkX/nhcU9bZSnZoi3h/qGYqQAGhq6zZe/aQW8=
-github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
-github.com/gorilla/securecookie v1.1.1 h1:miw7JPhV+b/lAHSXz4qd/nN9jRiAFV5FwjeKyCS8BvQ=
-github.com/gorilla/securecookie v1.1.1/go.mod h1:ra0sb63/xPlUeL+yeDciTfxMRAA+MP+HVt/4epWDjd4=
-github.com/gorilla/sessions v1.1.1/go.mod h1:8KCfur6+4Mqcc6S0FEfKuN15Vl5MgXW92AE8ovaJD0w=
-github.com/gorilla/sessions v1.2.1 h1:DHd3rPN5lE3Ts3D8rKkQ8x/0kqfeNmBAaiSi+o7FsgI=
-github.com/gorilla/sessions v1.2.1/go.mod h1:dk2InVEVJ0sfLlnXv9EAgkf6ecYs/i80K/zI+bUmuGM=
+github.com/google/pprof v0.0.0-20230602150820-91b7bce49751 h1:hR7/MlvK23p6+lIw9SN1TigNLn9ZnF3W4SYRKq2gAHs=
+github.com/google/pprof v0.0.0-20230602150820-91b7bce49751/go.mod h1:Jh3hGz2jkYak8qXPD19ryItVnUgpgeqzdkY/D0EaeuA=
+github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
 github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
-github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
+github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
+github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
+github.com/imroc/req/v3 v3.37.2 h1:vEemuA0cq9zJ6lhe+mSRhsZm951bT0CdiSH47+KTn6I=
+github.com/imroc/req/v3 v3.37.2/go.mod h1:DECzjVIrj6jcUr5n6e+z0ygmCO93rx4Jy0RjOEe1YCI=
 github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jinzhu/now v1.1.4/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
@@ -66,43 +96,88 @@ github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht
 github.com/json-iterator/go v1.1.5/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
-github.com/klauspost/cpuid/v2 v2.0.9 h1:lgaqFMSdTdQYdZ04uHyN2d/eKdOMyi2YLSvlQIBFYa4=
+github.com/klauspost/compress v1.16.7 h1:2mk3MPGNzKyxErAw8YaohYh69+pa4sIQSC0fPGCFR9I=
+github.com/klauspost/compress v1.16.7/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
+github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.5 h1:0E5MSMDEoAulmXNFquVs//DdoomxaoTY1kUhbc/qbZg=
+github.com/klauspost/cpuid/v2 v2.2.5/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
+github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/leodido/go-urn v1.2.1 h1:BqpAaACuzVSgi/VLzGZIobT2z4v53pjosyNd9Yv6n/w=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY=
+github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
+github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
 github.com/lionsoul2014/ip2region/binding/golang v0.0.0-20230415042440-a5e3d8259ae0 h1:LgmjED/yQILqmUED4GaXjrINWe7YJh4HM6z2EvEINPs=
 github.com/lionsoul2014/ip2region/binding/golang v0.0.0-20230415042440-a5e3d8259ae0/go.mod h1:C5LA5UO2ZXJrLaPLYtE1wUJMiyd/nwWaCO5cw/2pSHs=
-github.com/mattn/go-isatty v0.0.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng=
-github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34=
+github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM=
+github.com/minio/minio-go/v7 v7.0.62 h1:qNYsFZHEzl+NfH8UxW4jpmlKav1qUAgfY30YNRneVhc=
+github.com/minio/minio-go/v7 v7.0.62/go.mod h1:Q6X7Qjb7WMhvG65qKf4gUgA5XaiSox74kR1uAEjxRS4=
+github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM=
+github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
-github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.7.0 h1:WSHQ+IS43OoUrWtD1/bbclrwK8TTH5hzp+umCiuxHgs=
-github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/gomega v1.4.3 h1:RE1xgDvH7imwFD45h+u2SgIfERHlS2yNG4DObb5BSKU=
-github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 h1:zYyBkD/k9seD2A7fsi6Oo2LfFZAehjjQMERAvZLEDnQ=
+github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8=
+github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
+github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
+github.com/onsi/ginkgo/v2 v2.10.0 h1:sfUl4qgLdvkChZrWCYndY2EAu9BRIw1YphNAzy1VNWs=
+github.com/onsi/ginkgo/v2 v2.10.0/go.mod h1:UDQOh5wbQUlMnkLfVaIUMtQ1Vus92oM+P2JX1aulgcE=
+github.com/onsi/gomega v1.27.7 h1:fVih9JD6ogIiHUN6ePK7HJidyEDpWGVB5mzM7cWNXoU=
 github.com/opentracing/opentracing-go v1.2.1-0.20220228012449-10b1cf09e00b h1:FfH+VrHHk6Lxt9HdVS0PXzSXFyS2NbZKXv33FYPol0A=
 github.com/opentracing/opentracing-go v1.2.1-0.20220228012449-10b1cf09e00b/go.mod h1:AC62GU6hc0BrNm+9RK9VSiwa/EUe1bkIeFORAMcHvJU=
-github.com/pelletier/go-toml/v2 v2.0.6 h1:nrzqCb7j9cDFj2coyLNLaZuJTLjWjlaz6nvTvIwycIU=
-github.com/pelletier/go-toml/v2 v2.0.6/go.mod h1:eumQOmlWiOPt5WriQQqoM5y18pDHwha2N+QD+EUNTek=
+github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ=
+github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkoukk/tiktoken-go v0.1.1-0.20230418101013-cae809389480 h1:IFhPCcB0/HtnEN+ZoUGDT55YgFCymbFJ15kXqs3nv5w=
 github.com/pkoukk/tiktoken-go v0.1.1-0.20230418101013-cae809389480/go.mod h1:BijIqAP84FMYC4XbdJgjyMpiSjusU8x0Y0W9K2t0QtU=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/quasoft/memstore v0.0.0-20191010062613-2bce066d2b0b h1:aUNXCGgukb4gtY99imuIeoh8Vr0GSwAlYxPAhqZrpFc=
-github.com/quasoft/memstore v0.0.0-20191010062613-2bce066d2b0b/go.mod h1:wTPjTepVu7uJBYgZ0SdWHQlIas582j6cn2jgk4DDdlg=
+github.com/qiniu/dyn v1.3.0/go.mod h1:E8oERcm8TtwJiZvkQPbcAh0RL8jO1G0VXJMW3FAWdkk=
+github.com/qiniu/go-sdk/v7 v7.17.1 h1:UoQv7fBKtzAiD1qZPIvTy62Se48YLKxcCYP9nAwWMa0=
+github.com/qiniu/go-sdk/v7 v7.17.1/go.mod h1:nqoYCNo53ZlGA521RvRethvxUDvXKt4gtYXOwye868w=
+github.com/qiniu/x v1.10.5/go.mod h1:03Ni9tj+N2h2aKnAz+6N0Xfl8FwMEDRC2PAlxekASDs=
+github.com/quic-go/qpack v0.4.0 h1:Cr9BXA1sQS2SmDUWjSofMPNKmvF6IiIfDRmgU0w1ZCo=
+github.com/quic-go/qpack v0.4.0/go.mod h1:UZVnYIfi5GRk+zI9UMaCPsmZ2xKJP7XBUvVyT1Knj9A=
+github.com/quic-go/qtls-go1-19 v0.3.2 h1:tFxjCFcTQzK+oMxG6Zcvp4Dq8dx4yD3dDiIiyc86Z5U=
+github.com/quic-go/qtls-go1-19 v0.3.2/go.mod h1:ySOI96ew8lnoKPtSqx2BlI5wCpUVPT05RMAlajtnyOI=
+github.com/quic-go/qtls-go1-20 v0.2.2 h1:WLOPx6OY/hxtTxKV1Zrq20FtXtDEkeY00CGQm8GEa3E=
+github.com/quic-go/qtls-go1-20 v0.2.2/go.mod h1:JKtK6mjbAVcUTN/9jZpvLbGxvdWIKS8uT7EiStoU1SM=
+github.com/quic-go/quic-go v0.35.1 h1:b0kzj6b/cQAf05cT0CkQubHM31wiA+xH3IBkxP62poo=
+github.com/quic-go/quic-go v0.35.1/go.mod h1:+4CVgVppm0FNjpG3UcX8Joi/frKOH7/ciD5yGcwOO1g=
+github.com/refraction-networking/utls v1.3.2 h1:o+AkWB57mkcoW36ET7uJ002CpBWHu0KPxi6vzxvPnv8=
+github.com/refraction-networking/utls v1.3.2/go.mod h1:fmoaOww2bxzzEpIKOebIsnBvjQpqP7L2vcm/9KUfm/E=
+github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
 github.com/rogpeppe/go-internal v1.8.0 h1:FCbCCtXNOY3UtUuHUYaghJg4y7Fd14rXifAYUAtL9R8=
+github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE=
+github.com/rs/xid v1.5.0 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc=
+github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e h1:MRM5ITcdelLK2j1vwZ3Je0FKVCfqOLp5zO6trqMLYs0=
+github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e/go.mod h1:XV66xRDqSt+GTGFMVlhk3ULuV0y9ZmzeVGR4mloJI3M=
+github.com/smartwalle/alipay/v3 v3.2.15 h1:3fvFJnINKKAOXHR/Iv20k1Z7KJ+nOh3oK214lELPqG8=
+github.com/smartwalle/alipay/v3 v3.2.15/go.mod h1:niTNB609KyUYuAx9Bex/MawEjv2yPx4XOjxSAkqmGjE=
+github.com/smartwalle/ncrypto v1.0.2 h1:pTAhCqtPCMhpOwFXX+EcMdR6PNzruBNoGQrN2S1GbGI=
+github.com/smartwalle/ncrypto v1.0.2/go.mod h1:Dwlp6sfeNaPMnOxMNayMTacvC5JGEVln3CVdiVDgbBk=
+github.com/smartwalle/ngx v1.0.6 h1:JPNqNOIj+2nxxFtrSkJO+vKJfeNUSEQueck/Wworjps=
+github.com/smartwalle/ngx v1.0.6/go.mod h1:mx/nz2Pk5j+RBs7t6u6k22MPiBG/8CtOMpCnALIG8Y0=
+github.com/smartwalle/nsign v1.0.8 h1:78KWtwKPrdt4Xsn+tNEBVxaTLIJBX9YRX0ZSrMUeuHo=
+github.com/smartwalle/nsign v1.0.8/go.mod h1:eY6I4CJlyNdVMP+t6z1H6Jpd4m5/V+8xi44ufSTxXgc=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
@@ -112,17 +187,21 @@ github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
-github.com/syndtr/goleveldb v1.0.0 h1:fBdIW9lB4Iz0n9khmH8w27SJ3QEJ7+IgjPEwGSZiFdE=
-github.com/syndtr/goleveldb v1.0.0/go.mod h1:ZVVdQEZoIme9iO1Ch2Jdy24qqXrMMOU6lpPAyBWyWuQ=
+github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY=
+github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/uber/jaeger-client-go v2.30.0+incompatible h1:D6wyKGCecFaSRUpo8lCVbaOOb6ThwMmTEbhRwtKR97o=
 github.com/uber/jaeger-client-go v2.30.0+incompatible/go.mod h1:WVhlPFC8FDjOFMMWRy2pZqQJSXxYSwNYOkTr/Z6d3Kk=
 github.com/uber/jaeger-lib v2.4.1+incompatible h1:td4jdvLcExb4cBISKIpHuGoVXh+dVKhn2Um6rjCsSsg=
 github.com/uber/jaeger-lib v2.4.1+incompatible/go.mod h1:ComeNDZlWwrWnDv8aPp0Ba6+uUTzImX/AauajbLI56U=
-github.com/ugorji/go/codec v1.2.9 h1:rmenucSohSTiyL09Y+l2OCk+FrMxGMzho2+tjr5ticU=
-github.com/ugorji/go/codec v1.2.9/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU=
+github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+github.com/xxl-job/xxl-job-executor-go v1.2.0 h1:MTl2DpwrK2+hNjRRks2k7vB3oy+3onqm9OaSarneeLQ=
+github.com/xxl-job/xxl-job-executor-go v1.2.0/go.mod h1:bUFhz/5Irp9zkdYk5MxhQcDDT6LlZrI8+rv5mHtQ1mo=
+github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
 go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
@@ -135,37 +214,88 @@ go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4=
 go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
 go.uber.org/zap v1.23.0 h1:OjGQ5KQDEUawVHxNwQgPpiypGHOxo2mNZsOqTak4fFY=
 go.uber.org/zap v1.23.0/go.mod h1:D+nX8jyLsMHMYrln8A0rJjFt/T/9/bGgIhAqxv5URuY=
-golang.org/x/arch v0.0.0-20210923205945-b76863e36670 h1:18EFjUmQOcUvxNYSkA6jO9VAiXCnxFY6NyDX0bHDmkU=
 golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
-golang.org/x/crypto v0.6.0 h1:qfktjS5LUO+fFKeJXZ+ikTRijMmljikvG68fpMMruSc=
-golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58=
-golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.9.0 h1:aWJ/m6xSmxWBx+V0XRHTlrYrPG56jKsLdTFmsSsCzOM=
-golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.7.0 h1:3jlCCIQZPdOYu1h8BkNvLz8Kgwtae2cagcG/VamtZRU=
-golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/arch v0.3.0 h1:02VY4/ZcO/gBOH6PUaoiptASxtXU10jazRCP865E97k=
+golang.org/x/arch v0.3.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
+golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw=
+golang.org/x/crypto v0.12.0 h1:tFM/ta59kqch6LlvYnPa0yx5a83cL2nHflFhYKvv9Yk=
+golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
+golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1 h1:k/i9J1pBpvlfR+9QsetwPyERsqu1GIbi967PQMq3Ivc=
+golang.org/x/exp v0.0.0-20230522175609-2e198f4a06a1/go.mod h1:V1LtkGg67GoY2N1AnLN78QLrzxkLyJw7RJb1gzOOz9w=
+golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.11.0 h1:bUO06HqtnRcc/7l71XBe4WcqTZ+3AH1J59zWDDwLKgU=
+golang.org/x/mod v0.11.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco=
+golang.org/x/net v0.14.0 h1:BONx9s002vGdD9umnlX1Po8vOZmrgH34qlHcD1MfK14=
+golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
+golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
+golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc=
+golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=
+golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.10.0 h1:tvDr/iQoUqNdohiYm0LmmKcBk+q86lb9EprIUFhHHGg=
+golang.org/x/tools v0.10.0/go.mod h1:UJwyiVBsOA2uwvK/e5OY3GTpDUJriEd+/YlqAwLPmyM=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w=
-google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
+google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
-gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
-gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
-gopkg.in/ini.v1 v1.66.2 h1:XfR1dOYubytKy4Shzc2LHrrGhU0lDCfDGG1yLPmpgsI=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/ini.v1 v1.66.2/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
+gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc=
+gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
--- a/api/handler/admin/admin_handler.go
+++ b/api/handler/admin/admin_handler.go
@@ -5,12 +5,11 @@ import (
 	"chatplus/core/types"
 	"chatplus/handler"
 	logger2 "chatplus/logger"
-	"chatplus/store/model"
-	"chatplus/utils"
 	"chatplus/utils/resp"
-	"strings"
-
-	"github.com/gin-contrib/sessions"
+	"context"
+	"github.com/go-redis/redis/v8"
+	"github.com/golang-jwt/jwt/v5"
+	"time"

 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
@@ -20,11 +19,12 @@ var logger = logger2.GetLogger()

 type ManagerHandler struct {
 	handler.BaseHandler
-	db *gorm.DB
+	db    *gorm.DB
+	redis *redis.Client
 }

-func NewAdminHandler(app *core.AppServer, db *gorm.DB) *ManagerHandler {
-	h := ManagerHandler{db: db}
+func NewAdminHandler(app *core.AppServer, db *gorm.DB, client *redis.Client) *ManagerHandler {
+	h := ManagerHandler{db: db, redis: client}
 	h.App = app
 	return &h
 }
@@ -38,13 +38,23 @@ func (h *ManagerHandler) Login(c *gin.Context) {
 	}
 	manager := h.App.Config.Manager
 	if data.Username == manager.Username && data.Password == manager.Password {
-		err := utils.SetLoginAdmin(c, manager)
+		// 创建 token
+		token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
+			"user_id": manager.Username,
+			"expired": time.Now().Add(time.Second * time.Duration(h.App.Config.Session.MaxAge)).Unix(),
+		})
+		tokenString, err := token.SignedString([]byte(h.App.Config.Session.SecretKey))
 		if err != nil {
-			resp.ERROR(c, "Save session failed")
+			resp.ERROR(c, "Failed to generate token, "+err.Error())
 			return
 		}
-		manager.Password = "" // 清空密码]
-		resp.SUCCESS(c, manager)
+		// 保存到 redis
+		key := "users/" + manager.Username
+		if _, err := h.redis.Set(context.Background(), key, tokenString, 0).Result(); err != nil {
+			resp.ERROR(c, "error with save token: "+err.Error())
+			return
+		}
+		resp.SUCCESS(c, tokenString)
 	} else {
 		resp.ERROR(c, "用户名或者密码错误")
 	}
@@ -52,11 +62,9 @@ func (h *ManagerHandler) Login(c *gin.Context) {

 // Logout 注销
 func (h *ManagerHandler) Logout(c *gin.Context) {
-	session := sessions.Default(c)
-	session.Delete(types.SessionAdmin)
-	err := session.Save()
-	if err != nil {
-		resp.ERROR(c, "Save session failed")
+	key := h.GetUserKey(c)
+	if _, err := h.redis.Del(c, key).Result(); err != nil {
+		logger.Error("error with delete session: ", err)
 	} else {
 		resp.SUCCESS(c)
 	}
@@ -64,75 +72,10 @@ func (h *ManagerHandler) Logout(c *gin.Context) {

 // Session 会话检测
 func (h *ManagerHandler) Session(c *gin.Context) {
-	session := sessions.Default(c)
-	admin := session.Get(types.SessionAdmin)
-	if admin == nil {
+	token := c.GetHeader(types.AdminAuthHeader)
+	if token == "" {
 		resp.NotAuth(c)
 	} else {
 		resp.SUCCESS(c)
 	}
 }
-
-// Migrate 数据修正
-func (h *ManagerHandler) Migrate(c *gin.Context) {
-	opt := c.Query("opt")
-	switch opt {
-	case "user":
-		// 将用户订阅角色的数据结构从 map 改成数组
-		var users []model.User
-		h.db.Find(&users)
-		for _, u := range users {
-			var m map[string]int
-			var roleKeys = make([]string, 0)
-			err := utils.JsonDecode(u.ChatRoles, &m)
-			if err != nil {
-				continue
-			}
-
-			for k := range m {
-				roleKeys = append(roleKeys, k)
-			}
-			u.ChatRoles = utils.JsonEncode(roleKeys)
-			h.db.Updates(&u)
-
-		}
-		break
-	case "role":
-		// 修改角色图片，改成绝对路径
-		var roles []model.ChatRole
-		h.db.Find(&roles)
-		for _, r := range roles {
-			if !strings.HasPrefix(r.Icon, "/") {
-				r.Icon = "/" + r.Icon
-				h.db.Updates(&r)
-			}
-		}
-		break
-	case "history":
-		// 修改角色图片，改成绝对路径
-		var message []model.HistoryMessage
-		h.db.Find(&message)
-		for _, r := range message {
-			if !strings.HasPrefix(r.Icon, "/") {
-				r.Icon = "/" + r.Icon
-				h.db.Updates(&r)
-			}
-
-		}
-		break
-
-	case "avatar":
-		// 更新用户的头像地址
-		var users []model.User
-		h.db.Find(&users)
-		for _, u := range users {
-			if !strings.HasPrefix(u.Avatar, "/") {
-				u.Avatar = "/" + u.Avatar
-				h.db.Updates(&u)
-			}
-		}
-		break
-	}
-
-	resp.SUCCESS(c, "SUCCESS")
-}
--- a/api/handler/admin/api_key_handler.go
+++ b/api/handler/admin/api_key_handler.go
@@ -8,8 +8,6 @@ import (
 	"chatplus/store/vo"
 	"chatplus/utils"
 	"chatplus/utils/resp"
-	"time"
-
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
 )
@@ -27,22 +25,23 @@ func NewApiKeyHandler(app *core.AppServer, db *gorm.DB) *ApiKeyHandler {

 func (h *ApiKeyHandler) Save(c *gin.Context) {
 	var data struct {
-		Id         uint   `json:"id"`
-		UserId     uint   `json:"user_id"`
-		Value      string `json:"value"`
-		LastUsedAt string `json:"last_used_at"`
-		CreatedAt  int64  `json:"created_at"`
+		Id       uint   `json:"id"`
+		Platform string `json:"platform"`
+		Type     string `json:"type"`
+		Value    string `json:"value"`
 	}
 	if err := c.ShouldBindJSON(&data); err != nil {
 		resp.ERROR(c, types.InvalidArgs)
 		return
 	}

-	apiKey := model.ApiKey{Value: data.Value, UserId: data.UserId, LastUsedAt: utils.Str2stamp(data.LastUsedAt)}
-	apiKey.Id = data.Id
-	if apiKey.Id > 0 {
-		apiKey.CreatedAt = time.Unix(data.CreatedAt, 0)
+	apiKey := model.ApiKey{}
+	if data.Id > 0 {
+		h.db.Find(&apiKey, data.Id)
 	}
+	apiKey.Platform = data.Platform
+	apiKey.Value = data.Value
+	apiKey.Type = data.Type
 	res := h.db.Save(&apiKey)
 	if res.Error != nil {
 		resp.ERROR(c, "更新数据库失败！")
@@ -61,14 +60,9 @@ func (h *ApiKeyHandler) Save(c *gin.Context) {
 }

 func (h *ApiKeyHandler) List(c *gin.Context) {
-	userId := h.GetInt(c, "user_id", -1)
-	query := h.db.Session(&gorm.Session{})
-	if userId >= 0 {
-		query = query.Where("user_id", userId)
-	}
 	var items []model.ApiKey
 	var keys = make([]vo.ApiKey, 0)
-	res := query.Find(&items)
+	res := h.db.Find(&items)
 	if res.Error == nil {
 		for _, item := range items {
 			var key vo.ApiKey
--- a/api/handler/admin/chat_model_handler.go
+++ b/api/handler/admin/chat_model_handler.go
@@ -0,0 +1,153 @@
+package admin
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/handler"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"time"
+)
+
+type ChatModelHandler struct {
+	handler.BaseHandler
+	db *gorm.DB
+}
+
+func NewChatModelHandler(app *core.AppServer, db *gorm.DB) *ChatModelHandler {
+	h := ChatModelHandler{db: db}
+	h.App = app
+	return &h
+}
+
+func (h *ChatModelHandler) Save(c *gin.Context) {
+	var data struct {
+		Id        uint   `json:"id"`
+		Name      string `json:"name"`
+		Value     string `json:"value"`
+		Enabled   bool   `json:"enabled"`
+		SortNum   int    `json:"sort_num"`
+		Open      bool   `json:"open"`
+		Platform  string `json:"platform"`
+		Weight    int    `json:"weight"`
+		CreatedAt int64  `json:"created_at"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	item := model.ChatModel{
+		Platform: data.Platform,
+		Name:     data.Name,
+		Value:    data.Value,
+		Enabled:  data.Enabled,
+		SortNum:  data.SortNum,
+		Open:     data.Open,
+		Weight:   data.Weight}
+	item.Id = data.Id
+	if item.Id > 0 {
+		item.CreatedAt = time.Unix(data.CreatedAt, 0)
+	}
+	res := h.db.Save(&item)
+	if res.Error != nil {
+		resp.ERROR(c, "更新数据库失败！")
+		return
+	}
+
+	var itemVo vo.ChatModel
+	err := utils.CopyObject(item, &itemVo)
+	if err != nil {
+		resp.ERROR(c, "数据拷贝失败！")
+		return
+	}
+	itemVo.Id = item.Id
+	itemVo.CreatedAt = item.CreatedAt.Unix()
+	resp.SUCCESS(c, itemVo)
+}
+
+// List 模型列表
+func (h *ChatModelHandler) List(c *gin.Context) {
+	session := h.db.Session(&gorm.Session{})
+	enable := h.GetBool(c, "enable")
+	if enable {
+		session = session.Where("enabled", enable)
+	}
+	var items []model.ChatModel
+	var cms = make([]vo.ChatModel, 0)
+	res := session.Order("sort_num ASC").Find(&items)
+	if res.Error == nil {
+		for _, item := range items {
+			var cm vo.ChatModel
+			err := utils.CopyObject(item, &cm)
+			if err == nil {
+				cm.Id = item.Id
+				cm.CreatedAt = item.CreatedAt.Unix()
+				cm.UpdatedAt = item.UpdatedAt.Unix()
+				cms = append(cms, cm)
+			} else {
+				logger.Error(err)
+			}
+		}
+	}
+	resp.SUCCESS(c, cms)
+}
+
+func (h *ChatModelHandler) Set(c *gin.Context) {
+	var data struct {
+		Id    uint        `json:"id"`
+		Filed string      `json:"filed"`
+		Value interface{} `json:"value"`
+	}
+
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	res := h.db.Model(&model.ChatModel{}).Where("id = ?", data.Id).Update(data.Filed, data.Value)
+	if res.Error != nil {
+		resp.ERROR(c, "更新数据库失败！")
+		return
+	}
+	resp.SUCCESS(c)
+}
+
+func (h *ChatModelHandler) Sort(c *gin.Context) {
+	var data struct {
+		Ids   []uint `json:"ids"`
+		Sorts []int  `json:"sorts"`
+	}
+
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	for index, id := range data.Ids {
+		res := h.db.Model(&model.ChatModel{}).Where("id = ?", id).Update("sort_num", data.Sorts[index])
+		if res.Error != nil {
+			resp.ERROR(c, "更新数据库失败！")
+			return
+		}
+	}
+
+	resp.SUCCESS(c)
+}
+
+func (h *ChatModelHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+
+	if id > 0 {
+		res := h.db.Where("id = ?", id).Delete(&model.ChatModel{})
+		if res.Error != nil {
+			resp.ERROR(c, "更新数据库失败！")
+			return
+		}
+	}
+	resp.SUCCESS(c)
+}
--- a/api/handler/admin/chat_role_handler.go
+++ b/api/handler/admin/chat_role_handler.go
@@ -55,7 +55,7 @@ func (h *ChatRoleHandler) Save(c *gin.Context) {
 func (h *ChatRoleHandler) List(c *gin.Context) {
 	var items []model.ChatRole
 	var roles = make([]vo.ChatRole, 0)
-	res := h.db.Order("sort ASC").Find(&items)
+	res := h.db.Order("sort_num ASC").Find(&items)
 	if res.Error != nil {
 		resp.ERROR(c, "No data found")
 		return
@@ -75,24 +75,24 @@ func (h *ChatRoleHandler) List(c *gin.Context) {
 	resp.SUCCESS(c, roles)
 }

-// SetSort 更新角色排序
-func (h *ChatRoleHandler) SetSort(c *gin.Context) {
+// Sort 更新角色排序
+func (h *ChatRoleHandler) Sort(c *gin.Context) {
 	var data struct {
-		Id   uint `json:"id"`
-		Sort int  `json:"sort"`
+		Ids   []uint `json:"ids"`
+		Sorts []int  `json:"sorts"`
 	}
+
 	if err := c.ShouldBindJSON(&data); err != nil {
 		resp.ERROR(c, types.InvalidArgs)
 		return
 	}
-	if data.Id <= 0 {
-		resp.HACKER(c)
-		return
-	}
-	res := h.db.Model(&model.ChatRole{}).Where("id = ?", data.Id).Update("sort", data.Sort)
-	if res.Error != nil {
-		resp.ERROR(c, "更新数据库失败！")
-		return
+
+	for index, id := range data.Ids {
+		res := h.db.Model(&model.ChatRole{}).Where("id = ?", id).Update("sort_num", data.Sorts[index])
+		if res.Error != nil {
+			resp.ERROR(c, "更新数据库失败！")
+			return
+		}
 	}

 	resp.SUCCESS(c)
--- a/api/handler/admin/config_handler.go
+++ b/api/handler/admin/config_handler.go
@@ -48,6 +48,21 @@ func (h *ConfigHandler) Update(c *gin.Context) {
 			resp.ERROR(c, res.Error.Error())
 			return
 		}
+
+		// update config cache for AppServer
+		var cfg model.Config
+		h.db.Where("marker", data.Key).First(&cfg)
+		var err error
+		if data.Key == "system" {
+			err = utils.JsonDecode(cfg.Config, &h.App.SysConfig)
+		} else if data.Key == "chat" {
+			err = utils.JsonDecode(cfg.Config, &h.App.ChatConfig)
+		}
+		if err != nil {
+			resp.ERROR(c, "Failed to update config cache: "+err.Error())
+			return
+		}
+		logger.Infof("Update AppServer's config successfully: %v", config.Config)
 	}

 	resp.SUCCESS(c, config)
--- a/api/handler/admin/dashboard_handler.go
+++ b/api/handler/admin/dashboard_handler.go
@@ -0,0 +1,71 @@
+package admin
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/handler"
+	"chatplus/store/model"
+	"chatplus/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"time"
+)
+
+type DashboardHandler struct {
+	handler.BaseHandler
+	db *gorm.DB
+}
+
+func NewDashboardHandler(app *core.AppServer, db *gorm.DB) *DashboardHandler {
+	h := DashboardHandler{db: db}
+	h.App = app
+	return &h
+}
+
+type statsVo struct {
+	Users  int64   `json:"users"`
+	Chats  int64   `json:"chats"`
+	Tokens int     `json:"tokens"`
+	Income float64 `json:"income"`
+}
+
+func (h *DashboardHandler) Stats(c *gin.Context) {
+	stats := statsVo{}
+	// new users statistic
+	var userCount int64
+	now := time.Now()
+	zeroTime := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
+	res := h.db.Model(&model.User{}).Where("created_at > ?", zeroTime).Count(&userCount)
+	if res.Error == nil {
+		stats.Users = userCount
+	}
+
+	// new chats statistic
+	var chatCount int64
+	res = h.db.Model(&model.ChatItem{}).Where("created_at > ?", zeroTime).Count(&chatCount)
+	if res.Error == nil {
+		stats.Chats = chatCount
+	}
+
+	// tokens took stats
+	var historyMessages []model.HistoryMessage
+	res = h.db.Where("created_at > ?", zeroTime).Find(&historyMessages)
+	for _, item := range historyMessages {
+		stats.Tokens += item.Tokens
+	}
+
+	// 众筹收入
+	var rewards []model.Reward
+	res = h.db.Where("created_at > ?", zeroTime).Find(&rewards)
+	for _, item := range rewards {
+		stats.Income += item.Amount
+	}
+
+	// 订单收入
+	var orders []model.Order
+	res = h.db.Where("status = ?", types.OrderPaidSuccess).Where("created_at > ?", zeroTime).Find(&orders)
+	for _, item := range orders {
+		stats.Income += item.Amount
+	}
+	resp.SUCCESS(c, stats)
+}
--- a/api/handler/admin/order_handler.go
+++ b/api/handler/admin/order_handler.go
@@ -0,0 +1,95 @@
+package admin
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/handler"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type OrderHandler struct {
+	handler.BaseHandler
+	db *gorm.DB
+}
+
+func NewOrderHandler(app *core.AppServer, db *gorm.DB) *OrderHandler {
+	h := OrderHandler{db: db}
+	h.App = app
+	return &h
+}
+
+func (h *OrderHandler) List(c *gin.Context) {
+	var data struct {
+		OrderNo  string   `json:"order_no"`
+		PayTime  []string `json:"pay_time"`
+		Page     int      `json:"page"`
+		PageSize int      `json:"page_size"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	session := h.db.Session(&gorm.Session{})
+	if data.OrderNo != "" {
+		session = session.Where("order_no", data.OrderNo)
+	}
+	if len(data.PayTime) == 2 {
+		start := utils.Str2stamp(data.PayTime[0] + " 00:00:00")
+		end := utils.Str2stamp(data.PayTime[1] + " 00:00:00")
+		session = session.Where("pay_time >= ? AND pay_time <= ?", start, end)
+	}
+	session = session.Where("status = ?", types.OrderPaidSuccess)
+
+	var total int64
+	session.Model(&model.Order{}).Count(&total)
+	var items []model.Order
+	var list = make([]vo.Order, 0)
+	offset := (data.Page - 1) * data.PageSize
+	res := session.Order("id DESC").Offset(offset).Limit(data.PageSize).Find(&items)
+	if res.Error == nil {
+		for _, item := range items {
+			var order vo.Order
+			err := utils.CopyObject(item, &order)
+			if err == nil {
+				order.Id = item.Id
+				order.CreatedAt = item.CreatedAt.Unix()
+				order.UpdatedAt = item.UpdatedAt.Unix()
+				list = append(list, order)
+			} else {
+				logger.Error(err)
+			}
+		}
+	}
+	resp.SUCCESS(c, vo.NewPage(total, data.Page, data.PageSize, list))
+}
+
+func (h *OrderHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+
+	if id > 0 {
+		var item model.Order
+		res := h.db.First(&item, id)
+		if res.Error != nil {
+			resp.ERROR(c, "记录不存在！")
+			return
+		}
+
+		if item.Status == types.OrderPaidSuccess {
+			resp.ERROR(c, "已支付订单不允许删除！")
+			return
+		}
+
+		res = h.db.Where("id = ?", id).Delete(&model.Order{})
+		if res.Error != nil {
+			resp.ERROR(c, "更新数据库失败！")
+			return
+		}
+	}
+	resp.SUCCESS(c)
+}
--- a/api/handler/admin/product_handler.go
+++ b/api/handler/admin/product_handler.go
@@ -0,0 +1,144 @@
+package admin
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/handler"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"time"
+)
+
+type ProductHandler struct {
+	handler.BaseHandler
+	db *gorm.DB
+}
+
+func NewProductHandler(app *core.AppServer, db *gorm.DB) *ProductHandler {
+	h := ProductHandler{db: db}
+	h.App = app
+	return &h
+}
+
+func (h *ProductHandler) Save(c *gin.Context) {
+	var data struct {
+		Id        uint    `json:"id"`
+		Name      string  `json:"name"`
+		Price     float64 `json:"price"`
+		Discount  float64 `json:"discount"`
+		Enabled   bool    `json:"enabled"`
+		Days      int     `json:"days"`
+		Calls     int     `json:"calls"`
+		CreatedAt int64   `json:"created_at"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	item := model.Product{Name: data.Name, Price: data.Price, Discount: data.Discount, Days: data.Days, Calls: data.Calls, Enabled: data.Enabled}
+	item.Id = data.Id
+	if item.Id > 0 {
+		item.CreatedAt = time.Unix(data.CreatedAt, 0)
+	}
+	res := h.db.Save(&item)
+	if res.Error != nil {
+		resp.ERROR(c, "更新数据库失败！")
+		return
+	}
+
+	var itemVo vo.Product
+	err := utils.CopyObject(item, &itemVo)
+	if err != nil {
+		resp.ERROR(c, "数据拷贝失败！")
+		return
+	}
+	itemVo.Id = item.Id
+	itemVo.UpdatedAt = item.UpdatedAt.Unix()
+	resp.SUCCESS(c, itemVo)
+}
+
+// List 模型列表
+func (h *ProductHandler) List(c *gin.Context) {
+	session := h.db.Session(&gorm.Session{})
+	enable := h.GetBool(c, "enable")
+	if enable {
+		session = session.Where("enabled", enable)
+	}
+	var items []model.Product
+	var list = make([]vo.Product, 0)
+	res := session.Order("sort_num ASC").Find(&items)
+	if res.Error == nil {
+		for _, item := range items {
+			var product vo.Product
+			err := utils.CopyObject(item, &product)
+			if err == nil {
+				product.Id = item.Id
+				product.CreatedAt = item.CreatedAt.Unix()
+				product.UpdatedAt = item.UpdatedAt.Unix()
+				list = append(list, product)
+			} else {
+				logger.Error(err)
+			}
+		}
+	}
+	resp.SUCCESS(c, list)
+}
+
+func (h *ProductHandler) Enable(c *gin.Context) {
+	var data struct {
+		Id      uint `json:"id"`
+		Enabled bool `json:"enabled"`
+	}
+
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	res := h.db.Model(&model.Product{}).Where("id = ?", data.Id).Update("enabled", data.Enabled)
+	if res.Error != nil {
+		resp.ERROR(c, "更新数据库失败！")
+		return
+	}
+	resp.SUCCESS(c)
+}
+
+func (h *ProductHandler) Sort(c *gin.Context) {
+	var data struct {
+		Ids   []uint `json:"ids"`
+		Sorts []int  `json:"sorts"`
+	}
+
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	for index, id := range data.Ids {
+		res := h.db.Model(&model.Product{}).Where("id = ?", id).Update("sort_num", data.Sorts[index])
+		if res.Error != nil {
+			resp.ERROR(c, "更新数据库失败！")
+			return
+		}
+	}
+
+	resp.SUCCESS(c)
+}
+
+func (h *ProductHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+
+	if id > 0 {
+		res := h.db.Where("id = ?", id).Delete(&model.Product{})
+		if res.Error != nil {
+			resp.ERROR(c, "更新数据库失败！")
+			return
+		}
+	}
+	resp.SUCCESS(c)
+}
--- a/api/handler/admin/reward_handler.go
+++ b/api/handler/admin/reward_handler.go
@@ -0,0 +1,57 @@
+package admin
+
+import (
+	"chatplus/core"
+	"chatplus/handler"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type RewardHandler struct {
+	handler.BaseHandler
+	db *gorm.DB
+}
+
+func NewRewardHandler(app *core.AppServer, db *gorm.DB) *RewardHandler {
+	h := RewardHandler{db: db}
+	h.App = app
+	return &h
+}
+
+func (h *RewardHandler) List(c *gin.Context) {
+	var items []model.Reward
+	res := h.db.Order("id DESC").Find(&items)
+	var rewards = make([]vo.Reward, 0)
+	if res.Error == nil {
+		userIds := make([]uint, 0)
+		for _, v := range items {
+			userIds = append(userIds, v.UserId)
+		}
+		var users []model.User
+		h.db.Where("id IN ?", userIds).Find(&users)
+		var userMap = make(map[uint]model.User)
+		for _, u := range users {
+			userMap[u.Id] = u
+		}
+
+		for _, v := range items {
+			var r vo.Reward
+			err := utils.CopyObject(v, &r)
+			if err != nil {
+				continue
+			}
+
+			r.Id = v.Id
+			r.Username = userMap[v.UserId].Mobile
+			r.CreatedAt = v.CreatedAt.Unix()
+			r.UpdatedAt = v.UpdatedAt.Unix()
+			rewards = append(rewards, r)
+		}
+	}
+
+	resp.SUCCESS(c, rewards)
+}
--- a/api/handler/admin/user_handler.go
+++ b/api/handler/admin/user_handler.go
@@ -8,7 +8,6 @@ import (
 	"chatplus/store/vo"
 	"chatplus/utils"
 	"chatplus/utils/resp"
-
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
 )
@@ -28,12 +27,20 @@ func NewUserHandler(app *core.AppServer, db *gorm.DB) *UserHandler {
 func (h *UserHandler) List(c *gin.Context) {
 	page := h.GetInt(c, "page", 1)
 	pageSize := h.GetInt(c, "page_size", 20)
+	mobile := h.GetTrim(c, "mobile")
+
 	offset := (page - 1) * pageSize
 	var items []model.User
 	var users = make([]vo.User, 0)
 	var total int64
-	h.db.Model(&model.User{}).Count(&total)
-	res := h.db.Offset(offset).Limit(pageSize).Find(&items)
+
+	session := h.db.Session(&gorm.Session{})
+	if mobile != "" {
+		session = session.Where("mobile LIKE ?", "%"+mobile+"%")
+	}
+
+	session.Model(&model.User{}).Count(&total)
+	res := session.Offset(offset).Limit(pageSize).Find(&items)
 	if res.Error == nil {
 		for _, item := range items {
 			var user vo.User
@@ -52,35 +59,101 @@ func (h *UserHandler) List(c *gin.Context) {
 	resp.SUCCESS(c, pageVo)
 }

-func (h *UserHandler) Update(c *gin.Context) {
+func (h *UserHandler) Save(c *gin.Context) {
 	var data struct {
 		Id          uint     `json:"id"`
-		Nickname    string   `json:"nickname"`
+		Password    string   `json:"password"`
+		Mobile      string   `json:"mobile"`
 		Calls       int      `json:"calls"`
+		ImgCalls    int      `json:"img_calls"`
 		ChatRoles   []string `json:"chat_roles"`
+		ChatModels  []string `json:"chat_models"`
 		ExpiredTime string   `json:"expired_time"`
 		Status      bool     `json:"status"`
+		Vip         bool     `json:"vip"`
 	}
 	if err := c.ShouldBindJSON(&data); err != nil {
 		resp.ERROR(c, types.InvalidArgs)
 		return
 	}
 	var user = model.User{}
-	user.Id = data.Id
-	// 此处需要用 map 更新，用结构体无法更新 0 值
-	res := h.db.Model(&user).Updates(map[string]interface{}{
-		"nickname":        data.Nickname,
-		"calls":           data.Calls,
-		"status":          data.Status,
-		"chat_roles_json": utils.JsonEncode(data.ChatRoles),
-		"expired_time":    utils.Str2stamp(data.ExpiredTime),
-	})
+	var res *gorm.DB
+	var userVo vo.User
+	if data.Id > 0 { // 更新
+		user.Id = data.Id
+		// 此处需要用 map 更新，用结构体无法更新 0 值
+		res = h.db.Model(&user).Updates(map[string]interface{}{
+			"mobile":           data.Mobile,
+			"calls":            data.Calls,
+			"img_calls":        data.ImgCalls,
+			"status":           data.Status,
+			"vip":              data.Vip,
+			"chat_roles_json":  utils.JsonEncode(data.ChatRoles),
+			"chat_models_json": utils.JsonEncode(data.ChatModels),
+			"expired_time":     utils.Str2stamp(data.ExpiredTime),
+		})
+	} else {
+		salt := utils.RandString(8)
+		u := model.User{
+			Mobile:      data.Mobile,
+			Password:    utils.GenPassword(data.Password, salt),
+			Avatar:      "/images/avatar/user.png",
+			Salt:        salt,
+			Status:      true,
+			ChatRoles:   utils.JsonEncode(data.ChatRoles),
+			ChatModels:  utils.JsonEncode(data.ChatModels),
+			ExpiredTime: utils.Str2stamp(data.ExpiredTime),
+			ChatConfig: utils.JsonEncode(types.UserChatConfig{
+				ApiKeys: map[types.Platform]string{
+					types.OpenAI:  "",
+					types.Azure:   "",
+					types.ChatGLM: "",
+				},
+			}),
+			Calls:    data.Calls,
+			ImgCalls: data.ImgCalls,
+		}
+		res = h.db.Create(&u)
+		_ = utils.CopyObject(u, &userVo)
+		userVo.Id = u.Id
+		userVo.CreatedAt = u.CreatedAt.Unix()
+		userVo.UpdatedAt = u.UpdatedAt.Unix()
+	}
+
 	if res.Error != nil {
 		resp.ERROR(c, "更新数据库失败")
 		return
 	}

-	resp.SUCCESS(c)
+	resp.SUCCESS(c, userVo)
+}
+
+// ResetPass 重置密码
+func (h *UserHandler) ResetPass(c *gin.Context) {
+	var data struct {
+		Id       uint
+		Password string
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	var user model.User
+	res := h.db.First(&user, data.Id)
+	if res.Error != nil {
+		resp.ERROR(c, "No user found")
+		return
+	}
+
+	password := utils.GenPassword(data.Password, user.Salt)
+	user.Password = password
+	res = h.db.Updates(&user)
+	if res.Error != nil {
+		resp.ERROR(c)
+	} else {
+		resp.SUCCESS(c)
+	}
 }

 func (h *UserHandler) Remove(c *gin.Context) {
@@ -125,7 +198,7 @@ func (h *UserHandler) LoginLog(c *gin.Context) {
 	h.db.Model(&model.UserLoginLog{}).Count(&total)
 	offset := (page - 1) * pageSize
 	var items []model.UserLoginLog
-	res := h.db.Offset(offset).Limit(pageSize).Find(&items)
+	res := h.db.Offset(offset).Limit(pageSize).Order("id DESC").Find(&items)
 	if res.Error != nil {
 		resp.ERROR(c, "获取数据失败")
 		return
--- a/api/handler/base_handler.go
+++ b/api/handler/base_handler.go
@@ -2,8 +2,10 @@ package handler

 import (
 	"chatplus/core"
+	"chatplus/core/types"
 	logger2 "chatplus/logger"
-	"strconv"
+	"chatplus/utils"
+	"fmt"
 	"strings"

 	"github.com/gin-gonic/gin"
@@ -20,47 +22,38 @@ func (h *BaseHandler) GetTrim(c *gin.Context, key string) string {
 }

 func (h *BaseHandler) PostInt(c *gin.Context, key string, defaultValue int) int {
-	return intValue(c.PostForm(key), defaultValue)
+	return utils.IntValue(c.PostForm(key), defaultValue)
 }

 func (h *BaseHandler) GetInt(c *gin.Context, key string, defaultValue int) int {
-	return intValue(c.Query(key), defaultValue)
-}
-
-func intValue(str string, defaultValue int) int {
-	value, err := strconv.Atoi(str)
-	if err != nil {
-		return defaultValue
-	}
-	return value
+	return utils.IntValue(c.Query(key), defaultValue)
 }

 func (h *BaseHandler) GetFloat(c *gin.Context, key string) float64 {
-	return floatValue(c.Query(key))
+	return utils.FloatValue(c.Query(key))
 }
 func (h *BaseHandler) PostFloat(c *gin.Context, key string) float64 {
-	return floatValue(c.PostForm(key))
-}
-
-func floatValue(str string) float64 {
-	value, err := strconv.ParseFloat(str, 64)
-	if err != nil {
-		return 0
-	}
-	return value
+	return utils.FloatValue(c.PostForm(key))
 }

 func (h *BaseHandler) GetBool(c *gin.Context, key string) bool {
-	return boolValue(c.Query(key))
+	return utils.BoolValue(c.Query(key))
 }
 func (h *BaseHandler) PostBool(c *gin.Context, key string) bool {
-	return boolValue(c.PostForm(key))
+	return utils.BoolValue(c.PostForm(key))
+}
+func (h *BaseHandler) GetUserKey(c *gin.Context) string {
+	userId, ok := c.Get(types.LoginUserID)
+	if !ok {
+		return ""
+	}
+	return fmt.Sprintf("users/%v", userId)
 }

-func boolValue(str string) bool {
-	value, err := strconv.ParseBool(str)
-	if err != nil {
-		return false
+func (h *BaseHandler) GetLoginUserId(c *gin.Context) uint {
+	userId, ok := c.Get(types.LoginUserID)
+	if !ok {
+		return 0
 	}
-	return value
+	return uint(utils.IntValue(utils.InterfaceToString(userId), 0))
 }
--- a/api/handler/captcha_handler.go
+++ b/api/handler/captcha_handler.go
@@ -0,0 +1,47 @@
+package handler
+
+import (
+	"chatplus/core/types"
+	"chatplus/service"
+	"chatplus/utils/resp"
+	"github.com/gin-gonic/gin"
+)
+
+// 今日头条函数实现
+
+type CaptchaHandler struct {
+	service *service.CaptchaService
+}
+
+func NewCaptchaHandler(s *service.CaptchaService) *CaptchaHandler {
+	return &CaptchaHandler{service: s}
+}
+
+func (h *CaptchaHandler) Get(c *gin.Context) {
+	data, err := h.service.Get()
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, data)
+}
+
+// Check verify the captcha data
+func (h *CaptchaHandler) Check(c *gin.Context) {
+	var data struct {
+		Key  string `json:"key"`
+		Dots string `json:"dots"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if h.service.Check(data) {
+		resp.SUCCESS(c)
+	} else {
+		resp.ERROR(c)
+	}
+
+}
--- a/api/handler/chat_handler.go
+++ b/api/handler/chat_handler.go
@@ -1,520 +0,0 @@
-package handler
-
-import (
-	"bufio"
-	"bytes"
-	"chatplus/core"
-	"chatplus/core/types"
-	"chatplus/service/function"
-	"chatplus/store/model"
-	"chatplus/store/vo"
-	"chatplus/utils"
-	"chatplus/utils/resp"
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"strings"
-	"time"
-	"unicode/utf8"
-
-	"github.com/gin-gonic/gin"
-	"github.com/gorilla/websocket"
-	"gorm.io/gorm"
-)
-
-const ErrorMsg = "抱歉，AI 助手开小差了，请稍后再试。"
-
-type ChatHandler struct {
-	BaseHandler
-	db         *gorm.DB
-	funcZaoBao *function.FuncZaoBao
-}
-
-func NewChatHandler(app *core.AppServer, db *gorm.DB, zaoBao *function.FuncZaoBao) *ChatHandler {
-	handler := ChatHandler{db: db, funcZaoBao: zaoBao}
-	handler.App = app
-	return &handler
-}
-
-// ChatHandle 处理聊天 WebSocket 请求
-func (h *ChatHandler) ChatHandle(c *gin.Context) {
-	ws, err := (&websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}).Upgrade(c.Writer, c.Request, nil)
-	if err != nil {
-		logger.Error(err)
-		return
-	}
-	sessionId := c.Query("session_id")
-	roleId := h.GetInt(c, "role_id", 0)
-	chatId := c.Query("chat_id")
-	chatModel := c.Query("model")
-
-	session := h.App.ChatSession.Get(sessionId)
-	if session.SessionId == "" {
-		user, err := utils.GetLoginUser(c, h.db)
-		if err != nil {
-			logger.Info("用户未登录")
-			c.Abort()
-			return
-		}
-		session = types.ChatSession{
-			SessionId: sessionId,
-			ClientIP:  c.ClientIP(),
-			Username:  user.Username,
-			UserId:    user.Id,
-		}
-		h.App.ChatSession.Put(sessionId, session)
-	}
-
-	// use old chat data override the chat model and role ID
-	var chat model.ChatItem
-	res := h.db.Where("chat_id=?", chatId).First(&chat)
-	if res.Error == nil {
-		chatModel = chat.Model
-		roleId = int(chat.RoleId)
-	}
-
-	session.ChatId = chatId
-	session.Model = chatModel
-	logger.Infof("New websocket connected, IP: %s, Username: %s", c.Request.RemoteAddr, session.Username)
-	client := types.NewWsClient(ws)
-	var chatRole model.ChatRole
-	res = h.db.First(&chatRole, roleId)
-	if res.Error != nil || !chatRole.Enable {
-		replyMessage(client, "当前聊天角色不存在或者未启用！！！")
-		c.Abort()
-		return
-	}
-
-	// 保存会话连接
-	h.App.ChatClients.Put(sessionId, client)
-	go func() {
-		for {
-			_, message, err := client.Receive()
-			if err != nil {
-				logger.Error(err)
-				client.Close()
-				h.App.ChatClients.Delete(sessionId)
-				h.App.ReqCancelFunc.Delete(sessionId)
-				return
-			}
-			logger.Info("Receive a message: ", string(message))
-			//replyMessage(client, "这是一条测试消息！")
-			ctx, cancel := context.WithCancel(context.Background())
-			h.App.ReqCancelFunc.Put(sessionId, cancel)
-			// 回复消息
-			err = h.sendMessage(ctx, session, chatRole, string(message), client)
-			if err != nil {
-				logger.Error(err)
-			} else {
-				replyChunkMessage(client, types.WsMessage{Type: types.WsEnd})
-				logger.Info("回答完毕: " + string(message))
-			}
-
-		}
-	}()
-}
-
-// 将消息发送给 ChatGPT 并获取结果，通过 WebSocket 推送到客户端
-func (h *ChatHandler) sendMessage(ctx context.Context, session types.ChatSession, role model.ChatRole, prompt string, ws types.Client) error {
-	promptCreatedAt := time.Now() // 记录提问时间
-
-	var user model.User
-	res := h.db.Model(&model.User{}).First(&user, session.UserId)
-	if res.Error != nil {
-		replyMessage(ws, "非法用户，请联系管理员！")
-		return res.Error
-	}
-	var userVo vo.User
-	err := utils.CopyObject(user, &userVo)
-	userVo.Id = user.Id
-	if err != nil {
-		return errors.New("User 对象转换失败，" + err.Error())
-	}
-
-	if userVo.Status == false {
-		replyMessage(ws, "您的账号已经被禁用，如果疑问，请联系管理员！")
-		replyMessage(ws, "![](/images/wx.png)")
-		return nil
-	}
-
-	if userVo.Calls <= 0 {
-		replyMessage(ws, "您的对话次数已经用尽，请联系管理员充值！")
-		replyMessage(ws, "![](/images/wx.png)")
-		return nil
-	}
-
-	if userVo.ExpiredTime > 0 && userVo.ExpiredTime <= time.Now().Unix() {
-		replyMessage(ws, "您的账号已经过期，请联系管理员！")
-		replyMessage(ws, "![](/images/wx.png)")
-		return nil
-	}
-	var req = types.ApiRequest{
-		Model:       session.Model,
-		Temperature: userVo.ChatConfig.Temperature,
-		MaxTokens:   userVo.ChatConfig.MaxTokens,
-		Stream:      true,
-	}
-
-	// 加载聊天上下文
-	var chatCtx []types.Message
-	if userVo.ChatConfig.EnableContext {
-		if h.App.ChatContexts.Has(session.ChatId) {
-			chatCtx = h.App.ChatContexts.Get(session.ChatId)
-		} else {
-			// 加载角色信息
-			var messages []types.Message
-			err := utils.JsonDecode(role.Context, &messages)
-			if err == nil {
-				chatCtx = messages
-			}
-			// TODO: 这里默认加载最近 4 条聊天记录作为上下文，后期应该做成可配置的
-			var historyMessages []model.HistoryMessage
-			res := h.db.Where("chat_id = ?", session.ChatId).Limit(4).Order("created_at desc").Find(&historyMessages)
-			if res.Error == nil {
-				for _, msg := range historyMessages {
-					ms := types.Message{Role: "user", Content: msg.Content}
-					if msg.Type == types.ReplyMsg {
-						ms.Role = "assistant"
-					}
-					chatCtx = append(chatCtx, ms)
-				}
-			}
-		}
-
-		if h.App.Debug { // 调试打印聊天上下文
-			logger.Info("聊天上下文：", chatCtx)
-		}
-	}
-	req.Messages = append(chatCtx, types.Message{
-		Role:    "user",
-		Content: prompt,
-	})
-	var apiKey string
-	response, err := h.fakeRequest(ctx, userVo, &apiKey, req)
-	if err != nil {
-		if strings.Contains(err.Error(), "context canceled") {
-			logger.Info("用户取消了请求：", prompt)
-			return nil
-		} else if strings.Contains(err.Error(), "no available key") {
-			replyMessage(ws, "抱歉😔😔😔，系统已经没有可用的 API KEY🔑，您可以导入自己的 API KEY🔑 继续使用！🙏🙏🙏")
-			return nil
-		} else {
-			logger.Error(err)
-		}
-
-		replyMessage(ws, ErrorMsg)
-		replyMessage(ws, "![](/images/wx.png)")
-		return err
-	} else {
-		defer response.Body.Close()
-	}
-
-	//contentType := response.Header.Get("Content-Type")
-	//if strings.Contains(contentType, "text/event-stream") || true {
-	if true {
-		replyCreatedAt := time.Now()
-		// 循环读取 Chunk 消息
-		var message = types.Message{}
-		var contents = make([]string, 0)
-		var functionCall = false
-		var functionName string
-		var arguments = make([]string, 0)
-		reader := bufio.NewReader(response.Body)
-		for {
-			line, err := reader.ReadString('\n')
-			if err != nil {
-				if strings.Contains(err.Error(), "context canceled") {
-					logger.Info("用户取消了请求：", prompt)
-				} else {
-					logger.Error(err)
-				}
-				break
-			}
-			if !strings.Contains(line, "data:") || len(line) < 30 {
-				continue
-			}
-
-			var responseBody = types.ApiResponse{}
-			err = json.Unmarshal([]byte(line[6:]), &responseBody)
-			if err != nil || len(responseBody.Choices) == 0 { // 数据解析出错
-				logger.Error(err, line)
-				replyMessage(ws, ErrorMsg)
-				replyMessage(ws, "![](/images/wx.png)")
-				break
-			}
-
-			fun := responseBody.Choices[0].Delta.FunctionCall
-			if functionCall && fun.Name == "" {
-				arguments = append(arguments, fun.Arguments)
-				continue
-			}
-
-			if !utils.IsEmptyValue(fun) {
-				functionCall = true
-				functionName = fun.Name
-				replyChunkMessage(ws, types.WsMessage{Type: types.WsStart})
-				replyChunkMessage(ws, types.WsMessage{Type: types.WsMiddle, Content: fmt.Sprintf("正在调用函数 %s 作答 ...\n\n", functionName)})
-				continue
-			}
-
-			if responseBody.Choices[0].FinishReason == "function_call" { // 函数调用完毕
-				break
-			}
-
-			// 初始化 role
-			if responseBody.Choices[0].Delta.Role != "" && message.Role == "" {
-				message.Role = responseBody.Choices[0].Delta.Role
-				replyChunkMessage(ws, types.WsMessage{Type: types.WsStart})
-				continue
-			} else if responseBody.Choices[0].FinishReason != "" {
-				break // 输出完成或者输出中断了
-			} else {
-				content := responseBody.Choices[0].Delta.Content
-				contents = append(contents, content)
-				replyChunkMessage(ws, types.WsMessage{
-					Type:    types.WsMiddle,
-					Content: responseBody.Choices[0].Delta.Content,
-				})
-			}
-		} // end for
-
-		if functionCall { // 调用函数完成任务
-			// TODO 调用函数完成任务
-			data, err := h.funcZaoBao.Fetch()
-			if err != nil {
-				replyChunkMessage(ws, types.WsMessage{
-					Type:    types.WsMiddle,
-					Content: "调用函数出错",
-				})
-			} else {
-				replyChunkMessage(ws, types.WsMessage{
-					Type:    types.WsMiddle,
-					Content: data,
-				})
-			}
-			contents = append(contents, data)
-		}
-
-		// 消息发送成功
-		if len(contents) > 0 {
-			// 更新用户的对话次数
-			res := h.db.Model(&user).UpdateColumn("calls", gorm.Expr("calls - ?", 1))
-			if res.Error != nil {
-				return res.Error
-			}
-
-			if message.Role == "" {
-				message.Role = "assistant"
-			}
-			message.Content = strings.Join(contents, "")
-			useMsg := types.Message{Role: "user", Content: prompt}
-
-			// 更新上下文消息，如果是调用函数则不需要更新上下文
-			if userVo.ChatConfig.EnableContext && functionCall == false {
-				chatCtx = append(chatCtx, useMsg)  // 提问消息
-				chatCtx = append(chatCtx, message) // 回复消息
-				h.App.ChatContexts.Put(session.ChatId, chatCtx)
-			}
-
-			// 追加聊天记录
-			if userVo.ChatConfig.EnableHistory {
-				// for prompt
-				token, err := utils.CalcTokens(prompt, req.Model)
-				if err != nil {
-					logger.Error(err)
-				}
-				historyUserMsg := model.HistoryMessage{
-					UserId:  userVo.Id,
-					ChatId:  session.ChatId,
-					RoleId:  role.Id,
-					Type:    types.PromptMsg,
-					Icon:    user.Avatar,
-					Content: prompt,
-					Tokens:  token,
-				}
-				historyUserMsg.CreatedAt = promptCreatedAt
-				historyUserMsg.UpdatedAt = promptCreatedAt
-				res := h.db.Save(&historyUserMsg)
-				if res.Error != nil {
-					logger.Error("failed to save prompt history message: ", res.Error)
-				}
-
-				// for reply
-				token, err = utils.CalcTokens(message.Content, req.Model)
-				if err != nil {
-					logger.Error(err)
-				}
-				historyReplyMsg := model.HistoryMessage{
-					UserId:  userVo.Id,
-					ChatId:  session.ChatId,
-					RoleId:  role.Id,
-					Type:    types.ReplyMsg,
-					Icon:    role.Icon,
-					Content: message.Content,
-					Tokens:  token,
-				}
-				historyReplyMsg.CreatedAt = replyCreatedAt
-				historyReplyMsg.UpdatedAt = replyCreatedAt
-				res = h.db.Create(&historyReplyMsg)
-				if res.Error != nil {
-					logger.Error("failed to save reply history message: ", res.Error)
-				}
-
-				// 统计用户 token 数量
-				h.db.Model(&user).UpdateColumn("tokens", gorm.Expr("tokens + ?",
-					historyUserMsg.Tokens+historyReplyMsg.Tokens))
-			}
-
-			// 保存当前会话
-			var chatItem model.ChatItem
-			res = h.db.Where("chat_id = ?", session.ChatId).First(&chatItem)
-			if res.Error != nil {
-				chatItem.ChatId = session.ChatId
-				chatItem.UserId = session.UserId
-				chatItem.RoleId = role.Id
-				chatItem.Model = session.Model
-				if utf8.RuneCountInString(prompt) > 30 {
-					chatItem.Title = string([]rune(prompt)[:30]) + "..."
-				} else {
-					chatItem.Title = prompt
-				}
-				h.db.Create(&chatItem)
-			}
-		}
-	} else {
-		body, err := io.ReadAll(response.Body)
-		if err != nil {
-			return fmt.Errorf("error with reading response: %v", err)
-		}
-		var res types.ApiError
-		err = json.Unmarshal(body, &res)
-		if err != nil {
-			return fmt.Errorf("error with decode response: %v", err)
-		}
-
-		// OpenAI API 调用异常处理
-		// TODO: 是否考虑重发消息？
-		if strings.Contains(res.Error.Message, "This key is associated with a deactivated account") {
-			replyMessage(ws, "请求 OpenAI API 失败：API KEY 所关联的账户被禁用。")
-			// 移除当前 API key
-			h.db.Where("value = ?", apiKey).Delete(&model.ApiKey{})
-		} else if strings.Contains(res.Error.Message, "You exceeded your current quota") {
-			replyMessage(ws, "请求 OpenAI API 失败：API KEY 触发并发限制，请稍后再试。")
-		} else if strings.Contains(res.Error.Message, "This model's maximum context length") {
-			replyMessage(ws, "当前会话上下文长度超出限制，已为您删减会话上下文！")
-			// 只保留最近的三条记录
-			chatContext := h.App.ChatContexts.Get(session.ChatId)
-			if len(chatContext) > 3 {
-				chatContext = chatContext[len(chatContext)-3:]
-			}
-			h.App.ChatContexts.Put(session.ChatId, chatContext)
-			return h.sendMessage(ctx, session, role, prompt, ws)
-		} else {
-			replyMessage(ws, "请求 OpenAI API 失败："+res.Error.Message)
-		}
-	}
-
-	return nil
-}
-
-// 发送请求到 OpenAI 服务器
-// useOwnApiKey: 是否使用了用户自己的 API KEY
-func (h *ChatHandler) doRequest(ctx context.Context, user vo.User, apiKey *string, req types.ApiRequest) (*http.Response, error) {
-	var client *http.Client
-	requestBody, err := json.Marshal(req)
-	if err != nil {
-		return nil, err
-	}
-	// 创建 HttpClient 请求对象
-	request, err := http.NewRequest(http.MethodPost, h.App.ChatConfig.ApiURL, bytes.NewBuffer(requestBody))
-	if err != nil {
-		return nil, err
-	}
-
-	request = request.WithContext(ctx)
-	request.Header.Add("Content-Type", "application/json")
-
-	proxyURL := h.App.Config.ProxyURL
-	if proxyURL == "" {
-		client = &http.Client{}
-	} else { // 使用代理
-		proxy, _ := url.Parse(proxyURL)
-		client = &http.Client{
-			Transport: &http.Transport{
-				Proxy: http.ProxyURL(proxy),
-			},
-		}
-	}
-	// 查询当前用户是否导入了自己的 API KEY
-	if user.ChatConfig.ApiKey != "" {
-		logger.Info("使用用户自己的 API KEY: ", user.ChatConfig.ApiKey)
-		*apiKey = user.ChatConfig.ApiKey
-	} else { // 获取系统的 API KEY
-		var key model.ApiKey
-		res := h.db.Where("user_id = ?", 0).Order("last_used_at ASC").First(&key)
-		if res.Error != nil {
-			return nil, errors.New("no available key, please import key")
-		}
-		*apiKey = key.Value
-		// 更新 API KEY 的最后使用时间
-		h.db.Model(&key).UpdateColumn("last_used_at", time.Now().Unix())
-	}
-
-	logger.Infof("Sending OpenAI request, KEY: %s, PROXY: %s, Model: %s", *apiKey, proxyURL, req.Model)
-	request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiKey))
-	return client.Do(request)
-}
-
-func (h *ChatHandler) fakeRequest(ctx context.Context, user vo.User, apiKey *string, req types.ApiRequest) (*http.Response, error) {
-	link := "https://img.r9it.com/chatgpt/response"
-	client := &http.Client{}
-	request, _ := http.NewRequest(http.MethodGet, link, nil)
-	return client.Do(request)
-}
-
-// 回复客户片段端消息
-func replyChunkMessage(client types.Client, message types.WsMessage) {
-	msg, err := json.Marshal(message)
-	if err != nil {
-		logger.Errorf("Error for decoding json data: %v", err.Error())
-		return
-	}
-	err = client.(*types.WsClient).Send(msg)
-	if err != nil {
-		logger.Errorf("Error for reply message: %v", err.Error())
-	}
-}
-
-// 回复客户端一条完整的消息
-func replyMessage(ws types.Client, message string) {
-	replyChunkMessage(ws, types.WsMessage{Type: types.WsStart})
-	replyChunkMessage(ws, types.WsMessage{Type: types.WsMiddle, Content: message})
-	replyChunkMessage(ws, types.WsMessage{Type: types.WsEnd})
-}
-
-// Tokens 统计 token 数量
-func (h *ChatHandler) Tokens(c *gin.Context) {
-	text := c.Query("text")
-	md := c.Query("model")
-	tokens, err := utils.CalcTokens(text, md)
-	if err != nil {
-		resp.ERROR(c, err.Error())
-		return
-	}
-
-	resp.SUCCESS(c, tokens)
-}
-
-// StopGenerate 停止生成
-func (h *ChatHandler) StopGenerate(c *gin.Context) {
-	sessionId := c.Query("session_id")
-	if h.App.ReqCancelFunc.Has(sessionId) {
-		h.App.ReqCancelFunc.Get(sessionId)()
-		h.App.ReqCancelFunc.Delete(sessionId)
-	}
-	resp.SUCCESS(c, types.OkMsg)
-}
--- a/api/handler/chat_model_handler.go
+++ b/api/handler/chat_model_handler.go
@@ -0,0 +1,61 @@
+package handler
+
+import (
+	"chatplus/core"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type ChatModelHandler struct {
+	BaseHandler
+	db *gorm.DB
+}
+
+func NewChatModelHandler(app *core.AppServer, db *gorm.DB) *ChatModelHandler {
+	h := ChatModelHandler{db: db}
+	h.App = app
+	return &h
+}
+
+// List 模型列表
+func (h *ChatModelHandler) List(c *gin.Context) {
+	var items []model.ChatModel
+	var chatModels = make([]vo.ChatModel, 0)
+	// 只加载用户订阅的 AI 模型
+	user, err := utils.GetLoginUser(c, h.db)
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+
+	var models []string
+	err = utils.JsonDecode(user.ChatModels, &models)
+	if err != nil {
+		resp.ERROR(c, "当前用户没有订阅任何模型")
+		return
+	}
+
+	// 查询用户有权限访问的模型以及所有开放的模型
+	res := h.db.Where("enabled = ?", true).Where(
+		h.db.Where("value IN ?", models).Or("open =?", true),
+	).Order("sort_num ASC").Find(&items)
+	if res.Error == nil {
+		for _, item := range items {
+			var cm vo.ChatModel
+			err := utils.CopyObject(item, &cm)
+			if err == nil {
+				cm.Id = item.Id
+				cm.CreatedAt = item.CreatedAt.Unix()
+				cm.UpdatedAt = item.UpdatedAt.Unix()
+				chatModels = append(chatModels, cm)
+			} else {
+				logger.Error(err)
+			}
+		}
+	}
+	resp.SUCCESS(c, chatModels)
+}
--- a/api/handler/chat_role_handler.go
+++ b/api/handler/chat_role_handler.go
@@ -2,6 +2,7 @@ package handler

 import (
 	"chatplus/core"
+	"chatplus/core/types"
 	"chatplus/store/model"
 	"chatplus/store/vo"
 	"chatplus/utils"
@@ -24,20 +25,39 @@ func NewChatRoleHandler(app *core.AppServer, db *gorm.DB) *ChatRoleHandler {

 // List get user list
 func (h *ChatRoleHandler) List(c *gin.Context) {
+	all := h.GetBool(c, "all")
 	var roles []model.ChatRole
-	res := h.db.Where("enable", true).Order("sort ASC").Find(&roles)
+	res := h.db.Where("enable", true).Order("sort_num ASC").Find(&roles)
 	if res.Error != nil {
 		resp.ERROR(c, "No roles found,"+res.Error.Error())
 		return
 	}

-	user, err := utils.GetLoginUser(c, h.db)
-	if err != nil {
+	// 获取所有角色
+	if all {
+		// 转成 vo
+		var roleVos = make([]vo.ChatRole, 0)
+		for _, r := range roles {
+			var v vo.ChatRole
+			err := utils.CopyObject(r, &v)
+			if err == nil {
+				v.Id = r.Id
+				roleVos = append(roleVos, v)
+			}
+		}
+		resp.SUCCESS(c, roleVos)
+		return
+	}
+
+	userId := h.GetInt(c, "user_id", 0)
+	if userId == 0 {
 		resp.NotAuth(c)
 		return
 	}
+	var user model.User
+	h.db.First(&user, userId)
 	var roleKeys []string
-	err = utils.JsonDecode(user.ChatRoles, &roleKeys)
+	err := utils.JsonDecode(user.ChatRoles, &roleKeys)
 	if err != nil {
 		resp.ERROR(c, "角色解析失败！")
 		return
@@ -57,3 +77,29 @@ func (h *ChatRoleHandler) List(c *gin.Context) {
 	}
 	resp.SUCCESS(c, roleVos)
 }
+
+// UpdateRole 更新用户聊天角色
+func (h *ChatRoleHandler) UpdateRole(c *gin.Context) {
+	user, err := utils.GetLoginUser(c, h.db)
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+
+	var data struct {
+		Keys []string `json:"keys"`
+	}
+	if err = c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	res := h.db.Model(&model.User{}).Where("id = ?", user.Id).UpdateColumn("chat_roles_json", utils.JsonEncode(data.Keys))
+	if res.Error != nil {
+		logger.Error("添加应用失败：", err)
+		resp.ERROR(c, "更新数据库失败！")
+		return
+	}
+
+	resp.SUCCESS(c)
+}
--- a/api/handler/chatimpl/azure_handler.go
+++ b/api/handler/chatimpl/azure_handler.go
@@ -0,0 +1,286 @@
+package chatimpl
+
+import (
+	"bufio"
+	"chatplus/core/types"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"context"
+	"encoding/json"
+	"fmt"
+	"gorm.io/gorm"
+	"html/template"
+	"io"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+// 微软 Azure 模型消息发送实现
+
+func (h *ChatHandler) sendAzureMessage(
+	chatCtx []interface{},
+	req types.ApiRequest,
+	userVo vo.User,
+	ctx context.Context,
+	session *types.ChatSession,
+	role model.ChatRole,
+	prompt string,
+	ws *types.WsClient) error {
+	promptCreatedAt := time.Now() // 记录提问时间
+	start := time.Now()
+	var apiKey = userVo.ChatConfig.ApiKeys[session.Model.Platform]
+	response, err := h.doRequest(ctx, req, session.Model.Platform, &apiKey)
+	logger.Info("HTTP请求完成，耗时：", time.Now().Sub(start))
+	if err != nil {
+		if strings.Contains(err.Error(), "context canceled") {
+			logger.Info("用户取消了请求：", prompt)
+			return nil
+		} else if strings.Contains(err.Error(), "no available key") {
+			utils.ReplyMessage(ws, "抱歉😔😔😔，系统已经没有可用的 API KEY，请联系管理员！")
+			return nil
+		} else {
+			logger.Error(err)
+		}
+
+		utils.ReplyMessage(ws, ErrorMsg)
+		utils.ReplyMessage(ws, ErrImg)
+		return err
+	} else {
+		defer response.Body.Close()
+	}
+
+	contentType := response.Header.Get("Content-Type")
+	if strings.Contains(contentType, "text/event-stream") {
+		replyCreatedAt := time.Now() // 记录回复时间
+		// 循环读取 Chunk 消息
+		var message = types.Message{}
+		var contents = make([]string, 0)
+		var functionCall = false
+		var functionName string
+		var arguments = make([]string, 0)
+		scanner := bufio.NewScanner(response.Body)
+		for scanner.Scan() {
+			line := scanner.Text()
+			if !strings.Contains(line, "data:") || len(line) < 30 {
+				continue
+			}
+
+			var responseBody = types.ApiResponse{}
+			err = json.Unmarshal([]byte(line[6:]), &responseBody)
+			if err != nil || len(responseBody.Choices) == 0 { // 数据解析出错
+				logger.Error(err, line)
+				utils.ReplyMessage(ws, ErrorMsg)
+				utils.ReplyMessage(ws, ErrImg)
+				break
+			}
+
+			fun := responseBody.Choices[0].Delta.FunctionCall
+			if functionCall && fun.Name == "" {
+				arguments = append(arguments, fun.Arguments)
+				continue
+			}
+
+			if !utils.IsEmptyValue(fun) {
+				functionName = fun.Name
+				f := h.App.Functions[functionName]
+				if f != nil {
+					functionCall = true
+					utils.ReplyChunkMessage(ws, types.WsMessage{Type: types.WsStart})
+					utils.ReplyChunkMessage(ws, types.WsMessage{Type: types.WsMiddle, Content: fmt.Sprintf("正在调用函数 `%s` 作答 ...\n\n", f.Name())})
+					continue
+				}
+			}
+
+			if responseBody.Choices[0].FinishReason == "function_call" { // 函数调用完毕
+				break
+			}
+
+			// 初始化 role
+			if responseBody.Choices[0].Delta.Role != "" && message.Role == "" {
+				message.Role = responseBody.Choices[0].Delta.Role
+				utils.ReplyChunkMessage(ws, types.WsMessage{Type: types.WsStart})
+				continue
+			} else if responseBody.Choices[0].FinishReason != "" {
+				break // 输出完成或者输出中断了
+			} else {
+				content := responseBody.Choices[0].Delta.Content
+				contents = append(contents, utils.InterfaceToString(content))
+				utils.ReplyChunkMessage(ws, types.WsMessage{
+					Type:    types.WsMiddle,
+					Content: utils.InterfaceToString(responseBody.Choices[0].Delta.Content),
+				})
+			}
+		} // end for
+
+		if err := scanner.Err(); err != nil {
+			if strings.Contains(err.Error(), "context canceled") {
+				logger.Info("用户取消了请求：", prompt)
+			} else {
+				logger.Error("信息读取出错：", err)
+			}
+		}
+
+		if functionCall { // 调用函数完成任务
+			var params map[string]interface{}
+			_ = utils.JsonDecode(strings.Join(arguments, ""), &params)
+			logger.Debugf("函数名称: %s, 函数参数：%s", functionName, params)
+
+			// for creating image, check if the user's img_calls > 0
+			if functionName == types.FuncImage && userVo.ImgCalls <= 0 {
+				utils.ReplyMessage(ws, "**当前用户剩余绘图次数已用尽，请扫描下面二维码联系管理员！**")
+				utils.ReplyMessage(ws, ErrImg)
+			} else {
+				f := h.App.Functions[functionName]
+				if functionName == types.FuncImage {
+					params["user_id"] = userVo.Id
+					params["role_id"] = role.Id
+					params["chat_id"] = session.ChatId
+					params["icon"] = "/images/avatar/mid_journey.png"
+					params["session_id"] = session.SessionId
+				}
+				data, err := f.Invoke(params)
+				if err != nil {
+					msg := "调用函数出错：" + err.Error()
+					utils.ReplyChunkMessage(ws, types.WsMessage{
+						Type:    types.WsMiddle,
+						Content: msg,
+					})
+					contents = append(contents, msg)
+				} else {
+					content := data
+					if functionName == types.FuncImage {
+						content = fmt.Sprintf("下面是根据您的描述创作的图片，他们描绘了 【%s】 的场景", params["prompt"])
+						// update user's img_calls
+						h.db.Model(&model.User{}).Where("id = ?", userVo.Id).UpdateColumn("img_calls", gorm.Expr("img_calls - ?", 1))
+					}
+
+					utils.ReplyChunkMessage(ws, types.WsMessage{
+						Type:    types.WsMiddle,
+						Content: content,
+					})
+					contents = append(contents, content)
+				}
+			}
+		}
+
+		// 消息发送成功
+		if len(contents) > 0 {
+			// 更新用户的对话次数
+			h.subUserCalls(userVo, session)
+
+			if message.Role == "" {
+				message.Role = "assistant"
+			}
+			message.Content = strings.Join(contents, "")
+			useMsg := types.Message{Role: "user", Content: prompt}
+
+			// 更新上下文消息，如果是调用函数则不需要更新上下文
+			if h.App.ChatConfig.EnableContext && functionCall == false {
+				chatCtx = append(chatCtx, useMsg)  // 提问消息
+				chatCtx = append(chatCtx, message) // 回复消息
+				h.App.ChatContexts.Put(session.ChatId, chatCtx)
+			}
+
+			// 追加聊天记录
+			if h.App.ChatConfig.EnableHistory {
+				useContext := true
+				if functionCall {
+					useContext = false
+				}
+
+				// for prompt
+				promptToken, err := utils.CalcTokens(prompt, req.Model)
+				if err != nil {
+					logger.Error(err)
+				}
+				historyUserMsg := model.HistoryMessage{
+					UserId:     userVo.Id,
+					ChatId:     session.ChatId,
+					RoleId:     role.Id,
+					Type:       types.PromptMsg,
+					Icon:       userVo.Avatar,
+					Content:    template.HTMLEscapeString(prompt),
+					Tokens:     promptToken,
+					UseContext: useContext,
+				}
+				historyUserMsg.CreatedAt = promptCreatedAt
+				historyUserMsg.UpdatedAt = promptCreatedAt
+				res := h.db.Save(&historyUserMsg)
+				if res.Error != nil {
+					logger.Error("failed to save prompt history message: ", res.Error)
+				}
+
+				// 计算本次对话消耗的总 token 数量
+				var totalTokens = 0
+				if functionCall { // prompt + 函数名 + 参数 token
+					tokens, _ := utils.CalcTokens(functionName, req.Model)
+					totalTokens += tokens
+					tokens, _ = utils.CalcTokens(utils.InterfaceToString(arguments), req.Model)
+					totalTokens += tokens
+				} else {
+					totalTokens, _ = utils.CalcTokens(message.Content, req.Model)
+				}
+				totalTokens += getTotalTokens(req)
+
+				historyReplyMsg := model.HistoryMessage{
+					UserId:     userVo.Id,
+					ChatId:     session.ChatId,
+					RoleId:     role.Id,
+					Type:       types.ReplyMsg,
+					Icon:       role.Icon,
+					Content:    message.Content,
+					Tokens:     totalTokens,
+					UseContext: useContext,
+				}
+				historyReplyMsg.CreatedAt = replyCreatedAt
+				historyReplyMsg.UpdatedAt = replyCreatedAt
+				res = h.db.Create(&historyReplyMsg)
+				if res.Error != nil {
+					logger.Error("failed to save reply history message: ", res.Error)
+				}
+
+				// 更新用户信息
+				h.incUserTokenFee(userVo.Id, totalTokens)
+			}
+
+			// 保存当前会话
+			var chatItem model.ChatItem
+			res := h.db.Where("chat_id = ?", session.ChatId).First(&chatItem)
+			if res.Error != nil {
+				chatItem.ChatId = session.ChatId
+				chatItem.UserId = session.UserId
+				chatItem.RoleId = role.Id
+				chatItem.ModelId = session.Model.Id
+				if utf8.RuneCountInString(prompt) > 30 {
+					chatItem.Title = string([]rune(prompt)[:30]) + "..."
+				} else {
+					chatItem.Title = prompt
+				}
+				h.db.Create(&chatItem)
+			}
+		}
+	} else {
+		body, err := io.ReadAll(response.Body)
+		if err != nil {
+			return fmt.Errorf("error with reading response: %v", err)
+		}
+		var res types.ApiError
+		err = json.Unmarshal(body, &res)
+		if err != nil {
+			return fmt.Errorf("error with decode response: %v", err)
+		}
+
+		if strings.Contains(res.Error.Message, "maximum context length") {
+			logger.Error(res.Error.Message)
+			utils.ReplyMessage(ws, "当前会话上下文长度超出限制，已为您清空会话上下文！")
+			h.App.ChatContexts.Delete(session.ChatId)
+			return h.sendMessage(ctx, session, role, prompt, ws)
+		} else {
+			utils.ReplyMessage(ws, "请求 Azure API 失败："+res.Error.Message)
+		}
+	}
+
+	return nil
+}
--- a/api/handler/chatimpl/baidu_handler.go
+++ b/api/handler/chatimpl/baidu_handler.go
@@ -0,0 +1,275 @@
+package chatimpl
+
+import (
+	"bufio"
+	"chatplus/core/types"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"context"
+	"encoding/json"
+	"fmt"
+	"html/template"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+type baiduResp struct {
+	Id               string `json:"id"`
+	Object           string `json:"object"`
+	Created          int    `json:"created"`
+	SentenceId       int    `json:"sentence_id"`
+	IsEnd            bool   `json:"is_end"`
+	IsTruncated      bool   `json:"is_truncated"`
+	Result           string `json:"result"`
+	NeedClearHistory bool   `json:"need_clear_history"`
+	Usage            struct {
+		PromptTokens     int `json:"prompt_tokens"`
+		CompletionTokens int `json:"completion_tokens"`
+		TotalTokens      int `json:"total_tokens"`
+	} `json:"usage"`
+}
+
+// 百度文心一言消息发送实现
+
+func (h *ChatHandler) sendBaiduMessage(
+	chatCtx []interface{},
+	req types.ApiRequest,
+	userVo vo.User,
+	ctx context.Context,
+	session *types.ChatSession,
+	role model.ChatRole,
+	prompt string,
+	ws *types.WsClient) error {
+	promptCreatedAt := time.Now() // 记录提问时间
+	start := time.Now()
+	var apiKey = userVo.ChatConfig.ApiKeys[session.Model.Platform]
+	response, err := h.doRequest(ctx, req, session.Model.Platform, &apiKey)
+	logger.Info("HTTP请求完成，耗时：", time.Now().Sub(start))
+	if err != nil {
+		if strings.Contains(err.Error(), "context canceled") {
+			logger.Info("用户取消了请求：", prompt)
+			return nil
+		} else if strings.Contains(err.Error(), "no available key") {
+			utils.ReplyMessage(ws, "抱歉😔😔😔，系统已经没有可用的 API KEY，请联系管理员！")
+			return nil
+		} else {
+			logger.Error(err)
+		}
+
+		utils.ReplyMessage(ws, ErrorMsg)
+		utils.ReplyMessage(ws, ErrImg)
+		return err
+	} else {
+		defer response.Body.Close()
+	}
+
+	contentType := response.Header.Get("Content-Type")
+	if strings.Contains(contentType, "text/event-stream") {
+		replyCreatedAt := time.Now() // 记录回复时间
+		// 循环读取 Chunk 消息
+		var message = types.Message{}
+		var contents = make([]string, 0)
+		var content string
+		scanner := bufio.NewScanner(response.Body)
+		for scanner.Scan() {
+			line := scanner.Text()
+			if len(line) < 5 || strings.HasPrefix(line, "id:") {
+				continue
+			}
+
+			if strings.HasPrefix(line, "data:") {
+				content = line[5:]
+			}
+
+			// 处理代码换行
+			if len(content) == 0 {
+				content = "\n"
+			}
+
+			var resp baiduResp
+			err := utils.JsonDecode(content, &resp)
+			if err != nil {
+				logger.Error("error with parse data line: ", err)
+				utils.ReplyMessage(ws, fmt.Sprintf("**解析数据行失败：%s**", err))
+				break
+			}
+
+			if len(contents) == 0 {
+				utils.ReplyChunkMessage(ws, types.WsMessage{Type: types.WsStart})
+			}
+			utils.ReplyChunkMessage(ws, types.WsMessage{
+				Type:    types.WsMiddle,
+				Content: utils.InterfaceToString(resp.Result),
+			})
+			contents = append(contents, resp.Result)
+
+			if resp.IsTruncated {
+				utils.ReplyMessage(ws, "AI 输出异常中断")
+				break
+			}
+
+			if resp.IsEnd {
+				break
+			}
+
+		} // end for
+
+		if err := scanner.Err(); err != nil {
+			if strings.Contains(err.Error(), "context canceled") {
+				logger.Info("用户取消了请求：", prompt)
+			} else {
+				logger.Error("信息读取出错：", err)
+			}
+		}
+
+		// 消息发送成功
+		if len(contents) > 0 {
+			// 更新用户的对话次数
+			h.subUserCalls(userVo, session)
+
+			if message.Role == "" {
+				message.Role = "assistant"
+			}
+			message.Content = strings.Join(contents, "")
+			useMsg := types.Message{Role: "user", Content: prompt}
+
+			// 更新上下文消息，如果是调用函数则不需要更新上下文
+			if h.App.ChatConfig.EnableContext {
+				chatCtx = append(chatCtx, useMsg)  // 提问消息
+				chatCtx = append(chatCtx, message) // 回复消息
+				h.App.ChatContexts.Put(session.ChatId, chatCtx)
+			}
+
+			// 追加聊天记录
+			if h.App.ChatConfig.EnableHistory {
+				// for prompt
+				promptToken, err := utils.CalcTokens(prompt, req.Model)
+				if err != nil {
+					logger.Error(err)
+				}
+				historyUserMsg := model.HistoryMessage{
+					UserId:     userVo.Id,
+					ChatId:     session.ChatId,
+					RoleId:     role.Id,
+					Type:       types.PromptMsg,
+					Icon:       userVo.Avatar,
+					Content:    template.HTMLEscapeString(prompt),
+					Tokens:     promptToken,
+					UseContext: true,
+				}
+				historyUserMsg.CreatedAt = promptCreatedAt
+				historyUserMsg.UpdatedAt = promptCreatedAt
+				res := h.db.Save(&historyUserMsg)
+				if res.Error != nil {
+					logger.Error("failed to save prompt history message: ", res.Error)
+				}
+
+				// for reply
+				// 计算本次对话消耗的总 token 数量
+				replyToken, _ := utils.CalcTokens(message.Content, req.Model)
+				totalTokens := replyToken + getTotalTokens(req)
+				historyReplyMsg := model.HistoryMessage{
+					UserId:     userVo.Id,
+					ChatId:     session.ChatId,
+					RoleId:     role.Id,
+					Type:       types.ReplyMsg,
+					Icon:       role.Icon,
+					Content:    message.Content,
+					Tokens:     totalTokens,
+					UseContext: true,
+				}
+				historyReplyMsg.CreatedAt = replyCreatedAt
+				historyReplyMsg.UpdatedAt = replyCreatedAt
+				res = h.db.Create(&historyReplyMsg)
+				if res.Error != nil {
+					logger.Error("failed to save reply history message: ", res.Error)
+				}
+				// 更新用户信息
+				h.incUserTokenFee(userVo.Id, totalTokens)
+			}
+
+			// 保存当前会话
+			var chatItem model.ChatItem
+			res := h.db.Where("chat_id = ?", session.ChatId).First(&chatItem)
+			if res.Error != nil {
+				chatItem.ChatId = session.ChatId
+				chatItem.UserId = session.UserId
+				chatItem.RoleId = role.Id
+				chatItem.ModelId = session.Model.Id
+				if utf8.RuneCountInString(prompt) > 30 {
+					chatItem.Title = string([]rune(prompt)[:30]) + "..."
+				} else {
+					chatItem.Title = prompt
+				}
+				h.db.Create(&chatItem)
+			}
+		}
+	} else {
+		body, err := io.ReadAll(response.Body)
+		if err != nil {
+			return fmt.Errorf("error with reading response: %v", err)
+		}
+
+		var res struct {
+			Code int    `json:"error_code"`
+			Msg  string `json:"error_msg"`
+		}
+		err = json.Unmarshal(body, &res)
+		if err != nil {
+			return fmt.Errorf("error with decode response: %v", err)
+		}
+		utils.ReplyMessage(ws, "请求百度文心大模型 API 失败："+res.Msg)
+	}
+
+	return nil
+}
+
+func (h *ChatHandler) getBaiduToken(apiKey string) (string, error) {
+	ctx := context.Background()
+	tokenString, err := h.redis.Get(ctx, apiKey).Result()
+	if err == nil {
+		return tokenString, nil
+	}
+
+	expr := time.Hour * 24 * 20 // access_token 有效期
+	key := strings.Split(apiKey, "|")
+	if len(key) != 2 {
+		return "", fmt.Errorf("invalid api key: %s", apiKey)
+	}
+	url := fmt.Sprintf("https://aip.baidubce.com/oauth/2.0/token?client_id=%s&client_secret=%s&grant_type=client_credentials", key[0], key[1])
+	client := &http.Client{}
+	req, err := http.NewRequest("POST", url, nil)
+	if err != nil {
+		return "", err
+	}
+	req.Header.Add("Content-Type", "application/json")
+	req.Header.Add("Accept", "application/json")
+
+	res, err := client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("error with send request: %w", err)
+	}
+	defer res.Body.Close()
+
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		return "", fmt.Errorf("error with read response: %w", err)
+	}
+	var r map[string]interface{}
+	err = json.Unmarshal(body, &r)
+	if err != nil {
+		return "", fmt.Errorf("error with parse response: %w", err)
+	}
+
+	if r["error"] != nil {
+		return "", fmt.Errorf("error with api response: %s", r["error_description"])
+	}
+
+	tokenString = fmt.Sprintf("%s", r["access_token"])
+	h.redis.Set(ctx, apiKey, tokenString, expr)
+	return tokenString, nil
+}
--- a/api/handler/chatimpl/chat_handler.go
+++ b/api/handler/chatimpl/chat_handler.go
@@ -0,0 +1,483 @@
+package chatimpl
+
+import (
+	"bytes"
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/handler"
+	logger2 "chatplus/logger"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"github.com/go-redis/redis/v8"
+	"github.com/gorilla/websocket"
+	"gorm.io/gorm"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+const ErrorMsg = "抱歉，AI 助手开小差了，请稍后再试。"
+const ErrImg = "![](/images/wx.png)"
+
+var logger = logger2.GetLogger()
+
+type ChatHandler struct {
+	handler.BaseHandler
+	db    *gorm.DB
+	redis *redis.Client
+}
+
+func NewChatHandler(app *core.AppServer, db *gorm.DB, redis *redis.Client) *ChatHandler {
+	h := ChatHandler{
+		db:    db,
+		redis: redis,
+	}
+	h.App = app
+	return &h
+}
+
+var chatConfig types.ChatConfig
+
+// ChatHandle 处理聊天 WebSocket 请求
+func (h *ChatHandler) ChatHandle(c *gin.Context) {
+	ws, err := (&websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}).Upgrade(c.Writer, c.Request, nil)
+	if err != nil {
+		logger.Error(err)
+		return
+	}
+
+	sessionId := c.Query("session_id")
+	roleId := h.GetInt(c, "role_id", 0)
+	chatId := c.Query("chat_id")
+	modelId := h.GetInt(c, "model_id", 0)
+
+	client := types.NewWsClient(ws)
+	// get model info
+	var chatModel model.ChatModel
+	res := h.db.First(&chatModel, modelId)
+	if res.Error != nil || chatModel.Enabled == false {
+		utils.ReplyMessage(client, "当前AI模型暂未启用，连接已关闭！！！")
+		c.Abort()
+		return
+	}
+
+	session := h.App.ChatSession.Get(sessionId)
+	if session == nil {
+		user, err := utils.GetLoginUser(c, h.db)
+		if err != nil {
+			logger.Info("用户未登录")
+			c.Abort()
+			return
+		}
+		session = &types.ChatSession{
+			SessionId: sessionId,
+			ClientIP:  c.ClientIP(),
+			Username:  user.Mobile,
+			UserId:    user.Id,
+		}
+		h.App.ChatSession.Put(sessionId, session)
+	}
+
+	// use old chat data override the chat model and role ID
+	var chat model.ChatItem
+	res = h.db.Where("chat_id=?", chatId).First(&chat)
+	if res.Error == nil {
+		chatModel.Id = chat.ModelId
+		roleId = int(chat.RoleId)
+	}
+
+	session.ChatId = chatId
+	session.Model = types.ChatModel{
+		Id:       chatModel.Id,
+		Value:    chatModel.Value,
+		Weight:   chatModel.Weight,
+		Platform: types.Platform(chatModel.Platform)}
+	logger.Infof("New websocket connected, IP: %s, Username: %s", c.ClientIP(), session.Username)
+	var chatRole model.ChatRole
+	res = h.db.First(&chatRole, roleId)
+	if res.Error != nil || !chatRole.Enable {
+		utils.ReplyMessage(client, "当前聊天角色不存在或者未启用，连接已关闭！！！")
+		c.Abort()
+		return
+	}
+
+	// 初始化聊天配置
+	var config model.Config
+	h.db.Where("marker", "chat").First(&config)
+	err = utils.JsonDecode(config.Config, &chatConfig)
+	if err != nil {
+		utils.ReplyMessage(client, "加载系统配置失败，连接已关闭！！！")
+		c.Abort()
+		return
+	}
+
+	// 保存会话连接
+	h.App.ChatClients.Put(sessionId, client)
+	go func() {
+		for {
+			_, msg, err := client.Receive()
+			if err != nil {
+				logger.Error(err)
+				client.Close()
+				h.App.ChatClients.Delete(sessionId)
+				cancelFunc := h.App.ReqCancelFunc.Get(sessionId)
+				if cancelFunc != nil {
+					cancelFunc()
+					h.App.ReqCancelFunc.Delete(sessionId)
+				}
+				return
+			}
+
+			message := string(msg)
+			logger.Info("Receive a message: ", message)
+			//utils.ReplyMessage(client, "这是一条测试消息！")
+			ctx, cancel := context.WithCancel(context.Background())
+			h.App.ReqCancelFunc.Put(sessionId, cancel)
+			// 回复消息
+			err = h.sendMessage(ctx, session, chatRole, message, client)
+			if err != nil {
+				logger.Error(err)
+				utils.ReplyChunkMessage(client, types.WsMessage{Type: types.WsEnd})
+			} else {
+				utils.ReplyChunkMessage(client, types.WsMessage{Type: types.WsEnd})
+				logger.Info("回答完毕: " + string(message))
+			}
+
+		}
+	}()
+}
+
+func (h *ChatHandler) sendMessage(ctx context.Context, session *types.ChatSession, role model.ChatRole, prompt string, ws *types.WsClient) error {
+	defer func() {
+		if r := recover(); r != nil {
+			logger.Error("Recover message from error: ", r)
+		}
+	}()
+
+	var user model.User
+	res := h.db.Model(&model.User{}).First(&user, session.UserId)
+	if res.Error != nil {
+		utils.ReplyMessage(ws, "非法用户，请联系管理员！")
+		return res.Error
+	}
+	var userVo vo.User
+	err := utils.CopyObject(user, &userVo)
+	userVo.Id = user.Id
+	if err != nil {
+		return errors.New("User 对象转换失败，" + err.Error())
+	}
+
+	if userVo.Status == false {
+		utils.ReplyMessage(ws, "您的账号已经被禁用，如果疑问，请联系管理员！")
+		utils.ReplyMessage(ws, ErrImg)
+		return nil
+	}
+
+	if userVo.Calls < session.Model.Weight {
+		utils.ReplyMessage(ws, fmt.Sprintf("您当前剩余对话次数（%d）已不足以支付当前模型的单次对话需要消耗的对话额度（%d）！", userVo.Calls, session.Model.Weight))
+		utils.ReplyMessage(ws, ErrImg)
+		return nil
+	}
+
+	if userVo.Calls <= 0 && userVo.ChatConfig.ApiKeys[session.Model.Platform] == "" {
+		utils.ReplyMessage(ws, "您的对话次数已经用尽，请联系管理员或者充值点卡继续对话！")
+		utils.ReplyMessage(ws, ErrImg)
+		return nil
+	}
+
+	if userVo.ExpiredTime > 0 && userVo.ExpiredTime <= time.Now().Unix() {
+		utils.ReplyMessage(ws, "您的账号已经过期，请联系管理员！")
+		utils.ReplyMessage(ws, ErrImg)
+		return nil
+	}
+	var req = types.ApiRequest{
+		Model:  session.Model.Value,
+		Stream: true,
+	}
+	switch session.Model.Platform {
+	case types.Azure:
+		req.Temperature = h.App.ChatConfig.Azure.Temperature
+		req.MaxTokens = h.App.ChatConfig.Azure.MaxTokens
+		break
+	case types.ChatGLM:
+		req.Temperature = h.App.ChatConfig.ChatGML.Temperature
+		req.MaxTokens = h.App.ChatConfig.ChatGML.MaxTokens
+		break
+	case types.Baidu:
+		req.Temperature = h.App.ChatConfig.OpenAI.Temperature
+		// TODO： 目前只支持 ERNIE-Bot-turbo 模型，如果是 ERNIE-Bot 模型则需要增加函数支持
+	case types.OpenAI:
+		req.Temperature = h.App.ChatConfig.OpenAI.Temperature
+		req.MaxTokens = h.App.ChatConfig.OpenAI.MaxTokens
+		// OpenAI 支持函数功能
+		if h.App.SysConfig.EnabledFunction {
+			var functions = make([]types.Function, 0)
+			for _, f := range types.InnerFunctions {
+				functions = append(functions, f)
+			}
+			req.Functions = functions
+		}
+	case types.XunFei:
+		req.Temperature = h.App.ChatConfig.XunFei.Temperature
+		req.MaxTokens = h.App.ChatConfig.XunFei.MaxTokens
+	default:
+		utils.ReplyMessage(ws, "不支持的平台："+session.Model.Platform+"，请联系管理员！")
+		utils.ReplyMessage(ws, ErrImg)
+		return nil
+	}
+
+	// 加载聊天上下文
+	var chatCtx []interface{}
+	if h.App.ChatConfig.EnableContext {
+		if h.App.ChatContexts.Has(session.ChatId) {
+			chatCtx = h.App.ChatContexts.Get(session.ChatId)
+		} else {
+			// calculate the tokens of current request, to prevent to exceeding the max tokens num
+			tokens := req.MaxTokens
+			for _, f := range types.InnerFunctions {
+				tks, _ := utils.CalcTokens(utils.JsonEncode(f), req.Model)
+				tokens += tks
+			}
+
+			// loading the role context
+			var messages []types.Message
+			err := utils.JsonDecode(role.Context, &messages)
+			if err == nil {
+				for _, v := range messages {
+					tks, _ := utils.CalcTokens(v.Content, req.Model)
+					if tokens+tks >= types.ModelToTokens[req.Model] {
+						break
+					}
+					tokens += tks
+					chatCtx = append(chatCtx, v)
+				}
+			}
+
+			// loading recent chat history as chat context
+			if chatConfig.ContextDeep > 0 {
+				var historyMessages []model.HistoryMessage
+				res := h.db.Debug().Where("chat_id = ? and use_context = 1", session.ChatId).Limit(chatConfig.ContextDeep).Order("id desc").Find(&historyMessages)
+				if res.Error == nil {
+					for i := len(historyMessages) - 1; i >= 0; i-- {
+						msg := historyMessages[i]
+						if tokens+msg.Tokens >= types.ModelToTokens[session.Model.Value] {
+							break
+						}
+						tokens += msg.Tokens
+						ms := types.Message{Role: "user", Content: msg.Content}
+						if msg.Type == types.ReplyMsg {
+							ms.Role = "assistant"
+						}
+						chatCtx = append(chatCtx, ms)
+					}
+				}
+			}
+		}
+		logger.Debugf("聊天上下文：%+v", chatCtx)
+	}
+	reqMgs := make([]interface{}, 0)
+	for _, m := range chatCtx {
+		reqMgs = append(reqMgs, m)
+	}
+
+	req.Messages = append(reqMgs, map[string]interface{}{
+		"role":    "user",
+		"content": prompt,
+	})
+
+	switch session.Model.Platform {
+	case types.Azure:
+		return h.sendAzureMessage(chatCtx, req, userVo, ctx, session, role, prompt, ws)
+	case types.OpenAI:
+		return h.sendOpenAiMessage(chatCtx, req, userVo, ctx, session, role, prompt, ws)
+	case types.ChatGLM:
+		return h.sendChatGLMMessage(chatCtx, req, userVo, ctx, session, role, prompt, ws)
+	case types.Baidu:
+		return h.sendBaiduMessage(chatCtx, req, userVo, ctx, session, role, prompt, ws)
+	case types.XunFei:
+		return h.sendXunFeiMessage(chatCtx, req, userVo, ctx, session, role, prompt, ws)
+
+	}
+	utils.ReplyChunkMessage(ws, types.WsMessage{
+		Type:    types.WsMiddle,
+		Content: fmt.Sprintf("Not supported platform: %s", session.Model.Platform),
+	})
+	return nil
+}
+
+// Tokens 统计 token 数量
+func (h *ChatHandler) Tokens(c *gin.Context) {
+	var data struct {
+		Text  string `json:"text"`
+		Model string `json:"model"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	// 如果没有传入 text 字段，则说明是获取当前 reply 总的 token 消耗（带上下文）
+	if data.Text == "" {
+		var item model.HistoryMessage
+		userId, _ := c.Get(types.LoginUserID)
+		res := h.db.Where("user_id = ?", userId).Last(&item)
+		if res.Error != nil {
+			resp.ERROR(c, res.Error.Error())
+			return
+		}
+		resp.SUCCESS(c, item.Tokens)
+		return
+	}
+
+	tokens, err := utils.CalcTokens(data.Text, data.Model)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, tokens)
+}
+
+func getTotalTokens(req types.ApiRequest) int {
+	encode := utils.JsonEncode(req.Messages)
+	var items []map[string]interface{}
+	err := utils.JsonDecode(encode, &items)
+	if err != nil {
+		return 0
+	}
+	tokens := 0
+	for _, item := range items {
+		content, ok := item["content"]
+		if ok && !utils.IsEmptyValue(content) {
+			t, err := utils.CalcTokens(utils.InterfaceToString(content), req.Model)
+			if err == nil {
+				tokens += t
+			}
+		}
+	}
+	return tokens
+}
+
+// StopGenerate 停止生成
+func (h *ChatHandler) StopGenerate(c *gin.Context) {
+	sessionId := c.Query("session_id")
+	if h.App.ReqCancelFunc.Has(sessionId) {
+		h.App.ReqCancelFunc.Get(sessionId)()
+		h.App.ReqCancelFunc.Delete(sessionId)
+	}
+	resp.SUCCESS(c, types.OkMsg)
+}
+
+// 发送请求到 OpenAI 服务器
+// useOwnApiKey: 是否使用了用户自己的 API KEY
+func (h *ChatHandler) doRequest(ctx context.Context, req types.ApiRequest, platform types.Platform, apiKey *string) (*http.Response, error) {
+
+	var apiURL string
+	switch platform {
+	case types.Azure:
+		md := strings.Replace(req.Model, ".", "", 1)
+		apiURL = strings.Replace(h.App.ChatConfig.Azure.ApiURL, "{model}", md, 1)
+		break
+	case types.ChatGLM:
+		apiURL = strings.Replace(h.App.ChatConfig.ChatGML.ApiURL, "{model}", req.Model, 1)
+		req.Prompt = req.Messages // 使用 prompt 字段替代 message 字段
+		req.Messages = nil
+		break
+	case types.Baidu:
+		apiURL = strings.Replace(h.App.ChatConfig.Baidu.ApiURL, "{model}", req.Model, 1)
+		break
+	default:
+		apiURL = h.App.ChatConfig.OpenAI.ApiURL
+	}
+	if *apiKey == "" {
+		var key model.ApiKey
+		res := h.db.Where("platform = ? AND type = ?", platform, "chat").Order("last_used_at ASC").First(&key)
+		if res.Error != nil {
+			return nil, errors.New("no available key, please import key")
+		}
+		// 更新 API KEY 的最后使用时间
+		h.db.Model(&key).UpdateColumn("last_used_at", time.Now().Unix())
+		*apiKey = key.Value
+	}
+
+	// 百度文心，需要串接 access_token
+	if platform == types.Baidu {
+		token, err := h.getBaiduToken(*apiKey)
+		if err != nil {
+			return nil, err
+		}
+		logger.Info("百度文心 Access_Token：", token)
+		apiURL = fmt.Sprintf("%s?access_token=%s", apiURL, token)
+	}
+
+	// 创建 HttpClient 请求对象
+	var client *http.Client
+	requestBody, err := json.Marshal(req)
+	if err != nil {
+		return nil, err
+	}
+	request, err := http.NewRequest(http.MethodPost, apiURL, bytes.NewBuffer(requestBody))
+	if err != nil {
+		return nil, err
+	}
+
+	request = request.WithContext(ctx)
+	request.Header.Set("Content-Type", "application/json")
+	proxyURL := h.App.Config.ProxyURL
+	if proxyURL != "" && platform == types.OpenAI { // 使用代理
+		proxy, _ := url.Parse(proxyURL)
+		client = &http.Client{
+			Transport: &http.Transport{
+				Proxy: http.ProxyURL(proxy),
+			},
+		}
+	} else {
+		client = http.DefaultClient
+	}
+	logger.Infof("Sending %s request, KEY: %s, PROXY: %s, Model: %s", platform, *apiKey, proxyURL, req.Model)
+	switch platform {
+	case types.Azure:
+		request.Header.Set("api-key", *apiKey)
+		break
+	case types.ChatGLM:
+		token, err := h.getChatGLMToken(*apiKey)
+		if err != nil {
+			return nil, err
+		}
+		logger.Info(token)
+		request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))
+		break
+	case types.Baidu:
+		request.RequestURI = ""
+	case types.OpenAI:
+		request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiKey))
+	}
+	return client.Do(request)
+}
+
+// 扣减用户的对话次数
+func (h *ChatHandler) subUserCalls(userVo vo.User, session *types.ChatSession) {
+	// 仅当用户没有导入自己的 API KEY 时才进行扣减
+	if userVo.ChatConfig.ApiKeys[session.Model.Platform] == "" {
+		num := 1
+		if session.Model.Weight > 0 {
+			num = session.Model.Weight
+		}
+		h.db.Model(&model.User{}).Where("id = ?", userVo.Id).UpdateColumn("calls", gorm.Expr("calls - ?", num))
+	}
+}
+
+func (h *ChatHandler) incUserTokenFee(userId uint, tokens int) {
+	h.db.Model(&model.User{}).Where("id = ?", userId).
+		UpdateColumn("total_tokens", gorm.Expr("total_tokens + ?", tokens))
+	h.db.Model(&model.User{}).Where("id = ?", userId).
+		UpdateColumn("tokens", gorm.Expr("tokens + ?", tokens))
+}
--- a/api/handler/chatimpl/chat_item_handler.go
+++ b/api/handler/chatimpl/chat_item_handler.go
@@ -1,4 +1,4 @@
-package handler
+package chatimpl

 import (
 	"chatplus/core/types"
@@ -6,8 +6,8 @@ import (
 	"chatplus/store/vo"
 	"chatplus/utils"
 	"chatplus/utils/resp"
-
 	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
 )

 // List 获取会话列表
@@ -51,16 +51,14 @@ func (h *ChatHandler) List(c *gin.Context) {
 // Update 更新会话标题
 func (h *ChatHandler) Update(c *gin.Context) {
 	var data struct {
-		Id    uint   `json:"id"`
-		Title string `json:"title"`
+		ChatId string `json:"chat_id"`
+		Title  string `json:"title"`
 	}
 	if err := c.ShouldBindJSON(&data); err != nil {
 		resp.ERROR(c, types.InvalidArgs)
 		return
 	}
-	var m = model.ChatItem{}
-	m.Id = data.Id
-	res := h.db.Model(&m).UpdateColumn("title", data.Title)
+	res := h.db.Model(&model.ChatItem{}).Where("chat_id = ?", data.ChatId).UpdateColumn("title", data.Title)
 	if res.Error != nil {
 		resp.ERROR(c, "Failed to update database")
 		return
@@ -69,6 +67,76 @@ func (h *ChatHandler) Update(c *gin.Context) {
 	resp.SUCCESS(c, types.OkMsg)
 }

+// Clear 清空所有聊天记录
+func (h *ChatHandler) Clear(c *gin.Context) {
+	// 获取当前登录用户所有的聊天会话
+	user, err := utils.GetLoginUser(c, h.db)
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+
+	var chats []model.ChatItem
+	res := h.db.Where("user_id = ?", user.Id).Find(&chats)
+	if res.Error != nil {
+		resp.ERROR(c, "No chats found")
+		return
+	}
+
+	var chatIds = make([]string, 0)
+	for _, chat := range chats {
+		chatIds = append(chatIds, chat.ChatId)
+		// 清空会话上下文
+		h.App.ChatContexts.Delete(chat.ChatId)
+	}
+	err = h.db.Transaction(func(tx *gorm.DB) error {
+		res := h.db.Where("user_id =?", user.Id).Delete(&model.ChatItem{})
+		if res.Error != nil {
+			return res.Error
+		}
+
+		res = h.db.Where("user_id = ? AND chat_id IN ?", user.Id, chatIds).Delete(&model.HistoryMessage{})
+		if res.Error != nil {
+			return res.Error
+		}
+
+		// TODO: 是否要删除 MidJourney 绘画记录和图片文件？
+		return nil
+	})
+
+	if err != nil {
+		logger.Errorf("Error with delete chats: %+v", err)
+		resp.ERROR(c, "Failed to remove chat from database.")
+		return
+	}
+
+	resp.SUCCESS(c, types.OkMsg)
+}
+
+// History 获取聊天历史记录
+func (h *ChatHandler) History(c *gin.Context) {
+	chatId := c.Query("chat_id") // 会话 ID
+	var items []model.HistoryMessage
+	var messages = make([]vo.HistoryMessage, 0)
+	res := h.db.Where("chat_id = ?", chatId).Find(&items)
+	if res.Error != nil {
+		resp.ERROR(c, "No history message")
+		return
+	} else {
+		for _, item := range items {
+			var v vo.HistoryMessage
+			err := utils.CopyObject(item, &v)
+			v.CreatedAt = item.CreatedAt.Unix()
+			v.UpdatedAt = item.UpdatedAt.Unix()
+			if err == nil {
+				messages = append(messages, v)
+			}
+		}
+	}
+
+	resp.SUCCESS(c, messages)
+}
+
 // Remove 删除会话
 func (h *ChatHandler) Remove(c *gin.Context) {
 	chatId := h.GetTrim(c, "chat_id")
@@ -88,70 +156,41 @@ func (h *ChatHandler) Remove(c *gin.Context) {
 		return
 	}

-	// 清空会话上下文
-	h.App.ChatContexts.Delete(chatId)
-	resp.SUCCESS(c, types.OkMsg)
-}
-
-// History 获取聊天历史记录
-func (h *ChatHandler) History(c *gin.Context) {
-	chatId := c.Query("chat_id") // 会话 ID
-	user, err := utils.GetLoginUser(c, h.db)
-	if err != nil {
-		resp.NotAuth(c)
-		return
-	}
-	var items []model.HistoryMessage
-	var messages = make([]vo.HistoryMessage, 0)
-	res := h.db.Where("chat_id = ? AND user_id = ?", chatId, user.Id).Find(&items)
-	if res.Error != nil {
-		resp.ERROR(c, "No history message")
-		return
-	} else {
-		for _, item := range items {
-			var v vo.HistoryMessage
-			err := utils.CopyObject(item, &v)
-			v.CreatedAt = item.CreatedAt.Unix()
-			v.UpdatedAt = item.UpdatedAt.Unix()
-			if err == nil {
-				messages = append(messages, v)
-			}
-		}
-	}
-
-	resp.SUCCESS(c, messages)
-}
-
-// Clear 清空所有聊天记录
-func (h *ChatHandler) Clear(c *gin.Context) {
-	// 获取当前登录用户所有的聊天会话
-	user, err := utils.GetLoginUser(c, h.db)
-	if err != nil {
-		resp.NotAuth(c)
-		return
-	}
-
-	var chats []model.ChatItem
-	res := h.db.Where("user_id = ?", user.Id).Find(&chats)
-	if res.Error != nil {
-		resp.ERROR(c, "No chats found")
-		return
-	}
-	// 清空聊天记录
-	for _, chat := range chats {
-		err := h.db.Where("chat_id = ? AND user_id = ?", chat.ChatId, user.Id).Delete(&model.HistoryMessage{})
-		if err != nil {
-			logger.Warnf("Failed to delele chat history for ChatID: %s", chat.ChatId)
-		}
-		// 清空会话上下文
-		h.App.ChatContexts.Delete(chat.ChatId)
-	}
-	// 删除所有的会话记录
-	res = h.db.Where("user_id = ?", user.Id).Delete(&model.ChatItem{})
+	// 删除当前会话的聊天记录
+	res = h.db.Where("user_id = ? AND chat_id =?", user.Id, chatId).Delete(&model.ChatItem{})
 	if res.Error != nil {
 		resp.ERROR(c, "Failed to remove chat from database.")
 		return
 	}

+	// TODO: 是否要删除 MidJourney 绘画记录和图片文件？
+
+	// 清空会话上下文
+	h.App.ChatContexts.Delete(chatId)
 	resp.SUCCESS(c, types.OkMsg)
 }
+
+// Detail 对话详情，用户导出对话
+func (h *ChatHandler) Detail(c *gin.Context) {
+	chatId := h.GetTrim(c, "chat_id")
+	if utils.IsEmptyValue(chatId) {
+		resp.ERROR(c, "Invalid chatId")
+		return
+	}
+
+	var chatItem model.ChatItem
+	res := h.db.Where("chat_id = ?", chatId).First(&chatItem)
+	if res.Error != nil {
+		resp.ERROR(c, "No chat found")
+		return
+	}
+
+	var chatItemVo vo.ChatItem
+	err := utils.CopyObject(chatItem, &chatItemVo)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, chatItemVo)
+}
--- a/api/handler/chatimpl/chatglm_handler.go
+++ b/api/handler/chatimpl/chatglm_handler.go
@@ -0,0 +1,237 @@
+package chatimpl
+
+import (
+	"bufio"
+	"chatplus/core/types"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"context"
+	"encoding/json"
+	"fmt"
+	"github.com/golang-jwt/jwt/v5"
+	"html/template"
+	"io"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+// 清华大学 ChatGML 消息发送实现
+
+func (h *ChatHandler) sendChatGLMMessage(
+	chatCtx []interface{},
+	req types.ApiRequest,
+	userVo vo.User,
+	ctx context.Context,
+	session *types.ChatSession,
+	role model.ChatRole,
+	prompt string,
+	ws *types.WsClient) error {
+	promptCreatedAt := time.Now() // 记录提问时间
+	start := time.Now()
+	var apiKey = userVo.ChatConfig.ApiKeys[session.Model.Platform]
+	response, err := h.doRequest(ctx, req, session.Model.Platform, &apiKey)
+	logger.Info("HTTP请求完成，耗时：", time.Now().Sub(start))
+	if err != nil {
+		if strings.Contains(err.Error(), "context canceled") {
+			logger.Info("用户取消了请求：", prompt)
+			return nil
+		} else if strings.Contains(err.Error(), "no available key") {
+			utils.ReplyMessage(ws, "抱歉😔😔😔，系统已经没有可用的 API KEY，请联系管理员！")
+			return nil
+		} else {
+			logger.Error(err)
+		}
+
+		utils.ReplyMessage(ws, ErrorMsg)
+		utils.ReplyMessage(ws, ErrImg)
+		return err
+	} else {
+		defer response.Body.Close()
+	}
+
+	contentType := response.Header.Get("Content-Type")
+	if strings.Contains(contentType, "text/event-stream") {
+		replyCreatedAt := time.Now() // 记录回复时间
+		// 循环读取 Chunk 消息
+		var message = types.Message{}
+		var contents = make([]string, 0)
+		var event, content string
+		scanner := bufio.NewScanner(response.Body)
+		for scanner.Scan() {
+			line := scanner.Text()
+			if len(line) < 5 || strings.HasPrefix(line, "id:") {
+				continue
+			}
+			if strings.HasPrefix(line, "event:") {
+				event = line[6:]
+				continue
+			}
+
+			if strings.HasPrefix(line, "data:") {
+				content = line[5:]
+			}
+			// 处理代码换行
+			if len(content) == 0 {
+				content = "\n"
+			}
+			switch event {
+			case "add":
+				if len(contents) == 0 {
+					utils.ReplyChunkMessage(ws, types.WsMessage{Type: types.WsStart})
+				}
+				utils.ReplyChunkMessage(ws, types.WsMessage{
+					Type:    types.WsMiddle,
+					Content: utils.InterfaceToString(content),
+				})
+				contents = append(contents, content)
+			case "finish":
+				break
+			case "error":
+				utils.ReplyMessage(ws, fmt.Sprintf("**调用 ChatGLM API 出错：%s**", content))
+				break
+			case "interrupted":
+				utils.ReplyMessage(ws, "**调用 ChatGLM API 出错，当前输出被中断！**")
+			}
+
+		} // end for
+
+		if err := scanner.Err(); err != nil {
+			if strings.Contains(err.Error(), "context canceled") {
+				logger.Info("用户取消了请求：", prompt)
+			} else {
+				logger.Error("信息读取出错：", err)
+			}
+		}
+
+		// 消息发送成功
+		if len(contents) > 0 {
+			// 更新用户的对话次数
+			h.subUserCalls(userVo, session)
+
+			if message.Role == "" {
+				message.Role = "assistant"
+			}
+			message.Content = strings.Join(contents, "")
+			useMsg := types.Message{Role: "user", Content: prompt}
+
+			// 更新上下文消息，如果是调用函数则不需要更新上下文
+			if h.App.ChatConfig.EnableContext {
+				chatCtx = append(chatCtx, useMsg)  // 提问消息
+				chatCtx = append(chatCtx, message) // 回复消息
+				h.App.ChatContexts.Put(session.ChatId, chatCtx)
+			}
+
+			// 追加聊天记录
+			if h.App.ChatConfig.EnableHistory {
+				// for prompt
+				promptToken, err := utils.CalcTokens(prompt, req.Model)
+				if err != nil {
+					logger.Error(err)
+				}
+				historyUserMsg := model.HistoryMessage{
+					UserId:     userVo.Id,
+					ChatId:     session.ChatId,
+					RoleId:     role.Id,
+					Type:       types.PromptMsg,
+					Icon:       userVo.Avatar,
+					Content:    template.HTMLEscapeString(prompt),
+					Tokens:     promptToken,
+					UseContext: true,
+				}
+				historyUserMsg.CreatedAt = promptCreatedAt
+				historyUserMsg.UpdatedAt = promptCreatedAt
+				res := h.db.Save(&historyUserMsg)
+				if res.Error != nil {
+					logger.Error("failed to save prompt history message: ", res.Error)
+				}
+
+				// for reply
+				// 计算本次对话消耗的总 token 数量
+				replyToken, _ := utils.CalcTokens(message.Content, req.Model)
+				totalTokens := replyToken + getTotalTokens(req)
+				historyReplyMsg := model.HistoryMessage{
+					UserId:     userVo.Id,
+					ChatId:     session.ChatId,
+					RoleId:     role.Id,
+					Type:       types.ReplyMsg,
+					Icon:       role.Icon,
+					Content:    message.Content,
+					Tokens:     totalTokens,
+					UseContext: true,
+				}
+				historyReplyMsg.CreatedAt = replyCreatedAt
+				historyReplyMsg.UpdatedAt = replyCreatedAt
+				res = h.db.Create(&historyReplyMsg)
+				if res.Error != nil {
+					logger.Error("failed to save reply history message: ", res.Error)
+				}
+				// 更新用户信息
+				h.incUserTokenFee(userVo.Id, totalTokens)
+			}
+
+			// 保存当前会话
+			var chatItem model.ChatItem
+			res := h.db.Where("chat_id = ?", session.ChatId).First(&chatItem)
+			if res.Error != nil {
+				chatItem.ChatId = session.ChatId
+				chatItem.UserId = session.UserId
+				chatItem.RoleId = role.Id
+				chatItem.ModelId = session.Model.Id
+				if utf8.RuneCountInString(prompt) > 30 {
+					chatItem.Title = string([]rune(prompt)[:30]) + "..."
+				} else {
+					chatItem.Title = prompt
+				}
+				h.db.Create(&chatItem)
+			}
+		}
+	} else {
+		body, err := io.ReadAll(response.Body)
+		if err != nil {
+			return fmt.Errorf("error with reading response: %v", err)
+		}
+
+		var res struct {
+			Code    int    `json:"code"`
+			Success bool   `json:"success"`
+			Msg     string `json:"msg"`
+		}
+		err = json.Unmarshal(body, &res)
+		if err != nil {
+			return fmt.Errorf("error with decode response: %v", err)
+		}
+		if !res.Success {
+			utils.ReplyMessage(ws, "请求 ChatGLM 失败："+res.Msg)
+		}
+	}
+
+	return nil
+}
+
+func (h *ChatHandler) getChatGLMToken(apiKey string) (string, error) {
+	ctx := context.Background()
+	tokenString, err := h.redis.Get(ctx, apiKey).Result()
+	if err == nil {
+		return tokenString, nil
+	}
+
+	expr := time.Hour * 2
+	key := strings.Split(apiKey, ".")
+	if len(key) != 2 {
+		return "", fmt.Errorf("invalid api key: %s", apiKey)
+	}
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
+		"api_key":   key[0],
+		"timestamp": time.Now().Unix(),
+		"exp":       time.Now().Add(expr).Add(time.Second * 10).Unix(),
+	})
+	token.Header["alg"] = "HS256"
+	token.Header["sign_type"] = "SIGN"
+	delete(token.Header, "typ")
+	// Sign and get the complete encoded token as a string using the secret
+	tokenString, err = token.SignedString([]byte(key[1]))
+	h.redis.Set(ctx, apiKey, tokenString, expr)
+	return tokenString, err
+}
--- a/api/handler/chatimpl/openai_handler.go
+++ b/api/handler/chatimpl/openai_handler.go
@@ -0,0 +1,291 @@
+package chatimpl
+
+import (
+	"bufio"
+	"chatplus/core/types"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"context"
+	"encoding/json"
+	"fmt"
+	"gorm.io/gorm"
+	"html/template"
+	"io"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+// OPenAI 消息发送实现
+func (h *ChatHandler) sendOpenAiMessage(
+	chatCtx []interface{},
+	req types.ApiRequest,
+	userVo vo.User,
+	ctx context.Context,
+	session *types.ChatSession,
+	role model.ChatRole,
+	prompt string,
+	ws *types.WsClient) error {
+	promptCreatedAt := time.Now() // 记录提问时间
+	start := time.Now()
+	var apiKey = userVo.ChatConfig.ApiKeys[session.Model.Platform]
+	response, err := h.doRequest(ctx, req, session.Model.Platform, &apiKey)
+	logger.Info("HTTP请求完成，耗时：", time.Now().Sub(start))
+	if err != nil {
+		if strings.Contains(err.Error(), "context canceled") {
+			logger.Info("用户取消了请求：", prompt)
+			return nil
+		} else if strings.Contains(err.Error(), "no available key") {
+			utils.ReplyMessage(ws, "抱歉😔😔😔，系统已经没有可用的 API KEY，请联系管理员！")
+			return nil
+		} else {
+			logger.Error(err)
+		}
+
+		utils.ReplyMessage(ws, ErrorMsg)
+		utils.ReplyMessage(ws, ErrImg)
+		return err
+	} else {
+		defer response.Body.Close()
+	}
+
+	contentType := response.Header.Get("Content-Type")
+	if strings.Contains(contentType, "text/event-stream") {
+		replyCreatedAt := time.Now() // 记录回复时间
+		// 循环读取 Chunk 消息
+		var message = types.Message{}
+		var contents = make([]string, 0)
+		var functionCall = false
+		var functionName string
+		var arguments = make([]string, 0)
+		scanner := bufio.NewScanner(response.Body)
+		for scanner.Scan() {
+			line := scanner.Text()
+			if !strings.Contains(line, "data:") || len(line) < 30 {
+				continue
+			}
+
+			var responseBody = types.ApiResponse{}
+			err = json.Unmarshal([]byte(line[6:]), &responseBody)
+			if err != nil || len(responseBody.Choices) == 0 { // 数据解析出错
+				logger.Error(err, line)
+				utils.ReplyMessage(ws, ErrorMsg)
+				utils.ReplyMessage(ws, ErrImg)
+				break
+			}
+
+			fun := responseBody.Choices[0].Delta.FunctionCall
+			if functionCall && fun.Name == "" {
+				arguments = append(arguments, fun.Arguments)
+				continue
+			}
+
+			if !utils.IsEmptyValue(fun) {
+				functionName = fun.Name
+				f := h.App.Functions[functionName]
+				if f != nil {
+					functionCall = true
+					utils.ReplyChunkMessage(ws, types.WsMessage{Type: types.WsStart})
+					utils.ReplyChunkMessage(ws, types.WsMessage{Type: types.WsMiddle, Content: fmt.Sprintf("正在调用函数 `%s` 作答 ...\n\n", f.Name())})
+				}
+				continue
+			}
+
+			if responseBody.Choices[0].FinishReason == "function_call" { // 函数调用完毕
+				break
+			}
+
+			// 初始化 role
+			if responseBody.Choices[0].Delta.Role != "" && message.Role == "" {
+				message.Role = responseBody.Choices[0].Delta.Role
+				utils.ReplyChunkMessage(ws, types.WsMessage{Type: types.WsStart})
+				continue
+			} else if responseBody.Choices[0].FinishReason != "" {
+				break // 输出完成或者输出中断了
+			} else {
+				content := responseBody.Choices[0].Delta.Content
+				contents = append(contents, utils.InterfaceToString(content))
+				utils.ReplyChunkMessage(ws, types.WsMessage{
+					Type:    types.WsMiddle,
+					Content: utils.InterfaceToString(responseBody.Choices[0].Delta.Content),
+				})
+			}
+		} // end for
+
+		if err := scanner.Err(); err != nil {
+			if strings.Contains(err.Error(), "context canceled") {
+				logger.Info("用户取消了请求：", prompt)
+			} else {
+				logger.Error("信息读取出错：", err)
+			}
+		}
+
+		if functionCall { // 调用函数完成任务
+			var params map[string]interface{}
+			_ = utils.JsonDecode(strings.Join(arguments, ""), &params)
+			logger.Debugf("函数名称: %s, 函数参数：%s", functionName, params)
+
+			// for creating image, check if the user's img_calls > 0
+			if functionName == types.FuncImage && userVo.ImgCalls <= 0 {
+				utils.ReplyMessage(ws, "**当前用户剩余绘图次数已用尽，请扫描下面二维码联系管理员！**")
+				utils.ReplyMessage(ws, ErrImg)
+			} else {
+				f := h.App.Functions[functionName]
+				if functionName == types.FuncImage {
+					params["user_id"] = userVo.Id
+					params["role_id"] = role.Id
+					params["chat_id"] = session.ChatId
+					params["session_id"] = session.SessionId
+				}
+				data, err := f.Invoke(params)
+				if err != nil {
+					msg := "调用函数出错：" + err.Error()
+					utils.ReplyChunkMessage(ws, types.WsMessage{
+						Type:    types.WsMiddle,
+						Content: msg,
+					})
+					contents = append(contents, msg)
+				} else {
+					content := data
+					if functionName == types.FuncImage {
+						content = fmt.Sprintf("下面是根据您的描述创作的图片，他们描绘了 【%s】 的场景。%s", params["prompt"], data)
+						// update user's img_calls
+						h.db.Model(&model.User{}).Where("id = ?", userVo.Id).UpdateColumn("img_calls", gorm.Expr("img_calls - ?", 1))
+					}
+
+					utils.ReplyChunkMessage(ws, types.WsMessage{
+						Type:    types.WsMiddle,
+						Content: content,
+					})
+					contents = append(contents, content)
+				}
+			}
+		}
+
+		// 消息发送成功
+		if len(contents) > 0 {
+			// 更新用户的对话次数
+			h.subUserCalls(userVo, session)
+
+			if message.Role == "" {
+				message.Role = "assistant"
+			}
+			message.Content = strings.Join(contents, "")
+			useMsg := types.Message{Role: "user", Content: prompt}
+
+			// 更新上下文消息，如果是调用函数则不需要更新上下文
+			if h.App.ChatConfig.EnableContext && functionCall == false {
+				chatCtx = append(chatCtx, useMsg)  // 提问消息
+				chatCtx = append(chatCtx, message) // 回复消息
+				h.App.ChatContexts.Put(session.ChatId, chatCtx)
+			}
+
+			// 追加聊天记录
+			if h.App.ChatConfig.EnableHistory {
+				useContext := true
+				if functionCall {
+					useContext = false
+				}
+
+				// for prompt
+				promptToken, err := utils.CalcTokens(prompt, req.Model)
+				if err != nil {
+					logger.Error(err)
+				}
+				historyUserMsg := model.HistoryMessage{
+					UserId:     userVo.Id,
+					ChatId:     session.ChatId,
+					RoleId:     role.Id,
+					Type:       types.PromptMsg,
+					Icon:       userVo.Avatar,
+					Content:    template.HTMLEscapeString(prompt),
+					Tokens:     promptToken,
+					UseContext: useContext,
+				}
+				historyUserMsg.CreatedAt = promptCreatedAt
+				historyUserMsg.UpdatedAt = promptCreatedAt
+				res := h.db.Save(&historyUserMsg)
+				if res.Error != nil {
+					logger.Error("failed to save prompt history message: ", res.Error)
+				}
+
+				// 计算本次对话消耗的总 token 数量
+				var totalTokens = 0
+				if functionCall { // prompt + 函数名 + 参数 token
+					tokens, _ := utils.CalcTokens(functionName, req.Model)
+					totalTokens += tokens
+					tokens, _ = utils.CalcTokens(utils.InterfaceToString(arguments), req.Model)
+					totalTokens += tokens
+				} else {
+					totalTokens, _ = utils.CalcTokens(message.Content, req.Model)
+				}
+				totalTokens += getTotalTokens(req)
+
+				historyReplyMsg := model.HistoryMessage{
+					UserId:     userVo.Id,
+					ChatId:     session.ChatId,
+					RoleId:     role.Id,
+					Type:       types.ReplyMsg,
+					Icon:       role.Icon,
+					Content:    message.Content,
+					Tokens:     totalTokens,
+					UseContext: useContext,
+				}
+				historyReplyMsg.CreatedAt = replyCreatedAt
+				historyReplyMsg.UpdatedAt = replyCreatedAt
+				res = h.db.Create(&historyReplyMsg)
+				if res.Error != nil {
+					logger.Error("failed to save reply history message: ", res.Error)
+				}
+
+				// 更新用户信息
+				h.incUserTokenFee(userVo.Id, totalTokens)
+			}
+
+			// 保存当前会话
+			var chatItem model.ChatItem
+			res := h.db.Where("chat_id = ?", session.ChatId).First(&chatItem)
+			if res.Error != nil {
+				chatItem.ChatId = session.ChatId
+				chatItem.UserId = session.UserId
+				chatItem.RoleId = role.Id
+				chatItem.ModelId = session.Model.Id
+				if utf8.RuneCountInString(prompt) > 30 {
+					chatItem.Title = string([]rune(prompt)[:30]) + "..."
+				} else {
+					chatItem.Title = prompt
+				}
+				h.db.Create(&chatItem)
+			}
+		}
+	} else {
+		body, err := io.ReadAll(response.Body)
+		if err != nil {
+			return fmt.Errorf("error with reading response: %v", err)
+		}
+		var res types.ApiError
+		err = json.Unmarshal(body, &res)
+		if err != nil {
+			return fmt.Errorf("error with decode response: %v", err)
+		}
+
+		// OpenAI API 调用异常处理
+		if strings.Contains(res.Error.Message, "This key is associated with a deactivated account") {
+			utils.ReplyMessage(ws, "请求 OpenAI API 失败：API KEY 所关联的账户被禁用。")
+			// 移除当前 API key
+			h.db.Where("value = ?", apiKey).Delete(&model.ApiKey{})
+		} else if strings.Contains(res.Error.Message, "You exceeded your current quota") {
+			utils.ReplyMessage(ws, "请求 OpenAI API 失败：API KEY 触发并发限制，请稍后再试。")
+		} else if strings.Contains(res.Error.Message, "This model's maximum context length") {
+			logger.Error(res.Error.Message)
+			utils.ReplyMessage(ws, "当前会话上下文长度超出限制，已为您清空会话上下文！")
+			h.App.ChatContexts.Delete(session.ChatId)
+			return h.sendMessage(ctx, session, role, prompt, ws)
+		} else {
+			utils.ReplyMessage(ws, "请求 OpenAI API 失败："+res.Error.Message)
+		}
+	}
+
+	return nil
+}
--- a/api/handler/chatimpl/xunfei_handler.go
+++ b/api/handler/chatimpl/xunfei_handler.go
@@ -0,0 +1,323 @@
+package chatimpl
+
+import (
+	"chatplus/core/types"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"context"
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"github.com/gorilla/websocket"
+	"html/template"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+type xunFeiResp struct {
+	Header struct {
+		Code    int    `json:"code"`
+		Message string `json:"message"`
+		Sid     string `json:"sid"`
+		Status  int    `json:"status"`
+	} `json:"header"`
+	Payload struct {
+		Choices struct {
+			Status int `json:"status"`
+			Seq    int `json:"seq"`
+			Text   []struct {
+				Content string `json:"content"`
+				Role    string `json:"role"`
+				Index   int    `json:"index"`
+			} `json:"text"`
+		} `json:"choices"`
+		Usage struct {
+			Text struct {
+				QuestionTokens   int `json:"question_tokens"`
+				PromptTokens     int `json:"prompt_tokens"`
+				CompletionTokens int `json:"completion_tokens"`
+				TotalTokens      int `json:"total_tokens"`
+			} `json:"text"`
+		} `json:"usage"`
+	} `json:"payload"`
+}
+
+var Model2URL = map[string]string{
+	"generalv1": "1.1",
+	"generalv2": "v2.1",
+	"generalv3": "v3.1",
+}
+
+// 科大讯飞消息发送实现
+
+func (h *ChatHandler) sendXunFeiMessage(
+	chatCtx []interface{},
+	req types.ApiRequest,
+	userVo vo.User,
+	ctx context.Context,
+	session *types.ChatSession,
+	role model.ChatRole,
+	prompt string,
+	ws *types.WsClient) error {
+	promptCreatedAt := time.Now() // 记录提问时间
+	var apiKey = userVo.ChatConfig.ApiKeys[session.Model.Platform]
+	if apiKey == "" {
+		var key model.ApiKey
+		res := h.db.Where("platform = ? AND type = ?", session.Model.Platform, "chat").Order("last_used_at ASC").First(&key)
+		if res.Error != nil {
+			utils.ReplyMessage(ws, "抱歉😔😔😔，系统已经没有可用的 API KEY，请联系管理员！")
+			return nil
+		}
+		// 更新 API KEY 的最后使用时间
+		h.db.Model(&key).UpdateColumn("last_used_at", time.Now().Unix())
+		apiKey = key.Value
+	}
+
+	d := websocket.Dialer{
+		HandshakeTimeout: 5 * time.Second,
+	}
+	key := strings.Split(apiKey, "|")
+	if len(key) != 3 {
+		utils.ReplyMessage(ws, "非法的 API KEY！")
+		return nil
+	}
+
+	apiURL := strings.Replace(h.App.ChatConfig.XunFei.ApiURL, "{version}", Model2URL[req.Model], 1)
+	wsURL, err := assembleAuthUrl(apiURL, key[1], key[2])
+	//握手并建立websocket 连接
+	conn, resp, err := d.Dial(wsURL, nil)
+	if err != nil {
+		logger.Error(readResp(resp) + err.Error())
+		utils.ReplyMessage(ws, "请求讯飞星火模型 API 失败："+readResp(resp)+err.Error())
+		return nil
+	} else if resp.StatusCode != 101 {
+		utils.ReplyMessage(ws, "请求讯飞星火模型 API 失败："+readResp(resp)+err.Error())
+		return nil
+	}
+
+	data := buildRequest(key[0], req)
+	fmt.Printf("%+v", data)
+	fmt.Println(apiURL)
+	err = conn.WriteJSON(data)
+	if err != nil {
+		utils.ReplyMessage(ws, "发送消息失败："+err.Error())
+		return nil
+	}
+
+	replyCreatedAt := time.Now() // 记录回复时间
+	// 循环读取 Chunk 消息
+	var message = types.Message{}
+	var contents = make([]string, 0)
+	var content string
+	for {
+		_, msg, err := conn.ReadMessage()
+		if err != nil {
+			logger.Error("error with read message:", err)
+			utils.ReplyMessage(ws, fmt.Sprintf("**数据读取失败：%s**", err))
+			break
+		}
+
+		// 解析数据
+		var result xunFeiResp
+		err = json.Unmarshal(msg, &result)
+		if err != nil {
+			logger.Error("error with parsing JSON:", err)
+			utils.ReplyMessage(ws, fmt.Sprintf("**解析数据行失败：%s**", err))
+			return nil
+		}
+
+		if result.Header.Code != 0 {
+			utils.ReplyMessage(ws, fmt.Sprintf("**请求 API 返回错误：%s**", result.Header.Message))
+			return nil
+		}
+
+		content = result.Payload.Choices.Text[0].Content
+		// 处理代码换行
+		if len(content) == 0 {
+			content = "\n"
+		}
+		contents = append(contents, content)
+		// 第一个结果
+		if result.Payload.Choices.Status == 0 {
+			utils.ReplyChunkMessage(ws, types.WsMessage{Type: types.WsStart})
+		}
+		utils.ReplyChunkMessage(ws, types.WsMessage{
+			Type:    types.WsMiddle,
+			Content: utils.InterfaceToString(content),
+		})
+
+		if result.Payload.Choices.Status == 2 { // 最终结果
+			_ = conn.Close() // 关闭连接
+			break
+		}
+
+		select {
+		case <-ctx.Done():
+			utils.ReplyMessage(ws, "**用户取消了生成指令！**")
+			return nil
+		default:
+			continue
+		}
+
+	}
+
+	// 消息发送成功
+	if len(contents) > 0 {
+		// 更新用户的对话次数
+		h.subUserCalls(userVo, session)
+
+		if message.Role == "" {
+			message.Role = "assistant"
+		}
+		message.Content = strings.Join(contents, "")
+		useMsg := types.Message{Role: "user", Content: prompt}
+
+		// 更新上下文消息，如果是调用函数则不需要更新上下文
+		if h.App.ChatConfig.EnableContext {
+			chatCtx = append(chatCtx, useMsg)  // 提问消息
+			chatCtx = append(chatCtx, message) // 回复消息
+			h.App.ChatContexts.Put(session.ChatId, chatCtx)
+		}
+
+		// 追加聊天记录
+		if h.App.ChatConfig.EnableHistory {
+			// for prompt
+			promptToken, err := utils.CalcTokens(prompt, req.Model)
+			if err != nil {
+				logger.Error(err)
+			}
+			historyUserMsg := model.HistoryMessage{
+				UserId:     userVo.Id,
+				ChatId:     session.ChatId,
+				RoleId:     role.Id,
+				Type:       types.PromptMsg,
+				Icon:       userVo.Avatar,
+				Content:    template.HTMLEscapeString(prompt),
+				Tokens:     promptToken,
+				UseContext: true,
+			}
+			historyUserMsg.CreatedAt = promptCreatedAt
+			historyUserMsg.UpdatedAt = promptCreatedAt
+			res := h.db.Save(&historyUserMsg)
+			if res.Error != nil {
+				logger.Error("failed to save prompt history message: ", res.Error)
+			}
+
+			// for reply
+			// 计算本次对话消耗的总 token 数量
+			replyToken, _ := utils.CalcTokens(message.Content, req.Model)
+			totalTokens := replyToken + getTotalTokens(req)
+			historyReplyMsg := model.HistoryMessage{
+				UserId:     userVo.Id,
+				ChatId:     session.ChatId,
+				RoleId:     role.Id,
+				Type:       types.ReplyMsg,
+				Icon:       role.Icon,
+				Content:    message.Content,
+				Tokens:     totalTokens,
+				UseContext: true,
+			}
+			historyReplyMsg.CreatedAt = replyCreatedAt
+			historyReplyMsg.UpdatedAt = replyCreatedAt
+			res = h.db.Create(&historyReplyMsg)
+			if res.Error != nil {
+				logger.Error("failed to save reply history message: ", res.Error)
+			}
+			// 更新用户信息
+			h.incUserTokenFee(userVo.Id, totalTokens)
+		}
+
+		// 保存当前会话
+		var chatItem model.ChatItem
+		res := h.db.Where("chat_id = ?", session.ChatId).First(&chatItem)
+		if res.Error != nil {
+			chatItem.ChatId = session.ChatId
+			chatItem.UserId = session.UserId
+			chatItem.RoleId = role.Id
+			chatItem.ModelId = session.Model.Id
+			if utf8.RuneCountInString(prompt) > 30 {
+				chatItem.Title = string([]rune(prompt)[:30]) + "..."
+			} else {
+				chatItem.Title = prompt
+			}
+			h.db.Create(&chatItem)
+		}
+	}
+
+	return nil
+}
+
+// 构建 websocket 请求实体
+func buildRequest(appid string, req types.ApiRequest) map[string]interface{} {
+	return map[string]interface{}{
+		"header": map[string]interface{}{
+			"app_id": appid,
+		},
+		"parameter": map[string]interface{}{
+			"chat": map[string]interface{}{
+				"domain":      req.Model,
+				"temperature": float64(req.Temperature),
+				"top_k":       int64(6),
+				"max_tokens":  int64(req.MaxTokens),
+				"auditing":    "default",
+			},
+		},
+		"payload": map[string]interface{}{
+			"message": map[string]interface{}{
+				"text": req.Messages,
+			},
+		},
+	}
+}
+
+// 创建鉴权 URL
+func assembleAuthUrl(hostURL string, apiKey, apiSecret string) (string, error) {
+	ul, err := url.Parse(hostURL)
+	if err != nil {
+		return "", err
+	}
+
+	date := time.Now().UTC().Format(time.RFC1123)
+	signString := []string{"host: " + ul.Host, "date: " + date, "GET " + ul.Path + " HTTP/1.1"}
+	//拼接签名字符串
+	signStr := strings.Join(signString, "\n")
+	sha := hmacWithSha256(signStr, apiSecret)
+
+	authUrl := fmt.Sprintf("hmac username=\"%s\", algorithm=\"%s\", headers=\"%s\", signature=\"%s\"", apiKey,
+		"hmac-sha256", "host date request-line", sha)
+	//将请求参数使用base64编码
+	authorization := base64.StdEncoding.EncodeToString([]byte(authUrl))
+	v := url.Values{}
+	v.Add("host", ul.Host)
+	v.Add("date", date)
+	v.Add("authorization", authorization)
+	//将编码后的字符串url encode后添加到url后面
+	return hostURL + "?" + v.Encode(), nil
+}
+
+// 使用 sha256 签名
+func hmacWithSha256(data, key string) string {
+	mac := hmac.New(sha256.New, []byte(key))
+	mac.Write([]byte(data))
+	encodeData := mac.Sum(nil)
+	return base64.StdEncoding.EncodeToString(encodeData)
+}
+
+// 读取响应
+func readResp(resp *http.Response) string {
+	if resp == nil {
+		return ""
+	}
+	b, err := io.ReadAll(resp.Body)
+	if err != nil {
+		panic(err)
+	}
+	return fmt.Sprintf("code=%d,body=%s", resp.StatusCode, string(b))
+}
--- a/api/handler/invite_handler.go
+++ b/api/handler/invite_handler.go
@@ -0,0 +1,96 @@
+package handler
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"strings"
+)
+
+// InviteHandler 用户邀请
+type InviteHandler struct {
+	BaseHandler
+	db *gorm.DB
+}
+
+func NewInviteHandler(app *core.AppServer, db *gorm.DB) *InviteHandler {
+	h := InviteHandler{db: db}
+	h.App = app
+	return &h
+}
+
+// Code 获取当前用户邀请码
+func (h *InviteHandler) Code(c *gin.Context) {
+	userId := h.GetLoginUserId(c)
+	var inviteCode model.InviteCode
+	res := h.db.Where("user_id = ?", userId).First(&inviteCode)
+	// 如果邀请码不存在，则创建一个
+	if res.Error != nil {
+		code := strings.ToUpper(utils.RandString(8))
+		for {
+			res = h.db.Where("code = ?", code).First(&inviteCode)
+			if res.Error != nil { // 不存在相同的邀请码则退出
+				break
+			}
+		}
+		inviteCode.UserId = userId
+		inviteCode.Code = code
+		h.db.Create(&inviteCode)
+	}
+
+	var codeVo vo.InviteCode
+	err := utils.CopyObject(inviteCode, &codeVo)
+	if err != nil {
+		resp.ERROR(c, "拷贝对象失败")
+		return
+	}
+
+	resp.SUCCESS(c, codeVo)
+}
+
+// List Log 用户邀请记录
+func (h *InviteHandler) List(c *gin.Context) {
+
+	var data struct {
+		Page     int `json:"page"`
+		PageSize int `json:"page_size"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	userId := h.GetLoginUserId(c)
+	session := h.db.Session(&gorm.Session{}).Where("inviter_id = ?", userId)
+	var total int64
+	session.Model(&model.InviteLog{}).Count(&total)
+	var items []model.InviteLog
+	var list = make([]vo.InviteLog, 0)
+	offset := (data.Page - 1) * data.PageSize
+	res := session.Order("id DESC").Offset(offset).Limit(data.PageSize).Find(&items)
+	if res.Error == nil {
+		for _, item := range items {
+			var v vo.InviteLog
+			err := utils.CopyObject(item, &v)
+			if err == nil {
+				v.Id = item.Id
+				v.CreatedAt = item.CreatedAt.Unix()
+				list = append(list, v)
+			} else {
+				logger.Error(err)
+			}
+		}
+	}
+	resp.SUCCESS(c, vo.NewPage(total, data.Page, data.PageSize, list))
+}
+
+// Hits 访问邀请码
+func (h *InviteHandler) Hits(c *gin.Context) {
+	code := c.Query("code")
+	h.db.Model(&model.InviteCode{}).Where("code = ?", code).UpdateColumn("hits", gorm.Expr("hits + ?", 1))
+	resp.SUCCESS(c)
+}
--- a/api/handler/mj_handler.go
+++ b/api/handler/mj_handler.go
@@ -0,0 +1,276 @@
+package handler
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/service"
+	"chatplus/service/mj"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"encoding/base64"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"strings"
+	"time"
+)
+
+type MidJourneyHandler struct {
+	BaseHandler
+	db        *gorm.DB
+	pool      *mj.ServicePool
+	snowflake *service.Snowflake
+}
+
+func NewMidJourneyHandler(app *core.AppServer, db *gorm.DB, snowflake *service.Snowflake, pool *mj.ServicePool) *MidJourneyHandler {
+	h := MidJourneyHandler{
+		db:        db,
+		snowflake: snowflake,
+		pool:      pool,
+	}
+	h.App = app
+	return &h
+}
+
+func (h *MidJourneyHandler) preCheck(c *gin.Context) bool {
+	user, err := utils.GetLoginUser(c, h.db)
+	if err != nil {
+		resp.NotAuth(c)
+		return false
+	}
+
+	if user.ImgCalls <= 0 {
+		resp.ERROR(c, "您的绘图次数不足，请联系管理员充值！")
+		return false
+	}
+
+	if !h.pool.HasAvailableService() {
+		resp.ERROR(c, "MidJourney 池子中没有没有可用的服务！")
+		return false
+	}
+
+	return true
+
+}
+
+// Image 创建一个绘画任务
+func (h *MidJourneyHandler) Image(c *gin.Context) {
+	var data struct {
+		SessionId string  `json:"session_id"`
+		Prompt    string  `json:"prompt"`
+		NegPrompt string  `json:"neg_prompt"`
+		Rate      string  `json:"rate"`
+		Model     string  `json:"model"`
+		Chaos     int     `json:"chaos"`
+		Raw       bool    `json:"raw"`
+		Seed      int64   `json:"seed"`
+		Stylize   int     `json:"stylize"`
+		Img       string  `json:"img"`
+		Tile      bool    `json:"tile"`
+		Quality   float32 `json:"quality"`
+		Weight    float32 `json:"weight"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	if !h.preCheck(c) {
+		return
+	}
+
+	var prompt = data.Prompt
+	if data.Rate != "" && !strings.Contains(prompt, "--ar") {
+		prompt += " --ar " + data.Rate
+	}
+	if data.Seed > 0 && !strings.Contains(prompt, "--seed") {
+		prompt += fmt.Sprintf(" --seed %d", data.Seed)
+	}
+	if data.Stylize > 0 && !strings.Contains(prompt, "--s") && !strings.Contains(prompt, "--stylize") {
+		prompt += fmt.Sprintf(" --s %d", data.Stylize)
+	}
+	if data.Chaos > 0 && !strings.Contains(prompt, "--c") && !strings.Contains(prompt, "--chaos") {
+		prompt += fmt.Sprintf(" --c %d", data.Chaos)
+	}
+	if data.Img != "" {
+		prompt = fmt.Sprintf("%s %s", data.Img, prompt)
+		if data.Weight > 0 {
+			prompt += fmt.Sprintf(" --iw %f", data.Weight)
+		}
+	}
+	if data.Raw {
+		prompt += " --style raw"
+	}
+	if data.Quality > 0 {
+		prompt += fmt.Sprintf(" --q %.2f", data.Quality)
+	}
+	if data.NegPrompt != "" {
+		prompt += fmt.Sprintf(" --no %s", data.NegPrompt)
+	}
+	if data.Tile {
+		prompt += " --tile "
+	}
+	if data.Model != "" && !strings.Contains(prompt, "--v") && !strings.Contains(prompt, "--niji") {
+		prompt += fmt.Sprintf(" %s", data.Model)
+	}
+
+	idValue, _ := c.Get(types.LoginUserID)
+	userId := utils.IntValue(utils.InterfaceToString(idValue), 0)
+	// generate task id
+	taskId, err := h.snowflake.Next(true)
+	if err != nil {
+		resp.ERROR(c, "error with generate task id: "+err.Error())
+		return
+	}
+	job := model.MidJourneyJob{
+		Type:      types.TaskImage.String(),
+		UserId:    userId,
+		TaskId:    taskId,
+		Progress:  0,
+		Prompt:    prompt,
+		CreatedAt: time.Now(),
+	}
+	if res := h.db.Create(&job); res.Error != nil {
+		resp.ERROR(c, "添加任务失败："+res.Error.Error())
+		return
+	}
+
+	h.pool.PushTask(types.MjTask{
+		Id:        int(job.Id),
+		SessionId: data.SessionId,
+		Type:      types.TaskImage,
+		Prompt:    fmt.Sprintf("%s %s", taskId, prompt),
+		UserId:    userId,
+	})
+	resp.SUCCESS(c)
+}
+
+type reqVo struct {
+	Src         string `json:"src"`
+	Index       int    `json:"index"`
+	MessageId   string `json:"message_id"`
+	MessageHash string `json:"message_hash"`
+	SessionId   string `json:"session_id"`
+	Prompt      string `json:"prompt"`
+	ChatId      string `json:"chat_id"`
+	RoleId      int    `json:"role_id"`
+	Icon        string `json:"icon"`
+}
+
+// Upscale send upscale command to MidJourney Bot
+func (h *MidJourneyHandler) Upscale(c *gin.Context) {
+	var data reqVo
+	if err := c.ShouldBindJSON(&data); err != nil || data.SessionId == "" {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if !h.preCheck(c) {
+		return
+	}
+
+	idValue, _ := c.Get(types.LoginUserID)
+	jobId := 0
+	userId := utils.IntValue(utils.InterfaceToString(idValue), 0)
+	h.pool.PushTask(types.MjTask{
+		Id:          jobId,
+		SessionId:   data.SessionId,
+		Type:        types.TaskUpscale,
+		Prompt:      data.Prompt,
+		UserId:      userId,
+		Index:       data.Index,
+		MessageId:   data.MessageId,
+		MessageHash: data.MessageHash,
+	})
+	resp.SUCCESS(c)
+}
+
+// Variation send variation command to MidJourney Bot
+func (h *MidJourneyHandler) Variation(c *gin.Context) {
+	var data reqVo
+	if err := c.ShouldBindJSON(&data); err != nil || data.SessionId == "" {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if !h.preCheck(c) {
+		return
+	}
+
+	idValue, _ := c.Get(types.LoginUserID)
+	jobId := 0
+	userId := utils.IntValue(utils.InterfaceToString(idValue), 0)
+	h.pool.PushTask(types.MjTask{
+		Id:          jobId,
+		SessionId:   data.SessionId,
+		Type:        types.TaskVariation,
+		Prompt:      data.Prompt,
+		UserId:      userId,
+		Index:       data.Index,
+		MessageId:   data.MessageId,
+		MessageHash: data.MessageHash,
+	})
+	resp.SUCCESS(c)
+}
+
+// JobList 获取 MJ 任务列表
+func (h *MidJourneyHandler) JobList(c *gin.Context) {
+	status := h.GetInt(c, "status", 0)
+	userId := h.GetInt(c, "user_id", 0)
+	page := h.GetInt(c, "page", 0)
+	pageSize := h.GetInt(c, "page_size", 0)
+
+	session := h.db.Session(&gorm.Session{})
+	if status == 1 {
+		session = session.Where("progress = ?", 100).Order("id DESC")
+	} else {
+		session = session.Where("progress < ?", 100).Order("id ASC")
+	}
+	if userId > 0 {
+		session = session.Where("user_id = ?", userId)
+	}
+	if page > 0 && pageSize > 0 {
+		offset := (page - 1) * pageSize
+		session = session.Offset(offset).Limit(pageSize)
+	}
+
+	var items []model.MidJourneyJob
+	res := session.Find(&items)
+	if res.Error != nil {
+		resp.ERROR(c, types.NoData)
+		return
+	}
+
+	var jobs = make([]vo.MidJourneyJob, 0)
+	for _, item := range items {
+		var job vo.MidJourneyJob
+		err := utils.CopyObject(item, &job)
+		if err != nil {
+			continue
+		}
+
+		if job.Progress == -1 {
+			h.db.Delete(&model.MidJourneyJob{Id: job.Id})
+		}
+
+		if item.Progress < 100 {
+			// 10 分钟还没完成的任务直接删除
+			if time.Now().Sub(item.CreatedAt) > time.Minute*10 {
+				h.db.Delete(&item)
+				continue
+			}
+
+			// 正在运行中任务使用代理访问图片
+			if item.ImgURL == "" && item.OrgURL != "" {
+				image, err := utils.DownloadImage(item.OrgURL, h.App.Config.ProxyURL)
+				if err == nil {
+					job.ImgURL = "data:image/png;base64," + base64.StdEncoding.EncodeToString(image)
+				}
+			}
+		}
+
+		jobs = append(jobs, job)
+	}
+	resp.SUCCESS(c, jobs)
+}
--- a/api/handler/order_handler.go
+++ b/api/handler/order_handler.go
@@ -0,0 +1,57 @@
+package handler
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type OrderHandler struct {
+	BaseHandler
+	db *gorm.DB
+}
+
+func NewOrderHandler(app *core.AppServer, db *gorm.DB) *OrderHandler {
+	h := OrderHandler{db: db}
+	h.App = app
+	return &h
+}
+
+func (h *OrderHandler) List(c *gin.Context) {
+	var data struct {
+		Page     int `json:"page"`
+		PageSize int `json:"page_size"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	user, _ := utils.GetLoginUser(c, h.db)
+	session := h.db.Session(&gorm.Session{}).Where("user_id = ? AND status = ?", user.Id, types.OrderPaidSuccess)
+	var total int64
+	session.Model(&model.Order{}).Count(&total)
+	var items []model.Order
+	var list = make([]vo.Order, 0)
+	offset := (data.Page - 1) * data.PageSize
+	res := session.Order("id DESC").Offset(offset).Limit(data.PageSize).Find(&items)
+	if res.Error == nil {
+		for _, item := range items {
+			var order vo.Order
+			err := utils.CopyObject(item, &order)
+			if err == nil {
+				order.Id = item.Id
+				order.CreatedAt = item.CreatedAt.Unix()
+				order.UpdatedAt = item.UpdatedAt.Unix()
+				list = append(list, order)
+			} else {
+				logger.Error(err)
+			}
+		}
+	}
+	resp.SUCCESS(c, vo.NewPage(total, data.Page, data.PageSize, list))
+}
--- a/api/handler/payment_handler.go
+++ b/api/handler/payment_handler.go
@@ -0,0 +1,389 @@
+package handler
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/service"
+	"chatplus/service/payment"
+	"chatplus/store/model"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"embed"
+	"encoding/base64"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"net/http"
+	"net/url"
+	"sync"
+	"time"
+)
+
+const (
+	PayWayAlipay = "支付宝"
+	PayWayXunHu  = "虎皮椒"
+)
+
+// PaymentHandler 支付服务回调 handler
+type PaymentHandler struct {
+	BaseHandler
+	alipayService  *payment.AlipayService
+	huPiPayService *payment.HuPiPayService
+	snowflake      *service.Snowflake
+	db             *gorm.DB
+	fs             embed.FS
+	lock           sync.Mutex
+}
+
+func NewPaymentHandler(server *core.AppServer, alipayService *payment.AlipayService, huPiPayService *payment.HuPiPayService, snowflake *service.Snowflake, db *gorm.DB, fs embed.FS) *PaymentHandler {
+	h := PaymentHandler{
+		alipayService:  alipayService,
+		huPiPayService: huPiPayService,
+		snowflake:      snowflake,
+		fs:             fs,
+		db:             db,
+		lock:           sync.Mutex{},
+	}
+	h.App = server
+	return &h
+}
+
+func (h *PaymentHandler) DoPay(c *gin.Context) {
+	orderNo := h.GetTrim(c, "order_no")
+	payWay := h.GetTrim(c, "pay_way")
+
+	if orderNo == "" {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	var order model.Order
+	res := h.db.Where("order_no = ?", orderNo).First(&order)
+	if res.Error != nil {
+		resp.ERROR(c, "Order not found")
+		return
+	}
+
+	// 更新扫码状态
+	h.db.Model(&order).UpdateColumn("status", types.OrderScanned)
+	if payWay == "alipay" { // 支付宝
+		// 生成支付链接
+		notifyURL := h.App.Config.AlipayConfig.NotifyURL
+		returnURL := "" // 关闭同步回跳
+		amount := fmt.Sprintf("%.2f", order.Amount)
+
+		uri, err := h.alipayService.PayUrlMobile(order.OrderNo, notifyURL, returnURL, amount, order.Subject)
+		if err != nil {
+			resp.ERROR(c, "error with generate pay url: "+err.Error())
+			return
+		}
+
+		c.Redirect(302, uri)
+		return
+	} else if payWay == "hupi" { // 虎皮椒支付
+		params := map[string]string{
+			"version":        "1.1",
+			"trade_order_id": orderNo,
+			"total_fee":      fmt.Sprintf("%f", order.Amount),
+			"title":          order.Subject,
+			"notify_url":     h.App.Config.HuPiPayConfig.NotifyURL,
+			"return_url":     "",
+			"wap_name":       "极客学长",
+			"callback_url":   "",
+		}
+
+		res, err := h.huPiPayService.Pay(params)
+		if err != nil {
+			resp.ERROR(c, "error with generate pay url: "+err.Error())
+			return
+		}
+
+		var r struct {
+			Openid    int64  `json:"openid"`
+			UrlQrcode string `json:"url_qrcode"`
+			URL       string `json:"url"`
+			ErrCode   int    `json:"errcode"`
+			ErrMsg    string `json:"errmsg"`
+		}
+		err = utils.JsonDecode(res, &r)
+		if err != nil {
+			resp.ERROR(c, "error with decode payment result: "+err.Error())
+			return
+		}
+
+		if r.ErrCode != 0 {
+			resp.ERROR(c, "error with generate pay url: "+r.ErrMsg)
+			return
+		}
+		c.Redirect(302, r.URL)
+	}
+	resp.ERROR(c, "Invalid operations")
+}
+
+// OrderQuery 查询订单状态
+func (h *PaymentHandler) OrderQuery(c *gin.Context) {
+	var data struct {
+		OrderNo string `json:"order_no"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	var order model.Order
+	res := h.db.Where("order_no = ?", data.OrderNo).First(&order)
+	if res.Error != nil {
+		resp.ERROR(c, "Order not found")
+		return
+	}
+
+	if order.Status == types.OrderPaidSuccess {
+		resp.SUCCESS(c, gin.H{"status": order.Status})
+		return
+	}
+
+	counter := 0
+	for {
+		time.Sleep(time.Second)
+		var item model.Order
+		h.db.Where("order_no = ?", data.OrderNo).First(&item)
+		if counter >= 15 || item.Status == types.OrderPaidSuccess || item.Status != order.Status {
+			order.Status = item.Status
+			break
+		}
+		counter++
+	}
+
+	resp.SUCCESS(c, gin.H{"status": order.Status})
+}
+
+// PayQrcode 生成支付 URL 二维码
+func (h *PaymentHandler) PayQrcode(c *gin.Context) {
+	var data struct {
+		PayWay    string `json:"pay_way"` // 支付方式
+		ProductId uint   `json:"product_id"`
+		UserId    int    `json:"user_id"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	var product model.Product
+	res := h.db.First(&product, data.ProductId)
+	if res.Error != nil {
+		resp.ERROR(c, "Product not found")
+		return
+	}
+
+	orderNo, err := h.snowflake.Next(false)
+	if err != nil {
+		resp.ERROR(c, "error with generate trade no: "+err.Error())
+		return
+	}
+	var user model.User
+	res = h.db.First(&user, data.UserId)
+	if res.Error != nil {
+		resp.ERROR(c, "Invalid user ID")
+		return
+	}
+
+	payWay := PayWayAlipay
+	if data.PayWay == "hupi" {
+		payWay = PayWayXunHu
+	}
+	// 创建订单
+	remark := types.OrderRemark{
+		Days:     product.Days,
+		Calls:    product.Calls,
+		Name:     product.Name,
+		Price:    product.Price,
+		Discount: product.Discount,
+	}
+	order := model.Order{
+		UserId:    user.Id,
+		Mobile:    user.Mobile,
+		ProductId: product.Id,
+		OrderNo:   orderNo,
+		Subject:   product.Name,
+		Amount:    product.Price - product.Discount,
+		Status:    types.OrderNotPaid,
+		PayWay:    payWay,
+		Remark:    utils.JsonEncode(remark),
+	}
+	res = h.db.Create(&order)
+	if res.Error != nil {
+		resp.ERROR(c, "error with create order: "+res.Error.Error())
+		return
+	}
+
+	var logo string
+	if data.PayWay == "alipay" {
+		logo = "res/img/alipay.jpg"
+	} else if data.PayWay == "hupi" {
+		if h.App.Config.HuPiPayConfig.Name == "wechat" {
+			logo = "res/img/wechat-pay.jpg"
+		} else {
+			logo = "res/img/alipay.jpg"
+		}
+	}
+
+	file, err := h.fs.Open(logo)
+	if err != nil {
+		resp.ERROR(c, "error with open qrcode log file: "+err.Error())
+		return
+	}
+
+	parse, err := url.Parse(h.App.Config.AlipayConfig.NotifyURL)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	imageURL := fmt.Sprintf("%s://%s/api/payment/doPay?order_no=%s&pay_way=%s", parse.Scheme, parse.Host, orderNo, data.PayWay)
+	imgData, err := utils.GenQrcode(imageURL, 400, file)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	imgDataBase64 := base64.StdEncoding.EncodeToString(imgData)
+	resp.SUCCESS(c, gin.H{"order_no": orderNo, "image": fmt.Sprintf("data:image/jpg;base64, %s", imgDataBase64), "url": imageURL})
+}
+
+// AlipayNotify 支付宝支付回调
+func (h *PaymentHandler) AlipayNotify(c *gin.Context) {
+	err := c.Request.ParseForm()
+	if err != nil {
+		c.String(http.StatusOK, "fail")
+		return
+	}
+
+	// TODO：这里最好用支付宝的公钥签名签证一下交易真假
+	//res := h.alipayService.TradeVerify(c.Request.Form)
+	r := h.alipayService.TradeQuery(c.Request.Form.Get("out_trade_no"))
+	logger.Infof("验证支付结果：%+v", r)
+	if !r.Success() {
+		c.String(http.StatusOK, "fail")
+		return
+	}
+
+	h.lock.Lock()
+	defer h.lock.Unlock()
+
+	err = h.notify(r.OutTradeNo)
+	if err != nil {
+		c.String(http.StatusOK, "fail")
+		return
+	}
+
+	c.String(http.StatusOK, "success")
+}
+
+// 异步通知回调公共逻辑
+func (h *PaymentHandler) notify(orderNo string) error {
+	var order model.Order
+	res := h.db.Where("order_no = ?", orderNo).First(&order)
+	if res.Error != nil {
+		err := fmt.Errorf("error with fetch order: %v", res.Error)
+		logger.Error(err)
+		return err
+	}
+
+	// 已支付订单，直接返回
+	if order.Status == types.OrderPaidSuccess {
+		return nil
+	}
+
+	var user model.User
+	res = h.db.First(&user, order.UserId)
+	if res.Error != nil {
+		err := fmt.Errorf("error with fetch user info: %v", res.Error)
+		logger.Error(err)
+		return err
+	}
+
+	var remark types.OrderRemark
+	err := utils.JsonDecode(order.Remark, &remark)
+	if err != nil {
+		err := fmt.Errorf("error with decode order remark: %v", err)
+		logger.Error(err)
+		return err
+	}
+
+	// 1. 点卡：days == 0, calls > 0
+	// 2. vip 套餐：days > 0, calls == 0
+	if remark.Days > 0 {
+		if user.ExpiredTime > time.Now().Unix() {
+			user.ExpiredTime = time.Unix(user.ExpiredTime, 0).AddDate(0, 0, remark.Days).Unix()
+		} else {
+			user.ExpiredTime = time.Now().AddDate(0, 0, remark.Days).Unix()
+		}
+		user.Vip = true
+
+	} else if !user.Vip { // 充值点卡的非 VIP 用户
+		user.ExpiredTime = time.Now().AddDate(0, 0, 30).Unix()
+	}
+
+	if remark.Calls > 0 { // 充值点卡
+		user.Calls += remark.Calls
+	} else {
+		user.Calls += h.App.SysConfig.VipMonthCalls
+	}
+
+	// 更新用户信息
+	res = h.db.Updates(&user)
+	if res.Error != nil {
+		err := fmt.Errorf("error with update user info: %v", res.Error)
+		logger.Error(err)
+		return err
+	}
+
+	// 更新订单状态
+	order.PayTime = time.Now().Unix()
+	order.Status = types.OrderPaidSuccess
+	res = h.db.Updates(&order)
+	if res.Error != nil {
+		err := fmt.Errorf("error with update order info: %v", res.Error)
+		logger.Error(err)
+		return err
+	}
+
+	// 更新产品销量
+	h.db.Model(&model.Product{}).Where("id = ?", order.ProductId).UpdateColumn("sales", gorm.Expr("sales + ?", 1))
+	return nil
+}
+
+// GetPayWays 获取支付方式
+func (h *PaymentHandler) GetPayWays(c *gin.Context) {
+	data := gin.H{}
+	if h.App.Config.AlipayConfig.Enabled {
+		data["alipay"] = gin.H{"name": "alipay"}
+	}
+	if h.App.Config.HuPiPayConfig.Enabled {
+		data["hupi"] = gin.H{"name": h.App.Config.HuPiPayConfig.Name}
+	}
+	resp.SUCCESS(c, data)
+}
+
+// HuPiPayNotify 虎皮椒支付异步回调
+func (h *PaymentHandler) HuPiPayNotify(c *gin.Context) {
+	err := c.Request.ParseForm()
+	if err != nil {
+		c.String(http.StatusOK, "fail")
+		return
+	}
+
+	orderNo := c.Request.Form.Get("trade_order_id")
+	logger.Infof("收到订单支付回调，订单 NO：%s", orderNo)
+	// TODO 是否要保存订单交易流水号
+	h.lock.Lock()
+	defer h.lock.Unlock()
+
+	err = h.notify(orderNo)
+	if err != nil {
+		c.String(http.StatusOK, "fail")
+		return
+	}
+
+	c.String(http.StatusOK, "success")
+}
--- a/api/handler/product_handler.go
+++ b/api/handler/product_handler.go
@@ -0,0 +1,44 @@
+package handler
+
+import (
+	"chatplus/core"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type ProductHandler struct {
+	BaseHandler
+	db *gorm.DB
+}
+
+func NewProductHandler(app *core.AppServer, db *gorm.DB) *ProductHandler {
+	h := ProductHandler{db: db}
+	h.App = app
+	return &h
+}
+
+// List 模型列表
+func (h *ProductHandler) List(c *gin.Context) {
+	var items []model.Product
+	var list = make([]vo.Product, 0)
+	res := h.db.Where("enabled", true).Order("sort_num ASC").Find(&items)
+	if res.Error == nil {
+		for _, item := range items {
+			var product vo.Product
+			err := utils.CopyObject(item, &product)
+			if err == nil {
+				product.Id = item.Id
+				product.CreatedAt = item.CreatedAt.Unix()
+				product.UpdatedAt = item.UpdatedAt.Unix()
+				list = append(list, product)
+			} else {
+				logger.Error(err)
+			}
+		}
+	}
+	resp.SUCCESS(c, list)
+}
--- a/api/handler/prompt_handler.go
+++ b/api/handler/prompt_handler.go
@@ -0,0 +1,120 @@
+package handler
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/store/model"
+	"chatplus/utils/resp"
+	"fmt"
+
+	"github.com/imroc/req/v3"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+const rewritePromptTemplate = "Please rewrite the following text into AI painting prompt words, and please try to add detailed description of the picture, painting style, scene, rendering effect, picture light and other elements. Please output directly in English without any explanation, within 150 words. The text to be rewritten is: [%s]"
+const translatePromptTemplate = "Translate the following painting prompt words into English keyword phrases. Without any explanation, directly output the keyword phrases separated by commas. The content to be translated is: [%s]"
+
+type PromptHandler struct {
+	BaseHandler
+	db *gorm.DB
+}
+
+func NewPromptHandler(app *core.AppServer, db *gorm.DB) *PromptHandler {
+	h := &PromptHandler{db: db}
+	h.App = app
+	return h
+}
+
+type apiRes struct {
+	Model   string `json:"model"`
+	Choices []struct {
+		Index   int `json:"index"`
+		Message struct {
+			Role    string `json:"role"`
+			Content string `json:"content"`
+		} `json:"message"`
+		FinishReason string `json:"finish_reason"`
+	} `json:"choices"`
+}
+
+type apiErrRes struct {
+	Error struct {
+		Code    interface{} `json:"code"`
+		Message string      `json:"message"`
+		Param   interface{} `json:"param"`
+		Type    string      `json:"type"`
+	} `json:"error"`
+}
+
+// Rewrite translate and rewrite prompt with ChatGPT
+func (h *PromptHandler) Rewrite(c *gin.Context) {
+	var data struct {
+		Prompt string `json:"prompt"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	content, err := h.request(data.Prompt, rewritePromptTemplate)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, content)
+}
+
+func (h *PromptHandler) Translate(c *gin.Context) {
+	var data struct {
+		Prompt string `json:"prompt"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	content, err := h.request(data.Prompt, translatePromptTemplate)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, content)
+}
+
+func (h *PromptHandler) request(prompt string, promptTemplate string) (string, error) {
+	// 获取 OpenAI 的 API KEY
+	var apiKey model.ApiKey
+	res := h.db.Where("platform = ?", types.OpenAI).First(&apiKey)
+	if res.Error != nil {
+		return "", fmt.Errorf("error with fetch OpenAI API KEY：%v", res.Error)
+	}
+
+	messages := make([]interface{}, 1)
+	messages[0] = types.Message{
+		Role:    "user",
+		Content: fmt.Sprintf(promptTemplate, prompt),
+	}
+
+	var response apiRes
+	var errRes apiErrRes
+	r, err := req.C().SetProxyURL(h.App.Config.ProxyURL).R().SetHeader("Content-Type", "application/json").
+		SetHeader("Authorization", "Bearer "+apiKey.Value).
+		SetBody(types.ApiRequest{
+			Model:       "gpt-3.5-turbo",
+			Temperature: 0.9,
+			MaxTokens:   1024,
+			Stream:      false,
+			Messages:    messages,
+		}).
+		SetErrorResult(&errRes).
+		SetSuccessResult(&response).Post(h.App.ChatConfig.OpenAI.ApiURL)
+	if err != nil || r.IsErrorState() {
+		return "", fmt.Errorf("error with http request: %v%v%s", err, r.Err, errRes.Error.Message)
+	}
+
+	return response.Choices[0].Message.Content, nil
+}
--- a/api/handler/reward_handler.go
+++ b/api/handler/reward_handler.go
@@ -0,0 +1,77 @@
+package handler
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/store/model"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"strings"
+)
+
+type RewardHandler struct {
+	BaseHandler
+	db *gorm.DB
+}
+
+func NewRewardHandler(server *core.AppServer, db *gorm.DB) *RewardHandler {
+	h := RewardHandler{db: db}
+	h.App = server
+	return &h
+}
+
+// Verify 打赏码核销
+func (h *RewardHandler) Verify(c *gin.Context) {
+	var data struct {
+		TxId string `json:"tx_id"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	// 移除转账单号中间的空格，防止有人复制的时候多复制了空格
+	data.TxId = strings.ReplaceAll(data.TxId, " ", "")
+
+	var item model.Reward
+	res := h.db.Where("tx_id = ?", data.TxId).First(&item)
+	if res.Error != nil {
+		resp.ERROR(c, "无效的众筹交易流水号！")
+		return
+	}
+
+	if item.Status {
+		resp.ERROR(c, "当前众筹交易流水号已经被核销，请不要重复核销！")
+		return
+	}
+
+	user, err := utils.GetLoginUser(c, h.db)
+	if err != nil {
+		resp.HACKER(c)
+		return
+	}
+
+	tx := h.db.Begin()
+	calls := (item.Amount + 0.1) * 10
+	res = h.db.Model(&user).UpdateColumn("calls", gorm.Expr("calls + ?", calls))
+	if res.Error != nil {
+		resp.ERROR(c, "更新数据库失败！")
+		return
+	}
+
+	// 更新核销状态
+	item.Status = true
+	item.UserId = user.Id
+	res = h.db.Updates(&item)
+	if res.Error != nil {
+		tx.Rollback()
+		resp.ERROR(c, "更新数据库失败！")
+		return
+	}
+
+	tx.Commit()
+	resp.SUCCESS(c)
+
+}
--- a/api/handler/sd_handler.go
+++ b/api/handler/sd_handler.go
@@ -0,0 +1,190 @@
+package handler
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/service/sd"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"encoding/base64"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"github.com/go-redis/redis/v8"
+	"gorm.io/gorm"
+	"time"
+)
+
+type SdJobHandler struct {
+	BaseHandler
+	redis *redis.Client
+	db    *gorm.DB
+	pool  *sd.ServicePool
+}
+
+func NewSdJobHandler(app *core.AppServer, db *gorm.DB, pool *sd.ServicePool) *SdJobHandler {
+	h := SdJobHandler{
+		db:   db,
+		pool: pool,
+	}
+	h.App = app
+	return &h
+}
+
+func (h *SdJobHandler) checkLimits(c *gin.Context) bool {
+	user, err := utils.GetLoginUser(c, h.db)
+	if err != nil {
+		resp.NotAuth(c)
+		return false
+	}
+
+	if !h.pool.HasAvailableService() {
+		resp.ERROR(c, "Stable-Diffusion 池子中没有没有可用的服务！")
+		return false
+	}
+
+	if user.ImgCalls <= 0 {
+		resp.ERROR(c, "您的绘图次数不足，请联系管理员充值！")
+		return false
+	}
+
+	return true
+
+}
+
+// Image 创建一个绘画任务
+func (h *SdJobHandler) Image(c *gin.Context) {
+	if !h.checkLimits(c) {
+		return
+	}
+
+	var data struct {
+		SessionId string `json:"session_id"`
+		types.SdTaskParams
+	}
+	if err := c.ShouldBindJSON(&data); err != nil || data.Prompt == "" {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if data.Width <= 0 {
+		data.Width = 512
+	}
+	if data.Height <= 0 {
+		data.Height = 512
+	}
+	if data.CfgScale <= 0 {
+		data.CfgScale = 7
+	}
+	if data.Seed == 0 {
+		data.Seed = -1
+	}
+	if data.Steps <= 0 {
+		data.Steps = 20
+	}
+	if data.Sampler == "" {
+		data.Sampler = "Euler a"
+	}
+	idValue, _ := c.Get(types.LoginUserID)
+	userId := utils.IntValue(utils.InterfaceToString(idValue), 0)
+	params := types.SdTaskParams{
+		TaskId:         fmt.Sprintf("task(%s)", utils.RandString(15)),
+		Prompt:         data.Prompt,
+		NegativePrompt: data.NegativePrompt,
+		Steps:          data.Steps,
+		Sampler:        data.Sampler,
+		FaceFix:        data.FaceFix,
+		CfgScale:       data.CfgScale,
+		Seed:           data.Seed,
+		Height:         data.Height,
+		Width:          data.Width,
+		HdFix:          data.HdFix,
+		HdRedrawRate:   data.HdRedrawRate,
+		HdScale:        data.HdScale,
+		HdScaleAlg:     data.HdScaleAlg,
+		HdSteps:        data.HdSteps,
+	}
+	job := model.SdJob{
+		UserId:    userId,
+		Type:      types.TaskImage.String(),
+		TaskId:    params.TaskId,
+		Params:    utils.JsonEncode(params),
+		Prompt:    data.Prompt,
+		Progress:  0,
+		CreatedAt: time.Now(),
+	}
+	res := h.db.Create(&job)
+	if res.Error != nil {
+		resp.ERROR(c, "error with save job: "+res.Error.Error())
+		return
+	}
+
+	h.pool.PushTask(types.SdTask{
+		Id:        int(job.Id),
+		SessionId: data.SessionId,
+		Type:      types.TaskImage,
+		Prompt:    data.Prompt,
+		Params:    params,
+		UserId:    userId,
+	})
+
+	resp.SUCCESS(c)
+}
+
+// JobList 获取 stable diffusion 任务列表
+func (h *SdJobHandler) JobList(c *gin.Context) {
+	status := h.GetInt(c, "status", 0)
+	userId := h.GetInt(c, "user_id", 0)
+	page := h.GetInt(c, "page", 0)
+	pageSize := h.GetInt(c, "page_size", 0)
+
+	session := h.db.Session(&gorm.Session{})
+	if status == 1 {
+		session = session.Where("progress = ?", 100).Order("id DESC")
+	} else {
+		session = session.Where("progress < ?", 100).Order("id ASC")
+	}
+	if userId > 0 {
+		session = session.Where("user_id = ?", userId)
+	}
+	if page > 0 && pageSize > 0 {
+		offset := (page - 1) * pageSize
+		session = session.Offset(offset).Limit(pageSize)
+	}
+
+	var items []model.SdJob
+	res := session.Find(&items)
+	if res.Error != nil {
+		resp.ERROR(c, types.NoData)
+		return
+	}
+
+	var jobs = make([]vo.SdJob, 0)
+	for _, item := range items {
+		var job vo.SdJob
+		err := utils.CopyObject(item, &job)
+		if err != nil {
+			continue
+		}
+
+		if job.Progress == -1 {
+			h.db.Delete(&model.MidJourneyJob{Id: job.Id})
+		}
+
+		if item.Progress < 100 {
+			// 10 分钟还没完成的任务直接删除
+			if time.Now().Sub(item.CreatedAt) > time.Minute*10 {
+				h.db.Delete(&item)
+				continue
+			}
+			// 正在运行中任务使用代理访问图片
+			image, err := utils.DownloadImage(item.ImgURL, "")
+			if err == nil {
+				job.ImgURL = "data:image/png;base64," + base64.StdEncoding.EncodeToString(image)
+			}
+		}
+		jobs = append(jobs, job)
+	}
+	resp.SUCCESS(c, jobs)
+}
--- a/api/handler/sms_handler.go
+++ b/api/handler/sms_handler.go
@@ -0,0 +1,60 @@
+package handler
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/service"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"github.com/gin-gonic/gin"
+	"github.com/go-redis/redis/v8"
+)
+
+const CodeStorePrefix = "/verify/codes/"
+
+type SmsHandler struct {
+	BaseHandler
+	redis   *redis.Client
+	sms     *service.AliYunSmsService
+	captcha *service.CaptchaService
+}
+
+func NewSmsHandler(app *core.AppServer, client *redis.Client, sms *service.AliYunSmsService, captcha *service.CaptchaService) *SmsHandler {
+	handler := &SmsHandler{redis: client, sms: sms, captcha: captcha}
+	handler.App = app
+	return handler
+}
+
+// SendCode 发送验证码短信
+func (h *SmsHandler) SendCode(c *gin.Context) {
+	var data struct {
+		Mobile string `json:"mobile"`
+		Key    string `json:"key"`
+		Dots   string `json:"dots"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if !h.captcha.Check(data) {
+		resp.ERROR(c, "验证码错误，请先完人机验证")
+		return
+	}
+
+	code := utils.RandomNumber(6)
+	err := h.sms.SendVerifyCode(data.Mobile, code)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// 存储验证码，等待后面注册验证
+	_, err = h.redis.Set(c, CodeStorePrefix+data.Mobile, code, 0).Result()
+	if err != nil {
+		resp.ERROR(c, "验证码保存失败")
+		return
+	}
+
+	resp.SUCCESS(c)
+}
--- a/api/handler/test_handler.go
+++ b/api/handler/test_handler.go
@@ -0,0 +1,40 @@
+package handler
+
+import (
+	"chatplus/service"
+	"github.com/gin-gonic/gin"
+)
+
+type TestHandler struct {
+	snowflake *service.Snowflake
+}
+
+func NewTestHandler(snowflake *service.Snowflake) *TestHandler {
+	return &TestHandler{snowflake: snowflake}
+}
+
+func (h *TestHandler) TestPay(c *gin.Context) {
+	//appId := ""                                           //Appid
+	//appSecret := ""                                       //密钥
+	//var host = "https://api.xunhupay.com/payment/do.html" //跳转支付页接口URL
+	//client := payment.NewXunHuPay(appId, appSecret)     //初始化调用
+	//
+	////支付参数，appid、time、nonce_str和hash这四个参数不用传，调用的时候执行方法内部已经处理
+	//orderNo, _ := h.snowflake.Next()
+	//params := map[string]string{
+	//	"version":        "1.1",
+	//	"trade_order_id": orderNo,
+	//	"total_fee":      "0.1",
+	//	"title":          "测试支付",
+	//	"notify_url":     "http://xxxxxxx.com",
+	//	"return_url":     "http://localhost:8888",
+	//	"wap_name":       "极客学长",
+	//	"callback_url":   "",
+	//}
+	//
+	//execute, err := client.Execute(host, params) //执行支付操作
+	//if err != nil {
+	//	logger.Error(err)
+	//}
+	//resp.SUCCESS(c, execute)
+}
--- a/api/handler/upload_handler.go
+++ b/api/handler/upload_handler.go
@@ -2,66 +2,30 @@ package handler

 import (
 	"chatplus/core"
+	"chatplus/service/oss"
 	"chatplus/utils/resp"
-	"fmt"
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
-	"os"
-	"path/filepath"
-	"time"
 )

 type UploadHandler struct {
 	BaseHandler
-	db *gorm.DB
+	db              *gorm.DB
+	uploaderManager *oss.UploaderManager
 }

-func NewUploadHandler(app *core.AppServer, db *gorm.DB) *UploadHandler {
-	handler := &UploadHandler{db: db}
+func NewUploadHandler(app *core.AppServer, db *gorm.DB, manager *oss.UploaderManager) *UploadHandler {
+	handler := &UploadHandler{db: db, uploaderManager: manager}
 	handler.App = app
 	return handler
 }

 func (h *UploadHandler) Upload(c *gin.Context) {
-	file, err := c.FormFile("file")
+	fileURL, err := h.uploaderManager.GetUploadHandler().PutFile(c, "file")
 	if err != nil {
-		resp.ERROR(c, fmt.Sprintf("文件上传失败: %s", err.Error()))
+		resp.ERROR(c, err.Error())
 		return
 	}

-	filePath, err := h.genFilePath(file.Filename)
-	if err != nil {
-		resp.ERROR(c, fmt.Sprintf("文件上传失败: %s", err.Error()))
-		return
-	}
-	// 将文件保存到指定路径
-	err = c.SaveUploadedFile(file, filePath)
-	if err != nil {
-		resp.ERROR(c, fmt.Sprintf("文件保存失败: %s", err.Error()))
-		return
-	}
-
-	resp.SUCCESS(c, h.genFileUrl(filePath))
-}
-
-// 生成上传文件路径
-func (h *UploadHandler) genFilePath(filename string) (string, error) {
-	now := time.Now()
-	dir := fmt.Sprintf("%s/upload/%d/%d", h.App.Config.StaticDir, now.Year(), now.Month())
-	_, err := os.Stat(dir)
-	if err != nil {
-		err = os.MkdirAll(dir, 0755)
-		if err != nil {
-			return "", fmt.Errorf("创建上传目录失败：%s", err)
-		}
-	}
-	fileExt := filepath.Ext(filename)
-	return fmt.Sprintf("%s/%d%s", dir, now.UnixMilli(), fileExt), nil
-}
-
-// 生成上传文件 URL
-func (h *UploadHandler) genFileUrl(filePath string) string {
-	now := time.Now()
-	filename := filepath.Base(filePath)
-	return fmt.Sprintf("%s/upload/%d/%d/%s", h.App.Config.StaticUrl, now.Year(), now.Month(), filename)
+	resp.SUCCESS(c, fileURL)
 }
--- a/api/handler/user_handler.go
+++ b/api/handler/user_handler.go
@@ -3,16 +3,16 @@ package handler
 import (
 	"chatplus/core"
 	"chatplus/core/types"
-	"chatplus/store"
 	"chatplus/store/model"
 	"chatplus/store/vo"
 	"chatplus/utils"
 	"chatplus/utils/resp"
 	"fmt"
+	"github.com/go-redis/redis/v8"
+	"github.com/golang-jwt/jwt/v5"
 	"strings"
 	"time"

-	"github.com/gin-contrib/sessions"
 	"github.com/gin-gonic/gin"
 	"github.com/lionsoul2014/ip2region/binding/golang/xdb"
 	"gorm.io/gorm"
@@ -22,11 +22,15 @@ type UserHandler struct {
 	BaseHandler
 	db       *gorm.DB
 	searcher *xdb.Searcher
-	levelDB  *store.LevelDB
+	redis    *redis.Client
 }

-func NewUserHandler(app *core.AppServer, db *gorm.DB, searcher *xdb.Searcher, levelDB *store.LevelDB) *UserHandler {
-	handler := &UserHandler{db: db, searcher: searcher, levelDB: levelDB}
+func NewUserHandler(
+	app *core.AppServer,
+	db *gorm.DB,
+	searcher *xdb.Searcher,
+	client *redis.Client) *UserHandler {
+	handler := &UserHandler{db: db, searcher: searcher, redis: client}
 	handler.App = app
 	return handler
 }
@@ -35,20 +39,19 @@ func NewUserHandler(app *core.AppServer, db *gorm.DB, searcher *xdb.Searcher, le
 func (h *UserHandler) Register(c *gin.Context) {
 	// parameters process
 	var data struct {
-		Username string `json:"username"`
-		Password string `json:"password"`
-		Mobile   string `json:"mobile"`
-		Code     int    `json:"code"`
+		Mobile     string `json:"mobile"`
+		Password   string `json:"password"`
+		Code       string `json:"code"`
+		InviteCode string `json:"invite_code"`
 	}
 	if err := c.ShouldBindJSON(&data); err != nil {
 		resp.ERROR(c, types.InvalidArgs)
 		return
 	}
-	data.Username = strings.TrimSpace(data.Username)
 	data.Password = strings.TrimSpace(data.Password)

-	if len(data.Username) < 5 {
-		resp.ERROR(c, "用户名长度不能少于5个字符")
+	if len(data.Mobile) < 10 {
+		resp.ERROR(c, "请输入合法的手机号")
 		return
 	}
 	if len(data.Password) < 8 {
@@ -58,64 +61,55 @@ func (h *UserHandler) Register(c *gin.Context) {

 	// 检查验证码
 	key := CodeStorePrefix + data.Mobile
-	var code int
-	err := h.levelDB.Get(key, &code)
-	if err != nil || code != data.Code {
-		logger.Info(code)
-		resp.ERROR(c, "短信验证码错误")
-		return
+	if h.App.SysConfig.EnabledMsg {
+		code, err := h.redis.Get(c, key).Result()
+		if err != nil || code != data.Code {
+			resp.ERROR(c, "短信验证码错误")
+			return
+		}
+	}
+
+	// 验证邀请码
+	inviteCode := model.InviteCode{}
+	if data.InviteCode == "" {
+		if h.App.SysConfig.ForceInvite {
+			resp.ERROR(c, "当前系统设定必须使用邀请码才能注册")
+			return
+		}
+	} else {
+		res := h.db.Where("code = ?", data.InviteCode).First(&inviteCode)
+		if res.Error != nil {
+			resp.ERROR(c, "无效的邀请码")
+			return
+		}
 	}

 	// check if the username is exists
 	var item model.User
-	res := h.db.Where("username = ?", data.Username).First(&item)
+	res := h.db.Where("mobile = ?", data.Mobile).First(&item)
 	if res.RowsAffected > 0 {
-		resp.ERROR(c, "用户名已存在")
+		resp.ERROR(c, "该手机号码已经被注册，请更换其他手机号")
 		return
 	}

-	res = h.db.Where("mobile = ?", data.Mobile).First(&item)
-	if res.RowsAffected > 0 {
-		resp.ERROR(c, "该手机号码以及被注册，请更换其他手机号")
-		return
-	}
-
-	// 默认订阅所有角色
-	var chatRoles []model.ChatRole
-	h.db.Find(&chatRoles)
-	var roleKeys = make([]string, 0)
-	for _, r := range chatRoles {
-		roleKeys = append(roleKeys, r.Key)
-	}
-
 	salt := utils.RandString(8)
 	user := model.User{
-		Username:  data.Username,
-		Password:  utils.GenPassword(data.Password, salt),
-		Nickname:  fmt.Sprintf("极客学长@%d", utils.RandomNumber(5)),
-		Avatar:    "/images/avatar/user.png",
-		Salt:      salt,
-		Status:    true,
-		Mobile:    data.Mobile,
-		ChatRoles: utils.JsonEncode(roleKeys),
-		ChatConfig: utils.JsonEncode(types.ChatConfig{
-			Temperature:   h.App.ChatConfig.Temperature,
-			MaxTokens:     h.App.ChatConfig.MaxTokens,
-			EnableContext: h.App.ChatConfig.EnableContext,
-			EnableHistory: true,
-			Model:         h.App.ChatConfig.Model,
-			ApiKey:        "",
+		Password:   utils.GenPassword(data.Password, salt),
+		Avatar:     "/images/avatar/user.png",
+		Salt:       salt,
+		Status:     true,
+		Mobile:     data.Mobile,
+		ChatRoles:  utils.JsonEncode([]string{"gpt"}),               // 默认只订阅通用助手角色
+		ChatModels: utils.JsonEncode(h.App.SysConfig.DefaultModels), // 默认开通的模型
+		ChatConfig: utils.JsonEncode(types.UserChatConfig{
+			ApiKeys: map[types.Platform]string{
+				types.OpenAI:  "",
+				types.Azure:   "",
+				types.ChatGLM: "",
+			},
 		}),
-	}
-	// 初始化调用次数
-	var cfg model.Config
-	h.db.Where("marker = ?", "system").First(&cfg)
-	var config types.SystemConfig
-	err = utils.JsonDecode(cfg.Config, &config)
-	if err != nil || config.UserInitCalls <= 0 {
-		user.Calls = types.UserInitCalls
-	} else {
-		user.Calls = config.UserInitCalls
+		Calls:    h.App.SysConfig.InitChatCalls,
+		ImgCalls: h.App.SysConfig.InitImgCalls,
 	}
 	res = h.db.Create(&user)
 	if res.Error != nil {
@@ -124,22 +118,61 @@ func (h *UserHandler) Register(c *gin.Context) {
 		return
 	}

-	_ = h.levelDB.Delete(key) // 注册成功，删除短信验证码
-	resp.SUCCESS(c, user)
+	// 记录邀请关系
+	if data.InviteCode != "" {
+		// 增加邀请数量
+		h.db.Model(&model.InviteCode{}).Where("code = ?", data.InviteCode).UpdateColumn("reg_num", gorm.Expr("reg_num + ?", 1))
+		if h.App.SysConfig.InviteChatCalls > 0 {
+			h.db.Model(&model.User{}).Where("id = ?", inviteCode.UserId).UpdateColumn("calls", gorm.Expr("calls + ?", h.App.SysConfig.InviteChatCalls))
+		}
+		if h.App.SysConfig.InviteImgCalls > 0 {
+			h.db.Model(&model.User{}).Where("id = ?", inviteCode.UserId).UpdateColumn("img_calls", gorm.Expr("img_calls + ?", h.App.SysConfig.InviteImgCalls))
+		}
+
+		// 添加邀请记录
+		h.db.Create(&model.InviteLog{
+			InviterId:  inviteCode.UserId,
+			UserId:     user.Id,
+			Username:   user.Mobile,
+			InviteCode: inviteCode.Code,
+			Reward:     utils.JsonEncode(types.InviteReward{ChatCalls: h.App.SysConfig.InviteChatCalls, ImgCalls: h.App.SysConfig.InviteImgCalls}),
+		})
+	}
+	if h.App.SysConfig.EnabledMsg {
+		_ = h.redis.Del(c, key) // 注册成功，删除短信验证码
+	}
+
+	// 自动登录创建 token
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
+		"user_id": user.Id,
+		"expired": time.Now().Add(time.Second * time.Duration(h.App.Config.Session.MaxAge)).Unix(),
+	})
+	tokenString, err := token.SignedString([]byte(h.App.Config.Session.SecretKey))
+	if err != nil {
+		resp.ERROR(c, "Failed to generate token, "+err.Error())
+		return
+	}
+	// 保存到 redis
+	key = fmt.Sprintf("users/%d", user.Id)
+	if _, err := h.redis.Set(c, key, tokenString, 0).Result(); err != nil {
+		resp.ERROR(c, "error with save token: "+err.Error())
+		return
+	}
+	resp.SUCCESS(c, tokenString)
 }

 // Login 用户登录
 func (h *UserHandler) Login(c *gin.Context) {
 	var data struct {
-		Username string
-		Password string
+		Mobile   string `json:"username"`
+		Password string `json:"password"`
 	}
 	if err := c.ShouldBindJSON(&data); err != nil {
 		resp.ERROR(c, types.InvalidArgs)
 		return
 	}
 	var user model.User
-	res := h.db.Where("username = ?", data.Username).First(&user)
+	res := h.db.Where("mobile = ?", data.Mobile).First(&user)
 	if res.Error != nil {
 		resp.ERROR(c, "用户名不存在")
 		return
@@ -151,61 +184,48 @@ func (h *UserHandler) Login(c *gin.Context) {
 		return
 	}

+	if user.Status == false {
+		resp.ERROR(c, "该用户已被禁止登录，请联系管理员")
+		return
+	}
+
 	// 更新最后登录时间和IP
 	user.LastLoginIp = c.ClientIP()
 	user.LastLoginAt = time.Now().Unix()
 	h.db.Model(&user).Updates(user)

-	sessionId := utils.RandString(42)
-	err := utils.SetLoginUser(c, user)
-	if err != nil {
-		resp.ERROR(c, "保存会话失败")
-		logger.Error("Error for save session: ", err)
-		return
-	}
-
-	// 记录登录信息在服务端
-	h.App.ChatSession.Put(sessionId, types.ChatSession{ClientIP: c.ClientIP(), UserId: user.Id, Username: data.Username, SessionId: sessionId})
-
 	h.db.Create(&model.UserLoginLog{
 		UserId:       user.Id,
-		Username:     user.Username,
+		Username:     user.Mobile,
 		LoginIp:      c.ClientIP(),
 		LoginAddress: utils.Ip2Region(h.searcher, c.ClientIP()),
 	})
-	var chatConfig types.ChatConfig
-	err = utils.JsonDecode(user.ChatConfig, &chatConfig)
+
+	// 创建 token
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
+		"user_id": user.Id,
+		"expired": time.Now().Add(time.Second * time.Duration(h.App.Config.Session.MaxAge)).Unix(),
+	})
+	tokenString, err := token.SignedString([]byte(h.App.Config.Session.SecretKey))
 	if err != nil {
-		resp.ERROR(c, err.Error())
+		resp.ERROR(c, "Failed to generate token, "+err.Error())
 		return
 	}
-
-	resp.SUCCESS(c, gin.H{
-		"session_id":     sessionId,
-		"id":             user.Id,
-		"nickname":       user.Nickname,
-		"avatar":         user.Avatar,
-		"username":       user.Username,
-		"tokens":         user.Tokens,
-		"calls":          user.Calls,
-		"expired_time":   user.ExpiredTime,
-		"api_key":        chatConfig.ApiKey,
-		"model":          chatConfig.Model,
-		"temperature":    chatConfig.Temperature,
-		"max_tokens":     chatConfig.MaxTokens,
-		"enable_context": chatConfig.EnableContext,
-		"enable_history": chatConfig.EnableHistory,
-	})
+	// 保存到 redis
+	key := fmt.Sprintf("users/%d", user.Id)
+	if _, err := h.redis.Set(c, key, tokenString, 0).Result(); err != nil {
+		resp.ERROR(c, "error with save token: "+err.Error())
+		return
+	}
+	resp.SUCCESS(c, tokenString)
 }

 // Logout 注 销
 func (h *UserHandler) Logout(c *gin.Context) {
-	sessionId := c.GetHeader(types.SessionName)
-	session := sessions.Default(c)
-	session.Delete(types.SessionUser)
-	err := session.Save()
-	if err != nil {
-		logger.Error("Error for save session: ", err)
+	sessionId := c.GetHeader(types.ChatTokenHeader)
+	key := h.GetUserKey(c)
+	if _, err := h.redis.Del(c, key).Result(); err != nil {
+		logger.Error("error with delete session: ", err)
 	}
 	// 删除 websocket 会话列表
 	h.App.ChatSession.Delete(sessionId)
@@ -235,14 +255,16 @@ func (h *UserHandler) Session(c *gin.Context) {
 }

 type userProfile struct {
-	Id         uint             `json:"id"`
-	Username   string           `json:"username"`
-	Nickname   string           `json:"nickname"`
-	Mobile     string           `json:"mobile"`
-	Avatar     string           `json:"avatar"`
-	ChatConfig types.ChatConfig `json:"chat_config"`
-	Calls      int              `json:"calls"`
-	Tokens     int64            `json:"tokens"`
+	Id          uint                 `json:"id"`
+	Mobile      string               `json:"mobile"`
+	Avatar      string               `json:"avatar"`
+	ChatConfig  types.UserChatConfig `json:"chat_config"`
+	Calls       int                  `json:"calls"`
+	ImgCalls    int                  `json:"img_calls"`
+	TotalTokens int64                `json:"total_tokens"`
+	Tokens      int64                `json:"tokens"`
+	ExpiredTime int64                `json:"expired_time"`
+	Vip         bool                 `json:"vip"`
 }

 func (h *UserHandler) Profile(c *gin.Context) {
@@ -278,34 +300,19 @@ func (h *UserHandler) ProfileUpdate(c *gin.Context) {
 		return
 	}
 	h.db.First(&user, user.Id)
-	user.Nickname = data.Nickname
 	user.Avatar = data.Avatar
-
-	var chatConfig types.ChatConfig
-	err = utils.JsonDecode(user.ChatConfig, &chatConfig)
-	if err != nil {
-		resp.ERROR(c, "用户配置解析失败")
-		return
-	}
-
-	chatConfig.EnableHistory = data.ChatConfig.EnableHistory
-	chatConfig.EnableContext = data.ChatConfig.EnableContext
-	chatConfig.Model = data.ChatConfig.Model
-	chatConfig.MaxTokens = data.ChatConfig.MaxTokens
-	chatConfig.ApiKey = data.ChatConfig.ApiKey
-	chatConfig.Temperature = data.ChatConfig.Temperature
-
-	user.ChatConfig = utils.JsonEncode(chatConfig)
+	user.ChatConfig = utils.JsonEncode(data.ChatConfig)
 	res := h.db.Updates(&user)
 	if res.Error != nil {
 		resp.ERROR(c, "更新用户信息失败")
 		return
 	}
+
 	resp.SUCCESS(c)
 }

-// Password 更新密码
-func (h *UserHandler) Password(c *gin.Context) {
+// UpdatePass 更新密码
+func (h *UserHandler) UpdatePass(c *gin.Context) {
 	var data struct {
 		OldPass  string `json:"old_pass"`
 		Password string `json:"password"`
@@ -344,17 +351,65 @@ func (h *UserHandler) Password(c *gin.Context) {
 	resp.SUCCESS(c)
 }

+// ResetPass 重置密码
+func (h *UserHandler) ResetPass(c *gin.Context) {
+	var data struct {
+		Mobile   string
+		Code     string // 验证码
+		Password string // 新密码
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	var user model.User
+	res := h.db.Where("mobile", data.Mobile).First(&user)
+	if res.Error != nil {
+		resp.ERROR(c, "用户不存在！")
+		return
+	}
+
+	// 检查验证码
+	key := CodeStorePrefix + data.Mobile
+	if h.App.SysConfig.EnabledMsg {
+		code, err := h.redis.Get(c, key).Result()
+		if err != nil || code != data.Code {
+			resp.ERROR(c, "短信验证码错误")
+			return
+		}
+	}
+
+	password := utils.GenPassword(data.Password, user.Salt)
+	user.Password = password
+	res = h.db.Updates(&user)
+	if res.Error != nil {
+		resp.ERROR(c)
+	} else {
+		h.redis.Del(c, key)
+		resp.SUCCESS(c)
+	}
+}
+
 // BindMobile 绑定手机号
 func (h *UserHandler) BindMobile(c *gin.Context) {
 	var data struct {
 		Mobile string `json:"mobile"`
-		Code   int    `json:"code"`
+		Code   string `json:"code"`
 	}
 	if err := c.ShouldBindJSON(&data); err != nil {
 		resp.ERROR(c, types.InvalidArgs)
 		return
 	}

+	// 检查验证码
+	key := CodeStorePrefix + data.Mobile
+	code, err := h.redis.Get(c, key).Result()
+	if err != nil || code != data.Code {
+		resp.ERROR(c, "短信验证码错误")
+		return
+	}
+
 	// 检查手机号是否被其他账号绑定
 	var item model.User
 	res := h.db.Where("mobile = ?", data.Mobile).First(&item)
@@ -363,15 +418,6 @@ func (h *UserHandler) BindMobile(c *gin.Context) {
 		return
 	}

-	// 检查验证码
-	key := CodeStorePrefix + data.Mobile
-	var code int
-	err := h.levelDB.Get(key, &code)
-	if err != nil || code != data.Code {
-		resp.ERROR(c, "短信验证码错误")
-		return
-	}
-
 	user, err := utils.GetLoginUser(c, h.db)
 	if err != nil {
 		resp.NotAuth(c)
@@ -384,6 +430,6 @@ func (h *UserHandler) BindMobile(c *gin.Context) {
 		return
 	}

-	_ = h.levelDB.Delete(key) // 删除短信验证码
+	_ = h.redis.Del(c, key) // 删除短信验证码
 	resp.SUCCESS(c)
 }
--- a/api/handler/verify_handler.go
+++ b/api/handler/verify_handler.go
@@ -1,150 +0,0 @@
-package handler
-
-import (
-	"chatplus/core"
-	"chatplus/core/types"
-	"chatplus/service"
-	"chatplus/store"
-	"chatplus/utils"
-	"chatplus/utils/resp"
-	"fmt"
-	"time"
-
-	"github.com/gin-gonic/gin"
-)
-
-// 生成验证的控制器
-
-type VerifyHandler struct {
-	BaseHandler
-	sms *service.AliYunSmsService
-	db  *store.LevelDB
-}
-
-const TokenStorePrefix = "/verify/tokens/"
-const CodeStorePrefix = "/verify/codes/"
-const MobileStatPrefix = "/verify/stats/"
-
-func NewVerifyHandler(app *core.AppServer, sms *service.AliYunSmsService, db *store.LevelDB) *VerifyHandler {
-	handler := &VerifyHandler{sms: sms, db: db}
-	handler.App = app
-	return handler
-}
-
-type VerifyToken struct {
-	Token     string
-	Timestamp int64
-}
-
-// CodeStats 验证码发送统计
-type CodeStats struct {
-	Mobile string
-	Count  uint
-	Time   int64
-}
-
-// Token 生成自验证 token
-func (h *VerifyHandler) Token(c *gin.Context) {
-	// 如果不是通过浏览器访问，则返回错误的 token
-	if c.GetHeader("Sec-Fetch-Mode") != "cors" {
-		token := fmt.Sprintf("%s:%d", utils.RandString(32), time.Now().Unix())
-		encrypt, err := utils.AesEncrypt(h.App.Config.AesEncryptKey, []byte(token))
-		if err != nil {
-			resp.ERROR(c, "Token 加密出错")
-			return
-		}
-		resp.SUCCESS(c, encrypt)
-		return
-	}
-
-	token := VerifyToken{
-		Token:     utils.RandString(32),
-		Timestamp: time.Now().Unix(),
-	}
-	json := utils.JsonEncode(token)
-	encrypt, err := utils.AesEncrypt(h.App.Config.AesEncryptKey, []byte(json))
-	if err != nil {
-		resp.ERROR(c, "Token 加密出错")
-		return
-	}
-	err = h.db.Put(TokenStorePrefix+token.Token, token)
-	if err != nil {
-		resp.ERROR(c, "Token 存储失败")
-		return
-	}
-
-	resp.SUCCESS(c, encrypt)
-}
-
-// SendMsg 发送验证码短信
-func (h *VerifyHandler) SendMsg(c *gin.Context) {
-	var data struct {
-		Mobile string `json:"mobile"`
-		Token  string `json:"token"`
-	}
-	if err := c.ShouldBindJSON(&data); err != nil {
-		resp.ERROR(c, types.InvalidArgs)
-		return
-	}
-
-	decrypt, err := utils.AesDecrypt(h.App.Config.AesEncryptKey, data.Token)
-	if err != nil {
-		resp.ERROR(c, "Token 解密失败")
-		return
-	}
-
-	var token VerifyToken
-	err = utils.JsonDecode(string(decrypt), &token)
-	if err != nil {
-		resp.ERROR(c, "Token 解码失败")
-		return
-	}
-
-	if time.Now().Unix()-token.Timestamp > 30 {
-		resp.ERROR(c, "Token 已过期，请刷新页面重试")
-		return
-	}
-
-	// 验证当前手机号发送次数，24 小时内相同手机号只允许发送 2 次
-	var stat CodeStats
-	err = h.db.Get(MobileStatPrefix+data.Mobile, &stat)
-	if err != nil {
-		logger.Error(err)
-		stat = CodeStats{
-			Mobile: data.Mobile,
-			Count:  0,
-			Time:   time.Now().Unix(),
-		}
-	} else if stat.Count == 2 {
-		if time.Now().Unix()-stat.Time > 86400 {
-			stat.Count = 0
-			stat.Time = time.Now().Unix()
-		} else {
-			resp.ERROR(c, "触发流量预警，请 24 小时后再操作！")
-			return
-		}
-	}
-
-	code := utils.RandomNumber(6)
-	err = h.sms.SendVerifyCode(data.Mobile, code)
-	if err != nil {
-		resp.ERROR(c, err.Error())
-		return
-	}
-
-	// 每个 token 用完一次立即失效
-	_ = h.db.Delete(TokenStorePrefix + token.Token)
-	// 存储验证码，等待后面注册验证
-	err = h.db.Put(CodeStorePrefix+data.Mobile, code)
-	if err != nil {
-		resp.ERROR(c, "验证码保存失败")
-		return
-	}
-
-	// 更新发送次数
-	stat.Count = stat.Count + 1
-	_ = h.db.Put(MobileStatPrefix+data.Mobile, stat)
-	logger.Infof("%+v", stat)
-
-	resp.SUCCESS(c)
-}
--- a/api/logger/logger.go
+++ b/api/logger/logger.go
@@ -2,25 +2,73 @@ package logger

 import (
 	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+	"gopkg.in/natefinch/lumberjack.v2"
+	"os"
+	"strings"
 )

-var logger *zap.SugaredLogger
+var logger *zap.Logger
+var sugarLogger *zap.SugaredLogger

 func GetLogger() *zap.SugaredLogger {
-	if logger != nil {
-		return logger
+	if sugarLogger != nil {
+		return sugarLogger
 	}

-	logLevel := zap.NewAtomicLevel()
-	logLevel.SetLevel(zap.InfoLevel)
-	log, _ := zap.Config{
-		Level:            logLevel,
-		Development:      false,
-		Encoding:         "console",
-		EncoderConfig:    zap.NewDevelopmentEncoderConfig(),
-		OutputPaths:      []string{"stderr"},
-		ErrorOutputPaths: []string{"stderr"},
-	}.Build()
-	logger = log.Sugar()
-	return logger
+	logLevel := zap.NewAtomicLevelAt(getLogLevel(os.Getenv("LOG_LEVEL")))
+	encoder := getEncoder()
+	writerSyncer := getLogWriter()
+	fileCore := zapcore.NewCore(encoder, writerSyncer, logLevel)
+	consoleOutput := zapcore.Lock(os.Stdout)
+	consoleCore := zapcore.NewCore(
+		encoder,
+		consoleOutput,
+		logLevel,
+	)
+	core := zapcore.NewTee(fileCore, consoleCore)
+	logger = zap.New(core, zap.AddCaller())
+	sugarLogger = logger.Sugar()
+	return sugarLogger
+}
+
+// core 三个参数之  编码
+func getEncoder() zapcore.Encoder {
+	encoderConfig := zapcore.EncoderConfig{
+		TimeKey:        "time",
+		LevelKey:       "level",
+		NameKey:        "logger",
+		CallerKey:      "caller",
+		MessageKey:     "msg",
+		StacktraceKey:  "stacktrace",
+		EncodeTime:     zapcore.ISO8601TimeEncoder,
+		EncodeDuration: zapcore.SecondsDurationEncoder,
+		EncodeCaller:   zapcore.ShortCallerEncoder,
+		EncodeLevel:    zapcore.CapitalLevelEncoder,
+	}
+	return zapcore.NewConsoleEncoder(encoderConfig)
+}
+
+func getLogWriter() zapcore.WriteSyncer {
+	lumberJackLogger := &lumberjack.Logger{
+		Filename:   "logs/app.log",
+		MaxSize:    10,
+		MaxBackups: 5,
+		MaxAge:     30,
+		Compress:   false,
+	}
+	return zapcore.AddSync(lumberJackLogger)
+}
+
+func getLogLevel(level string) zapcore.Level {
+	switch strings.ToUpper(level) {
+	case "DEBUG":
+		return zapcore.DebugLevel
+	case "WARN":
+		return zapcore.WarnLevel
+	case "ERROR":
+		return zapcore.ErrorLevel
+	default:
+		return zapcore.InfoLevel
+	}
 }
--- a/api/main.go
+++ b/api/main.go
@@ -5,9 +5,15 @@ import (
 	"chatplus/core/types"
 	"chatplus/handler"
 	"chatplus/handler/admin"
+	"chatplus/handler/chatimpl"
 	logger2 "chatplus/logger"
 	"chatplus/service"
-	"chatplus/service/function"
+	"chatplus/service/fun"
+	"chatplus/service/mj"
+	"chatplus/service/oss"
+	"chatplus/service/payment"
+	"chatplus/service/sd"
+	"chatplus/service/wx"
 	"chatplus/store"
 	"context"
 	"embed"
@@ -19,6 +25,8 @@ import (
 	"syscall"
 	"time"

+	"github.com/go-redis/redis/v8"
+
 	"github.com/lionsoul2014/ip2region/binding/golang/xdb"
 	"go.uber.org/fx"
 	"gorm.io/gorm"
@@ -26,7 +34,7 @@ import (

 var logger = logger2.GetLogger()

-//go:embed res/ip2region.xdb
+//go:embed res
 var xdbFS embed.FS

 // AppLifecycle 应用程序生命周期
@@ -72,19 +80,26 @@ func main() {
 				log.Fatal(err)
 			}
 			config.Path = configFile
+			if debug {
+				_ = core.SaveConfig(config)
+			}
 			return config
 		}),
 		// 创建应用服务
 		fx.Provide(core.NewServer),
 		// 初始化
-		fx.Invoke(func(s *core.AppServer) {
-			s.Init(debug)
+		fx.Invoke(func(s *core.AppServer, client *redis.Client) {
+			s.Init(debug, client)
 		}),

 		// 初始化数据库
 		fx.Provide(store.NewGormConfig),
 		fx.Provide(store.NewMysql),
-		fx.Provide(store.NewLevelDB),
+		fx.Provide(store.NewRedisClient),
+
+		fx.Provide(func() embed.FS {
+			return xdbFS
+		}),

 		// 创建 Ip2Region 查询对象
 		fx.Provide(func() (*xdb.Searcher, error) {
@@ -101,31 +116,76 @@ func main() {
 		}),

 		// 创建函数
-		fx.Provide(func() *function.FuncZaoBao {
-			token := os.Getenv("AL_API_TOKEN")
-			return function.NewZaoBao(token)
-		}),
+		fx.Provide(fun.NewFunctions),

 		// 创建控制器
 		fx.Provide(handler.NewChatRoleHandler),
 		fx.Provide(handler.NewUserHandler),
-		fx.Provide(handler.NewChatHandler),
+		fx.Provide(chatimpl.NewChatHandler),
 		fx.Provide(handler.NewUploadHandler),
-		fx.Provide(handler.NewVerifyHandler),
+		fx.Provide(handler.NewSmsHandler),
+		fx.Provide(handler.NewRewardHandler),
+		fx.Provide(handler.NewCaptchaHandler),
+		fx.Provide(handler.NewMidJourneyHandler),
+		fx.Provide(handler.NewChatModelHandler),
+		fx.Provide(handler.NewSdJobHandler),
+		fx.Provide(handler.NewPaymentHandler),
+		fx.Provide(handler.NewOrderHandler),
+		fx.Provide(handler.NewProductHandler),

 		fx.Provide(admin.NewConfigHandler),
 		fx.Provide(admin.NewAdminHandler),
 		fx.Provide(admin.NewApiKeyHandler),
 		fx.Provide(admin.NewUserHandler),
 		fx.Provide(admin.NewChatRoleHandler),
+		fx.Provide(admin.NewRewardHandler),
+		fx.Provide(admin.NewDashboardHandler),
+		fx.Provide(admin.NewChatModelHandler),
+		fx.Provide(admin.NewProductHandler),
+		fx.Provide(admin.NewOrderHandler),

 		// 创建服务
 		fx.Provide(service.NewAliYunSmsService),
+		fx.Provide(func(config *types.AppConfig) *service.CaptchaService {
+			return service.NewCaptchaService(config.ApiConfig)
+		}),
+		fx.Provide(oss.NewUploaderManager),
+		fx.Provide(mj.NewService),
+
+		// 微信机器人服务
+		fx.Provide(wx.NewWeChatBot),
+		fx.Invoke(func(config *types.AppConfig, bot *wx.Bot) {
+			if config.WeChatBot {
+				err := bot.Run()
+				if err != nil {
+					logger.Error("微信登录失败：", err)
+				}
+			}
+		}),
+
+		// MidJourney service pool
+		fx.Provide(mj.NewServicePool),
+
+		// Stable Diffusion 机器人
+		fx.Provide(sd.NewServicePool),
+
+		fx.Provide(payment.NewAlipayService),
+		fx.Provide(payment.NewHuPiPay),
+		fx.Provide(service.NewSnowflake),
+		fx.Provide(service.NewXXLJobExecutor),
+		fx.Invoke(func(exec *service.XXLJobExecutor, config *types.AppConfig) {
+			if config.XXLConfig.Enabled {
+				go func() {
+					log.Fatal(exec.Run())
+				}()
+			}
+		}),

 		// 注册路由
 		fx.Invoke(func(s *core.AppServer, h *handler.ChatRoleHandler) {
 			group := s.Engine.Group("/api/role/")
 			group.GET("list", h.List)
+			group.POST("update", h.UpdateRole)
 		}),
 		fx.Invoke(func(s *core.AppServer, h *handler.UserHandler) {
 			group := s.Engine.Group("/api/user/")
@@ -135,27 +195,49 @@ func main() {
 			group.GET("session", h.Session)
 			group.GET("profile", h.Profile)
 			group.POST("profile/update", h.ProfileUpdate)
-			group.POST("password", h.Password)
+			group.POST("password", h.UpdatePass)
 			group.POST("bind/mobile", h.BindMobile)
+			group.POST("resetPass", h.ResetPass)
 		}),
-		fx.Invoke(func(s *core.AppServer, h *handler.ChatHandler) {
+		fx.Invoke(func(s *core.AppServer, h *chatimpl.ChatHandler) {
 			group := s.Engine.Group("/api/chat/")
 			group.Any("new", h.ChatHandle)
 			group.GET("list", h.List)
+			group.GET("detail", h.Detail)
 			group.POST("update", h.Update)
 			group.GET("remove", h.Remove)
 			group.GET("history", h.History)
 			group.GET("clear", h.Clear)
-			group.GET("tokens", h.Tokens)
+			group.POST("tokens", h.Tokens)
 			group.GET("stop", h.StopGenerate)
 		}),
 		fx.Invoke(func(s *core.AppServer, h *handler.UploadHandler) {
 			s.Engine.POST("/api/upload", h.Upload)
 		}),
-		fx.Invoke(func(s *core.AppServer, h *handler.VerifyHandler) {
-			group := s.Engine.Group("/api/verify/")
-			group.GET("token", h.Token)
-			group.POST("sms", h.SendMsg)
+		fx.Invoke(func(s *core.AppServer, h *handler.SmsHandler) {
+			group := s.Engine.Group("/api/sms/")
+			group.POST("code", h.SendCode)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.CaptchaHandler) {
+			group := s.Engine.Group("/api/captcha/")
+			group.GET("get", h.Get)
+			group.POST("check", h.Check)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.RewardHandler) {
+			group := s.Engine.Group("/api/reward/")
+			group.POST("verify", h.Verify)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.MidJourneyHandler) {
+			group := s.Engine.Group("/api/mj/")
+			group.POST("image", h.Image)
+			group.POST("upscale", h.Upscale)
+			group.POST("variation", h.Variation)
+			group.GET("jobs", h.JobList)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.SdJobHandler) {
+			group := s.Engine.Group("/api/sd")
+			group.POST("image", h.Image)
+			group.GET("jobs", h.JobList)
 		}),

 		// 管理后台控制器
@@ -169,7 +251,6 @@ func main() {
 			group.POST("login", h.Login)
 			group.GET("logout", h.Logout)
 			group.GET("session", h.Session)
-			group.GET("migrate", h.Migrate)
 		}),
 		fx.Invoke(func(s *core.AppServer, h *admin.ApiKeyHandler) {
 			group := s.Engine.Group("/api/admin/apikey/")
@@ -180,18 +261,89 @@ func main() {
 		fx.Invoke(func(s *core.AppServer, h *admin.UserHandler) {
 			group := s.Engine.Group("/api/admin/user/")
 			group.GET("list", h.List)
-			group.POST("update", h.Update)
+			group.POST("save", h.Save)
 			group.GET("remove", h.Remove)
 			group.GET("loginLog", h.LoginLog)
+			group.POST("resetPass", h.ResetPass)
 		}),
 		fx.Invoke(func(s *core.AppServer, h *admin.ChatRoleHandler) {
 			group := s.Engine.Group("/api/admin/role/")
 			group.GET("list", h.List)
 			group.POST("save", h.Save)
-			group.POST("sort", h.SetSort)
+			group.POST("sort", h.Sort)
 			group.GET("remove", h.Remove)
 		}),
+		fx.Invoke(func(s *core.AppServer, h *admin.RewardHandler) {
+			group := s.Engine.Group("/api/admin/reward/")
+			group.GET("list", h.List)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *admin.DashboardHandler) {
+			group := s.Engine.Group("/api/admin/dashboard/")
+			group.GET("stats", h.Stats)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.ChatModelHandler) {
+			group := s.Engine.Group("/api/model/")
+			group.GET("list", h.List)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *admin.ChatModelHandler) {
+			group := s.Engine.Group("/api/admin/model/")
+			group.POST("save", h.Save)
+			group.GET("list", h.List)
+			group.POST("set", h.Set)
+			group.POST("sort", h.Sort)
+			group.GET("remove", h.Remove)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.PaymentHandler) {
+			group := s.Engine.Group("/api/payment/")
+			group.GET("doPay", h.DoPay)
+			group.GET("payWays", h.GetPayWays)
+			group.POST("query", h.OrderQuery)
+			group.POST("qrcode", h.PayQrcode)
+			group.POST("alipay/notify", h.AlipayNotify)
+			group.POST("hupipay/notify", h.HuPiPayNotify)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *admin.ProductHandler) {
+			group := s.Engine.Group("/api/admin/product/")
+			group.POST("save", h.Save)
+			group.GET("list", h.List)
+			group.POST("enable", h.Enable)
+			group.POST("sort", h.Sort)
+			group.GET("remove", h.Remove)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *admin.OrderHandler) {
+			group := s.Engine.Group("/api/admin/order/")
+			group.POST("list", h.List)
+			group.GET("remove", h.Remove)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.OrderHandler) {
+			group := s.Engine.Group("/api/order/")
+			group.POST("list", h.List)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.ProductHandler) {
+			group := s.Engine.Group("/api/product/")
+			group.GET("list", h.List)
+		}),

+		fx.Provide(handler.NewInviteHandler),
+		fx.Invoke(func(s *core.AppServer, h *handler.InviteHandler) {
+			group := s.Engine.Group("/api/invite/")
+			group.GET("code", h.Code)
+			group.POST("list", h.List)
+			group.GET("hits", h.Hits)
+		}),
+
+		fx.Provide(handler.NewPromptHandler),
+		fx.Invoke(func(s *core.AppServer, h *handler.PromptHandler) {
+			group := s.Engine.Group("/api/prompt/")
+			group.POST("rewrite", h.Rewrite)
+			group.POST("translate", h.Translate)
+		}),
+
+		fx.Provide(handler.NewTestHandler),
+		fx.Invoke(func(s *core.AppServer, h *handler.TestHandler) {
+			group := s.Engine.Group("/test/")
+			group.GET("pay", h.TestPay)
+		}),
 		fx.Invoke(func(s *core.AppServer, db *gorm.DB) {
 			err := s.Run(db)
 			if err != nil {
--- a/api/res/img/alipay.jpg
+++ b/api/res/img/alipay.jpg
--- a/api/res/img/wechat-pay.jpg
+++ b/api/res/img/wechat-pay.jpg
--- a/api/res/text2img.json
+++ b/api/res/text2img.json
@@ -0,0 +1,79 @@
+{
+  "data": [
+    "task(owy5niy1sbbnlq0)",
+    "A beautiful Chinese girl plays the guitar on the beach. She is dressed in a flowing dress that matches the colors of the sunset. With her eyes closed, she strums the guitar with passion and confidence, her fingers dancing gracefully on the strings. The painting employs a vibrant color palette, capturing the warmth of the setting sun blending with the serene hues of the ocean. The artist uses a combination of impressionistic and realistic brushstrokes to convey both the girl's delicate features and the dynamic movement of the waves. The rendering effect creates a dream-like atmosphere, as if the viewer is being transported to a magical realm where music and nature intertwine. The picture is bathed in a soft, golden light, casting a warm glow on the girl's face, illuminating her joy and connection to the music she creates.",
+    "",
+    [],
+    30,
+    "DPM++ 3M SDE Karras",
+    1,
+    1,
+    7,
+    512,
+    512,
+    false,
+    0.7,
+    2,
+    "Latent",
+    0,
+    0,
+    0,
+    "Use same checkpoint",
+    "Use same sampler",
+    "",
+    "",
+    [],
+    "None",
+    false,
+    "",
+    0.8,
+    -1,
+    false,
+    -1,
+    0,
+    0,
+    0,
+    null,
+    null,
+    null,
+    false,
+    false,
+    "positive",
+    "comma",
+    0,
+    false,
+    false,
+    "",
+    "Seed",
+    "",
+    [],
+    "Nothing",
+    "",
+    [],
+    "Nothing",
+    "",
+    [],
+    true,
+    false,
+    false,
+    false,
+    0,
+    null,
+    null,
+    false,
+    null,
+    null,
+    false,
+    null,
+    null,
+    false,
+    50,
+    [],
+    "",
+    "",
+    ""
+  ],
+  "event_data": null,
+  "fn_index": 316,
+  "session_hash": "ttr8efgt63g"
+}
--- a/api/service/aliyun_sms_service.go
+++ b/api/service/aliyun_sms_service.go
@@ -2,18 +2,16 @@ package service

 import (
 	"chatplus/core/types"
-	"chatplus/store"
 	"fmt"
 	"github.com/aliyun/alibaba-cloud-sdk-go/services/dysmsapi"
 )

 type AliYunSmsService struct {
-	config *types.AppConfig
-	db     *store.LevelDB
+	config *types.AliYunSmsConfig
 	client *dysmsapi.Client
 }

-func NewAliYunSmsService(config *types.AppConfig, db *store.LevelDB) (*AliYunSmsService, error) {
+func NewAliYunSmsService(config *types.AppConfig) (*AliYunSmsService, error) {
 	// 创建阿里云短信客户端
 	client, err := dysmsapi.NewClientWithAccessKey(
 		"cn-hangzhou",
@@ -24,8 +22,7 @@ func NewAliYunSmsService(config *types.AppConfig, db *store.LevelDB) (*AliYunSms
 	}

 	return &AliYunSmsService{
-		config: config,
-		db:     db,
+		config: &config.SmsConfig,
 		client: client,
 	}, nil
 }
@@ -34,10 +31,10 @@ func (s *AliYunSmsService) SendVerifyCode(mobile string, code int) error {
 	// 创建短信请求并设置参数
 	request := dysmsapi.CreateSendSmsRequest()
 	request.Scheme = "https"
-	request.Domain = s.config.SmsConfig.Domain
+	request.Domain = s.config.Domain
 	request.PhoneNumbers = mobile
-	request.SignName = "飞行的蜗牛"
-	request.TemplateCode = "SMS_281460317"
+	request.SignName = s.config.Sign
+	request.TemplateCode = s.config.CodeTempId
 	request.TemplateParam = fmt.Sprintf("{\"code\":\"%d\"}", code) // 短信模板中的参数

 	// 发送短信
--- a/api/service/captcha_service.go
+++ b/api/service/captcha_service.go
@@ -0,0 +1,62 @@
+package service
+
+import (
+	"chatplus/core/types"
+	"errors"
+	"fmt"
+	"github.com/imroc/req/v3"
+	"time"
+)
+
+type CaptchaService struct {
+	config types.ChatPlusApiConfig
+	client *req.Client
+}
+
+func NewCaptchaService(config types.ChatPlusApiConfig) *CaptchaService {
+	return &CaptchaService{
+		config: config,
+		client: req.C().SetTimeout(10 * time.Second),
+	}
+}
+
+func (s *CaptchaService) Get() (interface{}, error) {
+	if s.config.Token == "" {
+		return nil, errors.New("无效的 API Token")
+	}
+
+	url := fmt.Sprintf("%s/api/captcha/get", s.config.ApiURL)
+	var res types.BizVo
+	r, err := s.client.R().
+		SetHeader("AppId", s.config.AppId).
+		SetHeader("Authorization", fmt.Sprintf("Bearer %s", s.config.Token)).
+		SetSuccessResult(&res).Get(url)
+	if err != nil || r.IsErrorState() {
+		return nil, fmt.Errorf("请求 API 失败：%v", err)
+	}
+
+	if res.Code != types.Success {
+		return nil, fmt.Errorf("请求 API 失败：%s", res.Message)
+	}
+
+	return res.Data, nil
+}
+
+func (s *CaptchaService) Check(data interface{}) bool {
+	url := fmt.Sprintf("%s/api/captcha/check", s.config.ApiURL)
+	var res types.BizVo
+	r, err := s.client.R().
+		SetHeader("AppId", s.config.AppId).
+		SetHeader("Authorization", fmt.Sprintf("Bearer %s", s.config.Token)).
+		SetBodyJsonMarshal(data).
+		SetSuccessResult(&res).Post(url)
+	if err != nil || r.IsErrorState() {
+		return false
+	}
+
+	if res.Code != types.Success {
+		return false
+	}
+
+	return true
+}
--- a/api/service/fun/func_img.go
+++ b/api/service/fun/func_img.go
@@ -0,0 +1,116 @@
+package fun
+
+import (
+	"chatplus/core/types"
+	"chatplus/service/oss"
+	"chatplus/store/model"
+	"chatplus/utils"
+	"fmt"
+
+	"github.com/imroc/req/v3"
+	"gorm.io/gorm"
+)
+
+// AI 绘画函数
+
+type FuncImage struct {
+	name          string
+	db            *gorm.DB
+	uploadManager *oss.UploaderManager
+	proxyURL      string
+}
+
+func NewImageFunc(db *gorm.DB, manager *oss.UploaderManager, config *types.AppConfig) FuncImage {
+	return FuncImage{
+		db:            db,
+		name:          "DALL-E3 绘画",
+		uploadManager: manager,
+		proxyURL:      config.ProxyURL,
+	}
+}
+
+type imgReq struct {
+	Model  string `json:"model"`
+	Prompt string `json:"prompt"`
+	N      int    `json:"n"`
+	Size   string `json:"size"`
+}
+
+type imgRes struct {
+	Created int64 `json:"created"`
+	Data    []struct {
+		RevisedPrompt string `json:"revised_prompt"`
+		Url           string `json:"url"`
+	} `json:"data"`
+}
+
+type ErrRes struct {
+	Error struct {
+		Code    interface{} `json:"code"`
+		Message string      `json:"message"`
+		Param   interface{} `json:"param"`
+		Type    string      `json:"type"`
+	} `json:"error"`
+}
+
+func (f FuncImage) Invoke(params map[string]interface{}) (string, error) {
+	logger.Infof("绘画参数：%+v", params)
+	prompt := utils.InterfaceToString(params["prompt"])
+	// get image generation API KEY
+	var apiKey model.ApiKey
+	tx := f.db.Where("platform = ? AND type = ?", types.OpenAI, "img").Order("last_used_at ASC").First(&apiKey)
+	if tx.Error != nil {
+		return "", fmt.Errorf("error with get generation API KEY: %v", tx.Error)
+	}
+
+	// get image generation api URL
+	var conf model.Config
+	var chatConfig types.ChatConfig
+	tx = f.db.Where("marker", "chat").First(&conf)
+	if tx.Error != nil {
+		return "", fmt.Errorf("error with get chat configs: %v", tx.Error)
+	}
+
+	err := utils.JsonDecode(conf.Config, &chatConfig)
+	if err != nil {
+		return "", fmt.Errorf("error with decode chat config: %v", err)
+	}
+
+	apiURL := chatConfig.DallApiURL
+	if utils.IsEmptyValue(apiURL) {
+		apiURL = "https://api.openai.com/v1/images/generations"
+	}
+	imgNum := chatConfig.DallImgNum
+	if imgNum <= 0 {
+		imgNum = 1
+	}
+	var res imgRes
+	var errRes ErrRes
+	r, err := req.C().SetProxyURL(f.proxyURL).R().SetHeader("Content-Type", "application/json").
+		SetHeader("Authorization", "Bearer "+apiKey.Value).
+		SetBody(imgReq{
+			Model:  "dall-e-3",
+			Prompt: prompt,
+			N:      imgNum,
+			Size:   "1024x1024",
+		}).
+		SetErrorResult(&errRes).
+		SetSuccessResult(&res).Post(apiURL)
+	if err != nil || r.IsErrorState() {
+		return "", fmt.Errorf("error with http request: %v%v%s", err, r.Err, errRes.Error.Message)
+	}
+	// 存储图片
+	imgURL, err := f.uploadManager.GetUploadHandler().PutImg(res.Data[0].Url, false)
+	if err != nil {
+		return "", fmt.Errorf("下载图片失败: %s", err.Error())
+	}
+
+	logger.Info(imgURL)
+	return fmt.Sprintf("\n\n![](%s)\n", imgURL), nil
+}
+
+func (f FuncImage) Name() string {
+	return f.name
+}
+
+var _ Function = &FuncImage{}
--- a/api/service/fun/function.go
+++ b/api/service/fun/function.go
@@ -0,0 +1,40 @@
+package fun
+
+import (
+	"chatplus/core/types"
+	logger2 "chatplus/logger"
+	"chatplus/service/oss"
+	"gorm.io/gorm"
+)
+
+type Function interface {
+	Invoke(map[string]interface{}) (string, error)
+	Name() string
+}
+
+var logger = logger2.GetLogger()
+
+type resVo struct {
+	Code    types.BizCode `json:"code"`
+	Message string        `json:"message"`
+	Data    struct {
+		Title     string     `json:"title"`
+		UpdatedAt string     `json:"updated_at"`
+		Items     []dataItem `json:"items"`
+	} `json:"data"`
+}
+
+type dataItem struct {
+	Title  string `json:"title"`
+	Url    string `json:"url"`
+	Remark string `json:"remark"`
+}
+
+func NewFunctions(config *types.AppConfig, db *gorm.DB, manager *oss.UploaderManager) map[string]Function {
+	return map[string]Function{
+		types.FuncZaoBao:   NewZaoBao(config.ApiConfig),
+		types.FuncWeibo:    NewWeiboHot(config.ApiConfig),
+		types.FuncHeadLine: NewHeadLines(config.ApiConfig),
+		types.FuncImage:    NewImageFunc(db, manager, config),
+	}
+}
--- a/api/service/fun/tou_tiao.go
+++ b/api/service/fun/tou_tiao.go
@@ -0,0 +1,58 @@
+package fun
+
+import (
+	"chatplus/core/types"
+	"errors"
+	"fmt"
+	"github.com/imroc/req/v3"
+	"strings"
+	"time"
+)
+
+// 今日头条函数实现
+
+type FuncHeadlines struct {
+	name   string
+	config types.ChatPlusApiConfig
+	client *req.Client
+}
+
+func NewHeadLines(config types.ChatPlusApiConfig) FuncHeadlines {
+	return FuncHeadlines{
+		name:   "今日头条",
+		config: config,
+		client: req.C().SetTimeout(10 * time.Second)}
+}
+
+func (f FuncHeadlines) Invoke(map[string]interface{}) (string, error) {
+	if f.config.Token == "" {
+		return "", errors.New("无效的 API Token")
+	}
+
+	url := fmt.Sprintf("%s/api/headline/fetch", f.config.ApiURL)
+	var res resVo
+	r, err := f.client.R().
+		SetHeader("AppId", f.config.AppId).
+		SetHeader("Authorization", fmt.Sprintf("Bearer %s", f.config.Token)).
+		SetSuccessResult(&res).Get(url)
+	if err != nil || r.IsErrorState() {
+		return "", fmt.Errorf("%v%v", err, r.Err)
+	}
+
+	if res.Code != types.Success {
+		return "", errors.New(res.Message)
+	}
+
+	builder := make([]string, 0)
+	builder = append(builder, fmt.Sprintf("**%s**，最新更新：%s", res.Data.Title, res.Data.UpdatedAt))
+	for i, v := range res.Data.Items {
+		builder = append(builder, fmt.Sprintf("%d、 [%s](%s) [%s]", i+1, v.Title, v.Url, v.Remark))
+	}
+	return strings.Join(builder, "\n\n"), nil
+}
+
+func (f FuncHeadlines) Name() string {
+	return f.name
+}
+
+var _ Function = &FuncHeadlines{}
--- a/api/service/fun/weibo_hot.go
+++ b/api/service/fun/weibo_hot.go
@@ -0,0 +1,58 @@
+package fun
+
+import (
+	"chatplus/core/types"
+	"errors"
+	"fmt"
+	"github.com/imroc/req/v3"
+	"strings"
+	"time"
+)
+
+// 微博热搜函数实现
+
+type FuncWeiboHot struct {
+	name   string
+	config types.ChatPlusApiConfig
+	client *req.Client
+}
+
+func NewWeiboHot(config types.ChatPlusApiConfig) FuncWeiboHot {
+	return FuncWeiboHot{
+		name:   "微博热搜",
+		config: config,
+		client: req.C().SetTimeout(10 * time.Second)}
+}
+
+func (f FuncWeiboHot) Invoke(map[string]interface{}) (string, error) {
+	if f.config.Token == "" {
+		return "", errors.New("无效的 API Token")
+	}
+
+	url := fmt.Sprintf("%s/api/weibo/fetch", f.config.ApiURL)
+	var res resVo
+	r, err := f.client.R().
+		SetHeader("AppId", f.config.AppId).
+		SetHeader("Authorization", fmt.Sprintf("Bearer %s", f.config.Token)).
+		SetSuccessResult(&res).Get(url)
+	if err != nil || r.IsErrorState() {
+		return "", fmt.Errorf("%v%v", err, r.Err)
+	}
+
+	if res.Code != types.Success {
+		return "", errors.New(res.Message)
+	}
+
+	builder := make([]string, 0)
+	builder = append(builder, fmt.Sprintf("**%s**，最新更新：%s", res.Data.Title, res.Data.UpdatedAt))
+	for i, v := range res.Data.Items {
+		builder = append(builder, fmt.Sprintf("%d、 [%s](%s) [热度：%s]", i+1, v.Title, v.Url, v.Remark))
+	}
+	return strings.Join(builder, "\n\n"), nil
+}
+
+func (f FuncWeiboHot) Name() string {
+	return f.name
+}
+
+var _ Function = &FuncWeiboHot{}
--- a/api/service/fun/zao_bao.go
+++ b/api/service/fun/zao_bao.go
@@ -0,0 +1,59 @@
+package fun
+
+import (
+	"chatplus/core/types"
+	"errors"
+	"fmt"
+	"github.com/imroc/req/v3"
+	"strings"
+	"time"
+)
+
+// 每日早报函数实现
+
+type FuncZaoBao struct {
+	name   string
+	config types.ChatPlusApiConfig
+	client *req.Client
+}
+
+func NewZaoBao(config types.ChatPlusApiConfig) FuncZaoBao {
+	return FuncZaoBao{
+		name:   "每日早报",
+		config: config,
+		client: req.C().SetTimeout(10 * time.Second)}
+}
+
+func (f FuncZaoBao) Invoke(map[string]interface{}) (string, error) {
+	if f.config.Token == "" {
+		return "", errors.New("无效的 API Token")
+	}
+
+	url := fmt.Sprintf("%s/api/zaobao/fetch", f.config.ApiURL)
+	var res resVo
+	r, err := f.client.R().
+		SetHeader("AppId", f.config.AppId).
+		SetHeader("Authorization", fmt.Sprintf("Bearer %s", f.config.Token)).
+		SetSuccessResult(&res).Get(url)
+	if err != nil || r.IsErrorState() {
+		return "", fmt.Errorf("%v%v", err, r.Err)
+	}
+
+	if res.Code != types.Success {
+		return "", errors.New(res.Message)
+	}
+
+	builder := make([]string, 0)
+	builder = append(builder, fmt.Sprintf("**%s 早报：**", res.Data.UpdatedAt))
+	for _, v := range res.Data.Items {
+		builder = append(builder, v.Title)
+	}
+	builder = append(builder, fmt.Sprintf("%s", res.Data.Title))
+	return strings.Join(builder, "\n\n"), nil
+}
+
+func (f FuncZaoBao) Name() string {
+	return f.name
+}
+
+var _ Function = &FuncZaoBao{}
--- a/api/service/function/zao_bao.go
+++ b/api/service/function/zao_bao.go
@@ -1,51 +0,0 @@
-package function
-
-import (
-	"chatplus/utils"
-	"fmt"
-	"strings"
-)
-
-// 每日早报函数实现
-
-type FuncZaoBao struct {
-	apiURL string
-	token  string
-}
-
-func NewZaoBao(token string) *FuncZaoBao {
-	return &FuncZaoBao{apiURL: "https://v2.alapi.cn/api/zaobao", token: token}
-}
-
-type resVo struct {
-	Code int    `json:"code"`
-	Msg  string `json:"msg"`
-	Data struct {
-		Date  string   `json:"date"`
-		News  []string `json:"news"`
-		WeiYu string   `json:"weiyu"`
-	} `json:"data"`
-}
-
-func (f *FuncZaoBao) Fetch() (string, error) {
-
-	url := fmt.Sprintf("%s?format=json&token=%s", f.apiURL, f.token)
-	bytes, err := utils.HttpGet(url, "")
-	if err != nil {
-		return "", err
-	}
-	var res resVo
-	err = utils.JsonDecode(string(bytes), &res)
-	if err != nil {
-		return "", err
-	}
-
-	if res.Code != 200 {
-		return "", fmt.Errorf("call api fail: %s", res.Msg)
-	}
-	builder := make([]string, 0)
-	builder = append(builder, fmt.Sprintf("**%s 早报：**", res.Data.Date))
-	builder = append(builder, res.Data.News...)
-	builder = append(builder, fmt.Sprintf("%s", res.Data.WeiYu))
-	return strings.Join(builder, "\n\n"), nil
-}
--- a/api/service/mj/bot.go
+++ b/api/service/mj/bot.go
@@ -0,0 +1,215 @@
+package mj
+
+import (
+	"chatplus/core/types"
+	logger2 "chatplus/logger"
+	"chatplus/utils"
+	"github.com/bwmarrin/discordgo"
+	"github.com/gorilla/websocket"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+)
+
+// MidJourney 机器人
+
+var logger = logger2.GetLogger()
+
+type Bot struct {
+	config  *types.MidJourneyConfig
+	bot     *discordgo.Session
+	name    string
+	service *Service
+}
+
+func NewBot(name string, proxy string, config *types.MidJourneyConfig, service *Service) (*Bot, error) {
+	discord, err := discordgo.New("Bot " + config.BotToken)
+	if err != nil {
+		return nil, err
+	}
+
+	if proxy != "" {
+		proxy, _ := url.Parse(proxy)
+		discord.Client = &http.Client{
+			Transport: &http.Transport{
+				Proxy: http.ProxyURL(proxy),
+			},
+		}
+		discord.Dialer = &websocket.Dialer{
+			Proxy: http.ProxyURL(proxy),
+		}
+	}
+
+	return &Bot{
+		config:  config,
+		bot:     discord,
+		name:    name,
+		service: service,
+	}, nil
+}
+
+func (b *Bot) Run() error {
+	b.bot.Identify.Intents = discordgo.IntentsAllWithoutPrivileged | discordgo.IntentsGuildMessages | discordgo.IntentMessageContent
+	b.bot.AddHandler(b.messageCreate)
+	b.bot.AddHandler(b.messageUpdate)
+
+	logger.Infof("Starting MidJourney %s", b.name)
+	err := b.bot.Open()
+	if err != nil {
+		logger.Errorf("Error opening Discord connection for %s, error: %v", b.name, err)
+		return err
+	}
+	logger.Infof("Starting MidJourney %s successfully!", b.name)
+	return nil
+}
+
+type TaskStatus string
+
+const (
+	Start    = TaskStatus("Started")
+	Running  = TaskStatus("Running")
+	Stopped  = TaskStatus("Stopped")
+	Finished = TaskStatus("Finished")
+)
+
+type Image struct {
+	URL      string `json:"url"`
+	ProxyURL string `json:"proxy_url"`
+	Filename string `json:"filename"`
+	Width    int    `json:"width"`
+	Height   int    `json:"height"`
+	Size     int    `json:"size"`
+	Hash     string `json:"hash"`
+}
+
+func (b *Bot) messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
+	// ignore messages for other channels
+	if m.GuildID != b.config.GuildId || m.ChannelID != b.config.ChanelId {
+		return
+	}
+	// ignore messages for self
+	if m.Author.ID == s.State.User.ID {
+		return
+	}
+
+	logger.Debugf("CREATE: %s", utils.JsonEncode(m))
+	var referenceId = ""
+	if m.ReferencedMessage != nil {
+		referenceId = m.ReferencedMessage.ID
+	}
+	if strings.Contains(m.Content, "(Waiting to start)") && !strings.Contains(m.Content, "Rerolling **") {
+		// parse content
+		req := CBReq{
+			MessageId:   m.ID,
+			ReferenceId: referenceId,
+			Prompt:      extractPrompt(m.Content),
+			Content:     m.Content,
+			Progress:    0,
+			Status:      Start}
+		b.service.Notify(req)
+		return
+	}
+
+	b.addAttachment(m.ID, referenceId, m.Content, m.Attachments)
+}
+
+func (b *Bot) messageUpdate(s *discordgo.Session, m *discordgo.MessageUpdate) {
+	// ignore messages for other channels
+	if m.GuildID != b.config.GuildId || m.ChannelID != b.config.ChanelId {
+		return
+	}
+	// ignore messages for self
+	if m.Author.ID == s.State.User.ID {
+		return
+	}
+
+	logger.Debugf("UPDATE: %s", utils.JsonEncode(m))
+
+	var referenceId = ""
+	if m.ReferencedMessage != nil {
+		referenceId = m.ReferencedMessage.ID
+	}
+	if strings.Contains(m.Content, "(Stopped)") {
+		req := CBReq{
+			MessageId:   m.ID,
+			ReferenceId: referenceId,
+			Prompt:      extractPrompt(m.Content),
+			Content:     m.Content,
+			Progress:    extractProgress(m.Content),
+			Status:      Stopped}
+		b.service.Notify(req)
+		return
+	}
+
+	b.addAttachment(m.ID, referenceId, m.Content, m.Attachments)
+
+}
+
+func (b *Bot) addAttachment(messageId string, referenceId string, content string, attachments []*discordgo.MessageAttachment) {
+	progress := extractProgress(content)
+	var status TaskStatus
+	if progress == 100 {
+		status = Finished
+	} else {
+		status = Running
+	}
+	for _, attachment := range attachments {
+		if attachment.Width == 0 || attachment.Height == 0 {
+			continue
+		}
+		image := Image{
+			URL:      attachment.URL,
+			Height:   attachment.Height,
+			ProxyURL: attachment.ProxyURL,
+			Width:    attachment.Width,
+			Size:     attachment.Size,
+			Filename: attachment.Filename,
+			Hash:     extractHashFromFilename(attachment.Filename),
+		}
+		req := CBReq{
+			MessageId:   messageId,
+			ReferenceId: referenceId,
+			Image:       image,
+			Prompt:      extractPrompt(content),
+			Content:     content,
+			Progress:    progress,
+			Status:      status,
+		}
+		b.service.Notify(req)
+		break // only get one image
+	}
+}
+
+// extract prompt from string
+func extractPrompt(input string) string {
+	pattern := `\*\*(.*?)\*\*`
+	re := regexp.MustCompile(pattern)
+	matches := re.FindStringSubmatch(input)
+	if len(matches) > 1 {
+		return strings.TrimSpace(matches[1])
+	}
+	return ""
+}
+
+func extractProgress(input string) int {
+	pattern := `\((\d+)\%\)`
+	re := regexp.MustCompile(pattern)
+	matches := re.FindStringSubmatch(input)
+	if len(matches) > 1 {
+		return utils.IntValue(matches[1], 0)
+	}
+	return 100
+}
+
+func extractHashFromFilename(filename string) string {
+	if !strings.HasSuffix(filename, ".png") {
+		return ""
+	}
+
+	index := strings.LastIndex(filename, "_")
+	if index != -1 {
+		return filename[index+1 : len(filename)-4]
+	}
+	return ""
+}
--- a/api/service/mj/client.go
+++ b/api/service/mj/client.go
@@ -0,0 +1,145 @@
+package mj
+
+import (
+	"chatplus/core/types"
+	"fmt"
+	"github.com/imroc/req/v3"
+	"time"
+)
+
+// MidJourney client
+
+type Client struct {
+	client *req.Client
+	config *types.MidJourneyConfig
+}
+
+func NewClient(config *types.MidJourneyConfig, proxy string) *Client {
+	client := req.C().SetTimeout(10 * time.Second)
+	// set proxy URL
+	if proxy != "" {
+		client.SetProxyURL(proxy)
+	}
+	logger.Info(proxy)
+	return &Client{client: client, config: config}
+}
+
+func (c *Client) Imagine(prompt string) error {
+	interactionsReq := &InteractionsRequest{
+		Type:          2,
+		ApplicationID: ApplicationID,
+		GuildID:       c.config.GuildId,
+		ChannelID:     c.config.ChanelId,
+		SessionID:     SessionID,
+		Data: map[string]any{
+			"version": "1166847114203123795",
+			"id":      "938956540159881230",
+			"name":    "imagine",
+			"type":    "1",
+			"options": []map[string]any{
+				{
+					"type":  3,
+					"name":  "prompt",
+					"value": prompt,
+				},
+			},
+			"application_command": map[string]any{
+				"id":                         "938956540159881230",
+				"application_id":             ApplicationID,
+				"version":                    "1118961510123847772",
+				"default_permission":         true,
+				"default_member_permissions": nil,
+				"type":                       1,
+				"nsfw":                       false,
+				"name":                       "imagine",
+				"description":                "Create images with Midjourney",
+				"dm_permission":              true,
+				"options": []map[string]any{
+					{
+						"type":        3,
+						"name":        "prompt",
+						"description": "The prompt to imagine",
+						"required":    true,
+					},
+				},
+				"attachments": []any{},
+			},
+		},
+	}
+
+	url := "https://discord.com/api/v9/interactions"
+	r, err := c.client.R().SetHeader("Authorization", c.config.UserToken).
+		SetHeader("Content-Type", "application/json").
+		SetBody(interactionsReq).
+		Post(url)
+
+	if err != nil || r.IsErrorState() {
+		return fmt.Errorf("error with http request: %w%v", err, r.Err)
+	}
+
+	return nil
+}
+
+// Upscale 放大指定的图片
+func (c *Client) Upscale(index int, messageId string, hash string) error {
+	flags := 0
+	interactionsReq := &InteractionsRequest{
+		Type:          3,
+		ApplicationID: ApplicationID,
+		GuildID:       c.config.GuildId,
+		ChannelID:     c.config.ChanelId,
+		MessageFlags:  &flags,
+		MessageID:     &messageId,
+		SessionID:     SessionID,
+		Data: map[string]any{
+			"component_type": 2,
+			"custom_id":      fmt.Sprintf("MJ::JOB::upsample::%d::%s", index, hash),
+		},
+		Nonce: fmt.Sprintf("%d", time.Now().UnixNano()),
+	}
+
+	url := "https://discord.com/api/v9/interactions"
+	var res InteractionsResult
+	r, err := c.client.R().SetHeader("Authorization", c.config.UserToken).
+		SetHeader("Content-Type", "application/json").
+		SetBody(interactionsReq).
+		SetErrorResult(&res).
+		Post(url)
+	if err != nil || r.IsErrorState() {
+		return fmt.Errorf("error with http request: %v%v%v", err, r.Err, res.Message)
+	}
+
+	return nil
+}
+
+// Variation  以指定的图片的视角进行变换再创作，注意需要在对应的频道中关闭 Remix 变换，否则 Variation 指令将不会生效
+func (c *Client) Variation(index int, messageId string, hash string) error {
+	flags := 0
+	interactionsReq := &InteractionsRequest{
+		Type:          3,
+		ApplicationID: ApplicationID,
+		GuildID:       c.config.GuildId,
+		ChannelID:     c.config.ChanelId,
+		MessageFlags:  &flags,
+		MessageID:     &messageId,
+		SessionID:     SessionID,
+		Data: map[string]any{
+			"component_type": 2,
+			"custom_id":      fmt.Sprintf("MJ::JOB::variation::%d::%s", index, hash),
+		},
+		Nonce: fmt.Sprintf("%d", time.Now().UnixNano()),
+	}
+
+	url := "https://discord.com/api/v9/interactions"
+	var res InteractionsResult
+	r, err := c.client.R().SetHeader("Authorization", c.config.UserToken).
+		SetHeader("Content-Type", "application/json").
+		SetBody(interactionsReq).
+		SetErrorResult(&res).
+		Post(url)
+	if err != nil || r.IsErrorState() {
+		return fmt.Errorf("error with http request: %v%v%v", err, r.Err, res.Message)
+	}
+
+	return nil
+}
--- a/api/service/mj/pool.go
+++ b/api/service/mj/pool.go
@@ -0,0 +1,66 @@
+package mj
+
+import (
+	"chatplus/core/types"
+	"chatplus/service/oss"
+	"chatplus/store"
+	"fmt"
+	"github.com/go-redis/redis/v8"
+	"gorm.io/gorm"
+)
+
+// ServicePool Mj service pool
+type ServicePool struct {
+	services  []*Service
+	taskQueue *store.RedisQueue
+}
+
+func NewServicePool(db *gorm.DB, redisCli *redis.Client, manager *oss.UploaderManager, appConfig *types.AppConfig) *ServicePool {
+	services := make([]*Service, 0)
+	queue := store.NewRedisQueue("MidJourney_Task_Queue", redisCli)
+	// create mj client and service
+	for k, config := range appConfig.MjConfigs {
+		if config.Enabled == false {
+			continue
+		}
+		// create mj client
+		client := NewClient(&config, appConfig.ProxyURL)
+
+		name := fmt.Sprintf("MjService-%d", k)
+		// create mj service
+		service := NewService(name, queue, 4, 600, db, client, manager, appConfig)
+		botName := fmt.Sprintf("MjBot-%d", k)
+		bot, err := NewBot(botName, appConfig.ProxyURL, &config, service)
+		if err != nil {
+			continue
+		}
+
+		err = bot.Run()
+		if err != nil {
+			continue
+		}
+
+		// run mj service
+		go func() {
+			service.Run()
+		}()
+
+		services = append(services, service)
+	}
+
+	return &ServicePool{
+		taskQueue: queue,
+		services:  services,
+	}
+}
+
+// PushTask push a new mj task in to task queue
+func (p *ServicePool) PushTask(task types.MjTask) {
+	logger.Debugf("add a new MidJourney task to the task list: %+v", task)
+	p.taskQueue.RPush(task)
+}
+
+// HasAvailableService check if it has available mj service in pool
+func (p *ServicePool) HasAvailableService() bool {
+	return len(p.services) > 0
+}
--- a/api/service/mj/service.go
+++ b/api/service/mj/service.go
@@ -0,0 +1,152 @@
+package mj
+
+import (
+	"chatplus/core/types"
+	"chatplus/service/oss"
+	"chatplus/store"
+	"chatplus/store/model"
+	"gorm.io/gorm"
+	"strings"
+	"sync/atomic"
+	"time"
+)
+
+// Service MJ 绘画服务
+type Service struct {
+	name             string  // service name
+	client           *Client // MJ client
+	taskQueue        *store.RedisQueue
+	db               *gorm.DB
+	uploadManager    *oss.UploaderManager
+	proxyURL         string
+	maxHandleTaskNum int32             // max task number current service can handle
+	handledTaskNum   int32             // already handled task number
+	taskStartTimes   map[int]time.Time // task start time, to check if the task is timeout
+	taskTimeout      int64
+}
+
+func NewService(name string, queue *store.RedisQueue, maxTaskNum int32, timeout int64, db *gorm.DB, client *Client, manager *oss.UploaderManager, config *types.AppConfig) *Service {
+	return &Service{
+		name:             name,
+		db:               db,
+		taskQueue:        queue,
+		client:           client,
+		uploadManager:    manager,
+		taskTimeout:      timeout,
+		maxHandleTaskNum: maxTaskNum,
+		proxyURL:         config.ProxyURL,
+		taskStartTimes:   make(map[int]time.Time, 0),
+	}
+}
+
+func (s *Service) Run() {
+	logger.Infof("Starting MidJourney job consumer for %s", s.name)
+	for {
+		s.checkTasks()
+		if !s.canHandleTask() {
+			// current service is full, can not handle more task
+			// waiting for running task finish
+			time.Sleep(time.Second * 3)
+			continue
+		}
+
+		var task types.MjTask
+		err := s.taskQueue.LPop(&task)
+		if err != nil {
+			logger.Errorf("taking task with error: %v", err)
+			continue
+		}
+
+		logger.Infof("%s handle a new MidJourney task: %+v", s.name, task)
+		switch task.Type {
+		case types.TaskImage:
+			err = s.client.Imagine(task.Prompt)
+			break
+		case types.TaskUpscale:
+			err = s.client.Upscale(task.Index, task.MessageId, task.MessageHash)
+
+			break
+		case types.TaskVariation:
+			err = s.client.Variation(task.Index, task.MessageId, task.MessageHash)
+		}
+
+		if err != nil {
+			logger.Error("绘画任务执行失败：", err)
+			// update the task progress
+			s.db.Model(&model.MidJourneyJob{Id: uint(task.Id)}).UpdateColumn("progress", -1)
+			atomic.AddInt32(&s.handledTaskNum, -1)
+			continue
+		}
+
+		// lock the task until the execute timeout
+		s.taskStartTimes[task.Id] = time.Now()
+		atomic.AddInt32(&s.handledTaskNum, 1)
+
+	}
+}
+
+// check if current service instance can handle more task
+func (s *Service) canHandleTask() bool {
+	handledNum := atomic.LoadInt32(&s.handledTaskNum)
+	return handledNum < s.maxHandleTaskNum
+}
+
+// remove the expired tasks
+func (s *Service) checkTasks() {
+	for k, t := range s.taskStartTimes {
+		if time.Now().Unix()-t.Unix() > s.taskTimeout {
+			delete(s.taskStartTimes, k)
+			atomic.AddInt32(&s.handledTaskNum, -1)
+			// delete task from database
+			s.db.Delete(&model.MidJourneyJob{Id: uint(k)}, "progress < 100")
+		}
+	}
+}
+
+func (s *Service) Notify(data CBReq) {
+	// extract the task ID
+	split := strings.Split(data.Prompt, " ")
+	var job model.MidJourneyJob
+	res := s.db.Where("message_id = ?", data.MessageId).First(&job)
+	if res.Error == nil && data.Status == Finished {
+		logger.Warn("重复消息：", data.MessageId)
+		return
+	}
+
+	res = s.db.Where("task_id = ?", split[0]).First(&job)
+	if res.Error != nil {
+		logger.Warn("非法任务：", res.Error)
+		return
+	}
+	job.MessageId = data.MessageId
+	job.ReferenceId = data.ReferenceId
+	job.Progress = data.Progress
+	job.Prompt = data.Prompt
+	job.Hash = data.Image.Hash
+	job.OrgURL = data.Image.URL
+
+	res = s.db.Updates(&job)
+	if res.Error != nil {
+		logger.Error("error with update job: ", res.Error)
+		return
+	}
+
+	// upload image
+	if data.Status == Finished {
+		imgURL, err := s.uploadManager.GetUploadHandler().PutImg(data.Image.URL, true)
+		if err != nil {
+			logger.Error("error with download img: ", err.Error())
+			return
+		}
+		job.ImgURL = imgURL
+		s.db.Updates(&job)
+	}
+
+	if data.Status == Finished {
+		// update user's img calls
+		s.db.Model(&model.User{}).Where("id = ?", job.UserId).UpdateColumn("img_calls", gorm.Expr("img_calls - ?", 1))
+		// release lock task
+		atomic.AddInt32(&s.handledTaskNum, -1)
+	}
+
+}
--- a/api/service/mj/types.go
+++ b/api/service/mj/types.go
@@ -0,0 +1,34 @@
+package mj
+
+const (
+	ApplicationID string = "936929561302675456"
+	SessionID     string = "ea8816d857ba9ae2f74c59ae1a953afe"
+)
+
+type InteractionsRequest struct {
+	Type          int            `json:"type"`
+	ApplicationID string         `json:"application_id"`
+	MessageFlags  *int           `json:"message_flags,omitempty"`
+	MessageID     *string        `json:"message_id,omitempty"`
+	GuildID       string         `json:"guild_id"`
+	ChannelID     string         `json:"channel_id"`
+	SessionID     string         `json:"session_id"`
+	Data          map[string]any `json:"data"`
+	Nonce         string         `json:"nonce,omitempty"`
+}
+
+type InteractionsResult struct {
+	Code    int `json:"code"`
+	Message string
+	Error   map[string]any
+}
+
+type CBReq struct {
+	MessageId   string     `json:"message_id"`
+	ReferenceId string     `json:"reference_id"`
+	Image       Image      `json:"image"`
+	Content     string     `json:"content"`
+	Prompt      string     `json:"prompt"`
+	Status      TaskStatus `json:"status"`
+	Progress    int        `json:"progress"`
+}
--- a/api/service/oss/aliyun_oss.go
+++ b/api/service/oss/aliyun_oss.go
@@ -0,0 +1,102 @@
+package oss
+
+import (
+	"bytes"
+	"chatplus/core/types"
+	"chatplus/utils"
+	"fmt"
+	"github.com/aliyun/aliyun-oss-go-sdk/oss"
+	"github.com/gin-gonic/gin"
+	"net/url"
+	"path/filepath"
+	"time"
+)
+
+type AliYunOss struct {
+	config   *types.AliYunOssConfig
+	bucket   *oss.Bucket
+	proxyURL string
+}
+
+func NewAliYunOss(appConfig *types.AppConfig) (*AliYunOss, error) {
+	config := &appConfig.OSS.AliYun
+	// 创建 OSS 客户端
+	client, err := oss.New(config.Endpoint, config.AccessKey, config.AccessSecret)
+	if err != nil {
+		return nil, err
+	}
+
+	// 获取存储空间
+	bucket, err := client.Bucket(config.Bucket)
+	if err != nil {
+		return nil, err
+	}
+
+	if config.SubDir == "" {
+		config.SubDir = "gpt"
+	}
+
+	return &AliYunOss{
+		config:   config,
+		bucket:   bucket,
+		proxyURL: appConfig.ProxyURL,
+	}, nil
+
+}
+
+func (s AliYunOss) PutFile(ctx *gin.Context, name string) (string, error) {
+	// 解析表单
+	file, err := ctx.FormFile(name)
+	if err != nil {
+		return "", err
+	}
+	// 打开上传文件
+	src, err := file.Open()
+	if err != nil {
+		return "", err
+	}
+	defer src.Close()
+
+	fileExt := filepath.Ext(file.Filename)
+	objectKey := fmt.Sprintf("%s/%d%s", s.config.SubDir, time.Now().UnixMicro(), fileExt)
+	// 上传文件
+	err = s.bucket.PutObject(objectKey, src)
+	if err != nil {
+		return "", err
+	}
+
+	return fmt.Sprintf("%s/%s", s.config.Domain, objectKey), nil
+}
+
+func (s AliYunOss) PutImg(imageURL string, useProxy bool) (string, error) {
+	var imageData []byte
+	var err error
+	if useProxy {
+		imageData, err = utils.DownloadImage(imageURL, s.proxyURL)
+	} else {
+		imageData, err = utils.DownloadImage(imageURL, "")
+	}
+	if err != nil {
+		return "", fmt.Errorf("error with download image: %v", err)
+	}
+	parse, err := url.Parse(imageURL)
+	if err != nil {
+		return "", fmt.Errorf("error with parse image URL: %v", err)
+	}
+	fileExt := filepath.Ext(parse.Path)
+	objectKey := fmt.Sprintf("%s/%d%s", s.config.SubDir, time.Now().UnixMicro(), fileExt)
+	// 上传文件字节数据
+	err = s.bucket.PutObject(objectKey, bytes.NewReader(imageData))
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%s/%s", s.config.Domain, objectKey), nil
+}
+
+func (s AliYunOss) Delete(fileURL string) error {
+	objectName := filepath.Base(fileURL)
+	key := fmt.Sprintf("%s/%s", s.config.SubDir, objectName)
+	return s.bucket.DeleteObject(key)
+}
+
+var _ Uploader = AliYunOss{}
--- a/api/service/oss/localstorage.go
+++ b/api/service/oss/localstorage.go
@@ -0,0 +1,73 @@
+package oss
+
+import (
+	"chatplus/core/types"
+	"chatplus/utils"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type LocalStorage struct {
+	config   *types.LocalStorageConfig
+	proxyURL string
+}
+
+func NewLocalStorage(config *types.AppConfig) LocalStorage {
+	return LocalStorage{
+		config:   &config.OSS.Local,
+		proxyURL: config.ProxyURL,
+	}
+}
+
+func (s LocalStorage) PutFile(ctx *gin.Context, name string) (string, error) {
+	file, err := ctx.FormFile(name)
+	if err != nil {
+		return "", fmt.Errorf("error with get form: %v", err)
+	}
+
+	filePath, err := utils.GenUploadPath(s.config.BasePath, file.Filename)
+	if err != nil {
+		return "", fmt.Errorf("error with generate filename: %s", err.Error())
+	}
+	// 将文件保存到指定路径
+	err = ctx.SaveUploadedFile(file, filePath)
+	if err != nil {
+		return "", fmt.Errorf("error with save upload file: %s", err.Error())
+	}
+
+	return utils.GenUploadUrl(s.config.BasePath, s.config.BaseURL, filePath), nil
+}
+
+func (s LocalStorage) PutImg(imageURL string, useProxy bool) (string, error) {
+	parse, err := url.Parse(imageURL)
+	if err != nil {
+		return "", fmt.Errorf("error with parse image URL: %v", err)
+	}
+	filename := filepath.Base(parse.Path)
+	filePath, err := utils.GenUploadPath(s.config.BasePath, filename)
+	if err != nil {
+		return "", fmt.Errorf("error with generate image dir: %v", err)
+	}
+
+	if useProxy {
+		err = utils.DownloadFile(imageURL, filePath, s.proxyURL)
+	} else {
+		err = utils.DownloadFile(imageURL, filePath, "")
+	}
+	if err != nil {
+		return "", fmt.Errorf("error with download image: %v", err)
+	}
+
+	return utils.GenUploadUrl(s.config.BasePath, s.config.BaseURL, filePath), nil
+}
+
+func (s LocalStorage) Delete(fileURL string) error {
+	filePath := strings.Replace(fileURL, s.config.BaseURL, s.config.BasePath, 1)
+	return os.Remove(filePath)
+}
+
+var _ Uploader = LocalStorage{}
--- a/api/service/oss/minio_oss.go
+++ b/api/service/oss/minio_oss.go
@@ -0,0 +1,98 @@
+package oss
+
+import (
+	"chatplus/core/types"
+	"chatplus/utils"
+	"context"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"github.com/minio/minio-go/v7"
+	"github.com/minio/minio-go/v7/pkg/credentials"
+	"net/url"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+type MiniOss struct {
+	config   *types.MiniOssConfig
+	client   *minio.Client
+	proxyURL string
+}
+
+func NewMiniOss(appConfig *types.AppConfig) (MiniOss, error) {
+	config := &appConfig.OSS.Minio
+	minioClient, err := minio.New(config.Endpoint, &minio.Options{
+		Creds:  credentials.NewStaticV4(config.AccessKey, config.AccessSecret, ""),
+		Secure: config.UseSSL,
+	})
+	if err != nil {
+		return MiniOss{}, err
+	}
+	if config.SubDir == "" {
+		config.SubDir = "gpt"
+	}
+	return MiniOss{config: config, client: minioClient, proxyURL: appConfig.ProxyURL}, nil
+}
+
+func (s MiniOss) PutImg(imageURL string, useProxy bool) (string, error) {
+	var imageData []byte
+	var err error
+	if useProxy {
+		imageData, err = utils.DownloadImage(imageURL, s.proxyURL)
+	} else {
+		imageData, err = utils.DownloadImage(imageURL, "")
+	}
+	if err != nil {
+		return "", fmt.Errorf("error with download image: %v", err)
+	}
+	parse, err := url.Parse(imageURL)
+	if err != nil {
+		return "", fmt.Errorf("error with parse image URL: %v", err)
+	}
+	fileExt := filepath.Ext(parse.Path)
+	filename := fmt.Sprintf("%s/%d%s", s.config.SubDir, time.Now().UnixMicro(), fileExt)
+	info, err := s.client.PutObject(
+		context.Background(),
+		s.config.Bucket,
+		filename,
+		strings.NewReader(string(imageData)),
+		int64(len(imageData)),
+		minio.PutObjectOptions{ContentType: "image/png"})
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%s/%s/%s", s.config.Domain, s.config.Bucket, info.Key), nil
+}
+
+func (s MiniOss) PutFile(ctx *gin.Context, name string) (string, error) {
+	file, err := ctx.FormFile(name)
+	if err != nil {
+		return "", fmt.Errorf("error with get form: %v", err)
+	}
+	// Open the uploaded file
+	fileReader, err := file.Open()
+	if err != nil {
+		return "", fmt.Errorf("error opening file: %v", err)
+	}
+	defer fileReader.Close()
+
+	fileExt := filepath.Ext(file.Filename)
+	filename := fmt.Sprintf("%s/%d%s", s.config.SubDir, time.Now().UnixMicro(), fileExt)
+	info, err := s.client.PutObject(ctx, s.config.Bucket, filename, fileReader, file.Size, minio.PutObjectOptions{
+		ContentType: file.Header.Get("Content-Type"),
+	})
+	if err != nil {
+		return "", fmt.Errorf("error uploading to MinIO: %v", err)
+	}
+
+	return fmt.Sprintf("%s/%s/%s", s.config.Domain, s.config.Bucket, info.Key), nil
+}
+
+func (s MiniOss) Delete(fileURL string) error {
+	objectName := filepath.Base(fileURL)
+	key := fmt.Sprintf("%s/%s", s.config.SubDir, objectName)
+	return s.client.RemoveObject(context.Background(), s.config.Bucket, key, minio.RemoveObjectOptions{})
+}
+
+var _ Uploader = MiniOss{}
--- a/api/service/oss/qiniu_oss.go
+++ b/api/service/oss/qiniu_oss.go
@@ -0,0 +1,112 @@
+package oss
+
+import (
+	"bytes"
+	"chatplus/core/types"
+	"chatplus/utils"
+	"context"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"github.com/qiniu/go-sdk/v7/auth/qbox"
+	"github.com/qiniu/go-sdk/v7/storage"
+	"net/url"
+	"path/filepath"
+	"time"
+)
+
+type QinNiuOss struct {
+	config    *types.QiNiuOssConfig
+	mac       *qbox.Mac
+	putPolicy storage.PutPolicy
+	uploader  *storage.FormUploader
+	manager   *storage.BucketManager
+	proxyURL  string
+}
+
+func NewQiNiuOss(appConfig *types.AppConfig) QinNiuOss {
+	config := &appConfig.OSS.QiNiu
+	// build storage uploader
+	zone, ok := storage.GetRegionByID(storage.RegionID(config.Zone))
+	if !ok {
+		zone = storage.ZoneHuanan
+	}
+	storeConfig := storage.Config{Zone: &zone}
+	formUploader := storage.NewFormUploader(&storeConfig)
+	// generate token
+	mac := qbox.NewMac(config.AccessKey, config.AccessSecret)
+	putPolicy := storage.PutPolicy{
+		Scope: config.Bucket,
+	}
+	if config.SubDir == "" {
+		config.SubDir = "gpt"
+	}
+	return QinNiuOss{
+		config:    config,
+		mac:       mac,
+		putPolicy: putPolicy,
+		uploader:  formUploader,
+		manager:   storage.NewBucketManager(mac, &storeConfig),
+		proxyURL:  appConfig.ProxyURL,
+	}
+}
+
+func (s QinNiuOss) PutFile(ctx *gin.Context, name string) (string, error) {
+	// 解析表单
+	file, err := ctx.FormFile(name)
+	if err != nil {
+		return "", err
+	}
+	// 打开上传文件
+	src, err := file.Open()
+	if err != nil {
+		return "", err
+	}
+	defer src.Close()
+
+	fileExt := filepath.Ext(file.Filename)
+	key := fmt.Sprintf("%s/%d%s", s.config.SubDir, time.Now().UnixMicro(), fileExt)
+	// 上传文件
+	ret := storage.PutRet{}
+	extra := storage.PutExtra{}
+	err = s.uploader.Put(ctx, &ret, s.putPolicy.UploadToken(s.mac), key, src, file.Size, &extra)
+	if err != nil {
+		return "", err
+	}
+
+	return fmt.Sprintf("%s/%s", s.config.Domain, ret.Key), nil
+}
+
+func (s QinNiuOss) PutImg(imageURL string, useProxy bool) (string, error) {
+	var imageData []byte
+	var err error
+	if useProxy {
+		imageData, err = utils.DownloadImage(imageURL, s.proxyURL)
+	} else {
+		imageData, err = utils.DownloadImage(imageURL, "")
+	}
+	if err != nil {
+		return "", fmt.Errorf("error with download image: %v", err)
+	}
+	parse, err := url.Parse(imageURL)
+	if err != nil {
+		return "", fmt.Errorf("error with parse image URL: %v", err)
+	}
+	fileExt := filepath.Ext(parse.Path)
+	key := fmt.Sprintf("%s/%d%s", s.config.SubDir, time.Now().UnixMicro(), fileExt)
+	ret := storage.PutRet{}
+	extra := storage.PutExtra{}
+	// 上传文件字节数据
+	err = s.uploader.Put(context.Background(), &ret, s.putPolicy.UploadToken(s.mac), key, bytes.NewReader(imageData), int64(len(imageData)), &extra)
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%s/%s", s.config.Domain, ret.Key), nil
+}
+
+func (s QinNiuOss) Delete(fileURL string) error {
+	objectName := filepath.Base(fileURL)
+	key := fmt.Sprintf("%s/%s", s.config.SubDir, objectName)
+	return s.manager.Delete(s.config.Bucket, key)
+}
+
+var _ Uploader = QinNiuOss{}
--- a/api/service/oss/uploader.go
+++ b/api/service/oss/uploader.go
@@ -0,0 +1,9 @@
+package oss
+
+import "github.com/gin-gonic/gin"
+
+type Uploader interface {
+	PutFile(ctx *gin.Context, name string) (string, error)
+	PutImg(imageURL string, useProxy bool) (string, error)
+	Delete(fileURL string) error
+}
--- a/api/service/oss/uploader_manager.go
+++ b/api/service/oss/uploader_manager.go
@@ -0,0 +1,51 @@
+package oss
+
+import (
+	"chatplus/core/types"
+	"strings"
+)
+
+type UploaderManager struct {
+	handler Uploader
+}
+
+const Local = "LOCAL"
+const Minio = "MINIO"
+const QiNiu = "QINIU"
+const AliYun = "ALIYUN"
+
+func NewUploaderManager(config *types.AppConfig) (*UploaderManager, error) {
+	active := Local
+	if config.OSS.Active != "" {
+		active = strings.ToUpper(config.OSS.Active)
+	}
+	var handler Uploader
+	switch active {
+	case Local:
+		handler = NewLocalStorage(config)
+		break
+	case Minio:
+		client, err := NewMiniOss(config)
+		if err != nil {
+			return nil, err
+		}
+		handler = client
+		break
+	case QiNiu:
+		handler = NewQiNiuOss(config)
+		break
+	case AliYun:
+		client, err := NewAliYunOss(config)
+		if err != nil {
+			return nil, err
+		}
+		handler = client
+		break
+	}
+
+	return &UploaderManager{handler: handler}, nil
+}
+
+func (m *UploaderManager) GetUploadHandler() Uploader {
+	return m.handler
+}
--- a/api/service/payment/alipay_service.go
+++ b/api/service/payment/alipay_service.go
@@ -0,0 +1,142 @@
+package payment
+
+import (
+	"chatplus/core/types"
+	logger2 "chatplus/logger"
+	"fmt"
+	"github.com/smartwalle/alipay/v3"
+	"log"
+	"net/url"
+	"os"
+)
+
+type AlipayService struct {
+	config *types.AlipayConfig
+	client *alipay.Client
+}
+
+var logger = logger2.GetLogger()
+
+func NewAlipayService(appConfig *types.AppConfig) (*AlipayService, error) {
+	config := appConfig.AlipayConfig
+	if !config.Enabled {
+		logger.Info("Disabled Alipay service")
+		return nil, nil
+	}
+	priKey, err := readKey(config.PrivateKey)
+	if err != nil {
+		return nil, fmt.Errorf("error with read App Private key: %v", err)
+	}
+
+	xClient, err := alipay.New(config.AppId, priKey, !config.SandBox)
+	if err != nil {
+		return nil, fmt.Errorf("error with initialize alipay service: %v", err)
+	}
+
+	if err = xClient.LoadAppCertPublicKeyFromFile(config.PublicKey); err != nil {
+		return nil, fmt.Errorf("error with loading App PublicKey: %v", err)
+	}
+	if err = xClient.LoadAliPayRootCertFromFile(config.RootCert); err != nil {
+		return nil, fmt.Errorf("error with loading alipay RootCert: %v", err)
+	}
+	if err = xClient.LoadAlipayCertPublicKeyFromFile(config.AlipayPublicKey); err != nil {
+		return nil, fmt.Errorf("error with loading Alipay PublicKey: %v", err)
+	}
+
+	return &AlipayService{config: &config, client: xClient}, nil
+}
+
+func (s *AlipayService) PayUrlMobile(outTradeNo string, notifyURL string, returnURL string, Amount string, subject string) (string, error) {
+	var p = alipay.TradeWapPay{}
+	p.NotifyURL = notifyURL
+	p.ReturnURL = returnURL
+	p.Subject = subject
+	p.OutTradeNo = outTradeNo
+	p.TotalAmount = Amount
+	p.ProductCode = "QUICK_WAP_WAY"
+	res, err := s.client.TradeWapPay(p)
+	if err != nil {
+		return "", err
+	}
+
+	return res.String(), err
+}
+
+func (s *AlipayService) PayUrlPc(outTradeNo string, notifyURL string, returnURL string, amount string, subject string) (string, error) {
+	var p = alipay.TradePagePay{}
+	p.NotifyURL = notifyURL
+	p.ReturnURL = returnURL
+	p.Subject = subject
+	p.OutTradeNo = outTradeNo
+	p.TotalAmount = amount
+	p.ProductCode = "FAST_INSTANT_TRADE_PAY"
+	res, err := s.client.TradePagePay(p)
+	if err != nil {
+		return "", nil
+	}
+
+	return res.String(), err
+}
+
+// TradeVerify 交易验证
+func (s *AlipayService) TradeVerify(reqForm url.Values) NotifyVo {
+	err := s.client.VerifySign(reqForm)
+	if err != nil {
+		log.Println("异步通知验证签名发生错误", err)
+		return NotifyVo{
+			Status:  0,
+			Message: "异步通知验证签名发生错误",
+		}
+	}
+
+	return s.TradeQuery(reqForm.Get("out_trade_no"))
+}
+
+func (s *AlipayService) TradeQuery(outTradeNo string) NotifyVo {
+	var p = alipay.TradeQuery{}
+	p.OutTradeNo = outTradeNo
+	rsp, err := s.client.TradeQuery(p)
+	if err != nil {
+		return NotifyVo{
+			Status:  0,
+			Message: "异步查询验证订单信息发生错误" + outTradeNo + err.Error(),
+		}
+	}
+
+	if rsp.IsSuccess() == true && rsp.TradeStatus == "TRADE_SUCCESS" {
+		return NotifyVo{
+			Status:     1,
+			OutTradeNo: rsp.OutTradeNo,
+			TradeNo:    rsp.TradeNo,
+			Amount:     rsp.TotalAmount,
+			Subject:    rsp.Subject,
+			Message:    "OK",
+		}
+	} else {
+		return NotifyVo{
+			Status:  0,
+			Message: "异步查询验证订单信息发生错误" + outTradeNo,
+		}
+	}
+}
+
+func readKey(filename string) (string, error) {
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+type NotifyVo struct {
+	Status     int
+	OutTradeNo string
+	TradeNo    string
+	Amount     string
+	Message    string
+	Subject    string
+}
+
+func (v NotifyVo) Success() bool {
+	return v.Status == 1
+}
--- a/api/service/payment/hupipay_serive.go
+++ b/api/service/payment/hupipay_serive.go
@@ -0,0 +1,72 @@
+package payment
+
+import (
+	"chatplus/core/types"
+	"crypto/md5"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type HuPiPayService struct {
+	appId     string
+	appSecret string
+	host      string
+}
+
+func NewHuPiPay(config *types.AppConfig) *HuPiPayService {
+	return &HuPiPayService{
+		appId:     config.HuPiPayConfig.AppId,
+		appSecret: config.HuPiPayConfig.AppSecret,
+		host:      config.HuPiPayConfig.PayURL,
+	}
+}
+
+// Pay 执行支付请求操作
+func (s *HuPiPayService) Pay(params map[string]string) (string, error) {
+	data := url.Values{}
+	simple := strconv.FormatInt(time.Now().Unix(), 10)
+	params["appid"] = s.appId
+	params["time"] = simple
+	params["nonce_str"] = simple
+	for k, v := range params {
+		data.Add(k, v)
+	}
+	data.Add("hash", s.Sign(params))
+	resp, err := http.PostForm(s.host, data)
+	if err != nil {
+		return "error", err
+	}
+	defer resp.Body.Close()
+	all, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "error", err
+	}
+	return string(all), err
+}
+
+// Sign 签名方法
+func (s *HuPiPayService) Sign(params map[string]string) string {
+	var data string
+	keys := make([]string, 0, 0)
+	params["appid"] = s.appId
+	for key := range params {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	//拼接
+	for _, k := range keys {
+		data = fmt.Sprintf("%s%s=%s&", data, k, params[k])
+	}
+	data = strings.Trim(data, "&")
+	data = fmt.Sprintf("%s%s", data, s.appSecret)
+	m := md5.New()
+	m.Write([]byte(data))
+	sign := fmt.Sprintf("%x", m.Sum(nil))
+	return sign
+}
--- a/api/service/sd/pool.go
+++ b/api/service/sd/pool.go
@@ -0,0 +1,52 @@
+package sd
+
+import (
+	"chatplus/core/types"
+	"chatplus/service/oss"
+	"chatplus/store"
+	"fmt"
+	"github.com/go-redis/redis/v8"
+	"gorm.io/gorm"
+)
+
+type ServicePool struct {
+	services  []*Service
+	taskQueue *store.RedisQueue
+}
+
+func NewServicePool(db *gorm.DB, redisCli *redis.Client, manager *oss.UploaderManager, appConfig *types.AppConfig) *ServicePool {
+	services := make([]*Service, 0)
+	queue := store.NewRedisQueue("StableDiffusion_Task_Queue", redisCli)
+	// create mj client and service
+	for k, config := range appConfig.SdConfigs {
+		if config.Enabled == false {
+			continue
+		}
+
+		// create sd service
+		name := fmt.Sprintf("StableDifffusion Service-%d", k)
+		service := NewService(name, 4, 600, &config, queue, db, manager)
+		// run sd service
+		go func() {
+			service.Run()
+		}()
+
+		services = append(services, service)
+	}
+
+	return &ServicePool{
+		taskQueue: queue,
+		services:  services,
+	}
+}
+
+// PushTask push a new mj task in to task queue
+func (p *ServicePool) PushTask(task types.SdTask) {
+	logger.Debugf("add a new MidJourney task to the task list: %+v", task)
+	p.taskQueue.RPush(task)
+}
+
+// HasAvailableService check if it has available mj service in pool
+func (p *ServicePool) HasAvailableService() bool {
+	return len(p.services) > 0
+}
--- a/api/service/sd/service.go
+++ b/api/service/sd/service.go
@@ -0,0 +1,303 @@
+package sd
+
+import (
+	"chatplus/core/types"
+	"chatplus/service/oss"
+	"chatplus/store"
+	"chatplus/store/model"
+	"chatplus/utils"
+	"encoding/json"
+	"fmt"
+	"github.com/imroc/req/v3"
+	"gorm.io/gorm"
+	"io"
+	"os"
+	"strconv"
+	"sync/atomic"
+	"time"
+)
+
+// SD 绘画服务
+
+type Service struct {
+	httpClient       *req.Client
+	config           *types.StableDiffusionConfig
+	taskQueue        *store.RedisQueue
+	db               *gorm.DB
+	uploadManager    *oss.UploaderManager
+	name             string            // service name
+	maxHandleTaskNum int32             // max task number current service can handle
+	handledTaskNum   int32             // already handled task number
+	taskStartTimes   map[int]time.Time // task start time, to check if the task is timeout
+	taskTimeout      int64
+}
+
+func NewService(name string, maxTaskNum int32, timeout int64, config *types.StableDiffusionConfig, queue *store.RedisQueue, db *gorm.DB, manager *oss.UploaderManager) *Service {
+	return &Service{
+		name:             name,
+		config:           config,
+		httpClient:       req.C(),
+		taskQueue:        queue,
+		db:               db,
+		uploadManager:    manager,
+		taskTimeout:      timeout,
+		maxHandleTaskNum: maxTaskNum,
+		taskStartTimes:   make(map[int]time.Time),
+	}
+}
+
+func (s *Service) Run() {
+	for {
+		s.checkTasks()
+		if !s.canHandleTask() {
+			// current service is full, can not handle more task
+			// waiting for running task finish
+			time.Sleep(time.Second * 3)
+			continue
+		}
+
+		var task types.SdTask
+		err := s.taskQueue.LPop(&task)
+		if err != nil {
+			logger.Errorf("taking task with error: %v", err)
+			continue
+		}
+		logger.Infof("%s handle a new Stable-Diffusion task: %+v", s.name, task)
+		err = s.Txt2Img(task)
+		if err != nil {
+			logger.Error("绘画任务执行失败：", err)
+			// update the task progress
+			s.db.Model(&model.SdJob{Id: uint(task.Id)}).UpdateColumn("progress", -1)
+			// release task num
+			atomic.AddInt32(&s.handledTaskNum, -1)
+			continue
+		}
+
+		// lock the task until the execute timeout
+		s.taskStartTimes[task.Id] = time.Now()
+		atomic.AddInt32(&s.handledTaskNum, 1)
+	}
+}
+
+// check if current service instance can handle more task
+func (s *Service) canHandleTask() bool {
+	handledNum := atomic.LoadInt32(&s.handledTaskNum)
+	return handledNum < s.maxHandleTaskNum
+}
+
+// remove the expired tasks
+func (s *Service) checkTasks() {
+	for k, t := range s.taskStartTimes {
+		if time.Now().Unix()-t.Unix() > s.taskTimeout {
+			delete(s.taskStartTimes, k)
+			atomic.AddInt32(&s.handledTaskNum, -1)
+			// delete task from database
+			s.db.Delete(&model.MidJourneyJob{Id: uint(k)}, "progress < 100")
+		}
+	}
+}
+
+// Txt2Img 文生图 API
+func (s *Service) Txt2Img(task types.SdTask) error {
+	var taskInfo TaskInfo
+	bytes, err := os.ReadFile(s.config.Txt2ImgJsonPath)
+	if err != nil {
+		return fmt.Errorf("error with load text2img json template file: %s", err.Error())
+	}
+
+	err = json.Unmarshal(bytes, &taskInfo)
+	if err != nil {
+		return fmt.Errorf("error with decode json params: %s", err.Error())
+	}
+
+	data := taskInfo.Data
+	params := task.Params
+	data[ParamKeys["task_id"]] = params.TaskId
+	data[ParamKeys["prompt"]] = params.Prompt
+	data[ParamKeys["negative_prompt"]] = params.NegativePrompt
+	data[ParamKeys["steps"]] = params.Steps
+	data[ParamKeys["sampler"]] = params.Sampler
+	// @fix bug: 有些 stable diffusion 没有面部修复功能
+	//data[ParamKeys["face_fix"]] = params.FaceFix
+	data[ParamKeys["cfg_scale"]] = params.CfgScale
+	data[ParamKeys["seed"]] = params.Seed
+	data[ParamKeys["height"]] = params.Height
+	data[ParamKeys["width"]] = params.Width
+	data[ParamKeys["hd_fix"]] = params.HdFix
+	data[ParamKeys["hd_redraw_rate"]] = params.HdRedrawRate
+	data[ParamKeys["hd_scale"]] = params.HdScale
+	data[ParamKeys["hd_scale_alg"]] = params.HdScaleAlg
+	data[ParamKeys["hd_sample_num"]] = params.HdSteps
+
+	taskInfo.SessionId = task.SessionId
+	taskInfo.TaskId = params.TaskId
+	taskInfo.Data = data
+	taskInfo.JobId = task.Id
+	go func() {
+		s.runTask(taskInfo, s.httpClient)
+	}()
+	return nil
+}
+
+// 执行任务
+func (s *Service) runTask(taskInfo TaskInfo, client *req.Client) {
+	body := map[string]any{
+		"data":         taskInfo.Data,
+		"event_data":   taskInfo.EventData,
+		"fn_index":     taskInfo.FnIndex,
+		"session_hash": taskInfo.SessionHash,
+	}
+	var result = make(chan CBReq)
+	go func() {
+		var res struct {
+			Data            []interface{} `json:"data"`
+			IsGenerating    bool          `json:"is_generating"`
+			Duration        float64       `json:"duration"`
+			AverageDuration float64       `json:"average_duration"`
+		}
+		var cbReq = CBReq{TaskId: taskInfo.TaskId, JobId: taskInfo.JobId, SessionId: taskInfo.SessionId}
+		response, err := client.R().SetBody(body).SetSuccessResult(&res).Post(s.config.ApiURL + "/run/predict")
+		if err != nil {
+			cbReq.Message = "error with send request: " + err.Error()
+			cbReq.Success = false
+			result <- cbReq
+			return
+		}
+
+		if response.IsErrorState() {
+			bytes, _ := io.ReadAll(response.Body)
+			cbReq.Message = "error http status code: " + string(bytes)
+			cbReq.Success = false
+			result <- cbReq
+			return
+		}
+
+		var images []struct {
+			Name   string      `json:"name"`
+			Data   interface{} `json:"data"`
+			IsFile bool        `json:"is_file"`
+		}
+		err = utils.ForceCovert(res.Data[0], &images)
+		if err != nil {
+			cbReq.Message = "error with decode image:" + err.Error()
+			cbReq.Success = false
+			result <- cbReq
+			return
+		}
+
+		var info map[string]any
+		err = utils.JsonDecode(utils.InterfaceToString(res.Data[1]), &info)
+		if err != nil {
+			logger.Error(res.Data)
+			cbReq.Message = "error with decode image url:" + err.Error()
+			cbReq.Success = false
+			result <- cbReq
+			return
+		}
+
+		// 获取真实的 seed 值
+		cbReq.ImageName = images[0].Name
+		seed, _ := strconv.ParseInt(utils.InterfaceToString(info["seed"]), 10, 64)
+		cbReq.Seed = seed
+		cbReq.Success = true
+		cbReq.Progress = 100
+		result <- cbReq
+		close(result)
+
+	}()
+
+	for {
+		select {
+		case value := <-result:
+			s.callback(value)
+			return
+		default:
+			var progressReq = map[string]any{
+				"id_task":         taskInfo.TaskId,
+				"id_live_preview": 1,
+			}
+
+			var progressRes struct {
+				Active        bool        `json:"active"`
+				Queued        bool        `json:"queued"`
+				Completed     bool        `json:"completed"`
+				Progress      float64     `json:"progress"`
+				Eta           float64     `json:"eta"`
+				LivePreview   string      `json:"live_preview"`
+				IDLivePreview int         `json:"id_live_preview"`
+				TextInfo      interface{} `json:"textinfo"`
+			}
+			response, err := client.R().SetBody(progressReq).SetSuccessResult(&progressRes).Post(s.config.ApiURL + "/internal/progress")
+			var cbReq = CBReq{TaskId: taskInfo.TaskId, Success: true, JobId: taskInfo.JobId, SessionId: taskInfo.SessionId}
+			if err != nil { // TODO: 这里可以考虑设置失败重试次数
+				logger.Error(err)
+				return
+			}
+
+			if response.IsErrorState() {
+				bytes, _ := io.ReadAll(response.Body)
+				logger.Error(string(bytes))
+				return
+			}
+
+			cbReq.ImageData = progressRes.LivePreview
+			cbReq.Progress = int(progressRes.Progress * 100)
+			s.callback(cbReq)
+			time.Sleep(time.Second)
+		}
+	}
+}
+
+func (s *Service) callback(data CBReq) {
+	// release task num
+	atomic.AddInt32(&s.handledTaskNum, -1)
+	if data.Success { // 任务成功
+		var job model.SdJob
+		res := s.db.Where("id = ?", data.JobId).First(&job)
+		if res.Error != nil {
+			logger.Warn("非法任务：", res.Error)
+			return
+		}
+		// 更新任务进度
+		job.Progress = data.Progress
+		// 更新任务 seed
+		var params types.SdTaskParams
+		err := utils.JsonDecode(job.Params, &params)
+		if err != nil {
+			logger.Error("任务解析失败：", err)
+			return
+		}
+
+		params.Seed = data.Seed
+		if data.ImageName != "" { // 下载图片
+			job.ImgURL = fmt.Sprintf("%s/file=%s", s.config.ApiURL, data.ImageName)
+			if data.Progress == 100 {
+				imageURL, err := s.uploadManager.GetUploadHandler().PutImg(job.ImgURL, false)
+				if err != nil {
+					logger.Error("error with download img: ", err.Error())
+					return
+				}
+				job.ImgURL = imageURL
+			}
+		}
+
+		job.Params = utils.JsonEncode(params)
+		res = s.db.Updates(&job)
+		if res.Error != nil {
+			logger.Error("error with update job: ", res.Error)
+			return
+		}
+
+		logger.Debugf("绘图进度：%d", data.Progress)
+
+		// 扣减绘图次数
+		if data.Progress == 100 {
+			s.db.Model(&model.User{}).Where("id = ? AND img_calls > 0", job.UserId).UpdateColumn("img_calls", gorm.Expr("img_calls - ?", 1))
+		}
+
+	} else { // 任务失败
+		logger.Error("任务执行失败：", data.Message)
+		// update the task progress
+		s.db.Model(&model.SdJob{Id: uint(data.JobId)}).UpdateColumn("progress", -1)
+	}
+}
--- a/api/service/sd/types.go
+++ b/api/service/sd/types.go
@@ -0,0 +1,45 @@
+package sd
+
+import logger2 "chatplus/logger"
+
+var logger = logger2.GetLogger()
+
+type TaskInfo struct {
+	SessionId   string        `json:"session_id"`
+	JobId       int           `json:"job_id"`
+	TaskId      string        `json:"task_id"`
+	Data        []interface{} `json:"data"`
+	EventData   interface{}   `json:"event_data"`
+	FnIndex     int           `json:"fn_index"`
+	SessionHash string        `json:"session_hash"`
+}
+
+type CBReq struct {
+	SessionId string
+	JobId     int
+	TaskId    string
+	ImageName string
+	ImageData string
+	Progress  int
+	Seed      int64
+	Success   bool
+	Message   string
+}
+
+var ParamKeys = map[string]int{
+	"task_id":         0,
+	"prompt":          1,
+	"negative_prompt": 2,
+	"steps":           4,
+	"sampler":         5,
+	"face_fix":        6, // 面部修复
+	"cfg_scale":       8,
+	"seed":            27,
+	"height":          9,
+	"width":           10,
+	"hd_fix":          11,
+	"hd_redraw_rate":  12, //高清修复重绘幅度
+	"hd_scale":        13, // 高清修复放大倍数
+	"hd_scale_alg":    14, // 高清修复放大算法
+	"hd_sample_num":   15, // 高清修复采样次数
+}
--- a/api/service/snowflake.go
+++ b/api/service/snowflake.go
@@ -0,0 +1,59 @@
+package service
+
+import (
+	"fmt"
+	"sync"
+	"time"
+)
+
+// Snowflake 雪花算法实现
+type Snowflake struct {
+	mu            sync.Mutex
+	lastTimestamp int64
+	workerID      int
+	sequence      int
+}
+
+func NewSnowflake() *Snowflake {
+	return &Snowflake{
+		lastTimestamp: -1,
+		workerID:      0, // TODO: 增加 WorkID 参数
+		sequence:      0,
+	}
+}
+
+// Next 生成一个新的唯一ID
+func (s *Snowflake) Next(raw bool) (string, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	timestamp := time.Now().UnixNano() / 1000000 // 转换为毫秒
+	if timestamp < s.lastTimestamp {
+		return "", fmt.Errorf("clock moved backwards. Refusing to generate id for %d milliseconds", s.lastTimestamp-timestamp)
+	}
+
+	if timestamp == s.lastTimestamp {
+		s.sequence = (s.sequence + 1) & 4095
+		if s.sequence == 0 {
+			timestamp = s.waitNextMillis()
+		}
+	} else {
+		s.sequence = 0
+	}
+
+	s.lastTimestamp = timestamp
+	id := (timestamp << 22) | (int64(s.workerID) << 10) | int64(s.sequence)
+	if raw {
+		return fmt.Sprintf("%d", id), nil
+	}
+	now := time.Now()
+	return fmt.Sprintf("%d%02d%02d%d", now.Year(), now.Month(), now.Day(), id), nil
+}
+
+func (s *Snowflake) waitNextMillis() int64 {
+	timestamp := time.Now().UnixNano() / 1000000
+	for timestamp <= s.lastTimestamp {
+		timestamp = time.Now().UnixNano() / 1000000
+	}
+	return timestamp
+}
--- a/api/service/wx/bot.go
+++ b/api/service/wx/bot.go
@@ -0,0 +1,87 @@
+package wx
+
+import (
+	logger2 "chatplus/logger"
+	"chatplus/store/model"
+	"github.com/eatmoreapple/openwechat"
+	"github.com/skip2/go-qrcode"
+	"gorm.io/gorm"
+)
+
+// 微信收款机器人
+var logger = logger2.GetLogger()
+
+type Bot struct {
+	bot   *openwechat.Bot
+	token string
+	db    *gorm.DB
+}
+
+func NewWeChatBot(db *gorm.DB) *Bot {
+	bot := openwechat.DefaultBot(openwechat.Desktop)
+	return &Bot{
+		bot: bot,
+		db:  db,
+	}
+}
+
+func (b *Bot) Run() error {
+	logger.Info("Starting WeChat Bot...")
+
+	// set message handler
+	b.bot.MessageHandler = func(msg *openwechat.Message) {
+		b.messageHandler(msg)
+	}
+	// scan code login callback
+	b.bot.UUIDCallback = b.qrCodeCallBack
+
+	err := b.bot.Login()
+	if err != nil {
+		return err
+	}
+
+	logger.Info("微信登录成功！")
+	return nil
+}
+
+// message handler
+func (b *Bot) messageHandler(msg *openwechat.Message) {
+	sender, err := msg.Sender()
+	if err != nil {
+		return
+	}
+
+	// 只处理微信支付的推送消息
+	if sender.NickName == "微信支付" ||
+		msg.MsgType == openwechat.MsgTypeApp ||
+		msg.AppMsgType == openwechat.AppMsgTypeUrl {
+		// 解析支付金额
+		message, err := parseTransactionMessage(msg.Content)
+		if err == nil {
+			transaction := extractTransaction(message)
+			logger.Infof("解析到收款信息：%+v", transaction)
+			var item model.Reward
+			res := b.db.Where("tx_id = ?", transaction.TransId).First(&item)
+			if res.Error == nil {
+				logger.Error("当前交易 ID 己经存在！")
+				return
+			}
+
+			res = b.db.Create(&model.Reward{
+				TxId:   transaction.TransId,
+				Amount: transaction.Amount,
+				Remark: transaction.Remark,
+				Status: false,
+			})
+			if res.Error != nil {
+				logger.Errorf("交易保存失败: %v", res.Error)
+			}
+		}
+	}
+}
+
+func (b *Bot) qrCodeCallBack(uuid string) {
+	logger.Info("请使用微信扫描下面二维码登录")
+	q, _ := qrcode.New("https://login.weixin.qq.com/l/"+uuid, qrcode.Medium)
+	logger.Info(q.ToString(true))
+}
--- a/api/service/wx/tranaction.go
+++ b/api/service/wx/tranaction.go
@@ -0,0 +1,68 @@
+package wx
+
+import (
+	"encoding/xml"
+	"strconv"
+	"strings"
+)
+
+// Message 转账消息
+type Message struct {
+	XMLName xml.Name `xml:"msg"`
+	AppMsg  struct {
+		Des string `xml:"des"`
+		Url string `xml:"url"`
+	} `xml:"appmsg"`
+}
+
+// Transaction 解析后的交易信息
+type Transaction struct {
+	TransId string  `json:"trans_id"` // 微信转账交易 ID
+	Amount  float64 `json:"amount"`   // 微信转账交易金额
+	Remark  string  `json:"remark"`   // 转账备注
+}
+
+// 解析微信转账消息
+func parseTransactionMessage(xmlData string) (*Message, error) {
+	var msg Message
+	if err := xml.Unmarshal([]byte(xmlData), &msg); err != nil {
+		return nil, err
+	}
+
+	return &msg, nil
+}
+
+// 导出交易信息
+func extractTransaction(message *Message) Transaction {
+	var tx = Transaction{}
+	// 导出交易金额和备注
+	lines := strings.Split(message.AppMsg.Des, "\n")
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if len(line) == 0 {
+			continue
+		}
+		// 解析收款金额
+		prefix := "收款金额￥"
+		if strings.HasPrefix(line, prefix) {
+			if value, err := strconv.ParseFloat(line[len(prefix):], 64); err == nil {
+				tx.Amount = value
+				continue
+			}
+		}
+		// 解析收款备注
+		prefix = "付款方备注"
+		if strings.HasPrefix(line, prefix) {
+			tx.Remark = line[len(prefix):]
+			break
+		}
+	}
+
+	// 解析交易 ID
+	index := strings.Index(message.AppMsg.Url, "trans_id=")
+	if index != -1 {
+		end := strings.LastIndex(message.AppMsg.Url, "&")
+		tx.TransId = strings.TrimSpace(message.AppMsg.Url[index+9 : end])
+	}
+	return tx
+}
--- a/api/service/xxl_job_service.go
+++ b/api/service/xxl_job_service.go
@@ -0,0 +1,145 @@
+package service
+
+import (
+	"chatplus/core/types"
+	logger2 "chatplus/logger"
+	"chatplus/store/model"
+	"chatplus/utils"
+	"context"
+	"fmt"
+	"github.com/xxl-job/xxl-job-executor-go"
+	"gorm.io/gorm"
+	"time"
+)
+
+var logger = logger2.GetLogger()
+
+type XXLJobExecutor struct {
+	executor xxl.Executor
+	db       *gorm.DB
+}
+
+func NewXXLJobExecutor(config *types.AppConfig, db *gorm.DB) *XXLJobExecutor {
+	if !config.XXLConfig.Enabled {
+		logger.Info("XXL-JOB service is disabled")
+		return nil
+	}
+
+	exec := xxl.NewExecutor(
+		xxl.ServerAddr(config.XXLConfig.ServerAddr),
+		xxl.AccessToken(config.XXLConfig.AccessToken),   //请求令牌(默认为空)
+		xxl.ExecutorIp(config.XXLConfig.ExecutorIp),     //可自动获取
+		xxl.ExecutorPort(config.XXLConfig.ExecutorPort), //默认9999（非必填）
+		xxl.RegistryKey(config.XXLConfig.RegistryKey),   //执行器名称
+		xxl.SetLogger(&customLogger{}),                  //自定义日志
+	)
+	exec.Init()
+	return &XXLJobExecutor{executor: exec, db: db}
+}
+
+func (e *XXLJobExecutor) Run() error {
+	e.executor.RegTask("ClearOrders", e.ClearOrders)
+	e.executor.RegTask("ResetVipCalls", e.ResetVipCalls)
+	return e.executor.Run()
+}
+
+// ClearOrders 清理未支付的订单，如果没有抛出异常则表示执行成功
+func (e *XXLJobExecutor) ClearOrders(cxt context.Context, param *xxl.RunReq) (msg string) {
+	logger.Debug("执行清理未支付订单...")
+	var sysConfig model.Config
+	res := e.db.Where("marker", "system").First(&sysConfig)
+	if res.Error != nil {
+		return "error with get system config: " + res.Error.Error()
+	}
+
+	var config types.SystemConfig
+	err := utils.JsonDecode(sysConfig.Config, &config)
+	if err != nil {
+		return "error with decode system config: " + err.Error()
+	}
+
+	if config.OrderPayTimeout == 0 { // 默认未支付订单的生命周期为 30 分钟
+		config.OrderPayTimeout = 1800
+	}
+	timeout := time.Now().Unix() - int64(config.OrderPayTimeout)
+	start := utils.Stamp2str(timeout)
+	// 这里不是用软删除，而是永久删除订单
+	res = e.db.Unscoped().Where("status != ? AND created_at < ?", types.OrderPaidSuccess, start).Delete(&model.Order{})
+	return fmt.Sprintf("Clear order successfully, affect rows: %d", res.RowsAffected)
+}
+
+// ResetVipCalls 清理过期的 VIP 会员
+func (e *XXLJobExecutor) ResetVipCalls(cxt context.Context, param *xxl.RunReq) (msg string) {
+	logger.Info("开始进行月底账号盘点...")
+	var users []model.User
+	res := e.db.Where("vip = ?", 1).Find(&users)
+	if res.Error != nil {
+		return "No vip users found"
+	}
+
+	var sysConfig model.Config
+	res = e.db.Where("marker", "system").First(&sysConfig)
+	if res.Error != nil {
+		return "error with get system config: " + res.Error.Error()
+	}
+
+	var config types.SystemConfig
+	err := utils.JsonDecode(sysConfig.Config, &config)
+	if err != nil {
+		return "error with decode system config: " + err.Error()
+	}
+
+	// 获取本月月初时间
+	currentTime := time.Now()
+	year, month, _ := currentTime.Date()
+	firstOfMonth := time.Date(year, month, 1, 0, 0, 0, 0, currentTime.Location()).Unix()
+	for _, u := range users {
+		// 账号到期，直接清零
+		if u.ExpiredTime <= currentTime.Unix() {
+			logger.Info("账号过期：", u.Mobile)
+			u.Calls = 0
+			u.Vip = false
+		} else {
+			if u.Calls <= 0 {
+				u.Calls = config.VipMonthCalls
+			} else {
+				// 如果该用户当月有充值点卡，则将点卡中未用完的点数结余到下个月
+				var orders []model.Order
+				e.db.Debug().Where("user_id = ? AND pay_time > ?", u.Id, firstOfMonth).Find(&orders)
+				var calls = 0
+				for _, o := range orders {
+					var remark types.OrderRemark
+					err = utils.JsonDecode(o.Remark, &remark)
+					if err != nil {
+						continue
+					}
+					if remark.Days > 0 { // 会员续费
+						continue
+					}
+					calls += remark.Calls
+				}
+				if u.Calls > calls { // 本月套餐没有用完
+					u.Calls = calls + config.VipMonthCalls
+				} else {
+					u.Calls = u.Calls + config.VipMonthCalls
+				}
+				logger.Infof("%s 点卡结余：%d", u.Mobile, calls)
+			}
+		}
+		u.Tokens = 0
+		// update user
+		e.db.Updates(&u)
+	}
+	logger.Info("月底盘点完成！")
+	return "success"
+}
+
+type customLogger struct{}
+
+func (l *customLogger) Info(format string, a ...interface{}) {
+	logger.Debugf(format, a...)
+}
+
+func (l *customLogger) Error(format string, a ...interface{}) {
+	logger.Errorf(format, a...)
+}
--- a/api/static/hello.txt
+++ b/api/static/hello.txt
@@ -1 +0,0 @@
-hello, world!
--- a/api/store/leveldb.go
+++ b/api/store/leveldb.go
@@ -1,96 +0,0 @@
-package store
-
-import (
-	"chatplus/store/vo"
-	"encoding/json"
-	"github.com/syndtr/goleveldb/leveldb"
-	"github.com/syndtr/goleveldb/leveldb/util"
-)
-
-type LevelDB struct {
-	driver *leveldb.DB
-}
-
-func NewLevelDB() (*LevelDB, error) {
-	db, err := leveldb.OpenFile("data/leveldb", nil)
-	if err != nil {
-		return nil, err
-	}
-	return &LevelDB{
-		driver: db,
-	}, nil
-}
-
-func (db *LevelDB) Put(key string, value interface{}) error {
-	bytes, err := json.Marshal(value)
-	if err != nil {
-		return err
-	}
-	return db.driver.Put([]byte(key), bytes, nil)
-}
-
-func (db *LevelDB) Get(key string, value interface{}) error {
-	bytes, err := db.driver.Get([]byte(key), nil)
-	if err != nil {
-		return err
-	}
-
-	return json.Unmarshal(bytes, &value)
-}
-
-func (db *LevelDB) Search(prefix string) []string {
-	var items = make([]string, 0)
-	iter := db.driver.NewIterator(util.BytesPrefix([]byte(prefix)), nil)
-	defer iter.Release()
-
-	for iter.Next() {
-		items = append(items, string(iter.Value()))
-	}
-	return items
-}
-
-func (db *LevelDB) SearchPage(prefix string, page int, pageSize int) *vo.Page {
-	var items = make([]string, 0)
-	iter := db.driver.NewIterator(util.BytesPrefix([]byte(prefix)), nil)
-	defer iter.Release()
-
-	res := &vo.Page{Page: page, PageSize: pageSize}
-	// 计算数据总数和总页数
-	total := 0
-	for iter.Next() {
-		total++
-	}
-	res.TotalPage = (total + pageSize - 1) / pageSize
-	res.Total = int64(total)
-
-	// 计算目标页码的起始和结束位置
-	start := (page - 1) * pageSize
-	if start > total {
-		return nil
-	}
-	end := start + pageSize
-	if end > total {
-		end = total
-	}
-
-	// 跳转到目标页码的起始位置
-	count := 0
-	for iter.Next() {
-		if count >= start {
-			items = append(items, string(iter.Value()))
-		}
-		count++
-	}
-	iter.Release()
-	res.Items = items
-	return res
-}
-
-func (db *LevelDB) Delete(key string) error {
-	return db.driver.Delete([]byte(key), nil)
-}
-
-// Close release resources
-func (db *LevelDB) Close() error {
-	return db.driver.Close()
-}
--- a/api/store/model/api_key.go
+++ b/api/store/model/api_key.go
@@ -3,7 +3,8 @@ package model
 // ApiKey OpenAI API 模型
 type ApiKey struct {
 	BaseModel
-	UserId     uint   //用户ID，系统添加的用户 ID 为 0
+	Platform   string
+	Type       string // 用途 chat => 聊天，img => 绘图
 	Value      string // API Key 的值
 	LastUsedAt int64  // 最后使用时间
 }
--- a/api/store/model/chat_history.go
+++ b/api/store/model/chat_history.go
@@ -1,14 +1,18 @@
 package model

+import "gorm.io/gorm"
+
 type HistoryMessage struct {
 	BaseModel
-	ChatId  string // 会话 ID
-	UserId  uint   // 用户 ID
-	RoleId  uint   // 角色 ID
-	Type    string
-	Icon    string
-	Tokens  int
-	Content string
+	ChatId     string // 会话 ID
+	UserId     uint   // 用户 ID
+	RoleId     uint   // 角色 ID
+	Type       string
+	Icon       string
+	Tokens     int
+	Content    string
+	UseContext bool // 是否可以作为聊天上下文
+	DeletedAt  gorm.DeletedAt
 }

 func (HistoryMessage) TableName() string {
--- a/api/store/model/chat_item.go
+++ b/api/store/model/chat_item.go
@@ -1,10 +1,13 @@
 package model

+import "gorm.io/gorm"
+
 type ChatItem struct {
 	BaseModel
-	ChatId string `gorm:"column:chat_id;unique"` // 会话 ID
-	UserId uint   // 用户 ID
-	RoleId uint   // 角色 ID
-	Model  string // 会话模型
-	Title  string // 会话标题
+	ChatId    string `gorm:"column:chat_id;unique"` // 会话 ID
+	UserId    uint   // 用户 ID
+	RoleId    uint   // 角色 ID
+	ModelId   uint   // 会话模型
+	Title     string // 会话标题
+	DeletedAt gorm.DeletedAt
 }
--- a/api/store/model/chat_model.go
+++ b/api/store/model/chat_model.go
@@ -0,0 +1,12 @@
+package model
+
+type ChatModel struct {
+	BaseModel
+	Platform string
+	Name     string
+	Value    string // API Key 的值
+	SortNum  int
+	Enabled  bool
+	Weight   int  // 对话权重，每次对话扣减多少次对话额度
+	Open     bool // 是否开放模型给所有人使用
+}
--- a/api/store/model/chat_role.go
+++ b/api/store/model/chat_role.go
@@ -8,5 +8,5 @@ type ChatRole struct {
 	HelloMsg string // 打招呼的消息
 	Icon     string // 角色聊天图标
 	Enable   bool   // 是否启用被启用
-	Sort     int    //排序数字
+	SortNum  int    //排序数字
 }
--- a/api/store/model/invite_code.go
+++ b/api/store/model/invite_code.go
@@ -0,0 +1,12 @@
+package model
+
+import "time"
+
+type InviteCode struct {
+	Id        uint `gorm:"primarykey;column:id"`
+	UserId    uint
+	Code      string
+	Hits      int // 点击次数
+	RegNum    int // 注册人数
+	CreatedAt time.Time
+}
--- a/api/store/model/invite_log.go
+++ b/api/store/model/invite_log.go
@@ -0,0 +1,15 @@
+package model
+
+import (
+	"time"
+)
+
+type InviteLog struct {
+	Id         uint `gorm:"primarykey;column:id"`
+	InviterId  uint
+	UserId     uint
+	Username   string
+	InviteCode string
+	Reward     string `gorm:"column:reward_json"` // 邀请奖励
+	CreatedAt  time.Time
+}
--- a/api/store/model/mj_job.go
+++ b/api/store/model/mj_job.go
@@ -0,0 +1,22 @@
+package model
+
+import "time"
+
+type MidJourneyJob struct {
+	Id          uint `gorm:"primarykey;column:id"`
+	Type        string
+	UserId      int
+	TaskId      string
+	MessageId   string
+	ReferenceId string
+	ImgURL      string
+	OrgURL      string // 原图地址
+	Hash        string // message hash
+	Progress    int
+	Prompt      string
+	CreatedAt   time.Time
+}
+
+func (MidJourneyJob) TableName() string {
+	return "chatgpt_mj_jobs"
+}
--- a/api/store/model/order.go
+++ b/api/store/model/order.go
@@ -0,0 +1,22 @@
+package model
+
+import (
+	"chatplus/core/types"
+	"gorm.io/gorm"
+)
+
+// Order 充值订单
+type Order struct {
+	BaseModel
+	UserId    uint
+	ProductId uint
+	Mobile    string
+	OrderNo   string
+	Subject   string
+	Amount    float64
+	Status    types.OrderStatus
+	Remark    string
+	PayTime   int64
+	PayWay    string // 支付方式
+	DeletedAt gorm.DeletedAt
+}
--- a/api/store/model/product.go
+++ b/api/store/model/product.go
@@ -0,0 +1,14 @@
+package model
+
+// Product 充值产品
+type Product struct {
+	BaseModel
+	Name     string
+	Price    float64
+	Discount float64
+	Days     int
+	Calls    int
+	Enabled  bool
+	Sales    int
+	SortNum  int
+}
--- a/api/store/model/reward.go
+++ b/api/store/model/reward.go
@@ -0,0 +1,12 @@
+package model
+
+// 用户打赏
+
+type Reward struct {
+	BaseModel
+	UserId uint    // 用户 ID
+	TxId   string  // 交易ID
+	Amount float64 // 打赏金额
+	Remark string  // 打赏备注
+	Status bool    // 核销状态
+}
--- a/Show More
+++ b/Show More