update changelog

feat: add router for function manager
fix: restore user img_calls quota when image task run failed
2025-11-07 17:53:42 +08:00 · 2023-12-29 11:53:37 +08:00 · 2023-12-29 11:22:26 +08:00 · 2023-12-29 10:41:29 +08:00 · 2023-12-29 10:09:37 +08:00 · 2023-12-29 09:39:52 +08:00
267 changed files with 21443 additions and 4142 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,15 +1,111 @@
 # 更新日志
+## v3.2.3
+* 功能重构：重构函数工具模块，设计成可以后台动态管理函数。支持添加自定义函数实现
+* 功能新增：为充值产品数据表添加 img_calls 字段，支持充值绘图次数
+* Bug修复：修复 [MJ 机器人空指针异常的 Bug](https://github.com/yangjian102621/chatgpt-plus/issues/73) 
+* Bug修复：确保相同 Prompt 的绘图任务的 Upscale 和 Variation 任务调度给相同的频道
+* 功能新增：新增删除绘图任何和图片功能
+* Bug修复：修复虎皮椒支付二维码重复扫码时报错问题
+* 功能优化：自动将 AI 绘画中的中文提示词翻译成英文
+* 功能优化：优化AI绘画的大图压缩算法，新增图片缓存
+* 功能优化：支持为 MJ 绘图 API 增加反代功能，提高图片的加载速度，大大降低绘图任务的失败率
+* Bug修复：修复[Azure Api 更换api-version参数后请求失败的问题](https://github.com/yangjian102621/chatgpt-plus/pull/71)
+* Bug修复：修复科大讯飞 V1.5 API 请求失败的问题
+* Bug修复：绘图失败后，自动恢复用户的剩余绘图次数
+* 功能新增：为移动端新增 SD 绘图功能，分享功能
+
+## v3.2.2
+* 功能重构：重构 MidJourney 和 Stable-Diffusion 绘图模块，支持使用多组配置创建池子提供绘画服务
+* 功能新增：AI绘画页面增加翻译和重写提示词功能
+* 功能优化：OSS上传组件支持在 Bucket 下设置二级目录
+* Bug修复：修复阿里云 OSS 访问路径错误
+* 功能优化：在 AI 绘图页面使用 HTTP 轮询替换 Websocket 
+
+## 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。  
+6. 功能优化：增加阿里云短信服务配置项 `Sign` 和 `CodeTempId` 用来配置自己的短信签名和短信验证码模版 ID。
 7. 功能优化：添加系统配置用来设置自定义的众筹微信收款二维码。
 8. 功能优化：优化绘画页面的弹窗样式和页面布局。

 ## v3.1.3
+
 1. 页面重构：重后 Home 页面，拆分成聊天，MJ绘画，SD 绘画，应用广场等多个功能菜单。
 2. 功能新增：新增 MidJourney 专业绘画页面，开放更高级的 MJ 绘画姿势。
 3. 功能优化：采用队列的方式控制绘画任务并发，简化任务回调通知逻辑，给任务回调加锁。
@@ -18,6 +114,7 @@
 6. Bug修复：修复 JWT token 有效期计算错误的 Bug。

 ## v3.1.2
+
 1. 功能新增：新增七牛云 OSS 实现，目前已支持三种文件上传服务：Local, Minio, QiNiu OSS。
 2. 功能新增：新增桌面版，使用 electron 套壳网页版。
 3. Bug修复：自动去除众筹核销时候转账单号中的空格，防止复制的时候多复制了空格。
@@ -26,17 +123,20 @@
 6. 功能优化：所有路由跳转都使用绝对路径

 ## v3.1.1
+
 紧急修复版本，采用弹窗的方式显示验证码，解决验证码在低分辨率下被掩盖的Bug

 ## v3.1.0(大版本更新)
-1. 功能重构：将聊天模型独立拆分，以便支持多平台模型，目前已经内置支持 OPenAI，Azure 以及 ChatGLM，用户可以在这两个平台的模型中随意切换，体验不同的模型聊天。
+
+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 组件到最新版本。 
+8. 升级 gin, element-plus，redis 组件到最新版本。
 9. Bug修复：修复若干已知的的 Bug

 ## v3.0.7
--- a/README.md
+++ b/README.md
@@ -1,14 +1,22 @@
 # ChatGPT-Plus

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

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

 ## 功能截图

@@ -16,41 +24,49 @@ ChatGLM,讯飞星火，文心一言等多个平台的大语言模型。主要有

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

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

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

-### MidJourney 专业绘画界面(v3.1.3)
+### MidJourney 专业绘画界面

-![ChatGPT-midjourney](/docs/imgs/mj_image.png)
+![mid-journey](/docs/imgs/mj_image.jpg)
+
+### Stable-Diffusion 专业绘画页面
+
+![Stable-Diffusion](/docs/imgs/sd_image.jpg)
+![Stable-Diffusion](/docs/imgs/sd_image_detail.jpg)
+
+### 绘图作品展
+
+![ChatGPT image_list](/docs/imgs/image-list.png)
+
+### AI应用列表
+
+![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 user profle](/docs/imgs/user_profile.png)
-
-### 登录页面
-
-![ChatGPT Login](/docs/imgs/login.png)
-
 ### 管理后台

 ![ChatGPT admin](/docs/imgs/admin_dashboard.png)
-
-![ChatGPT admin](/docs/imgs/admin_config.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. 体验地址

@@ -62,290 +78,36 @@ ChatGLM,讯飞星火，文心一言等多个平台的大语言模型。主要有
 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. 支持会话搜索过滤。
-9. 支持微信支付充值

 ## 项目地址

 * 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
-
-* [x] 整合 Midjourney AI 绘画 API
-* [x] 开发移动端聊天页面
-* [x] 接入微信支付功能
-* [x] 支持 ChatGPT 函数功能，通过函数实现插件
 * [ ] 支持基于知识库的 AI 问答
-* [ ] 开发桌面版应用
-* [ ] 开发手机 App 客户端
+* [ ] 会员邀请注册推广功能
+* [ ] 微信支付功能

-## Docker 快速部署
+## 项目文档

->
-鉴于最新不少网友反馈在部署的时候遇到一些问题，大部分问题都是相同的，所以我这边做了一个视频教程 [五分钟部署自己的 ChatGPT 服务](https://www.bilibili.com/video/BV1H14y1B7Qw/)。
-> 习惯看视频教程的朋友可以去看视频教程，视频的语速比较慢，建议 2 倍速观看。
+**最新的部署视频教程：[https://www.bilibili.com/video/BV1ge411C7uA/](https://www.bilibili.com/video/BV1ge411C7uA/?vd_source=dee8b15703ccfcbd24a60ee9a0fabb73)**

-V3.0.0 版本以后已经支持使用容器部署了，跳过所有的繁琐的环境准备，一条命令就可以轻松部署上线。
+详细的部署和开发文档请参考 [**ChatGPT-Plus 文档**](https://ai.r9it.com/docs/)。

-### 1. 导入数据库
+加微信进入微信讨论群可获取 **一键部署脚本（添加好友时请注明来自Github!!!）。**

-首先我们需要创建一个 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-v3.1.4.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 = "" # 如 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" # 注意：这个是 JWT Token 授权密钥，生产环境请务必更换
-  MaxAge = 86400
-
-[Manager]
-  Username = "admin"
-  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"
-
-[ExtConfig] # MidJourney和微信机器人服务 API 配置，开通此功能需要配合 chatpgt-plus-exts 项目部署
-  ApiURL = "" # 插件扩展 API 地址
-  Token = "" # 这个 token 随便填，只要确保跟 chatgpt-plus-exts 项目的 token 一样就行 
-  
-[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] # MidJourney AI 绘画配置
-  Enabled = false # 是否启动 MidJourney 机器人服务
-  UserToken = "" # 用户授权 Token
-  BotToken = "" # Discord 机器人 Token
-  GuildId = "" # 服务器 ID
-  ChanelId = "" # 频道 ID
-
-[SdConfig]
-  Enabled = false # 是否启动 Stable Diffusion 机器人服务
-  ApiURL = "http://172.22.11.200:7860" # stable-diffusion-webui API 地址
-  ApiKey = "" # 如果开启了授权，这里需要配置授权的 ApiKey
-  Txt2ImgJsonPath = "res/text2img.json" # 文生图的 API 请求报文 json 模板，允许自定义请求json报文，因为不同版本的 API 绘图的参数以及 fn_index 会不同。
-```
-
-> 1. 如果你不知道如何获取 Discord 用户 Token 和 Bot Token
-请查参考 [Midjourney｜如何集成到自己的平台](https://zhuanlan.zhihu.com/p/631079476)。
-> 2. `Txt2ImgJsonPath` 的默认用的是使用最广泛的 [stable-diffusion-webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui) 项目的 API，如果你用的是其他版本，比如秋叶的懒人包部署的，那么请将对应的 text2img 的参数报文复制放在 `res/text2img.json` 文件中即可。
-
-修改 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 地址
-       
-# 静态资源转发
-location /static/ {
-   proxy_pass http://172.22.11.47:5678; # 这里改成后端服务的内网 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 对话。
-
-![add API Key](docs/imgs/apikey_add.png)
-
-最后登录前端聊天页面 [http://localhost:8080/chat](http://localhost:8080/chat)
-你可以注册新用户，也可以使用系统默认有个账号：`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 clean all
-# for linux only
-make clean linux
-```
-
-打包后的可执行文件在 `bin` 目录下。
+![微信名片](docs/imgs/wx.png)

 ## 参与贡献

 个人的力量始终有限，任何形式的贡献都是欢迎的，包括但不限于贡献代码，优化文档，提交 issue 和 PR 等。

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

 ### Commit 类型

@@ -361,6 +123,9 @@ make clean 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
@@ -18,3 +18,4 @@ data
 config.toml
 static/upload 
 storage.json
+certs/alipay/*
--- a/api/Makefile
+++ b/api/Makefile
@@ -1,19 +1,14 @@
 SHELL=/usr/bin/env bash
 NAME := chatgpt-plus
-all: window linux darwin
+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=0 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
@@ -33,10 +33,6 @@ WeChatBot = false
  Sign = ""
  CodeTempId = ""

-[ExtConfig] # MidJourney和微信机器人服务 API 配置，开通此功能需要配合 chatpgt-plus-exts 项目部署
-  ApiURL = "" # 插件扩展 API 地址
-  Token = "" # 这个 token 随便填，只要确保跟 chatgpt-plus-exts 项目的 token 一样就行
-
 [OSS] # OSS 配置，用于存储 MJ 绘画图片
   Active = "local" # 默认使用本地文件存储引擎
   [OSS.Local]
@@ -56,15 +52,47 @@ WeChatBot = false
       Bucket = ""
       Domain = "" # OSS Bucket 所绑定的域名，如 https://img.r9it.com

-[MjConfig]
+[[MjConfigs]]
  Enabled = false
  UserToken = ""
  BotToken = ""
  GuildId = ""
  ChanelId = ""

-[SdConfig]
+[[MjConfigs]]
  Enabled = false
-  ApiURL = "http://172.22.11.200:7860"
+  UserToken = ""
+  BotToken = ""
+  GuildId = ""
+  ChanelId = ""
+
+[[SdConfigs]]
+  Enabled = false
+  ApiURL = ""
  ApiKey = ""
-  Txt2ImgJsonPath = "res/text2img.json"
+  Txt2ImgJsonPath = "res/sd/text2img.json"
+
+[[SdConfigs]]
+  Enabled = false
+  ApiURL = ""
+  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,8 +1,8 @@
 package core

 import (
+	"bytes"
 	"chatplus/core/types"
-	"chatplus/service/fun"
 	"chatplus/store/model"
 	"chatplus/utils"
 	"chatplus/utils/resp"
@@ -11,9 +11,14 @@ import (
 	"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"
@@ -33,10 +38,9 @@ type AppServer struct {
 	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, functions map[string]fun.Function) *AppServer {
+func NewServer(appConfig *types.AppConfig) *AppServer {
 	gin.SetMode(gin.ReleaseMode)
 	gin.DefaultWriter = io.Discard
 	return &AppServer{
@@ -47,7 +51,6 @@ func NewServer(appConfig *types.AppConfig, functions map[string]fun.Function) *A
 		ChatSession:   types.NewLMap[string, *types.ChatSession](),
 		ChatClients:   types.NewLMap[string, *types.WsClient](),
 		ReqCancelFunc: types.NewLMap[string, context.CancelFunc](),
-		Functions:     functions,
 	}
 }

@@ -57,7 +60,9 @@ func (s *AppServer) Init(debug bool, client *redis.Client) {
 		logger.Info("Enabled debug mode")
 	}
 	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)
@@ -139,15 +144,22 @@ func corsMiddleware() 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" ||
-			c.Request.URL.Path == "/api/reward/notify" ||
-			c.Request.URL.Path == "/api/mj/notify" ||
 			c.Request.URL.Path == "/api/chat/history" ||
 			c.Request.URL.Path == "/api/chat/detail" ||
-			c.Request.URL.Path == "/api/mj/proxy" ||
+			c.Request.URL.Path == "/api/role/list" ||
+			c.Request.URL.Path == "/api/mj/jobs" ||
+			c.Request.URL.Path == "/api/mj/client" ||
+			c.Request.URL.Path == "/api/invite/hits" ||
+			c.Request.URL.Path == "/api/sd/jobs" ||
+			c.Request.URL.Path == "/api/upload" ||
+			strings.HasPrefix(c.Request.URL.Path, "/test/") ||
+			strings.HasPrefix(c.Request.URL.Path, "/api/function/") ||
 			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()
@@ -157,9 +169,7 @@ func authorizeMiddleware(s *AppServer, client *redis.Client) gin.HandlerFunc {
 		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" ||
-			c.Request.URL.Path == "/api/mj/client" ||
-			c.Request.URL.Path == "/api/sd/client" {
+		} else if c.Request.URL.Path == "/api/chat/new" {
 			tokenString = c.Query("token")
 		} else {
 			tokenString = c.GetHeader(types.UserAuthHeader)
@@ -207,3 +217,130 @@ func authorizeMiddleware(s *AppServer, client *redis.Client) gin.HandlerFunc {
 		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)
+			}
+
+			// 设置图片缓存有效期为一年 (365天)
+			c.Header("Cache-Control", "max-age=31536000, public")
+			// 直接输出图像数据流
+			c.Data(http.StatusOK, "image/jpeg", buffer.Bytes())
+			c.Abort() // 中断请求
+		}
+		c.Next()
+	}
+}
--- a/api/core/config.go
+++ b/api/core/config.go
@@ -14,13 +14,12 @@ var logger = logger2.GetLogger()

 func NewDefaultConfig() *types.AppConfig {
 	return &types.AppConfig{
-		Listen:        "0.0.0.0:5678",
-		ProxyURL:      "",
-		Manager:       types.Manager{Username: "admin", Password: "admin123"},
-		StaticDir:     "./static",
-		StaticUrl:     "http://localhost/5678/static",
-		Redis:         types.RedisConfig{Host: "localhost", Port: 6379, Password: ""},
-		AesEncryptKey: utils.RandString(24),
+		Listen:    "0.0.0.0:5678",
+		ProxyURL:  "",
+		Manager:   types.Manager{Username: "admin", Password: "admin123"},
+		StaticDir: "./static",
+		StaticUrl: "http://localhost/5678/static",
+		Redis:     types.RedisConfig{Host: "localhost", Port: 6379, Password: ""},
 		Session: types.Session{
 			SecretKey: utils.RandString(64),
 			MaxAge:    86400,
@@ -33,9 +32,8 @@ func NewDefaultConfig() *types.AppConfig {
 				BasePath: "./static/upload",
 			},
 		},
-		MjConfig:  types.MidJourneyConfig{Enabled: false},
-		SdConfig:  types.StableDiffusionConfig{Enabled: false, Txt2ImgJsonPath: "res/text2img.json"},
-		WeChatBot: false,
+		WeChatBot:    false,
+		AlipayConfig: types.AlipayConfig{Enabled: false, SandBox: false},
 	}
 }

--- a/api/core/types/chat.go
+++ b/api/core/types/chat.go
@@ -2,13 +2,14 @@ package types

 // ApiRequest API 请求实体
 type ApiRequest struct {
-	Model       string        `json:"model"`
+	Model       string        `json:"model,omitempty"` // 兼容百度文心一言
 	Temperature float32       `json:"temperature"`
-	MaxTokens   int           `json:"max_tokens"`
+	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"`
+	Tools       []interface{} `json:"tools,omitempty"`
+	ToolChoice  string        `json:"tool_choice,omitempty"`
 }

 type Message struct {
@@ -27,10 +28,10 @@ type ChoiceItem struct {
 }

 type Delta struct {
-	Role         string       `json:"role"`
-	Name         string       `json:"name"`
-	Content      interface{}  `json:"content"`
-	FunctionCall FunctionCall `json:"function_call,omitempty"`
+	Role      string      `json:"role"`
+	Name      string      `json:"name"`
+	Content   interface{} `json:"content"`
+	ToolCalls []ToolCall  `json:"tool_calls,omitempty"`
 }

 // ChatSession 聊天会话对象
@@ -47,6 +48,7 @@ type ChatModel struct {
 	Id       uint     `json:"id"`
 	Platform Platform `json:"platform"`
 	Value    string   `json:"value"`
+	Weight   int      `json:"weight"`
 }

 type ApiError struct {
@@ -67,4 +69,10 @@ var ModelToTokens = map[string]int{
 	"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
@@ -36,6 +36,16 @@ func (wc *WsClient) Send(message []byte) error {
 	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 {
 		return 0, nil, ErrConClosed
--- a/api/core/types/config.go
+++ b/api/core/types/config.go
@@ -5,22 +5,25 @@ import (
 )

 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 连接信息
-	ApiConfig     ChatPlusApiConfig // ChatPlus API authorization configs
-	AesEncryptKey string
-	SmsConfig     AliYunSmsConfig       // AliYun send message service config
-	OSS           OSSConfig             // OSS config
-	MjConfig      MidJourneyConfig      // mj 绘画配置
-	WeChatBot     bool                  // 是否启用微信机器人
-	SdConfig      StableDiffusionConfig // sd 绘画配置
+	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
+	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 {
@@ -30,15 +33,15 @@ type ChatPlusApiConfig struct {
 }

 type MidJourneyConfig struct {
-	Enabled   bool
-	UserToken string
-	BotToken  string
-	GuildId   string // Server ID
-	ChanelId  string // Chanel ID
-}
-
-type WeChatConfig struct {
-	Enabled bool
+	Enabled        bool
+	UserToken      string
+	BotToken       string
+	GuildId        string // Server ID
+	ChanelId       string // Chanel ID
+	UseCDN         bool
+	DiscordAPI     string
+	DiscordCDN     string
+	DiscordGateway string
 }

 type StableDiffusionConfig struct {
@@ -57,6 +60,36 @@ type AliYunSmsConfig struct {
 	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
@@ -79,10 +112,14 @@ type ChatConfig struct {
 	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"`   // 上下文深度
+	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
@@ -90,12 +127,19 @@ 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"`
@@ -104,14 +148,22 @@ type ModelAPIConfig struct {
 }

 type SystemConfig struct {
-	Title           string   `json:"title"`
-	AdminTitle      string   `json:"admin_title"`
-	Models          []string `json:"models"`
-	UserInitCalls   int      `json:"user_init_calls"` // 新用户注册默认总送多少次调用
-	InitImgCalls    int      `json:"init_img_calls"`
-	VipMonthCalls   int      `json:"vip_month_calls"` // 会员每个赠送的调用次数
-	EnabledRegister bool     `json:"enabled_register"`
-	EnabledMsg      bool     `json:"enabled_msg"`  // 启用短信验证码服务
-	EnabledDraw     bool     `json:"enabled_draw"` // 启动 AI 绘画功能
-	RewardImg       string   `json:"reward_img"`   // 众筹收款二维码地址
+	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"`     // VIP 会员每月赠送的对话次数
+	VipMonthImgCalls int      `json:"vip_month_img_calls"` // VIP 会员每月赠送绘图次数
+	EnabledRegister  bool     `json:"enabled_register"`    // 是否启用注册功能，关闭注册功能之后将无法注册
+	EnabledMsg       bool     `json:"enabled_msg"`         // 是否启用短信验证码服务
+	RewardImg        string   `json:"reward_img"`          // 众筹收款二维码地址
+	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"`        // 是否强制必须使用邀请码才能注册
 }
--- a/api/core/types/function.go
+++ b/api/core/types/function.go
@@ -1,8 +1,11 @@
 package types

-type FunctionCall struct {
-	Name      string `json:"name"`
-	Arguments string `json:"arguments"`
+type ToolCall struct {
+	Type     string `json:"type"`
+	Function struct {
+		Name      string `json:"name"`
+		Arguments string `json:"arguments"`
+	} `json:"function"`
 }

 type Function struct {
@@ -21,72 +24,3 @@ type Property struct {
 	Type        string `json:"type"`
 	Description string `json:"description"`
 }
-
-const (
-	FuncZaoBao     = "zao_bao"     // 每日早报
-	FuncHeadLine   = "headline"    // 今日头条
-	FuncWeibo      = "weibo_hot"   // 微博热搜
-	FuncMidJourney = "mid_journey" // MJ 绘画
-)
-
-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:        FuncMidJourney,
-		Description: "AI 绘画工具，使用 MJ MidJourney API 进行 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
@@ -6,7 +6,7 @@ import (
 )

 type MKey interface {
-	string | int
+	string | int | uint
 }
 type MValue interface {
 	*WsClient | *ChatSession | context.CancelFunc | []interface{}
--- a/api/core/types/order.go
+++ b/api/core/types/order.go
@@ -0,0 +1,18 @@
+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"`     // 增加对话次数
+	ImgCalls int     `json:"img_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
@@ -12,6 +12,7 @@ type MiniOssConfig struct {
 	AccessKey    string
 	AccessSecret string
 	Bucket       string
+	SubDir       string
 	UseSSL       bool
 	Domain       string
 }
@@ -21,6 +22,7 @@ type QiNiuOssConfig struct {
 	AccessKey    string
 	AccessSecret string
 	Bucket       string
+	SubDir       string
 	Domain       string
 }

@@ -29,6 +31,7 @@ type AliYunOssConfig struct {
 	AccessKey    string
 	AccessSecret string
 	Bucket       string
+	SubDir       string
 	Domain       string
 }

--- a/api/core/types/task.go
+++ b/api/core/types/task.go
@@ -11,28 +11,16 @@ const (
 	TaskImage     = TaskType("image")
 	TaskUpscale   = TaskType("upscale")
 	TaskVariation = TaskType("variation")
-	TaskTxt2Img   = TaskType("text2img")
-)
-
-// TaskSrc 任务来源
-type TaskSrc string
-
-const (
-	TaskSrcChat = TaskSrc("chat") // 来自聊天页面
-	TaskSrcImg  = TaskSrc("img")  // 专业绘画页面
 )

 // MjTask MidJourney 任务
 type MjTask struct {
 	Id          int      `json:"id"`
+	ChannelId   string   `json:"channel_id"`
 	SessionId   string   `json:"session_id"`
-	Src         TaskSrc  `json:"src"`
 	Type        TaskType `json:"type"`
 	UserId      int      `json:"user_id"`
 	Prompt      string   `json:"prompt,omitempty"`
-	ChatId      string   `json:"chat_id,omitempty"`
-	RoleId      int      `json:"role_id,omitempty"`
-	Icon        string   `json:"icon,omitempty"`
 	Index       int      `json:"index,omitempty"`
 	MessageId   string   `json:"message_id,omitempty"`
 	MessageHash string   `json:"message_hash,omitempty"`
@@ -42,7 +30,6 @@ type MjTask struct {
 type SdTask struct {
 	Id         int          `json:"id"` // job 数据库ID
 	SessionId  string       `json:"session_id"`
-	Src        TaskSrc      `json:"src"`
 	Type       TaskType     `json:"type"`
 	UserId     int          `json:"user_id"`
 	Prompt     string       `json:"prompt,omitempty"`
--- a/api/go.mod
+++ b/api/go.mod
@@ -6,7 +6,6 @@ require (
 	github.com/BurntSushi/toml v1.1.0
 	github.com/aliyun/alibaba-cloud-sdk-go v1.62.405
 	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
@@ -18,12 +17,16 @@ require (
 	github.com/pkoukk/tiktoken-go v0.1.1-0.20230418101013-cae809389480
 	github.com/qiniu/go-sdk/v7 v7.17.1
 	github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
-	github.com/syndtr/goleveldb v1.0.0
+	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/bg5t/mydiscordgo v0.28.1
+
 require (
 	github.com/andybalholm/brotli v1.0.4 // indirect
 	github.com/bytedance/sonic v1.9.1 // indirect
@@ -34,6 +37,7 @@ require (
 	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/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 // indirect
 	github.com/goccy/go-json v0.10.2 // indirect
@@ -49,6 +53,7 @@ require (
 	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.8 // indirect
@@ -59,6 +64,9 @@ require (
 	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.3.0 // indirect
@@ -79,7 +87,6 @@ require (
 	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.14.0 // indirect
-	github.com/golang/snappy v0.0.1 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/leodido/go-urn v1.2.4 // indirect
 	github.com/mattn/go-isatty v0.0.19 // indirect
--- a/api/go.sum
+++ b/api/go.sum
@@ -7,8 +7,8 @@ github.com/aliyun/aliyun-oss-go-sdk v2.2.9+incompatible/go.mod h1:T/Aws4fEfogEE9
 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/bwmarrin/discordgo v0.27.1 h1:ib9AIc/dom1E/fSIulrBwnez0CToJE113ZGt4HoliGY=
-github.com/bwmarrin/discordgo v0.27.1/go.mod h1:NJZpH+1AfhIcyQsPeuBKsUtYrRnjkyu0kIVMCHkZtRY=
+github.com/bg5t/mydiscordgo v0.28.1 h1:mVH0ZWstVdJffCi/EXJAYQDtXwIKAJYVXLmECu1hEK8=
+github.com/bg5t/mydiscordgo v0.28.1/go.mod h1:n3aba73N18k1DzM0t0mGE8rwW3Z+vwTvI8pcsBgxN/8=
 github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM=
 github.com/bytedance/sonic v1.9.1 h1:6iJ6NqdoxCDr6mbY8h18oSO+cShGSMRGCEo7F2h0x8s=
 github.com/bytedance/sonic v1.9.1/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U=
@@ -29,7 +29,6 @@ github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkp
 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.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 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=
@@ -39,6 +38,8 @@ 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.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=
@@ -66,12 +67,8 @@ github.com/golang-jwt/jwt/v5 v5.0.0 h1:1n1XNM9hk7O9mnQoNBGolZvzebBQ7p93ULHRc28XJ
 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.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
 github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
-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/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=
@@ -87,7 +84,6 @@ github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY
 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/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 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=
@@ -133,13 +129,12 @@ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJ
 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/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.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 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.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 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=
@@ -175,6 +170,14 @@ 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=
@@ -187,8 +190,6 @@ github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o
 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/syndtr/goleveldb v1.0.0 h1:fBdIW9lB4Iz0n9khmH8w27SJ3QEJ7+IgjPEwGSZiFdE=
-github.com/syndtr/goleveldb v1.0.0/go.mod h1:ZVVdQEZoIme9iO1Ch2Jdy24qqXrMMOU6lpPAyBWyWuQ=
 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=
@@ -197,6 +198,8 @@ github.com/uber/jaeger-lib v2.4.1+incompatible h1:td4jdvLcExb4cBISKIpHuGoVXh+dVK
 github.com/uber/jaeger-lib v2.4.1+incompatible/go.mod h1:ComeNDZlWwrWnDv8aPp0Ba6+uUTzImX/AauajbLI56U=
 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=
@@ -228,7 +231,6 @@ 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-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 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=
@@ -237,13 +239,11 @@ golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug
 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-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 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-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 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=
@@ -290,15 +290,12 @@ gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 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/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
 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.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,13 +5,10 @@ import (
 	"chatplus/core/types"
 	"chatplus/handler"
 	logger2 "chatplus/logger"
-	"chatplus/store/model"
-	"chatplus/utils"
 	"chatplus/utils/resp"
 	"context"
 	"github.com/go-redis/redis/v8"
 	"github.com/golang-jwt/jwt/v5"
-	"strings"
 	"time"

 	"github.com/gin-gonic/gin"
@@ -82,67 +79,3 @@ func (h *ManagerHandler) Session(c *gin.Context) {
 		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
@@ -27,6 +27,7 @@ func (h *ApiKeyHandler) Save(c *gin.Context) {
 	var data struct {
 		Id       uint   `json:"id"`
 		Platform string `json:"platform"`
+		Type     string `json:"type"`
 		Value    string `json:"value"`
 	}
 	if err := c.ShouldBindJSON(&data); err != nil {
@@ -36,10 +37,11 @@ func (h *ApiKeyHandler) Save(c *gin.Context) {

 	apiKey := model.ApiKey{}
 	if data.Id > 0 {
-		h.db.Find(&apiKey)
+		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, "更新数据库失败！")
--- a/api/handler/admin/chat_model_handler.go
+++ b/api/handler/admin/chat_model_handler.go
@@ -31,7 +31,9 @@ func (h *ChatModelHandler) Save(c *gin.Context) {
 		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 {
@@ -39,7 +41,14 @@ func (h *ChatModelHandler) Save(c *gin.Context) {
 		return
 	}

-	item := model.ChatModel{Platform: data.Platform, Name: data.Name, Value: data.Value, Enabled: data.Enabled}
+	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)
@@ -88,10 +97,11 @@ func (h *ChatModelHandler) List(c *gin.Context) {
 	resp.SUCCESS(c, cms)
 }

-func (h *ChatModelHandler) Enable(c *gin.Context) {
+func (h *ChatModelHandler) Set(c *gin.Context) {
 	var data struct {
-		Id      uint `json:"id"`
-		Enabled bool `json:"enabled"`
+		Id    uint        `json:"id"`
+		Filed string      `json:"filed"`
+		Value interface{} `json:"value"`
 	}

 	if err := c.ShouldBindJSON(&data); err != nil {
@@ -99,7 +109,7 @@ func (h *ChatModelHandler) Enable(c *gin.Context) {
 		return
 	}

-	res := h.db.Model(&model.ChatModel{}).Where("id = ?", data.Id).Update("enabled", data.Enabled)
+	res := h.db.Model(&model.ChatModel{}).Where("id = ?", data.Id).Update(data.Filed, data.Value)
 	if res.Error != nil {
 		resp.ERROR(c, "更新数据库失败！")
 		return
--- a/api/handler/admin/dashboard_handler.go
+++ b/api/handler/admin/dashboard_handler.go
@@ -2,6 +2,7 @@ package admin

 import (
 	"chatplus/core"
+	"chatplus/core/types"
 	"chatplus/handler"
 	"chatplus/store/model"
 	"chatplus/utils/resp"
@@ -22,10 +23,10 @@ func NewDashboardHandler(app *core.AppServer, db *gorm.DB) *DashboardHandler {
 }

 type statsVo struct {
-	Users   int64   `json:"users"`
-	Chats   int64   `json:"chats"`
-	Tokens  int64   `json:"tokens"`
-	Rewards float64 `json:"rewards"`
+	Users  int64   `json:"users"`
+	Chats  int64   `json:"chats"`
+	Tokens int     `json:"tokens"`
+	Income float64 `json:"income"`
 }

 func (h *DashboardHandler) Stats(c *gin.Context) {
@@ -47,17 +48,24 @@ func (h *DashboardHandler) Stats(c *gin.Context) {
 	}

 	// tokens took stats
-	var tokenCount int64
-	res = h.db.Model(&model.HistoryMessage{}).Select("sum(tokens) as total").Where("created_at > ?", zeroTime).Scan(&tokenCount)
-	if res.Error == nil {
-		stats.Tokens = tokenCount
+	var historyMessages []model.HistoryMessage
+	res = h.db.Where("created_at > ?", zeroTime).Find(&historyMessages)
+	for _, item := range historyMessages {
+		stats.Tokens += item.Tokens
 	}

-	// reward revenue
-	var amount float64
-	res = h.db.Model(&model.Reward{}).Select("sum(amount) as total").Where("created_at > ?", zeroTime).Scan(&amount)
-	if res.Error == nil {
-		stats.Rewards = amount
+	// 众筹收入
+	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/function_handler.go
+++ b/api/handler/admin/function_handler.go
@@ -0,0 +1,124 @@
+package admin
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/handler"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+
+	"github.com/golang-jwt/jwt/v5"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type FunctionHandler struct {
+	handler.BaseHandler
+	db *gorm.DB
+}
+
+func NewFunctionHandler(app *core.AppServer, db *gorm.DB) *FunctionHandler {
+	h := FunctionHandler{db: db}
+	h.App = app
+	return &h
+}
+
+func (h *FunctionHandler) Save(c *gin.Context) {
+	var data vo.Function
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	var f = model.Function{
+		Id:          data.Id,
+		Name:        data.Name,
+		Label:       data.Label,
+		Description: data.Description,
+		Parameters:  utils.JsonEncode(data.Parameters),
+		Action:      data.Action,
+		Token:       data.Token,
+		Enabled:     data.Enabled,
+	}
+
+	res := h.db.Save(&f)
+	if res.Error != nil {
+		resp.ERROR(c, "error with save data:"+res.Error.Error())
+		return
+	}
+	data.Id = f.Id
+	resp.SUCCESS(c, data)
+}
+
+func (h *FunctionHandler) 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.Function{}).Where("id = ?", data.Id).Update(data.Filed, data.Value)
+	if res.Error != nil {
+		resp.ERROR(c, "更新数据库失败！")
+		return
+	}
+	resp.SUCCESS(c)
+}
+
+func (h *FunctionHandler) List(c *gin.Context) {
+	var items []model.Function
+	res := h.db.Find(&items)
+	if res.Error != nil {
+		resp.ERROR(c, "No data found")
+		return
+	}
+
+	functions := make([]vo.Function, 0)
+	for _, v := range items {
+		var f vo.Function
+		err := utils.CopyObject(v, &f)
+		if err != nil {
+			continue
+		}
+		functions = append(functions, f)
+	}
+	resp.SUCCESS(c, functions)
+}
+
+func (h *FunctionHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+
+	if id > 0 {
+		res := h.db.Delete(&model.Function{Id: uint(id)})
+		if res.Error != nil {
+			resp.ERROR(c, "更新数据库失败！")
+			return
+		}
+	}
+	resp.SUCCESS(c)
+}
+
+// GenToken generate function api access token
+func (h *FunctionHandler) GenToken(c *gin.Context) {
+	// 创建 token
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
+		"user_id": 0,
+		"expired": 0,
+	})
+	tokenString, err := token.SignedString([]byte(h.App.Config.Session.SecretKey))
+	if err != nil {
+		logger.Error("error with generate token", err)
+		resp.ERROR(c)
+		return
+	}
+
+	resp.SUCCESS(c, tokenString)
+}
--- 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,152 @@
+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"`
+		ImgCalls  int     `json:"img_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,
+		ImgCalls: data.ImgCalls,
+		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/user_handler.go
+++ b/api/handler/admin/user_handler.go
@@ -67,8 +67,10 @@ func (h *UserHandler) Save(c *gin.Context) {
 		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)
@@ -81,12 +83,14 @@ func (h *UserHandler) Save(c *gin.Context) {
 		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,
-			"chat_roles_json": utils.JsonEncode(data.ChatRoles),
-			"expired_time":    utils.Str2stamp(data.ExpiredTime),
+			"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)
@@ -97,6 +101,7 @@ func (h *UserHandler) Save(c *gin.Context) {
 			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{
--- a/api/handler/base_handler.go
+++ b/api/handler/base_handler.go
@@ -49,3 +49,11 @@ func (h *BaseHandler) GetUserKey(c *gin.Context) string {
 	}
 	return fmt.Sprintf("users/%v", userId)
 }
+
+func (h *BaseHandler) GetLoginUserId(c *gin.Context) uint {
+	userId, ok := c.Get(types.LoginUserID)
+	if !ok {
+		return 0
+	}
+	return uint(utils.IntValue(utils.InterfaceToString(userId), 0))
+}
--- a/api/handler/chat_history_handler.go
+++ b/api/handler/chat_history_handler.go
@@ -1,103 +0,0 @@
-package handler
-
-import (
-	"chatplus/core/types"
-	"chatplus/store/model"
-	"chatplus/store/vo"
-	"chatplus/utils"
-	"chatplus/utils/resp"
-	"gorm.io/gorm"
-
-	"github.com/gin-gonic/gin"
-)
-
-// Update 更新会话标题
-func (h *ChatHandler) Update(c *gin.Context) {
-	var data struct {
-		Id    uint   `json:"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)
-	if res.Error != nil {
-		resp.ERROR(c, "Failed to update 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)
-}
-
-// 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)
-}
--- a/api/handler/chat_model_handler.go
+++ b/api/handler/chat_model_handler.go
@@ -24,8 +24,25 @@ func NewChatModelHandler(app *core.AppServer, db *gorm.DB) *ChatModelHandler {
 // List 模型列表
 func (h *ChatModelHandler) List(c *gin.Context) {
 	var items []model.ChatModel
-	var cms = make([]vo.ChatModel, 0)
-	res := h.db.Where("enabled = ?", true).Order("sort_num ASC").Find(&items)
+	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
@@ -34,11 +51,11 @@ func (h *ChatModelHandler) List(c *gin.Context) {
 				cm.Id = item.Id
 				cm.CreatedAt = item.CreatedAt.Unix()
 				cm.UpdatedAt = item.UpdatedAt.Unix()
-				cms = append(cms, cm)
+				chatModels = append(chatModels, cm)
 			} else {
 				logger.Error(err)
 			}
 		}
 	}
-	resp.SUCCESS(c, cms)
+	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,6 +25,7 @@ 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_num ASC").Find(&roles)
 	if res.Error != nil {
@@ -31,13 +33,31 @@ func (h *ChatRoleHandler) List(c *gin.Context) {
 		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
@@ -1,4 +1,4 @@
-package handler
+package chatimpl

 import (
 	"bufio"
@@ -9,14 +9,15 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"gorm.io/gorm"
+	"html/template"
 	"io"
 	"strings"
 	"time"
 	"unicode/utf8"
 )

-// 将消息发送给 Azure API 并获取结果，通过 WebSocket 推送到客户端
+// 微软 Azure 模型消息发送实现
+
 func (h *ChatHandler) sendAzureMessage(
 	chatCtx []interface{},
 	req types.ApiRequest,
@@ -43,7 +44,7 @@ func (h *ChatHandler) sendAzureMessage(
 		}

 		utils.ReplyMessage(ws, ErrorMsg)
-		utils.ReplyMessage(ws, "![](/images/wx.png)")
+		utils.ReplyMessage(ws, ErrImg)
 		return err
 	} else {
 		defer response.Body.Close()
@@ -55,9 +56,6 @@ func (h *ChatHandler) sendAzureMessage(
 		// 循环读取 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()
@@ -67,34 +65,17 @@ func (h *ChatHandler) sendAzureMessage(

 			var responseBody = types.ApiResponse{}
 			err = json.Unmarshal([]byte(line[6:]), &responseBody)
-			if err != nil || len(responseBody.Choices) == 0 { // 数据解析出错
+			if err != nil { // 数据解析出错
 				logger.Error(err, line)
 				utils.ReplyMessage(ws, ErrorMsg)
-				utils.ReplyMessage(ws, "![](/images/wx.png)")
+				utils.ReplyMessage(ws, ErrImg)
 				break
 			}

-			fun := responseBody.Choices[0].Delta.FunctionCall
-			if functionCall && fun.Name == "" {
-				arguments = append(arguments, fun.Arguments)
+			if len(responseBody.Choices) == 0 {
 				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
@@ -120,56 +101,10 @@ func (h *ChatHandler) sendAzureMessage(
 			}
 		}

-		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.FuncMidJourney && userVo.ImgCalls <= 0 {
-				utils.ReplyMessage(ws, "**当前用户剩余绘图次数已用尽，请扫描下面二维码联系管理员！**")
-				utils.ReplyMessage(ws, "![](/images/wx.png)")
-			} else {
-				f := h.App.Functions[functionName]
-				if functionName == types.FuncMidJourney {
-					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.FuncMidJourney {
-						content = fmt.Sprintf("绘画提示词：%s 已推送任务到 MidJourney 机器人，请耐心等待任务执行...", data)
-						h.mjService.ChatClients.Put(session.SessionId, ws)
-						// 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 {
 			// 更新用户的对话次数
-			if userVo.ChatConfig.ApiKeys[session.Model.Platform] == "" {
-				h.db.Model(&model.User{}).Where("id = ?", userVo.Id).UpdateColumn("calls", gorm.Expr("calls - ?", 1))
-			}
+			h.subUserCalls(userVo, session)

 			if message.Role == "" {
 				message.Role = "assistant"
@@ -178,7 +113,7 @@ func (h *ChatHandler) sendAzureMessage(
 			useMsg := types.Message{Role: "user", Content: prompt}

 			// 更新上下文消息，如果是调用函数则不需要更新上下文
-			if h.App.ChatConfig.EnableContext && functionCall == false {
+			if h.App.ChatConfig.EnableContext {
 				chatCtx = append(chatCtx, useMsg)  // 提问消息
 				chatCtx = append(chatCtx, message) // 回复消息
 				h.App.ChatContexts.Put(session.ChatId, chatCtx)
@@ -186,11 +121,6 @@ func (h *ChatHandler) sendAzureMessage(

 			// 追加聊天记录
 			if h.App.ChatConfig.EnableHistory {
-				useContext := true
-				if functionCall {
-					useContext = false
-				}
-
 				// for prompt
 				promptToken, err := utils.CalcTokens(prompt, req.Model)
 				if err != nil {
@@ -202,9 +132,9 @@ func (h *ChatHandler) sendAzureMessage(
 					RoleId:     role.Id,
 					Type:       types.PromptMsg,
 					Icon:       userVo.Avatar,
-					Content:    prompt,
+					Content:    template.HTMLEscapeString(prompt),
 					Tokens:     promptToken,
-					UseContext: useContext,
+					UseContext: true,
 				}
 				historyUserMsg.CreatedAt = promptCreatedAt
 				historyUserMsg.UpdatedAt = promptCreatedAt
@@ -214,15 +144,7 @@ func (h *ChatHandler) sendAzureMessage(
 				}

 				// 计算本次对话消耗的总 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, _ := utils.CalcTokens(message.Content, req.Model)
 				totalTokens += getTotalTokens(req)

 				historyReplyMsg := model.HistoryMessage{
@@ -233,7 +155,7 @@ func (h *ChatHandler) sendAzureMessage(
 					Icon:       role.Icon,
 					Content:    message.Content,
 					Tokens:     totalTokens,
-					UseContext: useContext,
+					UseContext: true,
 				}
 				historyReplyMsg.CreatedAt = replyCreatedAt
 				historyReplyMsg.UpdatedAt = replyCreatedAt
@@ -243,8 +165,7 @@ func (h *ChatHandler) sendAzureMessage(
 				}

 				// 更新用户信息
-				h.db.Model(&model.User{}).Where("id = ?", userVo.Id).
-					UpdateColumn("total_tokens", gorm.Expr("total_tokens + ?", totalTokens))
+				h.incUserTokenFee(userVo.Id, totalTokens)
 			}

 			// 保存当前会话
--- 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
@@ -1,11 +1,11 @@
-package handler
+package chatimpl

 import (
 	"bytes"
 	"chatplus/core"
 	"chatplus/core/types"
-	"chatplus/service/mj"
-	"chatplus/store"
+	"chatplus/handler"
+	logger2 "chatplus/logger"
 	"chatplus/store/model"
 	"chatplus/store/vo"
 	"chatplus/utils"
@@ -25,19 +25,23 @@ import (
 )

 const ErrorMsg = "抱歉，AI 助手开小差了，请稍后再试。"
+const ErrImg = "![](/images/wx.png)"
+
+var logger = logger2.GetLogger()

 type ChatHandler struct {
-	BaseHandler
-	db        *gorm.DB
-	leveldb   *store.LevelDB
-	redis     *redis.Client
-	mjService *mj.Service
+	handler.BaseHandler
+	db    *gorm.DB
+	redis *redis.Client
 }

-func NewChatHandler(app *core.AppServer, db *gorm.DB, levelDB *store.LevelDB, redis *redis.Client, service *mj.Service) *ChatHandler {
-	handler := ChatHandler{db: db, leveldb: levelDB, redis: redis, mjService: service}
-	handler.App = app
-	return &handler
+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
@@ -94,6 +98,7 @@ func (h *ChatHandler) ChatHandle(c *gin.Context) {
 	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
@@ -123,7 +128,11 @@ func (h *ChatHandler) ChatHandle(c *gin.Context) {
 				logger.Error(err)
 				client.Close()
 				h.App.ChatClients.Delete(sessionId)
-				h.App.ReqCancelFunc.Delete(sessionId)
+				cancelFunc := h.App.ReqCancelFunc.Get(sessionId)
+				if cancelFunc != nil {
+					cancelFunc()
+					h.App.ReqCancelFunc.Delete(sessionId)
+				}
 				return
 			}

@@ -168,19 +177,25 @@ func (h *ChatHandler) sendMessage(ctx context.Context, session *types.ChatSessio

 	if userVo.Status == false {
 		utils.ReplyMessage(ws, "您的账号已经被禁用，如果疑问，请联系管理员！")
-		utils.ReplyMessage(ws, "![](/images/wx.png)")
+		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, "您的对话次数已经用尽，请联系管理员或者点击左下角菜单加入众筹获得100次对话！")
-		utils.ReplyMessage(ws, "![](/images/wx.png)")
+		utils.ReplyMessage(ws, "您的对话次数已经用尽，请联系管理员或者充值点卡继续对话！")
+		utils.ReplyMessage(ws, ErrImg)
 		return nil
 	}

 	if userVo.ExpiredTime > 0 && userVo.ExpiredTime <= time.Now().Unix() {
 		utils.ReplyMessage(ws, "您的账号已经过期，请联系管理员！")
-		utils.ReplyMessage(ws, "![](/images/wx.png)")
+		utils.ReplyMessage(ws, ErrImg)
 		return nil
 	}
 	var req = types.ApiRequest{
@@ -196,17 +211,52 @@ func (h *ChatHandler) sendMessage(ctx context.Context, session *types.ChatSessio
 		req.Temperature = h.App.ChatConfig.ChatGML.Temperature
 		req.MaxTokens = h.App.ChatConfig.ChatGML.MaxTokens
 		break
-	default:
+	case types.Baidu:
+		req.Temperature = h.App.ChatConfig.OpenAI.Temperature
+		// TODO： 目前只支持 ERNIE-Bot-turbo 模型，如果是 ERNIE-Bot 模型则需要增加函数支持
+		break
+	case types.OpenAI:
 		req.Temperature = h.App.ChatConfig.OpenAI.Temperature
 		req.MaxTokens = h.App.ChatConfig.OpenAI.MaxTokens
-		var functions = make([]types.Function, 0)
-		for _, f := range types.InnerFunctions {
-			if !h.App.SysConfig.EnabledDraw && f.Name == types.FuncMidJourney {
+		// OpenAI 支持函数功能
+		var items []model.Function
+		res := h.db.Where("enabled", true).Find(&items)
+		if res.Error != nil {
+			break
+		}
+
+		var tools = make([]interface{}, 0)
+		for _, v := range items {
+			var parameters map[string]interface{}
+			err = utils.JsonDecode(v.Parameters, &parameters)
+			if err != nil {
 				continue
 			}
-			functions = append(functions, f)
+			required := parameters["required"]
+			delete(parameters, "required")
+			tools = append(tools, gin.H{
+				"type": "function",
+				"function": gin.H{
+					"name":        v.Name,
+					"description": v.Description,
+					"parameters":  parameters,
+					"required":    required,
+				},
+			})
 		}
-		req.Functions = functions
+
+		if len(tools) > 0 {
+			req.Tools = tools
+			req.ToolChoice = "auto"
+		}
+	case types.XunFei:
+		req.Temperature = h.App.ChatConfig.XunFei.Temperature
+		req.MaxTokens = h.App.ChatConfig.XunFei.MaxTokens
+		break
+	default:
+		utils.ReplyMessage(ws, "不支持的平台："+session.Model.Platform+"，请联系管理员！")
+		utils.ReplyMessage(ws, ErrImg)
+		return nil
 	}

 	// 加载聊天上下文
@@ -217,11 +267,8 @@ func (h *ChatHandler) sendMessage(ctx context.Context, session *types.ChatSessio
 		} 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
-			}
-
+			tks, _ := utils.CalcTokens(utils.JsonEncode(req.Tools), req.Model)
+			tokens += tks
 			// loading the role context
 			var messages []types.Message
 			err := utils.JsonDecode(role.Context, &messages)
@@ -239,9 +286,10 @@ func (h *ChatHandler) sendMessage(ctx context.Context, session *types.ChatSessio
 			// loading recent chat history as chat context
 			if chatConfig.ContextDeep > 0 {
 				var historyMessages []model.HistoryMessage
-				res := h.db.Where("chat_id = ? and use_context = 1", session.ChatId).Limit(chatConfig.ContextDeep).Order("created_at desc").Find(&historyMessages)
+				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 _, msg := range historyMessages {
+					for i := len(historyMessages) - 1; i >= 0; i-- {
+						msg := historyMessages[i]
 						if tokens+msg.Tokens >= types.ModelToTokens[session.Model.Value] {
 							break
 						}
@@ -274,6 +322,11 @@ func (h *ChatHandler) sendMessage(ctx context.Context, session *types.ChatSessio
 		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,
@@ -357,12 +410,36 @@ func (h *ChatHandler) doRequest(ctx context.Context, req types.ApiRequest, platf
 		break
 	case types.ChatGLM:
 		apiURL = strings.Replace(h.App.ChatConfig.ChatGML.ApiURL, "{model}", req.Model, 1)
-		req.Prompt = req.Messages
+		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)
@@ -387,18 +464,7 @@ func (h *ChatHandler) doRequest(ctx context.Context, req types.ApiRequest, platf
 	} else {
 		client = http.DefaultClient
 	}
-	if *apiKey == "" {
-		var key model.ApiKey
-		res := h.db.Where("platform = ?", platform).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
-	}
-
-	logger.Infof("Sending %s request, KEY: %s, PROXY: %s, Model: %s", platform, *apiKey, proxyURL, req.Model)
+	logger.Infof("Sending %s request, ApiURL:%s, PROXY: %s, Model: %s", platform, apiURL, proxyURL, req.Model)
 	switch platform {
 	case types.Azure:
 		request.Header.Set("api-key", *apiKey)
@@ -408,11 +474,31 @@ func (h *ChatHandler) doRequest(ctx context.Context, req types.ApiRequest, platf
 		if err != nil {
 			return nil, err
 		}
-		logger.Info(token)
 		request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))
 		break
-	default:
+	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"
@@ -7,6 +7,7 @@ import (
 	"chatplus/utils"
 	"chatplus/utils/resp"
 	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
 )

 // List 获取会话列表
@@ -47,6 +48,95 @@ func (h *ChatHandler) List(c *gin.Context) {
 	resp.SUCCESS(c, items)
 }

+// Update 更新会话标题
+func (h *ChatHandler) Update(c *gin.Context) {
+	var data struct {
+		ChatId string `json:"chat_id"`
+		Title  string `json:"title"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	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
+	}
+
+	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")
@@ -80,6 +170,7 @@ func (h *ChatHandler) Remove(c *gin.Context) {
 	resp.SUCCESS(c, types.OkMsg)
 }

+// Detail 对话详情，用户导出对话
 func (h *ChatHandler) Detail(c *gin.Context) {
 	chatId := h.GetTrim(c, "chat_id")
 	if utils.IsEmptyValue(chatId) {
--- a/api/handler/chatimpl/chatglm_handler.go
+++ b/api/handler/chatimpl/chatglm_handler.go
@@ -1,4 +1,4 @@
-package handler
+package chatimpl

 import (
 	"bufio"
@@ -10,14 +10,15 @@ import (
 	"encoding/json"
 	"fmt"
 	"github.com/golang-jwt/jwt/v5"
-	"gorm.io/gorm"
+	"html/template"
 	"io"
 	"strings"
 	"time"
 	"unicode/utf8"
 )

-// 将消息发送给 ChatGLM API 并获取结果，通过 WebSocket 推送到客户端
+// 清华大学 ChatGML 消息发送实现
+
 func (h *ChatHandler) sendChatGLMMessage(
 	chatCtx []interface{},
 	req types.ApiRequest,
@@ -44,7 +45,7 @@ func (h *ChatHandler) sendChatGLMMessage(
 		}

 		utils.ReplyMessage(ws, ErrorMsg)
-		utils.ReplyMessage(ws, "![](/images/wx.png)")
+		utils.ReplyMessage(ws, ErrImg)
 		return err
 	} else {
 		defer response.Body.Close()
@@ -71,6 +72,10 @@ func (h *ChatHandler) sendChatGLMMessage(
 			if strings.HasPrefix(line, "data:") {
 				content = line[5:]
 			}
+			// 处理代码换行
+			if len(content) == 0 {
+				content = "\n"
+			}
 			switch event {
 			case "add":
 				if len(contents) == 0 {
@@ -103,9 +108,7 @@ func (h *ChatHandler) sendChatGLMMessage(
 		// 消息发送成功
 		if len(contents) > 0 {
 			// 更新用户的对话次数
-			if userVo.ChatConfig.ApiKeys[session.Model.Platform] == "" {
-				h.db.Model(&model.User{}).Where("id = ?", userVo.Id).UpdateColumn("calls", gorm.Expr("calls - ?", 1))
-			}
+			h.subUserCalls(userVo, session)

 			if message.Role == "" {
 				message.Role = "assistant"
@@ -133,7 +136,7 @@ func (h *ChatHandler) sendChatGLMMessage(
 					RoleId:     role.Id,
 					Type:       types.PromptMsg,
 					Icon:       userVo.Avatar,
-					Content:    prompt,
+					Content:    template.HTMLEscapeString(prompt),
 					Tokens:     promptToken,
 					UseContext: true,
 				}
@@ -165,8 +168,7 @@ func (h *ChatHandler) sendChatGLMMessage(
 					logger.Error("failed to save reply history message: ", res.Error)
 				}
 				// 更新用户信息
-				h.db.Model(&model.User{}).Where("id = ?", userVo.Id).
-					UpdateColumn("total_tokens", gorm.Expr("total_tokens + ?", totalTokens))
+				h.incUserTokenFee(userVo.Id, totalTokens)
 			}

 			// 保存当前会话
--- a/api/handler/chatimpl/openai_handler.go
+++ b/api/handler/chatimpl/openai_handler.go
@@ -1,4 +1,4 @@
-package handler
+package chatimpl

 import (
 	"bufio"
@@ -9,14 +9,15 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"gorm.io/gorm"
+	req2 "github.com/imroc/req/v3"
+	"html/template"
 	"io"
 	"strings"
 	"time"
 	"unicode/utf8"
 )

-// 将消息发送给 OpenAI API 并获取结果，通过 WebSocket 推送到客户端
+// OPenAI 消息发送实现
 func (h *ChatHandler) sendOpenAiMessage(
 	chatCtx []interface{},
 	req types.ApiRequest,
@@ -43,7 +44,7 @@ func (h *ChatHandler) sendOpenAiMessage(
 		}

 		utils.ReplyMessage(ws, ErrorMsg)
-		utils.ReplyMessage(ws, "![](/images/wx.png)")
+		utils.ReplyMessage(ws, ErrImg)
 		return err
 	} else {
 		defer response.Body.Close()
@@ -55,8 +56,8 @@ func (h *ChatHandler) sendOpenAiMessage(
 		// 循环读取 Chunk 消息
 		var message = types.Message{}
 		var contents = make([]string, 0)
-		var functionCall = false
-		var functionName string
+		var function model.Function
+		var toolCall = false
 		var arguments = make([]string, 0)
 		scanner := bufio.NewScanner(response.Body)
 		for scanner.Scan() {
@@ -70,28 +71,30 @@ func (h *ChatHandler) sendOpenAiMessage(
 			if err != nil || len(responseBody.Choices) == 0 { // 数据解析出错
 				logger.Error(err, line)
 				utils.ReplyMessage(ws, ErrorMsg)
-				utils.ReplyMessage(ws, "![](/images/wx.png)")
+				utils.ReplyMessage(ws, ErrImg)
 				break
 			}

-			fun := responseBody.Choices[0].Delta.FunctionCall
-			if functionCall && fun.Name == "" {
-				arguments = append(arguments, fun.Arguments)
-				continue
+			var fun types.ToolCall
+			if len(responseBody.Choices[0].Delta.ToolCalls) > 0 {
+				fun = responseBody.Choices[0].Delta.ToolCalls[0]
+				if toolCall && fun.Function.Name == "" {
+					arguments = append(arguments, fun.Function.Arguments)
+					continue
+				}
 			}

 			if !utils.IsEmptyValue(fun) {
-				functionName = fun.Name
-				f := h.App.Functions[functionName]
-				if f != nil {
-					functionCall = true
+				res := h.db.Where("name = ?", fun.Function.Name).First(&function)
+				if res.Error == nil {
+					toolCall = 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())})
+					utils.ReplyChunkMessage(ws, types.WsMessage{Type: types.WsMiddle, Content: fmt.Sprintf("正在调用工具 `%s` 作答 ...\n\n", function.Label)})
 				}
 				continue
 			}

-			if responseBody.Choices[0].FinishReason == "function_call" { // 函数调用完毕
+			if responseBody.Choices[0].FinishReason == "tool_calls" { // 函数调用完毕
 				break
 			}

@@ -120,56 +123,42 @@ func (h *ChatHandler) sendOpenAiMessage(
 			}
 		}

-		if functionCall { // 调用函数完成任务
+		if toolCall { // 调用函数完成任务
 			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.FuncMidJourney && userVo.ImgCalls <= 0 {
-				utils.ReplyMessage(ws, "**当前用户剩余绘图次数已用尽，请扫描下面二维码联系管理员！**")
-				utils.ReplyMessage(ws, "![](/images/wx.png)")
+			logger.Debugf("函数名称: %s, 函数参数：%s", function.Name, params)
+			params["user_id"] = userVo.Id
+			var apiRes types.BizVo
+			r, err := req2.C().R().SetHeader("Content-Type", "application/json").
+				SetHeader("Authorization", function.Token).
+				SetBody(params).
+				SetSuccessResult(&apiRes).Post(function.Action)
+			errMsg := ""
+			if err != nil {
+				errMsg = err.Error()
+			} else if r.IsErrorState() {
+				errMsg = r.Err.Error()
+			}
+			if errMsg != "" || apiRes.Code != types.Success {
+				msg := "调用函数工具出错：" + apiRes.Message + errMsg
+				utils.ReplyChunkMessage(ws, types.WsMessage{
+					Type:    types.WsMiddle,
+					Content: msg,
+				})
+				contents = append(contents, msg)
 			} else {
-				f := h.App.Functions[functionName]
-				if functionName == types.FuncMidJourney {
-					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.FuncMidJourney {
-						content = fmt.Sprintf("绘画提示词：%s 已推送任务到 MidJourney 机器人，请耐心等待任务执行...", data)
-						h.mjService.ChatClients.Put(session.SessionId, ws)
-						// 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)
-				}
+				utils.ReplyChunkMessage(ws, types.WsMessage{
+					Type:    types.WsMiddle,
+					Content: apiRes.Data,
+				})
+				contents = append(contents, utils.InterfaceToString(apiRes.Data))
 			}
 		}

 		// 消息发送成功
 		if len(contents) > 0 {
 			// 更新用户的对话次数
-			if userVo.ChatConfig.ApiKeys[session.Model.Platform] == "" {
-				h.db.Model(&model.User{}).Where("id = ?", userVo.Id).UpdateColumn("calls", gorm.Expr("calls - ?", 1))
-			}
+			h.subUserCalls(userVo, session)

 			if message.Role == "" {
 				message.Role = "assistant"
@@ -178,7 +167,7 @@ func (h *ChatHandler) sendOpenAiMessage(
 			useMsg := types.Message{Role: "user", Content: prompt}

 			// 更新上下文消息，如果是调用函数则不需要更新上下文
-			if h.App.ChatConfig.EnableContext && functionCall == false {
+			if h.App.ChatConfig.EnableContext && toolCall == false {
 				chatCtx = append(chatCtx, useMsg)  // 提问消息
 				chatCtx = append(chatCtx, message) // 回复消息
 				h.App.ChatContexts.Put(session.ChatId, chatCtx)
@@ -187,7 +176,7 @@ func (h *ChatHandler) sendOpenAiMessage(
 			// 追加聊天记录
 			if h.App.ChatConfig.EnableHistory {
 				useContext := true
-				if functionCall {
+				if toolCall {
 					useContext = false
 				}

@@ -202,7 +191,7 @@ func (h *ChatHandler) sendOpenAiMessage(
 					RoleId:     role.Id,
 					Type:       types.PromptMsg,
 					Icon:       userVo.Avatar,
-					Content:    prompt,
+					Content:    template.HTMLEscapeString(prompt),
 					Tokens:     promptToken,
 					UseContext: useContext,
 				}
@@ -215,8 +204,8 @@ func (h *ChatHandler) sendOpenAiMessage(

 				// 计算本次对话消耗的总 token 数量
 				var totalTokens = 0
-				if functionCall { // prompt + 函数名 + 参数 token
-					tokens, _ := utils.CalcTokens(functionName, req.Model)
+				if toolCall { // prompt + 函数名 + 参数 token
+					tokens, _ := utils.CalcTokens(function.Name, req.Model)
 					totalTokens += tokens
 					tokens, _ = utils.CalcTokens(utils.InterfaceToString(arguments), req.Model)
 					totalTokens += tokens
@@ -243,8 +232,7 @@ func (h *ChatHandler) sendOpenAiMessage(
 				}

 				// 更新用户信息
-				h.db.Model(&model.User{}).Where("id = ?", userVo.Id).
-					UpdateColumn("total_tokens", gorm.Expr("total_tokens + ?", totalTokens))
+				h.incUserTokenFee(userVo.Id, totalTokens)
 			}

 			// 保存当前会话
--- 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{
+	"general":   "v1.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/function_handler.go
+++ b/api/handler/function_handler.go
@@ -0,0 +1,235 @@
+package handler
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/service/oss"
+	"chatplus/store/model"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"github.com/imroc/req/v3"
+	"gorm.io/gorm"
+	"strings"
+)
+
+type FunctionHandler struct {
+	BaseHandler
+	db            *gorm.DB
+	config        types.ChatPlusApiConfig
+	uploadManager *oss.UploaderManager
+	proxyURL      string
+}
+
+func NewFunctionHandler(server *core.AppServer, db *gorm.DB, config *types.AppConfig, manager *oss.UploaderManager) *FunctionHandler {
+	return &FunctionHandler{
+		BaseHandler: BaseHandler{
+			App: server,
+		},
+		db:            db,
+		config:        config.ApiConfig,
+		uploadManager: manager,
+		proxyURL:      config.ProxyURL,
+	}
+}
+
+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"`
+}
+
+// WeiBo 微博热搜
+func (h *FunctionHandler) WeiBo(c *gin.Context) {
+	if h.config.Token == "" {
+		resp.ERROR(c, "无效的 API Token")
+		return
+	}
+
+	url := fmt.Sprintf("%s/api/weibo/fetch", h.config.ApiURL)
+	var res resVo
+	r, err := req.C().R().
+		SetHeader("AppId", h.config.AppId).
+		SetHeader("Authorization", fmt.Sprintf("Bearer %s", h.config.Token)).
+		SetSuccessResult(&res).Get(url)
+	if err != nil || r.IsErrorState() {
+		resp.ERROR(c, fmt.Sprintf("%v%v", err, r.Err))
+		return
+	}
+
+	if res.Code != types.Success {
+		resp.ERROR(c, res.Message)
+		return
+	}
+
+	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))
+	}
+	resp.SUCCESS(c, strings.Join(builder, "\n\n"))
+}
+
+// ZaoBao 今日早报
+func (h *FunctionHandler) ZaoBao(c *gin.Context) {
+	if h.config.Token == "" {
+		resp.ERROR(c, "无效的 API Token")
+		return
+	}
+
+	url := fmt.Sprintf("%s/api/zaobao/fetch", h.config.ApiURL)
+	var res resVo
+	r, err := req.C().R().
+		SetHeader("AppId", h.config.AppId).
+		SetHeader("Authorization", fmt.Sprintf("Bearer %s", h.config.Token)).
+		SetSuccessResult(&res).Get(url)
+	if err != nil || r.IsErrorState() {
+		resp.ERROR(c, fmt.Sprintf("%v%v", err, r.Err))
+		return
+	}
+
+	if res.Code != types.Success {
+		resp.ERROR(c, res.Message)
+		return
+	}
+
+	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))
+	resp.SUCCESS(c, strings.Join(builder, "\n\n"))
+}
+
+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"`
+}
+
+// Dall3 DallE3 AI 绘图
+func (h *FunctionHandler) Dall3(c *gin.Context) {
+	var params map[string]interface{}
+	if err := c.ShouldBindJSON(&params); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	logger.Debugf("绘画参数：%+v", params)
+	// check img calls
+	var user model.User
+	tx := h.db.Where("id = ?", params["user_id"]).First(&user)
+	if tx.Error != nil {
+		resp.ERROR(c, "当前用户不存在！")
+		return
+	}
+
+	if user.ImgCalls <= 0 {
+		resp.ERROR(c, "当前用户的绘图次数额度不足！")
+		return
+	}
+
+	prompt := utils.InterfaceToString(params["prompt"])
+	// get image generation API KEY
+	var apiKey model.ApiKey
+	tx = h.db.Where("platform = ? AND type = ?", types.OpenAI, "img").Order("last_used_at ASC").First(&apiKey)
+	if tx.Error != nil {
+		resp.ERROR(c, "获取绘图 API KEY 失败: "+tx.Error.Error())
+		return
+	}
+
+	// get image generation api URL
+	var conf model.Config
+	var chatConfig types.ChatConfig
+	tx = h.db.Where("marker", "chat").First(&conf)
+	if tx.Error != nil {
+		resp.ERROR(c, "error with get chat configs:"+tx.Error.Error())
+		return
+	}
+
+	err := utils.JsonDecode(conf.Config, &chatConfig)
+	if err != nil {
+		resp.ERROR(c, "error with decode chat config: "+err.Error())
+		return
+	}
+
+	// translate prompt
+	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]"
+	pt, err := utils.OpenAIRequest(fmt.Sprintf(translatePromptTemplate, params["prompt"]), apiKey.Value, h.App.Config.ProxyURL, chatConfig.OpenAI.ApiURL)
+	if err == nil {
+		prompt = pt
+	}
+
+	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
+	var request *req.Request
+	if strings.Contains(apiURL, "api.openai.com") {
+		request = req.C().SetProxyURL(h.proxyURL).R()
+	} else {
+		request = req.C().R()
+	}
+	r, err := request.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 r.IsErrorState() {
+		resp.ERROR(c, "请求 OpenAI API 失败: "+errRes.Error.Message)
+		return
+	}
+	// 存储图片
+	imgURL, err := h.uploadManager.GetUploadHandler().PutImg(res.Data[0].Url, false)
+	if err != nil {
+		resp.ERROR(c, "下载图片失败: "+err.Error())
+		return
+	}
+
+	content := fmt.Sprintf("下面是根据您的描述创作的图片，它描绘了 【%s】 的场景。 \n\n![](%s)\n", prompt, imgURL)
+	// update user's img_calls
+	h.db.Model(&model.User{}).Where("id = ?", user.Id).UpdateColumn("img_calls", gorm.Expr("img_calls - ?", 1))
+
+	resp.SUCCESS(c, content)
+}
--- 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
@@ -3,7 +3,9 @@ package handler
 import (
 	"chatplus/core"
 	"chatplus/core/types"
+	"chatplus/service"
 	"chatplus/service/mj"
+	"chatplus/service/oss"
 	"chatplus/store/model"
 	"chatplus/store/vo"
 	"chatplus/utils"
@@ -11,7 +13,6 @@ import (
 	"encoding/base64"
 	"fmt"
 	"github.com/gin-gonic/gin"
-	"github.com/go-redis/redis/v8"
 	"github.com/gorilla/websocket"
 	"gorm.io/gorm"
 	"net/http"
@@ -21,40 +22,24 @@ import (

 type MidJourneyHandler struct {
 	BaseHandler
-	redis     *redis.Client
 	db        *gorm.DB
-	mjService *mj.Service
+	pool      *mj.ServicePool
+	snowflake *service.Snowflake
+	uploader  *oss.UploaderManager
 }

-func NewMidJourneyHandler(
-	app *core.AppServer,
-	client *redis.Client,
-	db *gorm.DB,
-	mjService *mj.Service) *MidJourneyHandler {
+func NewMidJourneyHandler(app *core.AppServer, db *gorm.DB, snowflake *service.Snowflake, pool *mj.ServicePool, manager *oss.UploaderManager) *MidJourneyHandler {
 	h := MidJourneyHandler{
-		redis:     client,
 		db:        db,
-		mjService: mjService,
+		snowflake: snowflake,
+		pool:      pool,
+		uploader:  manager,
 	}
 	h.App = app
 	return &h
 }

-// Client WebSocket 客户端，用于通知任务状态变更
-func (h *MidJourneyHandler) Client(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")
-	client := types.NewWsClient(ws)
-	h.mjService.Clients.Put(sessionId, client)
-	logger.Infof("New websocket connected, IP: %s", c.ClientIP())
-}
-
-func (h *MidJourneyHandler) checkLimits(c *gin.Context) bool {
+func (h *MidJourneyHandler) preCheck(c *gin.Context) bool {
 	user, err := utils.GetLoginUser(c, h.db)
 	if err != nil {
 		resp.NotAuth(c)
@@ -66,20 +51,42 @@ func (h *MidJourneyHandler) checkLimits(c *gin.Context) bool {
 		return false
 	}

+	if !h.pool.HasAvailableService() {
+		resp.ERROR(c, "MidJourney 池子中没有没有可用的服务！")
+		return false
+	}
+
 	return true

 }

-// Image 创建一个绘画任务
-func (h *MidJourneyHandler) Image(c *gin.Context) {
-	if !h.App.Config.MjConfig.Enabled {
-		resp.ERROR(c, "MidJourney service is disabled")
+// Client WebSocket 客户端，用于通知任务状态变更
+func (h *MidJourneyHandler) Client(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)
+		c.Abort()
 		return
 	}

+	userId := h.GetInt(c, "user_id", 0)
+	if userId == 0 {
+		logger.Info("Invalid user ID")
+		c.Abort()
+		return
+	}
+
+	client := types.NewWsClient(ws)
+	h.pool.Clients.Put(uint(userId), client)
+	logger.Infof("New websocket connected, IP: %s", c.RemoteIP())
+}
+
+// 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"`
@@ -87,13 +94,15 @@ func (h *MidJourneyHandler) Image(c *gin.Context) {
 		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.checkLimits(c) {
+	if !h.preCheck(c) {
 		return
 	}

@@ -119,15 +128,31 @@ func (h *MidJourneyHandler) Image(c *gin.Context) {
 	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 += data.Model
+		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(),
@@ -137,30 +162,26 @@ func (h *MidJourneyHandler) Image(c *gin.Context) {
 		return
 	}

-	h.mjService.PushTask(types.MjTask{
+	h.pool.PushTask(types.MjTask{
 		Id:        int(job.Id),
 		SessionId: data.SessionId,
-		Src:       types.TaskSrcImg,
 		Type:      types.TaskImage,
-		Prompt:    prompt,
+		Prompt:    fmt.Sprintf("%s %s", taskId, prompt),
 		UserId:    userId,
 	})

-	var jobVo vo.MidJourneyJob
-	err := utils.CopyObject(job, &jobVo)
-	if err == nil {
-		// 推送任务到前端
-		client := h.mjService.Clients.Get(data.SessionId)
-		if client != nil {
-			utils.ReplyChunkMessage(client, jobVo)
-		}
-	}
+	client := h.pool.Clients.Get(uint(job.UserId))
+	_ = client.Send([]byte("Task Updated"))
+
+	// update user's img calls
+	h.db.Model(&model.User{}).Where("id = ?", job.UserId).UpdateColumn("img_calls", gorm.Expr("img_calls - ?", 1))
 	resp.SUCCESS(c)
 }

 type reqVo struct {
-	Src         string `json:"src"`
+	TaskId      string `json:"task_id"`
 	Index       int    `json:"index"`
+	ChannelId   string `json:"channel_id"`
 	MessageId   string `json:"message_id"`
 	MessageHash string `json:"message_hash"`
 	SessionId   string `json:"session_id"`
@@ -178,65 +199,42 @@ func (h *MidJourneyHandler) Upscale(c *gin.Context) {
 		return
 	}

-	if !h.checkLimits(c) {
+	if !h.preCheck(c) {
 		return
 	}

 	idValue, _ := c.Get(types.LoginUserID)
 	jobId := 0
 	userId := utils.IntValue(utils.InterfaceToString(idValue), 0)
-	src := types.TaskSrc(data.Src)
-	if src == types.TaskSrcImg {
-		job := model.MidJourneyJob{
-			Type:      types.TaskUpscale.String(),
-			UserId:    userId,
-			Hash:      data.MessageHash,
-			Progress:  0,
-			Prompt:    data.Prompt,
-			CreatedAt: time.Now(),
-		}
-		if res := h.db.Create(&job); res.Error == nil {
-			jobId = int(job.Id)
-		} else {
-			resp.ERROR(c, "添加任务失败："+res.Error.Error())
-			return
-		}
-
-		var jobVo vo.MidJourneyJob
-		err := utils.CopyObject(job, &jobVo)
-		if err == nil {
-			// 推送任务到前端
-			client := h.mjService.Clients.Get(data.SessionId)
-			if client != nil {
-				utils.ReplyChunkMessage(client, jobVo)
-			}
-		}
+	job := model.MidJourneyJob{
+		Type:        types.TaskUpscale.String(),
+		ReferenceId: data.MessageId,
+		UserId:      userId,
+		TaskId:      data.TaskId,
+		Progress:    0,
+		Prompt:      data.Prompt,
+		CreatedAt:   time.Now(),
 	}
-	h.mjService.PushTask(types.MjTask{
+	if res := h.db.Create(&job); res.Error != nil {
+		resp.ERROR(c, "添加任务失败："+res.Error.Error())
+		return
+	}
+
+	h.pool.PushTask(types.MjTask{
 		Id:          jobId,
 		SessionId:   data.SessionId,
-		Src:         src,
 		Type:        types.TaskUpscale,
 		Prompt:      data.Prompt,
 		UserId:      userId,
-		RoleId:      data.RoleId,
-		Icon:        data.Icon,
-		ChatId:      data.ChatId,
+		ChannelId:   data.ChannelId,
 		Index:       data.Index,
 		MessageId:   data.MessageId,
 		MessageHash: data.MessageHash,
 	})

-	if src == types.TaskSrcChat {
-		wsClient := h.App.ChatClients.Get(data.SessionId)
-		if wsClient != nil {
-			content := fmt.Sprintf("**%s** 已推送 upscale 任务到 MidJourney 机器人，请耐心等待任务执行...", data.Prompt)
-			utils.ReplyMessage(wsClient, content)
-			if h.mjService.ChatClients.Get(data.SessionId) == nil {
-				h.mjService.ChatClients.Put(data.SessionId, wsClient)
-			}
-		}
-	}
+	client := h.pool.Clients.Get(uint(job.UserId))
+	_ = client.Send([]byte("Task Updated"))
+
 	resp.SUCCESS(c)
 }

@@ -248,81 +246,72 @@ func (h *MidJourneyHandler) Variation(c *gin.Context) {
 		return
 	}

-	if !h.checkLimits(c) {
+	if !h.preCheck(c) {
 		return
 	}

 	idValue, _ := c.Get(types.LoginUserID)
 	jobId := 0
 	userId := utils.IntValue(utils.InterfaceToString(idValue), 0)
-	src := types.TaskSrc(data.Src)
-	if src == types.TaskSrcImg {
-		job := model.MidJourneyJob{
-			Type:      types.TaskVariation.String(),
-			UserId:    userId,
-			ImgURL:    "",
-			Hash:      data.MessageHash,
-			Progress:  0,
-			Prompt:    data.Prompt,
-			CreatedAt: time.Now(),
-		}
-		if res := h.db.Create(&job); res.Error == nil {
-			jobId = int(job.Id)
-		} else {
-			resp.ERROR(c, "添加任务失败："+res.Error.Error())
-			return
-		}

-		var jobVo vo.MidJourneyJob
-		err := utils.CopyObject(job, &jobVo)
-		if err == nil {
-			// 推送任务到前端
-			client := h.mjService.Clients.Get(data.SessionId)
-			if client != nil {
-				utils.ReplyChunkMessage(client, jobVo)
-			}
-		}
+	job := model.MidJourneyJob{
+		Type:        types.TaskVariation.String(),
+		ChannelId:   data.ChannelId,
+		ReferenceId: data.MessageId,
+		UserId:      userId,
+		TaskId:      data.TaskId,
+		Progress:    0,
+		Prompt:      data.Prompt,
+		CreatedAt:   time.Now(),
 	}
-	h.mjService.PushTask(types.MjTask{
+	if res := h.db.Create(&job); res.Error != nil {
+		resp.ERROR(c, "添加任务失败："+res.Error.Error())
+		return
+	}
+
+	h.pool.PushTask(types.MjTask{
 		Id:          jobId,
 		SessionId:   data.SessionId,
-		Src:         src,
 		Type:        types.TaskVariation,
 		Prompt:      data.Prompt,
 		UserId:      userId,
-		RoleId:      data.RoleId,
-		Icon:        data.Icon,
-		ChatId:      data.ChatId,
 		Index:       data.Index,
+		ChannelId:   data.ChannelId,
 		MessageId:   data.MessageId,
 		MessageHash: data.MessageHash,
 	})

-	if src == types.TaskSrcChat {
-		// 从聊天窗口发送的请求，记录客户端信息
-		wsClient := h.mjService.ChatClients.Get(data.SessionId)
-		if wsClient != nil {
-			content := fmt.Sprintf("**%s** 已推送 variation 任务到 MidJourney 机器人，请耐心等待任务执行...", data.Prompt)
-			utils.ReplyMessage(wsClient, content)
-			if h.mjService.Clients.Get(data.SessionId) == nil {
-				h.mjService.Clients.Put(data.SessionId, wsClient)
-			}
-		}
-	}
+	client := h.pool.Clients.Get(uint(job.UserId))
+	_ = client.Send([]byte("Task Updated"))
+
+	// update user's img calls
+	h.db.Model(&model.User{}).Where("id = ?", job.UserId).UpdateColumn("img_calls", gorm.Expr("img_calls - ?", 1))
 	resp.SUCCESS(c)
 }

 // JobList 获取 MJ 任务列表
 func (h *MidJourneyHandler) JobList(c *gin.Context) {
 	status := h.GetInt(c, "status", 0)
-	var items []model.MidJourneyJob
-	var res *gorm.DB
-	userId, _ := c.Get(types.LoginUserID)
+	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 {
-		res = h.db.Where("user_id = ? AND progress = 100", userId).Order("id DESC").Find(&items)
+		session = session.Where("progress = ?", 100).Order("id DESC")
 	} else {
-		res = h.db.Where("user_id = ? AND progress < 100", userId).Order("id ASC").Find(&items)
+		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
@@ -335,20 +324,61 @@ func (h *MidJourneyHandler) JobList(c *gin.Context) {
 		if err != nil {
 			continue
 		}
+
+		if job.Progress == -1 {
+			h.db.Delete(&model.MidJourneyJob{Id: job.Id})
+		}
+
 		if item.Progress < 100 {
-			// 30 分钟还没完成的任务直接删除
-			if time.Now().Sub(item.CreatedAt) > time.Minute*30 {
+			// 10 分钟还没完成的任务直接删除
+			if time.Now().Sub(item.CreatedAt) > time.Minute*10 {
 				h.db.Delete(&item)
+				// 退回绘图次数
+				h.db.Model(&model.User{}).Where("id = ?", item.UserId).UpdateColumn("img_calls", gorm.Expr("img_calls + ?", 1))
 				continue
 			}
-			if item.ImgURL != "" { // 正在运行中任务使用代理访问图片
-				image, err := utils.DownloadImage(item.ImgURL, h.App.Config.ProxyURL)
+
+			// 正在运行中任务使用代理访问图片
+			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)
 }
+
+// Remove remove task image
+func (h *MidJourneyHandler) Remove(c *gin.Context) {
+	var data struct {
+		Id     uint   `json:"id"`
+		UserId uint   `json:"user_id"`
+		ImgURL string `json:"img_url"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	// remove job recode
+	res := h.db.Delete(&model.MidJourneyJob{Id: data.Id})
+	if res.Error != nil {
+		resp.ERROR(c, res.Error.Error())
+		return
+	}
+
+	// remove image
+	err := h.uploader.GetUploadHandler().Delete(data.ImgURL)
+	if err != nil {
+		logger.Error("remove image failed: ", err)
+	}
+
+	client := h.pool.Clients.Get(data.UserId)
+	_ = client.Send([]byte("Task Updated"))
+
+	resp.SUCCESS(c)
+}
--- 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,397 @@
+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    interface{} `json:"openid"`
+			UrlQrcode string      `json:"url_qrcode"`
+			URL       string      `json:"url"`
+			ErrCode   int         `json:"errcode"`
+			ErrMsg    string      `json:"errmsg,omitempty"`
+		}
+		err = utils.JsonDecode(res, &r)
+		if err != nil {
+			logger.Debugf(res)
+			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,
+		ImgCalls: product.ImgCalls,
+		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
+	}
+
+	if remark.ImgCalls > 0 {
+		user.ImgCalls += remark.ImgCalls
+	} else {
+		user.ImgCalls += h.App.SysConfig.VipMonthImgCalls
+	}
+
+	// 更新用户信息
+	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,75 @@
+package handler
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/store/model"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"fmt"
+
+	"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
+}
+
+// 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)
+	}
+
+	return utils.OpenAIRequest(fmt.Sprintf(promptTemplate, prompt), apiKey.Value, h.App.Config.ProxyURL, h.App.ChatConfig.OpenAI.ApiURL)
+}
--- a/api/handler/sd_handler.go
+++ b/api/handler/sd_handler.go
@@ -3,6 +3,7 @@ package handler
 import (
 	"chatplus/core"
 	"chatplus/core/types"
+	"chatplus/service/oss"
 	"chatplus/service/sd"
 	"chatplus/store/model"
 	"chatplus/store/vo"
@@ -10,46 +11,31 @@ import (
 	"chatplus/utils/resp"
 	"encoding/base64"
 	"fmt"
+	"time"
+
 	"github.com/gin-gonic/gin"
 	"github.com/go-redis/redis/v8"
-	"github.com/gorilla/websocket"
 	"gorm.io/gorm"
-	"net/http"
-	"time"
 )

 type SdJobHandler struct {
 	BaseHandler
-	redis   *redis.Client
-	db      *gorm.DB
-	service *sd.Service
+	redis    *redis.Client
+	db       *gorm.DB
+	pool     *sd.ServicePool
+	uploader *oss.UploaderManager
 }

-func NewSdJobHandler(app *core.AppServer, redisCli *redis.Client, db *gorm.DB, service *sd.Service) *SdJobHandler {
+func NewSdJobHandler(app *core.AppServer, db *gorm.DB, pool *sd.ServicePool, manager *oss.UploaderManager) *SdJobHandler {
 	h := SdJobHandler{
-		redis:   redisCli,
-		db:      db,
-		service: service,
+		db:       db,
+		pool:     pool,
+		uploader: manager,
 	}
 	h.App = app
 	return &h
 }

-// Client WebSocket 客户端，用于通知任务状态变更
-func (h *SdJobHandler) Client(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")
-	client := types.NewWsClient(ws)
-	// 删除旧的连接
-	h.service.Clients.Put(sessionId, client)
-	logger.Infof("New websocket connected, IP: %s", c.ClientIP())
-}
-
 func (h *SdJobHandler) checkLimits(c *gin.Context) bool {
 	user, err := utils.GetLoginUser(c, h.db)
 	if err != nil {
@@ -57,6 +43,11 @@ func (h *SdJobHandler) checkLimits(c *gin.Context) bool {
 		return false
 	}

+	if !h.pool.HasAvailableService() {
+		resp.ERROR(c, "Stable-Diffusion 池子中没有没有可用的服务！")
+		return false
+	}
+
 	if user.ImgCalls <= 0 {
 		resp.ERROR(c, "您的绘图次数不足，请联系管理员充值！")
 		return false
@@ -68,11 +59,6 @@ func (h *SdJobHandler) checkLimits(c *gin.Context) bool {

 // Image 创建一个绘画任务
 func (h *SdJobHandler) Image(c *gin.Context) {
-	if !h.App.Config.SdConfig.Enabled {
-		resp.ERROR(c, "Stable Diffusion service is disabled")
-		return
-	}
-
 	if !h.checkLimits(c) {
 		return
 	}
@@ -130,7 +116,6 @@ func (h *SdJobHandler) Image(c *gin.Context) {
 		Params:    utils.JsonEncode(params),
 		Prompt:    data.Prompt,
 		Progress:  0,
-		Started:   false,
 		CreatedAt: time.Now(),
 	}
 	res := h.db.Create(&job)
@@ -139,38 +124,44 @@ func (h *SdJobHandler) Image(c *gin.Context) {
 		return
 	}

-	h.service.PushTask(types.SdTask{
+	h.pool.PushTask(types.SdTask{
 		Id:        int(job.Id),
 		SessionId: data.SessionId,
-		Src:       types.TaskSrcImg,
 		Type:      types.TaskImage,
 		Prompt:    data.Prompt,
 		Params:    params,
 		UserId:    userId,
 	})
-	var jobVo vo.SdJob
-	err := utils.CopyObject(job, &jobVo)
-	if err == nil {
-		// 推送任务到前端
-		client := h.service.Clients.Get(data.SessionId)
-		if client != nil {
-			utils.ReplyChunkMessage(client, jobVo)
-		}
-	}
+
+	// update user's img calls
+	h.db.Model(&model.User{}).Where("id = ?", job.UserId).UpdateColumn("img_calls", gorm.Expr("img_calls - ?", 1))
+
 	resp.SUCCESS(c)
 }

-// JobList 获取 MJ 任务列表
+// JobList 获取 stable diffusion 任务列表
 func (h *SdJobHandler) JobList(c *gin.Context) {
 	status := h.GetInt(c, "status", 0)
-	var items []model.SdJob
-	var res *gorm.DB
-	userId, _ := c.Get(types.LoginUserID)
+	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 {
-		res = h.db.Where("user_id = ? AND progress = 100", userId).Order("id DESC").Find(&items)
+		session = session.Where("progress = ?", 100).Order("id DESC")
 	} else {
-		res = h.db.Where("user_id = ? AND progress < 100", userId).Order("id ASC").Find(&items)
+		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
@@ -183,20 +174,53 @@ func (h *SdJobHandler) JobList(c *gin.Context) {
 		if err != nil {
 			continue
 		}
+
+		if job.Progress == -1 {
+			h.db.Delete(&model.SdJob{Id: job.Id})
+		}
+
 		if item.Progress < 100 {
-			// 30 分钟还没完成的任务直接删除
-			if time.Now().Sub(item.CreatedAt) > time.Minute*30 {
+			// 5 分钟还没完成的任务直接删除
+			if time.Now().Sub(item.CreatedAt) > time.Minute*5 {
 				h.db.Delete(&item)
+				// 退回绘图次数
+				h.db.Model(&model.User{}).Where("id = ?", item.UserId).UpdateColumn("img_calls", gorm.Expr("img_calls + ?", 1))
 				continue
 			}
-			if item.ImgURL != "" { // 正在运行中任务使用代理访问图片
-				image, err := utils.DownloadImage(item.ImgURL, h.App.Config.ProxyURL)
-				if err == nil {
-					job.ImgURL = "data:image/png;base64," + base64.StdEncoding.EncodeToString(image)
-				}
+			// 正在运行中任务使用代理访问图片
+			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)
 }
+
+// Remove remove task image
+func (h *SdJobHandler) Remove(c *gin.Context) {
+	var data struct {
+		Id     uint   `json:"id"`
+		ImgURL string `json:"img_url"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	// remove job recode
+	res := h.db.Delete(&model.SdJob{Id: data.Id})
+	if res.Error != nil {
+		resp.ERROR(c, res.Error.Error())
+		return
+	}
+
+	// remove image
+	err := h.uploader.GetUploadHandler().Delete(data.ImgURL)
+	if err != nil {
+		logger.Error("remove image failed: ", err)
+	}
+
+	resp.SUCCESS(c)
+}
--- a/api/handler/sms_handler.go
+++ b/api/handler/sms_handler.go
@@ -4,23 +4,23 @@ import (
 	"chatplus/core"
 	"chatplus/core/types"
 	"chatplus/service"
-	"chatplus/store"
 	"chatplus/utils"
 	"chatplus/utils/resp"
 	"github.com/gin-gonic/gin"
+	"github.com/go-redis/redis/v8"
 )

 const CodeStorePrefix = "/verify/codes/"

 type SmsHandler struct {
 	BaseHandler
-	leveldb *store.LevelDB
+	redis   *redis.Client
 	sms     *service.AliYunSmsService
 	captcha *service.CaptchaService
 }

-func NewSmsHandler(app *core.AppServer, db *store.LevelDB, sms *service.AliYunSmsService, captcha *service.CaptchaService) *SmsHandler {
-	handler := &SmsHandler{leveldb: db, sms: sms, captcha: captcha}
+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
 }
@@ -50,7 +50,7 @@ func (h *SmsHandler) SendCode(c *gin.Context) {
 	}

 	// 存储验证码，等待后面注册验证
-	err = h.leveldb.Put(CodeStorePrefix+data.Mobile, code)
+	_, err = h.redis.Set(c, CodeStorePrefix+data.Mobile, code, 0).Result()
 	if err != nil {
 		resp.ERROR(c, "验证码保存失败")
 		return
@@ -58,13 +58,3 @@ func (h *SmsHandler) SendCode(c *gin.Context) {

 	resp.SUCCESS(c)
 }
-
-type statusVo struct {
-	EnabledMsgService bool `json:"enabled_msg_service"`
-	EnabledRegister   bool `json:"enabled_register"`
-}
-
-// Status check if the message service is enabled
-func (h *SmsHandler) Status(c *gin.Context) {
-	resp.SUCCESS(c, statusVo{EnabledMsgService: h.App.SysConfig.EnabledMsg, EnabledRegister: h.App.SysConfig.EnabledRegister})
-}
--- 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/user_handler.go
+++ b/api/handler/user_handler.go
@@ -3,7 +3,6 @@ package handler
 import (
 	"chatplus/core"
 	"chatplus/core/types"
-	"chatplus/store"
 	"chatplus/store/model"
 	"chatplus/store/vo"
 	"chatplus/utils"
@@ -23,7 +22,6 @@ type UserHandler struct {
 	BaseHandler
 	db       *gorm.DB
 	searcher *xdb.Searcher
-	leveldb  *store.LevelDB
 	redis    *redis.Client
 }

@@ -31,9 +29,8 @@ func NewUserHandler(
 	app *core.AppServer,
 	db *gorm.DB,
 	searcher *xdb.Searcher,
-	levelDB *store.LevelDB,
 	client *redis.Client) *UserHandler {
-	handler := &UserHandler{db: db, searcher: searcher, leveldb: levelDB, redis: client}
+	handler := &UserHandler{db: db, searcher: searcher, redis: client}
 	handler.App = app
 	return handler
 }
@@ -42,9 +39,10 @@ func NewUserHandler(
 func (h *UserHandler) Register(c *gin.Context) {
 	// parameters process
 	var data struct {
-		Mobile   string `json:"mobile"`
-		Password string `json:"password"`
-		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)
@@ -64,14 +62,28 @@ func (h *UserHandler) Register(c *gin.Context) {
 	// 检查验证码
 	key := CodeStorePrefix + data.Mobile
 	if h.App.SysConfig.EnabledMsg {
-		var code int
-		err := h.leveldb.Get(key, &code)
+		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("mobile = ?", data.Mobile).First(&item)
@@ -80,22 +92,15 @@ func (h *UserHandler) Register(c *gin.Context) {
 		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{
-		Password:  utils.GenPassword(data.Password, salt),
-		Avatar:    "/images/avatar/user.png",
-		Salt:      salt,
-		Status:    true,
-		Mobile:    data.Mobile,
-		ChatRoles: utils.JsonEncode(roleKeys),
+		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:  "",
@@ -103,7 +108,7 @@ func (h *UserHandler) Register(c *gin.Context) {
 				types.ChatGLM: "",
 			},
 		}),
-		Calls:    h.App.SysConfig.UserInitCalls,
+		Calls:    h.App.SysConfig.InitChatCalls,
 		ImgCalls: h.App.SysConfig.InitImgCalls,
 	}
 	res = h.db.Create(&user)
@@ -113,10 +118,47 @@ func (h *UserHandler) Register(c *gin.Context) {
 		return
 	}

-	if h.App.SysConfig.EnabledMsg {
-		_ = h.leveldb.Delete(key) // 注册成功，删除短信验证码
+	// 记录邀请关系
+	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}),
+		})
 	}
-	resp.SUCCESS(c, user)
+	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 用户登录
@@ -220,6 +262,9 @@ type userProfile struct {
 	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) {
@@ -266,8 +311,8 @@ func (h *UserHandler) ProfileUpdate(c *gin.Context) {
 	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"`
@@ -306,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)
@@ -325,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)
@@ -346,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/main.go
+++ b/api/main.go
@@ -5,17 +5,17 @@ import (
 	"chatplus/core/types"
 	"chatplus/handler"
 	"chatplus/handler/admin"
+	"chatplus/handler/chatimpl"
 	logger2 "chatplus/logger"
 	"chatplus/service"
-	"chatplus/service/fun"
 	"chatplus/service/mj"
 	"chatplus/service/oss"
+	"chatplus/service/payment"
 	"chatplus/service/sd"
 	"chatplus/service/wx"
 	"chatplus/store"
 	"context"
 	"embed"
-	"github.com/go-redis/redis/v8"
 	"io"
 	"log"
 	"os"
@@ -24,6 +24,8 @@ import (
 	"syscall"
 	"time"

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

 var logger = logger2.GetLogger()

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

 // AppLifecycle 应用程序生命周期
@@ -92,9 +94,12 @@ func main() {
 		// 初始化数据库
 		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) {
 			file, err := xdbFS.Open("res/ip2region.xdb")
@@ -109,13 +114,10 @@ func main() {
 			return xdb.NewWithBuffer(cBuff)
 		}),

-		// 创建函数
-		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.NewSmsHandler),
 		fx.Provide(handler.NewRewardHandler),
@@ -123,6 +125,9 @@ func main() {
 		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),
@@ -132,6 +137,8 @@ func main() {
 		fx.Provide(admin.NewRewardHandler),
 		fx.Provide(admin.NewDashboardHandler),
 		fx.Provide(admin.NewChatModelHandler),
+		fx.Provide(admin.NewProductHandler),
+		fx.Provide(admin.NewOrderHandler),

 		// 创建服务
 		fx.Provide(service.NewAliYunSmsService),
@@ -152,38 +159,35 @@ func main() {
 			}
 		}),

-		// MidJourney 机器人
-		fx.Provide(mj.NewBot),
-		fx.Provide(mj.NewClient),
-		fx.Invoke(func(config *types.AppConfig, bot *mj.Bot) {
-			if config.MjConfig.Enabled {
-				err := bot.Run()
-				if err != nil {
-					log.Fatal("MidJourney 服务启动失败：", err)
-				}
-			}
-		}),
-		fx.Invoke(func(config *types.AppConfig, mjService *mj.Service) {
-			if config.MjConfig.Enabled {
-				go func() {
-					mjService.Run()
-				}()
+		// MidJourney service pool
+		fx.Provide(mj.NewServicePool),
+		fx.Invoke(func(pool *mj.ServicePool) {
+			if pool.HasAvailableService() {
+				pool.DownloadImages()
+				pool.CheckTaskNotify()
 			}
 		}),

 		// Stable Diffusion 机器人
-		fx.Provide(sd.NewService),
-		fx.Invoke(func(config *types.AppConfig, service *sd.Service) {
-			if config.SdConfig.Enabled {
+		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() {
-					service.Run()
+					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/")
@@ -193,10 +197,11 @@ 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)
@@ -213,7 +218,6 @@ func main() {
 		}),
 		fx.Invoke(func(s *core.AppServer, h *handler.SmsHandler) {
 			group := s.Engine.Group("/api/sms/")
-			group.GET("status", h.Status)
 			group.POST("code", h.SendCode)
 		}),
 		fx.Invoke(func(s *core.AppServer, h *handler.CaptchaHandler) {
@@ -227,17 +231,18 @@ func main() {
 		}),
 		fx.Invoke(func(s *core.AppServer, h *handler.MidJourneyHandler) {
 			group := s.Engine.Group("/api/mj/")
+			group.Any("client", h.Client)
 			group.POST("image", h.Image)
 			group.POST("upscale", h.Upscale)
 			group.POST("variation", h.Variation)
 			group.GET("jobs", h.JobList)
-			group.Any("client", h.Client)
+			group.POST("remove", h.Remove)
 		}),
 		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)
-			group.Any("client", h.Client)
+			group.POST("remove", h.Remove)
 		}),

 		// 管理后台控制器
@@ -251,7 +256,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/")
@@ -290,11 +294,79 @@ func main() {
 			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(admin.NewFunctionHandler),
+		fx.Invoke(func(s *core.AppServer, h *admin.FunctionHandler) {
+			group := s.Engine.Group("/api/admin/function/")
+			group.POST("save", h.Save)
+			group.POST("set", h.Set)
+			group.GET("list", h.List)
+			group.GET("remove", h.Remove)
+			group.GET("token", h.GenToken)
+		}),
+
+		fx.Provide(handler.NewFunctionHandler),
+		fx.Invoke(func(s *core.AppServer, h *handler.FunctionHandler) {
+			group := s.Engine.Group("/api/function/")
+			group.POST("weibo", h.WeiBo)
+			group.POST("zaobao", h.ZaoBao)
+			group.POST("dalle3", h.Dall3)
+		}),
+
+		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/sd/text2img.json
+++ b/api/res/sd/text2img.json
@@ -1,36 +1,41 @@
 {
  "data": [
-    "task(38194gitxp745ha)",
-    "A beautiful Chinese girl riding on a tiger",
+    "task(cxvkpawy8onnfti)",
+    "a  cute girl",
    "",
    [],
    20,
-    "Euler a",
-    false,
-    false,
+    "DPM++ 2M Karras",
    1,
    1,
    7,
-    -1,
-    -1,
-    0,
-    0,
-    0,
+    512,
+    512,
    false,
-    512,
-    512,
-    true,
    0.7,
    2,
-    "ESRGAN_4x",
+    "Latent",
    0,
    0,
    0,
+    "Use same checkpoint",
    "Use same sampler",
    "",
    "",
    [],
    "None",
+    false,
+    "",
+    0.8,
+    -1,
+    false,
+    -1,
+    0,
+    0,
+    0,
+    null,
+    null,
+    null,
    null,
    false,
    false,
@@ -54,36 +59,13 @@
    false,
    false,
    0,
-    "Not set",
-    true,
-    true,
-    "",
-    "",
-    "",
-    "",
-    "",
-    1.3,
-    "Not set",
-    "Not set",
-    1.3,
-    "Not set",
-    1.3,
-    "Not set",
-    1.3,
-    1.3,
-    "Not set",
-    1.3,
-    "Not set",
-    1.3,
-    "Not set",
-    1.3,
-    "Not set",
-    1.3,
-    "Not set",
-    1.3,
-    "Not set",
+    null,
+    null,
    false,
-    "None",
+    null,
+    null,
+    false,
+    null,
    null,
    false,
    50,
@@ -93,6 +75,6 @@
    ""
  ],
  "event_data": null,
-  "fn_index": 232,
-  "session_hash": "3xedmn4nuzq"
+  "fn_index": 446,
+  "session_hash": "nk5noh1rz1o"
 }
--- 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.AliYunSmsConfig
-	db     *store.LevelDB
 	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",
@@ -25,7 +23,6 @@ func NewAliYunSmsService(config *types.AppConfig, db *store.LevelDB) (*AliYunSms

 	return &AliYunSmsService{
 		config: &config.SmsConfig,
-		db:     db,
 		client: client,
 	}, nil
 }
--- a/api/service/fun/func_mj.go
+++ b/api/service/fun/func_mj.go
@@ -1,42 +0,0 @@
-package fun
-
-import (
-	"chatplus/core/types"
-	"chatplus/service/mj"
-	"chatplus/utils"
-)
-
-// AI 绘画函数
-
-type FuncMidJourney struct {
-	name    string
-	service *mj.Service
-}
-
-func NewMidJourneyFunc(mjService *mj.Service) FuncMidJourney {
-	return FuncMidJourney{
-		name:    "MidJourney AI 绘画",
-		service: mjService}
-}
-
-func (f FuncMidJourney) Invoke(params map[string]interface{}) (string, error) {
-	logger.Infof("MJ 绘画参数：%+v", params)
-	prompt := utils.InterfaceToString(params["prompt"])
-	f.service.PushTask(types.MjTask{
-		SessionId: utils.InterfaceToString(params["session_id"]),
-		Src:       types.TaskSrcChat,
-		Type:      types.TaskImage,
-		Prompt:    prompt,
-		UserId:    utils.IntValue(utils.InterfaceToString(params["user_id"]), 0),
-		RoleId:    utils.IntValue(utils.InterfaceToString(params["role_id"]), 0),
-		Icon:      utils.InterfaceToString(params["icon"]),
-		ChatId:    utils.InterfaceToString(params["chat_id"]),
-	})
-	return prompt, nil
-}
-
-func (f FuncMidJourney) Name() string {
-	return f.name
-}
-
-var _ Function = &FuncMidJourney{}
--- a/api/service/fun/function.go
+++ b/api/service/fun/function.go
@@ -1,39 +0,0 @@
-package fun
-
-import (
-	"chatplus/core/types"
-	logger2 "chatplus/logger"
-	"chatplus/service/mj"
-)
-
-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, mjService *mj.Service) map[string]Function {
-	return map[string]Function{
-		types.FuncZaoBao:     NewZaoBao(config.ApiConfig),
-		types.FuncWeibo:      NewWeiboHot(config.ApiConfig),
-		types.FuncHeadLine:   NewHeadLines(config.ApiConfig),
-		types.FuncMidJourney: NewMidJourneyFunc(mjService),
-	}
-}
--- a/api/service/fun/tou_tiao.go
+++ b/api/service/fun/tou_tiao.go
@@ -1,58 +0,0 @@
-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
@@ -1,58 +0,0 @@
-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
@@ -1,59 +0,0 @@
-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/mj/bot.go
+++ b/api/service/mj/bot.go
@@ -4,7 +4,7 @@ import (
 	"chatplus/core/types"
 	logger2 "chatplus/logger"
 	"chatplus/utils"
-	"github.com/bwmarrin/discordgo"
+	discordgo "github.com/bg5t/mydiscordgo"
 	"github.com/gorilla/websocket"
 	"net/http"
 	"net/url"
@@ -17,32 +17,49 @@ import (
 var logger = logger2.GetLogger()

 type Bot struct {
-	config  *types.MidJourneyConfig
+	config  types.MidJourneyConfig
 	bot     *discordgo.Session
+	name    string
 	service *Service
 }

-func NewBot(config *types.AppConfig, service *Service) (*Bot, error) {
-	discord, err := discordgo.New("Bot " + config.MjConfig.BotToken)
+func NewBot(name string, proxy string, config types.MidJourneyConfig, service *Service) (*Bot, error) {
+	bot, err := discordgo.New("Bot " + config.BotToken)
 	if err != nil {
+		logger.Error(err)
 		return nil, err
 	}

-	if config.ProxyURL != "" {
-		proxy, _ := url.Parse(config.ProxyURL)
-		discord.Client = &http.Client{
-			Transport: &http.Transport{
+	// use CDN reverse proxy
+	if config.UseCDN {
+		discordgo.SetEndpointDiscord(config.DiscordAPI)
+		discordgo.SetEndpointCDN(config.DiscordCDN)
+		discordgo.SetEndpointStatus(config.DiscordAPI + "/api/v2/")
+		bot.MjGateway = config.DiscordGateway + "/"
+	} else { // use proxy
+		discordgo.SetEndpointDiscord("https://discord.com")
+		discordgo.SetEndpointCDN("https://cdn.discordapp.com")
+		discordgo.SetEndpointStatus("https://discord.com/api/v2/")
+		bot.MjGateway = "wss://gateway.discord.gg"
+
+		if proxy != "" {
+			proxy, _ := url.Parse(proxy)
+			bot.Client = &http.Client{
+				Transport: &http.Transport{
+					Proxy: http.ProxyURL(proxy),
+				},
+			}
+			bot.Dialer = &websocket.Dialer{
 				Proxy: http.ProxyURL(proxy),
-			},
-		}
-		discord.Dialer = &websocket.Dialer{
-			Proxy: http.ProxyURL(proxy),
+			}
 		}
+
 	}

 	return &Bot{
-		config:  &config.MjConfig,
-		bot:     discord,
+		config:  config,
+		bot:     bot,
+		name:    name,
 		service: service,
 	}, nil
 }
@@ -52,13 +69,13 @@ func (b *Bot) Run() error {
 	b.bot.AddHandler(b.messageCreate)
 	b.bot.AddHandler(b.messageUpdate)

-	logger.Info("Starting MidJourney Bot...")
+	logger.Infof("Starting MidJourney %s", b.name)
 	err := b.bot.Open()
 	if err != nil {
-		logger.Error("Error opening Discord connection:", err)
+		logger.Errorf("Error opening Discord connection for %s, error: %v", b.name, err)
 		return err
 	}
-	logger.Info("Starting MidJourney Bot successfully!")
+	logger.Infof("Starting MidJourney %s successfully!", b.name)
 	return nil
 }

@@ -87,7 +104,7 @@ func (b *Bot) messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
 		return
 	}
 	// ignore messages for self
-	if m.Author.ID == s.State.User.ID {
+	if m.Author == nil || m.Author.ID == s.State.User.ID {
 		return
 	}

@@ -99,6 +116,7 @@ func (b *Bot) messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
 	if strings.Contains(m.Content, "(Waiting to start)") && !strings.Contains(m.Content, "Rerolling **") {
 		// parse content
 		req := CBReq{
+			ChannelId:   m.ChannelID,
 			MessageId:   m.ID,
 			ReferenceId: referenceId,
 			Prompt:      extractPrompt(m.Content),
@@ -109,7 +127,7 @@ func (b *Bot) messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
 		return
 	}

-	b.addAttachment(m.ID, referenceId, m.Content, m.Attachments)
+	b.addAttachment(m.ChannelID, m.ID, referenceId, m.Content, m.Attachments)
 }

 func (b *Bot) messageUpdate(s *discordgo.Session, m *discordgo.MessageUpdate) {
@@ -118,7 +136,7 @@ func (b *Bot) messageUpdate(s *discordgo.Session, m *discordgo.MessageUpdate) {
 		return
 	}
 	// ignore messages for self
-	if m.Author.ID == s.State.User.ID {
+	if m.Author == nil || m.Author.ID == s.State.User.ID {
 		return
 	}

@@ -130,6 +148,7 @@ func (b *Bot) messageUpdate(s *discordgo.Session, m *discordgo.MessageUpdate) {
 	}
 	if strings.Contains(m.Content, "(Stopped)") {
 		req := CBReq{
+			ChannelId:   m.ChannelID,
 			MessageId:   m.ID,
 			ReferenceId: referenceId,
 			Prompt:      extractPrompt(m.Content),
@@ -140,11 +159,11 @@ func (b *Bot) messageUpdate(s *discordgo.Session, m *discordgo.MessageUpdate) {
 		return
 	}

-	b.addAttachment(m.ID, referenceId, m.Content, m.Attachments)
+	b.addAttachment(m.ChannelID, m.ID, referenceId, m.Content, m.Attachments)

 }

-func (b *Bot) addAttachment(messageId string, referenceId string, content string, attachments []*discordgo.MessageAttachment) {
+func (b *Bot) addAttachment(channelId string, messageId string, referenceId string, content string, attachments []*discordgo.MessageAttachment) {
 	progress := extractProgress(content)
 	var status TaskStatus
 	if progress == 100 {
@@ -166,6 +185,7 @@ func (b *Bot) addAttachment(messageId string, referenceId string, content string
 			Hash:     extractHashFromFilename(attachment.Filename),
 		}
 		req := CBReq{
+			ChannelId:   channelId,
 			MessageId:   messageId,
 			ReferenceId: referenceId,
 			Image:       image,
--- a/api/service/mj/client.go
+++ b/api/service/mj/client.go
@@ -3,35 +3,44 @@ package mj
 import (
 	"chatplus/core/types"
 	"fmt"
-	"github.com/imroc/req/v3"
 	"time"
+
+	"github.com/imroc/req/v3"
 )

 // MidJourney client

 type Client struct {
 	client *req.Client
-	config *types.MidJourneyConfig
+	Config types.MidJourneyConfig
+	apiURL string
 }

-func NewClient(config *types.AppConfig) *Client {
+func NewClient(config types.MidJourneyConfig, proxy string) *Client {
 	client := req.C().SetTimeout(10 * time.Second)
+	var apiURL string
 	// set proxy URL
-	if config.ProxyURL != "" {
-		client.SetProxyURL(config.ProxyURL)
+	if config.UseCDN {
+		apiURL = config.DiscordAPI + "/api/v9/interactions"
+	} else {
+		apiURL = "https://discord.com/api/v9/interactions"
+		if proxy != "" {
+			client.SetProxyURL(proxy)
+		}
 	}
-	return &Client{client: client, config: &config.MjConfig}
+
+	return &Client{client: client, Config: config, apiURL: apiURL}
 }

 func (c *Client) Imagine(prompt string) error {
 	interactionsReq := &InteractionsRequest{
 		Type:          2,
 		ApplicationID: ApplicationID,
-		GuildID:       c.config.GuildId,
-		ChannelID:     c.config.ChanelId,
+		GuildID:       c.Config.GuildId,
+		ChannelID:     c.Config.ChanelId,
 		SessionID:     SessionID,
 		Data: map[string]any{
-			"version": "1118961510123847772",
+			"version": "1166847114203123795",
 			"id":      "938956540159881230",
 			"name":    "imagine",
 			"type":    "1",
@@ -66,11 +75,10 @@ func (c *Client) Imagine(prompt string) error {
 		},
 	}

-	url := "https://discord.com/api/v9/interactions"
-	r, err := c.client.R().SetHeader("Authorization", c.config.UserToken).
+	r, err := c.client.R().SetHeader("Authorization", c.Config.UserToken).
 		SetHeader("Content-Type", "application/json").
 		SetBody(interactionsReq).
-		Post(url)
+		Post(c.apiURL)

 	if err != nil || r.IsErrorState() {
 		return fmt.Errorf("error with http request: %w%v", err, r.Err)
@@ -85,8 +93,8 @@ func (c *Client) Upscale(index int, messageId string, hash string) error {
 	interactionsReq := &InteractionsRequest{
 		Type:          3,
 		ApplicationID: ApplicationID,
-		GuildID:       c.config.GuildId,
-		ChannelID:     c.config.ChanelId,
+		GuildID:       c.Config.GuildId,
+		ChannelID:     c.Config.ChanelId,
 		MessageFlags:  &flags,
 		MessageID:     &messageId,
 		SessionID:     SessionID,
@@ -97,13 +105,12 @@ func (c *Client) Upscale(index int, messageId string, hash string) error {
 		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).
+	r, err := c.client.R().SetHeader("Authorization", c.Config.UserToken).
 		SetHeader("Content-Type", "application/json").
 		SetBody(interactionsReq).
 		SetErrorResult(&res).
-		Post(url)
+		Post(c.apiURL)
 	if err != nil || r.IsErrorState() {
 		return fmt.Errorf("error with http request: %v%v%v", err, r.Err, res.Message)
 	}
@@ -117,8 +124,8 @@ func (c *Client) Variation(index int, messageId string, hash string) error {
 	interactionsReq := &InteractionsRequest{
 		Type:          3,
 		ApplicationID: ApplicationID,
-		GuildID:       c.config.GuildId,
-		ChannelID:     c.config.ChanelId,
+		GuildID:       c.Config.GuildId,
+		ChannelID:     c.Config.ChanelId,
 		MessageFlags:  &flags,
 		MessageID:     &messageId,
 		SessionID:     SessionID,
@@ -129,13 +136,12 @@ func (c *Client) Variation(index int, messageId string, hash string) error {
 		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).
+	r, err := c.client.R().SetHeader("Authorization", c.Config.UserToken).
 		SetHeader("Content-Type", "application/json").
 		SetBody(interactionsReq).
 		SetErrorResult(&res).
-		Post(url)
+		Post(c.apiURL)
 	if err != nil || r.IsErrorState() {
 		return fmt.Errorf("error with http request: %v%v%v", err, r.Err, res.Message)
 	}
--- a/api/service/mj/pool.go
+++ b/api/service/mj/pool.go
@@ -0,0 +1,127 @@
+package mj
+
+import (
+	"chatplus/core/types"
+	"chatplus/service/oss"
+	"chatplus/store"
+	"chatplus/store/model"
+	"fmt"
+	"github.com/go-redis/redis/v8"
+	"time"
+
+	"gorm.io/gorm"
+)
+
+// ServicePool Mj service pool
+type ServicePool struct {
+	services        []*Service
+	taskQueue       *store.RedisQueue
+	notifyQueue     *store.RedisQueue
+	db              *gorm.DB
+	uploaderManager *oss.UploaderManager
+	Clients         *types.LMap[uint, *types.WsClient] // UserId => Client
+}
+
+func NewServicePool(db *gorm.DB, redisCli *redis.Client, manager *oss.UploaderManager, appConfig *types.AppConfig) *ServicePool {
+	services := make([]*Service, 0)
+	taskQueue := store.NewRedisQueue("MidJourney_Task_Queue", redisCli)
+	notifyQueue := store.NewRedisQueue("MidJourney_Notify_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, taskQueue, notifyQueue, 4, 600, db, client)
+		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:       taskQueue,
+		notifyQueue:     notifyQueue,
+		services:        services,
+		uploaderManager: manager,
+		db:              db,
+		Clients:         types.NewLMap[uint, *types.WsClient](),
+	}
+}
+
+func (p *ServicePool) CheckTaskNotify() {
+	go func() {
+		for {
+			var userId uint
+			err := p.notifyQueue.LPop(&userId)
+			if err != nil {
+				continue
+			}
+			client := p.Clients.Get(userId)
+			err = client.Send([]byte("Task Updated"))
+			if err != nil {
+				continue
+			}
+		}
+	}()
+}
+
+func (p *ServicePool) DownloadImages() {
+	go func() {
+		var items []model.MidJourneyJob
+		for {
+			res := p.db.Where("img_url = ? AND progress = ?", "", 100).Find(&items)
+			if res.Error != nil {
+				continue
+			}
+
+			// download images
+			for _, v := range items {
+				imgURL, err := p.uploaderManager.GetUploadHandler().PutImg(v.OrgURL, true)
+				if err != nil {
+					logger.Error("error with download image: ", err)
+					continue
+				}
+
+				v.ImgURL = imgURL
+				p.db.Updates(&v)
+
+				client := p.Clients.Get(uint(v.UserId))
+				err = client.Send([]byte("Task Updated"))
+				if err != nil {
+					continue
+				}
+			}
+
+			time.Sleep(time.Second * 5)
+		}
+	}()
+}
+
+// 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
@@ -2,63 +2,68 @@ package mj

 import (
 	"chatplus/core/types"
-	"chatplus/service/oss"
 	"chatplus/store"
 	"chatplus/store/model"
-	"chatplus/store/vo"
-	"chatplus/utils"
-	"context"
-	"encoding/base64"
-	"fmt"
-	"github.com/go-redis/redis/v8"
 	"gorm.io/gorm"
+	"strings"
+	"sync/atomic"
 	"time"
 )

-// MJ 绘画服务
-
-const RunningJobKey = "MidJourney_Running_Job"
-
+// Service MJ 绘画服务
 type Service struct {
-	client        *Client // MJ 客户端
-	taskQueue     *store.RedisQueue
-	redis         *redis.Client
-	db            *gorm.DB
-	uploadManager *oss.UploaderManager
-	Clients       *types.LMap[string, *types.WsClient] // MJ 绘画页面 websocket 连接池，用户推送绘画消息
-	ChatClients   *types.LMap[string, *types.WsClient] // 聊天页面 websocket 连接池，用于推送绘画消息
-	proxyURL      string
+	name             string  // service name
+	client           *Client // MJ client
+	taskQueue        *store.RedisQueue
+	notifyQueue      *store.RedisQueue
+	db               *gorm.DB
+	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(redisCli *redis.Client, db *gorm.DB, client *Client, manager *oss.UploaderManager, config *types.AppConfig) *Service {
+func NewService(name string, taskQueue *store.RedisQueue, notifyQueue *store.RedisQueue, maxTaskNum int32, timeout int64, db *gorm.DB, client *Client) *Service {
 	return &Service{
-		redis:         redisCli,
-		db:            db,
-		taskQueue:     store.NewRedisQueue("MidJourney_Task_Queue", redisCli),
-		client:        client,
-		uploadManager: manager,
-		Clients:       types.NewLMap[string, *types.WsClient](),
-		ChatClients:   types.NewLMap[string, *types.WsClient](),
-		proxyURL:      config.ProxyURL,
+		name:             name,
+		db:               db,
+		taskQueue:        taskQueue,
+		notifyQueue:      notifyQueue,
+		client:           client,
+		taskTimeout:      timeout,
+		maxHandleTaskNum: maxTaskNum,
+		taskStartTimes:   make(map[int]time.Time, 0),
 	}
 }

 func (s *Service) Run() {
-	logger.Info("Starting MidJourney job consumer.")
-	ctx := context.Background()
+	logger.Infof("Starting MidJourney job consumer for %s", s.name)
 	for {
-		_, err := s.redis.Get(ctx, RunningJobKey).Result()
-		if err == nil { // 队列串行执行
+		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)
+		err := s.taskQueue.LPop(&task)
 		if err != nil {
 			logger.Errorf("taking task with error: %v", err)
 			continue
 		}
-		logger.Infof("Consuming Task: %+v", task)
+
+		// if it's reference message, check if it's this channel's  message
+		if task.ChannelId != "" && task.ChannelId != s.client.Config.ChanelId {
+			s.taskQueue.RPush(task)
+			s.db.Model(&model.MidJourneyJob{Id: uint(task.Id)}).UpdateColumn("progress", -1)
+			s.notifyQueue.RPush(task.UserId)
+			time.Sleep(time.Second)
+			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)
@@ -70,42 +75,45 @@ func (s *Service) Run() {
 		case types.TaskVariation:
 			err = s.client.Variation(task.Index, task.MessageId, task.MessageHash)
 		}
+
 		if err != nil {
 			logger.Error("绘画任务执行失败：", err)
-			if task.RetryCount <= 5 {
-				s.taskQueue.RPush(task)
-			}
-			task.RetryCount += 1
-			time.Sleep(time.Second * 3)
+			// update the task progress
+			s.db.Model(&model.MidJourneyJob{Id: uint(task.Id)}).UpdateColumn("progress", -1)
+			s.notifyQueue.RPush(task.UserId)
+			// restore img_call quota
+			s.db.Model(&model.User{}).Where("id = ?", task.UserId).UpdateColumn("img_calls", gorm.Expr("img_calls + ?", 1))
 			continue
 		}

-		// 更新任务的执行状态
-		s.db.Model(&model.MidJourneyJob{}).Where("id = ?", task.Id).UpdateColumn("started", true)
-		// 锁定任务执行通道，直到任务超时（5分钟）
-		s.redis.Set(ctx, RunningJobKey, utils.JsonEncode(task), time.Minute*5)
+		// lock the task until the execute timeout
+		s.taskStartTimes[task.Id] = time.Now()
+		atomic.AddInt32(&s.handledTaskNum, 1)
+
 	}
 }

-func (s *Service) PushTask(task types.MjTask) {
-	logger.Infof("add a new MidJourney Task: %+v", task)
-	s.taskQueue.RPush(task)
+// 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) {
-	taskString, err := s.redis.Get(context.Background(), RunningJobKey).Result()
-	if err != nil { // 过期任务，丢弃
-		logger.Warn("任务已过期：", err)
-		return
-	}
-
-	var task types.MjTask
-	err = utils.JsonDecode(taskString, &task)
-	if err != nil { // 非标准任务，丢弃
-		logger.Warn("任务解析失败：", err)
-		return
-	}
-
+	// 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 {
@@ -113,137 +121,39 @@ func (s *Service) Notify(data CBReq) {
 		return
 	}

-	if task.Src == types.TaskSrcImg { // 绘画任务
-		var job model.MidJourneyJob
-		res := s.db.Where("id = ?", task.Id).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
-
-		// 任务完成，将最终的图片下载下来
-		if data.Progress == 100 {
-			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
-		} else {
-			// 临时图片直接保存，访问的时候使用代理进行转发
-			job.ImgURL = data.Image.URL
-		}
-		res = s.db.Updates(&job)
-		if res.Error != nil {
-			logger.Error("error with update job: ", res.Error)
-			return
-		}
-
-		var jobVo vo.MidJourneyJob
-		err := utils.CopyObject(job, &jobVo)
-		if err == nil {
-			if data.Progress < 100 {
-				image, err := utils.DownloadImage(jobVo.ImgURL, s.proxyURL)
-				if err == nil {
-					jobVo.ImgURL = "data:image/png;base64," + base64.StdEncoding.EncodeToString(image)
-				}
-			}
-
-			// 推送任务到前端
-			client := s.Clients.Get(task.SessionId)
-			if client != nil {
-				utils.ReplyChunkMessage(client, jobVo)
-			}
-		}
-
-	} else if task.Src == types.TaskSrcChat { // 聊天任务
-		wsClient := s.ChatClients.Get(task.SessionId)
-		if data.Status == Finished {
-			if wsClient != nil && data.ReferenceId != "" {
-				content := fmt.Sprintf("**%s** 任务执行成功，正在从 MidJourney 服务器下载图片，请稍后...", data.Prompt)
-				utils.ReplyMessage(wsClient, content)
-			}
-			// download image
-			imgURL, err := s.uploadManager.GetUploadHandler().PutImg(data.Image.URL, true)
-			if err != nil {
-				logger.Error("error with download image: ", err)
-				if wsClient != nil && data.ReferenceId != "" {
-					content := fmt.Sprintf("**%s** 图片下载失败：%s", data.Prompt, err.Error())
-					utils.ReplyMessage(wsClient, content)
-				}
-				return
-			}
-
-			tx := s.db.Begin()
-			data.Image.URL = imgURL
-			message := model.HistoryMessage{
-				UserId:     uint(task.UserId),
-				ChatId:     task.ChatId,
-				RoleId:     uint(task.RoleId),
-				Type:       types.MjMsg,
-				Icon:       task.Icon,
-				Content:    utils.JsonEncode(data),
-				Tokens:     0,
-				UseContext: false,
-			}
-			res = tx.Create(&message)
-			if res.Error != nil {
-				logger.Error("error with update database: ", err)
-				return
-			}
-
-			// save the job
-			job.UserId = task.UserId
-			job.Type = task.Type.String()
-			job.MessageId = data.MessageId
-			job.ReferenceId = data.ReferenceId
-			job.Prompt = data.Prompt
-			job.ImgURL = imgURL
-			job.Progress = data.Progress
-			job.Hash = data.Image.Hash
-			job.CreatedAt = time.Now()
-			res = tx.Create(&job)
-			if res.Error != nil {
-				logger.Error("error with update database: ", err)
-				tx.Rollback()
-				return
-			}
-			tx.Commit()
-		}
-
-		if wsClient == nil { // 客户端断线，则丢弃
-			logger.Errorf("Client is offline: %+v", data)
-			return
-		}
-
-		if data.Status == Finished {
-			utils.ReplyChunkMessage(wsClient, types.WsMessage{Type: types.WsMjImg, Content: data})
-			utils.ReplyChunkMessage(wsClient, types.WsMessage{Type: types.WsEnd})
-			// 本次绘画完毕，移除客户端
-			s.ChatClients.Delete(task.SessionId)
-		} else {
-			// 使用代理临时转发图片
-			if data.Image.URL != "" {
-				image, err := utils.DownloadImage(data.Image.URL, s.proxyURL)
-				if err == nil {
-					data.Image.URL = "data:image/png;base64," + base64.StdEncoding.EncodeToString(image)
-				}
-			}
-			utils.ReplyChunkMessage(wsClient, types.WsMessage{Type: types.WsMjImg, Content: data})
-		}
+	tx := s.db.Where("task_id = ? AND progress < 100", split[0]).Session(&gorm.Session{}).Order("id ASC")
+	if data.ReferenceId != "" {
+		tx = tx.Where("reference_id = ?", data.ReferenceId)
+	}
+	res = tx.First(&job)
+	if res.Error != nil {
+		logger.Warn("非法任务：", res.Error)
+		return
+	}
+
+	job.ChannelId = data.ChannelId
+	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
+	if s.client.Config.UseCDN {
+		job.UseProxy = true
+		job.ImgURL = strings.ReplaceAll(data.Image.URL, "https://cdn.discordapp.com", s.client.Config.DiscordCDN)
+	}
+
+	res = s.db.Updates(&job)
+	if res.Error != nil {
+		logger.Error("error with update job: ", res.Error)
+		return
 	}

-	// 更新用户剩余绘图次数
-	// TODO: 放大图片是否需要消耗绘图次数？
 	if data.Status == Finished {
-		s.db.Model(&model.User{}).Where("id = ?", task.UserId).UpdateColumn("img_calls", gorm.Expr("img_calls - ?", 1))
-		// 解除任务锁定
-		s.redis.Del(context.Background(), RunningJobKey)
+		// release lock task
+		atomic.AddInt32(&s.handledTaskNum, -1)
 	}

+	s.notifyQueue.RPush(job.UserId)
+
 }
--- a/api/service/mj/types.go
+++ b/api/service/mj/types.go
@@ -24,6 +24,7 @@ type InteractionsResult struct {
 }

 type CBReq struct {
+	ChannelId   string     `json:"channel_id"`
 	MessageId   string     `json:"message_id"`
 	ReferenceId string     `json:"reference_id"`
 	Image       Image      `json:"image"`
--- a/api/service/oss/aliyun_oss.go
+++ b/api/service/oss/aliyun_oss.go
@@ -32,6 +32,10 @@ func NewAliYunOss(appConfig *types.AppConfig) (*AliYunOss, error) {
 		return nil, err
 	}

+	if config.SubDir == "" {
+		config.SubDir = "gpt"
+	}
+
 	return &AliYunOss{
 		config:   config,
 		bucket:   bucket,
@@ -54,14 +58,14 @@ func (s AliYunOss) PutFile(ctx *gin.Context, name string) (string, error) {
 	defer src.Close()

 	fileExt := filepath.Ext(file.Filename)
-	objectKey := fmt.Sprintf("%d%s", time.Now().UnixMicro(), fileExt)
+	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("https://%s.%s/%s", s.config.Bucket, s.config.Endpoint, objectKey), nil
+	return fmt.Sprintf("%s/%s", s.config.Domain, objectKey), nil
 }

 func (s AliYunOss) PutImg(imageURL string, useProxy bool) (string, error) {
@@ -80,18 +84,19 @@ func (s AliYunOss) PutImg(imageURL string, useProxy bool) (string, error) {
 		return "", fmt.Errorf("error with parse image URL: %v", err)
 	}
 	fileExt := filepath.Ext(parse.Path)
-	objectKey := fmt.Sprintf("%d%s", time.Now().UnixMicro(), fileExt)
+	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("https://%s.%s/%s", s.config.Bucket, s.config.Endpoint, objectKey), nil
+	return fmt.Sprintf("%s/%s", s.config.Domain, objectKey), nil
 }

 func (s AliYunOss) Delete(fileURL string) error {
 	objectName := filepath.Base(fileURL)
-	return s.bucket.DeleteObject(objectName)
+	key := fmt.Sprintf("%s/%s", s.config.SubDir, objectName)
+	return s.bucket.DeleteObject(key)
 }

 var _ Uploader = AliYunOss{}
--- a/api/service/oss/minio_oss.go
+++ b/api/service/oss/minio_oss.go
@@ -29,6 +29,9 @@ func NewMiniOss(appConfig *types.AppConfig) (MiniOss, error) {
 	if err != nil {
 		return MiniOss{}, err
 	}
+	if config.SubDir == "" {
+		config.SubDir = "gpt"
+	}
 	return MiniOss{config: config, client: minioClient, proxyURL: appConfig.ProxyURL}, nil
 }

@@ -48,7 +51,7 @@ func (s MiniOss) PutImg(imageURL string, useProxy bool) (string, error) {
 		return "", fmt.Errorf("error with parse image URL: %v", err)
 	}
 	fileExt := filepath.Ext(parse.Path)
-	filename := fmt.Sprintf("%d%s", time.Now().UnixMicro(), fileExt)
+	filename := fmt.Sprintf("%s/%d%s", s.config.SubDir, time.Now().UnixMicro(), fileExt)
 	info, err := s.client.PutObject(
 		context.Background(),
 		s.config.Bucket,
@@ -75,7 +78,7 @@ func (s MiniOss) PutFile(ctx *gin.Context, name string) (string, error) {
 	defer fileReader.Close()

 	fileExt := filepath.Ext(file.Filename)
-	filename := fmt.Sprintf("%d%s", time.Now().UnixMicro(), fileExt)
+	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"),
 	})
@@ -88,7 +91,8 @@ func (s MiniOss) PutFile(ctx *gin.Context, name string) (string, error) {

 func (s MiniOss) Delete(fileURL string) error {
 	objectName := filepath.Base(fileURL)
-	return s.client.RemoveObject(context.Background(), s.config.Bucket, objectName, minio.RemoveObjectOptions{})
+	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
@@ -15,12 +15,12 @@ import (
 )

 type QinNiuOss struct {
-	config   *types.QiNiuOssConfig
-	token    string
-	uploader *storage.FormUploader
-	manager  *storage.BucketManager
-	proxyURL string
-	dir      string
+	config    *types.QiNiuOssConfig
+	mac       *qbox.Mac
+	putPolicy storage.PutPolicy
+	uploader  *storage.FormUploader
+	manager   *storage.BucketManager
+	proxyURL  string
 }

 func NewQiNiuOss(appConfig *types.AppConfig) QinNiuOss {
@@ -37,13 +37,16 @@ func NewQiNiuOss(appConfig *types.AppConfig) QinNiuOss {
 	putPolicy := storage.PutPolicy{
 		Scope: config.Bucket,
 	}
+	if config.SubDir == "" {
+		config.SubDir = "gpt"
+	}
 	return QinNiuOss{
-		config:   config,
-		token:    putPolicy.UploadToken(mac),
-		uploader: formUploader,
-		manager:  storage.NewBucketManager(mac, &storeConfig),
-		proxyURL: appConfig.ProxyURL,
-		dir:      "chatgpt-plus",
+		config:    config,
+		mac:       mac,
+		putPolicy: putPolicy,
+		uploader:  formUploader,
+		manager:   storage.NewBucketManager(mac, &storeConfig),
+		proxyURL:  appConfig.ProxyURL,
 	}
 }

@@ -61,11 +64,11 @@ func (s QinNiuOss) PutFile(ctx *gin.Context, name string) (string, error) {
 	defer src.Close()

 	fileExt := filepath.Ext(file.Filename)
-	key := fmt.Sprintf("%s/%d%s", s.dir, time.Now().UnixMicro(), fileExt)
+	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.token, key, src, file.Size, &extra)
+	err = s.uploader.Put(ctx, &ret, s.putPolicy.UploadToken(s.mac), key, src, file.Size, &extra)
 	if err != nil {
 		return "", err
 	}
@@ -89,11 +92,11 @@ func (s QinNiuOss) PutImg(imageURL string, useProxy bool) (string, error) {
 		return "", fmt.Errorf("error with parse image URL: %v", err)
 	}
 	fileExt := filepath.Ext(parse.Path)
-	key := fmt.Sprintf("%s/%d%s", s.dir, time.Now().UnixMicro(), fileExt)
+	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.token, key, bytes.NewReader(imageData), int64(len(imageData)), &extra)
+	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
 	}
@@ -102,7 +105,7 @@ func (s QinNiuOss) PutImg(imageURL string, useProxy bool) (string, error) {

 func (s QinNiuOss) Delete(fileURL string) error {
 	objectName := filepath.Base(fileURL)
-	key := fmt.Sprintf("%s/%s", s.dir, objectName)
+	key := fmt.Sprintf("%s/%s", s.config.SubDir, objectName)
 	return s.manager.Delete(s.config.Bucket, key)
 }

--- 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,53 @@
+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, 1, 300, 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
@@ -5,84 +5,99 @@ import (
 	"chatplus/service/oss"
 	"chatplus/store"
 	"chatplus/store/model"
-	"chatplus/store/vo"
 	"chatplus/utils"
-	"context"
 	"encoding/json"
 	"fmt"
-	"github.com/go-redis/redis/v8"
-	"github.com/imroc/req/v3"
-	"gorm.io/gorm"
 	"io"
 	"os"
 	"strconv"
+	"sync/atomic"
 	"time"
+
+	"github.com/imroc/req/v3"
+	"gorm.io/gorm"
 )

 // SD 绘画服务

-const RunningJobKey = "StableDiffusion_Running_Job"
-
 type Service struct {
-	httpClient    *req.Client
-	config        *types.StableDiffusionConfig
-	taskQueue     *store.RedisQueue
-	redis         *redis.Client
-	db            *gorm.DB
-	uploadManager *oss.UploaderManager
-	Clients       *types.LMap[string, *types.WsClient] // SD 绘画页面 websocket 连接池
+	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(config *types.AppConfig, redisCli *redis.Client, db *gorm.DB, manager *oss.UploaderManager) *Service {
+func NewService(name string, maxTaskNum int32, timeout int64, config types.StableDiffusionConfig, queue *store.RedisQueue, db *gorm.DB, manager *oss.UploaderManager) *Service {
 	return &Service{
-		config:        &config.SdConfig,
-		httpClient:    req.C(),
-		redis:         redisCli,
-		db:            db,
-		uploadManager: manager,
-		Clients:       types.NewLMap[string, *types.WsClient](),
-		taskQueue:     store.NewRedisQueue("stable_diffusion_task_queue", redisCli),
+		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() {
-	logger.Info("Starting StableDiffusion job consumer.")
-	ctx := context.Background()
 	for {
-		_, err := s.redis.Get(ctx, RunningJobKey).Result()
-		if err == nil { // 队列串行执行
+		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)
+		err := s.taskQueue.LPop(&task)
 		if err != nil {
 			logger.Errorf("taking task with error: %v", err)
 			continue
 		}
-		logger.Infof("Consuming Task: %+v", task)
+		logger.Infof("%s handle a new Stable-Diffusion task: %+v", s.name, task)
 		err = s.Txt2Img(task)
 		if err != nil {
 			logger.Error("绘画任务执行失败：", err)
-			if task.RetryCount <= 5 {
-				s.taskQueue.RPush(task)
-			}
-			task.RetryCount += 1
-			time.Sleep(time.Second * 3)
+			// update the task progress
+			s.db.Model(&model.SdJob{Id: uint(task.Id)}).UpdateColumn("progress", -1)
+			// restore img_call quota
+			s.db.Model(&model.User{}).Where("id = ?", task.UserId).UpdateColumn("img_calls", gorm.Expr("img_calls + ?", 1))
+			// release task num
+			atomic.AddInt32(&s.handledTaskNum, -1)
 			continue
 		}

-		// 更新任务的执行状态
-		s.db.Model(&model.SdJob{}).Where("id = ?", task.Id).UpdateColumn("started", true)
-		// 锁定任务执行通道，直到任务超时（5分钟）
-		s.redis.Set(ctx, RunningJobKey, utils.JsonEncode(task), time.Minute*5)
+		// lock the task until the execute timeout
+		s.taskStartTimes[task.Id] = time.Now()
+		atomic.AddInt32(&s.handledTaskNum, 1)
 	}
 }

-// PushTask 推送任务到队列
-func (s *Service) PushTask(task types.SdTask) {
-	logger.Infof("add a new MidJourney Task: %+v", task)
-	s.taskQueue.RPush(task)
+// 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
@@ -105,7 +120,8 @@ func (s *Service) Txt2Img(task types.SdTask) error {
 	data[ParamKeys["negative_prompt"]] = params.NegativePrompt
 	data[ParamKeys["steps"]] = params.Steps
 	data[ParamKeys["sampler"]] = params.Sampler
-	data[ParamKeys["face_fix"]] = params.FaceFix
+	// @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
@@ -134,7 +150,6 @@ func (s *Service) runTask(taskInfo TaskInfo, client *req.Client) {
 		"fn_index":     taskInfo.FnIndex,
 		"session_hash": taskInfo.SessionHash,
 	}
-	logger.Debug(utils.JsonEncode(body))
 	var result = make(chan CBReq)
 	go func() {
 		var res struct {
@@ -176,7 +191,8 @@ func (s *Service) runTask(taskInfo TaskInfo, client *req.Client) {
 		var info map[string]any
 		err = utils.JsonDecode(utils.InterfaceToString(res.Data[1]), &info)
 		if err != nil {
-			cbReq.Message = err.Error()
+			logger.Error(res.Data)
+			cbReq.Message = "error with decode image url:" + err.Error()
 			cbReq.Success = false
 			result <- cbReq
 			return
@@ -236,9 +252,8 @@ func (s *Service) runTask(taskInfo TaskInfo, client *req.Client) {
 }

 func (s *Service) callback(data CBReq) {
-	// 释放任务锁
-	s.redis.Del(context.Background(), RunningJobKey)
-	client := s.Clients.Get(data.SessionId)
+	// release task num
+	atomic.AddInt32(&s.handledTaskNum, -1)
 	if data.Success { // 任务成功
 		var job model.SdJob
 		res := s.db.Where("id = ?", data.JobId).First(&job)
@@ -258,13 +273,15 @@ func (s *Service) callback(data CBReq) {

 		params.Seed = data.Seed
 		if data.ImageName != "" { // 下载图片
-			imageURL := fmt.Sprintf("%s/file=%s", s.config.ApiURL, data.ImageName)
-			imageURL, err := s.uploadManager.GetUploadHandler().PutImg(imageURL, false)
-			if err != nil {
-				logger.Error("error with download img: ", err.Error())
-				return
+			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.ImgURL = imageURL
 		}

 		job.Params = utils.JsonEncode(params)
@@ -274,32 +291,16 @@ func (s *Service) callback(data CBReq) {
 			return
 		}

-		var jobVo vo.SdJob
-		err = utils.CopyObject(job, &jobVo)
-		if err != nil {
-			logger.Error("error with copy object: ", err)
-			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))
 		}

-		if data.Progress < 100 && data.ImageData != "" {
-			jobVo.ImgURL = data.ImageData
-		}
-
-		// 推送任务到前端
-		if client != nil {
-			utils.ReplyChunkMessage(client, jobVo)
-		}
 	} else { // 任务失败
 		logger.Error("任务执行失败：", data.Message)
-		// 删除任务
-		s.db.Delete(&model.SdJob{Id: uint(data.JobId)})
-		// 推送消息到前端
-		if client != nil {
-			utils.ReplyChunkMessage(client, vo.SdJob{
-				Id:       uint(data.JobId),
-				Progress: -1,
-				TaskId:   data.TaskId,
-			})
-		}
+		// 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
@@ -32,14 +32,14 @@ var ParamKeys = map[string]int{
 	"negative_prompt": 2,
 	"steps":           4,
 	"sampler":         5,
-	"face_fix":        6,
-	"cfg_scale":       10,
-	"seed":            11,
-	"height":          17,
-	"width":           18,
-	"hd_fix":          19,
-	"hd_redraw_rate":  20, //高清修复重绘幅度
-	"hd_scale":        21, // 高清修复放大倍数
-	"hd_scale_alg":    22, // 高清修复放大算法
-	"hd_sample_num":   23, // 高清修复采样次数
+	"face_fix":        7, // 面部修复
+	"cfg_scale":       8,
+	"seed":            27,
+	"height":          10,
+	"width":           9,
+	"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/xxl_job_service.go
+++ b/api/service/xxl_job_service.go
@@ -0,0 +1,154 @@
+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 = 0
+			}
+			if u.ImgCalls <= 0 {
+				u.ImgCalls = 0
+			}
+			// 如果该用户当月有充值点卡，则将点卡中未用完的点数结余到下个月
+			var orders []model.Order
+			e.db.Debug().Where("user_id = ? AND pay_time > ?", u.Id, firstOfMonth).Find(&orders)
+			var calls = 0
+			var imgCalls = 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
+				imgCalls += remark.ImgCalls
+			}
+			if u.Calls > calls { // 本月套餐没有用完
+				u.Calls = calls + config.VipMonthCalls
+			} else {
+				u.Calls = u.Calls + config.VipMonthCalls
+			}
+			if u.ImgCalls > imgCalls { // 本月套餐没有用完
+				u.ImgCalls = imgCalls + config.VipMonthImgCalls
+			} else {
+				u.ImgCalls = u.ImgCalls + config.VipMonthImgCalls
+			}
+			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
@@ -4,6 +4,7 @@ package model
 type ApiKey struct {
 	BaseModel
 	Platform   string
+	Type       string // 用途 chat => 聊天，img => 绘图
 	Value      string // API Key 的值
 	LastUsedAt int64  // 最后使用时间
 }
--- a/api/store/model/chat_model.go
+++ b/api/store/model/chat_model.go
@@ -7,4 +7,6 @@ type ChatModel struct {
 	Value    string // API Key 的值
 	SortNum  int
 	Enabled  bool
+	Weight   int  // 对话权重，每次对话扣减多少次对话额度
+	Open     bool // 是否开放模型给所有人使用
 }
--- a/api/store/model/function.go
+++ b/api/store/model/function.go
@@ -0,0 +1,12 @@
+package model
+
+type Function struct {
+	Id          uint `gorm:"primarykey;column:id"`
+	Name        string
+	Label       string
+	Description string
+	Parameters  string
+	Action      string
+	Token       string
+	Enabled     bool
+}
--- 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
@@ -6,13 +6,16 @@ type MidJourneyJob struct {
 	Id          uint `gorm:"primarykey;column:id"`
 	Type        string
 	UserId      int
+	TaskId      string
+	ChannelId   string
 	MessageId   string
 	ReferenceId string
 	ImgURL      string
+	OrgURL      string // 原图地址
 	Hash        string // message hash
 	Progress    int
 	Prompt      string
-	Started     bool
+	UseProxy    bool // 是否使用反代加载图片
 	CreatedAt   time.Time
 }

--- 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,15 @@
+package model
+
+// Product 充值产品
+type Product struct {
+	BaseModel
+	Name     string
+	Price    float64
+	Discount float64
+	Days     int
+	Calls    int
+	ImgCalls int
+	Enabled  bool
+	Sales    int
+	SortNum  int
+}
--- a/api/store/model/sd_job.go
+++ b/api/store/model/sd_job.go
@@ -11,7 +11,6 @@ type SdJob struct {
 	Progress  int
 	Prompt    string
 	Params    string
-	Started   bool
 	CreatedAt time.Time
 }

--- a/api/store/model/user.go
+++ b/api/store/model/user.go
@@ -11,8 +11,11 @@ type User struct {
 	ImgCalls    int    // 剩余绘图次数
 	ChatConfig  string `gorm:"column:chat_config_json"` // 聊天配置 json
 	ChatRoles   string `gorm:"column:chat_roles_json"`  // 聊天角色
+	ChatModels  string `gorm:"column:chat_models_json"` // AI 模型，不同的用户拥有不同的聊天模型
 	ExpiredTime int64  // 账户到期时间
 	Status      bool   `gorm:"default:true"` // 当前状态
 	LastLoginAt int64  // 最后登录时间
 	LastLoginIp string // 最后登录 IP
+	Vip         bool   // 是否 VIP 会员
+	Tokens      int
 }
--- a/api/store/mysql.go
+++ b/api/store/mysql.go
@@ -21,6 +21,9 @@ func NewGormConfig() *gorm.Config {

 func NewMysql(config *gorm.Config, appConfig *types.AppConfig) (*gorm.DB, error) {
 	db, err := gorm.Open(mysql.Open(appConfig.MysqlDns), config)
+	if err != nil {
+		return nil, err
+	}

 	sqlDB, err := db.DB()
 	if err != nil {
@@ -29,8 +32,6 @@ func NewMysql(config *gorm.Config, appConfig *types.AppConfig) (*gorm.DB, error)
 	sqlDB.SetMaxIdleConns(32)
 	sqlDB.SetMaxOpenConns(512)
 	sqlDB.SetConnMaxLifetime(time.Hour)
-	if err != nil {
-		return nil, err
-	}
+
 	return db, nil
 }
--- a/api/store/vo/api_key.go
+++ b/api/store/vo/api_key.go
@@ -4,6 +4,7 @@ package vo
 type ApiKey struct {
 	BaseVo
 	Platform   string `json:"platform"`
+	Type       string `json:"type"`
 	Value      string `json:"value"`        // API Key 的值
 	LastUsedAt int64  `json:"last_used_at"` // 最后使用时间
 }
--- a/api/store/vo/chat_model.go
+++ b/api/store/vo/chat_model.go
@@ -6,4 +6,7 @@ type ChatModel struct {
 	Name     string `json:"name"`
 	Value    string `json:"value"`
 	Enabled  bool   `json:"enabled"`
+	SortNum  int    `json:"sort_num"`
+	Weight   int    `json:"weight"`
+	Open     bool   `json:"open"`
 }
--- a/api/store/vo/function.go
+++ b/api/store/vo/function.go
@@ -0,0 +1,23 @@
+package vo
+
+type Parameters struct {
+	Type       string              `json:"type"`
+	Required   []string            `json:"required,omitempty"`
+	Properties map[string]Property `json:"properties"`
+}
+
+type Property struct {
+	Type        string `json:"type"`
+	Description string `json:"description"`
+}
+
+type Function struct {
+	Id          uint       `json:"id"`
+	Name        string     `json:"name"`
+	Label       string     `json:"label"`
+	Description string     `json:"description"`
+	Parameters  Parameters `json:"parameters"`
+	Action      string     `json:"action"`
+	Token       string     `json:"token"`
+	Enabled     bool       `json:"enabled"`
+}
--- a/api/store/vo/invite_code.go
+++ b/api/store/vo/invite_code.go
@@ -0,0 +1,10 @@
+package vo
+
+type InviteCode struct {
+	Id        uint   `json:"id"`
+	UserId    uint   `json:"user_id"`
+	Code      string `json:"code"`
+	Hits      int    `json:"hits"`
+	RegNum    int    `json:"reg_num"`
+	CreatedAt int64  `json:"created_at"`
+}
--- a/api/store/vo/invite_log.go
+++ b/api/store/vo/invite_log.go
@@ -0,0 +1,15 @@
+package vo
+
+import (
+	"chatplus/core/types"
+)
+
+type InviteLog struct {
+	Id         uint               `json:"id"`
+	InviterId  uint               `json:"inviter_id"`
+	UserId     uint               `json:"user_id"`
+	Username   string             `json:"username"`
+	InviteCode string             `json:"invite_code"`
+	Reward     types.InviteReward `json:"reward"`
+	CreatedAt  int64              `json:"created_at"`
+}
--- a/api/store/vo/mj_job.go
+++ b/api/store/vo/mj_job.go
@@ -6,12 +6,15 @@ type MidJourneyJob struct {
 	Id          uint      `json:"id"`
 	Type        string    `json:"type"`
 	UserId      int       `json:"user_id"`
+	ChannelId   string    `json:"channel_id"`
+	TaskId      string    `json:"task_id"`
 	MessageId   string    `json:"message_id"`
 	ReferenceId string    `json:"reference_id"`
 	ImgURL      string    `json:"img_url"`
+	OrgURL      string    `json:"org_url"`
 	Hash        string    `json:"hash"`
 	Progress    int       `json:"progress"`
 	Prompt      string    `json:"prompt"`
+	UseProxy    bool      `json:"use_proxy"`
 	CreatedAt   time.Time `json:"created_at"`
-	Started     bool      `json:"started"`
 }
--- a/api/store/vo/order.go
+++ b/api/store/vo/order.go
@@ -0,0 +1,19 @@
+package vo
+
+import (
+	"chatplus/core/types"
+)
+
+type Order struct {
+	BaseVo
+	UserId    uint              `json:"user_id"`
+	ProductId uint              `json:"product_id"`
+	Mobile    string            `json:"mobile"`
+	OrderNo   string            `json:"order_no"`
+	Subject   string            `json:"subject"`
+	Amount    float64           `json:"amount"`
+	Status    types.OrderStatus `json:"status"`
+	PayTime   int64             `json:"pay_time"`
+	PayWay    string            `json:"pay_way"`
+	Remark    types.OrderRemark `json:"remark"`
+}
--- a/api/store/vo/product.go
+++ b/api/store/vo/product.go
@@ -0,0 +1,14 @@
+package vo
+
+type Product struct {
+	BaseVo
+	Name     string  `json:"name"`
+	Price    float64 `json:"price"`
+	Discount float64 `json:"discount"`
+	Days     int     `json:"days"`
+	Calls    int     `json:"calls"`
+	ImgCalls int     `json:"img_calls"`
+	Enabled  bool    `json:"enabled"`
+	Sales    int     `json:"sales"`
+	SortNum  int     `json:"sort_num"`
+}
--- a/api/store/vo/sd_job.go
+++ b/api/store/vo/sd_job.go
@@ -15,5 +15,4 @@ type SdJob struct {
 	Progress  int                `json:"progress"`
 	Prompt    string             `json:"prompt"`
 	CreatedAt time.Time          `json:"created_at"`
-	Started   bool               `json:"started"`
 }
--- a/api/store/vo/user.go
+++ b/api/store/vo/user.go
@@ -12,8 +12,11 @@ type User struct {
 	ImgCalls    int                  `json:"img_calls"`
 	ChatConfig  types.UserChatConfig `json:"chat_config"`   // 聊天配置
 	ChatRoles   []string             `json:"chat_roles"`    // 聊天角色集合
+	ChatModels  []string             `json:"chat_models"`   // AI模型集合
 	ExpiredTime int64                `json:"expired_time"`  // 账户到期时间
 	Status      bool                 `json:"status"`        // 当前状态
 	LastLoginAt int64                `json:"last_login_at"` // 最后登录时间
 	LastLoginIp string               `json:"last_login_ip"` // 最后登录 IP
+	Vip         bool                 `json:"vip"`
+	Tokens      int                  `json:"token"` // 当月消耗的 fee
 }
--- a/api/test/test.go
+++ b/api/test/test.go
@@ -1,14 +1,5 @@
 package main

-import (
-	"fmt"
-	"os"
-)
-
 func main() {
-	bytes, err := os.ReadFile("res/text2img.json")
-	if err != nil {
-		panic(err)
-	}
-	fmt.Println(string(bytes))
+
 }
--- a/api/utils/common.go
+++ b/api/utils/common.go
@@ -1,13 +1,20 @@
 package utils

 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
+	"github.com/lionsoul2014/ip2region/binding/golang/xdb"
+	"github.com/nfnt/resize"
+	"github.com/skip2/go-qrcode"
+	"image"
+	"image/color"
+	"image/draw"
+	"image/jpeg"
+	"io"
 	"reflect"
 	"strconv"
 	"strings"
-
-	"github.com/lionsoul2014/ip2region/binding/golang/xdb"
 )

 // CopyObject 拷贝对象
@@ -36,7 +43,7 @@ func CopyObject(src interface{}, dst interface{}) error {
 				pType := reflect.New(value.Type())
 				v2 := pType.Interface()
 				err := json.Unmarshal([]byte(v.String()), &v2)
-				if err == nil {
+				if err == nil && v2 != nil {
 					value.Set(reflect.ValueOf(v2).Elem())
 				}
 				// map, struct, slice to string
@@ -52,6 +59,8 @@ func CopyObject(src interface{}, dst interface{}) error {
 						value.Set(reflect.ValueOf(""))
 					}
 				}
+			} else if field.Type.Kind() != value.Type().Kind() { // 不同类型的字段过滤掉
+				continue
 			} else { // 简单数据类型的强制类型转换
 				switch value.Kind() {
 				case reflect.Int:
@@ -140,13 +149,57 @@ func IntValue(str string, defaultValue int) int {
 }

 func ForceCovert(src any, dst interface{}) error {
-	bytes, err := json.Marshal(src)
+	b, err := json.Marshal(src)
 	if err != nil {
 		return err
 	}
-	err = json.Unmarshal(bytes, dst)
+	err = json.Unmarshal(b, dst)
 	if err != nil {
 		return err
 	}
 	return nil
 }
+
+func GenQrcode(text string, size int, logo io.Reader) ([]byte, error) {
+	qr, err := qrcode.New(text, qrcode.Medium)
+	if err != nil {
+		return nil, err
+	}
+
+	qr.BackgroundColor = color.White
+	qr.ForegroundColor = color.Black
+	if logo == nil {
+		return qr.PNG(size)
+	}
+
+	// 生成带Logo的二维码图像
+	logoImage, _, err := image.Decode(logo)
+	if err != nil {
+		return nil, err
+	}
+
+	// 缩放 Logo
+	scaledLogo := resize.Resize(uint(size/9), uint(size/9), logoImage, resize.Lanczos3)
+	// 将Logo叠加到二维码图像上
+	qrWithLogo := overlayLogo(qr.Image(size), scaledLogo)
+
+	// 将带Logo的二维码图像以JPEG格式编码为图片数据
+	var buf bytes.Buffer
+	err = jpeg.Encode(&buf, qrWithLogo, nil)
+	if err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
+
+// 叠加Logo到图片上
+func overlayLogo(qrImage, logoImage image.Image) image.Image {
+	offsetX := (qrImage.Bounds().Dx() - logoImage.Bounds().Dx()) / 2
+	offsetY := (qrImage.Bounds().Dy() - logoImage.Bounds().Dy()) / 2
+
+	combinedImage := image.NewRGBA(qrImage.Bounds())
+	draw.Draw(combinedImage, qrImage.Bounds(), qrImage, image.Point{}, draw.Over)
+	draw.Draw(combinedImage, logoImage.Bounds().Add(image.Pt(offsetX, offsetY)), logoImage, image.Point{}, draw.Over)
+
+	return combinedImage
+}
--- a/api/utils/net.go
+++ b/api/utils/net.go
@@ -4,6 +4,8 @@ import (
 	"chatplus/core/types"
 	logger2 "chatplus/logger"
 	"encoding/json"
+	"fmt"
+	"github.com/imroc/req/v3"
 	"io"
 	"net/http"
 	"net/url"
@@ -61,3 +63,51 @@ func DownloadImage(imageURL string, proxy string) ([]byte, error) {

 	return imageBytes, nil
 }
+
+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"`
+}
+
+func OpenAIRequest(prompt string, apiKey string, proxy string, apiURL string) (string, error) {
+	messages := make([]interface{}, 1)
+	messages[0] = types.Message{
+		Role:    "user",
+		Content: prompt,
+	}
+
+	var response apiRes
+	var errRes apiErrRes
+	r, err := req.C().SetProxyURL(proxy).R().SetHeader("Content-Type", "application/json").
+		SetHeader("Authorization", "Bearer "+apiKey).
+		SetBody(types.ApiRequest{
+			Model:       "gpt-3.5-turbo",
+			Temperature: 0.9,
+			MaxTokens:   1024,
+			Stream:      false,
+			Messages:    messages,
+		}).
+		SetErrorResult(&errRes).
+		SetSuccessResult(&response).Post(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/docker/build.sh
+++ b/docker/build.sh
@@ -1,26 +1,28 @@
 #!/bin/bash

 version=$1
-# build go api
+arch=${2:-amd64}
+
+# build go api program
 cd ../api
-make clean linux
+make clean $arch

 # build web app
 cd ../web
 npm run build

-cd ../docker
+cd ../build

 # remove docker image if exists
-docker rmi -f registry.cn-shenzhen.aliyuncs.com/geekmaster/chatgpt-plus-api:$version
+docker rmi -f registry.cn-shenzhen.aliyuncs.com/geekmaster/chatgpt-plus-api:$version-$arch
 # build docker image for chatgpt-plus-go
-docker build -t registry.cn-shenzhen.aliyuncs.com/geekmaster/chatgpt-plus-api:$version -f dockerfile-api-go ../
+docker build -t registry.cn-shenzhen.aliyuncs.com/geekmaster/chatgpt-plus-api:$version-$arch -f dockerfile-api-go ../

 # build docker image for chatgpt-plus-vue
-docker rmi -f registry.cn-shenzhen.aliyuncs.com/geekmaster/chatgpt-plus-web:$version
-docker build --platform linux/amd64 -t registry.cn-shenzhen.aliyuncs.com/geekmaster/chatgpt-plus-web:$version -f dockerfile-vue ../
+docker rmi -f registry.cn-shenzhen.aliyuncs.com/geekmaster/chatgpt-plus-web:$version-$arch
+docker build --platform linux/amd64 -t registry.cn-shenzhen.aliyuncs.com/geekmaster/chatgpt-plus-web:$version-$arch -f dockerfile-vue ../

-if [ "$2" = "push" ];then
-  docker push registry.cn-shenzhen.aliyuncs.com/geekmaster/chatgpt-plus-api:$version
-  docker push registry.cn-shenzhen.aliyuncs.com/geekmaster/chatgpt-plus-web:$version
-fi
+if [ "$3" = "push" ];then
+  docker push registry.cn-shenzhen.aliyuncs.com/geekmaster/chatgpt-plus-api:$version-$arch
+  docker push registry.cn-shenzhen.aliyuncs.com/geekmaster/chatgpt-plus-web:$version-$arch
+fi
--- a/docker/dockerfile-api-go
+++ b/docker/dockerfile-api-go
@@ -4,9 +4,9 @@ FROM alpine:3.18.2
 MAINTAINER yangjian<yangjian102621@163.com>

 WORKDIR /var/www/app
-COPY ./api/bin/chatgpt-plus-amd64-linux /var/www/app
+COPY ./api/bin/chatgpt-plus-linux /var/www/app

 EXPOSE 5678

 # 容器启动时执行的命令
-CMD ["./chatgpt-plus-amd64-linux"]
+CMD ["./chatgpt-plus-linux"]
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
RockYang	da86f916d8	update changelog	2023-12-29 11:53:37 +08:00
RockYang	e7a07f7e92	feat: add router for function manager	2023-12-29 11:22:26 +08:00
RockYang	b01e6387fc	fix: restore user img_calls quota when image task run failed	2023-12-29 10:41:29 +08:00
RockYang	d86aca0f5d	merge pull request #72	2023-12-29 10:09:37 +08:00
RockYang	09414fe36a	Merge branch 'main' of github.com:yangjian102621/chatgpt-plus	2023-12-29 09:39:52 +08:00
RockYang	df0e7508db	Merge pull request #72 from Unclesimonlau/main 重新设计了移动端web页面，新增了移动端CSS，增加移动端SD绘图页面	2023-12-29 09:39:33 +08:00
RockYang	92b1f01118	merge pull request #71	2023-12-29 09:31:25 +08:00
RockYang	8fb8bd932b	Merge pull request #71 from JingHong0202/main fix: Azure Api request failure after changing the API-version parameter	2023-12-29 09:27:23 +08:00
RockYang	3f74b94784	chore: remove dead code	2023-12-29 09:02:55 +08:00
RockYang	e9467341fa	feat: function manager refactor is ready	2023-12-28 18:14:38 +08:00
JingHong	131e051ddc	Merge branch 'yangjian102621:main' into main	2023-12-27 23:33:46 +08:00
UncleSimonlau	f626fe3166	Merge branch 'main' of https://github.com/Unclesimonlau/chatgpt-plus	2023-12-26 14:19:25 +08:00
RockYang	6bc57b6132	fix: fixed bug #70 , XunFei 1.5 url version map error	2023-12-26 14:19:00 +08:00
RockYang	d972e97c88	fix: fixed bug #70 , XunFei 1.5 url version map error	2023-12-25 08:54:17 +08:00
RockYang	3991f4daec	feat: function CRUD operation is ready	2023-12-24 22:12:12 +08:00
jinghong0202	f6b567d6fc	fix: Azure Api 更换api-version参数后请求失败的问题	2023-12-24 08:36:34 +01:00
RockYang	8addba8203	feat: function add for admin page is ready	2023-12-23 22:30:27 +08:00
RockYang	3ab930a107	feat: support CDN reverse proxy for MidJourney and OpenAI API	2023-12-22 17:25:31 +08:00
RockYang	de512a5ea2	feat: add function list page in admin console	2023-12-21 18:06:09 +08:00
RockYang	113cfae2dc	opt: optimize image compress alg, add cache control for image	2023-12-21 15:00:46 +08:00
RockYang	33aebf9cb5	feat: add funcitons manger page	2023-12-21 08:58:24 +08:00
RockYang	6e58ddf681	feat: auto translate image creating prompt	2023-12-19 18:54:19 +08:00
RockYang	cae5c049e4	fix: fixed bug for HuPiPay qrcode generation. set field 'openid' of result struct to Any data type	2023-12-19 11:31:57 +08:00
RockYang	ff76e4bd89	chore: update copyright information	2023-12-18 18:19:41 +08:00
RockYang	a0a506a3c4	feat: add remove action to remove task and images for MJ and SD task list page	2023-12-18 17:44:52 +08:00
RockYang	aa5a4a9977	opt: merge RAG branch	2023-12-18 16:41:40 +08:00
RockYang	abf4f061c1	opt: make sure the Upscale and Variation task is assign to the same mj service with Image task	2023-12-18 16:34:33 +08:00
RockYang	245cd3ee1a	fix: fixed bug for mj service pool config pointer	2023-12-15 22:52:57 +08:00
RockYang	45cb29d9a0	feat: add img_calls field for recharge products	2023-12-15 16:56:56 +08:00
RockYang	d974b1ff0e	chore: update default config.toml	2023-12-15 11:23:13 +08:00
RockYang	56269170cb	opt: limit the image display size in reply component	2023-12-15 10:48:13 +08:00
RockYang	4290c4ca22	docs: update changelog	2023-12-15 09:04:02 +08:00
RockYang	7f7c8e831e	docs: add sql file	2023-12-14 17:05:51 +08:00
RockYang	8f057ca9d1	refactor: refactor stable diffusion service, add service pool support	2023-12-14 16:48:54 +08:00
RockYang	4a56621ec3	chore: add sub dir support for OSS	2023-12-13 17:02:49 +08:00
RockYang	a398e7a550	refactor: add midjourney pool implementation, add translate prompt for mj drawing	2023-12-13 16:38:27 +08:00
RockYang	96816c12ca	fix: fixed bug for aliyun OSS img url	2023-12-13 09:49:55 +08:00
RockYang	9984926f69	refactor mj service, add mj service pool support	2023-12-12 18:33:24 +08:00
RockYang	a2a6081027	opt: remove default value for stable-diffusion page	2023-12-12 09:59:20 +08:00
RockYang	5a10ed37a7	docs: update readme file	2023-12-12 09:52:28 +08:00
RockYang	1a9dd9de0b	docs: update build config.toml	2023-12-12 07:25:36 +08:00
RockYang	0dae5bef71	docs: update changelog file	2023-12-11 17:17:17 +08:00
RockYang	b4413ed726	add translate api for midjourney	2023-12-11 17:01:02 +08:00
RockYang	5e1fe88b8b	feat: add prompt translate handler	2023-12-11 06:56:00 +08:00
RockYang	91ed41b536	feat: add system config item for dall e3 generate image num	2023-12-10 17:13:25 +08:00
RockYang	024c0032eb	chore: change default params for stable diffusion	2023-12-10 14:45:22 +08:00
RockYang	4a9f7e3bce	feat: add HuPiPay payment support	2023-12-08 19:43:13 +08:00
RockYang	cf4dcc34ec	feat: add image generation API URL in chat configurations	2023-12-07 16:31:32 +08:00
RockYang	4d612c15af	docs: add arm64 build script	2023-12-07 15:44:20 +08:00
RockYang	8aec87cc02	fix: fixed bug for prompt code format, prevent xss attacks	2023-12-07 14:02:13 +08:00
RockYang	442e411cde	opt: save chat ID when the chat websocket disconnect	2023-12-07 11:07:08 +08:00
RockYang	acec0194de	feat: adjust task list component styles	2023-12-06 19:05:51 +08:00
RockYang	8557f5b94a	Merge branch 'pr_3' into dev	2023-12-06 18:54:45 +08:00
RockYang	babef8baae	feat: refactor midjourney image creating page	2023-12-06 18:54:30 +08:00
RockYang	efd4ab46f5	docs: update readme file	2023-12-06 14:44:06 +08:00
liyuwanglan	ae8239e5de	修改	2023-12-05 11:08:03 +08:00
RockYang	f0994ba457	docs: update comments	2023-11-30 17:35:56 +08:00
RockYang	dae91ed243	fix: fixed bug for upload image failed	2023-11-29 17:46:46 +08:00
RockYang	de42a428e6	opt: create new chat session when change role or model, fix bug for mobile no validate	2023-11-29 17:36:27 +08:00
RockYang	63c7041e1f	docs: update change logs	2023-11-28 15:33:30 +08:00
RockYang	b1263ddc69	docs: 添加一键部署脚本	2023-11-28 15:25:51 +08:00
RockYang	7e50e17aaf	opt: 缩略图生成算法	2023-11-28 14:50:19 +08:00
RockYang	a7265c4251	feat: 为大图片生成缩略图，加快前端图片加载速度	2023-11-28 12:04:02 +08:00
RockYang	6f39f639bd	fix: fix bug for oss image domain	2023-11-28 07:27:18 +08:00
RockYang	a7db123437	docs: update build script	2023-11-27 18:24:52 +08:00
RockYang	241c714a8b	Merge branch 'main' of github.com:yangjian102621/chatgpt-plus	2023-11-27 12:03:23 +08:00
RockYang	67ac3cfe32	feat: merge mysql and redis docker service to docker-compose.yaml file	2023-11-27 10:56:18 +08:00
RockYang	c926e0afcc	Merge pull request #55 from openjst/main 修改code显示颜色样式	2023-11-27 10:27:13 +08:00
RockYang	5bc07e6d57	docs: make a full docker-compose.yaml	2023-11-27 07:21:37 +08:00
openjst	c3666a9a71	修改code显示颜色样式	2023-11-26 23:26:08 +08:00
RockYang	23b5ffa97d	feat: implements image function replace Mj with DALL-E-3	2023-11-26 20:37:48 +08:00
RockYang	a2c7a75705	feat: add type field for api key	2023-11-24 18:05:59 +08:00
RockYang	d68f2ef12c	feat: add support for registing use force use invite code	2023-11-24 12:02:28 +08:00
RockYang	67d30353f0	opt: optimize image preview for MidJourney image list page, only preview current image not for all images	2023-11-23 17:55:12 +08:00
RockYang	4813163eac	opt: 增加中间件自动对HTTP请求的参数去掉首尾空格	2023-11-23 17:50:55 +08:00
RockYang	5c5210625e	opt: optimize styles for invitation page	2023-11-23 17:40:15 +08:00
RockYang	a4a1eec30b	feat: add invitation and promotion functions	2023-11-23 16:30:15 +08:00
RockYang	d35164506a	docs: add database sql file for v3.1.9	2023-11-23 09:58:01 +08:00
RockYang	1ed08f01ea	docs: update change log	2023-11-23 09:46:49 +08:00
RockYang	eca07ab830	docs: update change log and readme file	2023-11-23 09:14:42 +08:00
RockYang	3512715704	feat: 支持讯飞大模型 v3.0	2023-11-23 07:11:13 +08:00
RockYang	6d07881141	feat: reset password function is ready	2023-11-22 18:00:45 +08:00
RockYang	251fe626f2	feat: add copy code btn in chat page, fixed bug for code wrap in model of ChatGLM and XunFei	2023-11-22 17:00:43 +08:00
RockYang	5fee3a9288	feat: add feekback orcode in chat page	2023-11-22 12:05:58 +08:00
RockYang	9b68d8101e	fix: fixed bug for enable user vip in admin console not work	2023-11-22 11:30:58 +08:00
RockYang	cfe6f27d48	option: replace leveldb with redis in storing message code	2023-11-22 10:57:24 +08:00
RockYang	b314dd0900	Merge pull request #52 from KunMingStar/fix_migrate fix: remove dead code	2023-11-22 08:23:01 +08:00
tongkunming	950fab6374	fix: remove dead code	2023-11-21 22:18:53 +08:00
RockYang	9d1f5c42ce	chore: remove dead code	2023-11-21 19:04:53 +08:00
RockYang	a84046390b	feat: add wechat id card for closing register	2023-11-20 16:38:04 +08:00
RockYang	aa29323a8a	docs: update docs installation docs url	2023-11-17 18:42:13 +08:00
RockYang	d5617b7c3a	docs: update readme and config sample files	2023-11-16 17:20:38 +08:00
RockYang	1ef60a9e5e	fix: fix bug with missing chat context	2023-11-15 18:20:34 +08:00
RockYang	fb6e395ad8	fix: unbind event for login page when the component is unmount	2023-11-14 18:19:40 +08:00
RockYang	d9216060bc	feat: add link on logo	2023-11-14 13:50:44 +08:00
RockYang	bcaa9a92e5	fix: fix member page flex styles	2023-11-14 11:21:16 +08:00
RockYang	576adc9036	fix: deducating the user's img call quota after stable diffusion callback	2023-11-14 08:59:39 +08:00
RockYang	00de18be9a	feat: 更改 MJ 和 SD 菜单图标	2023-11-13 11:27:42 +08:00
RockYang	c61d32816a	Merge branch 'main' of github.com:yangjian102621/chatgpt-plus	2023-11-13 10:11:45 +08:00
RockYang	f3fbb0b89c	feat: 更改 MJ 和 SD 菜单图标	2023-11-13 10:11:21 +08:00
RockYang	e311a39632	chore: change xxl-job name	2023-11-12 15:39:12 +08:00
RockYang	51407abe44	opt: 优化 ItemList 组件样式，调整支付页面布局	2023-11-11 22:11:04 +08:00
RockYang	8a470b1038	docs: update change log file	2023-11-11 12:58:57 +08:00
RockYang	baddabaa16	fix: fix bug for issue 49, stable diffusion service not decrease img_calls	2023-11-11 11:00:26 +08:00
RockYang	427b434ce3	opt: 优化 ItemList 组件样式	2023-11-11 10:53:33 +08:00
RockYang	5f921965e6	feat: add order list compponent	2023-11-10 18:06:32 +08:00
RockYang	1e705c8ed5	Merge branch 'alipay'	2023-11-10 16:51:00 +08:00
RockYang	b8ae65bb30	docs: export database, update readme doc, remove useless configs for alipay	2023-11-10 16:49:07 +08:00
RockYang	321e2087ea	feat: add switch to disable xxl-job service, update readme	2023-11-10 15:22:35 +08:00
RockYang	aac60edce2	feat: 增加订单倒计时组件，自动清理过期未支付订单	2023-11-10 14:39:27 +08:00
RockYang	9dc9a6923e	feat: add system configration switch option for order pay service, support sandbox env for alipay	2023-11-09 18:28:56 +08:00
RockYang	7ca4dfe09b	feat: check if the user's chat quota is gt than current chat model required before starting a conversation	2023-11-09 16:56:44 +08:00
RockYang	c584b82ddb	Merge pull request #47 from KunMingStar/fix/sendMessage fix: 添加messages为空校验	2023-11-09 08:21:24 +08:00
RockYang	5f17ab2501	fix: fix bug for token expired with QiNiu oss upload file	2023-11-08 21:14:09 +08:00
RockYang	c84e912dd8	feat: adjust layout for user profile page	2023-11-08 18:33:26 +08:00
RockYang	2ebff2623f	feat: order payment function is ready	2023-11-08 17:48:07 +08:00
tongkunming	72418ce4d7	fix: 添加messages为空校验	2023-11-08 16:51:36 +08:00
RockYang	e221b1eed4	feat: update stable diffusion api version	2023-11-08 14:54:10 +08:00
RockYang	696306f066	feat: finish payment page layout	2023-11-07 18:10:28 +08:00
RockYang	1807d5b5d4	feat: adjust table styles for markdown	2023-11-07 12:02:16 +08:00
RockYang	85c12aa322	feat: integrated Alipay payment module	2023-11-06 17:55:46 +08:00
RockYang	da9d0dc3bc	Merge branch 'main' of github.com:yangjian102621/chatgpt-plus	2023-11-06 15:04:11 +08:00
RockYang	daaca822ac	opt:update mj api version, wrapper chat api error message as a constant	2023-11-06 15:03:56 +08:00
RockYang	59ced3f947	chore: remove invalid filepath for windows	2023-11-02 19:16:02 +08:00
RockYang	22ae7dd1f3	feat: different AI model consuming different amounts of use_calls	2023-10-26 14:38:06 +08:00
RockYang	1816e9d5cf	docs: add database full backup	2023-10-26 14:00:06 +08:00
RockYang	9be6755f65	feat: 支持文心4.0模型，不同的用户可以订阅不同的AI模型	2023-10-26 13:41:49 +08:00
RockYang	e5fb986463	feat: add system configration item to close rewarding function	2023-10-19 11:19:29 +08:00
RockYang	55d24e577e	docs: add alipay reward qrcode	2023-10-17 17:58:03 +08:00
RockYang	7f50fa3fcf	chore: set app list page as the index page	2023-10-16 14:20:44 +08:00
RockYang	fff8b78aba	update changelog file	2023-10-16 13:40:44 +08:00
RockYang	7ca1989d98	opt: adjust styles for ItemList component, cut string for chat role's hello message	2023-10-16 10:46:10 +08:00
RockYang	4595dcb7ed	feat: finish adding chat role to user function	2023-10-16 06:56:42 +08:00
RockYang	a688d3feb5	opt: adjust ItemList component styles	2023-10-15 15:47:42 +08:00
RockYang	7d1d88a32f	opt: optimize imgae loading for image wall page, loading thumb image replace source image	2023-10-13 23:07:41 +08:00
RockYang	d95c048edd	feat: create chat app list page, build the layout of page	2023-10-13 18:05:40 +08:00
RockYang	df2fc9d77c	feat: auto login when register successfully	2023-10-13 16:27:40 +08:00
RockYang	d7e815d2bb	docs: update images for readme	2023-10-13 15:55:30 +08:00
RockYang	f58b0a65f0	Merge branch 'main' into image-wall	2023-10-13 15:39:34 +08:00
RockYang	b59ad521ca	feat: image wall stable diffusion image list component is ready	2023-10-13 15:16:40 +08:00
RockYang	b47ff975b0	feat: optimize the midjourney image list styles	2023-10-13 11:14:39 +08:00
RockYang	d043a87b30	docs: update readme, database files	2023-10-13 09:59:05 +08:00
RockYang	4cae7525d9	docs: update readme file	2023-10-13 06:49:21 +08:00
RockYang	76966d2ce7	docs: update change log	2023-10-13 06:39:44 +08:00
RockYang	5a740aecb0	style: fix style for update chat title input element	2023-10-13 06:29:25 +08:00
RockYang	1ae79331e7	feat: image wall page is ready	2023-10-12 18:09:50 +08:00
RockYang	8b14e141d0	opt: close websocket connection when finish a chat call for XunFei API	2023-10-12 10:02:12 +08:00
RockYang	9cbc6c91c4	feat: XunFei ai mode api implements is ready	2023-10-11 18:17:03 +08:00
RockYang	21c3a419a5	feat: adjust package struct, put chat code the seperate 'chatimpl' package, fix bug: baidu api chat context number must be even number	2023-10-11 15:46:40 +08:00
RockYang	287fac3a89	feat: add system configration for enable/disable funciton in chat session	2023-10-11 14:35:47 +08:00
RockYang	ba206bb387	finish baidu ai model api implementation	2023-10-11 14:21:16 +08:00
RockYang	4fc01f3f7b	add baidu ai model api configrations	2023-10-10 18:19:56 +08:00
RockYang	f5ed71bcc6	docs: update readme	2023-10-09 12:13:21 +08:00