update docker image version

v4.1.5中，存在Merge冲突脚本 #237

.dockerignore

@@ -0,0 +1,6 @@
+deploy
+docs
+api/static 
+web/node_modules
+desktop
+

.github/ISSUE_TEMPLATE/1.bug.yml

@@ -0,0 +1,47 @@
+name: Bug 报告 🐛
+description: 为 geekai 提交错误报告
+labels: ['Bug']
+body:
+  - type: checkboxes
+    attributes:
+      label: ⚠️  确认 issue 是否已存在 ⚠️
+      description: 在提交 Issue 之前，请在 issue 列表搜索一下，确保你不是在提交一个重复的 issue。
+      options:
+        - label: 我已经搜索了现有的问题，没有找到跟我问题相关的问题。
+          required: true
+  - type: dropdown
+    attributes:
+      label: GPT-3 or GPT-4
+      description: 请选择你使用的 GPT 模型
+      options:
+        - GPT-3.5
+        - GPT-4
+    validations:
+      required: true
+  - type: dropdown
+    attributes:
+      label: 操作系统
+      description: 请选择你使用的操作系统
+      options:
+        - Windows
+        - Linux
+        - MacOS
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Bug 描述 📝
+      description: 请简单描述你发现的问题。
+  - type: textarea
+    attributes:
+      label: 重现步骤 🕹
+      description: |
+        **⚠️  无法重现的 issue 将会被关闭**
+  - type: textarea
+    attributes:
+      label: 你的应用配置信息
+      description: 请提供你的配置文档，**请注意数据脱敏**。
+      value: |
+        ```toml
+        把你的配置信息粘贴到这里
+        ```

.github/ISSUE_TEMPLATE/2.feature.yml

@@ -0,0 +1,26 @@
+name: 功能优化 🚀
+description: 为 geekai 提交优化建议
+labels: ['feature']
+body:
+  - type: checkboxes
+    attributes:
+      label: ⚠️  确认 issue 是否已存在 ⚠️
+      description: >
+        在提交 Issue 之前，请在 issue 列表搜索一下，确保你不是在提交一个重复的 issue。
+      options:
+        - label: 我已经搜索了现有的问题，没有找到相关 issue。
+          required: true
+  - type: textarea
+    attributes:
+      label: 功能描述 📝
+      description: |
+        描述此功能该如何工作。
+  - type: textarea
+    attributes:
+      label: 示例 🌈
+      description: 是否可以提供类似的样例，比如提供参考项目的链接或者截图。
+  - type: textarea
+    attributes:
+      label: 动机 🔦
+      description: 为什么要新增或者优化这个功能，缺少这个功能会给你或者其他用户带来什么不便？
+ 

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,24 @@
+<!-- 📢 注意：
+
+在提交的 PR 的时候请确保每个 PR 只包含一个功能修改或者优化，请不要把多个更改组合到一个 PR 提交。保持干净可管理的 git 历史记录至关重要。 为确保我们存储库的质量，我们恳请您在提交 PR 时遵守以下准则：
+
+1. 每个 PR 专注于一个单一的、具体的改进。
+2. 不要包括任何不相关或[额外]的修改。
+3. 为所做的更改提供清晰的文档和解释。
+-->
+
+### Background
+<!-- 简要概述此更改背后的基本原理。 包括相关背景、先前的讨论或相关 issue 的链接。 确保变更与项目的总体方向一致。-->
+
+### Changes
+<!-- 简要说明你改动的内容  -->
+
+### Test Plan
+<!-- 描述您如何测试此功能。 包括重现步骤、相关测试用例和任何其他相关信息-->
+
+### PR 规则验证列表
+- [ ] 确保本次 PR 只包含单一的功能修改。
+- [ ] 我已经对我的代码更改进行了充分的测试。
+- [ ] 我已经考虑了我的更改的潜在风险和缓解措施。
+- [ ] 我已经修正了相关文档 
+

.gitignore

@@ -1,15 +1,7 @@
 # Logs
 logs
 *.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-pnpm-debug.log*
-lerna-debug.log*
 
-node_modules
-src/dist
-dist-ssr
 *.local
 
 # Editor directories and files
@@ -22,8 +14,3 @@ dist-ssr
 *.njsproj
 *.sln
 *.sw?
-src/tmp
-src/bin
-src/data
-web/.env.development
-config.toml

CHANGELOG.md

@@ -0,0 +1,507 @@
+# 更新日志
+
+## v4.1.8
+
+- 功能优化：**UI 全新改版，支持主题切换**。 :rocket: :rocket: :rocket:
+- 功能新增：Gitee AI API 接口接入，目前支持 Gitee 的 SD 绘图接口，支持 Gitee 的 AI 对话接口。:rocket: :rocket: :rocket:
+- Bug 修复：修复音 Luma API 更新导致任务响应解析失败的错误
+- 功能优化：支持 Suno v4.0 模型支持
+- Bug 修复：修复 Suno 已完成任务删除失败的 错误
+- 功能新增：支持 OpenAI 实时语音通话功能，目前已经支持按次收费，支持管理员设置每次实时语音通话的算力消耗
+- 功能新增：生成提示词需要消耗算力，支持管理员设置每次生成提示词的算力消耗，防止被白嫖
+- 功能新增：DALL-E-3 绘图支持 Flux 绘图模型，支持在管理后添加 Flux,SD 等绘图模型
+- 功能优化：Markdown 支持解析 emoji 表情
+- 功能优化：当管理后台禁用了某个绘图菜单的时候，移动端绘图菜单也会同步禁用（不显示该功能）
+
+## v4.1.7
+
+- Bug 修复：手机邮箱相关的注册问题 [#IB0HS5](https://gitee.com/blackfox/geekai/issues/IB0HS5)
+- Bug 修复：音乐视频无法下载，思维导图下载后看不清文字[#IB0N2E](https://gitee.com/blackfox/geekai/issues/IB0N2E)
+- 功能优化：保存所有 AIGC 任务的原始信息，程序启动之后自动将未执行的任务加入到 redis 队列
+- 功能优化：失败的任务自动退回算力，而不需要在删除的时候再退回
+- 功能新增：支持设置一个专门的模型来翻译提示词，提供 Mate 提示词生成功能
+- Bug 修复：修复图片对话的时候，上下文不起作用的 Bug
+- 功能新增：管理后台新增批量导出兑换码功能
+
+## v4.1.6
+
+- 功能新增：**支持 OpenAI 实时语音对话功能** :rocket: :rocket: :rocket:, Beta 版，目前没有做算力计费控制，目前只有 VIP 用户可以使用。
+- 功能优化：优化 MysQL 容器配置文档，解决 MysQL 容器资源占用过高问题
+- 功能新增：管理后台增加 AI 绘图任务管理，可在管理后台浏览和删除用户的绘图任务
+- 功能新增：管理后台增加 Suno 和 Luma 任务管理功能
+- Bug 修复：修复管理后台删除兑换码报 404 错误
+- 功能优化：优化充值产品定价逻辑，可以设置原价和优惠价，**升级当前版本之后请务必要到管理后台去重新设置一下产品价格，以免造成损失！！！**，**升级当前版本之后请务必要到管理后台去重新设置一下产品价格，以免造成损失！！！**，**升级当前版本之后请务必要到管理后台去重新设置一下产品价格，以免造成损失！！！**。
+
+## v4.1.5
+
+- 功能优化：重构 websocket 组件，减少 websocket 连接数，全站共享一个 websocket 连接
+- Bug 修复：兼容手机端原生微信支付和支付宝支付渠道
+- Bug 修复：修复删除绘图任务时候因为字段长度过短导致 SQL 执行失败问题
+- 功能优化：优化 Vue 组件通信代码，使用共享数据来替换之前的事件订阅模式，效率更高一些
+- 功能优化：优化思维导图生成功果页面，优化用户体验
+
+## v4.1.4
+
+- 功能优化：用户文件列表组件增加分页功能支持
+- Bug 修复：修复用户注册失败 Bug，注册操作只弹出一次行为验证码
+- 功能优化：首次登录不需要验证码，直接登录，登录失败之后才弹出验证码
+- 功能新增：给 AI 应用（角色）增加分类，前端支持分类筛选
+- 功能优化：允许用户在聊天页面设置是否使用流式输出或者一次性输出，兼容 GPT-O1 模型。
+- 功能优化：移除 PayJS 支付渠道支持，PayJs 已经关闭注册服务，请使用其他支付方式。
+- 功能新增：新增 GeeK 易支付支付渠道，支持支付宝，微信支付，QQ 钱包，京东支付，抖音支付，Paypal 支付等支付方式
+- Bug 修复：修复注册页面 tab 组件没有自动选中问题 [#6](https://github.com/yangjian102621/geekai-plus/issues/6)
+- 功能优化：Luma 生成视频任务增加自动翻译功能
+- Bug 修复：Suno 和 Luma 任务没有判断用户算力
+- 功能新增：邮箱注册增加邮箱后缀白名单，防止使用某些垃圾邮箱注册薅羊毛
+- 功能优化：清空未支付订单时，只清空超过 15 分钟未支付的订单
+
+## v4.1.3
+
+- 功能优化：重构用户登录模块，给所有的登录组件增加行为验证码功能，支持用户绑定手机，邮箱和微信
+- 功能优化：重构找回密码模块，支持通过手机或者邮箱找回密码
+- 功能优化：管理后台给可以拖动排序的组件添加拖动图标
+- 功能优化：Suno 支持合成完整歌曲，和上传自己的音乐作品进行二次创作
+- Bug 修复：手机端角色和模型选择不生效
+- Bug 修复：用户登录过期之后聊天页面出现大量报错，需要刷新页面才能正常
+- 功能优化：优化聊天页面 Websocket 断线重连代码，提高用户体验
+- 功能优化：给算力增减服务全部加上数据库事务和同步锁
+- 功能优化：支持用户在前端对话界面选择插件
+- 功能新增：支持 Luma 文生视频功能
+
+## v4.1.2
+
+- Bug 修复：修复思维导图页面获取模型失败的问题
+- 功能优化：优化 MJ,SD,DALL-E 任务列表页面，显示失败任务的错误信息，删除失败任务可以恢复扣减算力
+- Bug 修复：修复后台拖动排序组件 Bug
+- 功能优化：更新数据库失败时候显示具体的的报错信息
+- Bug 修复：修复管理后台对话详情页内容显示异常问题
+- 功能优化：管理后台新增清空所有未支付订单的功能
+- 功能优化：给会话信息和系统配置数据加上缓存功能，减少 http 请求
+- 功能新增：移除微信机器人收款功能，增加卡密功能，支持用户使用卡密兑换算力
+
+## v4.1.1
+
+- Bug 修复：修复 GPT 模型 function call 调用后没有输出的问题
+- 功能新增：允许获取 License 授权用户可以自定义版权信息
+- 功能新增：聊天对话框支持粘贴剪切板内容来上传截图和文件
+- 功能优化：增加 session 和系统配置缓存，确保每个页面只进行一次 session 和 get system config 请求
+- 功能优化：在应用列表页面，无需先添加模型到用户工作区，可以直接使用
+- 功能新增：MJ 绘图失败的任务不会自动删除，而是会在列表页显示失败详细错误信息
+- 功能新增：允许在设置首页纯色背景，背景图片，随机背景图片三种背景模式
+- 功能新增：允许在管理后台设置首页显示的导航菜单
+- Bug 修复：修复注册页面先显示关闭注册组件，然后再显示注册组件
+- 功能新增：增加 Suno 文生歌曲功能
+- 功能优化：移除多平台模型支持，统一使用 one-api 接口形式，其他平台的模型需要通过 one-api 接口添加
+- 功能优化：在所有列表页面增加返回顶部按钮
+
+## v4.1.0
+
+- bug 修复：修复移动端修改聊天标题不生效的问题
+- Bug 修复：修复用户注册不显示用户名的问题
+- Bug 修复：修复管理后台拖动排序不生效的问题
+- 功能优化：允许用户设置自定义首页背景图片
+- 功能新增：**支持 AI 解读 PDF, Word, Excel 等文件**
+- 功能优化：优化聊天界面的用户上传文件的列表样式
+- 功能优化：优化聊天页面对话样式，支持列表样式和对话样式切换
+- 功能新增：支持微信扫码登录，未注册用户微信扫码后会自动注册并登录。移动使用微信浏览器打开可以实现无感登录。
+
+## v4.0.9
+
+- 环境升级：升级 Golang 到 go1.22.4
+- 功能增加：接入微信商户号支付渠道
+- Bug 修复：修复前端页面菜单把页面撑开，底部留白问题
+- 功能优化：聊天页面自动根据内容调整输入框的高度
+- Bug 修复：修复 Dalle 绘图失败退回算力的问题
+- 功能优化：邀请码注册时被邀请人也可以获得赠送的算力
+- 功能优化：允许设置邮件验证码的抬头
+- Bug 修复：修复免费模型不会记录聊天记录的 bug
+- Bug 修复：修复聊天输入公式显示异常的 Bug
+
+## v4.0.8
+
+- 功能优化：升级 mathjax 公式解析插件，修复公式因为图片访问限制而无法显示的问题
+- 功能优化：当数据库更新失败的时候记录错误日志
+- 功能优化：聊天输入框会随着输入内容的增多自动调整高度
+- Bug 修复：修复移动端聊天页面模型切换不生效的 Bug
+- 功能优化：给 PC 端扫码支付增加签名验证和有效期验证
+- Bug 修复：修复支付码生成 API 权限控制的问题
+- Bug 修复：模型算力设置为 0 时，不扣减用户算力，并且不记录算力消费日志
+- 功能优化：新增随机背景配置项，可以在后台设置，首页使用 Bing 壁纸作为背景图片
+- 功能新增：H5 端支持 Dalle 绘图
+
+## v4.0.7
+
+- 功能优化：添加导航菜单的时候支持框入外部链接，并支持上传自定义菜单图片
+- Bug 修复：修复弹窗等于图形验证码一直验证失败的问题
+- 功能重构：重构前端 UI 页面，增加顶部导航
+- 功能优化：优化 Vue 非父子组件之间的通信方式
+- 功能优化：优化 ItemList 组件，自动根据页面宽度计算 cols 数量
+
+## v4.0.6
+
+- Bug 修复：修复 PC 端画廊页面的瀑布流组件样式错乱问题
+- 功能新增：给思维导图增加 ToolBar，实现思维导图的放大缩小和定位
+- Bug 修复：修复思维导图不扣费的 Bug
+- Bug 修复：修复管理后台角色删除失败的 Bug
+- Bug 修复：兼容最新版秋叶 SD 懒人包的 SD API，新增 scheduler 参数
+- 功能优化：支持在管理后台配置 AI 绘图相关配置，包括 SD, MJ-PLUS, MJ-PROXY
+- Bug 修复：修复注册用户提示注册人数达到上限的 Bug
+- 功能优化：将 MJ,SD,Dall 绘画页面的任务列表全改成瀑布流组件
+
+## v4.0.5
+
+- 功能优化：已授权系统在后台显示授权信息
+- 功能优化：使用思维链提示词生成思维导图，确保生成的思维导图不会出现格式错误
+- 功能优化：优化首页登录注册页面的 UI
+- BUG 修复：修复 License 验证的逻辑漏洞
+- Bug 修复：后台添加用户的时候密码规则限制跟前台注册保持一致
+- 功能新增：管理后台支持切换主题，支持 light 和 dark 两种主题
+- 功能新增：移动端新增 DALL-E 绘画功能
+- 功能新增：新增移动端首页功能，移动端支持 light 和 dark 两种主题
+- 功能新增：移动支持免登录预览功能
+- Bug 修复：解决在同一个浏览器开启多个对话时候对话内容会相互乱串的问题
+- Bug 修复：修复部分中转 API 模型会出现第一输出的字符被淹没的 Bug
+
+## v4.0.4
+
+- Bug 修复：修复统一千问第二句不回复的问题
+- 功能优化：MJ 和 SD 任务正在执行时不更新已完成任务列表，加快页面渲染速度
+- 功能新增：Dalle AI 绘画功能实现
+- Bug 修复：修复思维导图格式乱码问题
+- 功能优化：支持使用 TLS 邮件协议，解决国内服务器无法使用 25 号端口发送邮件的问题
+- 功能新增：支持从应用列表直接和某个应用对话
+- 功能优化：优化算力日志的页面和首页的 UI
+- 功能新增：支持思维导图导出 PNG 图片下载
+
+## v4.0.3
+
+- 功能新增：允许为角色应用绑定模型，如指定某个角色只能使用某个模型
+- Bug 修复：兼容 gpt-4-turbo-2024-04-09 模型的函数调用 Bug
+- Bug 修复：修复 MidJourney 在任务超时后出现后面的任务覆盖前面任务的问题
+- 功能新增：支持上传图片和视觉模型
+- 功能优化：优化聊天页面的复制代码按钮样式乱码
+- 功能新增：增加思维导图功能，支持选择不同的对话模型来生成思维导图
+- 功能新增：支持为角色绑定对话模型，比如绑定某个角色只能用 GPT3.5 或者 GPT4
+- 功能新增：支持为模型绑定 API KEY，比如为 GPT3.5 模型绑定免费的 API KEY 给用户免费使用来引流不至于消耗你的收费 KEY。
+- 功能新增：支持管理后台 Logo 修改
+
+## 4.0.2
+
+- 功能新增：支持前端菜单可以配置
+- 功能优化：在登录和注册界面标题显示软件版本号
+- 功能优化：MJ 绘画支持 --sref 和 --cref 图片一致性参数
+- 功能优化：使用 leveldb 解决 SD 绘图进度图片预览问题
+- Bug 修复：解决因为图片上传使用相对路径而导致融图失败的问题。
+- 功能新增：手机端支持 Stable-Diffusion 绘画
+- 功能新增：管理后台登录页面增加行为验证码，防止爆破
+
+## v4.0.1
+
+- 功能重构：重构 Stable-Diffusion 绘画实现，使用 SDAPI 替换之前的 websocket 接口，SDAPI 兼容各种 stable-diffusion
+  发行版，稳定性更强一些
+- 功能优化：使用 [midjouney-proxy](https://github.com/novicezk/midjourney-proxy) 项目替换内置的原生 MidJourney API，兼容
+  MJ-Plus 中转
+- 功能新增：用户算力消费日志增加统计功能，统计一段时间内用户消费的算力
+- Bug 修复：修复 iphone 手机无法通过图形验证码的 Bug，使用滑动验证码替换
+- Bug 修复：修复手机端 MidJourney 绘画页面滚动条无法滚动的 Bug
+
+## v4.0.0
+
+非兼容版本，重大重构，引入算力概念，将系统中所有的能力（AI 对话，MJ 绘画，SD 绘画，DALL 绘画）全部使用算力来兑换。
+只要你的算力值余额不为 0，你就可以进行任何操作。比如一次 GPT3.5 对话消耗 1 个单位算力，一次 GPT4 对话消耗 10 个算力。一次 MJ
+对话消耗 15 个算力...
+
+- 功能重构：重构整体系统，全部采用算力来进行结算
+- 功能优化：SD 绘画页面采用 websocket 替换 http 轮询机制，节省带宽
+- 功能优化：移动端聊天页面图片支持预览和放大功能
+- 功能优化：MJ 和 SD 页面数据分页加载，解决一次性加载太多数据导致页面卡顿的问题
+- 功能优化：**PC 端不登录也可以预览功能，只有在发起操作的时候才需要登录**
+- 功能优化：控制台订单管理页面显示未支付订单，并提供订单删除功能
+- 功能新增：支持 H5 支付
+- 功能优化：支持数学公式的识别和美化输出
+- 功能新增：新增算力消费日志功能
+- 功能优化：整合 XXL-JOB 实现订单清理，每日算力派发，VIP 算力重置等任务
+- 功能新增：管理后台新增 7 日内新增用户和新增订单统计
+
+## v3.2.7
+
+- 功能重构：采用 Vant 重构移动页面，新增 MidJourney 功能
+- 功能优化：优化 PC 端 MidJourney 页面布局，新增融图和换脸功能
+- Bug 修复：修复 issue [
+  管理界面操作用户存在的两个问题](https://github.com/yangjian102621/chatgpt-plus/issues/117#issuecomment-1909201532)
+- 功能优化：在对话和聊天记录表中新增冗余字段 model，存储对话模型
+- Bug 修复：IPhone 手机验证码触摸事件坐标错位 [issue 144](https://github.com/yangjian102621/chatgpt-plus/issues/144)
+- Bug 修复：重新生成按钮功能失效问题
+- Bug 修复：对话输入 HTML 标签不显示的问题
+- 功能优化：gpt-4-all/gpts/midjourney-plus 支持第三方平台的 API KEY
+- 功能新增：新增删除文件功能
+- Bug 修复：解决 MJ-Plus discord 图片下载失败问题，使用第三方平台中转地址下载
+- 功能新增：后台管理新怎对话查看和检索功能
+
+## v3.2.6
+
+- 功能优化：恢复关闭注册系统配置项，管理员可以在后台关闭用户注册，只允许内部添加账号
+- 功能优化：兼用旧版本微信收款消息解析
+- 功能优化：优化订单扫码支付状态轮询功能，当关闭二维码时取消轮询，节约网络资源
+- 功能新增：新增图片发布功能，画廊只显示用户已发布的图片
+- 功能新增：后台新增配置微信客服二维码，可以上传自己的微信客服二维码
+- 功能新增：新增网站公告，可以在管理后台自定义配置
+- 功能新增：新增阿里通义千问大模型支持
+- Bug 修复：修复 MJ 放大任务失败时候 img_call 会增加的 Bug
+- 功能优化：新增虎皮椒和 PayJS 订单状态校验功能，增加安全性
+- Bug 修复：修复微信转账交易 ID 提取失败 Bug
+- 功能优化：给所有的 websocket 连接加上心跳，解决 "close 1006 (abnormal closure): unexpected EOF" Bug
+- 功能新增：新增短信宝短信平台发送平台集成
+
+## v3.2.5
+
+- 功能新增：**重磅更新！！！** 新增 MidJourney-Plus API 支持，一秒配置，开箱即用，高效稳定。
+- 功能新增：**重磅更新！！！** 新增 GPT4-ALL 和 GPTs 模型支持，你只需花几块钱，可以丝滑享受 ChatGPT-Plus 会员的所有功能，无需再订阅
+  Plus 账号了！！！
+- 功能优化：增强 markdown 图片和引用块解析。
+- 功能新增：新增用户文件管理，目前一支持上传文件跟 GPT 进行多态对话。
+- 功能优化：function call 兼用中转 API。
+- Bug 修复：修复部分已知的 Bug。
+
+## v3.2.4.1
+
+- 功能新增：新增 PayJs 支付通道
+- Bug 修复：紧急修复后台添加用户失败问题
+- Bug 修复：紧急修复使用中转 API-KEY 无法绘图的问题
+- Bug 修复：允许用户关闭手机和邮箱注册通道，移除验证码依赖
+
+## v3.2.4
+
+- 功能新增：重磅更新，支持邮箱注册
+- 功能优化：优化函数调用授权
+- 功能优化：给用户表新增 nickname 字段
+- 功能优化：管理后台给聊天角色增加启用/禁用开关
+- Bug 修复：SD 绘画出现重复扣减绘图次数
+- 功能优化：优化聊天对话导出样式，适应移动端
+- 功能新增：众筹核销可以选择兑换对话还是绘图的额度
+- Bug 修复：修复[从历史记录获取 reply 有并发风险 #92](https://github.com/yangjian102621/chatgpt-plus/issues/92)
+- Bug 修复：修复 MidJourney 绘图任务调度 Bug，为 task_id 建议唯一索引
+- 功能重构：重构了 API KEY 模块，支持为每个 API KEY 都设置不同的 API 地址，并可以单独开启是否使用代理。
+
+## 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。
+7. 功能优化：添加系统配置用来设置自定义的众筹微信收款二维码。
+8. 功能优化：优化绘画页面的弹窗样式和页面布局。
+
+## v3.1.3
+
+1. 页面重构：重后 Home 页面，拆分成聊天，MJ 绘画，SD 绘画，应用广场等多个功能菜单。
+2. 功能新增：新增 MidJourney 专业绘画页面，开放更高级的 MJ 绘画姿势。
+3. 功能优化：采用队列的方式控制绘画任务并发，简化任务回调通知逻辑，给任务回调加锁。
+4. 功能优化：精简用户表字段，删除用户名和昵称，只保留手机号。
+5. 功能优化：优化文件上传服务工厂实现，只创建激活的 Uploader 服务，节省资源。
+6. Bug 修复：修复 JWT token 有效期计算错误的 Bug。
+
+## v3.1.2
+
+1. 功能新增：新增七牛云 OSS 实现，目前已支持三种文件上传服务：Local, Minio, QiNiu OSS。
+2. 功能新增：新增桌面版，使用 electron 套壳网页版。
+3. Bug 修复：自动去除众筹核销时候转账单号中的空格，防止复制的时候多复制了空格。
+4. 功能优化：ChatPlus.vue 页面支持通过 chat_id path variable 来定位到指定的聊天。
+5. 功能优化：取消导出聊天页面的授权验证
+6. 功能优化：所有路由跳转都使用绝对路径
+
+## v3.1.1
+
+紧急修复版本，采用弹窗的方式显示验证码，解决验证码在低分辨率下被掩盖的 Bug
+
+## v3.1.0(大版本更新)
+
+1. 功能重构：将聊天模型独立拆分，以便支持多平台模型，目前已经内置支持 OPenAI，Azure 以及
+   ChatGLM，用户可以在这两个平台的模型中随意切换，体验不同的模型聊天。
+2. 功能重构：重写系统 API 授权机制，使用 JWT 替换传统的 session 会话授权，使得 API 授权变得更加灵活。
+3. 功能重构：重构文件夹上传服务，支持多种文件上传存储 handler，目前已经实现本地存储和 minio oss 存储。
+4. 功能优化：更新头像自动删除旧的图片资源。
+5. 功能优化：将应用日志在终端输出的同时存盘，方便 docker 部署查看日志。
+6. 功能新增：允许用户配置自己的 OPenAI，Azure 以及 ChatGLM API KEY。
+7. 功能优化：优化移动版的行为验证码样式，修复低分辨率显示器验证码被遮挡的 Bug
+8. 升级 gin, element-plus，redis 组件到最新版本。
+9. Bug 修复：修复若干已知的的 Bug
+
+## v3.0.7
+
+1. 聊天主界面：新增聊天引导页面，介绍产品功能
+2. 功能重构：拆分项目，将函数插件以及微信机器人，MidJourney 机器人等功能拆分新项目独立部署。
+3. 功能新增：新增 MidJourney AI 绘画支持，当识别到用户的绘画需求时，自动调用 MidJourney 绘画函数进行绘画。
+4. 功能新增：支持导出聊天记录为 PDF 文件。
+5. 功能优化：在后台 dashboard 页面新增统计今日众筹收入。
+6. 功能优化：支持用户设置默认的 GPT 模型
+7. Bug 修复：修复若干已知的的 Bug
+
+## v3.0.6
+
+1. 管理后台：新增用户名和手机号码搜索功能
+2. 管理后台：新增重置用户密码功能
+3. 管理后台：支持关闭注册功能，新增添加用户功能，适用于内部使用场景
+4. 管理后台：新增仪表盘页面，统计当天的新增用户，新增会话数据，以及 Token 消耗
+5. Bug 修复：修复注册页面验证码不显示 Bug
+6. Bug 修复：优化上下文 Token 计算算法，修复聊天上下文超出限制时循环发送消息的 Bug
+7. 功能修正：允许用户使用手机号码登录
+8. 功能优化：更新系统配置后同步更新服务端内存变量数据
+9. 功能优化：优化打包脚本，减少容器镜像大小
+
+## v3.0.5
+
+重磅功能更新！！！ 新增函数插件支持，可以轻松地接入你的第三方插件服务，ChatGPT 自动帮您调用对应的函数完成任务。
+
+1. 新增函数功能支持，全球早报，今日头条和微博热搜等插件服务，您也可以接入自己的第三方服务。
+2. 集成微信机器人模块，可以通过微信个人收款码来完成充值，无需接入微信支付功能也可以完成收款功能。
+3. 用户注册添加短信验证码功能，引入交互安全认证服务，有效防刷短信。
+4. 支持配置聊天上下文深度，精确统计每轮对话所消耗的总 TOKEN 数量。
+5. 修复已知的 Bug。
+
+## v3.0.4
+
+1. 调整项目目录结构，移除其他语言 API 目录
+2. 修复 nodejs apple M1 跨平台打包，运行报错 exec format error
+3. 增加用户 token 消耗统计功能
+
+## v3.0.3
+
+1. 优化启动参数接收处理，支持环境变量传参
+2. 修复 PC 端聊天界面出现滚动条的 Bug
+3. 修正前端 user_init_call 字段错误和用户注册初始化头像路径问题
+4. 更改 docker 构建镜像的基础镜像，改用作者的阿里云镜像，这样打包更快一些。
+
+## v3.0.2
+
+1. Feat：新增移动端的聊天和用户设置功能
+2. Fix: 修复 markdown 换行符解析的 Bug
+3. Feat: 新增头像上传功能
+4. Docs: 增加容器部署支持，支持 docker-compose 一键部署
+5. Fix: 增加全局错误处理 handler，修复业务处理异常导致服务退出的 Bug
+
+## v3.0.1
+
+1. 紧急修复前端 Home 组件路由被后台管理 Home 组件路由覆盖的 Bug。
+2. 增加 docker-compose 部署脚本
+
+## v3.0.0
+
+全新的重构版本！！！
+新版的系统前后端都进行大改动的重构，后端还是用的 Gin Web 框架，但是作者整合了 fx 自动注入框架，整个后端应用结构非常简洁，特别适合二次开发。
+另外，数据存储用 MySQL 替换了 leveldb, 因为要对 C 端，后期会涉及到很多业务数据查询统计，leveldb 已经完全不够用了。
+前后台技术架构还是基于 `Vue3 + Element-Plus` ，但是页面风格已经全部变了，几乎所有页面样式代码都重写了，希望会你是希望的风格！
+
+此次重构改版主要是为了后面功能的扩展准备了。
+
+新版本已经实现的功能如下：
+
+1. 引入用户体系，新增用户注册和登录功能。
+2. 聊天页面改版，实现了跟 ChatGPT 官方版本一致的聊天体验。
+3. 创建会话的时候可以选择聊天角色和模型。
+4. 新增聊天设置功能，用户可以导入自己的 API KEY
+5. 保存聊天记录，支持聊天上下文。
+6. 重构后台管理模块，更友好，扩展性更好的后台管理系统。
+7. 引入 ip2region 组件，记录用户的登录 IP 和地址。
+8. 支持会话搜索过滤。

LICENSE

@@ -1,21 +1,201 @@
-MIT License
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
 
-Copyright (c) 2023 RockYang
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+   1. Definitions.
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,68 +1,92 @@
-# ChatGPT-Plus
+# GeekAI
 
-基于 OpenAI API 实现的 ChatGPT Web 应用，一共分为两个版本：
+> 根据[《生成式人工智能服务管理暂行办法》](https://www.cac.gov.cn/2023-07/13/c_1690898327029107.htm)的要求，请勿对中国地区公众提供一切未经备案的生成式人工智能服务。
 
-* 通用版：交互体验跟 ChatGPT 官方一致，聊天记录保存在客户端（浏览器）
-* 角色版：内置了各种预训练好的角色，比如小红书写手，英语翻译大师，苏格拉底，孔子，乔布斯，周报助手等。轻松满足你的各种聊天和应用需求。
-聊天记录保存在云端（可以配置是否保存聊天记录）
-每个版本都有 PC 版和移动版，PC 版本的体验要略优于移动版。
+**GeekAI** 基于 AI 大语言模型 API 实现的 AI 助手全套开源解决方案，自带运营管理后台，开箱即用。集成了 OpenAI, Claude, 通义千问，Kimi，DeepSeek，Gitee AI 等多个平台的大语言模型。集成了 MidJourney 和 Stable Diffusion AI 绘画功能。
 
-**本项目基于 MIT 协议，免费开放全部源代码，可以作为个人学习使用或者商用。如需商用建议联系作者登记，仅做统计使用，优秀项目我们将在项目首页为您展示。**
+主要特性：
 
-## 项目介绍
-这一套完整的系统，包括两套前端聊天应用和一个后台管理系统。系统有用户鉴权，你可以自己使用，也可以部署直接给 C 端用户提供 ChatGPT 的服务。
+- 完整的开源系统，前端应用和后台管理系统皆可开箱即用。
+- 基于 Websocket 实现，完美的打字机体验。
+- 内置了各种预训练好的角色应用，比如小红书写手，英语翻译大师，苏格拉底，孔子，乔布斯，周报助手等。轻松满足你的各种聊天和应用需求。
+- 支持 OpenAI, Claude, 通义千问，Kimi，DeepSeek 等多个大语言模型，**支持 Gitee AI Serverless 大模型 API**。
+- 支持 Suno 文生音乐
+- 支持 MidJourney / Stable Diffusion AI 绘画集成，文生图，图生图，换脸，融图。开箱即用。
+- 支持使用个人微信二维码作为充值收费的支付渠道，无需企业支付通道。
+- 已集成支付宝支付功能，微信支付，支持多种会员套餐和点卡购买功能。
+- 集成插件 API 功能，可结合大语言模型的 function 功能开发各种强大的插件，已内置实现了微博热搜，今日头条，今日早报和 AI
+  绘画函数插件。
 
-项目的技术架构是
+### 🚀 更多功能请查看 [GeekAI-PLUS](https://github.com/yangjian102621/geekai-plus)
 
-> Go + Vue3 + element-plus
-
-后端采用的是 Go 语言开发的 Gin Web 框架。前端用的是 Vue3 + element-plus UI 框架
-
-目前已经实现了以下功能：
-1. 通用版的 ChatGPT 聊天界面和功能，聊天记录保存在客户端。
-2. 口令机制：输入口令才可以访问，支持设置口令的对话次数，有效期。
-3. 角色版的聊天界面和功能，角色设定，预设一些角色，比如程序员，客服，作家，老师，艺术家... 
-4. 保存聊天记录，支持聊天上下文。 
-5. OpenAI API 负载均衡，限制每个 API Key 每分钟之内调用次数不超过 15次，防止被封。 
-6. 支持配置多个代理，保证高可用。 
-7. 实现 markdown 语法解析和代码高亮，支持复制回复内容功能。 
-8. 后台管理功能，实现系统的动态配置，用户和角色的动态管理。
+- [x] 更友好的 UI 界面
+- [x] 支持 Dall-E 文生图功能
+- [x] 支持文生思维导图
+- [x] 支持为模型绑定指定的 API KEY，支持为角色绑定指定的模型等功能
+- [x] 支持网站 Logo 版权等信息的修改
 
 ## 功能截图
 
-### 1. 角色版PC端
-![ChatGPT Plus](docs/imgs/chat-plus.png)
+请参考 [GeekAI 项目介绍](https://docs.geekai.me/plus/info/)。
 
-![ChatGPT admin](docs/imgs/gpt.gif)
+### 体验地址
 
-### 2. 角色版移动端
-![ChatGPT Mobile](docs/imgs/chat-mobile.png)
+> 免费体验地址：[https://chat.geekai.me](https://chat.geekai.me) <br/> > **注意：请合法使用，禁止输出任何敏感、不友好或违规的内容！！！**
 
-### 3. 通用版
-![ChatGPT Free](docs/imgs/chat-free.png)
+## 快速部署
 
-### 4. 管理后台
-![ChatGPT admin](docs/imgs/admin-01.png)
+请参考文档 [**GeekAI 快速部署**](https://docs.geekai.me/plus/install/)。
 
-![ChatGPT admin](docs/imgs/admin-02.png)
+## 使用须知
 
-![ChatGPT admin](docs/imgs/admin-03.png)
+1. 本项目基于 Apache2.0 协议，免费开放全部源代码，可以作为个人学习使用或者商用。
+2. 如需商用必须保留版权信息，请自觉遵守。确保合法合规使用，在运营过程中产生的一切任何后果自负，与作者无关。
 
-### 5. 体验地址
-> 体验地址：[https://www.chat-plus.net/chat/#/free](https://www.chat-plus.net/chat/#/free) </br>
-> 口令：GeekMaster
+## 项目地址
+
+- Github 地址：https://github.com/yangjian102621/geekai
+- 码云地址：https://gitee.com/blackfox/geekai
+
+## 客户端下载
+
+目前已经支持 Win/Linux/Mac/Android 客户端，下载地址为：https://github.com/yangjian102621/geekai/releases/tag/v3.1.2
 
 ## TODOLIST
-* [ ] 让用户配置自己的 API KEY，调用自己的 API Key，将不记 Token 的使用次数
-* [ ] 嵌入 AI 绘画功能，支持根据描述词生成图片
-* [ ] 接入自己训练的开源大语言模型
-* [ ] 接入 Google 语音 API，支持语音聊天
 
-## 本地部署
-## 线上发布
+- [ ] 支持基于知识库的 AI 问答
+- [ ] 文生视频，文生歌曲功能
+- [ ] 微信支付功能
 
-## 注意事项
+## 项目文档
+
+最新的部署视频教程：[https://www.bilibili.com/video/BV1Cc411t7CX/](https://www.bilibili.com/video/BV1Cc411t7CX/)
+
+详细的部署和开发文档请参考 [**GeekAI 文档**](https://docs.geekai.me)。
+
+加微信进入微信讨论群可获取 **一键部署脚本（添加好友时请注明来自 Github!!!）。**
+
+![微信名片](https://docs.geekai.me/images/wx_card.png)
 
 ## 参与贡献
 
+个人的力量始终有限，任何形式的贡献都是欢迎的，包括但不限于贡献代码，优化文档，提交 issue 和 PR 等。
 
+#### 特此声明：由于个人时间有限，不接受在微信或者微信群给开发者提 Bug，有问题或者优化建议请提交 Issue 和 PR。非常感谢您的配合！
+
+### Commit 类型
+
+- feat: 新特性或功能
+- fix: 缺陷修复
+- docs: 文档更新
+- style: 代码风格或者组件样式更新
+- refactor: 代码重构，不引入新功能和缺陷修复
+- opt: 性能优化
+- chore: 一些不涉及到功能变动的小提交，比如修改文字表述，修改注释等
+
+## 打赏
+
+如果你觉得这个项目对你有帮助，并且情况允许的话，可以请作者喝杯咖啡，非常感谢你的支持～
+
+![打赏](https://blog.img.r9it.com/image-f02ca9eccbe93c7b1193c2623e7336ea.png)
+
+![Star History Chart](https://api.star-history.com/svg?repos=yangjian102621/geekai&type=Date)

api/.gitignore

@@ -0,0 +1,21 @@
+# Logs
+logs
+*.log
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+tmp
+bin
+data
+config.toml
+static/upload 
+storage.json 
+res/certs/wechat/apiclient_key.pem

api/Makefile

@@ -0,0 +1,15 @@
+SHELL=/usr/bin/env bash
+NAME := geekai
+all: amd64 arm64
+
+amd64:
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o bin/$(NAME)-linux main.go
+.PHONY: amd64
+
+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)-*
+.PHONY: clean

api/README.md

@@ -0,0 +1,5 @@
+# chatgpt-plus-go
+
+chatgpt-plus 后端 API Go 语言实现。技术选型采用 Gin + Mysql 架构，依赖注入使用的是 fx 框架，ORM 采用的是 GORM 框架。
+
+

api/config.sample.toml

@@ -0,0 +1,115 @@
+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=utf8mb4&collation=utf8mb4_unicode_ci&parseTime=True&loc=Local"
+StaticDir = "./static" # 静态资源的目录
+StaticUrl = "/static" # 静态资源访问 URL
+TikaHost = "http://tika:9998"
+
+[Session]
+  SecretKey = "azyehq3ivunjhbntz78isj00i4hz2mt9xtddysfucxakadq4qbfrt0b7q3lnvg80" # 注意：这个是 JWT Token 授权密钥，生产环境请务必更换
+  MaxAge = 86400
+
+[Redis] # redis 配置信息
+  Host = "localhost"
+  Port = 6379
+  Password = ""
+  DB = 0
+
+[ApiConfig] # 微博热搜，今日头条等函数服务 API 配置，此为第三方插件服务，如需使用请联系作者开通
+  ApiURL = "https://sapi.geekai.me"
+  AppId = ""
+  Token = ""
+
+
+[SMS] # Sms 配置，用于发送短信
+   Active = "Ali" # 当前启用的短信服务，默认使用阿里云
+   [SMS.Bao]
+      Username = ""
+      Password = ""
+      Domain = "api.smsbao.com"
+      Sign = "【极客学长】"
+      CodeTemplate = "您的验证码是{code}。5分钟有效，若非本人操作，请忽略本短信。"
+   [SMS.Ali]
+      AccessKey = ""
+      AccessSecret = ""
+      Product = "Dysmsapi"
+      Domain = "dysmsapi.aliyuncs.com"
+      Sign = ""
+      CodeTempId = ""
+
+[OSS] # OSS 配置，用于存储 MJ 绘画图片
+   Active = "local" # 默认使用本地文件存储引擎
+   [OSS.Local]
+     BasePath = "./static/upload" # 本地文件上传根路径
+     BaseURL = "http://localhost:5678/static/upload" # 本地上传文件前缀 URL，线上需要把 localhost 替换成自己的实际域名或者IP
+   [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
+   [OSS.AliYun]
+       Endpoint = "oss-cn-hangzhou.aliyuncs.com"
+       AccessKey = ""
+       AccessSecret = ""
+       Bucket = "chatgpt-plus"
+       SubDir = ""
+       Domain = ""
+
+[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
+
+ [SmtpConfig] # 注意，阿里云服务器禁用了25号端口，请使用 465 端口，并开启 TLS 连接
+   UseTls = false
+   Host = "smtp.163.com"
+   Port = 25
+   AppName = "极客学长"
+   From = "test@163.com" # 发件邮箱人地址
+   Password = "" #邮箱 stmp 服务授权码
+
+# 支付宝商户支付
+[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" # 支付宝根证书
+
+# 虎皮椒支付
+[HuPiPayConfig]
+  Enabled = false
+  AppId = ""
+  AppSecret = ""
+  ApiURL = "https://api.xunhupay.com"
+
+# 微信商户支付
+[WechatPayConfig]
+  Enabled = false
+  AppId = "" # 商户应用ID
+  MchId = "" # 商户号
+  SerialNo = "" # API 证书序列号
+  PrivateKey = "certs/alipay/privateKey.txt" # API 证书私钥文件路径，跟支付宝一样，把私钥文件拷贝到对应的路径，证书路径要映射到容器内
+  ApiV3Key = "" # APIV3 私钥，这个是你自己在微信支付平台设置的
+
+# 易支付
+[GeekPayConfig]
+  Enabled = true
+  AppId = "" # 商户ID
+  PrivateKey = "" # 商户私钥
+  ApiURL = "https://pay.geekai.cn"
+  Methods = ["alipay", "wxpay", "qqpay", "jdpay", "douyin", "paypal"] # 支持的支付方式

api/core/app_server.go

@@ -0,0 +1,398 @@
+package core
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"geekai/core/types"
+	"geekai/store/model"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"image"
+	"image/jpeg"
+	"io"
+	"net/http"
+	"os"
+	"runtime/debug"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/go-redis/redis/v8"
+	"github.com/golang-jwt/jwt/v5"
+	"github.com/imroc/req/v3"
+	"github.com/nfnt/resize"
+	"github.com/shirou/gopsutil/host"
+	"golang.org/x/image/webp"
+	"gorm.io/gorm"
+)
+
+type AppServer struct {
+	Debug     bool
+	Config    *types.AppConfig
+	Engine    *gin.Engine
+	SysConfig *types.SystemConfig // system config cache
+}
+
+func NewServer(appConfig *types.AppConfig) *AppServer {
+	gin.SetMode(gin.ReleaseMode)
+	gin.DefaultWriter = io.Discard
+	return &AppServer{
+		Debug:  false,
+		Config: appConfig,
+		Engine: gin.Default(),
+	}
+}
+
+func (s *AppServer) Init(debug bool, client *redis.Client) {
+	// 允许跨域请求 API
+	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)
+	//启动服务
+
+}
+
+func (s *AppServer) Run(db *gorm.DB) error {
+	// load system configs
+	var sysConfig model.Config
+	err := db.Where("marker", "system").First(&sysConfig).Error
+	if err != nil {
+		return fmt.Errorf("failed to load system config: %v", err)
+	}
+	err = utils.JsonDecode(sysConfig.Config, &s.SysConfig)
+	if err != nil {
+		return fmt.Errorf("failed to decode system config: %v", err)
+	}
+	logger.Infof("http://%s", s.Config.Listen)
+
+	// 统计安装信息
+	go func() {
+		info, err := host.Info()
+		if err == nil {
+			apiURL := fmt.Sprintf("%s/%s", s.Config.ApiConfig.ApiURL, "api/installs/push")
+			timestamp := time.Now().Unix()
+			product := "geekai-plus"
+			signStr := fmt.Sprintf("%s#%s#%d", product, info.HostID, timestamp)
+			sign := utils.Sha256(signStr)
+			resp, err := req.C().R().SetBody(map[string]interface{}{"product": product, "device_id": info.HostID, "timestamp": timestamp, "sign": sign}).Post(apiURL)
+			if err != nil {
+				logger.Errorf("register install info failed: %v", err)
+			} else {
+				logger.Debugf("register install info success: %v", resp.String())
+			}
+		}
+	}()
+
+	return s.Engine.Run(s.Config.Listen)
+}
+
+// 全局异常处理
+func errorHandler(c *gin.Context) {
+	defer func() {
+		if r := recover(); r != nil {
+			logger.Errorf("Handler Panic: %v", r)
+			debug.PrintStack()
+			c.JSON(http.StatusBadRequest, types.BizVo{Code: types.Failed, Message: types.ErrorMsg})
+			c.Abort()
+		}
+	}()
+	//加载完 defer recover，继续后续接口调用
+	c.Next()
+}
+
+// 跨域中间件设置
+func corsMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		method := c.Request.Method
+		origin := c.Request.Header.Get("Origin")
+		if origin != "" {
+			// 设置允许的请求源
+			c.Header("Access-Control-Allow-Origin", origin)
+			c.Header("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE, UPDATE")
+			//允许跨域设置可以返回其他子段，可以自定义字段
+			c.Header("Access-Control-Allow-Headers", "Authorization, Body-Length, Body-Type, Admin-Authorization,content-type")
+			// 允许浏览器（客户端）可以解析的头部 （重要）
+			c.Header("Access-Control-Expose-Headers", "Body-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers")
+			//设置缓存时间
+			c.Header("Access-Control-Max-Age", "172800")
+			//允许客户端传递校验信息比如 cookie (重要)
+			c.Header("Access-Control-Allow-Credentials", "true")
+		}
+
+		if method == http.MethodOptions {
+			c.JSON(http.StatusOK, "ok!")
+		}
+
+		defer func() {
+			if err := recover(); err != nil {
+				logger.Info("Panic info is: %v", err)
+			}
+		}()
+
+		c.Next()
+	}
+}
+
+// 用户授权验证
+func authorizeMiddleware(s *AppServer, client *redis.Client) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		clientProtocols := c.GetHeader("Sec-WebSocket-Protocol")
+		var tokenString string
+		isAdminApi := strings.Contains(c.Request.URL.Path, "/api/admin/")
+		if isAdminApi { // 后台管理 API
+			tokenString = c.GetHeader(types.AdminAuthHeader)
+		} else if clientProtocols != "" { // Websocket 连接
+			// 解析子协议内容
+			protocols := strings.Split(clientProtocols, ",")
+			if protocols[0] == "realtime" {
+				tokenString = strings.TrimSpace(protocols[1][25:])
+			} else if protocols[0] == "token" {
+				tokenString = strings.TrimSpace(protocols[1])
+			}
+		} else {
+			tokenString = c.GetHeader(types.UserAuthHeader)
+		}
+
+		if tokenString == "" {
+			if needLogin(c) {
+				resp.NotAuth(c, "You should put Authorization in request headers")
+				c.Abort()
+				return
+			} else { // 直接放行
+				c.Next()
+				return
+			}
+		}
+
+		token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
+			if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok && needLogin(c) {
+				return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
+			}
+			if isAdminApi {
+				return []byte(s.Config.AdminSession.SecretKey), nil
+			} else {
+				return []byte(s.Config.Session.SecretKey), nil
+			}
+
+		})
+
+		if err != nil && needLogin(c) {
+			resp.NotAuth(c, fmt.Sprintf("Error with parse auth token: %v", err))
+			c.Abort()
+			return
+		}
+
+		claims, ok := token.Claims.(jwt.MapClaims)
+		if !ok || !token.Valid && needLogin(c) {
+			resp.NotAuth(c, "Token is invalid")
+			c.Abort()
+			return
+		}
+
+		expr := utils.IntValue(utils.InterfaceToString(claims["expired"]), 0)
+		if expr > 0 && int64(expr) < time.Now().Unix() && needLogin(c) {
+			resp.NotAuth(c, "Token is expired")
+			c.Abort()
+			return
+		}
+
+		key := fmt.Sprintf("users/%v", claims["user_id"])
+		if isAdminApi {
+			key = fmt.Sprintf("admin/%v", claims["user_id"])
+		}
+		if _, err := client.Get(context.Background(), key).Result(); err != nil && needLogin(c) {
+			resp.NotAuth(c, "Token is not found in redis")
+			c.Abort()
+			return
+		}
+		c.Set(types.LoginUserID, claims["user_id"])
+	}
+}
+
+func needLogin(c *gin.Context) bool {
+	if c.Request.URL.Path == "/api/user/login" ||
+		c.Request.URL.Path == "/api/user/logout" ||
+		c.Request.URL.Path == "/api/user/resetPass" ||
+		c.Request.URL.Path == "/api/admin/login" ||
+		c.Request.URL.Path == "/api/admin/logout" ||
+		c.Request.URL.Path == "/api/admin/login/captcha" ||
+		c.Request.URL.Path == "/api/user/register" ||
+		c.Request.URL.Path == "/api/chat/history" ||
+		c.Request.URL.Path == "/api/chat/detail" ||
+		c.Request.URL.Path == "/api/chat/list" ||
+		c.Request.URL.Path == "/api/app/list" ||
+		c.Request.URL.Path == "/api/app/type/list" ||
+		c.Request.URL.Path == "/api/app/list/user" ||
+		c.Request.URL.Path == "/api/model/list" ||
+		c.Request.URL.Path == "/api/mj/imgWall" ||
+		c.Request.URL.Path == "/api/mj/notify" ||
+		c.Request.URL.Path == "/api/invite/hits" ||
+		c.Request.URL.Path == "/api/sd/imgWall" ||
+		c.Request.URL.Path == "/api/dall/imgWall" ||
+		c.Request.URL.Path == "/api/product/list" ||
+		c.Request.URL.Path == "/api/menu/list" ||
+		c.Request.URL.Path == "/api/markMap/client" ||
+		c.Request.URL.Path == "/api/payment/doPay" ||
+		c.Request.URL.Path == "/api/payment/payWays" ||
+		c.Request.URL.Path == "/api/suno/detail" ||
+		c.Request.URL.Path == "/api/suno/play" ||
+		c.Request.URL.Path == "/api/download" ||
+		c.Request.URL.Path == "/api/dall/models" ||
+		strings.HasPrefix(c.Request.URL.Path, "/api/test") ||
+		strings.HasPrefix(c.Request.URL.Path, "/api/payment/notify/") ||
+		strings.HasPrefix(c.Request.URL.Path, "/api/user/clogin") ||
+		strings.HasPrefix(c.Request.URL.Path, "/api/config/") ||
+		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, "/static/") {
+		return false
+	}
+	return true
+}
+
+// 统一参数处理
+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)
+			// for .webp image
+			if err != nil {
+				img, err = webp.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 {
+				logger.Error(err)
+				c.String(http.StatusInternalServerError, err.Error())
+				return
+			}
+
+			// 设置图片缓存有效期为一年 (365天)
+			c.Header("Cache-Control", "max-age=31536000, public")
+			// 直接输出图像数据流
+			c.Data(http.StatusOK, "image/jpeg", buffer.Bytes())
+			c.Abort() // 中断请求
+
+		}
+		c.Next()
+	}
+}

api/core/config.go

@@ -0,0 +1,76 @@
+package core
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"bytes"
+	"geekai/core/types"
+	logger2 "geekai/logger"
+	"geekai/utils"
+	"os"
+
+	"github.com/BurntSushi/toml"
+)
+
+var logger = logger2.GetLogger()
+
+func NewDefaultConfig() *types.AppConfig {
+	return &types.AppConfig{
+		Listen:    "0.0.0.0:5678",
+		ProxyURL:  "",
+		StaticDir: "./static",
+		StaticUrl: "http://localhost/5678/static",
+		Redis:     types.RedisConfig{Host: "localhost", Port: 6379, Password: ""},
+		Session: types.Session{
+			SecretKey: utils.RandString(64),
+			MaxAge:    86400,
+		},
+		ApiConfig: types.ApiConfig{},
+		OSS: types.OSSConfig{
+			Active: "local",
+			Local: types.LocalStorageConfig{
+				BaseURL:  "http://localhost/5678/static/upload",
+				BasePath: "./static/upload",
+			},
+		},
+		AlipayConfig: types.AlipayConfig{Enabled: false, SandBox: false},
+	}
+}
+
+func LoadConfig(configFile string) (*types.AppConfig, error) {
+	var config *types.AppConfig
+	_, err := os.Stat(configFile)
+	if err != nil {
+		logger.Info("creating new config file: ", configFile)
+		config = NewDefaultConfig()
+		config.Path = configFile
+		// save config
+		err := SaveConfig(config)
+		if err != nil {
+			return nil, err
+		}
+
+		return config, nil
+	}
+	_, err = toml.DecodeFile(configFile, &config)
+	if err != nil {
+		return nil, err
+	}
+
+	return config, err
+}
+
+func SaveConfig(config *types.AppConfig) error {
+	buf := new(bytes.Buffer)
+	encoder := toml.NewEncoder(buf)
+	if err := encoder.Encode(&config); err != nil {
+		return err
+	}
+
+	return os.WriteFile(config.Path, buf.Bytes(), 0644)
+}

api/core/types/chat.go

@@ -0,0 +1,123 @@
+package types
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+// ApiRequest API 请求实体
+type ApiRequest struct {
+	Model               string        `json:"model,omitempty"`
+	Temperature         float32       `json:"temperature"`
+	MaxTokens           int           `json:"max_tokens,omitempty"`
+	MaxCompletionTokens int           `json:"max_completion_tokens,omitempty"` // 兼容GPT O1 模型
+	Stream              bool          `json:"stream,omitempty"`
+	Messages            []interface{} `json:"messages,omitempty"`
+	Tools               []Tool        `json:"tools,omitempty"`
+	Functions           []interface{} `json:"functions,omitempty"`       // 兼容中转平台
+	ResponseFormat      interface{}   `json:"response_format,omitempty"` // 响应格式
+
+	ToolChoice string `json:"tool_choice,omitempty"`
+
+	Input      map[string]interface{} `json:"input,omitempty"`      //兼容阿里通义千问
+	Parameters map[string]interface{} `json:"parameters,omitempty"` //兼容阿里通义千问
+}
+
+type Message struct {
+	Role    string `json:"role"`
+	Content string `json:"content"`
+}
+
+type ApiResponse struct {
+	Choices []ChoiceItem `json:"choices"`
+}
+
+// ChoiceItem API 响应实体
+type ChoiceItem struct {
+	Delta        Delta  `json:"delta"`
+	FinishReason string `json:"finish_reason"`
+}
+
+type Delta struct {
+	Role         string      `json:"role"`
+	Name         string      `json:"name"`
+	Content      interface{} `json:"content"`
+	ToolCalls    []ToolCall  `json:"tool_calls,omitempty"`
+	FunctionCall struct {
+		Name      string `json:"name,omitempty"`
+		Arguments string `json:"arguments,omitempty"`
+	} `json:"function_call,omitempty"`
+}
+
+// ChatSession 聊天会话对象
+type ChatSession struct {
+	UserId   uint      `json:"user_id"`
+	ClientIP string    `json:"client_ip"` // 客户端 IP
+	ChatId   string    `json:"chat_id"`   // 客户端聊天会话 ID, 多会话模式专用字段
+	Model    ChatModel `json:"model"`     // GPT 模型
+	Start    int64     `json:"start"`     // 开始请求时间戳
+	Tools    []int     `json:"tools"`     // 工具函数列表
+	Stream   bool      `json:"stream"`    // 是否采用流式输出
+}
+
+type ChatModel struct {
+	Id          uint    `json:"id"`
+	Name        string  `json:"name"`
+	Value       string  `json:"value"`
+	Power       int     `json:"power"`
+	MaxTokens   int     `json:"max_tokens"`  // 最大响应长度
+	MaxContext  int     `json:"max_context"` // 最大上下文长度
+	Temperature float32 `json:"temperature"` // 模型温度
+	KeyId       int     `json:"key_id"`      // 绑定 API KEY
+}
+
+type ApiError struct {
+	Error struct {
+		Message string
+		Type    string
+		Param   interface{}
+		Code    string
+	}
+}
+
+const PromptMsg = "prompt" // prompt message
+const ReplyMsg = "reply"   // reply message
+
+// PowerType 算力日志类型
+type PowerType int
+
+const (
+	PowerRecharge = PowerType(1) // 充值
+	PowerConsume  = PowerType(2) // 消费
+	PowerRefund   = PowerType(3) // 任务（SD,MJ）执行失败，退款
+	PowerInvite   = PowerType(4) // 邀请奖励
+	PowerRedeem   = PowerType(5) // 众筹
+	PowerGift     = PowerType(6) // 系统赠送
+)
+
+func (t PowerType) String() string {
+	switch t {
+	case PowerRecharge:
+		return "充值"
+	case PowerConsume:
+		return "消费"
+	case PowerRefund:
+		return "退款"
+	case PowerRedeem:
+		return "兑换"
+	case PowerGift:
+		return "赠送"
+	case PowerInvite:
+		return "邀请"
+	}
+	return "其他"
+}
+
+type PowerMark int
+
+const (
+	PowerSub = PowerMark(0)
+	PowerAdd = PowerMark(1)
+)

api/core/types/client.go

@@ -0,0 +1,76 @@
+package types
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"errors"
+	"github.com/gorilla/websocket"
+	"sync"
+)
+
+var ErrConClosed = errors.New("connection Closed")
+
+// WsClient websocket client
+type WsClient struct {
+	Id     string
+	Conn   *websocket.Conn
+	lock   sync.Mutex
+	mt     int
+	Closed bool
+}
+
+func NewWsClient(conn *websocket.Conn, id string) *WsClient {
+	return &WsClient{
+		Conn:   conn,
+		Id:     id,
+		lock:   sync.Mutex{},
+		mt:     2, // fixed bug for 'Invalid UTF-8 in text frame'
+		Closed: false,
+	}
+}
+
+func (wc *WsClient) Send(message []byte) error {
+	wc.lock.Lock()
+	defer wc.lock.Unlock()
+
+	if wc.Closed {
+		return ErrConClosed
+	}
+
+	return wc.Conn.WriteMessage(wc.mt, message)
+}
+
+func (wc *WsClient) SendJson(value interface{}) error {
+	wc.lock.Lock()
+	defer wc.lock.Unlock()
+
+	if wc.Closed {
+		return ErrConClosed
+	}
+	return wc.Conn.WriteJSON(value)
+}
+
+func (wc *WsClient) Receive() (int, []byte, error) {
+	if wc.Closed {
+		return 0, nil, ErrConClosed
+	}
+
+	return wc.Conn.ReadMessage()
+}
+
+func (wc *WsClient) Close() {
+	wc.lock.Lock()
+	defer wc.lock.Unlock()
+
+	if wc.Closed {
+		return
+	}
+
+	_ = wc.Conn.Close()
+	wc.Closed = true
+}

api/core/types/config.go

@@ -0,0 +1,172 @@
+package types
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"fmt"
+)
+
+type AppConfig struct {
+	Path            string `toml:"-"`
+	Listen          string
+	Session         Session
+	AdminSession    Session
+	ProxyURL        string
+	MysqlDns        string      // mysql 连接地址
+	StaticDir       string      // 静态资源目录
+	StaticUrl       string      // 静态资源 URL
+	Redis           RedisConfig // redis 连接信息
+	ApiConfig       ApiConfig   // ChatPlus API authorization configs
+	SMS             SMSConfig   // send mobile message config
+	OSS             OSSConfig   // OSS config
+	SmtpConfig      SmtpConfig  // 邮件发送配置
+	XXLConfig       XXLConfig
+	AlipayConfig    AlipayConfig    // 支付宝支付渠道配置
+	HuPiPayConfig   HuPiPayConfig   // 虎皮椒支付配置
+	GeekPayConfig   GeekPayConfig   // GEEK 支付配置
+	WechatPayConfig WechatPayConfig // 微信支付渠道配置
+	TikaHost        string          // TiKa 服务器地址
+}
+
+type SmtpConfig struct {
+	UseTls   bool // 是否使用 TLS 发送
+	Host     string
+	Port     int
+	AppName  string // 应用名称
+	From     string // 发件人邮箱地址
+	Password string // 发件人邮箱密码
+}
+
+type ApiConfig struct {
+	ApiURL string
+	AppId  string
+	Token  string
+}
+
+type AlipayConfig struct {
+	Enabled         bool   // 是否启用该支付通道
+	SandBox         bool   // 是否沙盒环境
+	AppId           string // 应用 ID
+	UserId          string // 支付宝用户 ID
+	PrivateKey      string // 用户私钥文件路径
+	PublicKey       string // 用户公钥文件路径
+	AlipayPublicKey string // 支付宝公钥文件路径
+	RootCert        string // Root 秘钥路径
+	NotifyURL       string // 异步通知地址
+	ReturnURL       string // 同步通知地址
+}
+
+type WechatPayConfig struct {
+	Enabled    bool   // 是否启用该支付通道
+	AppId      string // 公众号的APPID,如：wxd678efh567hg6787
+	MchId      string // 直连商户的商户号，由微信支付生成并下发
+	SerialNo   string // 商户证书的证书序列号
+	PrivateKey string // 用户私钥文件路径
+	ApiV3Key   string // API V3 秘钥
+	NotifyURL  string // 异步通知地址
+}
+
+type HuPiPayConfig struct { //虎皮椒第四方支付配置
+	Enabled   bool   // 是否启用该支付通道
+	AppId     string // App ID
+	AppSecret string // app 密钥
+	ApiURL    string // 支付网关
+	NotifyURL string // 异步通知地址
+	ReturnURL string // 同步通知地址
+}
+
+// GeekPayConfig GEEK支付配置
+type GeekPayConfig struct {
+	Enabled    bool
+	AppId      string   // 商户 ID
+	PrivateKey string   // 私钥
+	ApiURL     string   // API 网关
+	NotifyURL  string   // 异步通知地址
+	ReturnURL  string   // 同步通知地址
+	Methods    []string // 支付方式
+}
+
+type XXLConfig struct { // XXL 任务调度配置
+	Enabled      bool
+	ServerAddr   string
+	ExecutorIp   string
+	ExecutorPort string
+	AccessToken  string
+	RegistryKey  string
+}
+
+type RedisConfig struct {
+	Host     string
+	Port     int
+	Password string
+	DB       int
+}
+
+// LicenseKey 存储许可证书的 KEY
+const LicenseKey = "Geek-AI-License"
+
+type License struct {
+	Key       string        `json:"key"`        // 许可证书密钥
+	MachineId string        `json:"machine_id"` // 机器码
+	ExpiredAt int64         `json:"expired_at"` // 过期时间
+	IsActive  bool          `json:"is_active"`  // 是否激活
+	Configs   LicenseConfig `json:"configs"`
+}
+
+type LicenseConfig struct {
+	UserNum int  `json:"user_num"` // 用户数量
+	DeCopy  bool `json:"de_copy"`  // 去版权
+}
+
+func (c RedisConfig) Url() string {
+	return fmt.Sprintf("%s:%d", c.Host, c.Port)
+}
+
+type SystemConfig struct {
+	Title         string `json:"title,omitempty"`           // 网站标题
+	Slogan        string `json:"slogan,omitempty"`          // 网站 slogan
+	AdminTitle    string `json:"admin_title,omitempty"`     // 管理后台标题
+	Logo          string `json:"logo,omitempty"`            // 方形 Logo
+	InitPower     int    `json:"init_power,omitempty"`      // 新用户注册赠送算力值
+	DailyPower int `json:"daily_power,omitempty"`           // 每日签到赠送算力
+	InvitePower   int    `json:"invite_power,omitempty"`    // 邀请新用户赠送算力值
+	VipMonthPower int    `json:"vip_month_power,omitempty"` // VIP 会员每月赠送的算力值
+
+	RegisterWays    []string `json:"register_ways,omitempty"`    // 注册方式：支持手机（mobile），邮箱注册（email），账号密码注册
+	EnabledRegister bool     `json:"enabled_register,omitempty"` // 是否开放注册
+
+	OrderPayTimeout int    `json:"order_pay_timeout,omitempty"` //订单支付超时时间
+	VipInfoText     string `json:"vip_info_text,omitempty"`     // 会员页面充值说明
+
+	MjPower           int `json:"mj_power,omitempty"`            // MJ 绘画消耗算力
+	MjActionPower     int `json:"mj_action_power,omitempty"`     // MJ 操作（放大，变换）消耗算力
+	SdPower           int `json:"sd_power,omitempty"`            // SD 绘画消耗算力
+	DallPower int `json:"dall_power,omitempty"`                  // DALL-E-3 绘图消耗算力
+	SunoPower         int `json:"suno_power,omitempty"`          // Suno 生成歌曲消耗算力
+	LumaPower         int `json:"luma_power,omitempty"`          // Luma 生成视频消耗算力
+	AdvanceVoicePower int `json:"advance_voice_power,omitempty"` // 高级语音对话消耗算力
+	PromptPower       int `json:"prompt_power,omitempty"`        // 生成提示词消耗算力
+
+	WechatCardURL string `json:"wechat_card_url,omitempty"` // 微信客服地址
+
+	EnableContext bool `json:"enable_context,omitempty"`
+	ContextDeep   int  `json:"context_deep,omitempty"`
+
+	SdNegPrompt string `json:"sd_neg_prompt"` // SD 默认反向提示词
+	MjMode      string `json:"mj_mode"`       // midjourney 默认的API模式，relax, fast, turbo
+
+	IndexBgURL  string `json:"index_bg_url"`  // 前端首页背景图片
+	IndexNavs   []int  `json:"index_navs"`    // 首页显示的导航菜单
+	Copyright   string `json:"copyright"`     // 版权信息
+	MarkMapText string `json:"mark_map_text"` // 思维导入的默认文本
+
+	EnabledVerify    bool     `json:"enabled_verify"`     // 是否启用验证码
+	EmailWhiteList   []string `json:"email_white_list"`   // 邮箱白名单列表
+	TranslateModelId int      `json:"translate_model_id"` // 用来做提示词翻译的大模型 id
+
+}

api/core/types/function.go

@@ -0,0 +1,27 @@
+package types
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+type ToolCall struct {
+	Type     string `json:"type"`
+	Function struct {
+		Name      string `json:"name"`
+		Arguments string `json:"arguments"`
+	} `json:"function"`
+}
+
+type Tool struct {
+	Type     string   `json:"type"`
+	Function Function `json:"function"`
+}
+
+type Function struct {
+	Name        string                 `json:"name"`
+	Description string                 `json:"description"`
+	Parameters  map[string]interface{} `json:"parameters"`
+}

api/core/types/locked_map.go

@@ -0,0 +1,70 @@
+package types
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"context"
+	"sync"
+)
+
+type MKey interface {
+	string | int | uint
+}
+type MValue interface {
+	*WsClient | *ChatSession | context.CancelFunc | []interface{}
+}
+type LMap[K MKey, T MValue] struct {
+	lock sync.RWMutex
+	data map[K]T
+}
+
+func NewLMap[K MKey, T MValue]() *LMap[K, T] {
+	return &LMap[K, T]{
+		lock: sync.RWMutex{},
+		data: make(map[K]T),
+	}
+}
+
+func (m *LMap[K, T]) Put(key K, value T) {
+	m.lock.Lock()
+	defer m.lock.Unlock()
+
+	m.data[key] = value
+}
+
+func (m *LMap[K, T]) Get(key K) T {
+	m.lock.RLock()
+	defer m.lock.RUnlock()
+
+	return m.data[key]
+}
+
+func (m *LMap[K, T]) Has(key K) bool {
+	m.lock.RLock()
+	defer m.lock.RUnlock()
+	_, ok := m.data[key]
+	return ok
+}
+
+func (m *LMap[K, T]) Delete(key K) {
+	m.lock.Lock()
+	defer m.lock.Unlock()
+
+	delete(m.data, key)
+}
+
+func (m *LMap[K, T]) ToList() []T {
+	m.lock.Lock()
+	defer m.lock.Unlock()
+
+	var s = make([]T, 0)
+	for _, v := range m.data {
+		s = append(s, v)
+	}
+	return s
+}

api/core/types/order.go

@@ -0,0 +1,39 @@
+package types
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+type OrderStatus int
+
+const (
+	OrderNotPaid     = OrderStatus(0)
+	OrderScanned     = OrderStatus(1) // 已扫码
+	OrderPaidSuccess = OrderStatus(2)
+)
+
+type OrderRemark struct {
+	Days     int     `json:"days"`  // 有效期
+	Power    int     `json:"power"` // 增加算力点数
+	Name     string  `json:"name"`  // 产品名称
+	Price    float64 `json:"price"`
+	Discount float64 `json:"discount"`
+}
+
+var PayMethods = map[string]string{
+	"alipay": "支付宝商号",
+	"wechat": "微信商号",
+	"hupi":   "虎皮椒",
+	"geek":   "易支付",
+}
+var PayNames = map[string]string{
+	"alipay": "支付宝",
+	"wxpay":  "微信支付",
+	"qqpay":  "QQ钱包",
+	"jdpay":  "京东支付",
+	"douyin": "抖音支付",
+	"paypal": "PayPal支付",
+}

api/core/types/oss.go

@@ -0,0 +1,48 @@
+package types
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+type OSSConfig struct {
+	Active string
+	Local  LocalStorageConfig
+	Minio  MiniOssConfig
+	QiNiu  QiNiuOssConfig
+	AliYun AliYunOssConfig
+}
+type MiniOssConfig struct {
+	Endpoint     string
+	AccessKey    string
+	AccessSecret string
+	Bucket       string
+	SubDir       string
+	UseSSL       bool
+	Domain       string
+}
+
+type QiNiuOssConfig struct {
+	Zone         string
+	AccessKey    string
+	AccessSecret string
+	Bucket       string
+	SubDir       string
+	Domain       string
+}
+
+type AliYunOssConfig struct {
+	Endpoint     string
+	AccessKey    string
+	AccessSecret string
+	Bucket       string
+	SubDir       string
+	Domain       string
+}
+
+type LocalStorageConfig struct {
+	BasePath string
+	BaseURL  string
+}

api/core/types/session.go

@@ -0,0 +1,20 @@
+package types
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+const LoginUserID = "LOGIN_USER_ID"
+const LoginUserCache = "LOGIN_USER_CACHE"
+
+const UserAuthHeader = "Authorization"
+const AdminAuthHeader = "Admin-Authorization"
+
+// Session configs struct
+type Session struct {
+	SecretKey string
+	MaxAge    int
+}

api/core/types/sms.go

@@ -0,0 +1,33 @@
+package types
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+type SMSConfig struct {
+	Active string
+	Ali    SmsConfigAli
+	Bao    SmsConfigBao
+}
+
+// SmsConfigAli 阿里云短信平台配置
+type SmsConfigAli struct {
+	AccessKey    string
+	AccessSecret string
+	Product      string
+	Domain       string
+	Sign         string // 短信签名
+	CodeTempId   string // 验证码短信模板 ID
+}
+
+// SmsConfigBao 短信宝平台配置
+type SmsConfigBao struct {
+	Username     string //短信宝平台注册的用户名
+	Password     string //短信宝平台注册的密码
+	Domain       string //域名
+	Sign         string // 短信签名
+	CodeTemplate string // 验证码短信模板 匹配
+}

api/core/types/task.go

@@ -0,0 +1,135 @@
+package types
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+// TaskType 任务类别
+type TaskType string
+
+func (t TaskType) String() string {
+	return string(t)
+}
+
+const (
+	TaskImage     = TaskType("image")
+	TaskBlend     = TaskType("blend")
+	TaskSwapFace  = TaskType("swapFace")
+	TaskUpscale   = TaskType("upscale")
+	TaskVariation = TaskType("variation")
+)
+
+// MjTask MidJourney 任务
+type MjTask struct {
+	Id               uint     `json:"id"`      // 任务ID
+	TaskId           string   `json:"task_id"` // 中转任务ID
+	ClientId         string   `json:"client_id"`
+	ImgArr           []string `json:"img_arr"`
+	Type             TaskType `json:"type"`
+	UserId           int      `json:"user_id"`
+	Prompt           string   `json:"prompt,omitempty"`
+	NegPrompt        string   `json:"neg_prompt,omitempty"`
+	Params           string   `json:"full_prompt"`
+	Index            int      `json:"index,omitempty"`
+	MessageId        string   `json:"message_id,omitempty"`
+	MessageHash      string   `json:"message_hash,omitempty"`
+	ChannelId        string   `json:"channel_id"`         // 渠道ID，用来区分是哪个渠道创建的任务，一个任务的 create 和 action 操作必须要再同一个渠道
+	Mode             string   `json:"mode"`               // 绘画模式，relax, fast, turbo
+	TranslateModelId int      `json:"translate_model_id"` // 提示词翻译模型ID
+}
+
+type SdTask struct {
+	Id               int          `json:"id"` // job 数据库ID
+	Type             TaskType     `json:"type"`
+	ClientId         string       `json:"client_id"`
+	UserId           int          `json:"user_id"`
+	Params           SdTaskParams `json:"params"`
+	RetryCount       int          `json:"retry_count"`
+	TranslateModelId int          `json:"translate_model_id"` // 提示词翻译模型ID
+}
+
+type SdTaskParams struct {
+	ClientId     string  `json:"client_id"` // 客户端ID
+	TaskId       string  `json:"task_id"`
+	Prompt       string  `json:"prompt"`     // 提示词
+	NegPrompt    string  `json:"neg_prompt"` // 反向提示词
+	Steps        int     `json:"steps"`      // 迭代步数，默认20
+	Sampler      string  `json:"sampler"`    // 采样器
+	Scheduler    string  `json:"scheduler"`  // 采样调度
+	FaceFix      bool    `json:"face_fix"`   // 面部修复
+	CfgScale     float32 `json:"cfg_scale"`  //引导系数，默认 7
+	Seed         int64   `json:"seed"`       // 随机数种子
+	Height       int     `json:"height"`
+	Width        int     `json:"width"`
+	HdFix        bool    `json:"hd_fix"`         // 启用高清修复
+	HdRedrawRate float32 `json:"hd_redraw_rate"` // 高清修复重绘幅度
+	HdScale      int     `json:"hd_scale"`       // 放大倍数
+	HdScaleAlg   string  `json:"hd_scale_alg"`   // 放大算法
+	HdSteps      int     `json:"hd_steps"`       // 高清修复迭代步数
+}
+
+// DallTask DALL-E task
+type DallTask struct {
+	ClientId string `json:"client_id"`
+	ModelId   uint   `json:"model_id"`
+	ModelName string `json:"model_name"`
+	Id       uint   `json:"id"`
+	UserId   uint   `json:"user_id"`
+	Prompt   string `json:"prompt"`
+	N        int    `json:"n"`
+	Quality  string `json:"quality"`
+	Size     string `json:"size"`
+	Style    string `json:"style"`
+	Power     int    `json:"power"`
+	TranslateModelId int `json:"translate_model_id"` // 提示词翻译模型ID
+}
+
+type SunoTask struct {
+	ClientId     string `json:"client_id"`
+	Id           uint   `json:"id"`
+	Channel      string `json:"channel"`
+	UserId       int    `json:"user_id"`
+	Type         int    `json:"type"`
+	Title        string `json:"title"`
+	RefTaskId    string `json:"ref_task_id,omitempty"`
+	RefSongId    string `json:"ref_song_id,omitempty"`
+	Prompt       string `json:"prompt"` // 提示词/歌词
+	Tags         string `json:"tags"`
+	Model        string `json:"model"`
+	Instrumental bool   `json:"instrumental"`          // 是否纯音乐
+	ExtendSecs   int    `json:"extend_secs,omitempty"` // 延长秒杀
+	SongId       string `json:"song_id,omitempty"`     // 合并歌曲ID
+	AudioURL     string `json:"audio_url"`             // 用户上传音频地址
+}
+
+const (
+	VideoLuma   = "luma"
+	VideoRunway = "runway"
+	VideoCog    = "cog"
+)
+
+type VideoTask struct {
+	ClientId         string      `json:"client_id"`
+	Id               uint        `json:"id"`
+	Channel          string      `json:"channel"`
+	UserId           int         `json:"user_id"`
+	Type             string      `json:"type"`
+	TaskId           string      `json:"task_id"`
+	Prompt           string      `json:"prompt"` // 提示词
+	Params           VideoParams `json:"params"`
+	TranslateModelId int         `json:"translate_model_id"` // 提示词翻译模型ID
+}
+
+type VideoParams struct {
+	PromptOptimize bool   `json:"prompt_optimize"` // 是否优化提示词
+	Loop           bool   `json:"loop"`            // 是否循环参考图
+	StartImgURL    string `json:"start_img_url"`   // 第一帧参考图地址
+	EndImgURL      string `json:"end_img_url"`     // 最后一帧参考图地址
+	Model          string `json:"model"`           // 使用哪个模型生成视频
+	Radio          string `json:"radio"`           // 视频尺寸
+	Style          string `json:"style"`           // 风格
+	Duration       int    `json:"duration"`        // 视频时长（秒）
+}

api/core/types/web.go

@@ -0,0 +1,72 @@
+package types
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+// BizVo 业务返回 VO
+type BizVo struct {
+	Code     BizCode     `json:"code"`
+	Page     int         `json:"page,omitempty"`
+	PageSize int         `json:"page_size,omitempty"`
+	Total    int         `json:"total,omitempty"`
+	Message  string      `json:"message,omitempty"`
+	Data     interface{} `json:"data,omitempty"`
+}
+
+// ReplyMessage 对话回复消息结构
+type ReplyMessage struct {
+	Channel  WsChannel   `json:"channel"`  // 消息频道，目前只有 chat
+	ClientId string      `json:"clientId"` // 客户端ID
+	Type     WsMsgType   `json:"type"`     // 消息类别
+	Body     interface{} `json:"body"`
+}
+
+type WsMsgType string
+type WsChannel string
+
+const (
+	MsgTypeText = WsMsgType("text") // 输出内容
+	MsgTypeEnd  = WsMsgType("end")
+	MsgTypeErr  = WsMsgType("error")
+	MsgTypePing = WsMsgType("ping") // 心跳消息
+
+	ChPing = WsChannel("ping")
+	ChChat = WsChannel("chat")
+	ChMj   = WsChannel("mj")
+	ChSd   = WsChannel("sd")
+	ChDall = WsChannel("dall")
+	ChSuno = WsChannel("suno")
+	ChLuma = WsChannel("luma")
+)
+
+// InputMessage 对话输入消息结构
+type InputMessage struct {
+	Channel WsChannel   `json:"channel"` // 消息频道
+	Type    WsMsgType   `json:"type"`    // 消息类别
+	Body    interface{} `json:"body"`
+}
+
+type ChatMessage struct {
+	Tools   []int  `json:"tools,omitempty"`  // 允许调用工具列表
+	Stream  bool   `json:"stream,omitempty"` // 是否采用流式输出
+	RoleId  int    `json:"role_id"`
+	ModelId int    `json:"model_id"`
+	ChatId  string `json:"chat_id"`
+	Content string `json:"content"`
+}
+
+type BizCode int
+
+const (
+	Success       = BizCode(0)
+	Failed        = BizCode(1)
+	NotAuthorized = BizCode(401) // 未授权
+
+	OkMsg       = "Success"
+	ErrorMsg    = "系统开小差了"
+	InvalidArgs = "非法参数或参数解析失败"
+)

api/go.mod

@@ -0,0 +1,125 @@
+module geekai
+
+go 1.21
+
+toolchain go1.22.4
+
+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/gin-gonic/gin v1.9.1
+	github.com/go-redis/redis/v8 v8.11.5
+	github.com/golang-jwt/jwt/v5 v5.0.0
+	github.com/gorilla/websocket v1.5.0
+	github.com/imroc/req/v3 v3.37.2
+	github.com/lionsoul2014/ip2region/binding/golang v0.0.0-20230415042440-a5e3d8259ae0
+	github.com/minio/minio-go/v7 v7.0.62
+	github.com/pkoukk/tiktoken-go v0.1.1-0.20230418101013-cae809389480
+	github.com/qiniu/go-sdk/v7 v7.17.1
+	github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
+	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/go-pay/gopay v1.5.101
+	github.com/google/go-tika v0.3.1
+	github.com/microcosm-cc/bluemonday v1.0.26
+	github.com/shirou/gopsutil v3.21.11+incompatible
+	github.com/shopspring/decimal v1.3.1
+	github.com/syndtr/goleveldb v1.0.0
+	golang.org/x/image v0.15.0
+)
+
+require (
+	github.com/aymerick/douceur v0.2.0 // indirect
+	github.com/go-ole/go-ole v1.2.6 // indirect
+	github.com/go-pay/crypto v0.0.1 // indirect
+	github.com/go-pay/errgroup v0.0.2 // indirect
+	github.com/go-pay/util v0.0.2 // indirect
+	github.com/go-pay/xlog v0.0.2 // indirect
+	github.com/go-pay/xtime v0.0.2 // indirect
+	github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db // indirect
+	github.com/gorilla/css v1.0.0 // indirect
+	github.com/gravityblast/fresh v0.0.0-20240621171608-8d1fef547a99 // indirect
+	github.com/howeyc/fsnotify v0.9.0 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/pilu/config v0.0.0-20131214182432-3eb99e6c0b9a // indirect
+	github.com/pilu/fresh v0.0.0-20240621171608-8d1fef547a99 // indirect
+	github.com/tklauser/go-sysconf v0.3.13 // indirect
+	github.com/tklauser/numcpus v0.7.0 // indirect
+	github.com/yusufpapurcu/wmi v1.2.4 // indirect
+	go.uber.org/mock v0.4.0 // indirect
+)
+
+require (
+	github.com/andybalholm/brotli v1.0.4 // indirect
+	github.com/bytedance/sonic v1.9.1 // indirect
+	github.com/cespare/xxhash/v2 v2.2.0 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
+	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
+	github.com/dlclark/regexp2 v1.8.1 // indirect
+	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
+	github.com/gaukas/godicttls v0.0.3 // indirect
+	github.com/go-basic/ipv4 v1.0.0 // indirect
+	github.com/go-sql-driver/mysql v1.7.0 // indirect
+	github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/google/pprof v0.0.0-20230602150820-91b7bce49751 // indirect
+	github.com/google/uuid v1.3.0 // indirect
+	github.com/hashicorp/errwrap v1.1.0 // indirect
+	github.com/hashicorp/go-multierror v1.1.1 // indirect
+	github.com/jinzhu/inflection v1.0.0 // indirect
+	github.com/jinzhu/now v1.1.5 // indirect
+	github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af // indirect
+	github.com/klauspost/compress v1.16.7 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.5 // indirect
+	github.com/minio/md5-simd v1.1.2 // indirect
+	github.com/minio/sha256-simd v1.0.1 // indirect
+	github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646
+	github.com/onsi/ginkgo/v2 v2.10.0 // indirect
+	github.com/opentracing/opentracing-go v1.2.1-0.20220228012449-10b1cf09e00b // indirect
+	github.com/pelletier/go-toml/v2 v2.0.8 // indirect
+	github.com/quic-go/qpack v0.4.0 // indirect
+	github.com/quic-go/quic-go v0.45.0 // indirect
+	github.com/refraction-networking/utls v1.3.2 // indirect
+	github.com/rs/xid v1.5.0 // indirect
+	github.com/sirupsen/logrus v1.9.3 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	go.uber.org/dig v1.16.1 // indirect
+	golang.org/x/arch v0.3.0 // indirect
+	golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 // indirect
+	golang.org/x/mod v0.17.0 // indirect
+	golang.org/x/net v0.25.0 // indirect
+	golang.org/x/sync v0.7.0 // indirect
+	golang.org/x/text v0.15.0 // indirect
+	golang.org/x/time v0.5.0 // indirect
+	golang.org/x/tools v0.21.0 // indirect
+	google.golang.org/protobuf v1.33.0 // indirect
+	gopkg.in/ini.v1 v1.67.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)
+
+require (
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.14.0 // 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
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/ugorji/go/codec v1.2.11 // indirect
+	go.uber.org/atomic v1.9.0 // indirect
+	go.uber.org/fx v1.19.3
+	go.uber.org/multierr v1.6.0 // indirect
+	golang.org/x/crypto v0.23.0
+	golang.org/x/sys v0.20.0 // indirect
+	gorm.io/gorm v1.25.1
+)

api/go.sum

@@ -0,0 +1,366 @@
+github.com/BurntSushi/toml v1.1.0 h1:ksErzDEI1khOiGPgpwuI7x2ebx/uXQNw7xJpn9Eq1+I=
+github.com/BurntSushi/toml v1.1.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
+github.com/aliyun/alibaba-cloud-sdk-go v1.62.405 h1:cKNFQmeCQFN0WNfjScKoVrGi7vXxTVbkCvCqSrOf+P4=
+github.com/aliyun/alibaba-cloud-sdk-go v1.62.405/go.mod h1:Api2AkmMgGaSUAhmk76oaFObkoeCPc/bKAqcyplPODs=
+github.com/aliyun/aliyun-oss-go-sdk v2.2.9+incompatible h1:Sg/2xHwDrioHpxTN6WMiwbXTpUEinBpHsN7mG21Rc2k=
+github.com/aliyun/aliyun-oss-go-sdk v2.2.9+incompatible/go.mod h1:T/Aws4fEfogEE9v+HPhhw+CntffsBHJ8nXQCwKr0/g8=
+github.com/andybalholm/brotli v1.0.4 h1:V7DdXeJtZscaqfNuAdSRuRFzuiKlHSC/Zh3zl9qY3JY=
+github.com/andybalholm/brotli v1.0.4/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
+github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
+github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
+github.com/benbjohnson/clock v1.3.0 h1:ip6w0uFQkncKQ979AypyG0ER7mqUSBdKLOgAle/AT8A=
+github.com/benbjohnson/clock v1.3.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
+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=
+github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
+github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 h1:qSGYFH7+jGhDF8vLC+iwCD4WpbV1EBDSzWkJODFLams=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
+github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
+github.com/dlclark/regexp2 v1.8.1 h1:6Lcdwya6GjPUNsBct8Lg/yRPwMhABj269AAzdGSiR+0=
+github.com/dlclark/regexp2 v1.8.1/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
+github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
+github.com/gaukas/godicttls v0.0.3 h1:YNDIf0d9adcxOijiLrEzpfZGAkNwLRzPaG6OjU7EITk=
+github.com/gaukas/godicttls v0.0.3/go.mod h1:l6EenT4TLWgTdwslVb4sEMOCf7Bv0JAK67deKr9/NCI=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.9.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-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
+github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
+github.com/go-pay/crypto v0.0.1 h1:B6InT8CLfSLc6nGRVx9VMJRBBazFMjr293+jl0lLXUY=
+github.com/go-pay/crypto v0.0.1/go.mod h1:41oEIvHMKbNcYlWUlRWtsnC6+ASgh7u29z0gJXe5bes=
+github.com/go-pay/errgroup v0.0.2 h1:5mZMdm0TDClDm2S3G0/sm0f8AuQRtz0dOrTHDR9R8Cc=
+github.com/go-pay/errgroup v0.0.2/go.mod h1:0+4b8mvFMS71MIzsaC+gVvB4x37I93lRb2dqrwuU8x8=
+github.com/go-pay/gopay v1.5.101 h1:rVb+sfv6hiQtknAlZnTTLvU27NvFJ4p0yglN/vPpGXI=
+github.com/go-pay/gopay v1.5.101/go.mod h1:AW4Yj8jDZX9BM1/GTLTY1Gy5SHjiq8kQvG5sBTN2sxI=
+github.com/go-pay/util v0.0.2 h1:goJ4f6kNY5zzdtg1Cj8oWC+Cw7bfg/qq2rJangMAb9U=
+github.com/go-pay/util v0.0.2/go.mod h1:qM8VbyF1n7YAPZBSJONSPMPsPedhUTktewUAdf1AjPg=
+github.com/go-pay/xlog v0.0.2 h1:kUg5X8/5VZAPDg1J5eGjA3MG0/H5kK6Ew0dW/Bycsws=
+github.com/go-pay/xlog v0.0.2/go.mod h1:DbjMADPK4+Sjxj28ekK9goqn4zmyY4hql/zRiab+S9E=
+github.com/go-pay/xtime v0.0.2 h1:7YR4/iuELsEHpJ6LUO0SVK80hQxDO9MLCfuVYIiTCRM=
+github.com/go-pay/xtime v0.0.2/go.mod h1:W1yRbJaSt4CSBcdAtLBQ8xajiN/Pl5hquGczUcUE9xE=
+github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
+github.com/go-playground/locales v0.14.0/go.mod h1:sawfccIbzZTqEDETgFXqTho0QybSa7l++s0DH+LDiLs=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
+github.com/go-playground/universal-translator v0.18.0/go.mod h1:UvRDBj+xPUEGrFYl+lu/H90nyDXpg0fqeB/AQUGNTVA=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.8.0/go.mod h1:9JhgTzTaE31GZDpH/HSvHiRJrJ3iKAgqqH0Bl/Ocjdk=
+github.com/go-playground/validator/v10 v10.14.0 h1:vgvQWe3XCz3gIeFDm/HnTIbj6UGmg/+t63MyGU2n5js=
+github.com/go-playground/validator/v10 v10.14.0/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
+github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI=
+github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo=
+github.com/go-sql-driver/mysql v1.7.0 h1:ueSltNNllEqE3qcWBTD0iQd3IpL/6U+mJxLkazJ7YPc=
+github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
+github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
+github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/goji/httpauth v0.0.0-20160601135302-2da839ab0f4d/go.mod h1:nnjvkQ9ptGaCkuDUx6wNykzzlUixGxvkme+H/lnzb+A=
+github.com/golang-jwt/jwt/v5 v5.0.0 h1:1n1XNM9hk7O9mnQoNBGolZvzebBQ7p93ULHRc28XJUE=
+github.com/golang-jwt/jwt/v5 v5.0.0/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
+github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db h1:woRePGFeVFfLKN/pOkfl+p/TAqKOfFu+7KPlMVpok/w=
+github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-tika v0.3.1 h1:l+jr10hDhZjcgxFRfcQChRLo1bPXQeLFluMyvDhXTTA=
+github.com/google/go-tika v0.3.1/go.mod h1:DJh5N8qxXIl85QkqmXknd+PeeRkUOTbvwyYf7ieDz6c=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/pprof v0.0.0-20230602150820-91b7bce49751 h1:hR7/MlvK23p6+lIw9SN1TigNLn9ZnF3W4SYRKq2gAHs=
+github.com/google/pprof v0.0.0-20230602150820-91b7bce49751/go.mod h1:Jh3hGz2jkYak8qXPD19ryItVnUgpgeqzdkY/D0EaeuA=
+github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/css v1.0.0 h1:BQqNyPTi50JCFMTw/b67hByjMVXZRwGha6wxVGkeihY=
+github.com/gorilla/css v1.0.0/go.mod h1:Dn721qIggHpt4+EFCcTLTU/vk5ySda2ReITrtgBl60c=
+github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
+github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/gravityblast/fresh v0.0.0-20240621171608-8d1fef547a99 h1:A6qlLfihaWef15viqtecCz4XknZcgjgD7mEuhu7bHEc=
+github.com/gravityblast/fresh v0.0.0-20240621171608-8d1fef547a99/go.mod h1:ukFDwXV66bGV7JnfyxFKuKiVp4zH4orBKXML+VCSrhI=
+github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/errwrap v1.1.0 h1:OxrOeh75EUXMY8TBjag2fzXGZ40LB6IKw45YeGUDY2I=
+github.com/hashicorp/errwrap v1.1.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
+github.com/hashicorp/go-multierror v1.1.1 h1:H5DkEtf6CXdFp0N0Em5UCwQpXMWke8IA0+lD48awMYo=
+github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9/fmwbPZ6JB6eMoM=
+github.com/howeyc/fsnotify v0.9.0 h1:0gtV5JmOKH4A8SsFxG2BczSeXWWPvcMT0euZt5gDAxY=
+github.com/howeyc/fsnotify v0.9.0/go.mod h1:41HzSPxBGeFRQKEEwgh49TRw/nKBsYZ2cF1OzPjSJsA=
+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=
+github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
+github.com/jinzhu/now v1.1.4/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
+github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
+github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
+github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af h1:pmfjZENx5imkbgOkpRUYLnmbU7UEFbjtDA2hxJ1ichM=
+github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
+github.com/json-iterator/go v1.1.5/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/klauspost/compress v1.16.7 h1:2mk3MPGNzKyxErAw8YaohYh69+pa4sIQSC0fPGCFR9I=
+github.com/klauspost/compress v1.16.7/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
+github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.5 h1:0E5MSMDEoAulmXNFquVs//DdoomxaoTY1kUhbc/qbZg=
+github.com/klauspost/cpuid/v2 v2.2.5/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
+github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0=
+github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY=
+github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
+github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
+github.com/lionsoul2014/ip2region/binding/golang v0.0.0-20230415042440-a5e3d8259ae0 h1:LgmjED/yQILqmUED4GaXjrINWe7YJh4HM6z2EvEINPs=
+github.com/lionsoul2014/ip2region/binding/golang v0.0.0-20230415042440-a5e3d8259ae0/go.mod h1:C5LA5UO2ZXJrLaPLYtE1wUJMiyd/nwWaCO5cw/2pSHs=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/microcosm-cc/bluemonday v1.0.26 h1:xbqSvqzQMeEHCqMi64VAs4d8uy6Mequs3rQ0k/Khz58=
+github.com/microcosm-cc/bluemonday v1.0.26/go.mod h1:JyzOCs9gkyQyjs+6h10UEVSe02CGwkhd72Xdqh78TWs=
+github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34=
+github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM=
+github.com/minio/minio-go/v7 v7.0.62 h1:qNYsFZHEzl+NfH8UxW4jpmlKav1qUAgfY30YNRneVhc=
+github.com/minio/minio-go/v7 v7.0.62/go.mod h1:Q6X7Qjb7WMhvG65qKf4gUgA5XaiSox74kR1uAEjxRS4=
+github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM=
+github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/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/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
+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 v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
+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/onsi/gomega v1.27.7/go.mod h1:1p8OOlwo2iUUDsHnOrjE5UKYJ+e3W8eQ3qSlRahPmr4=
+github.com/opentracing/opentracing-go v1.2.1-0.20220228012449-10b1cf09e00b h1:FfH+VrHHk6Lxt9HdVS0PXzSXFyS2NbZKXv33FYPol0A=
+github.com/opentracing/opentracing-go v1.2.1-0.20220228012449-10b1cf09e00b/go.mod h1:AC62GU6hc0BrNm+9RK9VSiwa/EUe1bkIeFORAMcHvJU=
+github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ=
+github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4=
+github.com/pilu/config v0.0.0-20131214182432-3eb99e6c0b9a h1:Tg4E4cXPZSZyd3H1tJlYo6ZreXV0ZJvE/lorNqyw1AU=
+github.com/pilu/config v0.0.0-20131214182432-3eb99e6c0b9a/go.mod h1:9Or9aIl95Kp43zONcHd5tLZGKXb9iLx0pZjau0uJ5zg=
+github.com/pilu/fresh v0.0.0-20240621171608-8d1fef547a99 h1:+X7Gb40b5Bl3v5+3MiGK8Jhemjp65MHc+nkVCfq1Yfc=
+github.com/pilu/fresh v0.0.0-20240621171608-8d1fef547a99/go.mod h1:2LLTtftTZSdAPR/iVyennXZDLZOYzyDn+T0qEKJ8eSw=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkoukk/tiktoken-go v0.1.1-0.20230418101013-cae809389480 h1:IFhPCcB0/HtnEN+ZoUGDT55YgFCymbFJ15kXqs3nv5w=
+github.com/pkoukk/tiktoken-go v0.1.1-0.20230418101013-cae809389480/go.mod h1:BijIqAP84FMYC4XbdJgjyMpiSjusU8x0Y0W9K2t0QtU=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/qiniu/dyn v1.3.0/go.mod h1:E8oERcm8TtwJiZvkQPbcAh0RL8jO1G0VXJMW3FAWdkk=
+github.com/qiniu/go-sdk/v7 v7.17.1 h1:UoQv7fBKtzAiD1qZPIvTy62Se48YLKxcCYP9nAwWMa0=
+github.com/qiniu/go-sdk/v7 v7.17.1/go.mod h1:nqoYCNo53ZlGA521RvRethvxUDvXKt4gtYXOwye868w=
+github.com/qiniu/x v1.10.5/go.mod h1:03Ni9tj+N2h2aKnAz+6N0Xfl8FwMEDRC2PAlxekASDs=
+github.com/quic-go/qpack v0.4.0 h1:Cr9BXA1sQS2SmDUWjSofMPNKmvF6IiIfDRmgU0w1ZCo=
+github.com/quic-go/qpack v0.4.0/go.mod h1:UZVnYIfi5GRk+zI9UMaCPsmZ2xKJP7XBUvVyT1Knj9A=
+github.com/quic-go/quic-go v0.45.0 h1:OHmkQGM37luZITyTSu6ff03HP/2IrwDX1ZFiNEhSFUE=
+github.com/quic-go/quic-go v0.45.0/go.mod h1:1dLehS7TIR64+vxGR70GDcatWTOtMX2PUtnKsjbTurI=
+github.com/refraction-networking/utls v1.3.2 h1:o+AkWB57mkcoW36ET7uJ002CpBWHu0KPxi6vzxvPnv8=
+github.com/refraction-networking/utls v1.3.2/go.mod h1:fmoaOww2bxzzEpIKOebIsnBvjQpqP7L2vcm/9KUfm/E=
+github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
+github.com/rogpeppe/go-internal v1.8.0 h1:FCbCCtXNOY3UtUuHUYaghJg4y7Fd14rXifAYUAtL9R8=
+github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE=
+github.com/rs/xid v1.5.0 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc=
+github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
+github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=
+github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
+github.com/shopspring/decimal v1.3.1 h1:2Usl1nmF/WZucqkFZhnfFYxxxu8LG21F6nPQBE5gKV8=
+github.com/shopspring/decimal v1.3.1/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o=
+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/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=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.2/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/tklauser/go-sysconf v0.3.13 h1:GBUpcahXSpR2xN01jhkNAbTLRk2Yzgggk8IM08lq3r4=
+github.com/tklauser/go-sysconf v0.3.13/go.mod h1:zwleP4Q4OehZHGn4CYZDipCgg9usW5IJePewFCGVEa0=
+github.com/tklauser/numcpus v0.7.0 h1:yjuerZP127QG9m5Zh/mSO4wqurYil27tHrqwRoRjpr4=
+github.com/tklauser/numcpus v0.7.0/go.mod h1:bb6dMVcj8A42tSE7i32fsIUCbQNllK5iDguyOZRUzAY=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
+github.com/uber/jaeger-client-go v2.30.0+incompatible h1:D6wyKGCecFaSRUpo8lCVbaOOb6ThwMmTEbhRwtKR97o=
+github.com/uber/jaeger-client-go v2.30.0+incompatible/go.mod h1:WVhlPFC8FDjOFMMWRy2pZqQJSXxYSwNYOkTr/Z6d3Kk=
+github.com/uber/jaeger-lib v2.4.1+incompatible h1:td4jdvLcExb4cBISKIpHuGoVXh+dVKhn2Um6rjCsSsg=
+github.com/uber/jaeger-lib v2.4.1+incompatible/go.mod h1:ComeNDZlWwrWnDv8aPp0Ba6+uUTzImX/AauajbLI56U=
+github.com/ugorji/go/codec v1.2.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.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
+github.com/yusufpapurcu/wmi v1.2.4/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
+go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
+go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+go.uber.org/dig v1.16.1 h1:+alNIBsl0qfY0j6epRubp/9obgtrObRAc5aD+6jbWY8=
+go.uber.org/dig v1.16.1/go.mod h1:557JTAUZT5bUK0SvCwikmLPPtdQhfvLYtO5tJgQSbnk=
+go.uber.org/fx v1.19.3 h1:YqMRE4+2IepTYCMOvXqQpRa+QAVdiSTnsHU4XNWBceA=
+go.uber.org/fx v1.19.3/go.mod h1:w2HrQg26ql9fLK7hlBiZ6JsRUKV+Lj/atT1KCjT8YhM=
+go.uber.org/goleak v1.1.11 h1:wy28qYRKZgnJTxGxvye5/wgWr1EKjmUDGYox5mGlRlI=
+go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
+go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU=
+go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc=
+go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4=
+go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
+go.uber.org/zap v1.23.0 h1:OjGQ5KQDEUawVHxNwQgPpiypGHOxo2mNZsOqTak4fFY=
+go.uber.org/zap v1.23.0/go.mod h1:D+nX8jyLsMHMYrln8A0rJjFt/T/9/bGgIhAqxv5URuY=
+golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/arch v0.3.0 h1:02VY4/ZcO/gBOH6PUaoiptASxtXU10jazRCP865E97k=
+golang.org/x/arch v0.3.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.1.0/go.mod h1:RecgLatLF4+eUMCP1PoPZQb+cVrJcOPbHkTkbkB9sbw=
+golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
+golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
+golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
+golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
+golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 h1:vr/HnozRka3pE4EsMEg1lgkXJkTFJCVUX+S/ZT6wYzM=
+golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc=
+golang.org/x/image v0.15.0 h1:kOELfmgrmJlw4Cdb7g/QGuB3CvDrXbqEIww/pNtNBm8=
+golang.org/x/image v0.15.0/go.mod h1:HUYqC05R2ZcZ3ejNQsIHQDQiwWM4JBqmm6MKANTp4LE=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA=
+golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.1.0/go.mod h1:Cx3nUiGt4eDBEyega/BKRp+/AlGL8hYe7U9odMt2Cco=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
+golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
+golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
+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-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+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-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.1.0/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
+golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
+golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
+golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
+golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/tools v0.21.0 h1:qc0xYgIbsSDt9EyWz05J5wfa7LOVW0YTLOXrqdLAWIw=
+golang.org/x/tools v0.21.0/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
+google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/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=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gorm.io/driver/mysql v1.4.7 h1:rY46lkCspzGHn7+IYsNpSfEv9tA+SU4SkkB+GFX125Y=
+gorm.io/driver/mysql v1.4.7/go.mod h1:SxzItlnT1cb6e1e4ZRpgJN2VYtcqJgqnHxWr4wsP8oc=
+gorm.io/gorm v1.23.8/go.mod h1:l2lP/RyAtc1ynaTjFksBde/O8v9oOGIApu2/xRitmZk=
+gorm.io/gorm v1.25.1 h1:nsSALe5Pr+cM3V1qwwQ7rOkw+6UeLrX5O4v3llhHa64=
+gorm.io/gorm v1.25.1/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=

api/handler/admin/admin_handler.go

@@ -0,0 +1,289 @@
+package admin
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"context"
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/handler"
+	logger2 "geekai/logger"
+	"geekai/service"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"github.com/go-redis/redis/v8"
+	"github.com/golang-jwt/jwt/v5"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+var logger = logger2.GetLogger()
+
+const SuperManagerID = 1
+
+type ManagerHandler struct {
+	handler.BaseHandler
+	redis   *redis.Client
+	captcha *service.CaptchaService
+}
+
+func NewAdminHandler(app *core.AppServer, db *gorm.DB, client *redis.Client, captcha *service.CaptchaService) *ManagerHandler {
+	return &ManagerHandler{
+		BaseHandler: handler.BaseHandler{DB: db, App: app},
+		redis:       client,
+		captcha:     captcha,
+	}
+}
+
+// Login 登录
+func (h *ManagerHandler) Login(c *gin.Context) {
+	var data struct {
+		Username string `json:"username"`
+		Password string `json:"password"`
+		Key      string `json:"key,omitempty"`
+		Dots     string `json:"dots,omitempty"`
+		X        int    `json:"x,omitempty"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if h.App.SysConfig.EnabledVerify {
+		var check bool
+		if data.X != 0 {
+			check = h.captcha.SlideCheck(data)
+		} else {
+			check = h.captcha.Check(data)
+		}
+		if !check {
+			resp.ERROR(c, "请先完人机验证")
+			return
+		}
+	}
+
+	var manager model.AdminUser
+	res := h.DB.Model(&model.AdminUser{}).Where("username = ?", data.Username).First(&manager)
+	if res.Error != nil {
+		resp.ERROR(c, "请检查用户名或者密码是否填写正确")
+		return
+	}
+	password := utils.GenPassword(data.Password, manager.Salt)
+	if password != manager.Password {
+		resp.ERROR(c, "用户名或密码错误")
+		return
+	}
+
+	// 超级管理员默认是ID:1
+	if manager.Id != SuperManagerID && manager.Status == false {
+		resp.ERROR(c, "该用户已被禁止登录，请联系超级管理员")
+		return
+	}
+
+	// 创建 token
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
+		"user_id": manager.Id,
+		"expired": time.Now().Add(time.Second * time.Duration(h.App.Config.Session.MaxAge)).Unix(),
+	})
+	tokenString, err := token.SignedString([]byte(h.App.Config.AdminSession.SecretKey))
+	if err != nil {
+		resp.ERROR(c, "Failed to generate token, "+err.Error())
+		return
+	}
+	// 保存到 redis
+	key := fmt.Sprintf("admin/%d", manager.Id)
+	if _, err := h.redis.Set(context.Background(), key, tokenString, 0).Result(); err != nil {
+		resp.ERROR(c, "error with save token: "+err.Error())
+		return
+	}
+
+	// 更新最后登录时间和IP
+	manager.LastLoginIp = c.ClientIP()
+	manager.LastLoginAt = time.Now().Unix()
+	h.DB.Updates(&manager)
+
+	var result = struct {
+		IsSuperAdmin bool   `json:"is_super_admin"`
+		Token        string `json:"token"`
+	}{
+		IsSuperAdmin: manager.Id == 1,
+		Token:        tokenString,
+	}
+
+	resp.SUCCESS(c, result)
+}
+
+// Logout 注销
+func (h *ManagerHandler) Logout(c *gin.Context) {
+	key := h.GetUserKey(c)
+	if _, err := h.redis.Del(c, key).Result(); err != nil {
+		logger.Error("error with delete session: ", err)
+	} else {
+		resp.SUCCESS(c)
+	}
+}
+
+// Session 会话检测
+func (h *ManagerHandler) Session(c *gin.Context) {
+	id := h.GetLoginUserId(c)
+	key := fmt.Sprintf("admin/%d", id)
+	if _, err := h.redis.Get(context.Background(), key).Result(); err != nil {
+		resp.NotAuth(c)
+		return
+	}
+	var manager model.AdminUser
+	res := h.DB.Where("id", id).First(&manager)
+	if res.Error != nil {
+		resp.NotAuth(c)
+		return
+	}
+
+	resp.SUCCESS(c, manager)
+}
+
+// List 数据列表
+func (h *ManagerHandler) List(c *gin.Context) {
+	var items []model.AdminUser
+	res := h.DB.Find(&items)
+	if res.Error != nil {
+		resp.ERROR(c, res.Error.Error())
+		return
+	}
+
+	users := make([]vo.AdminUser, 0)
+	for _, item := range items {
+		var u vo.AdminUser
+		err := utils.CopyObject(item, &u)
+		if err != nil {
+			continue
+		}
+		u.Id = item.Id
+		u.CreatedAt = item.CreatedAt.Unix()
+		users = append(users, u)
+	}
+
+	resp.SUCCESS(c, users)
+
+}
+
+func (h *ManagerHandler) Save(c *gin.Context) {
+	var data struct {
+		Username string `json:"username"`
+		Password string `json:"password"`
+		Status   bool   `json:"status"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	var user model.AdminUser
+	res := h.DB.Where("username", data.Username).First(&user)
+	if res.Error == nil {
+		resp.ERROR(c, "用户名已存在")
+		return
+	}
+
+	// 生成密码
+	salt := utils.RandString(8)
+	password := utils.GenPassword(data.Password, salt)
+	res = h.DB.Save(&model.AdminUser{
+		Username: data.Username,
+		Password: password,
+		Salt:     salt,
+		Status:   data.Status,
+	})
+	if res.Error != nil {
+		resp.ERROR(c, "failed with update database")
+		return
+	}
+
+	resp.SUCCESS(c)
+}
+
+// Remove 删除管理员
+func (h *ManagerHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+	if id <= 0 {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if id == SuperManagerID {
+		resp.ERROR(c, "超级管理员不能删除")
+		return
+	}
+
+	res := h.DB.Where("id", id).Delete(&model.AdminUser{})
+	if res.Error != nil {
+		resp.ERROR(c, res.Error.Error())
+		return
+	}
+
+	resp.SUCCESS(c)
+}
+
+// Enable 启用/禁用
+func (h *ManagerHandler) 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.AdminUser{}).Where("id", data.Id).UpdateColumn("status", data.Enabled)
+	if res.Error != nil {
+		resp.ERROR(c, res.Error.Error())
+		return
+	}
+	resp.SUCCESS(c)
+}
+
+// ResetPass 重置密码
+func (h *ManagerHandler) ResetPass(c *gin.Context) {
+	id := h.GetLoginUserId(c)
+	if id != SuperManagerID {
+		resp.ERROR(c, "只有超级管理员能够进行该操作")
+		return
+	}
+
+	var data struct {
+		Id       int    `json:"id"`
+		Password string `json:"password"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	var user model.AdminUser
+	res := h.DB.Where("id", data.Id).First(&user)
+	if res.Error != nil {
+		resp.ERROR(c, res.Error.Error())
+		return
+	}
+
+	password := utils.GenPassword(data.Password, user.Salt)
+	user.Password = password
+	res = h.DB.Updates(&user)
+	if res.Error != nil {
+		resp.ERROR(c, res.Error.Error())
+		return
+	}
+
+	resp.SUCCESS(c)
+}

api/handler/admin/api_key_handler.go

@@ -0,0 +1,139 @@
+package admin
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/handler"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type ApiKeyHandler struct {
+	handler.BaseHandler
+}
+
+func NewApiKeyHandler(app *core.AppServer, db *gorm.DB) *ApiKeyHandler {
+	return &ApiKeyHandler{BaseHandler: handler.BaseHandler{DB: db, App: app}}
+}
+
+func (h *ApiKeyHandler) Save(c *gin.Context) {
+	var data struct {
+		Id       uint   `json:"id"`
+		Name     string `json:"name"`
+		Type     string `json:"type"`
+		Value    string `json:"value"`
+		ApiURL   string `json:"api_url"`
+		Enabled  bool   `json:"enabled"`
+		ProxyURL string `json:"proxy_url"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	apiKey := model.ApiKey{}
+	if data.Id > 0 {
+		h.DB.Find(&apiKey, data.Id)
+	}
+	apiKey.Value = data.Value
+	apiKey.Type = data.Type
+	apiKey.ApiURL = data.ApiURL
+	apiKey.Enabled = data.Enabled
+	apiKey.ProxyURL = data.ProxyURL
+	apiKey.Name = data.Name
+	err := h.DB.Save(&apiKey).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	var keyVo vo.ApiKey
+	err = utils.CopyObject(apiKey, &keyVo)
+	if err != nil {
+		resp.ERROR(c, fmt.Sprintf("拷贝数据失败：%v", err))
+		return
+	}
+	keyVo.Id = apiKey.Id
+	keyVo.CreatedAt = apiKey.CreatedAt.Unix()
+	resp.SUCCESS(c, keyVo)
+}
+
+func (h *ApiKeyHandler) List(c *gin.Context) {
+	status := h.GetBool(c, "status")
+	t := h.GetTrim(c, "type")
+
+	session := h.DB.Session(&gorm.Session{})
+	if status {
+		session = session.Where("enabled", true)
+	}
+	if t != "" {
+		session = session.Where("type", t)
+	}
+
+	var items []model.ApiKey
+	var keys = make([]vo.ApiKey, 0)
+	res := session.Find(&items)
+	if res.Error == nil {
+		for _, item := range items {
+			var key vo.ApiKey
+			err := utils.CopyObject(item, &key)
+			if err == nil {
+				key.Id = item.Id
+				key.CreatedAt = item.CreatedAt.Unix()
+				key.UpdatedAt = item.UpdatedAt.Unix()
+				keys = append(keys, key)
+			} else {
+				logger.Error(err)
+			}
+		}
+	}
+	resp.SUCCESS(c, keys)
+}
+
+func (h *ApiKeyHandler) 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
+	}
+
+	err := h.DB.Model(&model.ApiKey{}).Where("id = ?", data.Id).Update(data.Filed, data.Value).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	resp.SUCCESS(c)
+}
+
+func (h *ApiKeyHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+	if id <= 0 {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	err := h.DB.Where("id", id).Delete(&model.ApiKey{}).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	resp.SUCCESS(c)
+}

api/handler/admin/chat_app_handler.go

@@ -0,0 +1,182 @@
+package admin
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/handler"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type ChatAppHandler struct {
+	handler.BaseHandler
+}
+
+func NewChatAppHandler(app *core.AppServer, db *gorm.DB) *ChatAppHandler {
+	return &ChatAppHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
+}
+
+// Save 创建或者更新某个角色
+func (h *ChatAppHandler) Save(c *gin.Context) {
+	var data vo.ChatRole
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	var role model.ChatRole
+	err := utils.CopyObject(data, &role)
+	if err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	role.Id = data.Id
+	if data.CreatedAt > 0 {
+		role.CreatedAt = time.Unix(data.CreatedAt, 0)
+	} else {
+		err = h.DB.Where("marker", data.Key).First(&role).Error
+		if err == nil {
+			resp.ERROR(c, fmt.Sprintf("角色 %s 已存在", data.Key))
+			return
+		}
+	}
+	err = h.DB.Save(&role).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	// 填充 ID 数据
+	data.Id = role.Id
+	data.CreatedAt = role.CreatedAt.Unix()
+	resp.SUCCESS(c, data)
+}
+
+func (h *ChatAppHandler) List(c *gin.Context) {
+	var items []model.ChatRole
+	var roles = make([]vo.ChatRole, 0)
+	res := h.DB.Order("sort_num ASC").Find(&items)
+	if res.Error != nil {
+		resp.ERROR(c, "No data found")
+		return
+	}
+
+	// initialize model mane for role
+	modelIds := make([]int, 0)
+	typeIds := make([]int, 0)
+	for _, v := range items {
+		if v.ModelId > 0 {
+			modelIds = append(modelIds, v.ModelId)
+		}
+		if v.Tid > 0 {
+			typeIds = append(typeIds, v.Tid)
+		}
+	}
+
+	modelNameMap := make(map[int]string)
+	typeNameMap := make(map[int]string)
+	if len(modelIds) > 0 {
+		var models []model.ChatModel
+		tx := h.DB.Where("id IN ?", modelIds).Find(&models)
+		if tx.Error == nil {
+			for _, m := range models {
+				modelNameMap[int(m.Id)] = m.Name
+			}
+		}
+	}
+	if len(typeIds) > 0 {
+		var appTypes []model.AppType
+		tx := h.DB.Where("id IN ?", typeIds).Find(&appTypes)
+		if tx.Error == nil {
+			for _, m := range appTypes {
+				typeNameMap[int(m.Id)] = m.Name
+			}
+		}
+	}
+
+	for _, v := range items {
+		var role vo.ChatRole
+		err := utils.CopyObject(v, &role)
+		if err == nil {
+			role.Id = v.Id
+			role.CreatedAt = v.CreatedAt.Unix()
+			role.UpdatedAt = v.UpdatedAt.Unix()
+			role.ModelName = modelNameMap[role.ModelId]
+			role.TypeName = typeNameMap[role.Tid]
+			roles = append(roles, role)
+		}
+	}
+
+	resp.SUCCESS(c, roles)
+}
+
+// Sort 更新角色排序
+func (h *ChatAppHandler) 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 {
+		err := h.DB.Model(&model.ChatRole{}).Where("id = ?", id).Update("sort_num", data.Sorts[index]).Error
+		if err != nil {
+			resp.ERROR(c, err.Error())
+			return
+		}
+	}
+
+	resp.SUCCESS(c)
+}
+
+func (h *ChatAppHandler) 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
+	}
+
+	err := h.DB.Model(&model.ChatRole{}).Where("id = ?", data.Id).Update(data.Filed, data.Value).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	resp.SUCCESS(c)
+}
+
+func (h *ChatAppHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+
+	if id <= 0 {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	res := h.DB.Where("id", id).Delete(&model.ChatRole{})
+	if res.Error != nil {
+		logger.Error("error with update database：", res.Error)
+		resp.ERROR(c, "删除失败！")
+		return
+	}
+	resp.SUCCESS(c)
+}

api/handler/admin/chat_app_type_handler.go

@@ -0,0 +1,148 @@
+package admin
+
+import (
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/handler"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type ChatAppTypeHandler struct {
+	handler.BaseHandler
+}
+
+func NewChatAppTypeHandler(app *core.AppServer, db *gorm.DB) *ChatAppTypeHandler {
+	return &ChatAppTypeHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
+}
+
+// Save 创建或更新App类型
+func (h *ChatAppTypeHandler) Save(c *gin.Context) {
+	var data struct {
+		Id      uint   `json:"id"`
+		Name    string `json:"name"`
+		Enabled bool   `json:"enabled"`
+		Icon    string `json:"icon"`
+		SortNum int    `json:"sort_num"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if data.Id == 0 { // for add
+		err := h.DB.Where("name", data.Name).First(&model.AppType{}).Error
+		if err == nil {
+			resp.ERROR(c, "当前分类已经存在")
+			return
+		}
+		err = h.DB.Create(&model.AppType{
+			Name:    data.Name,
+			Icon:    data.Icon,
+			Enabled: data.Enabled,
+			SortNum: data.SortNum,
+		}).Error
+		if err != nil {
+			resp.ERROR(c, err.Error())
+			return
+		}
+	} else { // for update
+		err := h.DB.Model(&model.AppType{}).Where("id", data.Id).Updates(map[string]interface{}{
+			"name":    data.Name,
+			"icon":    data.Icon,
+			"enabled": data.Enabled,
+		}).Error
+		if err != nil {
+			resp.ERROR(c, err.Error())
+			return
+		}
+	}
+	resp.SUCCESS(c)
+}
+
+// List 获取App类型列表
+func (h *ChatAppTypeHandler) List(c *gin.Context) {
+	var items []model.AppType
+	var appTypes = make([]vo.AppType, 0)
+	err := h.DB.Order("sort_num ASC").Find(&items).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	for _, v := range items {
+		var appType vo.AppType
+		err = utils.CopyObject(v, &appType)
+		if err != nil {
+			continue
+		}
+		appType.Id = v.Id
+		appType.CreatedAt = v.CreatedAt.Unix()
+		appTypes = append(appTypes, appType)
+	}
+
+	resp.SUCCESS(c, appTypes)
+}
+
+// Remove 删除App类型
+func (h *ChatAppTypeHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+
+	if id <= 0 {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	err := h.DB.Where("id", id).Delete(&model.AppType{}).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	resp.SUCCESS(c)
+}
+
+// Enable 启用|禁用
+func (h *ChatAppTypeHandler) 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
+	}
+
+	err := h.DB.Model(&model.AppType{}).Where("id", data.Id).UpdateColumn("enabled", data.Enabled).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	resp.SUCCESS(c)
+}
+
+// Sort 更新排序
+func (h *ChatAppTypeHandler) 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 {
+		err := h.DB.Model(&model.AppType{}).Where("id", id).Update("sort_num", data.Sorts[index]).Error
+		if err != nil {
+			resp.ERROR(c, err.Error())
+			return
+		}
+	}
+
+	resp.SUCCESS(c)
+}

api/handler/admin/chat_handler.go

@@ -0,0 +1,268 @@
+package admin
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/handler"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type ChatHandler struct {
+	handler.BaseHandler
+}
+
+func NewChatHandler(app *core.AppServer, db *gorm.DB) *ChatHandler {
+	return &ChatHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
+}
+
+type chatItemVo struct {
+	Username  string      `json:"username"`
+	UserId    uint        `json:"user_id"`
+	ChatId    string      `json:"chat_id"`
+	Title     string      `json:"title"`
+	Role      vo.ChatRole `json:"role"`
+	Model     string      `json:"model"`
+	Token     int         `json:"token"`
+	CreatedAt int64       `json:"created_at"`
+	MsgNum    int         `json:"msg_num"` // 消息数量
+}
+
+func (h *ChatHandler) List(c *gin.Context) {
+	var data struct {
+		Title    string   `json:"title"`
+		UserId   uint     `json:"user_id"`
+		Model    string   `json:"model"`
+		CreateAt []string `json:"created_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.Title != "" {
+		session = session.Where("title LIKE ?", "%"+data.Title+"%")
+	}
+	if data.UserId > 0 {
+		session = session.Where("user_id = ?", data.UserId)
+	}
+	if data.Model != "" {
+		session = session.Where("model = ?", data.Model)
+	}
+	if len(data.CreateAt) == 2 {
+		start := utils.Str2stamp(data.CreateAt[0] + " 00:00:00")
+		end := utils.Str2stamp(data.CreateAt[1] + " 00:00:00")
+		session = session.Where("created_at >= ? AND created_at <= ?", start, end)
+	}
+
+	var total int64
+	session.Model(&model.ChatItem{}).Count(&total)
+	var items []model.ChatItem
+	var list = make([]chatItemVo, 0)
+	offset := (data.Page - 1) * data.PageSize
+	res := session.Order("id DESC").Offset(offset).Limit(data.PageSize).Find(&items)
+	if res.Error == nil {
+		userIds := make([]uint, 0)
+		chatIds := make([]string, 0)
+		roleIds := make([]uint, 0)
+		for _, item := range items {
+			userIds = append(userIds, item.UserId)
+			chatIds = append(chatIds, item.ChatId)
+			roleIds = append(roleIds, item.RoleId)
+		}
+		var messages []model.ChatMessage
+		var users []model.User
+		var roles []model.ChatRole
+		h.DB.Where("chat_id IN ?", chatIds).Find(&messages)
+		h.DB.Where("id IN ?", userIds).Find(&users)
+		h.DB.Where("id IN ?", roleIds).Find(&roles)
+
+		tokenMap := make(map[string]int)
+		userMap := make(map[uint]string)
+		msgMap := make(map[string]int)
+		roleMap := make(map[uint]vo.ChatRole)
+		for _, msg := range messages {
+			tokenMap[msg.ChatId] += msg.Tokens
+			msgMap[msg.ChatId] += 1
+		}
+		for _, user := range users {
+			userMap[user.Id] = user.Username
+		}
+		for _, r := range roles {
+			var roleVo vo.ChatRole
+			err := utils.CopyObject(r, &roleVo)
+			if err != nil {
+				continue
+			}
+			roleMap[r.Id] = roleVo
+		}
+		for _, item := range items {
+			list = append(list, chatItemVo{
+				UserId:    item.UserId,
+				Username:  userMap[item.UserId],
+				ChatId:    item.ChatId,
+				Title:     item.Title,
+				Model:     item.Model,
+				Token:     tokenMap[item.ChatId],
+				MsgNum:    msgMap[item.ChatId],
+				Role:      roleMap[item.RoleId],
+				CreatedAt: item.CreatedAt.Unix(),
+			})
+		}
+	}
+	resp.SUCCESS(c, vo.NewPage(total, data.Page, data.PageSize, list))
+}
+
+type chatMessageVo struct {
+	Id        uint   `json:"id"`
+	UserId    uint   `json:"user_id"`
+	Username  string `json:"username"`
+	Content   string `json:"content"`
+	Type      string `json:"type"`
+	Model     string `json:"model"`
+	Token     int    `json:"token"`
+	Icon      string `json:"icon"`
+	CreatedAt int64  `json:"created_at"`
+}
+
+// Messages 读取聊天记录列表
+func (h *ChatHandler) Messages(c *gin.Context) {
+	var data struct {
+		UserId   uint     `json:"user_id"`
+		Content  string   `json:"content"`
+		Model    string   `json:"model"`
+		CreateAt []string `json:"created_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.Content != "" {
+		session = session.Where("content LIKE ?", "%"+data.Content+"%")
+	}
+	if data.UserId > 0 {
+		session = session.Where("user_id = ?", data.UserId)
+	}
+	if data.Model != "" {
+		session = session.Where("model = ?", data.Model)
+	}
+	if len(data.CreateAt) == 2 {
+		start := utils.Str2stamp(data.CreateAt[0] + " 00:00:00")
+		end := utils.Str2stamp(data.CreateAt[1] + " 00:00:00")
+		session = session.Where("created_at >= ? AND created_at <= ?", start, end)
+	}
+
+	var total int64
+	session.Model(&model.ChatMessage{}).Count(&total)
+	var items []model.ChatMessage
+	var list = make([]chatMessageVo, 0)
+	offset := (data.Page - 1) * data.PageSize
+	res := session.Order("id DESC").Offset(offset).Limit(data.PageSize).Find(&items)
+	if res.Error == nil {
+		userIds := make([]uint, 0)
+		for _, item := range items {
+			userIds = append(userIds, item.UserId)
+		}
+		var users []model.User
+		h.DB.Where("id IN ?", userIds).Find(&users)
+		userMap := make(map[uint]string)
+		for _, user := range users {
+			userMap[user.Id] = user.Username
+		}
+		for _, item := range items {
+			list = append(list, chatMessageVo{
+				Id:        item.Id,
+				UserId:    item.UserId,
+				Username:  userMap[item.UserId],
+				Content:   item.Content,
+				Model:     item.Model,
+				Token:     item.Tokens,
+				Icon:      item.Icon,
+				Type:      item.Type,
+				CreatedAt: item.CreatedAt.Unix(),
+			})
+		}
+	}
+	resp.SUCCESS(c, vo.NewPage(total, data.Page, data.PageSize, list))
+}
+
+// History 获取聊天历史记录
+func (h *ChatHandler) History(c *gin.Context) {
+	chatId := c.Query("chat_id") // 会话 ID
+	var items []model.ChatMessage
+	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)
+}
+
+// RemoveChat 删除对话
+func (h *ChatHandler) RemoveChat(c *gin.Context) {
+	chatId := h.GetTrim(c, "chat_id")
+	if chatId == "" {
+		resp.ERROR(c, "请传入 ChatId")
+		return
+	}
+
+	tx := h.DB.Begin()
+	// 删除聊天记录
+	res := tx.Unscoped().Debug().Where("chat_id = ?", chatId).Delete(&model.ChatMessage{})
+	if res.Error != nil {
+		resp.ERROR(c, "failed to remove chat message")
+		return
+	}
+
+	// 删除对话
+	res = tx.Unscoped().Where("chat_id = ?", chatId).Delete(model.ChatItem{})
+	if res.Error != nil {
+		tx.Rollback() // 回滚
+		resp.ERROR(c, "failed to remove chat")
+		return
+	}
+
+	tx.Commit()
+	resp.SUCCESS(c)
+}
+
+// RemoveMessage 删除聊天记录
+func (h *ChatHandler) RemoveMessage(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+	err := h.DB.Unscoped().Where("id = ?", id).Delete(&model.ChatMessage{}).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	resp.SUCCESS(c)
+}

api/handler/admin/chat_model_handler.go

@@ -0,0 +1,194 @@
+package admin
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/handler"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type ChatModelHandler struct {
+	handler.BaseHandler
+}
+
+func NewChatModelHandler(app *core.AppServer, db *gorm.DB) *ChatModelHandler {
+	return &ChatModelHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
+}
+
+func (h *ChatModelHandler) Save(c *gin.Context) {
+	var data struct {
+		Id          uint    `json:"id"`
+		Name        string  `json:"name"`
+		Value       string  `json:"value"`
+		Enabled     bool    `json:"enabled"`
+		SortNum     int     `json:"sort_num"`
+		Open        bool    `json:"open"`
+		Platform    string  `json:"platform"`
+		Power       int     `json:"power"`
+		MaxTokens   int     `json:"max_tokens"`  // 最大响应长度
+		MaxContext  int     `json:"max_context"` // 最大上下文长度
+		Temperature float32 `json:"temperature"` // 模型温度
+		KeyId       int     `json:"key_id,omitempty"`
+		CreatedAt   int64   `json:"created_at"`
+		Type        string  `json:"type"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	item := model.ChatModel{}
+	// 更新
+	if data.Id > 0 {
+		h.DB.Where("id", data.Id).First(&item)
+	}
+
+	item.Name = data.Name
+	item.Value = data.Value
+	item.Enabled = data.Enabled
+	item.SortNum = data.SortNum
+	item.Open = data.Open
+	item.Power = data.Power
+	item.MaxTokens = data.MaxTokens
+	item.MaxContext = data.MaxContext
+	item.Temperature = data.Temperature
+	item.KeyId = data.KeyId
+	item.Type = data.Type
+	var res *gorm.DB
+	if data.Id > 0 {
+		res = h.DB.Save(&item)
+	} else {
+		res = h.DB.Create(&item)
+	}
+	if res.Error != nil {
+		logger.Error("error with update database：", res.Error)
+		resp.ERROR(c, res.Error.Error())
+		return
+	}
+
+	var itemVo vo.ChatModel
+	err := utils.CopyObject(item, &itemVo)
+	if err != nil {
+		resp.ERROR(c, "数据拷贝失败！")
+		return
+	}
+	itemVo.Id = item.Id
+	itemVo.CreatedAt = item.CreatedAt.Unix()
+	resp.SUCCESS(c, itemVo)
+}
+
+// List 模型列表
+func (h *ChatModelHandler) List(c *gin.Context) {
+	session := h.DB.Session(&gorm.Session{})
+	enable := h.GetBool(c, "enable")
+	name := h.GetTrim(c, "name")
+	if enable {
+		session = session.Where("enabled", enable)
+	}
+	if name != "" {
+		session = session.Where("name LIKE ?", name+"%")
+	}
+	var items []model.ChatModel
+	var cms = make([]vo.ChatModel, 0)
+	res := session.Order("sort_num ASC").Find(&items)
+	if res.Error != nil {
+		resp.SUCCESS(c, cms)
+		return
+	}
+
+	// initialize key name
+	keyIds := make([]int, 0)
+	for _, v := range items {
+		keyIds = append(keyIds, v.KeyId)
+	}
+	var keys []model.ApiKey
+	keyMap := make(map[uint]string)
+	h.DB.Where("id IN ?", keyIds).Find(&keys)
+	for _, v := range keys {
+		keyMap[v.Id] = v.Name
+	}
+	for _, item := range items {
+		var cm vo.ChatModel
+		err := utils.CopyObject(item, &cm)
+		if err == nil {
+			cm.Id = item.Id
+			cm.CreatedAt = item.CreatedAt.Unix()
+			cm.UpdatedAt = item.UpdatedAt.Unix()
+			cm.KeyName = keyMap[uint(item.KeyId)]
+			cms = append(cms, cm)
+		} else {
+			logger.Error(err)
+		}
+	}
+	resp.SUCCESS(c, cms)
+}
+
+func (h *ChatModelHandler) Set(c *gin.Context) {
+	var data struct {
+		Id    uint        `json:"id"`
+		Filed string      `json:"filed"`
+		Value interface{} `json:"value"`
+	}
+
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	err := h.DB.Model(&model.ChatModel{}).Where("id = ?", data.Id).Update(data.Filed, data.Value).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	resp.SUCCESS(c)
+}
+
+func (h *ChatModelHandler) Sort(c *gin.Context) {
+	var data struct {
+		Ids   []uint `json:"ids"`
+		Sorts []int  `json:"sorts"`
+	}
+
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	for index, id := range data.Ids {
+		err := h.DB.Model(&model.ChatModel{}).Where("id = ?", id).Update("sort_num", data.Sorts[index]).Error
+		if err != nil {
+			resp.ERROR(c, err.Error())
+			return
+		}
+	}
+
+	resp.SUCCESS(c)
+}
+
+func (h *ChatModelHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+	if id <= 0 {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	err := h.DB.Where("id = ?", id).Delete(&model.ChatModel{}).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	resp.SUCCESS(c)
+}

api/handler/admin/config_handler.go

@@ -0,0 +1,209 @@
+package admin
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/handler"
+	"geekai/service"
+	"geekai/store"
+	"geekai/store/model"
+	"geekai/utils"
+	"geekai/utils/resp"
+
+	"github.com/gin-gonic/gin"
+	"github.com/shirou/gopsutil/host"
+	"gorm.io/gorm"
+)
+
+type ConfigHandler struct {
+	handler.BaseHandler
+	levelDB        *store.LevelDB
+	licenseService *service.LicenseService
+}
+
+func NewConfigHandler(app *core.AppServer, db *gorm.DB, levelDB *store.LevelDB, licenseService *service.LicenseService) *ConfigHandler {
+	return &ConfigHandler{
+		BaseHandler:    handler.BaseHandler{App: app, DB: db},
+		levelDB:        levelDB,
+		licenseService: licenseService,
+	}
+}
+
+func (h *ConfigHandler) Update(c *gin.Context) {
+	var data struct {
+		Key    string `json:"key"`
+		Config struct {
+			types.SystemConfig
+			Content string `json:"content,omitempty"`
+			Updated bool   `json:"updated,omitempty"`
+		} `json:"config"`
+		ConfigBak types.SystemConfig `json:"config_bak,omitempty"`
+	}
+
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	// ONLY authorized user can change the copyright
+	if (data.Key == "system" && data.Config.Copyright != data.ConfigBak.Copyright) && !h.licenseService.GetLicense().Configs.DeCopy {
+		resp.ERROR(c, "您无权修改版权信息，请先联系作者获取授权")
+		return
+	}
+
+	value := utils.JsonEncode(&data.Config)
+	config := model.Config{Key: data.Key, Config: value}
+	res := h.DB.FirstOrCreate(&config, model.Config{Key: data.Key})
+	if res.Error != nil {
+		resp.ERROR(c, res.Error.Error())
+		return
+	}
+
+	if config.Id > 0 {
+		config.Config = value
+		res := h.DB.Updates(&config)
+		if res.Error != nil {
+			resp.ERROR(c, res.Error.Error())
+			return
+		}
+
+		// update config cache for AppServer
+		var cfg model.Config
+		h.DB.Where("marker", data.Key).First(&cfg)
+		var err error
+		if data.Key == "system" {
+			err = utils.JsonDecode(cfg.Config, &h.App.SysConfig)
+		}
+		if err != nil {
+			resp.ERROR(c, "Failed to update config cache: "+err.Error())
+			return
+		}
+		logger.Infof("Update AppServer's config successfully: %v", config.Config)
+	}
+
+	resp.SUCCESS(c, config)
+}
+
+// Get 获取指定的系统配置
+func (h *ConfigHandler) Get(c *gin.Context) {
+	key := c.Query("key")
+	var config model.Config
+	res := h.DB.Where("marker", key).First(&config)
+	if res.Error != nil {
+		resp.ERROR(c, res.Error.Error())
+		return
+	}
+
+	var value map[string]interface{}
+	err := utils.JsonDecode(config.Config, &value)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, value)
+}
+
+// Active 激活系统
+func (h *ConfigHandler) Active(c *gin.Context) {
+	var data struct {
+		License string `json:"license"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	info, err := host.Info()
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	err = h.licenseService.ActiveLicense(data.License, info.HostID)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, info.HostID)
+}
+
+// GetLicense 获取 License 信息
+func (h *ConfigHandler) GetLicense(c *gin.Context) {
+	license := h.licenseService.GetLicense()
+	resp.SUCCESS(c, license)
+}
+
+// FixData 修复数据
+func (h *ConfigHandler) FixData(c *gin.Context) {
+	resp.ERROR(c, "当前升级版本没有数据需要修正！")
+	return
+	//var fixed bool
+	//version := "data_fix_4.1.4"
+	//err := h.levelDB.Get(version, &fixed)
+	//if err == nil || fixed {
+	//	resp.ERROR(c, "当前版本数据修复已完成，请不要重复执行操作")
+	//	return
+	//}
+	//tx := h.DB.Begin()
+	//var users []model.User
+	//err = tx.Find(&users).Error
+	//if err != nil {
+	//	resp.ERROR(c, err.Error())
+	//	return
+	//}
+	//for _, user := range users {
+	//	if user.Email != "" || user.Mobile != "" {
+	//		continue
+	//	}
+	//	if utils.IsValidEmail(user.Username) {
+	//		user.Email = user.Username
+	//	} else if utils.IsValidMobile(user.Username) {
+	//		user.Mobile = user.Username
+	//	}
+	//	err = tx.Save(&user).Error
+	//	if err != nil {
+	//		resp.ERROR(c, err.Error())
+	//		tx.Rollback()
+	//		return
+	//	}
+	//}
+	//
+	//var orders []model.Order
+	//err = h.DB.Find(&orders).Error
+	//if err != nil {
+	//	resp.ERROR(c, err.Error())
+	//	return
+	//}
+	//for _, order := range orders {
+	//	if order.PayWay == "支付宝" {
+	//		order.PayWay = "alipay"
+	//		order.PayType = "alipay"
+	//	} else if order.PayWay == "微信支付" {
+	//		order.PayWay = "wechat"
+	//		order.PayType = "wxpay"
+	//	} else if order.PayWay == "hupi" {
+	//		order.PayType = "wxpay"
+	//	}
+	//	err = tx.Save(&order).Error
+	//	if err != nil {
+	//		resp.ERROR(c, err.Error())
+	//		tx.Rollback()
+	//		return
+	//	}
+	//}
+	//tx.Commit()
+	//err = h.levelDB.Put(version, true)
+	//if err != nil {
+	//	resp.ERROR(c, err.Error())
+	//	return
+	//}
+	//resp.SUCCESS(c)
+}

api/handler/admin/dashboard_handler.go

@@ -0,0 +1,110 @@
+package admin
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/handler"
+	"geekai/store/model"
+	"geekai/utils/resp"
+	"github.com/gin-gonic/gin"
+	"github.com/shopspring/decimal"
+	"gorm.io/gorm"
+	"time"
+)
+
+type DashboardHandler struct {
+	handler.BaseHandler
+}
+
+func NewDashboardHandler(app *core.AppServer, db *gorm.DB) *DashboardHandler {
+	return &DashboardHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
+}
+
+type statsVo struct {
+	Users  int64                         `json:"users"`
+	Chats  int64                         `json:"chats"`
+	Tokens int                           `json:"tokens"`
+	Income float64                       `json:"income"`
+	Chart  map[string]map[string]float64 `json:"chart"`
+}
+
+func (h *DashboardHandler) Stats(c *gin.Context) {
+	stats := statsVo{}
+	// new users statistic
+	var userCount int64
+	now := time.Now()
+	zeroTime := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
+	res := h.DB.Model(&model.User{}).Where("created_at > ?", zeroTime).Count(&userCount)
+	if res.Error == nil {
+		stats.Users = userCount
+	}
+
+	// new chats statistic
+	var chatCount int64
+	res = h.DB.Model(&model.ChatItem{}).Where("created_at > ?", zeroTime).Count(&chatCount)
+	if res.Error == nil {
+		stats.Chats = chatCount
+	}
+
+	// tokens took stats
+	var historyMessages []model.ChatMessage
+	res = h.DB.Where("created_at > ?", zeroTime).Find(&historyMessages)
+	for _, item := range historyMessages {
+		stats.Tokens += item.Tokens
+	}
+
+	// 订单收入
+	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
+	}
+
+	// 统计7天的订单的图表
+	startDate := now.Add(-7 * 24 * time.Hour).Format("2006-01-02")
+	var statsChart = make(map[string]map[string]float64)
+	//// 初始化
+	var userStatistic, historyMessagesStatistic, incomeStatistic = make(map[string]float64), make(map[string]float64), make(map[string]float64)
+	for i := 0; i < 7; i++ {
+		var initTime = time.Date(now.Year(), now.Month(), now.Day()-i, 0, 0, 0, 0, now.Location()).Format("2006-01-02")
+		userStatistic[initTime] = float64(0)
+		historyMessagesStatistic[initTime] = float64(0)
+		incomeStatistic[initTime] = float64(0)
+	}
+
+	// 统计用户7天增加的曲线
+	var users []model.User
+	res = h.DB.Model(&model.User{}).Where("created_at > ?", startDate).Find(&users)
+	if res.Error == nil {
+		for _, item := range users {
+			userStatistic[item.CreatedAt.Format("2006-01-02")] += 1
+		}
+	}
+
+	// 统计7天Token 消耗
+	res = h.DB.Where("created_at > ?", startDate).Find(&historyMessages)
+	for _, item := range historyMessages {
+		historyMessagesStatistic[item.CreatedAt.Format("2006-01-02")] += float64(item.Tokens)
+	}
+
+	// 统计最近7天的订单
+	res = h.DB.Where("status = ?", types.OrderPaidSuccess).Where("created_at > ?", startDate).Find(&orders)
+	for _, item := range orders {
+		incomeStatistic[item.CreatedAt.Format("2006-01-02")], _ = decimal.NewFromFloat(incomeStatistic[item.CreatedAt.Format("2006-01-02")]).Add(decimal.NewFromFloat(item.Amount)).Float64()
+	}
+
+	statsChart["users"] = userStatistic
+	statsChart["historyMessage"] = historyMessagesStatistic
+	statsChart["orders"] = incomeStatistic
+
+	stats.Chart = statsChart
+
+	resp.SUCCESS(c, stats)
+}

api/handler/admin/function_handler.go

@@ -0,0 +1,128 @@
+package admin
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/handler"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+
+	"github.com/golang-jwt/jwt/v5"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type FunctionHandler struct {
+	handler.BaseHandler
+}
+
+func NewFunctionHandler(app *core.AppServer, db *gorm.DB) *FunctionHandler {
+	return &FunctionHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
+}
+
+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
+	}
+
+	err := h.DB.Model(&model.Function{}).Where("id = ?", data.Id).Update(data.Filed, data.Value).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		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 {
+		err := h.DB.Delete(&model.Function{Id: uint(id)}).Error
+		if err != nil {
+			resp.ERROR(c, err.Error())
+			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)
+}

api/handler/admin/image_handler.go

@@ -0,0 +1,254 @@
+package admin
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/handler"
+	"geekai/service"
+	"geekai/service/oss"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type ImageHandler struct {
+	handler.BaseHandler
+	userService *service.UserService
+	uploader    *oss.UploaderManager
+}
+
+func NewImageHandler(app *core.AppServer, db *gorm.DB, userService *service.UserService, manager *oss.UploaderManager) *ImageHandler {
+	return &ImageHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}, userService: userService, uploader: manager}
+}
+
+type imageQuery struct {
+	Prompt    string   `json:"prompt"`
+	Username  string   `json:"username"`
+	CreatedAt []string `json:"created_at"`
+	Page      int      `json:"page"`
+	PageSize  int      `json:"page_size"`
+}
+
+// MjList Midjourney 任务列表
+func (h *ImageHandler) MjList(c *gin.Context) {
+	var data imageQuery
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	session := h.DB.Session(&gorm.Session{})
+	if data.Username != "" {
+		var user model.User
+		err := h.DB.Where("username", data.Username).First(&user).Error
+		if err == nil {
+			session = session.Where("user_id", user.Id)
+		}
+	}
+	if data.Prompt != "" {
+		session = session.Where("prompt LIKE ?", "%"+data.Prompt+"%")
+	}
+	if len(data.CreatedAt) == 2 {
+		session = session.Where("created_at >= ? AND created_at <= ?", data.CreatedAt[0], data.CreatedAt[1])
+	}
+	var total int64
+	session.Model(&model.MidJourneyJob{}).Count(&total)
+	var list []model.MidJourneyJob
+	var items = make([]vo.MidJourneyJob, 0)
+	offset := (data.Page - 1) * data.PageSize
+	err := session.Order("id DESC").Offset(offset).Limit(data.PageSize).Find(&list).Error
+	if err == nil {
+		// 填充数据
+		for _, item := range list {
+			var job vo.MidJourneyJob
+			err = utils.CopyObject(item, &job)
+			if err != nil {
+				continue
+			}
+			job.CreatedAt = item.CreatedAt.Unix()
+			items = append(items, job)
+		}
+	}
+
+	resp.SUCCESS(c, vo.NewPage(total, data.Page, data.PageSize, items))
+}
+
+// SdList Stable Diffusion 任务列表
+func (h *ImageHandler) SdList(c *gin.Context) {
+	var data imageQuery
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	session := h.DB.Session(&gorm.Session{})
+	if data.Username != "" {
+		var user model.User
+		err := h.DB.Where("username", data.Username).First(&user).Error
+		if err == nil {
+			session = session.Where("user_id", user.Id)
+		}
+	}
+	if data.Prompt != "" {
+		session = session.Where("prompt LIKE ?", "%"+data.Prompt+"%")
+	}
+	if len(data.CreatedAt) == 2 {
+		session = session.Where("created_at >= ? AND created_at <= ?", data.CreatedAt[0], data.CreatedAt[1])
+	}
+	var total int64
+	session.Model(&model.SdJob{}).Count(&total)
+	var list []model.SdJob
+	var items = make([]vo.SdJob, 0)
+	offset := (data.Page - 1) * data.PageSize
+	err := session.Order("id DESC").Offset(offset).Limit(data.PageSize).Find(&list).Error
+	if err == nil {
+		// 填充数据
+		for _, item := range list {
+			var job vo.SdJob
+			err = utils.CopyObject(item, &job)
+			if err != nil {
+				continue
+			}
+			job.CreatedAt = item.CreatedAt.Unix()
+			items = append(items, job)
+		}
+	}
+
+	resp.SUCCESS(c, vo.NewPage(total, data.Page, data.PageSize, items))
+}
+
+// DallList DALL-E 任务列表
+func (h *ImageHandler) DallList(c *gin.Context) {
+	var data imageQuery
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	session := h.DB.Session(&gorm.Session{})
+	if data.Username != "" {
+		var user model.User
+		err := h.DB.Where("username", data.Username).First(&user).Error
+		if err == nil {
+			session = session.Where("user_id", user.Id)
+		}
+	}
+	if data.Prompt != "" {
+		session = session.Where("prompt LIKE ?", "%"+data.Prompt+"%")
+	}
+	if len(data.CreatedAt) == 2 {
+		session = session.Where("created_at >= ? AND created_at <= ?", data.CreatedAt[0], data.CreatedAt[1])
+	}
+	var total int64
+	session.Model(&model.DallJob{}).Count(&total)
+	var list []model.DallJob
+	var items = make([]vo.DallJob, 0)
+	offset := (data.Page - 1) * data.PageSize
+	err := session.Order("id DESC").Offset(offset).Limit(data.PageSize).Find(&list).Error
+	if err == nil {
+		// 填充数据
+		for _, item := range list {
+			var job vo.DallJob
+			err = utils.CopyObject(item, &job)
+			if err != nil {
+				continue
+			}
+			job.CreatedAt = item.CreatedAt.Unix()
+			items = append(items, job)
+		}
+	}
+
+	resp.SUCCESS(c, vo.NewPage(total, data.Page, data.PageSize, items))
+}
+
+func (h *ImageHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+	tab := c.Query("tab")
+
+	tx := h.DB.Begin()
+	var md, remark, imgURL string
+	var power, userId, progress int
+	switch tab {
+	case "mj":
+		var job model.MidJourneyJob
+		if err := h.DB.Where("id", id).First(&job).Error; err != nil {
+			resp.ERROR(c, "记录不存在")
+			return
+		}
+		tx.Delete(&job)
+		md = "mid-journey"
+		power = job.Power
+		userId = job.UserId
+		remark = fmt.Sprintf("任务失败，退回算力。任务ID：%d，Err: %s", job.Id, job.ErrMsg)
+		progress = job.Progress
+		imgURL = job.ImgURL
+		break
+	case "sd":
+		var job model.SdJob
+		if res := h.DB.Where("id", id).First(&job); res.Error != nil {
+			resp.ERROR(c, "记录不存在")
+			return
+		}
+
+		// 删除任务
+		tx.Delete(&job)
+		md = "stable-diffusion"
+		power = job.Power
+		userId = job.UserId
+		remark = fmt.Sprintf("任务失败，退回算力。任务ID：%d，Err: %s", job.Id, job.ErrMsg)
+		progress = job.Progress
+		imgURL = job.ImgURL
+		break
+	case "dall":
+		var job model.DallJob
+		if res := h.DB.Where("id", id).First(&job); res.Error != nil {
+			resp.ERROR(c, "记录不存在")
+			return
+		}
+
+		// 删除任务
+		tx.Delete(&job)
+		md = "dall-e-3"
+		power = job.Power
+		userId = int(job.UserId)
+		remark = fmt.Sprintf("任务失败，退回算力。任务ID：%d，Err: %s", job.Id, job.ErrMsg)
+		progress = job.Progress
+		imgURL = job.ImgURL
+		break
+	default:
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if progress != 100 {
+		err := h.userService.IncreasePower(userId, power, model.PowerLog{
+			Type:   types.PowerRefund,
+			Model:  md,
+			Remark: remark,
+		})
+		if err != nil {
+			tx.Rollback()
+			resp.ERROR(c, err.Error())
+			return
+		}
+	}
+	tx.Commit()
+	// remove image
+	err := h.uploader.GetUploadHandler().Delete(imgURL)
+	if err != nil {
+		logger.Error("remove image failed: ", err)
+	}
+
+	resp.SUCCESS(c)
+}

api/handler/admin/media_handler.go

@@ -0,0 +1,200 @@
+package admin
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/handler"
+	"geekai/service"
+	"geekai/service/oss"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type MediaHandler struct {
+	handler.BaseHandler
+	userService *service.UserService
+	uploader    *oss.UploaderManager
+}
+
+func NewMediaHandler(app *core.AppServer, db *gorm.DB, userService *service.UserService, manager *oss.UploaderManager) *MediaHandler {
+	return &MediaHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}, userService: userService, uploader: manager}
+}
+
+type mediaQuery struct {
+	Prompt    string   `json:"prompt"`
+	Username  string   `json:"username"`
+	CreatedAt []string `json:"created_at"`
+	Page      int      `json:"page"`
+	PageSize  int      `json:"page_size"`
+}
+
+// SunoList Suno 任务列表
+func (h *MediaHandler) SunoList(c *gin.Context) {
+	var data mediaQuery
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	session := h.DB.Session(&gorm.Session{})
+	if data.Username != "" {
+		var user model.User
+		err := h.DB.Where("username", data.Username).First(&user).Error
+		if err == nil {
+			session = session.Where("user_id", user.Id)
+		}
+	}
+	if data.Prompt != "" {
+		session = session.Where("prompt LIKE ?", "%"+data.Prompt+"%")
+	}
+	if len(data.CreatedAt) == 2 {
+		session = session.Where("created_at >= ? AND created_at <= ?", data.CreatedAt[0], data.CreatedAt[1])
+	}
+	var total int64
+	session.Model(&model.SunoJob{}).Count(&total)
+	var list []model.SunoJob
+	var items = make([]vo.SunoJob, 0)
+	offset := (data.Page - 1) * data.PageSize
+	err := session.Order("id DESC").Offset(offset).Limit(data.PageSize).Find(&list).Error
+	if err == nil {
+		// 填充数据
+		for _, item := range list {
+			var job vo.SunoJob
+			err = utils.CopyObject(item, &job)
+			if err != nil {
+				continue
+			}
+			job.CreatedAt = item.CreatedAt.Unix()
+			items = append(items, job)
+		}
+	}
+
+	resp.SUCCESS(c, vo.NewPage(total, data.Page, data.PageSize, items))
+}
+
+// LumaList Luma 视频任务列表
+func (h *MediaHandler) LumaList(c *gin.Context) {
+	var data mediaQuery
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	session := h.DB.Session(&gorm.Session{})
+	if data.Username != "" {
+		var user model.User
+		err := h.DB.Where("username", data.Username).First(&user).Error
+		if err == nil {
+			session = session.Where("user_id", user.Id)
+		}
+	}
+	if data.Prompt != "" {
+		session = session.Where("prompt LIKE ?", "%"+data.Prompt+"%")
+	}
+	if len(data.CreatedAt) == 2 {
+		session = session.Where("created_at >= ? AND created_at <= ?", data.CreatedAt[0], data.CreatedAt[1])
+	}
+	var total int64
+	session.Model(&model.VideoJob{}).Count(&total)
+	var list []model.VideoJob
+	var items = make([]vo.VideoJob, 0)
+	offset := (data.Page - 1) * data.PageSize
+	err := session.Order("id DESC").Offset(offset).Limit(data.PageSize).Find(&list).Error
+	if err == nil {
+		// 填充数据
+		for _, item := range list {
+			var job vo.VideoJob
+			err = utils.CopyObject(item, &job)
+			if err != nil {
+				continue
+			}
+			job.CreatedAt = item.CreatedAt.Unix()
+			if job.VideoURL == "" {
+				job.VideoURL = job.WaterURL
+			}
+			items = append(items, job)
+		}
+	}
+
+	resp.SUCCESS(c, vo.NewPage(total, data.Page, data.PageSize, items))
+}
+
+func (h *MediaHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+	tab := c.Query("tab")
+
+	tx := h.DB.Begin()
+	var md, remark, fileURL string
+	var power, userId, progress int
+	switch tab {
+	case "suno":
+		var job model.SunoJob
+		if err := h.DB.Where("id", id).First(&job).Error; err != nil {
+			resp.ERROR(c, "记录不存在")
+			return
+		}
+		tx.Delete(&job)
+		md = "suno"
+		power = job.Power
+		userId = job.UserId
+		remark = fmt.Sprintf("SUNO 任务失败，退回算力。任务ID：%d，Err: %s", job.Id, job.ErrMsg)
+		progress = job.Progress
+		fileURL = job.AudioURL
+		break
+	case "luma":
+		var job model.VideoJob
+		if res := h.DB.Where("id", id).First(&job); res.Error != nil {
+			resp.ERROR(c, "记录不存在")
+			return
+		}
+
+		// 删除任务
+		tx.Delete(&job)
+		md = job.Type
+		power = job.Power
+		userId = job.UserId
+		remark = fmt.Sprintf("LUMA 任务失败，退回算力。任务ID：%d，Err: %s", job.Id, job.ErrMsg)
+		progress = job.Progress
+		fileURL = job.VideoURL
+		if fileURL == "" {
+			fileURL = job.WaterURL
+		}
+		break
+	default:
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if progress != 100 {
+		err := h.userService.IncreasePower(userId, power, model.PowerLog{
+			Type:   types.PowerRefund,
+			Model:  md,
+			Remark: remark,
+		})
+		if err != nil {
+			tx.Rollback()
+			resp.ERROR(c, err.Error())
+			return
+		}
+	}
+	tx.Commit()
+	// remove image
+	err := h.uploader.GetUploadHandler().Delete(fileURL)
+	if err != nil {
+		logger.Error("remove image failed: ", err)
+	}
+
+	resp.SUCCESS(c)
+}

api/handler/admin/menu_handler.go

@@ -0,0 +1,128 @@
+package admin
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/handler"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type MenuHandler struct {
+	handler.BaseHandler
+}
+
+func NewMenuHandler(app *core.AppServer, db *gorm.DB) *MenuHandler {
+	return &MenuHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
+}
+
+func (h *MenuHandler) Save(c *gin.Context) {
+	var data struct {
+		Id      uint   `json:"id"`
+		Name    string `json:"name"`
+		Icon    string `json:"icon"`
+		URL     string `json:"url"`
+		SortNum int    `json:"sort_num"`
+		Enabled bool   `json:"enabled"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	err := h.DB.Save(&model.Menu{
+		Id:      data.Id,
+		Name:    data.Name,
+		Icon:    data.Icon,
+		URL:     data.URL,
+		SortNum: data.SortNum,
+		Enabled: data.Enabled,
+	}).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	resp.SUCCESS(c)
+}
+
+// List 数据列表
+func (h *MenuHandler) List(c *gin.Context) {
+	var items []model.Menu
+	var list = make([]vo.Menu, 0)
+	res := h.DB.Order("sort_num ASC").Find(&items)
+	if res.Error == nil {
+		for _, item := range items {
+			var product vo.Menu
+			err := utils.CopyObject(item, &product)
+			if err == nil {
+				list = append(list, product)
+			}
+		}
+	}
+	resp.SUCCESS(c, list)
+}
+
+func (h *MenuHandler) 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
+	}
+
+	err := h.DB.Model(&model.Menu{}).Where("id", data.Id).UpdateColumn("enabled", data.Enabled).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	resp.SUCCESS(c)
+}
+
+func (h *MenuHandler) 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 {
+		err := h.DB.Model(&model.Menu{}).Where("id", id).Update("sort_num", data.Sorts[index]).Error
+		if err != nil {
+			resp.ERROR(c, err.Error())
+			return
+		}
+	}
+
+	resp.SUCCESS(c)
+}
+
+func (h *MenuHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+
+	if id > 0 {
+		err := h.DB.Where("id", id).Delete(&model.Menu{}).Error
+		if err != nil {
+			resp.ERROR(c, err.Error())
+			return
+		}
+	}
+	resp.SUCCESS(c)
+}

api/handler/admin/order_handler.go

@@ -0,0 +1,135 @@
+package admin
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/handler"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type OrderHandler struct {
+	handler.BaseHandler
+}
+
+func NewOrderHandler(app *core.AppServer, db *gorm.DB) *OrderHandler {
+	return &OrderHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
+}
+
+func (h *OrderHandler) List(c *gin.Context) {
+	var data struct {
+		OrderNo  string   `json:"order_no"`
+		Status   int      `json:"status"`
+		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)
+	}
+	if data.Status >= 0 {
+		session = session.Where("status", data.Status)
+	}
+	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()
+				payMethod, ok := types.PayMethods[item.PayWay]
+				if !ok {
+					payMethod = item.PayWay
+				}
+				payName, ok := types.PayNames[item.PayType]
+				if !ok {
+					payName = item.PayWay
+				}
+				order.PayMethod = payMethod
+				order.PayName = payName
+				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
+		}
+
+		err := h.DB.Where("id = ?", id).Delete(&model.Order{}).Error
+		if err != nil {
+			resp.ERROR(c, err.Error())
+			return
+		}
+	}
+	resp.SUCCESS(c)
+}
+
+func (h *OrderHandler) Clear(c *gin.Context) {
+	var orders []model.Order
+	err := h.DB.Where("status <> ?", 2).Where("pay_time", 0).Find(&orders).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	deleteIds := make([]uint, 0)
+	for _, order := range orders {
+		// 只删除 15 分钟内的未支付订单
+		if time.Now().After(order.CreatedAt.Add(time.Minute * 15)) {
+			deleteIds = append(deleteIds, order.Id)
+		}
+	}
+	err = h.DB.Where("id IN ?", deleteIds).Delete(&model.Order{}).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	resp.SUCCESS(c)
+}

api/handler/admin/power_log_handler.go

@@ -0,0 +1,84 @@
+package admin
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/handler"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type PowerLogHandler struct {
+	handler.BaseHandler
+}
+
+func NewPowerLogHandler(app *core.AppServer, db *gorm.DB) *PowerLogHandler {
+	return &PowerLogHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
+}
+
+func (h *PowerLogHandler) List(c *gin.Context) {
+	var data struct {
+		Username string   `json:"username"`
+		Type     int      `json:"type"`
+		Model    string   `json:"model"`
+		Date     []string `json:"date"`
+		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.Model != "" {
+		session = session.Where("model", data.Model)
+	}
+	if data.Type > 0 {
+		session = session.Where("type", data.Type)
+	}
+	if len(data.Date) == 2 {
+		start := data.Date[0] + " 00:00:00"
+		end := data.Date[1] + " 00:00:00"
+		session = session.Where("created_at >= ? AND created_at <= ?", start, end)
+	}
+
+	var total int64
+	session.Model(&model.PowerLog{}).Count(&total)
+	var items []model.PowerLog
+	var list = make([]vo.PowerLog, 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 log vo.PowerLog
+			err := utils.CopyObject(item, &log)
+			if err != nil {
+				continue
+			}
+			log.Id = item.Id
+			log.CreatedAt = item.CreatedAt.Unix()
+			log.TypeStr = item.Type.String()
+			list = append(list, log)
+		}
+	}
+
+	// 统计消费算力总和
+	var totalPower float64
+	if len(data.Date) == 2 {
+		session.Where("mark", 0).Select("SUM(amount) as total_sum").Scan(&totalPower)
+	}
+	resp.SUCCESS(c, gin.H{"data": vo.NewPage(total, data.Page, data.PageSize, list), "stat": totalPower})
+}

api/handler/admin/product_handler.go

@@ -0,0 +1,149 @@
+package admin
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/handler"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"time"
+)
+
+type ProductHandler struct {
+	handler.BaseHandler
+}
+
+func NewProductHandler(app *core.AppServer, db *gorm.DB) *ProductHandler {
+	return &ProductHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
+}
+
+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"`
+		Power     int     `json:"power"`
+		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,
+		Power:    data.Power,
+		Enabled:  data.Enabled}
+	item.Id = data.Id
+	if item.Id > 0 {
+		item.CreatedAt = time.Unix(data.CreatedAt, 0)
+	}
+	err := h.DB.Save(&item).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	var itemVo vo.Product
+	err = utils.CopyObject(item, &itemVo)
+	if err != nil {
+		resp.ERROR(c, "数据拷贝失败: "+err.Error())
+		return
+	}
+	itemVo.Id = item.Id
+	itemVo.UpdatedAt = item.UpdatedAt.Unix()
+	resp.SUCCESS(c, itemVo)
+}
+
+// List 数据列表
+func (h *ProductHandler) List(c *gin.Context) {
+	var items []model.Product
+	var list = make([]vo.Product, 0)
+	res := h.DB.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
+	}
+
+	err := h.DB.Model(&model.Product{}).Where("id", data.Id).UpdateColumn("enabled", data.Enabled).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		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 {
+		err := h.DB.Model(&model.Product{}).Where("id", id).Update("sort_num", data.Sorts[index]).Error
+		if err != nil {
+			resp.ERROR(c, err.Error())
+			return
+		}
+	}
+
+	resp.SUCCESS(c)
+}
+
+func (h *ProductHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+
+	if id > 0 {
+		err := h.DB.Where("id", id).Delete(&model.Product{}).Error
+		if err != nil {
+			resp.ERROR(c, err.Error())
+			return
+		}
+	}
+	resp.SUCCESS(c)
+}

api/handler/admin/redeem_handler.go

@@ -0,0 +1,219 @@
+package admin
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"encoding/csv"
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/handler"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type RedeemHandler struct {
+	handler.BaseHandler
+}
+
+func NewRedeemHandler(app *core.AppServer, db *gorm.DB) *RedeemHandler {
+	return &RedeemHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
+}
+
+func (h *RedeemHandler) List(c *gin.Context) {
+	page := h.GetInt(c, "page", 1)
+	pageSize := h.GetInt(c, "page_size", 20)
+	code := c.Query("code")
+	status := h.GetInt(c, "status", -1)
+
+	session := h.DB.Session(&gorm.Session{})
+	if code != "" {
+		session = session.Where("code LIKE ?", "%"+code+"%")
+	}
+	if status >= 0 {
+		session = session.Where("redeemed_at", status)
+	}
+
+	var total int64
+	session.Model(&model.Redeem{}).Count(&total)
+	var redeems []model.Redeem
+	offset := (page - 1) * pageSize
+	err := session.Order("id DESC").Offset(offset).Limit(pageSize).Find(&redeems).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	var items = make([]vo.Redeem, 0)
+	userIds := make([]uint, 0)
+	for _, v := range redeems {
+		userIds = append(userIds, v.UserId)
+	}
+	var users []model.User
+	h.DB.Where("id IN ?", userIds).Find(&users)
+	var userMap = make(map[uint]model.User)
+	for _, u := range users {
+		userMap[u.Id] = u
+	}
+
+	for _, v := range redeems {
+		var r vo.Redeem
+		err = utils.CopyObject(v, &r)
+		if err != nil {
+			continue
+		}
+
+		r.Id = v.Id
+		r.Username = userMap[v.UserId].Username
+		r.CreatedAt = v.CreatedAt.Unix()
+		items = append(items, r)
+	}
+
+	resp.SUCCESS(c, vo.NewPage(total, page, pageSize, items))
+}
+
+// Export 导出 CVS 文件
+func (h *RedeemHandler) Export(c *gin.Context) {
+	var data struct {
+		Status int   `json:"status"`
+		Ids    []int `json:"ids"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+	}
+
+	session := h.DB.Session(&gorm.Session{})
+	if data.Status >= 0 {
+		session = session.Where("redeemed_at", data.Status)
+	}
+	if len(data.Ids) > 0 {
+		session = session.Where("id IN ?", data.Ids)
+	}
+
+	var items []model.Redeem
+	err := session.Order("id DESC").Find(&items).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// 设置响应头，告诉浏览器这是一个附件，需要下载
+	c.Header("Content-Disposition", "attachment; filename=output.csv")
+	c.Header("Content-Type", "text/csv")
+
+	// 创建一个 CSV writer
+	writer := csv.NewWriter(c.Writer)
+
+	// 写入 CSV 文件的标题行
+	headers := []string{"名称", "兑换码", "算力", "创建时间"}
+	if err := writer.Write(headers); err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// 写入数据行
+	records := make([][]string, 0)
+	for _, item := range items {
+		records = append(records, []string{item.Name, item.Code, fmt.Sprintf("%d", item.Power), item.CreatedAt.Format("2006-01-02 15:04:05")})
+	}
+	for _, record := range records {
+		if err := writer.Write(record); err != nil {
+			resp.ERROR(c, err.Error())
+			return
+		}
+	}
+
+	// 确保所有数据都已写入响应
+	writer.Flush()
+	if err := writer.Error(); err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+}
+
+func (h *RedeemHandler) Create(c *gin.Context) {
+	var data struct {
+		Name  string `json:"name"`
+		Power int    `json:"power"`
+		Num   int    `json:"num"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	counter := 0
+	codes := make([]string, 0)
+	var errMsg = ""
+	if data.Num > 0 {
+		for i := 0; i < data.Num; i++ {
+			code, err := utils.GenRedeemCode(32)
+			if err != nil {
+				errMsg = err.Error()
+				continue
+			}
+			err = h.DB.Create(&model.Redeem{
+				Code:    code,
+				Name:    data.Name,
+				Power:   data.Power,
+				Enabled: true,
+			}).Error
+			if err != nil {
+				errMsg = err.Error()
+				continue
+			}
+			codes = append(codes, code)
+			counter++
+		}
+	}
+	if counter == 0 {
+		resp.ERROR(c, errMsg)
+		return
+	}
+
+	resp.SUCCESS(c, gin.H{
+		"counter": counter,
+	})
+}
+
+func (h *RedeemHandler) 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
+	}
+
+	err := h.DB.Model(&model.Redeem{}).Where("id = ?", data.Id).Update(data.Filed, data.Value).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	resp.SUCCESS(c)
+}
+
+func (h *RedeemHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+	if id <= 0 {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	err := h.DB.Where("id", id).Delete(&model.Redeem{}).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	resp.SUCCESS(c)
+}

api/handler/admin/upload_handler.go

@@ -0,0 +1,52 @@
+package admin
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/handler"
+	"geekai/service/oss"
+	"geekai/store/model"
+	"geekai/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"time"
+)
+
+type UploadHandler struct {
+	handler.BaseHandler
+	uploaderManager *oss.UploaderManager
+}
+
+func NewUploadHandler(app *core.AppServer, db *gorm.DB, manager *oss.UploaderManager) *UploadHandler {
+	return &UploadHandler{BaseHandler: handler.BaseHandler{DB: db, App: app}, uploaderManager: manager}
+}
+
+func (h *UploadHandler) Upload(c *gin.Context) {
+	file, err := h.uploaderManager.GetUploadHandler().PutFile(c, "file")
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	userId := 0
+	res := h.DB.Create(&model.File{
+		UserId:    userId,
+		Name:      file.Name,
+		ObjKey:    file.ObjKey,
+		URL:       file.URL,
+		Ext:       file.Ext,
+		Size:      file.Size,
+		CreatedAt: time.Time{},
+	})
+	if res.Error != nil || res.RowsAffected == 0 {
+		resp.ERROR(c, "error with update database: "+res.Error.Error())
+		return
+	}
+
+	resp.SUCCESS(c, file)
+}

api/handler/admin/user_handler.go

@@ -0,0 +1,313 @@
+package admin
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/handler"
+	"geekai/service"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"github.com/go-redis/redis/v8"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type UserHandler struct {
+	handler.BaseHandler
+	licenseService *service.LicenseService
+	redis          *redis.Client
+}
+
+func NewUserHandler(app *core.AppServer, db *gorm.DB, licenseService *service.LicenseService, redisCli *redis.Client) *UserHandler {
+	return &UserHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}, licenseService: licenseService, redis: redisCli}
+}
+
+// List 用户列表
+func (h *UserHandler) List(c *gin.Context) {
+	page := h.GetInt(c, "page", 1)
+	pageSize := h.GetInt(c, "page_size", 20)
+	username := h.GetTrim(c, "username")
+
+	offset := (page - 1) * pageSize
+	var items []model.User
+	var users = make([]vo.User, 0)
+	var total int64
+
+	session := h.DB.Session(&gorm.Session{})
+	if username != "" {
+		session = session.Where("username LIKE ?", "%"+username+"%")
+	}
+
+	session.Model(&model.User{}).Count(&total)
+	res := session.Offset(offset).Limit(pageSize).Order("id DESC").Find(&items)
+	if res.Error == nil {
+		for _, item := range items {
+			var user vo.User
+			err := utils.CopyObject(item, &user)
+			if err == nil {
+				user.Id = item.Id
+				user.CreatedAt = item.CreatedAt.Unix()
+				user.UpdatedAt = item.UpdatedAt.Unix()
+				users = append(users, user)
+			} else {
+				logger.Error(err)
+			}
+		}
+	}
+	pageVo := vo.NewPage(total, page, pageSize, users)
+	resp.SUCCESS(c, pageVo)
+}
+
+func (h *UserHandler) Save(c *gin.Context) {
+	var data struct {
+		Id          uint     `json:"id"`
+		Password    string   `json:"password"`
+		Username    string   `json:"username"`
+		Mobile      string   `json:"mobile"`
+		Email       string   `json:"email"`
+		ChatRoles   []string `json:"chat_roles"`
+		ChatModels  []int    `json:"chat_models"`
+		ExpiredTime string   `json:"expired_time"`
+		Status      bool     `json:"status"`
+		Vip         bool     `json:"vip"`
+		Power       int      `json:"power"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	// 检测最大注册人数
+	var totalUser int64
+	h.DB.Model(&model.User{}).Count(&totalUser)
+	if h.licenseService.GetLicense().Configs.UserNum > 0 && int(totalUser) >= h.licenseService.GetLicense().Configs.UserNum {
+		resp.ERROR(c, "当前注册用户数已达上限，请请升级 License")
+		return
+	}
+	var user = model.User{}
+	var res *gorm.DB
+	var userVo vo.User
+	if data.Id > 0 { // 更新
+		res = h.DB.Where("id", data.Id).First(&user)
+		if res.Error != nil {
+			resp.ERROR(c, "user not found")
+			return
+		}
+		var oldPower = user.Power
+		user.Username = data.Username
+		user.Email = data.Email
+		user.Mobile = data.Mobile
+		user.Status = data.Status
+		user.Vip = data.Vip
+		user.Power = data.Power
+		user.ChatRoles = utils.JsonEncode(data.ChatRoles)
+		user.ChatModels = utils.JsonEncode(data.ChatModels)
+		user.ExpiredTime = utils.Str2stamp(data.ExpiredTime)
+
+		res = h.DB.Select("username", "mobile", "email", "status", "vip", "power", "chat_roles_json", "chat_models_json", "expired_time").Updates(&user)
+
+		if res.Error != nil {
+			logger.Error("error with update database：", res.Error)
+			resp.ERROR(c, res.Error.Error())
+			return
+		}
+		// 记录算力日志
+		if oldPower != user.Power {
+			mark := types.PowerAdd
+			amount := user.Power - oldPower
+			if oldPower > user.Power {
+				mark = types.PowerSub
+				amount = oldPower - user.Power
+			}
+			h.DB.Create(&model.PowerLog{
+				UserId:    user.Id,
+				Username:  user.Username,
+				Type:      types.PowerGift,
+				Amount:    amount,
+				Balance:   user.Power,
+				Mark:      mark,
+				Model:     "管理员",
+				Remark:    fmt.Sprintf("后台管理员强制修改用户算力，修改前：%d,修改后:%d, 管理员ID：%d", oldPower, user.Power, h.GetLoginUserId(c)),
+				CreatedAt: time.Now(),
+			})
+		}
+		// 如果禁用了用户，则将用户踢下线
+		if user.Status == false {
+			key := fmt.Sprintf("users/%v", user.Id)
+			if _, err := h.redis.Del(c, key).Result(); err != nil {
+				logger.Error("error with delete session: ", err)
+			}
+		}
+	} else {
+		// 检查用户是否已经存在
+		h.DB.Where("username", data.Username).First(&user)
+		if user.Id > 0 {
+			resp.ERROR(c, "用户名已存在")
+			return
+		}
+
+		salt := utils.RandString(8)
+		u := model.User{
+			Username:    data.Username,
+			Password:    utils.GenPassword(data.Password, salt),
+			Mobile:      data.Mobile,
+			Email:       data.Email,
+			Avatar:      "/images/avatar/user.png",
+			Salt:        salt,
+			Power:       data.Power,
+			Status:      true,
+			ChatRoles:   utils.JsonEncode(data.ChatRoles),
+			ChatModels:  utils.JsonEncode(data.ChatModels),
+			ExpiredTime: utils.Str2stamp(data.ExpiredTime),
+		}
+		if h.licenseService.GetLicense().Configs.DeCopy {
+			u.Nickname = fmt.Sprintf("用户@%d", utils.RandomNumber(6))
+		} else {
+			u.Nickname = fmt.Sprintf("极客学长@%d", utils.RandomNumber(6))
+		}
+		res = h.DB.Create(&u)
+		_ = utils.CopyObject(u, &userVo)
+		userVo.Id = u.Id
+		userVo.CreatedAt = u.CreatedAt.Unix()
+		userVo.UpdatedAt = u.UpdatedAt.Unix()
+	}
+
+	if res.Error != nil {
+		resp.ERROR(c, res.Error.Error())
+		return
+	}
+
+	resp.SUCCESS(c, userVo)
+}
+
+// ResetPass 重置密码
+func (h *UserHandler) ResetPass(c *gin.Context) {
+	var data struct {
+		Id       uint
+		Password string
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	var user model.User
+	res := h.DB.First(&user, data.Id)
+	if res.Error != nil {
+		resp.ERROR(c, "No user found")
+		return
+	}
+
+	password := utils.GenPassword(data.Password, user.Salt)
+	user.Password = password
+	res = h.DB.Updates(&user)
+	if res.Error != nil {
+		resp.ERROR(c)
+	} else {
+		resp.SUCCESS(c)
+	}
+}
+
+func (h *UserHandler) Remove(c *gin.Context) {
+	id := c.Query("id")
+	ids := c.QueryArray("ids[]")
+	if id != "" {
+		ids = append(ids, id)
+	}
+	if len(ids) == 0 {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	tx := h.DB.Begin()
+	var err error
+	for _, id = range ids {
+		// 删除用户
+		if err = tx.Where("id", id).Delete(&model.User{}).Error; err != nil {
+			break
+		}
+		// 删除聊天记录
+		if err = tx.Unscoped().Where("user_id = ?", id).Delete(&model.ChatItem{}).Error; err != nil {
+			break
+		}
+		// 删除聊天历史记录
+		if err = tx.Unscoped().Where("user_id = ?", id).Delete(&model.ChatMessage{}).Error; err != nil {
+			break
+		}
+		// 删除登录日志
+		if err = tx.Where("user_id = ?", id).Delete(&model.UserLoginLog{}).Error; err != nil {
+			break
+		}
+		// 删除算力日志
+		if err = tx.Where("user_id = ?", id).Delete(&model.PowerLog{}).Error; err != nil {
+			break
+		}
+		if err = tx.Where("user_id = ?", id).Delete(&model.InviteLog{}).Error; err != nil {
+			break
+		}
+		// 删除众筹日志
+		if err = tx.Where("user_id = ?", id).Delete(&model.Redeem{}).Error; err != nil {
+			break
+		}
+		// 删除绘图任务
+		if err = tx.Where("user_id = ?", id).Delete(&model.MidJourneyJob{}).Error; err != nil {
+			break
+		}
+		if err = tx.Where("user_id = ?", id).Delete(&model.SdJob{}).Error; err != nil {
+			break
+		}
+		if err = tx.Where("user_id = ?", id).Delete(&model.DallJob{}).Error; err != nil {
+			break
+		}
+		if err = tx.Where("user_id = ?", id).Delete(&model.SunoJob{}).Error; err != nil {
+			break
+		}
+		if err = tx.Where("user_id = ?", id).Delete(&model.VideoJob{}).Error; err != nil {
+			break
+		}
+	}
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		tx.Rollback()
+		return
+	}
+	tx.Commit()
+	resp.SUCCESS(c)
+}
+
+func (h *UserHandler) LoginLog(c *gin.Context) {
+	page := h.GetInt(c, "page", 1)
+	pageSize := h.GetInt(c, "page_size", 20)
+	var total int64
+	h.DB.Model(&model.UserLoginLog{}).Count(&total)
+	offset := (page - 1) * pageSize
+	var items []model.UserLoginLog
+	res := h.DB.Offset(offset).Limit(pageSize).Order("id DESC").Find(&items)
+	if res.Error != nil {
+		resp.ERROR(c, "获取数据失败")
+		return
+	}
+	var logs []vo.UserLoginLog
+	for _, v := range items {
+		var log vo.UserLoginLog
+		err := utils.CopyObject(v, &log)
+		if err == nil {
+			log.Id = v.Id
+			log.CreatedAt = v.CreatedAt.Unix()
+			logs = append(logs, log)
+		}
+	}
+
+	resp.SUCCESS(c, vo.NewPage(total, page, pageSize, logs))
+}

api/handler/base_handler.go

@@ -0,0 +1,94 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"errors"
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	logger2 "geekai/logger"
+	"geekai/store/model"
+	"geekai/utils"
+	"gorm.io/gorm"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+)
+
+var logger = logger2.GetLogger()
+
+type BaseHandler struct {
+	App *core.AppServer
+	DB  *gorm.DB
+}
+
+func (h *BaseHandler) GetTrim(c *gin.Context, key string) string {
+	return strings.TrimSpace(c.Query(key))
+}
+
+func (h *BaseHandler) PostInt(c *gin.Context, key string, defaultValue int) int {
+	return utils.IntValue(c.PostForm(key), defaultValue)
+}
+
+func (h *BaseHandler) GetInt(c *gin.Context, key string, defaultValue int) int {
+	return utils.IntValue(c.Query(key), defaultValue)
+}
+
+func (h *BaseHandler) GetFloat(c *gin.Context, key string) float64 {
+	return utils.FloatValue(c.Query(key))
+}
+func (h *BaseHandler) PostFloat(c *gin.Context, key string) float64 {
+	return utils.FloatValue(c.PostForm(key))
+}
+
+func (h *BaseHandler) GetBool(c *gin.Context, key string) bool {
+	return utils.BoolValue(c.Query(key))
+}
+func (h *BaseHandler) PostBool(c *gin.Context, key string) bool {
+	return utils.BoolValue(c.PostForm(key))
+}
+func (h *BaseHandler) GetUserKey(c *gin.Context) string {
+	userId, ok := c.Get(types.LoginUserID)
+	if !ok {
+		return ""
+	}
+	return fmt.Sprintf("users/%v", userId)
+}
+
+func (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))
+}
+
+func (h *BaseHandler) IsLogin(c *gin.Context) bool {
+	return h.GetLoginUserId(c) > 0
+}
+
+func (h *BaseHandler) GetLoginUser(c *gin.Context) (model.User, error) {
+	value, exists := c.Get(types.LoginUserCache)
+	if exists {
+		return value.(model.User), nil
+	}
+
+	userId, ok := c.Get(types.LoginUserID)
+	if !ok {
+		return model.User{}, errors.New("user not login")
+	}
+
+	var user model.User
+	res := h.DB.Where("id", userId).First(&user)
+	// 更新缓存
+	if res.Error == nil {
+		c.Set(types.LoginUserCache, user)
+	}
+	return user, res.Error
+}

api/handler/captcha_handler.go

@@ -0,0 +1,84 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core/types"
+	"geekai/service"
+	"geekai/utils/resp"
+	"github.com/gin-gonic/gin"
+)
+
+// 今日头条函数实现
+
+type CaptchaHandler struct {
+	service *service.CaptchaService
+}
+
+func NewCaptchaHandler(s *service.CaptchaService) *CaptchaHandler {
+	return &CaptchaHandler{service: s}
+}
+
+func (h *CaptchaHandler) Get(c *gin.Context) {
+	data, err := h.service.Get()
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, data)
+}
+
+// Check verify the captcha data
+func (h *CaptchaHandler) Check(c *gin.Context) {
+	var data struct {
+		Key  string `json:"key"`
+		Dots string `json:"dots"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if h.service.Check(data) {
+		resp.SUCCESS(c)
+	} else {
+		resp.ERROR(c)
+	}
+
+}
+
+// SlideGet 获取滑动验证图片
+func (h *CaptchaHandler) SlideGet(c *gin.Context) {
+	data, err := h.service.SlideGet()
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, data)
+}
+
+// SlideCheck 滑动验证结果校验
+func (h *CaptchaHandler) SlideCheck(c *gin.Context) {
+	var data struct {
+		Key string `json:"key"`
+		X   int    `json:"x"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if h.service.SlideCheck(data) {
+		resp.SUCCESS(c)
+	} else {
+		resp.ERROR(c)
+	}
+
+}

api/handler/chat_app_type_handler.go

@@ -0,0 +1,44 @@
+package handler
+
+import (
+	"geekai/core"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type ChatAppTypeHandler struct {
+	BaseHandler
+}
+
+func NewChatAppTypeHandler(app *core.AppServer, db *gorm.DB) *ChatAppTypeHandler {
+	return &ChatAppTypeHandler{BaseHandler: BaseHandler{App: app, DB: db}}
+}
+
+// List 获取App类型列表
+func (h *ChatAppTypeHandler) List(c *gin.Context) {
+	var items []model.AppType
+	var appTypes = make([]vo.AppType, 0)
+	err := h.DB.Where("enabled", true).Order("sort_num ASC").Find(&items).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	for _, v := range items {
+		var appType vo.AppType
+		err = utils.CopyObject(v, &appType)
+		if err != nil {
+			continue
+		}
+		appType.Id = v.Id
+		appType.CreatedAt = v.CreatedAt.Unix()
+		appTypes = append(appTypes, appType)
+	}
+
+	resp.SUCCESS(c, appTypes)
+}

api/handler/chat_handler.go

@@ -0,0 +1,521 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/service"
+	"geekai/service/oss"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"html/template"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"github.com/gin-gonic/gin"
+	"github.com/go-redis/redis/v8"
+	"gorm.io/gorm"
+)
+
+type ChatHandler struct {
+	BaseHandler
+	redis          *redis.Client
+	uploadManager  *oss.UploaderManager
+	licenseService *service.LicenseService
+	ReqCancelFunc  *types.LMap[string, context.CancelFunc] // HttpClient 请求取消 handle function
+	ChatContexts   *types.LMap[string, []interface{}]      // 聊天上下文 Map [chatId] => []Message
+	userService    *service.UserService
+}
+
+func NewChatHandler(app *core.AppServer, db *gorm.DB, redis *redis.Client, manager *oss.UploaderManager, licenseService *service.LicenseService, userService *service.UserService) *ChatHandler {
+	return &ChatHandler{
+		BaseHandler:    BaseHandler{App: app, DB: db},
+		redis:          redis,
+		uploadManager:  manager,
+		licenseService: licenseService,
+		ReqCancelFunc:  types.NewLMap[string, context.CancelFunc](),
+		ChatContexts:   types.NewLMap[string, []interface{}](),
+		userService:    userService,
+	}
+}
+
+func (h *ChatHandler) sendMessage(ctx context.Context, session *types.ChatSession, role model.ChatRole, prompt string, ws *types.WsClient) error {
+	if !h.App.Debug {
+		defer func() {
+			if r := recover(); r != nil {
+				logger.Error("Recover message from error: ", r)
+			}
+		}()
+	}
+
+	var user model.User
+	res := h.DB.Model(&model.User{}).First(&user, session.UserId)
+	if res.Error != nil {
+		return errors.New("未授权用户，您正在进行非法操作！")
+	}
+	var userVo vo.User
+	err := utils.CopyObject(user, &userVo)
+	userVo.Id = user.Id
+	if err != nil {
+		return errors.New("User 对象转换失败，" + err.Error())
+	}
+
+	if userVo.Status == false {
+		return errors.New("您的账号已经被禁用，如果疑问，请联系管理员！")
+	}
+
+	if userVo.Power < session.Model.Power {
+		return fmt.Errorf("您当前剩余算力 %d 已不足以支付当前模型的单次对话需要消耗的算力 %d，[立即购买](/member)。", userVo.Power, session.Model.Power)
+	}
+
+	if userVo.ExpiredTime > 0 && userVo.ExpiredTime <= time.Now().Unix() {
+		return errors.New("您的账号已经过期，请联系管理员！")
+	}
+
+	// 检查 prompt 长度是否超过了当前模型允许的最大上下文长度
+	promptTokens, err := utils.CalcTokens(prompt, session.Model.Value)
+	if promptTokens > session.Model.MaxContext {
+
+		return errors.New("对话内容超出了当前模型允许的最大上下文长度！")
+	}
+
+	var req = types.ApiRequest{
+		Model: session.Model.Value,
+	}
+	// 兼容 GPT-O1 模型
+	if strings.HasPrefix(session.Model.Value, "o1-") {
+		utils.SendChunkMsg(ws, "AI 正在思考...\n")
+		req.Stream = false
+		session.Start = time.Now().Unix()
+	} else {
+		req.MaxTokens = session.Model.MaxTokens
+		req.Temperature = session.Model.Temperature
+		req.Stream = session.Stream
+	}
+
+	if len(session.Tools) > 0 && !strings.HasPrefix(session.Model.Value, "o1-") {
+		var items []model.Function
+		res = h.DB.Where("enabled", true).Where("id IN ?", session.Tools).Find(&items)
+		if res.Error == nil {
+			var tools = make([]types.Tool, 0)
+			for _, v := range items {
+				var parameters map[string]interface{}
+				err = utils.JsonDecode(v.Parameters, &parameters)
+				if err != nil {
+					continue
+				}
+				tool := types.Tool{
+					Type: "function",
+					Function: types.Function{
+						Name:        v.Name,
+						Description: v.Description,
+						Parameters:  parameters,
+					},
+				}
+				if v, ok := parameters["required"]; v == nil || !ok {
+					tool.Function.Parameters["required"] = []string{}
+				}
+				tools = append(tools, tool)
+			}
+
+			if len(tools) > 0 {
+				req.Tools = tools
+				req.ToolChoice = "auto"
+			}
+		}
+	}
+
+	// 加载聊天上下文
+	chatCtx := make([]interface{}, 0)
+	messages := make([]interface{}, 0)
+	if h.App.SysConfig.EnableContext {
+		if h.ChatContexts.Has(session.ChatId) {
+			messages = h.ChatContexts.Get(session.ChatId)
+		} else {
+			_ = utils.JsonDecode(role.Context, &messages)
+			if h.App.SysConfig.ContextDeep > 0 {
+				var historyMessages []model.ChatMessage
+				res := h.DB.Where("chat_id = ? and use_context = 1", session.ChatId).Limit(h.App.SysConfig.ContextDeep).Order("id DESC").Find(&historyMessages)
+				if res.Error == nil {
+					for i := len(historyMessages) - 1; i >= 0; i-- {
+						msg := historyMessages[i]
+						ms := types.Message{Role: "user", Content: msg.Content}
+						if msg.Type == types.ReplyMsg {
+							ms.Role = "assistant"
+						}
+						chatCtx = append(chatCtx, ms)
+					}
+				}
+			}
+		}
+
+		// 计算当前请求的 token 总长度，确保不会超出最大上下文长度
+		// MaxContextLength = Response + Tool + Prompt + Context
+		tokens := req.MaxTokens // 最大响应长度
+		tks, _ := utils.CalcTokens(utils.JsonEncode(req.Tools), req.Model)
+		tokens += tks + promptTokens
+
+		for i := len(messages) - 1; i >= 0; i-- {
+			v := messages[i]
+			tks, _ = utils.CalcTokens(utils.JsonEncode(v), req.Model)
+			// 上下文 token 超出了模型的最大上下文长度
+			if tokens+tks >= session.Model.MaxContext {
+				break
+			}
+
+			// 上下文的深度超出了模型的最大上下文深度
+			if len(chatCtx) >= h.App.SysConfig.ContextDeep {
+				break
+			}
+
+			tokens += tks
+			chatCtx = append(chatCtx, v)
+		}
+
+		logger.Debugf("聊天上下文：%+v", chatCtx)
+	}
+	reqMgs := make([]interface{}, 0)
+
+	for i := len(chatCtx) - 1; i >= 0; i-- {
+		reqMgs = append(reqMgs, chatCtx[i])
+	}
+
+	fullPrompt := prompt
+	text := prompt
+	// extract files in prompt
+	files := utils.ExtractFileURLs(prompt)
+	logger.Debugf("detected FILES: %+v", files)
+	// 如果不是逆向模型，则提取文件内容
+	if len(files) > 0 && !(session.Model.Value == "gpt-4-all" ||
+		strings.HasPrefix(session.Model.Value, "gpt-4-gizmo") ||
+		strings.HasSuffix(session.Model.Value, "claude-3")) {
+		contents := make([]string, 0)
+		var file model.File
+		for _, v := range files {
+			h.DB.Where("url = ?", v).First(&file)
+			content, err := utils.ReadFileContent(v, h.App.Config.TikaHost)
+			if err != nil {
+				logger.Error("error with read file: ", err)
+			} else {
+				contents = append(contents, fmt.Sprintf("%s 文件内容：%s", file.Name, content))
+			}
+			text = strings.Replace(text, v, "", 1)
+		}
+		if len(contents) > 0 {
+			fullPrompt = fmt.Sprintf("请根据提供的文件内容信息回答问题(其中Excel 已转成 HTML)：\n\n %s\n\n 问题：%s", strings.Join(contents, "\n"), text)
+		}
+
+		tokens, _ := utils.CalcTokens(fullPrompt, req.Model)
+		if tokens > session.Model.MaxContext {
+			return fmt.Errorf("文件的长度超出模型允许的最大上下文长度，请减少文件内容数量或文件大小。")
+		}
+	}
+	logger.Debug("最终Prompt：", fullPrompt)
+
+	// extract images from prompt
+	imgURLs := utils.ExtractImgURLs(prompt)
+	logger.Debugf("detected IMG: %+v", imgURLs)
+	var content interface{}
+	if len(imgURLs) > 0 {
+		data := make([]interface{}, 0)
+		for _, v := range imgURLs {
+			text = strings.Replace(text, v, "", 1)
+			data = append(data, gin.H{
+				"type": "image_url",
+				"image_url": gin.H{
+					"url": v,
+				},
+			})
+		}
+		data = append(data, gin.H{
+			"type": "text",
+			"text": strings.TrimSpace(text),
+		})
+		content = data
+	} else {
+		content = fullPrompt
+	}
+	req.Messages = append(reqMgs, map[string]interface{}{
+		"role":    "user",
+		"content": content,
+	})
+
+	logger.Debugf("%+v", req.Messages)
+
+	return h.sendOpenAiMessage(req, userVo, ctx, session, role, prompt, ws)
+}
+
+// Tokens 统计 token 数量
+func (h *ChatHandler) Tokens(c *gin.Context) {
+	var data struct {
+		Text   string `json:"text"`
+		Model  string `json:"model"`
+		ChatId string `json:"chat_id"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	// 如果没有传入 text 字段，则说明是获取当前 reply 总的 token 消耗（带上下文）
+	//if data.Text == "" && data.ChatId != "" {
+	//	var item model.ChatMessage
+	//	userId, _ := c.Get(types.LoginUserID)
+	//	res := h.DB.Where("user_id = ?", userId).Where("chat_id = ?", data.ChatId).Last(&item)
+	//	if res.Error != nil {
+	//		resp.ERROR(c, res.Error.Error())
+	//		return
+	//	}
+	//	resp.SUCCESS(c, item.Tokens)
+	//	return
+	//}
+
+	tokens, err := utils.CalcTokens(data.Text, data.Model)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, tokens)
+}
+
+func getTotalTokens(req types.ApiRequest) int {
+	encode := utils.JsonEncode(req.Messages)
+	var items []map[string]interface{}
+	err := utils.JsonDecode(encode, &items)
+	if err != nil {
+		return 0
+	}
+	tokens := 0
+	for _, item := range items {
+		content, ok := item["content"]
+		if ok && !utils.IsEmptyValue(content) {
+			t, err := utils.CalcTokens(utils.InterfaceToString(content), req.Model)
+			if err == nil {
+				tokens += t
+			}
+		}
+	}
+	return tokens
+}
+
+// StopGenerate 停止生成
+func (h *ChatHandler) StopGenerate(c *gin.Context) {
+	sessionId := c.Query("session_id")
+	if h.ReqCancelFunc.Has(sessionId) {
+		h.ReqCancelFunc.Get(sessionId)()
+		h.ReqCancelFunc.Delete(sessionId)
+	}
+	resp.SUCCESS(c, types.OkMsg)
+}
+
+// 发送请求到 OpenAI 服务器
+// useOwnApiKey: 是否使用了用户自己的 API KEY
+func (h *ChatHandler) doRequest(ctx context.Context, req types.ApiRequest, session *types.ChatSession, apiKey *model.ApiKey) (*http.Response, error) {
+	// if the chat model bind a KEY, use it directly
+	if session.Model.KeyId > 0 {
+		h.DB.Where("id", session.Model.KeyId).Find(apiKey)
+	}
+	// use the last unused key
+	if apiKey.Id == 0 {
+		h.DB.Where("type", "chat").Where("enabled", true).Order("last_used_at ASC").First(apiKey)
+	}
+	if apiKey.Id == 0 {
+		return nil, errors.New("no available key, please import key")
+	}
+
+	// ONLY allow apiURL in blank list
+	err := h.licenseService.IsValidApiURL(apiKey.ApiURL)
+	if err != nil {
+		return nil, err
+	}
+	logger.Debugf("对话请求消息体：%+v", req)
+
+	apiURL := fmt.Sprintf("%s/v1/chat/completions", apiKey.ApiURL)
+	// 创建 HttpClient 请求对象
+	var client *http.Client
+	requestBody, err := json.Marshal(req)
+	if err != nil {
+		return nil, err
+	}
+	request, err := http.NewRequest(http.MethodPost, apiURL, bytes.NewBuffer(requestBody))
+	if err != nil {
+		return nil, err
+	}
+
+	request = request.WithContext(ctx)
+	request.Header.Set("Content-Type", "application/json")
+	if len(apiKey.ProxyURL) > 5 { // 使用代理
+		proxy, _ := url.Parse(apiKey.ProxyURL)
+		client = &http.Client{
+			Transport: &http.Transport{
+				Proxy: http.ProxyURL(proxy),
+			},
+		}
+	} else {
+		client = http.DefaultClient
+	}
+	logger.Infof("Sending %s request, API KEY:%s, PROXY: %s, Model: %s", apiKey.ApiURL, apiURL, apiKey.ProxyURL, req.Model)
+	request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", apiKey.Value))
+	// 更新API KEY 最后使用时间
+	h.DB.Model(&model.ApiKey{}).Where("id", apiKey.Id).UpdateColumn("last_used_at", time.Now().Unix())
+	return client.Do(request)
+}
+
+// 扣减用户算力
+func (h *ChatHandler) subUserPower(userVo vo.User, session *types.ChatSession, promptTokens int, replyTokens int) {
+	power := 1
+	if session.Model.Power > 0 {
+		power = session.Model.Power
+	}
+
+	err := h.userService.DecreasePower(int(userVo.Id), power, model.PowerLog{
+		Type:   types.PowerConsume,
+		Model:  session.Model.Value,
+		Remark: fmt.Sprintf("模型名称：%s, 提问长度：%d，回复长度：%d", session.Model.Name, promptTokens, replyTokens),
+	})
+	if err != nil {
+		logger.Error(err)
+	}
+}
+
+func (h *ChatHandler) saveChatHistory(
+	req types.ApiRequest,
+	usage Usage,
+	message types.Message,
+	session *types.ChatSession,
+	role model.ChatRole,
+	userVo vo.User,
+	promptCreatedAt time.Time,
+	replyCreatedAt time.Time) {
+
+	// 更新上下文消息
+	if h.App.SysConfig.EnableContext {
+		chatCtx := req.Messages            // 提问消息
+		chatCtx = append(chatCtx, message) // 回复消息
+		h.ChatContexts.Put(session.ChatId, chatCtx)
+	}
+
+	// 追加聊天记录
+	// for prompt
+	var promptTokens, replyTokens, totalTokens int
+	if usage.PromptTokens > 0 {
+		promptTokens = usage.PromptTokens
+	} else {
+		promptTokens, _ = utils.CalcTokens(usage.Content, req.Model)
+	}
+
+	historyUserMsg := model.ChatMessage{
+		UserId:      userVo.Id,
+		ChatId:      session.ChatId,
+		RoleId:      role.Id,
+		Type:        types.PromptMsg,
+		Icon:        userVo.Avatar,
+		Content:     template.HTMLEscapeString(usage.Prompt),
+		Tokens:      promptTokens,
+		TotalTokens: promptTokens,
+		UseContext:  true,
+		Model:       req.Model,
+	}
+	historyUserMsg.CreatedAt = promptCreatedAt
+	historyUserMsg.UpdatedAt = promptCreatedAt
+	err := h.DB.Save(&historyUserMsg).Error
+	if err != nil {
+		logger.Error("failed to save prompt history message: ", err)
+	}
+
+	// for reply
+	// 计算本次对话消耗的总 token 数量
+	if usage.CompletionTokens > 0 {
+		replyTokens = usage.CompletionTokens
+		totalTokens = usage.TotalTokens
+	} else {
+		replyTokens, _ = utils.CalcTokens(message.Content, req.Model)
+		totalTokens = replyTokens + getTotalTokens(req)
+	}
+	historyReplyMsg := model.ChatMessage{
+		UserId:      userVo.Id,
+		ChatId:      session.ChatId,
+		RoleId:      role.Id,
+		Type:        types.ReplyMsg,
+		Icon:        role.Icon,
+		Content:     usage.Content,
+		Tokens:      replyTokens,
+		TotalTokens: totalTokens,
+		UseContext:  true,
+		Model:       req.Model,
+	}
+	historyReplyMsg.CreatedAt = replyCreatedAt
+	historyReplyMsg.UpdatedAt = replyCreatedAt
+	err = h.DB.Create(&historyReplyMsg).Error
+	if err != nil {
+		logger.Error("failed to save reply history message: ", err)
+	}
+
+	// 更新用户算力
+	if session.Model.Power > 0 {
+		h.subUserPower(userVo, session, promptTokens, replyTokens)
+	}
+	// 保存当前会话
+	var chatItem model.ChatItem
+	err = h.DB.Where("chat_id = ?", session.ChatId).First(&chatItem).Error
+	if err != nil {
+		chatItem.ChatId = session.ChatId
+		chatItem.UserId = userVo.Id
+		chatItem.RoleId = role.Id
+		chatItem.ModelId = session.Model.Id
+		if utf8.RuneCountInString(usage.Prompt) > 30 {
+			chatItem.Title = string([]rune(usage.Prompt)[:30]) + "..."
+		} else {
+			chatItem.Title = usage.Prompt
+		}
+		chatItem.Model = req.Model
+		err = h.DB.Create(&chatItem).Error
+		if err != nil {
+			logger.Error("failed to save chat item: ", err)
+		}
+	}
+}
+
+// 将AI回复消息中生成的图片链接下载到本地
+func (h *ChatHandler) extractImgUrl(text string) string {
+	pattern := `!\[([^\]]*)]\(([^)]+)\)`
+	re := regexp.MustCompile(pattern)
+	matches := re.FindAllStringSubmatch(text, -1)
+
+	// 下载图片并替换链接地址
+	for _, match := range matches {
+		imageURL := match[2]
+		logger.Debug(imageURL)
+		// 对于相同地址的图片，已经被替换了，就不再重复下载了
+		if !strings.Contains(text, imageURL) {
+			continue
+		}
+
+		newImgURL, err := h.uploadManager.GetUploadHandler().PutUrlFile(imageURL, false)
+		if err != nil {
+			logger.Error("error with download image: ", err)
+			continue
+		}
+
+		text = strings.ReplaceAll(text, imageURL, newImgURL)
+	}
+	return text
+}

api/handler/chat_item_handler.go

@@ -0,0 +1,220 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core/types"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+// List 获取会话列表
+func (h *ChatHandler) List(c *gin.Context) {
+	if !h.IsLogin(c) {
+		resp.SUCCESS(c)
+		return
+	}
+
+	userId := h.GetLoginUserId(c)
+	var items = make([]vo.ChatItem, 0)
+	var chats []model.ChatItem
+	h.DB.Where("user_id", userId).Order("id DESC").Find(&chats)
+	if len(chats) == 0 {
+		resp.SUCCESS(c, items)
+		return
+	}
+
+	var roleIds = make([]uint, 0)
+	var modelValues = make([]string, 0)
+	for _, chat := range chats {
+		roleIds = append(roleIds, chat.RoleId)
+		modelValues = append(modelValues, chat.Model)
+	}
+
+	var roles []model.ChatRole
+	var models []model.ChatModel
+	roleMap := make(map[uint]model.ChatRole)
+	modelMap := make(map[string]model.ChatModel)
+	h.DB.Where("id IN ?", roleIds).Find(&roles)
+	h.DB.Where("value IN ?", modelValues).Find(&models)
+	for _, role := range roles {
+		roleMap[role.Id] = role
+	}
+	for _, m := range models {
+		modelMap[m.Value] = m
+	}
+	for _, chat := range chats {
+		var item vo.ChatItem
+		err := utils.CopyObject(chat, &item)
+		if err == nil {
+			item.Id = chat.Id
+			item.Icon = roleMap[chat.RoleId].Icon
+			item.ModelId = modelMap[chat.Model].Id
+			items = append(items, item)
+		}
+	}
+	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 := h.GetLoginUser(c)
+	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.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.ChatMessage{})
+		if res.Error != nil {
+			return res.Error
+		}
+		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.ChatMessage
+	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")
+	if chatId == "" {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	user, err := h.GetLoginUser(c)
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+
+	res := h.DB.Where("user_id = ? AND chat_id = ?", user.Id, chatId).Delete(&model.ChatItem{})
+	if res.Error != nil {
+		resp.ERROR(c, "Failed to update database")
+		return
+	}
+
+	// 删除当前会话的聊天记录
+	res = h.DB.Where("user_id = ? AND chat_id =?", user.Id, chatId).Delete(&model.ChatItem{})
+	if res.Error != nil {
+		resp.ERROR(c, "Failed to remove chat from database.")
+		return
+	}
+
+	// TODO: 是否要删除 MidJourney 绘画记录和图片文件？
+
+	// 清空会话上下文
+	h.ChatContexts.Delete(chatId)
+	resp.SUCCESS(c, types.OkMsg)
+}
+
+// Detail 对话详情，用户导出对话
+func (h *ChatHandler) Detail(c *gin.Context) {
+	chatId := h.GetTrim(c, "chat_id")
+	if utils.IsEmptyValue(chatId) {
+		resp.ERROR(c, "Invalid chatId")
+		return
+	}
+
+	var chatItem model.ChatItem
+	res := h.DB.Where("chat_id = ?", chatId).First(&chatItem)
+	if res.Error != nil {
+		resp.ERROR(c, "No chat found")
+		return
+	}
+
+	// 填充角色名称
+	var role model.ChatRole
+	res = h.DB.Where("id", chatItem.RoleId).First(&role)
+	if res.Error != nil {
+		resp.ERROR(c, "Role not found")
+		return
+	}
+
+	var chatItemVo vo.ChatItem
+	err := utils.CopyObject(chatItem, &chatItemVo)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	chatItemVo.RoleName = role.Name
+	resp.SUCCESS(c, chatItemVo)
+}

api/handler/chat_model_handler.go

@@ -0,0 +1,67 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type ChatModelHandler struct {
+	BaseHandler
+}
+
+func NewChatModelHandler(app *core.AppServer, db *gorm.DB) *ChatModelHandler {
+	return &ChatModelHandler{BaseHandler: BaseHandler{App: app, DB: db}}
+}
+
+// List 模型列表
+func (h *ChatModelHandler) List(c *gin.Context) {
+	var items []model.ChatModel
+	var chatModels = make([]vo.ChatModel, 0)
+	session := h.DB.Session(&gorm.Session{}).Where("type", "chat").Where("enabled", true)
+	t := c.Query("type")
+	if t != "" {
+		session = session.Where("type", t)
+	}
+
+	session = session.Where("open", true)
+	if h.IsLogin(c) {
+		user, _ := h.GetLoginUser(c)
+		var models []int
+		err := utils.JsonDecode(user.ChatModels, &models)
+		// 查询用户有权限访问的模型以及所有开放的模型
+		if err == nil {
+			session = session.Or("id IN ?", models)
+		}
+
+	}
+
+	res := session.Order("sort_num ASC").Find(&items)
+	if res.Error == nil {
+		for _, item := range items {
+			var cm vo.ChatModel
+			err := utils.CopyObject(item, &cm)
+			if err == nil {
+				cm.Id = item.Id
+				cm.CreatedAt = item.CreatedAt.Unix()
+				cm.UpdatedAt = item.UpdatedAt.Unix()
+				chatModels = append(chatModels, cm)
+			} else {
+				logger.Error(err)
+			}
+		}
+	}
+	resp.SUCCESS(c, chatModels)
+}

api/handler/chat_openai_handler.go

@@ -0,0 +1,233 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"geekai/core/types"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"io"
+	"strings"
+	"time"
+
+	req2 "github.com/imroc/req/v3"
+)
+
+type Usage struct {
+	Prompt           string `json:"prompt,omitempty"`
+	Content          string `json:"content,omitempty"`
+	PromptTokens     int    `json:"prompt_tokens"`
+	CompletionTokens int    `json:"completion_tokens"`
+	TotalTokens      int    `json:"total_tokens"`
+}
+
+type OpenAIResVo struct {
+	Id                string `json:"id"`
+	Object            string `json:"object"`
+	Created           int    `json:"created"`
+	Model             string `json:"model"`
+	SystemFingerprint string `json:"system_fingerprint"`
+	Choices           []struct {
+		Index   int `json:"index"`
+		Message struct {
+			Role    string `json:"role"`
+			Content string `json:"content"`
+		} `json:"message"`
+		Logprobs     interface{} `json:"logprobs"`
+		FinishReason string      `json:"finish_reason"`
+	} `json:"choices"`
+	Usage Usage `json:"usage"`
+}
+
+// OPenAI 消息发送实现
+func (h *ChatHandler) sendOpenAiMessage(
+	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 = model.ApiKey{}
+	response, err := h.doRequest(ctx, req, session, &apiKey)
+	logger.Info("HTTP请求完成，耗时：", time.Now().Sub(start))
+	if err != nil {
+		if strings.Contains(err.Error(), "context canceled") {
+			return fmt.Errorf("用户取消了请求：%s", prompt)
+		} else if strings.Contains(err.Error(), "no available key") {
+			return errors.New("抱歉😔😔😔，系统已经没有可用的 API KEY，请联系管理员！")
+		}
+		return err
+	} else {
+		defer response.Body.Close()
+	}
+
+	if response.StatusCode != 200 {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("请求 OpenAI API 失败：%d, %v", response.StatusCode, string(body))
+	}
+
+	contentType := response.Header.Get("Content-Type")
+	if strings.Contains(contentType, "text/event-stream") {
+		replyCreatedAt := time.Now() // 记录回复时间
+		// 循环读取 Chunk 消息
+		var message = types.Message{Role: "assistant"}
+		var contents = make([]string, 0)
+		var function model.Function
+		var toolCall = false
+		var arguments = make([]string, 0)
+		scanner := bufio.NewScanner(response.Body)
+		for scanner.Scan() {
+			line := scanner.Text()
+			if !strings.Contains(line, "data:") || len(line) < 30 {
+				continue
+			}
+			var responseBody = types.ApiResponse{}
+			err = json.Unmarshal([]byte(line[6:]), &responseBody)
+			if err != nil { // 数据解析出错
+				return errors.New(line)
+			}
+			if len(responseBody.Choices) == 0 { // Fixed: 兼容 Azure API 第一个输出空行
+				continue
+			}
+			if responseBody.Choices[0].Delta.Content == nil && responseBody.Choices[0].Delta.ToolCalls == nil {
+				continue
+			}
+
+			if responseBody.Choices[0].FinishReason == "stop" && len(contents) == 0 {
+				utils.SendChunkMsg(ws, "抱歉😔😔😔，AI助手由于未知原因已经停止输出内容。")
+				break
+			}
+
+			var tool types.ToolCall
+			if len(responseBody.Choices[0].Delta.ToolCalls) > 0 {
+				tool = responseBody.Choices[0].Delta.ToolCalls[0]
+				if toolCall && tool.Function.Name == "" {
+					arguments = append(arguments, tool.Function.Arguments)
+					continue
+				}
+			}
+
+			// 兼容 Function Call
+			fun := responseBody.Choices[0].Delta.FunctionCall
+			if fun.Name != "" {
+				tool = *new(types.ToolCall)
+				tool.Function.Name = fun.Name
+			} else if toolCall {
+				arguments = append(arguments, fun.Arguments)
+				continue
+			}
+
+			if !utils.IsEmptyValue(tool) {
+				res := h.DB.Where("name = ?", tool.Function.Name).First(&function)
+				if res.Error == nil {
+					toolCall = true
+					callMsg := fmt.Sprintf("正在调用工具 `%s` 作答 ...\n\n", function.Label)
+					utils.SendChunkMsg(ws, callMsg)
+					contents = append(contents, callMsg)
+				}
+				continue
+			}
+
+			if responseBody.Choices[0].FinishReason == "tool_calls" ||
+				responseBody.Choices[0].FinishReason == "function_call" { // 函数调用完毕
+				break
+			}
+
+			// output stopped
+			if responseBody.Choices[0].FinishReason != "" {
+				break // 输出完成或者输出中断了
+			} else {
+				content := responseBody.Choices[0].Delta.Content
+				contents = append(contents, utils.InterfaceToString(content))
+				utils.SendChunkMsg(ws, responseBody.Choices[0].Delta.Content)
+			}
+		} // end for
+
+		if err := scanner.Err(); err != nil {
+			if strings.Contains(err.Error(), "context canceled") {
+				logger.Info("用户取消了请求：", prompt)
+			} else {
+				logger.Error("信息读取出错：", err)
+			}
+		}
+
+		if toolCall { // 调用函数完成任务
+			params := make(map[string]interface{})
+			_ = utils.JsonDecode(strings.Join(arguments, ""), &params)
+			logger.Debugf("函数名称: %s, 函数参数：%s", function.Name, params)
+			params["user_id"] = userVo.Id
+			var apiRes types.BizVo
+			r, err := req2.C().R().SetHeader("Body-Type", "application/json").
+				SetHeader("Authorization", function.Token).
+				SetBody(params).Post(function.Action)
+			errMsg := ""
+			if err != nil {
+				errMsg = err.Error()
+			} else {
+				all, _ := io.ReadAll(r.Body)
+				err = json.Unmarshal(all, &apiRes)
+				if err != nil {
+					errMsg = err.Error()
+				} else if apiRes.Code != types.Success {
+					errMsg = apiRes.Message
+				}
+			}
+
+			if errMsg != "" {
+				errMsg = "调用函数工具出错：" + errMsg
+				contents = append(contents, errMsg)
+			} else {
+				errMsg = utils.InterfaceToString(apiRes.Data)
+				contents = append(contents, errMsg)
+			}
+			utils.SendChunkMsg(ws, errMsg)
+		}
+
+		// 消息发送成功
+		if len(contents) > 0 {
+			usage := Usage{
+				Prompt:           prompt,
+				Content:          strings.Join(contents, ""),
+				PromptTokens:     0,
+				CompletionTokens: 0,
+				TotalTokens:      0,
+			}
+			message.Content = usage.Content
+			h.saveChatHistory(req, usage, message, session, role, userVo, promptCreatedAt, replyCreatedAt)
+		}
+	} else { // 非流式输出
+		var respVo OpenAIResVo
+		body, err := io.ReadAll(response.Body)
+		if err != nil {
+			return fmt.Errorf("读取响应失败：%v", body)
+		}
+		err = json.Unmarshal(body, &respVo)
+		if err != nil {
+			return fmt.Errorf("解析响应失败：%v", body)
+		}
+		content := respVo.Choices[0].Message.Content
+		if strings.HasPrefix(req.Model, "o1-") {
+			content = fmt.Sprintf("AI思考结束，耗时：%d 秒。\n%s", time.Now().Unix()-session.Start, respVo.Choices[0].Message.Content)
+		}
+		utils.SendChunkMsg(ws, content)
+		respVo.Usage.Prompt = prompt
+		respVo.Usage.Content = content
+		h.saveChatHistory(req, respVo.Usage, respVo.Choices[0].Message, session, role, userVo, promptCreatedAt, time.Now())
+	}
+
+	return nil
+}

api/handler/chat_role_handler.go

@@ -0,0 +1,122 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type ChatRoleHandler struct {
+	BaseHandler
+}
+
+func NewChatRoleHandler(app *core.AppServer, db *gorm.DB) *ChatRoleHandler {
+	return &ChatRoleHandler{BaseHandler: BaseHandler{App: app, DB: db}}
+}
+
+// List 获取用户聊天应用列表
+func (h *ChatRoleHandler) List(c *gin.Context) {
+	tid := h.GetInt(c, "tid", 0)
+	var roles []model.ChatRole
+	session := h.DB.Where("enable", true)
+	if tid > 0 {
+		session = session.Where("tid", tid)
+	}
+	err := session.Order("sort_num ASC").Find(&roles).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	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)
+}
+
+// ListByUser 获取用户添加的角色列表
+func (h *ChatRoleHandler) ListByUser(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+	userId := h.GetLoginUserId(c)
+	var roles []model.ChatRole
+	session := h.DB.Where("enable", true)
+	// 如果用户没登录，则获取所有角色
+	if userId > 0 {
+		var user model.User
+		h.DB.First(&user, userId)
+		var roleKeys []string
+		err := utils.JsonDecode(user.ChatRoles, &roleKeys)
+		if err != nil {
+			resp.ERROR(c, "角色解析失败！")
+			return
+		}
+		// 保证用户至少有一个角色可用
+		if len(roleKeys) > 0 {
+			session = session.Where("marker IN ?", roleKeys)
+		}
+	}
+
+	if id > 0 {
+		session = session.Or("id", id)
+	}
+	res := session.Order("sort_num ASC").Find(&roles)
+	if res.Error != nil {
+		resp.ERROR(c, res.Error.Error())
+		return
+	}
+
+	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)
+}
+
+// UpdateRole 更新用户聊天角色
+func (h *ChatRoleHandler) UpdateRole(c *gin.Context) {
+	user, err := h.GetLoginUser(c)
+	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
+	}
+
+	err = h.DB.Model(&model.User{}).Where("id = ?", user.Id).UpdateColumn("chat_roles_json", utils.JsonEncode(data.Keys)).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c)
+}

api/handler/config_handler.go

@@ -0,0 +1,54 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/service"
+	"geekai/store/model"
+	"geekai/utils"
+	"geekai/utils/resp"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type ConfigHandler struct {
+	BaseHandler
+	licenseService *service.LicenseService
+}
+
+func NewConfigHandler(app *core.AppServer, db *gorm.DB, licenseService *service.LicenseService) *ConfigHandler {
+	return &ConfigHandler{BaseHandler: BaseHandler{App: app, DB: db}, licenseService: licenseService}
+}
+
+// Get 获取指定的系统配置
+func (h *ConfigHandler) Get(c *gin.Context) {
+	key := c.Query("key")
+	var config model.Config
+	res := h.DB.Where("marker", key).First(&config)
+	if res.Error != nil {
+		resp.ERROR(c, res.Error.Error())
+		return
+	}
+
+	var value map[string]interface{}
+	err := utils.JsonDecode(config.Config, &value)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, value)
+}
+
+// License 获取 License 配置
+func (h *ConfigHandler) License(c *gin.Context) {
+	license := h.licenseService.GetLicense()
+	resp.SUCCESS(c, license.Configs)
+}

api/handler/dalle_handler.go

@@ -0,0 +1,245 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/service"
+	"geekai/service/dalle"
+	"geekai/service/oss"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type DallJobHandler struct {
+	BaseHandler
+	dallService *dalle.Service
+	uploader    *oss.UploaderManager
+	userService *service.UserService
+}
+
+func NewDallJobHandler(app *core.AppServer, db *gorm.DB, service *dalle.Service, manager *oss.UploaderManager, userService *service.UserService) *DallJobHandler {
+	return &DallJobHandler{
+		dallService: service,
+		uploader:    manager,
+		userService: userService,
+		BaseHandler: BaseHandler{
+			App: app,
+			DB:  db,
+		},
+	}
+}
+
+// Image 创建一个绘画任务
+func (h *DallJobHandler) Image(c *gin.Context) {
+	var data types.DallTask
+	if err := c.ShouldBindJSON(&data); err != nil || data.Prompt == "" {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	var chatModel model.ChatModel
+	if res := h.DB.Where("id = ?", data.ModelId).First(&chatModel); res.Error != nil {
+		resp.ERROR(c, "模型不存在")
+		return
+	}
+
+	// 检查用户剩余算力
+	user, err := h.GetLoginUser(c)
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+	if user.Power < chatModel.Power {
+		resp.ERROR(c, "当前用户剩余算力不足以完成本次绘画！")
+		return
+	}
+
+	idValue, _ := c.Get(types.LoginUserID)
+	userId := utils.IntValue(utils.InterfaceToString(idValue), 0)
+	task := types.DallTask{
+		ClientId:         data.ClientId,
+		UserId:           uint(userId),
+		ModelId:          chatModel.Id,
+		ModelName:        chatModel.Value,
+		Prompt:           data.Prompt,
+		Quality:          data.Quality,
+		Size:             data.Size,
+		Style:            data.Style,
+		TranslateModelId: h.App.SysConfig.TranslateModelId,
+		Power:            chatModel.Power,
+	}
+	job := model.DallJob{
+		UserId:   uint(userId),
+		Prompt:   data.Prompt,
+		Power:    chatModel.Power,
+		TaskInfo: utils.JsonEncode(task),
+	}
+	res := h.DB.Create(&job)
+	if res.Error != nil {
+		resp.ERROR(c, "error with save job: "+res.Error.Error())
+		return
+	}
+
+	task.Id = job.Id
+	h.dallService.PushTask(task)
+
+	// 扣减算力
+	err = h.userService.DecreasePower(int(user.Id), chatModel.Power, model.PowerLog{
+		Type:   types.PowerConsume,
+		Model:  chatModel.Value,
+		Remark: fmt.Sprintf("绘画提示词：%s", utils.CutWords(task.Prompt, 10)),
+	})
+	if err != nil {
+		resp.ERROR(c, "error with decrease power: "+err.Error())
+		return
+	}
+	resp.SUCCESS(c)
+}
+
+// ImgWall 照片墙
+func (h *DallJobHandler) ImgWall(c *gin.Context) {
+	page := h.GetInt(c, "page", 0)
+	pageSize := h.GetInt(c, "page_size", 0)
+	err, jobs := h.getData(true, 0, page, pageSize, true)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, jobs)
+}
+
+// JobList 获取 SD 任务列表
+func (h *DallJobHandler) JobList(c *gin.Context) {
+	finish := h.GetBool(c, "finish")
+	userId := h.GetLoginUserId(c)
+	page := h.GetInt(c, "page", 0)
+	pageSize := h.GetInt(c, "page_size", 0)
+	publish := h.GetBool(c, "publish")
+
+	err, jobs := h.getData(finish, userId, page, pageSize, publish)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, jobs)
+}
+
+// JobList 获取任务列表
+func (h *DallJobHandler) getData(finish bool, userId uint, page int, pageSize int, publish bool) (error, vo.Page) {
+
+	session := h.DB.Session(&gorm.Session{})
+	if finish {
+		session = session.Where("progress >= ?", 100).Order("id DESC")
+	} else {
+		session = session.Where("progress < ?", 100).Order("id ASC")
+	}
+	if userId > 0 {
+		session = session.Where("user_id = ?", userId)
+	}
+	if publish {
+		session = session.Where("publish", publish)
+	}
+	if page > 0 && pageSize > 0 {
+		offset := (page - 1) * pageSize
+		session = session.Offset(offset).Limit(pageSize)
+	}
+	// 统计总数
+	var total int64
+	session.Model(&model.DallJob{}).Count(&total)
+
+	var items []model.DallJob
+	res := session.Find(&items)
+	if res.Error != nil {
+		return res.Error, vo.Page{}
+	}
+
+	var jobs = make([]vo.DallJob, 0)
+	for _, item := range items {
+		var job vo.DallJob
+		err := utils.CopyObject(item, &job)
+		if err != nil {
+			continue
+		}
+		jobs = append(jobs, job)
+	}
+
+	return nil, vo.NewPage(total, page, pageSize, jobs)
+}
+
+// Remove remove task image
+func (h *DallJobHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+	userId := h.GetLoginUserId(c)
+	var job model.DallJob
+	if res := h.DB.Where("id = ? AND user_id = ?", id, userId).First(&job); res.Error != nil {
+		resp.ERROR(c, "记录不存在")
+		return
+	}
+
+	// 删除任务
+	err := h.DB.Delete(&job).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// remove image
+	err = h.uploader.GetUploadHandler().Delete(job.ImgURL)
+	if err != nil {
+		logger.Error("remove image failed: ", err)
+	}
+
+	resp.SUCCESS(c)
+}
+
+// Publish 发布/取消发布图片到画廊显示
+func (h *DallJobHandler) Publish(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+	userId := h.GetLoginUserId(c)
+	action := h.GetBool(c, "action") // 发布动作，true => 发布，false => 取消分享
+
+	err := h.DB.Model(&model.DallJob{Id: uint(id), UserId: userId}).UpdateColumn("publish", action).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c)
+}
+
+func (h *DallJobHandler) GetModels(c *gin.Context) {
+	var models []model.ChatModel
+	err := h.DB.Where("type", "img").Where("enabled", true).Find(&models).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	var modelVos []vo.ChatModel
+	for _, v := range models {
+		var modelVo vo.ChatModel
+		err := utils.CopyObject(v, &modelVo)
+		if err != nil {
+			continue
+		}
+		modelVo.Id = v.Id
+		modelVos = append(modelVos, modelVo)
+	}
+
+	resp.SUCCESS(c, modelVos)
+}

api/handler/function_handler.go

@@ -0,0 +1,277 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"errors"
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/service"
+	"geekai/service/dalle"
+	"geekai/service/oss"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/golang-jwt/jwt/v5"
+	"github.com/imroc/req/v3"
+	"gorm.io/gorm"
+)
+
+type FunctionHandler struct {
+	BaseHandler
+	config        types.ApiConfig
+	uploadManager *oss.UploaderManager
+	dallService   *dalle.Service
+	userService   *service.UserService
+}
+
+func NewFunctionHandler(
+	server *core.AppServer,
+	db *gorm.DB,
+	config *types.AppConfig,
+	manager *oss.UploaderManager,
+	dallService *dalle.Service,
+	userService *service.UserService) *FunctionHandler {
+	return &FunctionHandler{
+		BaseHandler: BaseHandler{
+			App: server,
+			DB:  db,
+		},
+		config:        config.ApiConfig,
+		uploadManager: manager,
+		dallService:   dallService,
+		userService:   userService,
+	}
+}
+
+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"`
+}
+
+// check authorization
+func (h *FunctionHandler) checkAuth(c *gin.Context) error {
+	tokenString := c.GetHeader(types.UserAuthHeader)
+	token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
+		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
+		}
+
+		return []byte(h.App.Config.Session.SecretKey), nil
+	})
+
+	if err != nil {
+		return fmt.Errorf("error with parse auth token: %v", err)
+	}
+
+	claims, ok := token.Claims.(jwt.MapClaims)
+	if !ok || !token.Valid {
+		return errors.New("token is invalid")
+	}
+
+	expr := utils.IntValue(utils.InterfaceToString(claims["expired"]), 0)
+	if expr > 0 && int64(expr) < time.Now().Unix() {
+		return errors.New("token is expired")
+	}
+
+	return nil
+}
+
+// WeiBo 微博热搜
+func (h *FunctionHandler) WeiBo(c *gin.Context) {
+	if err := h.checkAuth(c); err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	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 {
+		resp.ERROR(c, fmt.Sprintf("%v", err))
+		return
+	}
+	if r.IsErrorState() {
+		resp.ERROR(c, fmt.Sprintf("error http code status: %v", r.Status))
+	}
+
+	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 err := h.checkAuth(c); err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	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 {
+		resp.ERROR(c, fmt.Sprintf("%v", err))
+		return
+	}
+	if r.IsErrorState() {
+		resp.ERROR(c, fmt.Sprintf("%v", 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, res.Data.Title)
+	resp.SUCCESS(c, strings.Join(builder, "\n\n"))
+}
+
+// Dall3 DallE3 AI 绘图
+func (h *FunctionHandler) Dall3(c *gin.Context) {
+	if err := h.checkAuth(c); err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	var params map[string]interface{}
+	if err := c.ShouldBindJSON(&params); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	logger.Debugf("绘画参数：%+v", params)
+	var user model.User
+	res := h.DB.Where("id = ?", params["user_id"]).First(&user)
+	if res.Error != nil {
+		resp.ERROR(c, "当前用户不存在！")
+		return
+	}
+
+	if user.Power < h.App.SysConfig.DallPower {
+		resp.ERROR(c, "创建 DALL-E 绘图任务失败，算力不足")
+		return
+	}
+
+	// create dall task
+	prompt := utils.InterfaceToString(params["prompt"])
+	task := types.DallTask{
+		UserId:           user.Id,
+		Prompt:           prompt,
+		ModelId:          0,
+		ModelName:        "dall-e-3",
+		TranslateModelId: h.App.SysConfig.TranslateModelId,
+		N:                1,
+		Quality:          "standard",
+		Size:             "1024x1024",
+		Style:            "vivid",
+		Power:            h.App.SysConfig.DallPower,
+	}
+	job := model.DallJob{
+		UserId:   user.Id,
+		Prompt:   prompt,
+		Power:    h.App.SysConfig.DallPower,
+		TaskInfo: utils.JsonEncode(task),
+	}
+	err := h.DB.Create(&job).Error
+	if err != nil {
+		resp.ERROR(c, "创建 DALL-E 绘图任务失败："+err.Error())
+		return
+	}
+
+	task.Id = job.Id
+	content, err := h.dallService.Image(task, true)
+	if err != nil {
+		resp.ERROR(c, "任务执行失败："+err.Error())
+		return
+	}
+
+	// 扣减算力
+	err = h.userService.DecreasePower(int(user.Id), job.Power, model.PowerLog{
+		Type:   types.PowerConsume,
+		Model:  task.ModelName,
+		Remark: fmt.Sprintf("绘画提示词：%s", utils.CutWords(job.Prompt, 10)),
+	})
+	if err != nil {
+		resp.ERROR(c, "扣减算力失败："+err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, content)
+}
+
+// List 获取所有的工具函数列表
+func (h *FunctionHandler) List(c *gin.Context) {
+	var items []model.Function
+	err := h.DB.Where("enabled", true).Find(&items).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	tools := make([]vo.Function, 0)
+	for _, v := range items {
+		var f vo.Function
+		err = utils.CopyObject(v, &f)
+		if err != nil {
+			continue
+		}
+		f.Action = ""
+		f.Token = ""
+		tools = append(tools, f)
+	}
+
+	resp.SUCCESS(c, tools)
+}

api/handler/invite_handler.go

@@ -0,0 +1,92 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"strings"
+)
+
+// InviteHandler 用户邀请
+type InviteHandler struct {
+	BaseHandler
+}
+
+func NewInviteHandler(app *core.AppServer, db *gorm.DB) *InviteHandler {
+	return &InviteHandler{BaseHandler: BaseHandler{App: app, DB: db}}
+}
+
+// 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) {
+	page := h.GetInt(c, "page", 1)
+	pageSize := h.GetInt(c, "page_size", 20)
+	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 := (page - 1) * pageSize
+	res := session.Order("id DESC").Offset(offset).Limit(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, page, 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)
+}

api/handler/markmap_handler.go

@@ -0,0 +1,110 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/service"
+	"geekai/store/model"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+// MarkMapHandler 生成思维导图
+type MarkMapHandler struct {
+	BaseHandler
+	clients     *types.LMap[int, *types.WsClient]
+	userService *service.UserService
+}
+
+func NewMarkMapHandler(app *core.AppServer, db *gorm.DB, userService *service.UserService) *MarkMapHandler {
+	return &MarkMapHandler{
+		BaseHandler: BaseHandler{App: app, DB: db},
+		clients:     types.NewLMap[int, *types.WsClient](),
+		userService: userService,
+	}
+}
+
+// Generate 生成思维导图
+func (h *MarkMapHandler) Generate(c *gin.Context) {
+	var data struct {
+		Prompt  string `json:"prompt"`
+		ModelId int    `json:"model_id"`
+	}
+
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	userId := h.GetLoginUserId(c)
+	var user model.User
+	err := h.DB.Where("id", userId).First(&user, userId).Error
+	if err != nil {
+		resp.ERROR(c, "error with query user info")
+		return
+	}
+	var chatModel model.ChatModel
+	err = h.DB.Where("id", data.ModelId).First(&chatModel).Error
+	if err != nil {
+		resp.ERROR(c, "error with query chat model")
+		return
+	}
+
+	if user.Power < chatModel.Power {
+		resp.ERROR(c, fmt.Sprintf("您当前剩余算力（%d）已不足以支付当前模型算力（%d）！", user.Power, chatModel.Power))
+		return
+	}
+
+	messages := make([]interface{}, 0)
+	messages = append(messages, types.Message{Role: "system", Content: `
+你是一位非常优秀的思维导图助手， 你能帮助用户整理思路，根据用户提供的主题或内容，快速生成结构清晰，有条理的思维导图，然后以 Markdown 格式输出。markdown 只需要输出一级标题，二级标题，三级标题，四级标题，最多输出四级，除此之外不要输出任何其他 markdown 标记。下面是一个合格的例子：
+# Geek-AI 助手
+
+## 完整的开源系统
+### 前端开源
+### 后端开源
+
+## 支持各种大模型
+### OpenAI 
+### Azure 
+### 文心一言
+### 通义千问
+
+## 集成多种收费方式
+### 支付宝
+### 微信
+
+请直接生成结果，不要任何解释性语句。
+`})
+	messages = append(messages, types.Message{Role: "user", Content: fmt.Sprintf("请生成一份有关【%s】一份思维导图，要求结构清晰，有条理", data.Prompt)})
+	content, err := utils.SendOpenAIMessage(h.DB, messages, data.ModelId)
+	if err != nil {
+		resp.ERROR(c, fmt.Sprintf("请求 OpenAI API 失败: %s", err))
+		return
+	}
+
+	// 扣减算力
+	if chatModel.Power > 0 {
+		err = h.userService.DecreasePower(int(userId), chatModel.Power, model.PowerLog{
+			Type:   types.PowerConsume,
+			Model:  chatModel.Value,
+			Remark: fmt.Sprintf("AI绘制思维导图，模型名称：%s, ", chatModel.Value),
+		})
+		if err != nil {
+			resp.ERROR(c, "error with save power log, "+err.Error())
+			return
+		}
+	}
+
+	resp.SUCCESS(c, content)
+}

api/handler/menu_handler.go

@@ -0,0 +1,49 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type MenuHandler struct {
+	BaseHandler
+}
+
+func NewMenuHandler(app *core.AppServer, db *gorm.DB) *MenuHandler {
+	return &MenuHandler{BaseHandler: BaseHandler{App: app, DB: db}}
+}
+
+// List 数据列表
+func (h *MenuHandler) List(c *gin.Context) {
+	index := h.GetBool(c, "index")
+	var items []model.Menu
+	var list = make([]vo.Menu, 0)
+	session := h.DB.Session(&gorm.Session{})
+	session = session.Where("enabled", true)
+	if index {
+		session = session.Where("id IN ?", h.App.SysConfig.IndexNavs)
+	}
+	res := session.Order("sort_num ASC").Find(&items)
+	if res.Error == nil {
+		for _, item := range items {
+			var product vo.Menu
+			err := utils.CopyObject(item, &product)
+			if err == nil {
+				list = append(list, product)
+			}
+		}
+	}
+	resp.SUCCESS(c, list)
+}

api/handler/mj_handler.go

@@ -0,0 +1,437 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/service"
+	"geekai/service/mj"
+	"geekai/service/oss"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type MidJourneyHandler struct {
+	BaseHandler
+	mjService   *mj.Service
+	snowflake   *service.Snowflake
+	uploader    *oss.UploaderManager
+	userService *service.UserService
+}
+
+func NewMidJourneyHandler(app *core.AppServer, db *gorm.DB, snowflake *service.Snowflake, service *mj.Service, manager *oss.UploaderManager, userService *service.UserService) *MidJourneyHandler {
+	return &MidJourneyHandler{
+		snowflake:   snowflake,
+		mjService:   service,
+		uploader:    manager,
+		userService: userService,
+		BaseHandler: BaseHandler{
+			App: app,
+			DB:  db,
+		},
+	}
+}
+
+func (h *MidJourneyHandler) preCheck(c *gin.Context) bool {
+	user, err := h.GetLoginUser(c)
+	if err != nil {
+		resp.NotAuth(c)
+		return false
+	}
+
+	if user.Power < h.App.SysConfig.MjPower {
+		resp.ERROR(c, "当前用户剩余算力不足以完成本次绘画！")
+		return false
+	}
+
+	return true
+
+}
+
+// Image 创建一个绘画任务
+func (h *MidJourneyHandler) Image(c *gin.Context) {
+	var data struct {
+		TaskType  string   `json:"task_type"`
+		ClientId  string   `json:"client_id"`
+		Prompt    string   `json:"prompt"`
+		NegPrompt string   `json:"neg_prompt"`
+		Rate      string   `json:"rate"`
+		Model     string   `json:"model"`   // 模型
+		Chaos     int      `json:"chaos"`   // 创意度取值范围: 0-100
+		Raw       bool     `json:"raw"`     // 是否开启原始模型
+		Seed      int64    `json:"seed"`    // 随机数
+		Stylize   int      `json:"stylize"` // 风格化
+		ImgArr    []string `json:"img_arr"`
+		Tile      bool     `json:"tile"`    // 重复平铺
+		Quality   float32  `json:"quality"` // 画质
+		Iw        float32  `json:"iw"`
+		CRef      string   `json:"cref"` //生成角色一致的图像
+		SRef      string   `json:"sref"` //生成风格一致的图像
+		Cw        int      `json:"cw"`   // 参考程度
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	if !h.preCheck(c) {
+		return
+	}
+
+	var params = ""
+	if data.Rate != "" && !strings.Contains(params, "--ar") {
+		params += " --ar " + data.Rate
+	}
+	if data.Seed > 0 && !strings.Contains(params, "--seed") {
+		params += fmt.Sprintf(" --seed %d", data.Seed)
+	}
+	if data.Stylize > 0 && !strings.Contains(params, "--s") && !strings.Contains(params, "--stylize") {
+		params += fmt.Sprintf(" --s %d", data.Stylize)
+	}
+	if data.Chaos > 0 && !strings.Contains(params, "--c") && !strings.Contains(params, "--chaos") {
+		params += fmt.Sprintf(" --c %d", data.Chaos)
+	}
+	if len(data.ImgArr) > 0 && data.Iw > 0 {
+		params += fmt.Sprintf(" --iw %.2f", data.Iw)
+	}
+	if data.Raw {
+		params += " --style raw"
+	}
+	if data.Quality > 0 {
+		params += fmt.Sprintf(" --q %.2f", data.Quality)
+	}
+	if data.Tile {
+		params += " --tile "
+	}
+	if data.CRef != "" {
+		params += fmt.Sprintf(" --cref %s", data.CRef)
+		if data.Cw > 0 {
+			params += fmt.Sprintf(" --cw %d", data.Cw)
+		} else {
+			params += " --cw 100"
+		}
+	}
+
+	if data.SRef != "" {
+		params += fmt.Sprintf(" --sref %s", data.SRef)
+	}
+	if data.Model != "" && !strings.Contains(params, "--v") && !strings.Contains(params, "--niji") {
+		params += fmt.Sprintf(" %s", data.Model)
+	}
+
+	// 处理融图和换脸的提示词
+	if data.TaskType == types.TaskSwapFace.String() || data.TaskType == types.TaskBlend.String() {
+		params = fmt.Sprintf("%s:%s", data.TaskType, strings.Join(data.ImgArr, ","))
+	}
+
+	// 如果本地图片上传的是相对地址，处理成绝对地址
+	for k, v := range data.ImgArr {
+		if !strings.HasPrefix(v, "http") {
+			data.ImgArr[k] = fmt.Sprintf("http://localhost:5678/%s", strings.TrimLeft(v, "/"))
+		}
+	}
+
+	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
+	}
+	task := types.MjTask{
+		ClientId:         data.ClientId,
+		TaskId:           taskId,
+		Type:             types.TaskType(data.TaskType),
+		Prompt:           data.Prompt,
+		NegPrompt:        data.NegPrompt,
+		Params:           params,
+		UserId:           userId,
+		ImgArr:           data.ImgArr,
+		Mode:             h.App.SysConfig.MjMode,
+		TranslateModelId: h.App.SysConfig.TranslateModelId,
+	}
+	job := model.MidJourneyJob{
+		Type:      data.TaskType,
+		UserId:    userId,
+		TaskId:    taskId,
+		TaskInfo:  utils.JsonEncode(task),
+		Progress:  0,
+		Prompt:    fmt.Sprintf("%s %s", data.Prompt, params),
+		Power:     h.App.SysConfig.MjPower,
+		CreatedAt: time.Now(),
+	}
+	opt := "绘图"
+	if data.TaskType == types.TaskBlend.String() {
+		job.Prompt = "融图：" + strings.Join(data.ImgArr, ",")
+		opt = "融图"
+	} else if data.TaskType == types.TaskSwapFace.String() {
+		job.Prompt = "换脸：" + strings.Join(data.ImgArr, ",")
+		opt = "换脸"
+	}
+
+	if res := h.DB.Create(&job); res.Error != nil || res.RowsAffected == 0 {
+		resp.ERROR(c, "添加任务失败："+res.Error.Error())
+		return
+	}
+
+	task.Id = job.Id
+	h.mjService.PushTask(task)
+
+	// update user's power
+	err = h.userService.DecreasePower(job.UserId, job.Power, model.PowerLog{
+		Type:   types.PowerConsume,
+		Model:  "mid-journey",
+		Remark: fmt.Sprintf("%s操作，任务ID：%s", opt, job.TaskId),
+	})
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c)
+}
+
+type reqVo struct {
+	Index       int    `json:"index"`
+	ClientId    string `json:"client_id"`
+	ChannelId   string `json:"channel_id"`
+	MessageId   string `json:"message_id"`
+	MessageHash string `json:"message_hash"`
+}
+
+// Upscale send upscale command to MidJourney Bot
+func (h *MidJourneyHandler) Upscale(c *gin.Context) {
+	var data reqVo
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if !h.preCheck(c) {
+		return
+	}
+
+	idValue, _ := c.Get(types.LoginUserID)
+	userId := utils.IntValue(utils.InterfaceToString(idValue), 0)
+	taskId, _ := h.snowflake.Next(true)
+	task := types.MjTask{
+		ClientId:    data.ClientId,
+		Type:        types.TaskUpscale,
+		UserId:      userId,
+		ChannelId:   data.ChannelId,
+		Index:       data.Index,
+		MessageId:   data.MessageId,
+		MessageHash: data.MessageHash,
+		Mode:        h.App.SysConfig.MjMode,
+	}
+	job := model.MidJourneyJob{
+		Type:      types.TaskUpscale.String(),
+		UserId:    userId,
+		TaskId:    taskId,
+		TaskInfo:  utils.JsonEncode(task),
+		Progress:  0,
+		Power:     h.App.SysConfig.MjActionPower,
+		CreatedAt: time.Now(),
+	}
+	if res := h.DB.Create(&job); res.Error != nil || res.RowsAffected == 0 {
+		resp.ERROR(c, "添加任务失败："+res.Error.Error())
+		return
+	}
+
+	task.Id = job.Id
+	h.mjService.PushTask(task)
+
+	// update user's power
+	err := h.userService.DecreasePower(job.UserId, job.Power, model.PowerLog{
+		Type:   types.PowerConsume,
+		Model:  "mid-journey",
+		Remark: fmt.Sprintf("Upscale 操作，任务ID：%s", job.TaskId),
+	})
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c)
+}
+
+// Variation send variation command to MidJourney Bot
+func (h *MidJourneyHandler) Variation(c *gin.Context) {
+	var data reqVo
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if !h.preCheck(c) {
+		return
+	}
+
+	idValue, _ := c.Get(types.LoginUserID)
+	userId := utils.IntValue(utils.InterfaceToString(idValue), 0)
+	taskId, _ := h.snowflake.Next(true)
+	task := types.MjTask{
+		Type:        types.TaskVariation,
+		ClientId:    data.ClientId,
+		UserId:      userId,
+		Index:       data.Index,
+		ChannelId:   data.ChannelId,
+		MessageId:   data.MessageId,
+		MessageHash: data.MessageHash,
+		Mode:        h.App.SysConfig.MjMode,
+	}
+	job := model.MidJourneyJob{
+		Type:      types.TaskVariation.String(),
+		ChannelId: data.ChannelId,
+		UserId:    userId,
+		TaskId:    taskId,
+		TaskInfo:  utils.JsonEncode(task),
+		Progress:  0,
+		Power:     h.App.SysConfig.MjActionPower,
+		CreatedAt: time.Now(),
+	}
+	if res := h.DB.Create(&job); res.Error != nil || res.RowsAffected == 0 {
+		resp.ERROR(c, "添加任务失败："+res.Error.Error())
+		return
+	}
+
+	task.Id = job.Id
+	h.mjService.PushTask(task)
+
+	err := h.userService.DecreasePower(job.UserId, job.Power, model.PowerLog{
+		Type:   types.PowerConsume,
+		Model:  "mid-journey",
+		Remark: fmt.Sprintf("Variation 操作，任务ID：%s", job.TaskId),
+	})
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c)
+}
+
+// ImgWall 照片墙
+func (h *MidJourneyHandler) ImgWall(c *gin.Context) {
+	page := h.GetInt(c, "page", 0)
+	pageSize := h.GetInt(c, "page_size", 0)
+	err, jobs := h.getData(true, 0, page, pageSize, true)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, jobs)
+}
+
+// JobList 获取 MJ 任务列表
+func (h *MidJourneyHandler) JobList(c *gin.Context) {
+	finish := h.GetBool(c, "finish")
+	userId := h.GetLoginUserId(c)
+	page := h.GetInt(c, "page", 0)
+	pageSize := h.GetInt(c, "page_size", 0)
+	publish := h.GetBool(c, "publish")
+
+	err, jobs := h.getData(finish, userId, page, pageSize, publish)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, jobs)
+}
+
+// JobList 获取 MJ 任务列表
+func (h *MidJourneyHandler) getData(finish bool, userId uint, page int, pageSize int, publish bool) (error, vo.Page) {
+	session := h.DB.Session(&gorm.Session{})
+	if finish {
+		session = session.Where("progress >= ?", 100).Order("id DESC")
+	} else {
+		session = session.Where("progress < ?", 100).Order("id ASC")
+	}
+	if userId > 0 {
+		session = session.Where("user_id = ?", userId)
+	}
+	if publish {
+		session = session.Where("publish = ?", publish)
+	}
+	if page > 0 && pageSize > 0 {
+		offset := (page - 1) * pageSize
+		session = session.Offset(offset).Limit(pageSize)
+	}
+
+	// 统计总数
+	var total int64
+	session.Model(&model.MidJourneyJob{}).Count(&total)
+
+	var items []model.MidJourneyJob
+	res := session.Find(&items)
+	if res.Error != nil {
+		return res.Error, vo.Page{}
+	}
+
+	var jobs = make([]vo.MidJourneyJob, 0)
+	for _, item := range items {
+		var job vo.MidJourneyJob
+		err := utils.CopyObject(item, &job)
+		if err != nil {
+			continue
+		}
+		jobs = append(jobs, job)
+	}
+	return nil, vo.NewPage(total, page, pageSize, jobs)
+}
+
+// Remove remove task image
+func (h *MidJourneyHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+	userId := h.GetInt(c, "user_id", 0)
+	var job model.MidJourneyJob
+	if res := h.DB.Where("id = ? AND user_id = ?", id, userId).First(&job); res.Error != nil {
+		resp.ERROR(c, "记录不存在")
+		return
+	}
+
+	// remove job
+	err := h.DB.Delete(&job).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// remove image
+	err = h.uploader.GetUploadHandler().Delete(job.ImgURL)
+	if err != nil {
+		logger.Error("remove image failed: ", err)
+	}
+
+	resp.SUCCESS(c)
+}
+
+// Publish 发布图片到画廊显示
+func (h *MidJourneyHandler) Publish(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+	userId := h.GetInt(c, "user_id", 0)
+	action := h.GetBool(c, "action") // 发布动作，true => 发布，false => 取消分享
+	err := h.DB.Model(&model.MidJourneyJob{Id: uint(id), UserId: userId}).UpdateColumn("publish", action).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c)
+}

api/handler/net_handler.go

@@ -0,0 +1,161 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/service/oss"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"io"
+	"net/http"
+	"time"
+)
+
+type NetHandler struct {
+	BaseHandler
+	uploaderManager *oss.UploaderManager
+}
+
+func NewNetHandler(app *core.AppServer, db *gorm.DB, manager *oss.UploaderManager) *NetHandler {
+	return &NetHandler{BaseHandler: BaseHandler{App: app, DB: db}, uploaderManager: manager}
+}
+
+func (h *NetHandler) Upload(c *gin.Context) {
+	file, err := h.uploaderManager.GetUploadHandler().PutFile(c, "file")
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	logger.Info("upload file: ", file.Name)
+	// cut the file name if it's too long
+	if len(file.Name) > 100 {
+		file.Name = file.Name[:90] + file.Ext
+	}
+
+	userId := h.GetLoginUserId(c)
+	res := h.DB.Create(&model.File{
+		UserId:    int(userId),
+		Name:      file.Name,
+		ObjKey:    file.ObjKey,
+		URL:       file.URL,
+		Ext:       file.Ext,
+		Size:      file.Size,
+		CreatedAt: time.Time{},
+	})
+	if res.Error != nil || res.RowsAffected == 0 {
+		resp.ERROR(c, "error with update database: "+res.Error.Error())
+		return
+	}
+
+	resp.SUCCESS(c, file)
+}
+
+func (h *NetHandler) List(c *gin.Context) {
+	var data struct {
+		Urls     []string `json:"urls,omitempty"`
+		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)
+	var items []model.File
+	var files = make([]vo.File, 0)
+	session := h.DB.Session(&gorm.Session{})
+	session = session.Where("user_id = ?", userId)
+	if len(data.Urls) > 0 {
+		session = session.Where("url IN ?", data.Urls)
+	}
+	// 统计总数
+	var total int64
+	session.Model(&model.File{}).Count(&total)
+
+	if data.Page > 0 && data.PageSize > 0 {
+		offset := (data.Page - 1) * data.PageSize
+		session = session.Offset(offset).Limit(data.PageSize)
+	}
+	err := session.Order("id desc").Find(&items).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	for _, v := range items {
+		var file vo.File
+		err := utils.CopyObject(v, &file)
+		if err != nil {
+			logger.Error(err)
+			continue
+		}
+		file.CreatedAt = v.CreatedAt.Unix()
+		files = append(files, file)
+	}
+
+	resp.SUCCESS(c, vo.NewPage(total, data.Page, data.PageSize, files))
+}
+
+// Remove remove files
+func (h *NetHandler) Remove(c *gin.Context) {
+	userId := h.GetLoginUserId(c)
+	id := h.GetInt(c, "id", 0)
+	var file model.File
+	tx := h.DB.Where("user_id = ? AND id = ?", userId, id).First(&file)
+	if tx.Error != nil || file.Id == 0 {
+		resp.ERROR(c, "file not existed")
+		return
+	}
+
+	// remove database
+	tx = h.DB.Model(&model.File{}).Delete("id = ?", id)
+	if tx.Error != nil || tx.RowsAffected == 0 {
+		resp.ERROR(c, "failed to update database")
+		return
+	}
+	// remove files
+	objectKey := file.ObjKey
+	if objectKey == "" {
+		objectKey = file.URL
+	}
+	_ = h.uploaderManager.GetUploadHandler().Delete(objectKey)
+	resp.SUCCESS(c)
+}
+
+func (h *NetHandler) Download(c *gin.Context) {
+	fileUrl := c.Query("url")
+	// 使用http工具下载文件
+	if fileUrl == "" {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	// 使用http.Get下载文件
+	r, err := http.Get(fileUrl)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	defer r.Body.Close()
+
+	if r.StatusCode != http.StatusOK {
+		resp.ERROR(c, "error status："+r.Status)
+		return
+	}
+
+	c.Status(http.StatusOK)
+	// 将下载的文件内容写入响应
+	_, _ = io.Copy(c.Writer, r.Body)
+}

api/handler/order_handler.go

@@ -0,0 +1,98 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type OrderHandler struct {
+	BaseHandler
+}
+
+func NewOrderHandler(app *core.AppServer, db *gorm.DB) *OrderHandler {
+	return &OrderHandler{BaseHandler: BaseHandler{App: app, DB: db}}
+}
+
+// List 订单列表
+func (h *OrderHandler) List(c *gin.Context) {
+	page := h.GetInt(c, "page", 1)
+	pageSize := h.GetInt(c, "page_size", 20)
+	userId := h.GetLoginUserId(c)
+	session := h.DB.Session(&gorm.Session{}).Where("user_id = ? AND status = ?", userId, types.OrderPaidSuccess)
+	var total int64
+	session.Model(&model.Order{}).Count(&total)
+	var items []model.Order
+	var list = make([]vo.Order, 0)
+	offset := (page - 1) * pageSize
+	res := session.Order("id DESC").Offset(offset).Limit(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()
+				payMethod, ok := types.PayMethods[item.PayWay]
+				if !ok {
+					payMethod = item.PayWay
+				}
+				payName, ok := types.PayNames[item.PayType]
+				if !ok {
+					payName = item.PayWay
+				}
+				order.PayMethod = payMethod
+				order.PayName = payName
+				list = append(list, order)
+			} else {
+				logger.Error(err)
+			}
+		}
+	}
+	resp.SUCCESS(c, vo.NewPage(total, page, pageSize, list))
+}
+
+// Query 查询订单状态
+func (h *OrderHandler) Query(c *gin.Context) {
+	orderNo := h.GetTrim(c, "order_no")
+	var order model.Order
+	res := h.DB.Where("order_no = ?", 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 = ?", 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})
+}

api/handler/payment_handler.go

@@ -0,0 +1,453 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"embed"
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/service"
+	"geekai/service/payment"
+	"geekai/store/model"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type PayWay struct {
+	Name  string `json:"name"`
+	Value string `json:"value"`
+}
+
+// PaymentHandler 支付服务回调 handler
+type PaymentHandler struct {
+	BaseHandler
+	alipayService    *payment.AlipayService
+	huPiPayService   *payment.HuPiPayService
+	geekPayService   *payment.GeekPayService
+	wechatPayService *payment.WechatPayService
+	snowflake        *service.Snowflake
+	userService      *service.UserService
+	fs               embed.FS
+	lock             sync.Mutex
+	signKey          string // 用来签名的随机秘钥
+}
+
+func NewPaymentHandler(
+	server *core.AppServer,
+	alipayService *payment.AlipayService,
+	huPiPayService *payment.HuPiPayService,
+	geekPayService *payment.GeekPayService,
+	wechatPayService *payment.WechatPayService,
+	db *gorm.DB,
+	userService *service.UserService,
+	snowflake *service.Snowflake,
+	fs embed.FS) *PaymentHandler {
+	return &PaymentHandler{
+		alipayService:    alipayService,
+		huPiPayService:   huPiPayService,
+		geekPayService:   geekPayService,
+		wechatPayService: wechatPayService,
+		snowflake:        snowflake,
+		userService:      userService,
+		fs:               fs,
+		lock:             sync.Mutex{},
+		BaseHandler: BaseHandler{
+			App: server,
+			DB:  db,
+		},
+		signKey: utils.RandString(32),
+	}
+}
+
+func (h *PaymentHandler) Pay(c *gin.Context) {
+	var data struct {
+		PayWay    string `json:"pay_way"`
+		PayType   string `json:"pay_type"`
+		ProductId int    `json:"product_id"`
+		UserId    int    `json:"user_id"`
+		Device    string `json:"device"`
+		Host      string `json:"host"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	var product model.Product
+	err := h.DB.Where("id", data.ProductId).First(&product).Error
+	if err != 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
+	err = h.DB.Where("id", data.UserId).First(&user).Error
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+
+	amount := product.Discount
+	var payURL, returnURL, notifyURL string
+	switch data.PayWay {
+	case "alipay":
+		if h.App.Config.AlipayConfig.NotifyURL != "" { // 用于本地调试支付
+			notifyURL = h.App.Config.AlipayConfig.NotifyURL
+		} else {
+			notifyURL = fmt.Sprintf("%s/api/payment/notify/alipay", data.Host)
+		}
+		if h.App.Config.AlipayConfig.ReturnURL != "" { // 用于本地调试支付
+			returnURL = h.App.Config.AlipayConfig.ReturnURL
+		} else {
+			returnURL = fmt.Sprintf("%s/payReturn", data.Host)
+		}
+		money := fmt.Sprintf("%.2f", amount)
+		if data.Device == "wechat" {
+			payURL, err = h.alipayService.PayMobile(payment.AlipayParams{
+				OutTradeNo: orderNo,
+				Subject:    product.Name,
+				TotalFee:   money,
+				ReturnURL:  returnURL,
+				NotifyURL:  notifyURL,
+			})
+		} else {
+			payURL, err = h.alipayService.PayPC(payment.AlipayParams{
+				OutTradeNo: orderNo,
+				Subject:    product.Name,
+				TotalFee:   money,
+				ReturnURL:  returnURL,
+				NotifyURL:  notifyURL,
+			})
+		}
+
+		if err != nil {
+			resp.ERROR(c, "error with generate pay url: "+err.Error())
+			return
+		}
+		break
+	case "wechat":
+		if h.App.Config.WechatPayConfig.NotifyURL != "" {
+			notifyURL = h.App.Config.WechatPayConfig.NotifyURL
+		} else {
+			notifyURL = fmt.Sprintf("%s/api/payment/notify/wechat", data.Host)
+		}
+		if data.Device == "wechat" {
+			payURL, err = h.wechatPayService.PayUrlH5(payment.WechatPayParams{
+				OutTradeNo: orderNo,
+				TotalFee:   int(amount * 100),
+				Subject:    product.Name,
+				NotifyURL:  notifyURL,
+				ClientIP:   c.ClientIP(),
+			})
+		} else {
+			payURL, err = h.wechatPayService.PayUrlNative(payment.WechatPayParams{
+				OutTradeNo: orderNo,
+				TotalFee:   int(amount * 100),
+				Subject:    product.Name,
+				NotifyURL:  notifyURL,
+			})
+		}
+		if err != nil {
+			resp.ERROR(c, err.Error())
+			return
+		}
+		break
+	case "hupi":
+		if h.App.Config.HuPiPayConfig.NotifyURL != "" {
+			notifyURL = h.App.Config.HuPiPayConfig.NotifyURL
+		} else {
+			notifyURL = fmt.Sprintf("%s/api/payment/notify/hupi", data.Host)
+		}
+		if h.App.Config.HuPiPayConfig.ReturnURL != "" {
+			returnURL = h.App.Config.HuPiPayConfig.ReturnURL
+		} else {
+			returnURL = fmt.Sprintf("%s/payReturn", data.Host)
+		}
+		r, err := h.huPiPayService.Pay(payment.HuPiPayParams{
+			Version:      "1.1",
+			TradeOrderId: orderNo,
+			TotalFee:     fmt.Sprintf("%f", amount),
+			Title:        product.Name,
+			NotifyURL:    notifyURL,
+			ReturnURL:    returnURL,
+			WapName:      "GeekAI助手",
+		})
+		if err != nil {
+			resp.ERROR(c, err.Error())
+			return
+		}
+		payURL = r.URL
+		break
+	case "geek":
+		if h.App.Config.GeekPayConfig.NotifyURL != "" {
+			notifyURL = h.App.Config.GeekPayConfig.NotifyURL
+		} else {
+			notifyURL = fmt.Sprintf("%s/api/payment/notify/geek", data.Host)
+		}
+		if h.App.Config.GeekPayConfig.ReturnURL != "" {
+			data.Host = utils.GetBaseURL(h.App.Config.GeekPayConfig.ReturnURL)
+		}
+		if data.Device == "wechat" { // 微信客户端打开，调回手机端用户中心页面
+			returnURL = fmt.Sprintf("%s/mobile/profile", data.Host)
+		} else {
+			returnURL = fmt.Sprintf("%s/payReturn", data.Host)
+		}
+		params := payment.GeekPayParams{
+			OutTradeNo: orderNo,
+			Method:     "web",
+			Name:       product.Name,
+			Money:      fmt.Sprintf("%f", amount),
+			ClientIP:   c.ClientIP(),
+			Device:     data.Device,
+			Type:       data.PayType,
+			ReturnURL:  returnURL,
+			NotifyURL:  notifyURL,
+		}
+
+		res, err := h.geekPayService.Pay(params)
+		if err != nil {
+			resp.ERROR(c, err.Error())
+			return
+		}
+		payURL = res.PayURL
+	default:
+		resp.ERROR(c, "不支持的支付渠道")
+		return
+	}
+
+	// 创建订单
+	remark := types.OrderRemark{
+		Days:     product.Days,
+		Power:    product.Power,
+		Name:     product.Name,
+		Price:    product.Price,
+		Discount: product.Discount,
+	}
+	order := model.Order{
+		UserId:    user.Id,
+		Username:  user.Username,
+		ProductId: product.Id,
+		OrderNo:   orderNo,
+		Subject:   product.Name,
+		Amount:    amount,
+		Status:    types.OrderNotPaid,
+		PayWay:    data.PayWay,
+		PayType:   data.PayType,
+		Remark:    utils.JsonEncode(remark),
+	}
+	err = h.DB.Create(&order).Error
+	if err != nil {
+		resp.ERROR(c, "error with create order: "+err.Error())
+		return
+	}
+	resp.SUCCESS(c, payURL)
+}
+
+// 异步通知回调公共逻辑
+func (h *PaymentHandler) notify(orderNo string, tradeNo string) error {
+	var order model.Order
+	err := h.DB.Where("order_no = ?", orderNo).First(&order).Error
+	if err != nil {
+		return fmt.Errorf("error with fetch order: %v", err)
+	}
+
+	h.lock.Lock()
+	defer h.lock.Unlock()
+
+	// 已支付订单，直接返回
+	if order.Status == types.OrderPaidSuccess {
+		return nil
+	}
+
+	var user model.User
+	err = h.DB.First(&user, order.UserId).Error
+	if err != nil {
+		return fmt.Errorf("error with fetch user info: %v", err)
+	}
+
+	var remark types.OrderRemark
+	err = utils.JsonDecode(order.Remark, &remark)
+	if err != nil {
+		return fmt.Errorf("error with decode order remark: %v", err)
+	}
+
+	// 增加用户算力
+	err = h.userService.IncreasePower(int(order.UserId), remark.Power, model.PowerLog{
+		Type:   types.PowerRecharge,
+		Model:  order.PayWay,
+		Remark: fmt.Sprintf("充值算力，金额：%f，订单号：%s", order.Amount, order.OrderNo),
+	})
+	if err != nil {
+		return err
+	}
+
+	// 更新订单状态
+	order.PayTime = time.Now().Unix()
+	order.Status = types.OrderPaidSuccess
+	order.TradeNo = tradeNo
+	err = h.DB.Updates(&order).Error
+	if err != nil {
+		return fmt.Errorf("error with update order info: %v", err)
+	}
+
+	// 更新产品销量
+	err = h.DB.Model(&model.Product{}).Where("id = ?", order.ProductId).
+		UpdateColumn("sales", gorm.Expr("sales + ?", 1)).Error
+	if err != nil {
+		return fmt.Errorf("error with update product sales: %v", err)
+	}
+
+	return nil
+}
+
+// GetPayWays 获取支付方式
+func (h *PaymentHandler) GetPayWays(c *gin.Context) {
+	payWays := make([]gin.H, 0)
+	if h.App.Config.AlipayConfig.Enabled {
+		payWays = append(payWays, gin.H{"pay_way": "alipay", "pay_type": "alipay"})
+	}
+	if h.App.Config.HuPiPayConfig.Enabled {
+		payWays = append(payWays, gin.H{"pay_way": "hupi", "pay_type": "wxpay"})
+	}
+	if h.App.Config.GeekPayConfig.Enabled {
+		for _, v := range h.App.Config.GeekPayConfig.Methods {
+			payWays = append(payWays, gin.H{"pay_way": "geek", "pay_type": v})
+		}
+	}
+	if h.App.Config.WechatPayConfig.Enabled {
+		payWays = append(payWays, gin.H{"pay_way": "wechat", "pay_type": "wxpay"})
+	}
+	resp.SUCCESS(c, payWays)
+}
+
+// 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")
+	tradeNo := c.Request.Form.Get("open_order_id")
+	logger.Infof("收到虎皮椒订单支付回调，%+v", c.Request.Form)
+
+	if err = h.huPiPayService.Check(orderNo); err != nil {
+		logger.Error("订单校验失败：", err)
+		c.String(http.StatusOK, "fail")
+		return
+	}
+
+	err = h.notify(orderNo, tradeNo)
+	if err != nil {
+		logger.Error(err)
+		c.String(http.StatusOK, "fail")
+		return
+	}
+
+	c.String(http.StatusOK, "success")
+}
+
+// AlipayNotify 支付宝支付回调
+func (h *PaymentHandler) AlipayNotify(c *gin.Context) {
+	err := c.Request.ParseForm()
+	if err != nil {
+		c.String(http.StatusOK, "fail")
+		return
+	}
+
+	result := h.alipayService.TradeVerify(c.Request)
+	logger.Infof("收到支付宝商号订单支付回调：%+v", result)
+	if !result.Success() {
+		logger.Error("订单校验失败：", result.Message)
+		c.String(http.StatusOK, "fail")
+		return
+	}
+
+	tradeNo := c.Request.Form.Get("trade_no")
+	err = h.notify(result.OutTradeNo, tradeNo)
+	if err != nil {
+		logger.Error(err)
+		c.String(http.StatusOK, "fail")
+		return
+	}
+
+	c.String(http.StatusOK, "success")
+}
+
+// GeekPayNotify 支付异步回调
+func (h *PaymentHandler) GeekPayNotify(c *gin.Context) {
+	var params = make(map[string]string)
+	for k := range c.Request.URL.Query() {
+		params[k] = c.Query(k)
+	}
+
+	logger.Infof("收到GeekPay订单支付回调：%+v", params)
+	// 检查支付状态
+	if params["trade_status"] != "TRADE_SUCCESS" {
+		c.String(http.StatusOK, "success")
+		return
+	}
+
+	sign := h.geekPayService.Sign(params)
+	if sign != c.Query("sign") {
+		logger.Errorf("签名验证失败, %s, %s", sign, c.Query("sign"))
+		c.String(http.StatusOK, "fail")
+		return
+	}
+
+	err := h.notify(params["out_trade_no"], params["trade_no"])
+	if err != nil {
+		logger.Error(err)
+		c.String(http.StatusOK, "fail")
+		return
+	}
+
+	c.String(http.StatusOK, "success")
+}
+
+// WechatPayNotify 微信商户支付异步回调
+func (h *PaymentHandler) WechatPayNotify(c *gin.Context) {
+	err := c.Request.ParseForm()
+	if err != nil {
+		c.String(http.StatusOK, "fail")
+		return
+	}
+
+	result := h.wechatPayService.TradeVerify(c.Request)
+	logger.Infof("收到微信商号订单支付回调：%+v", result)
+	if !result.Success() {
+		logger.Error("订单校验失败：", err)
+		c.JSON(http.StatusBadRequest, gin.H{
+			"code":    "FAIL",
+			"message": err.Error(),
+		})
+		return
+	}
+
+	err = h.notify(result.OutTradeNo, result.TradeId)
+	if err != nil {
+		logger.Error(err)
+		c.String(http.StatusOK, "fail")
+		return
+	}
+
+	c.String(http.StatusOK, "success")
+}

api/handler/power_log_handler.go

@@ -0,0 +1,74 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type PowerLogHandler struct {
+	BaseHandler
+}
+
+func NewPowerLogHandler(app *core.AppServer, db *gorm.DB) *PowerLogHandler {
+	return &PowerLogHandler{BaseHandler: BaseHandler{App: app, DB: db}}
+}
+
+func (h *PowerLogHandler) List(c *gin.Context) {
+	var data struct {
+		Model    string   `json:"model"`
+		Date     []string `json:"date"`
+		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{})
+	userId := h.GetLoginUserId(c)
+	session = session.Where("user_id", userId)
+	if data.Model != "" {
+		session = session.Where("model", data.Model)
+	}
+	if len(data.Date) == 2 {
+		start := data.Date[0] + " 00:00:00"
+		end := data.Date[1] + " 00:00:00"
+		session = session.Where("created_at >= ? AND created_at <= ?", start, end)
+	}
+
+	var total int64
+	session.Model(&model.PowerLog{}).Count(&total)
+	var items []model.PowerLog
+	var list = make([]vo.PowerLog, 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 log vo.PowerLog
+			err := utils.CopyObject(item, &log)
+			if err != nil {
+				continue
+			}
+			log.Id = item.Id
+			log.CreatedAt = item.CreatedAt.Unix()
+			log.TypeStr = item.Type.String()
+			list = append(list, log)
+		}
+	}
+	resp.SUCCESS(c, vo.NewPage(total, data.Page, data.PageSize, list))
+}

api/handler/product_handler.go

@@ -0,0 +1,48 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type ProductHandler struct {
+	BaseHandler
+}
+
+func NewProductHandler(app *core.AppServer, db *gorm.DB) *ProductHandler {
+	return &ProductHandler{BaseHandler: BaseHandler{App: app, DB: db}}
+}
+
+// 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)
+}

api/handler/prompt_handler.go

@@ -0,0 +1,155 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/service"
+	"geekai/store/model"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+// 提示词生成 handler
+// 使用 AI 生成绘画指令，歌词，视频生成指令等
+
+type PromptHandler struct {
+	BaseHandler
+	userService *service.UserService
+}
+
+func NewPromptHandler(app *core.AppServer, db *gorm.DB, userService *service.UserService) *PromptHandler {
+	return &PromptHandler{
+		BaseHandler: BaseHandler{
+			App: app,
+			DB:  db,
+		},
+		userService: userService,
+	}
+}
+
+// Lyric 生成歌词
+func (h *PromptHandler) Lyric(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 := utils.OpenAIRequest(h.DB, fmt.Sprintf(service.LyricPromptTemplate, data.Prompt), h.App.SysConfig.TranslateModelId)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	if h.App.SysConfig.PromptPower > 0 {
+		userId := h.GetLoginUserId(c)
+		h.userService.DecreasePower(int(userId), h.App.SysConfig.PromptPower, model.PowerLog{
+			Type:   types.PowerConsume,
+			Model:  h.getPromptModel(),
+			Remark: "生成歌词",
+		})
+	}
+
+	resp.SUCCESS(c, content)
+}
+
+// Image 生成 AI 绘画提示词
+func (h *PromptHandler) Image(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 := utils.OpenAIRequest(h.DB, fmt.Sprintf(service.ImagePromptOptimizeTemplate, data.Prompt), h.App.SysConfig.TranslateModelId)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	if h.App.SysConfig.PromptPower > 0 {
+		userId := h.GetLoginUserId(c)
+		h.userService.DecreasePower(int(userId), h.App.SysConfig.PromptPower, model.PowerLog{
+			Type:   types.PowerConsume,
+			Model:  h.getPromptModel(),
+			Remark: "生成绘画提示词",
+		})
+	}
+	resp.SUCCESS(c, strings.Trim(content, `"`))
+}
+
+// Video 生成视频提示词
+func (h *PromptHandler) Video(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 := utils.OpenAIRequest(h.DB, fmt.Sprintf(service.VideoPromptTemplate, data.Prompt), h.App.SysConfig.TranslateModelId)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	if h.App.SysConfig.PromptPower > 0 {
+		userId := h.GetLoginUserId(c)
+		h.userService.DecreasePower(int(userId), h.App.SysConfig.PromptPower, model.PowerLog{
+			Type:   types.PowerConsume,
+			Model:  h.getPromptModel(),
+			Remark: "生成视频脚本",
+		})
+	}
+
+	resp.SUCCESS(c, strings.Trim(content, `"`))
+}
+
+// MetaPrompt 生成元提示词
+func (h *PromptHandler) MetaPrompt(c *gin.Context) {
+	var data struct {
+		Prompt string `json:"prompt"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	messages := make([]interface{}, 0)
+	messages = append(messages, types.Message{
+		Role:    "system",
+		Content: service.MetaPromptTemplate,
+	})
+	messages = append(messages, types.Message{
+		Role:    "user",
+		Content: "Task, Goal, or the Role to actor is:\n" + data.Prompt,
+	})
+	content, err := utils.SendOpenAIMessage(h.DB, messages, 0)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, strings.Trim(content, `"`))
+}
+
+func (h *PromptHandler) getPromptModel() string {
+	if h.App.SysConfig.TranslateModelId > 0 {
+		var chatModel model.ChatModel
+		h.DB.Where("id", h.App.SysConfig.TranslateModelId).First(&chatModel)
+		return chatModel.Value
+	}
+	return "gpt-4o"
+}

api/handler/realtime_handler.go

@@ -0,0 +1,209 @@
+package handler
+
+import (
+	"encoding/json"
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/service"
+	"geekai/store/model"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"io"
+	"net/http"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/gorilla/websocket"
+	"github.com/imroc/req/v3"
+	"gorm.io/gorm"
+)
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+// OpenAI Realtime API Relay Server
+
+type RealtimeHandler struct {
+	BaseHandler
+	userService *service.UserService
+}
+
+func NewRealtimeHandler(server *core.AppServer, db *gorm.DB, userService *service.UserService) *RealtimeHandler {
+	return &RealtimeHandler{BaseHandler: BaseHandler{App: server, DB: db}, userService: userService}
+}
+
+func (h *RealtimeHandler) Connection(c *gin.Context) {
+	// 获取客户端请求中指定的子协议
+	clientProtocols := c.GetHeader("Sec-WebSocket-Protocol")
+	md := c.Query("model")
+
+	userId := h.GetLoginUserId(c)
+	var user model.User
+	if err := h.DB.Where("id", userId).First(&user).Error; err != nil {
+		c.Abort()
+		return
+	}
+
+	// 将 HTTP 协议升级为 Websocket 协议
+	subProtocols := strings.Split(clientProtocols, ",")
+	ws, err := (&websocket.Upgrader{
+		CheckOrigin:  func(r *http.Request) bool { return true },
+		Subprotocols: subProtocols,
+	}).Upgrade(c.Writer, c.Request, nil)
+	if err != nil {
+		logger.Error(err)
+		c.Abort()
+		return
+	}
+	defer ws.Close()
+
+	// 目前只针对 VIP 用户可以访问
+	if !user.Vip {
+		sendError(ws, "当前功能只针对 VIP 用户开放")
+		c.Abort()
+		return
+	}
+
+	var apiKey model.ApiKey
+	h.DB.Where("type", "realtime").Where("enabled", true).Order("last_used_at ASC").First(&apiKey)
+	if apiKey.Id == 0 {
+		sendError(ws, "管理员未配置 Realtime API KEY")
+		c.Abort()
+		return
+	}
+
+	apiURL := fmt.Sprintf("%s/v1/realtime?model=%s", apiKey.ApiURL, md)
+	// 连接到真实的后端服务器，传入相同的子协议
+	headers := http.Header{}
+	// 修正子协议内容
+	subProtocols[1] = "openai-insecure-api-key." + apiKey.Value
+	if clientProtocols != "" {
+		headers.Set("Sec-WebSocket-Protocol", strings.Join(subProtocols, ","))
+	}
+	backendConn, _, err := websocket.DefaultDialer.Dial(apiURL, headers)
+	if err != nil {
+		sendError(ws, "桥接后端 API 失败："+err.Error())
+		c.Abort()
+		return
+	}
+	defer backendConn.Close()
+
+	// 确保协议一致性，如果失败返回
+	if ws.Subprotocol() != backendConn.Subprotocol() {
+		sendError(ws, "Websocket 子协议不匹配")
+		c.Abort()
+		return
+	}
+
+	// 更新API KEY 最后使用时间
+	h.DB.Model(&model.ApiKey{}).Where("id", apiKey.Id).UpdateColumn("last_used_at", time.Now().Unix())
+
+	// 开始双向转发
+	errorChan := make(chan error, 2)
+	go relay(ws, backendConn, errorChan)
+	go relay(backendConn, ws, errorChan)
+
+	// 等待其中一个连接关闭
+	err = <-errorChan
+	logger.Infof("Relay ended: %v", err)
+}
+
+func relay(src, dst *websocket.Conn, errorChan chan error) {
+	for {
+		messageType, message, err := src.ReadMessage()
+		if err != nil {
+			errorChan <- err
+			return
+		}
+		err = dst.WriteMessage(messageType, message)
+		if err != nil {
+			errorChan <- err
+			return
+		}
+	}
+}
+
+func sendError(ws *websocket.Conn, message string) {
+	err := ws.WriteJSON(map[string]string{"event_id": "event_01", "type": "error", "error": message})
+	if err != nil {
+		logger.Error(err)
+	}
+}
+
+// OpenAI 实时语音对话，一次性对话
+func (h *RealtimeHandler) VoiceChat(c *gin.Context) {
+	var apiKey model.ApiKey
+	err := h.DB.Session(&gorm.Session{}).Where("type", "realtime").Where("enabled", true).First(&apiKey).Error
+	if err != nil {
+		resp.ERROR(c, fmt.Sprintf("error with fetch OpenAI API KEY：%v", err))
+		return
+	}
+
+	var response utils.OpenAIResponse
+	client := req.C()
+	if len(apiKey.ProxyURL) > 5 {
+		client.SetProxyURL(apiKey.ApiURL)
+	}
+	apiURL := fmt.Sprintf("%s/v1/chat/completions", apiKey.ApiURL)
+	logger.Infof("Sending %s request, API KEY:%s, PROXY: %s, Model: %s", apiKey.ApiURL, apiURL, apiKey.ProxyURL, "advanced-voice")
+	r, err := client.R().SetHeader("Body-Type", "application/json").
+		SetHeader("Authorization", "Bearer "+apiKey.Value).
+		SetBody(types.ApiRequest{
+			Model:       "advanced-voice",
+			Temperature: 0.9,
+			MaxTokens:   1024,
+			Stream:      false,
+			Messages: []interface{}{types.Message{
+				Role:    "user",
+				Content: "实时语音通话",
+			}},
+		}).Post(apiURL)
+	if err != nil {
+		resp.ERROR(c, fmt.Sprintf("请求 OpenAI API失败：%v", err))
+		return
+	}
+
+	if r.IsErrorState() {
+		resp.ERROR(c, fmt.Sprintf("请求 OpenAI API失败：%v", r.Status))
+		return
+	}
+
+	body, _ := io.ReadAll(r.Body)
+	err = json.Unmarshal(body, &response)
+	if err != nil {
+		resp.ERROR(c, fmt.Sprintf("解析API数据失败：%v, %s", err, string(body)))
+	}
+
+	// 更新 API KEY 的最后使用时间
+	h.DB.Model(&apiKey).UpdateColumn("last_used_at", time.Now().Unix())
+
+	// 扣减算力
+	userId := h.GetLoginUserId(c)
+	err = h.userService.DecreasePower(int(userId), h.App.SysConfig.AdvanceVoicePower, model.PowerLog{
+		Type:   types.PowerConsume,
+		Model:  "advanced-voice",
+		Remark: "实时语音通话",
+	})
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	logger.Infof("Response: %v", response.Choices[0].Message.Content)
+
+	// 提取链接
+	re := regexp.MustCompile(`\[(.*?)\]\((.*?)\)`)
+	links := re.FindAllStringSubmatch(response.Choices[0].Message.Content, -1)
+	var url = ""
+	if len(links) > 0 {
+		url = links[0][2]
+	}
+	resp.SUCCESS(c, url)
+}

api/handler/redeem_handler.go

@@ -0,0 +1,88 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/service"
+	"geekai/store/model"
+	"geekai/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"sync"
+	"time"
+)
+
+type RedeemHandler struct {
+	BaseHandler
+	lock        sync.Mutex
+	userService *service.UserService
+}
+
+func NewRedeemHandler(app *core.AppServer, db *gorm.DB, userService *service.UserService) *RedeemHandler {
+	return &RedeemHandler{BaseHandler: BaseHandler{App: app, DB: db}, userService: userService}
+}
+
+func (h *RedeemHandler) Verify(c *gin.Context) {
+	var data struct {
+		Code string `json:"code"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	userId := h.GetLoginUserId(c)
+
+	h.lock.Lock()
+	defer h.lock.Unlock()
+
+	var item model.Redeem
+	res := h.DB.Where("code", data.Code).First(&item)
+	if res.Error != nil {
+		resp.ERROR(c, "无效的兑换码！")
+		return
+	}
+
+	if !item.Enabled {
+		resp.ERROR(c, "当前兑换码已被禁用！")
+		return
+	}
+
+	if item.RedeemedAt > 0 {
+		resp.ERROR(c, "当前兑换码已使用，请勿重复使用！")
+		return
+	}
+
+	tx := h.DB.Begin()
+	err := h.userService.IncreasePower(int(userId), item.Power, model.PowerLog{
+		Type:   types.PowerRedeem,
+		Model:  "兑换码",
+		Remark: fmt.Sprintf("兑换码核销，算力：%d，兑换码：%s...", item.Power, item.Code[:10]),
+	})
+	if err != nil {
+		tx.Rollback()
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// 更新核销状态
+	item.RedeemedAt = time.Now().Unix()
+	item.UserId = userId
+	err = tx.Updates(&item).Error
+	if err != nil {
+		tx.Rollback()
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	tx.Commit()
+	resp.SUCCESS(c)
+
+}

api/handler/sd_handler.go

@@ -0,0 +1,283 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/service"
+	"geekai/service/oss"
+	"geekai/service/sd"
+	"geekai/store"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/go-redis/redis/v8"
+	"gorm.io/gorm"
+)
+
+type SdJobHandler struct {
+	BaseHandler
+	redis       *redis.Client
+	sdService   *sd.Service
+	uploader    *oss.UploaderManager
+	snowflake   *service.Snowflake
+	leveldb     *store.LevelDB
+	userService *service.UserService
+}
+
+func NewSdJobHandler(app *core.AppServer,
+	db *gorm.DB,
+	service *sd.Service,
+	manager *oss.UploaderManager,
+	snowflake *service.Snowflake,
+	userService *service.UserService,
+	levelDB *store.LevelDB) *SdJobHandler {
+	return &SdJobHandler{
+		sdService:   service,
+		uploader:    manager,
+		snowflake:   snowflake,
+		leveldb:     levelDB,
+		userService: userService,
+		BaseHandler: BaseHandler{
+			App: app,
+			DB:  db,
+		},
+	}
+}
+
+func (h *SdJobHandler) preCheck(c *gin.Context) bool {
+	user, err := h.GetLoginUser(c)
+	if err != nil {
+		resp.NotAuth(c)
+		return false
+	}
+
+	if user.Power < h.App.SysConfig.SdPower {
+		resp.ERROR(c, "当前用户剩余算力不足以完成本次绘画！")
+		return false
+	}
+
+	return true
+
+}
+
+// Image 创建一个绘画任务
+func (h *SdJobHandler) Image(c *gin.Context) {
+	if !h.preCheck(c) {
+		return
+	}
+
+	var data types.SdTaskParams
+	if err := c.ShouldBindJSON(&data); err != nil || data.Prompt == "" {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if data.Width <= 0 {
+		data.Width = 512
+	}
+	if data.Height <= 0 {
+		data.Height = 512
+	}
+	if data.CfgScale <= 0 {
+		data.CfgScale = 7
+	}
+	if data.Seed == 0 {
+		data.Seed = -1
+	}
+	if data.Steps <= 0 {
+		data.Steps = 20
+	}
+	if data.Sampler == "" {
+		data.Sampler = "Euler a"
+	}
+	idValue, _ := c.Get(types.LoginUserID)
+	userId := utils.IntValue(utils.InterfaceToString(idValue), 0)
+	taskId, err := h.snowflake.Next(true)
+	if err != nil {
+		resp.ERROR(c, "error with generate task id: "+err.Error())
+		return
+	}
+
+	task := types.SdTask{
+		ClientId: data.ClientId,
+		Type:     types.TaskImage,
+		Params: types.SdTaskParams{
+			TaskId:       taskId,
+			Prompt:       data.Prompt,
+			NegPrompt:    data.NegPrompt,
+			Steps:        data.Steps,
+			Sampler:      data.Sampler,
+			FaceFix:      data.FaceFix,
+			CfgScale:     data.CfgScale,
+			Seed:         data.Seed,
+			Height:       data.Height,
+			Width:        data.Width,
+			HdFix:        data.HdFix,
+			HdRedrawRate: data.HdRedrawRate,
+			HdScale:      data.HdScale,
+			HdScaleAlg:   data.HdScaleAlg,
+			HdSteps:      data.HdSteps,
+		},
+		UserId:           userId,
+		TranslateModelId: h.App.SysConfig.TranslateModelId,
+	}
+
+	job := model.SdJob{
+		UserId:    userId,
+		Type:      types.TaskImage.String(),
+		TaskId:    taskId,
+		Params:    utils.JsonEncode(task.Params),
+		TaskInfo:  utils.JsonEncode(task),
+		Prompt:    data.Prompt,
+		Progress:  0,
+		Power:     h.App.SysConfig.SdPower,
+		CreatedAt: time.Now(),
+	}
+	res := h.DB.Create(&job)
+	if res.Error != nil {
+		resp.ERROR(c, "error with save job: "+res.Error.Error())
+		return
+	}
+
+	task.Id = int(job.Id)
+	h.sdService.PushTask(task)
+
+	// update user's power
+	err = h.userService.DecreasePower(job.UserId, job.Power, model.PowerLog{
+		Type:   types.PowerConsume,
+		Model:  "stable-diffusion",
+		Remark: fmt.Sprintf("绘图操作，任务ID：%s", job.TaskId),
+	})
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c)
+}
+
+// ImgWall 照片墙
+func (h *SdJobHandler) ImgWall(c *gin.Context) {
+	page := h.GetInt(c, "page", 0)
+	pageSize := h.GetInt(c, "page_size", 0)
+	err, jobs := h.getData(true, 0, page, pageSize, true)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, jobs)
+}
+
+// JobList 获取 SD 任务列表
+func (h *SdJobHandler) JobList(c *gin.Context) {
+	finish := h.GetBool(c, "finish")
+	userId := h.GetLoginUserId(c)
+	page := h.GetInt(c, "page", 0)
+	pageSize := h.GetInt(c, "page_size", 0)
+	publish := h.GetBool(c, "publish")
+
+	err, jobs := h.getData(finish, userId, page, pageSize, publish)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, jobs)
+}
+
+// JobList 获取 MJ 任务列表
+func (h *SdJobHandler) getData(finish bool, userId uint, page int, pageSize int, publish bool) (error, vo.Page) {
+
+	session := h.DB.Session(&gorm.Session{})
+	if finish {
+		session = session.Where("progress >= ?", 100).Order("id DESC")
+	} else {
+		session = session.Where("progress < ?", 100).Order("id ASC")
+	}
+	if userId > 0 {
+		session = session.Where("user_id = ?", userId)
+	}
+	if publish {
+		session = session.Where("publish", publish)
+	}
+	if page > 0 && pageSize > 0 {
+		offset := (page - 1) * pageSize
+		session = session.Offset(offset).Limit(pageSize)
+	}
+
+	// 统计总数
+	var total int64
+	session.Model(&model.SdJob{}).Count(&total)
+
+	var items []model.SdJob
+	res := session.Find(&items)
+	if res.Error != nil {
+		return res.Error, vo.Page{}
+	}
+
+	var jobs = make([]vo.SdJob, 0)
+	for _, item := range items {
+		var job vo.SdJob
+		err := utils.CopyObject(item, &job)
+		if err != nil {
+			continue
+		}
+		jobs = append(jobs, job)
+	}
+
+	return nil, vo.NewPage(total, page, pageSize, jobs)
+}
+
+// Remove remove task image
+func (h *SdJobHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+	userId := h.GetLoginUserId(c)
+	var job model.SdJob
+	if res := h.DB.Where("id = ? AND user_id = ?", id, userId).First(&job); res.Error != nil {
+		resp.ERROR(c, "记录不存在")
+		return
+	}
+
+	// 删除任务
+	err := h.DB.Delete(&job).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// remove image
+	err = h.uploader.GetUploadHandler().Delete(job.ImgURL)
+	if err != nil {
+		logger.Error("remove image failed: ", err)
+	}
+
+	resp.SUCCESS(c)
+}
+
+// Publish 发布/取消发布图片到画廊显示
+func (h *SdJobHandler) Publish(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+	userId := h.GetLoginUserId(c)
+	action := h.GetBool(c, "action") // 发布动作，true => 发布，false => 取消分享
+
+	err := h.DB.Model(&model.SdJob{Id: uint(id), UserId: int(userId)}).UpdateColumn("publish", action).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c)
+}

api/handler/sms_handler.go

@@ -0,0 +1,119 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/service"
+	"geekai/service/sms"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"github.com/go-redis/redis/v8"
+)
+
+const CodeStorePrefix = "/verify/codes/"
+
+type SmsHandler struct {
+	BaseHandler
+	redis   *redis.Client
+	sms     *sms.ServiceManager
+	smtp    *service.SmtpService
+	captcha *service.CaptchaService
+}
+
+func NewSmsHandler(
+	app *core.AppServer,
+	client *redis.Client,
+	sms *sms.ServiceManager,
+	smtp *service.SmtpService,
+	captcha *service.CaptchaService) *SmsHandler {
+	return &SmsHandler{
+		redis:       client,
+		sms:         sms,
+		captcha:     captcha,
+		smtp:        smtp,
+		BaseHandler: BaseHandler{App: app}}
+}
+
+// SendCode 发送验证码
+func (h *SmsHandler) SendCode(c *gin.Context) {
+	var data struct {
+		Receiver string `json:"receiver"` // 接收者
+		Key      string `json:"key"`
+		Dots     string `json:"dots,omitempty"`
+		X        int    `json:"x,omitempty"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	if h.App.SysConfig.EnabledVerify {
+		var check bool
+		if data.X != 0 {
+			check = h.captcha.SlideCheck(data)
+		} else {
+			check = h.captcha.Check(data)
+		}
+		if !check {
+			resp.ERROR(c, "请先完人机验证")
+			return
+		}
+	}
+
+	code := utils.RandomNumber(6)
+	var err error
+	if strings.Contains(data.Receiver, "@") { // email
+		if !utils.Contains(h.App.SysConfig.RegisterWays, "email") {
+			resp.ERROR(c, "系统已禁用邮箱注册！")
+			return
+		}
+		// 检查邮箱后缀是否在白名单
+		if len(h.App.SysConfig.EmailWhiteList) > 0 {
+			inWhiteList := false
+			for _, suffix := range h.App.SysConfig.EmailWhiteList {
+				if strings.HasSuffix(data.Receiver, suffix) {
+					inWhiteList = true
+					break
+				}
+			}
+			if !inWhiteList {
+				resp.ERROR(c, "邮箱后缀不在白名单中")
+				return
+			}
+		}
+		err = h.smtp.SendVerifyCode(data.Receiver, code)
+	} else {
+		if !utils.Contains(h.App.SysConfig.RegisterWays, "mobile") {
+			resp.ERROR(c, "系统已禁用手机号注册！")
+			return
+		}
+		err = h.sms.GetService().SendVerifyCode(data.Receiver, code)
+
+	}
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// 存储验证码，等待后面注册验证
+	_, err = h.redis.Set(c, CodeStorePrefix+data.Receiver, code, 0).Result()
+	if err != nil {
+		resp.ERROR(c, "验证码保存失败")
+		return
+	}
+
+	if h.App.Debug {
+		resp.SUCCESS(c, code)
+	} else {
+		resp.SUCCESS(c)
+	}
+}

api/handler/suno_handler.go

@@ -0,0 +1,325 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/service"
+	"geekai/service/oss"
+	"geekai/service/suno"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"time"
+)
+
+type SunoHandler struct {
+	BaseHandler
+	sunoService *suno.Service
+	uploader    *oss.UploaderManager
+	userService *service.UserService
+}
+
+func NewSunoHandler(app *core.AppServer, db *gorm.DB, service *suno.Service, uploader *oss.UploaderManager, userService *service.UserService) *SunoHandler {
+	return &SunoHandler{
+		BaseHandler: BaseHandler{
+			App: app,
+			DB:  db,
+		},
+		sunoService: service,
+		uploader:    uploader,
+		userService: userService,
+	}
+}
+
+func (h *SunoHandler) Create(c *gin.Context) {
+
+	var data struct {
+		ClientId     string `json:"client_id"`
+		Prompt       string `json:"prompt"`
+		Instrumental bool   `json:"instrumental"`
+		Lyrics       string `json:"lyrics"`
+		Model        string `json:"model"`
+		Tags         string `json:"tags"`
+		Title        string `json:"title"`
+		Type         int    `json:"type"`
+		RefTaskId    string `json:"ref_task_id"`         // 续写的任务id
+		ExtendSecs   int    `json:"extend_secs"`         // 续写秒数
+		RefSongId    string `json:"ref_song_id"`         // 续写的歌曲id
+		SongId       string `json:"song_id,omitempty"`   // 要拼接的歌曲id
+		AudioURL     string `json:"audio_url,omitempty"` // 上传自己创作的歌曲
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	user, err := h.GetLoginUser(c)
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+
+	if user.Power < h.App.SysConfig.SunoPower {
+		resp.ERROR(c, "您的算力不足，请充值后再试！")
+		return
+	}
+
+	// 歌曲拼接
+	if data.SongId != "" && data.Type == 3 {
+		var song model.SunoJob
+		if err := h.DB.Where("song_id = ?", data.SongId).First(&song).Error; err == nil {
+			data.Instrumental = song.Instrumental
+			data.Model = song.ModelName
+			data.Tags = song.Tags
+		}
+		// 拼接歌词
+		var refSong model.SunoJob
+		if err := h.DB.Where("song_id = ?", data.RefSongId).First(&refSong).Error; err == nil {
+			data.Prompt = fmt.Sprintf("%s\n%s", song.Prompt, refSong.Prompt)
+		}
+	}
+	task := types.SunoTask{
+		ClientId:     data.ClientId,
+		UserId:       int(h.GetLoginUserId(c)),
+		Type:         data.Type,
+		Title:        data.Title,
+		RefTaskId:    data.RefTaskId,
+		RefSongId:    data.RefSongId,
+		ExtendSecs:   data.ExtendSecs,
+		Prompt:       data.Prompt,
+		Tags:         data.Tags,
+		Model:        data.Model,
+		Instrumental: data.Instrumental,
+		SongId:       data.SongId,
+		AudioURL:     data.AudioURL,
+	}
+
+	// 插入数据库
+	job := model.SunoJob{
+		UserId:       task.UserId,
+		Prompt:       data.Prompt,
+		Instrumental: data.Instrumental,
+		ModelName:    data.Model,
+		TaskInfo:     utils.JsonEncode(task),
+		Tags:         data.Tags,
+		Title:        data.Title,
+		Type:         data.Type,
+		RefSongId:    data.RefSongId,
+		RefTaskId:    data.RefTaskId,
+		ExtendSecs:   data.ExtendSecs,
+		Power:        h.App.SysConfig.SunoPower,
+		SongId:       utils.RandString(32),
+	}
+	if data.Lyrics != "" {
+		job.Prompt = data.Lyrics
+	}
+	tx := h.DB.Create(&job)
+	if tx.Error != nil {
+		resp.ERROR(c, tx.Error.Error())
+		return
+	}
+
+	// 创建任务
+	task.Id = job.Id
+	h.sunoService.PushTask(task)
+
+	// update user's power
+	err = h.userService.DecreasePower(job.UserId, job.Power, model.PowerLog{
+		Type:      types.PowerConsume,
+		Model:     job.ModelName,
+		Remark:    fmt.Sprintf("Suno 文生歌曲，%s", job.ModelName),
+		CreatedAt: time.Now(),
+	})
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c)
+}
+
+func (h *SunoHandler) List(c *gin.Context) {
+	userId := h.GetLoginUserId(c)
+	page := h.GetInt(c, "page", 1)
+	pageSize := h.GetInt(c, "page_size", 20)
+	session := h.DB.Session(&gorm.Session{}).Where("user_id", userId)
+
+	// 统计总数
+	var total int64
+	session.Model(&model.SunoJob{}).Count(&total)
+
+	if page > 0 && pageSize > 0 {
+		offset := (page - 1) * pageSize
+		session = session.Offset(offset).Limit(pageSize)
+	}
+	var list []model.SunoJob
+	err := session.Order("id desc").Find(&list).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	// 初始化续写关系
+	songIds := make([]string, 0)
+	for _, v := range list {
+		if v.RefTaskId != "" {
+			songIds = append(songIds, v.RefSongId)
+		}
+	}
+	var tasks []model.SunoJob
+	h.DB.Where("song_id IN ?", songIds).Find(&tasks)
+	songMap := make(map[string]model.SunoJob)
+	for _, t := range tasks {
+		songMap[t.SongId] = t
+	}
+	// 转换为 VO
+	items := make([]vo.SunoJob, 0)
+	for _, v := range list {
+		var item vo.SunoJob
+		err = utils.CopyObject(v, &item)
+		if err != nil {
+			continue
+		}
+		item.CreatedAt = v.CreatedAt.Unix()
+		if s, ok := songMap[v.RefSongId]; ok {
+			item.RefSong = map[string]interface{}{
+				"id":    s.Id,
+				"title": s.Title,
+				"cover": s.CoverURL,
+				"audio": s.AudioURL,
+			}
+		}
+		items = append(items, item)
+	}
+
+	resp.SUCCESS(c, vo.NewPage(total, page, pageSize, items))
+}
+
+func (h *SunoHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+	userId := h.GetLoginUserId(c)
+	var job model.SunoJob
+	err := h.DB.Where("id = ?", id).Where("user_id", userId).First(&job).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// 只有失败或者已完成的任务可以删除
+	if !(job.Progress == service.FailTaskProgress || job.Progress == 100) {
+		resp.ERROR(c, "只有失败和超时(10分钟)的任务才能删除！")
+		return
+	}
+
+	// 删除任务
+	err = h.DB.Delete(&job).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// 删除文件
+	_ = h.uploader.GetUploadHandler().Delete(job.CoverURL)
+	_ = h.uploader.GetUploadHandler().Delete(job.AudioURL)
+}
+
+func (h *SunoHandler) Publish(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+	userId := h.GetLoginUserId(c)
+	publish := h.GetBool(c, "publish")
+	err := h.DB.Model(&model.SunoJob{}).Where("id", id).Where("user_id", userId).UpdateColumn("publish", publish).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c)
+}
+
+func (h *SunoHandler) Update(c *gin.Context) {
+	var data struct {
+		Id    int    `json:"id"`
+		Title string `json:"title"`
+		Cover string `json:"cover"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if data.Id == 0 || data.Title == "" || data.Cover == "" {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	userId := h.GetLoginUserId(c)
+	var item model.SunoJob
+	if err := h.DB.Where("id", data.Id).Where("user_id", userId).First(&item).Error; err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	item.Title = data.Title
+	item.CoverURL = data.Cover
+
+	if err := h.DB.Updates(&item).Error; err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c)
+}
+
+// Detail 歌曲详情
+func (h *SunoHandler) Detail(c *gin.Context) {
+	songId := c.Query("song_id")
+	if songId == "" {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	var item model.SunoJob
+	if err := h.DB.Where("song_id", songId).First(&item).Error; err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// 读取用户信息
+	var user model.User
+	if err := h.DB.Where("id", item.UserId).First(&user).Error; err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	var itemVo vo.SunoJob
+	if err := utils.CopyObject(item, &itemVo); err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	itemVo.CreatedAt = item.CreatedAt.Unix()
+	itemVo.User = map[string]interface{}{
+		"nickname": user.Nickname,
+		"avatar":   user.Avatar,
+	}
+
+	resp.SUCCESS(c, itemVo)
+}
+
+// Play 增加歌曲播放次数
+func (h *SunoHandler) Play(c *gin.Context) {
+	songId := c.Query("song_id")
+	if songId == "" {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	h.DB.Model(&model.SunoJob{}).Where("song_id", songId).UpdateColumn("play_times", gorm.Expr("play_times + ?", 1))
+}

api/handler/test_handler.go

@@ -0,0 +1,54 @@
+package handler
+
+import (
+	"geekai/service"
+	"geekai/service/payment"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"net/http"
+)
+
+type TestHandler struct {
+	db        *gorm.DB
+	snowflake *service.Snowflake
+	js        *payment.GeekPayService
+}
+
+func NewTestHandler(db *gorm.DB, snowflake *service.Snowflake, js *payment.GeekPayService) *TestHandler {
+	return &TestHandler{db: db, snowflake: snowflake, js: js}
+}
+
+func (h *TestHandler) SseTest(c *gin.Context) {
+	//c.Header("Body-Type", "text/event-stream")
+	//c.Header("Cache-Control", "no-cache")
+	//c.Header("Connection", "keep-alive")
+	//
+	//
+	//// 模拟实时数据更新
+	//for i := 0; i < 10; i++ {
+	//	// 发送 SSE 数据
+	//	_, err := fmt.Fprintf(c.Writer, "data: %v\n\n", data)
+	//	if err != nil {
+	//		return
+	//	}
+	//	c.Writer.Flush()            // 确保立即发送数据
+	//	time.Sleep(1 * time.Second) // 每秒发送一次数据
+	//}
+	//c.Abort()
+}
+
+func (h *TestHandler) PostTest(c *gin.Context) {
+	var data struct {
+		Message string `json:"message"`
+		UserId  uint   `json:"user_id"`
+	}
+
+	if err := c.ShouldBindJSON(&data); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	// 将参数存储在上下文中
+	c.Set("data", data)
+	c.Next()
+}

api/handler/user_handler.go

@@ -0,0 +1,714 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/service"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"github.com/imroc/req/v3"
+	"strings"
+	"time"
+
+	"github.com/go-redis/redis/v8"
+	"github.com/golang-jwt/jwt/v5"
+
+	"github.com/gin-gonic/gin"
+	"github.com/lionsoul2014/ip2region/binding/golang/xdb"
+	"gorm.io/gorm"
+)
+
+type UserHandler struct {
+	BaseHandler
+	searcher       *xdb.Searcher
+	redis          *redis.Client
+	licenseService *service.LicenseService
+	captcha        *service.CaptchaService
+	userService    *service.UserService
+}
+
+func NewUserHandler(
+	app *core.AppServer,
+	db *gorm.DB,
+	searcher *xdb.Searcher,
+	client *redis.Client,
+	captcha *service.CaptchaService,
+	userService *service.UserService,
+	licenseService *service.LicenseService) *UserHandler {
+	return &UserHandler{
+		BaseHandler:    BaseHandler{DB: db, App: app},
+		searcher:       searcher,
+		redis:          client,
+		captcha:        captcha,
+		licenseService: licenseService,
+		userService:    userService,
+	}
+}
+
+// Register user register
+func (h *UserHandler) Register(c *gin.Context) {
+	// parameters process
+	var data struct {
+		RegWay     string `json:"reg_way"`
+		Username   string `json:"username"`
+		Mobile     string `json:"mobile"`
+		Email      string `json:"email"`
+		Password   string `json:"password"`
+		Code       string `json:"code"`
+		InviteCode string `json:"invite_code"`
+		Key        string `json:"key,omitempty"`
+		Dots       string `json:"dots,omitempty"`
+		X          int    `json:"x,omitempty"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if h.App.SysConfig.EnabledVerify && data.RegWay == "username" {
+		var check bool
+		if data.X != 0 {
+			check = h.captcha.SlideCheck(data)
+		} else {
+			check = h.captcha.Check(data)
+		}
+		if !check {
+			resp.ERROR(c, "请先完人机验证")
+			return
+		}
+	}
+
+	data.Password = strings.TrimSpace(data.Password)
+	if len(data.Password) < 8 {
+		resp.ERROR(c, "密码长度不能少于8个字符")
+		return
+	}
+
+	// 检测最大注册人数
+	var totalUser int64
+	h.DB.Model(&model.User{}).Count(&totalUser)
+	if h.licenseService.GetLicense().Configs.UserNum > 0 && int(totalUser) >= h.licenseService.GetLicense().Configs.UserNum {
+		resp.ERROR(c, "当前注册用户数已达上限，请请升级 License")
+		return
+	}
+
+	// 检查验证码
+	var key string
+	if data.RegWay == "email" {
+		key = CodeStorePrefix + data.Email
+		code, err := h.redis.Get(c, key).Result()
+		if err != nil || code != data.Code {
+			resp.ERROR(c, "验证码错误")
+			return
+		}
+	} else if data.RegWay == "mobile" {
+		key = CodeStorePrefix + data.Mobile
+		code, err := h.redis.Get(c, key).Result()
+		if err != nil || code != data.Code {
+			resp.ERROR(c, "验证码错误")
+			return
+		}
+	}
+
+	// 验证邀请码
+	inviteCode := model.InviteCode{}
+	if data.InviteCode != "" {
+		res := h.DB.Where("code = ?", data.InviteCode).First(&inviteCode)
+		if res.Error != nil {
+			resp.ERROR(c, "无效的邀请码")
+			return
+		}
+	}
+
+	salt := utils.RandString(8)
+	user := model.User{
+		Username:  data.Username,
+		Password:  utils.GenPassword(data.Password, salt),
+		Avatar:    "/images/avatar/user.png",
+		Salt:      salt,
+		Status:    true,
+		ChatRoles: utils.JsonEncode([]string{"gpt"}), // 默认只订阅通用助手角色
+		Power:     h.App.SysConfig.InitPower,
+	}
+
+	// check if the username is existing
+	var item model.User
+	session := h.DB.Session(&gorm.Session{})
+	if data.Mobile != "" {
+		session = session.Where("mobile = ?", data.Mobile)
+		user.Username = data.Mobile
+		user.Mobile = data.Mobile
+	} else if data.Email != "" {
+		session = session.Where("email = ?", data.Email)
+		user.Username = data.Email
+		user.Email = data.Email
+	} else if data.Username != "" {
+		session = session.Where("username = ?", data.Username)
+	}
+	session.First(&item)
+	if item.Id > 0 {
+		resp.ERROR(c, "该用户名已经被注册")
+		return
+	}
+
+	// 被邀请人也获得赠送算力
+	if data.InviteCode != "" {
+		user.Power += h.App.SysConfig.InvitePower
+	}
+	if h.licenseService.GetLicense().Configs.DeCopy {
+		user.Nickname = fmt.Sprintf("用户@%d", utils.RandomNumber(6))
+	} else {
+		user.Nickname = fmt.Sprintf("极客学长@%d", utils.RandomNumber(6))
+	}
+
+	tx := h.DB.Begin()
+	if err := tx.Create(&user).Error; err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// 记录邀请关系
+	if data.InviteCode != "" {
+		// 增加邀请数量
+		h.DB.Model(&model.InviteCode{}).Where("code = ?", data.InviteCode).UpdateColumn("reg_num", gorm.Expr("reg_num + ?", 1))
+		if h.App.SysConfig.InvitePower > 0 {
+			err := h.userService.IncreasePower(int(inviteCode.UserId), h.App.SysConfig.InvitePower, model.PowerLog{
+				Type:   types.PowerInvite,
+				Model: "Invite",
+				Remark: fmt.Sprintf("邀请用户注册奖励，金额：%d，邀请码：%s，新用户：%s", h.App.SysConfig.InvitePower, inviteCode.Code, user.Username),
+			})
+			if err != nil {
+				tx.Rollback()
+				resp.ERROR(c, err.Error())
+				return
+			}
+		}
+
+		// 添加邀请记录
+		err := tx.Create(&model.InviteLog{
+			InviterId:  inviteCode.UserId,
+			UserId:     user.Id,
+			Username:   user.Username,
+			InviteCode: inviteCode.Code,
+			Remark:     fmt.Sprintf("奖励 %d 算力", h.App.SysConfig.InvitePower),
+		}).Error
+		if err != nil {
+			tx.Rollback()
+			resp.ERROR(c, err.Error())
+			return
+		}
+	}
+	tx.Commit()
+
+	_ = 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, gin.H{"token": tokenString, "user_id": user.Id, "username": user.Username})
+}
+
+// Login 用户登录
+func (h *UserHandler) Login(c *gin.Context) {
+	var data struct {
+		Username string `json:"username"`
+		Password string `json:"password"`
+		Key      string `json:"key,omitempty"`
+		Dots     string `json:"dots,omitempty"`
+		X        int    `json:"x,omitempty"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	verifyKey := fmt.Sprintf("users/verify/%s", data.Username)
+	needVerify, err := h.redis.Get(c, verifyKey).Bool()
+
+	if h.App.SysConfig.EnabledVerify && needVerify {
+		var check bool
+		if data.X != 0 {
+			check = h.captcha.SlideCheck(data)
+		} else {
+			check = h.captcha.Check(data)
+		}
+		if !check {
+			resp.ERROR(c, "请先完人机验证")
+			return
+		}
+	}
+
+	var user model.User
+	res := h.DB.Where("username = ?", data.Username).First(&user)
+	if res.Error != nil {
+		h.redis.Set(c, verifyKey, true, 0)
+		resp.ERROR(c, "用户名不存在")
+		return
+	}
+
+	password := utils.GenPassword(data.Password, user.Salt)
+	if password != user.Password {
+		h.redis.Set(c, verifyKey, true, 0)
+		resp.ERROR(c, "用户名或密码错误")
+		return
+	}
+
+	if user.Status == false {
+		resp.ERROR(c, "该用户已被禁止登录，请联系管理员")
+		return
+	}
+
+	// 更新最后登录时间和IP
+	user.LastLoginIp = c.ClientIP()
+	user.LastLoginAt = time.Now().Unix()
+	h.DB.Model(&user).Updates(user)
+
+	h.DB.Create(&model.UserLoginLog{
+		UserId:       user.Id,
+		Username:     user.Username,
+		LoginIp:      c.ClientIP(),
+		LoginAddress: utils.Ip2Region(h.searcher, c.ClientIP()),
+	})
+
+	// 创建 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
+	sessionKey := fmt.Sprintf("users/%d", user.Id)
+	if _, err = h.redis.Set(c, sessionKey, tokenString, 0).Result(); err != nil {
+		resp.ERROR(c, "error with save token: "+err.Error())
+		return
+	}
+	// 移除登录行为验证码
+	h.redis.Del(c, verifyKey)
+	resp.SUCCESS(c, gin.H{"token": tokenString, "user_id": user.Id, "username": user.Username})
+}
+
+// Logout 注 销
+func (h *UserHandler) Logout(c *gin.Context) {
+	key := h.GetUserKey(c)
+	if _, err := h.redis.Del(c, key).Result(); err != nil {
+		logger.Error("error with delete session: ", err)
+	}
+	resp.SUCCESS(c)
+}
+
+// CLogin 第三方登录请求二维码
+func (h *UserHandler) CLogin(c *gin.Context) {
+	returnURL := h.GetTrim(c, "return_url")
+	var res types.BizVo
+	apiURL := fmt.Sprintf("%s/api/clogin/request", h.App.Config.ApiConfig.ApiURL)
+	r, err := req.C().R().SetBody(gin.H{"login_type": "wx", "return_url": returnURL}).
+		SetHeader("AppId", h.App.Config.ApiConfig.AppId).
+		SetHeader("Authorization", fmt.Sprintf("Bearer %s", h.App.Config.ApiConfig.Token)).
+		SetSuccessResult(&res).
+		Post(apiURL)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	if r.IsErrorState() {
+		resp.ERROR(c, "error with login http status: "+r.Status)
+		return
+	}
+
+	if res.Code != types.Success {
+		resp.ERROR(c, "error with http response: "+res.Message)
+		return
+	}
+
+	resp.SUCCESS(c, res.Data)
+}
+
+// CLoginCallback 第三方登录回调
+func (h *UserHandler) CLoginCallback(c *gin.Context) {
+	loginType := c.Query("login_type")
+	code := c.Query("code")
+	userId := h.GetInt(c, "user_id", 0)
+	action := c.Query("action")
+
+	var res types.BizVo
+	apiURL := fmt.Sprintf("%s/api/clogin/info", h.App.Config.ApiConfig.ApiURL)
+	r, err := req.C().R().SetBody(gin.H{"login_type": loginType, "code": code}).
+		SetHeader("AppId", h.App.Config.ApiConfig.AppId).
+		SetHeader("Authorization", fmt.Sprintf("Bearer %s", h.App.Config.ApiConfig.Token)).
+		SetSuccessResult(&res).
+		Post(apiURL)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	if r.IsErrorState() {
+		resp.ERROR(c, "error with login http status: "+r.Status)
+		return
+	}
+
+	if res.Code != types.Success {
+		resp.ERROR(c, "error with http response: "+res.Message)
+		return
+	}
+
+	// login successfully
+	data := res.Data.(map[string]interface{})
+	var user model.User
+	if action == "bind" && userId > 0 {
+		err = h.DB.Where("openid", data["openid"]).First(&user).Error
+		if err == nil {
+			resp.ERROR(c, "该微信已经绑定其他账号，请先解绑")
+			return
+		}
+
+		err = h.DB.Where("id", userId).First(&user).Error
+		if err != nil {
+			resp.ERROR(c, "绑定用户不存在")
+			return
+		}
+
+		err = h.DB.Model(&user).UpdateColumn("openid", data["openid"]).Error
+		if err != nil {
+			resp.ERROR(c, "更新用户信息失败，"+err.Error())
+			return
+		}
+
+		resp.SUCCESS(c, gin.H{"token": ""})
+		return
+	}
+
+	session := gin.H{}
+	tx := h.DB.Where("openid", data["openid"]).First(&user)
+	if tx.Error != nil {
+		// create new user
+		var totalUser int64
+		h.DB.Model(&model.User{}).Count(&totalUser)
+		if h.licenseService.GetLicense().Configs.UserNum > 0 && int(totalUser) >= h.licenseService.GetLicense().Configs.UserNum {
+			resp.ERROR(c, "当前注册用户数已达上限，请请升级 License")
+			return
+		}
+
+		salt := utils.RandString(8)
+		password := fmt.Sprintf("%d", utils.RandomNumber(8))
+		user = model.User{
+			Username:  fmt.Sprintf("%s@%d", loginType, utils.RandomNumber(10)),
+			Password:  utils.GenPassword(password, salt),
+			Avatar:    fmt.Sprintf("%s", data["avatar"]),
+			Salt:      salt,
+			Status:    true,
+			ChatRoles: utils.JsonEncode([]string{"gpt"}), // 默认只订阅通用助手角色
+			Power:     h.App.SysConfig.InitPower,
+			OpenId:    fmt.Sprintf("%s", data["openid"]),
+			Nickname:  fmt.Sprintf("%s", data["nickname"]),
+		}
+
+		tx = h.DB.Create(&user)
+		if tx.Error != nil {
+			resp.ERROR(c, "保存数据失败")
+			logger.Error(tx.Error)
+			return
+		}
+		session["username"] = user.Username
+		session["password"] = password
+	} else { // login directly
+		// 更新最后登录时间和IP
+		user.LastLoginIp = c.ClientIP()
+		user.LastLoginAt = time.Now().Unix()
+		h.DB.Model(&user).Updates(user)
+
+		h.DB.Create(&model.UserLoginLog{
+			UserId:       user.Id,
+			Username:     user.Username,
+			LoginIp:      c.ClientIP(),
+			LoginAddress: utils.Ip2Region(h.searcher, c.ClientIP()),
+		})
+	}
+
+	// 创建 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
+	}
+	session["token"] = tokenString
+	resp.SUCCESS(c, session)
+}
+
+// Session 获取/验证会话
+func (h *UserHandler) Session(c *gin.Context) {
+	user, err := h.GetLoginUser(c)
+	if err != nil {
+		resp.NotAuth(c, err.Error())
+		return
+	}
+
+	var userVo vo.User
+	err = utils.CopyObject(user, &userVo)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	// 用户 VIP 到期
+	if user.ExpiredTime > 0 && user.ExpiredTime < time.Now().Unix() {
+		h.DB.Model(&user).UpdateColumn("vip", false)
+	}
+	userVo.Id = user.Id
+	resp.SUCCESS(c, userVo)
+
+}
+
+type userProfile struct {
+	Id          uint   `json:"id"`
+	Nickname    string `json:"nickname"`
+	Username    string `json:"username"`
+	Avatar      string `json:"avatar"`
+	Power       int    `json:"power"`
+	ExpiredTime int64  `json:"expired_time"`
+	Vip         bool   `json:"vip"`
+}
+
+func (h *UserHandler) Profile(c *gin.Context) {
+	user, err := h.GetLoginUser(c)
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+
+	h.DB.First(&user, user.Id)
+	var profile userProfile
+	err = utils.CopyObject(user, &profile)
+	if err != nil {
+		logger.Error("对象拷贝失败：", err.Error())
+		resp.ERROR(c, "获取用户信息失败")
+		return
+	}
+
+	profile.Id = user.Id
+	resp.SUCCESS(c, profile)
+}
+
+func (h *UserHandler) ProfileUpdate(c *gin.Context) {
+	var data userProfile
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	user, err := h.GetLoginUser(c)
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+	h.DB.First(&user, user.Id)
+	user.Avatar = data.Avatar
+	user.Nickname = data.Nickname
+	res := h.DB.Updates(&user)
+	if res.Error != nil {
+		resp.ERROR(c, "更新用户信息失败")
+		return
+	}
+
+	resp.SUCCESS(c)
+}
+
+// UpdatePass 更新密码
+func (h *UserHandler) UpdatePass(c *gin.Context) {
+	var data struct {
+		OldPass  string `json:"old_pass"`
+		Password string `json:"password"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if len(data.Password) < 8 {
+		resp.ERROR(c, "密码长度不能少于8个字符")
+		return
+	}
+
+	user, err := h.GetLoginUser(c)
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+
+	password := utils.GenPassword(data.OldPass, user.Salt)
+	logger.Debugf(user.Salt, ",", user.Password, ",", password, ",", data.OldPass)
+	if password != user.Password {
+		resp.ERROR(c, "原密码错误")
+		return
+	}
+
+	newPass := utils.GenPassword(data.Password, user.Salt)
+	err = h.DB.Model(&user).UpdateColumn("password", newPass).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c)
+}
+
+// ResetPass 找回密码
+func (h *UserHandler) ResetPass(c *gin.Context) {
+	var data struct {
+		Type     string `json:"type"`     // 验证类别：mobile, email
+		Mobile   string `json:"mobile"`   // 手机号
+		Email    string `json:"email"`    // 邮箱地址
+		Code     string `json:"code"`     // 验证码
+		Password string `json:"password"` // 新密码
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	session := h.DB.Session(&gorm.Session{})
+	var key string
+	if data.Type == "email" {
+		session = session.Where("email", data.Email)
+		key = CodeStorePrefix + data.Email
+	} else if data.Type == "mobile" {
+		session = session.Where("mobile", data.Mobile)
+		key = CodeStorePrefix + data.Mobile
+	} else {
+		resp.ERROR(c, "验证类别错误")
+		return
+	}
+	var user model.User
+	err := session.First(&user).Error
+	if err != nil {
+		resp.ERROR(c, "用户不存在！")
+		return
+	}
+
+	// 检查验证码
+	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)
+	err = h.DB.Model(&user).UpdateColumn("password", password).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+	} 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   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)
+	if res.Error == nil {
+		resp.ERROR(c, "该手机号已经绑定了其他账号，请更换手机号")
+		return
+	}
+
+	userId := h.GetLoginUserId(c)
+
+	err = h.DB.Model(&item).Where("id", userId).UpdateColumn("mobile", data.Mobile).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	_ = h.redis.Del(c, key) // 删除短信验证码
+	resp.SUCCESS(c)
+}
+
+// BindEmail 绑定邮箱
+func (h *UserHandler) BindEmail(c *gin.Context) {
+	var data struct {
+		Email string `json:"email"`
+		Code  string `json:"code"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	// 检查验证码
+	key := CodeStorePrefix + data.Email
+	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("email", data.Email).First(&item)
+	if res.Error == nil {
+		resp.ERROR(c, "该邮箱地址已经绑定了其他账号，请更邮箱地址")
+		return
+	}
+
+	userId := h.GetLoginUserId(c)
+
+	err = h.DB.Model(&item).Where("id", userId).UpdateColumn("email", data.Email).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	_ = h.redis.Del(c, key) // 删除短信验证码
+	resp.SUCCESS(c)
+}

api/handler/video_handler.go

@@ -0,0 +1,215 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/service"
+	"geekai/service/oss"
+	"geekai/service/video"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"time"
+)
+
+type VideoHandler struct {
+	BaseHandler
+	videoService *video.Service
+	uploader     *oss.UploaderManager
+	userService  *service.UserService
+}
+
+func NewVideoHandler(app *core.AppServer, db *gorm.DB, service *video.Service, uploader *oss.UploaderManager, userService *service.UserService) *VideoHandler {
+	return &VideoHandler{
+		BaseHandler: BaseHandler{
+			App: app,
+			DB:  db,
+		},
+		videoService: service,
+		uploader:     uploader,
+		userService:  userService,
+	}
+}
+
+func (h *VideoHandler) LumaCreate(c *gin.Context) {
+
+	var data struct {
+		ClientId      string `json:"client_id"`
+		Prompt        string `json:"prompt"`
+		FirstFrameImg string `json:"first_frame_img,omitempty"`
+		EndFrameImg   string `json:"end_frame_img,omitempty"`
+		ExpandPrompt  bool   `json:"expand_prompt,omitempty"`
+		Loop          bool   `json:"loop,omitempty"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	user, err := h.GetLoginUser(c)
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+
+	if user.Power < h.App.SysConfig.LumaPower {
+		resp.ERROR(c, "您的算力不足，请充值后再试！")
+		return
+	}
+
+	if data.Prompt == "" {
+		resp.ERROR(c, "prompt is needed")
+		return
+	}
+
+	userId := int(h.GetLoginUserId(c))
+	params := types.VideoParams{
+		PromptOptimize: data.ExpandPrompt,
+		Loop:           data.Loop,
+		StartImgURL:    data.FirstFrameImg,
+		EndImgURL:      data.EndFrameImg,
+	}
+	task := types.VideoTask{
+		ClientId:         data.ClientId,
+		UserId:           userId,
+		Type:             types.VideoLuma,
+		Prompt:           data.Prompt,
+		Params:           params,
+		TranslateModelId: h.App.SysConfig.TranslateModelId,
+	}
+	// 插入数据库
+	job := model.VideoJob{
+		UserId:   userId,
+		Type:     types.VideoLuma,
+		Prompt:   data.Prompt,
+		Power:    h.App.SysConfig.LumaPower,
+		TaskInfo: utils.JsonEncode(task),
+	}
+	tx := h.DB.Create(&job)
+	if tx.Error != nil {
+		resp.ERROR(c, tx.Error.Error())
+		return
+	}
+
+	// 创建任务
+	task.Id = job.Id
+	h.videoService.PushTask(task)
+
+	// update user's power
+	err = h.userService.DecreasePower(job.UserId, job.Power, model.PowerLog{
+		Type:   types.PowerConsume,
+		Model:  "luma",
+		Remark: fmt.Sprintf("Luma 文生视频，任务ID：%d", job.Id),
+	})
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	resp.SUCCESS(c)
+}
+
+func (h *VideoHandler) List(c *gin.Context) {
+	userId := h.GetLoginUserId(c)
+	t := c.Query("type")
+	page := h.GetInt(c, "page", 1)
+	pageSize := h.GetInt(c, "page_size", 20)
+	all := h.GetBool(c, "all")
+	session := h.DB.Session(&gorm.Session{}).Where("user_id", userId)
+	if t != "" {
+		session = session.Where("type", t)
+	}
+	if all {
+		session = session.Where("publish", 0).Where("progress", 100)
+	} else {
+		session = session.Where("user_id", h.GetLoginUserId(c))
+	}
+	// 统计总数
+	var total int64
+	session.Model(&model.VideoJob{}).Count(&total)
+
+	if page > 0 && pageSize > 0 {
+		offset := (page - 1) * pageSize
+		session = session.Offset(offset).Limit(pageSize)
+	}
+	var list []model.VideoJob
+	err := session.Order("id desc").Find(&list).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// 转换为 VO
+	items := make([]vo.VideoJob, 0)
+	for _, v := range list {
+		var item vo.VideoJob
+		err = utils.CopyObject(v, &item)
+		if err != nil {
+			continue
+		}
+		item.CreatedAt = v.CreatedAt.Unix()
+		if item.VideoURL == "" {
+			item.VideoURL = v.WaterURL
+		}
+		items = append(items, item)
+	}
+
+	resp.SUCCESS(c, vo.NewPage(total, page, pageSize, items))
+}
+
+func (h *VideoHandler) Remove(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+	userId := h.GetLoginUserId(c)
+	var job model.VideoJob
+	err := h.DB.Where("id = ?", id).Where("user_id", userId).First(&job).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	// 只有失败或者超时的任务才能删除
+	if !(job.Progress == service.FailTaskProgress || time.Now().After(job.CreatedAt.Add(time.Minute*30))) {
+		resp.ERROR(c, "只有失败和超时(30分钟)的任务才能删除！")
+		return
+	}
+
+	// 删除任务
+	err = h.DB.Delete(&job).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// 删除文件
+	_ = h.uploader.GetUploadHandler().Delete(job.CoverURL)
+	_ = h.uploader.GetUploadHandler().Delete(job.VideoURL)
+}
+
+func (h *VideoHandler) Publish(c *gin.Context) {
+	id := h.GetInt(c, "id", 0)
+	userId := h.GetLoginUserId(c)
+	publish := h.GetBool(c, "publish")
+	var job model.VideoJob
+	err := h.DB.Where("id = ?", id).Where("user_id", userId).First(&job).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	err = h.DB.Model(&job).UpdateColumn("publish", publish).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c)
+}

api/handler/ws_handler.go

@@ -0,0 +1,150 @@
+package handler
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"context"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/service"
+	"geekai/store/model"
+	"geekai/utils"
+	"github.com/gin-gonic/gin"
+	"github.com/gorilla/websocket"
+	"gorm.io/gorm"
+	"net/http"
+	"strings"
+)
+
+// Websocket 连接处理 handler
+
+type WebsocketHandler struct {
+	BaseHandler
+	wsService   *service.WebsocketService
+	chatHandler *ChatHandler
+}
+
+func NewWebsocketHandler(app *core.AppServer, s *service.WebsocketService, db *gorm.DB, chatHandler *ChatHandler) *WebsocketHandler {
+	return &WebsocketHandler{
+		BaseHandler: BaseHandler{App: app, DB: db},
+		chatHandler: chatHandler,
+		wsService:   s,
+	}
+}
+
+func (h *WebsocketHandler) Client(c *gin.Context) {
+	clientProtocols := c.GetHeader("Sec-WebSocket-Protocol")
+	ws, err := (&websocket.Upgrader{
+		CheckOrigin:  func(r *http.Request) bool { return true },
+		Subprotocols: strings.Split(clientProtocols, ","),
+	}).Upgrade(c.Writer, c.Request, nil)
+	if err != nil {
+		logger.Error(err)
+		c.Abort()
+		return
+	}
+
+	clientId := c.Query("client_id")
+	client := types.NewWsClient(ws, clientId)
+	userId := h.GetLoginUserId(c)
+	if userId == 0 {
+		_ = client.Send([]byte("Invalid user_id"))
+		c.Abort()
+		return
+	}
+	var user model.User
+	if err := h.DB.Where("id", userId).First(&user).Error; err != nil {
+		_ = client.Send([]byte("Invalid user_id"))
+		c.Abort()
+		return
+	}
+
+	h.wsService.Clients.Put(clientId, client)
+	logger.Infof("New websocket connected, IP: %s", c.RemoteIP())
+	go func() {
+		for {
+			_, msg, err := client.Receive()
+			if err != nil {
+				logger.Debugf("close connection: %s", client.Conn.RemoteAddr())
+				client.Close()
+				h.wsService.Clients.Delete(clientId)
+				break
+			}
+
+			var message types.InputMessage
+			err = utils.JsonDecode(string(msg), &message)
+			if err != nil {
+				continue
+			}
+
+			logger.Debugf("Receive a message:%+v", message)
+			if message.Type == types.MsgTypePing {
+				utils.SendChannelMsg(client, types.ChPing, "pong")
+				continue
+			}
+
+			// 当前只处理聊天消息，其他消息全部丢弃
+			var chatMessage types.ChatMessage
+			err = utils.JsonDecode(utils.JsonEncode(message.Body), &chatMessage)
+			if err != nil || message.Channel != types.ChChat {
+				logger.Warnf("invalid message body:%+v", message.Body)
+				continue
+			}
+			var chatRole model.ChatRole
+			err = h.DB.First(&chatRole, chatMessage.RoleId).Error
+			if err != nil || !chatRole.Enable {
+				utils.SendAndFlush(client, "当前聊天角色不存在或者未启用，请更换角色之后再发起对话！！！")
+				continue
+			}
+			// if the role bind a model_id, use role's bind model_id
+			if chatRole.ModelId > 0 {
+				chatMessage.RoleId = chatRole.ModelId
+			}
+			// get model info
+			var chatModel model.ChatModel
+			err = h.DB.Where("id", chatMessage.ModelId).First(&chatModel).Error
+			if err != nil || chatModel.Enabled == false {
+				utils.SendAndFlush(client, "当前AI模型暂未启用，请更换模型后再发起对话！！！")
+				continue
+			}
+
+			session := &types.ChatSession{
+				ClientIP: c.ClientIP(),
+				UserId:   userId,
+			}
+
+			// use old chat data override the chat model and role ID
+			var chat model.ChatItem
+			h.DB.Where("chat_id", chatMessage.ChatId).First(&chat)
+			if chat.Id > 0 {
+				chatModel.Id = chat.ModelId
+				chatMessage.RoleId = int(chat.RoleId)
+			}
+
+			session.ChatId = chatMessage.ChatId
+			session.Tools = chatMessage.Tools
+			session.Stream = chatMessage.Stream
+			// 复制模型数据
+			err = utils.CopyObject(chatModel, &session.Model)
+			if err != nil {
+				logger.Error(err, chatModel)
+			}
+			ctx, cancel := context.WithCancel(context.Background())
+			h.chatHandler.ReqCancelFunc.Put(clientId, cancel)
+			err = h.chatHandler.sendMessage(ctx, session, chatRole, chatMessage.Content, client)
+			if err != nil {
+				logger.Error(err)
+				utils.SendAndFlush(client, err.Error())
+			} else {
+				utils.SendMsg(client, types.ReplyMessage{Channel: types.ChChat, Type: types.MsgTypeEnd})
+				logger.Infof("回答完毕: %v", message.Body)
+			}
+
+		}
+	}()
+}

api/logger/logger.go

@@ -0,0 +1,81 @@
+package logger
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+	"gopkg.in/natefinch/lumberjack.v2"
+	"os"
+	"strings"
+)
+
+var logger *zap.Logger
+var sugarLogger *zap.SugaredLogger
+
+func GetLogger() *zap.SugaredLogger {
+	if sugarLogger != nil {
+		return sugarLogger
+	}
+
+	logLevel := zap.NewAtomicLevelAt(getLogLevel(os.Getenv("LOG_LEVEL")))
+	encoder := getEncoder()
+	writerSyncer := getLogWriter()
+	fileCore := zapcore.NewCore(encoder, writerSyncer, logLevel)
+	consoleOutput := zapcore.Lock(os.Stdout)
+	consoleCore := zapcore.NewCore(
+		encoder,
+		consoleOutput,
+		logLevel,
+	)
+	core := zapcore.NewTee(fileCore, consoleCore)
+	logger = zap.New(core, zap.AddCaller())
+	sugarLogger = logger.Sugar()
+	return sugarLogger
+}
+
+// core 三个参数之  编码
+func getEncoder() zapcore.Encoder {
+	encoderConfig := zapcore.EncoderConfig{
+		TimeKey:        "time",
+		LevelKey:       "level",
+		NameKey:        "logger",
+		CallerKey:      "caller",
+		MessageKey:     "msg",
+		StacktraceKey:  "stacktrace",
+		EncodeTime:     zapcore.ISO8601TimeEncoder,
+		EncodeDuration: zapcore.SecondsDurationEncoder,
+		EncodeCaller:   zapcore.ShortCallerEncoder,
+		EncodeLevel:    zapcore.CapitalLevelEncoder,
+	}
+	return zapcore.NewConsoleEncoder(encoderConfig)
+}
+
+func getLogWriter() zapcore.WriteSyncer {
+	lumberJackLogger := &lumberjack.Logger{
+		Filename:   "logs/app.log",
+		MaxSize:    10,
+		MaxBackups: 5,
+		MaxAge:     30,
+		Compress:   false,
+	}
+	return zapcore.AddSync(lumberJackLogger)
+}
+
+func getLogLevel(level string) zapcore.Level {
+	switch strings.ToUpper(level) {
+	case "DEBUG":
+		return zapcore.DebugLevel
+	case "WARN":
+		return zapcore.WarnLevel
+	case "ERROR":
+		return zapcore.ErrorLevel
+	default:
+		return zapcore.InfoLevel
+	}
+}

api/main.go

@@ -0,0 +1,591 @@
+package main
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"context"
+	"embed"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/handler"
+	"geekai/handler/admin"
+	logger2 "geekai/logger"
+	"geekai/service"
+	"geekai/service/dalle"
+	"geekai/service/mj"
+	"geekai/service/oss"
+	"geekai/service/payment"
+	"geekai/service/sd"
+	"geekai/service/sms"
+	"geekai/service/suno"
+	"geekai/service/video"
+	"geekai/store"
+	"io"
+	"log"
+	"os"
+	"os/signal"
+	"strconv"
+	"syscall"
+	"time"
+
+	"github.com/go-redis/redis/v8"
+
+	"github.com/lionsoul2014/ip2region/binding/golang/xdb"
+	"go.uber.org/fx"
+	"gorm.io/gorm"
+)
+
+var logger = logger2.GetLogger()
+
+//go:embed res
+var xdbFS embed.FS
+
+// AppLifecycle 应用程序生命周期
+type AppLifecycle struct {
+}
+
+// OnStart 应用程序启动时执行
+func (l *AppLifecycle) OnStart(context.Context) error {
+	logger.Info("AppLifecycle OnStart")
+	return nil
+}
+
+// OnStop 应用程序停止时执行
+func (l *AppLifecycle) OnStop(context.Context) error {
+	logger.Info("AppLifecycle OnStop")
+	return nil
+}
+
+func NewAppLifeCycle() *AppLifecycle {
+	return &AppLifecycle{}
+}
+
+func main() {
+	configFile := os.Getenv("CONFIG_FILE")
+	if configFile == "" {
+		configFile = "config.toml"
+	}
+	debug, _ := strconv.ParseBool(os.Getenv("APP_DEBUG"))
+	logger.Info("Loading config file: ", configFile)
+	if !debug {
+		defer func() {
+			if err := recover(); err != nil {
+				logger.Error("Panic Error:", err)
+			}
+		}()
+	}
+
+	app := fx.New(
+		// 初始化配置应用配置
+		fx.Provide(func() *types.AppConfig {
+			config, err := core.LoadConfig(configFile)
+			if err != nil {
+				log.Fatal(err)
+			}
+			config.Path = configFile
+			if debug {
+				_ = core.SaveConfig(config)
+			}
+			return config
+		}),
+		// 创建应用服务
+		fx.Provide(core.NewServer),
+		// 初始化
+		fx.Invoke(func(s *core.AppServer, client *redis.Client) {
+			s.Init(debug, client)
+		}),
+
+		// 初始化数据库
+		fx.Provide(store.NewGormConfig),
+		fx.Provide(store.NewMysql),
+		fx.Provide(store.NewRedisClient),
+		fx.Provide(store.NewLevelDB),
+
+		fx.Provide(func() embed.FS {
+			return xdbFS
+		}),
+
+		// 创建 Ip2Region 查询对象
+		fx.Provide(func() (*xdb.Searcher, error) {
+			file, err := xdbFS.Open("res/ip2region.xdb")
+			if err != nil {
+				return nil, err
+			}
+			cBuff, err := io.ReadAll(file)
+			if err != nil {
+				return nil, err
+			}
+
+			return xdb.NewWithBuffer(cBuff)
+		}),
+
+		// 创建控制器
+		fx.Provide(handler.NewChatRoleHandler),
+		fx.Provide(handler.NewUserHandler),
+		fx.Provide(handler.NewChatHandler),
+		fx.Provide(handler.NewNetHandler),
+		fx.Provide(handler.NewSmsHandler),
+		fx.Provide(handler.NewRedeemHandler),
+		fx.Provide(handler.NewCaptchaHandler),
+		fx.Provide(handler.NewMidJourneyHandler),
+		fx.Provide(handler.NewChatModelHandler),
+		fx.Provide(handler.NewSdJobHandler),
+		fx.Provide(handler.NewPaymentHandler),
+		fx.Provide(handler.NewOrderHandler),
+		fx.Provide(handler.NewProductHandler),
+		fx.Provide(handler.NewConfigHandler),
+		fx.Provide(handler.NewPowerLogHandler),
+
+		fx.Provide(admin.NewConfigHandler),
+		fx.Provide(admin.NewAdminHandler),
+		fx.Provide(admin.NewApiKeyHandler),
+		fx.Provide(admin.NewUserHandler),
+		fx.Provide(admin.NewChatAppHandler),
+		fx.Provide(admin.NewRedeemHandler),
+		fx.Provide(admin.NewDashboardHandler),
+		fx.Provide(admin.NewChatModelHandler),
+		fx.Provide(admin.NewProductHandler),
+		fx.Provide(admin.NewOrderHandler),
+		fx.Provide(admin.NewChatHandler),
+		fx.Provide(admin.NewPowerLogHandler),
+
+		// 创建服务
+		fx.Provide(sms.NewSendServiceManager),
+		fx.Provide(func(config *types.AppConfig) *service.CaptchaService {
+			return service.NewCaptchaService(config.ApiConfig)
+		}),
+		fx.Provide(oss.NewUploaderManager),
+		fx.Provide(dalle.NewService),
+		fx.Invoke(func(s *dalle.Service) {
+			s.Run()
+			s.CheckTaskNotify()
+			s.DownloadImages()
+			s.CheckTaskStatus()
+		}),
+
+		// 邮件服务
+		fx.Provide(service.NewSmtpService),
+		// License 服务
+		fx.Provide(service.NewLicenseService),
+		fx.Invoke(func(licenseService *service.LicenseService) {
+			// licenseService.SyncLicense()
+		}),
+
+		// MidJourney service pool
+		fx.Provide(mj.NewService),
+		fx.Provide(mj.NewClient),
+		fx.Invoke(func(s *mj.Service) {
+			s.Run()
+			s.SyncTaskProgress()
+			s.CheckTaskNotify()
+			s.DownloadImages()
+		}),
+
+		// Stable Diffusion 机器人
+		fx.Provide(sd.NewService),
+		fx.Invoke(func(s *sd.Service, config *types.AppConfig) {
+			s.Run()
+			s.CheckTaskStatus()
+			s.CheckTaskNotify()
+		}),
+
+		fx.Provide(suno.NewService),
+		fx.Invoke(func(s *suno.Service) {
+			s.Run()
+			s.SyncTaskProgress()
+			s.CheckTaskNotify()
+			s.DownloadFiles()
+		}),
+		fx.Provide(video.NewService),
+		fx.Invoke(func(s *video.Service) {
+			s.Run()
+			s.SyncTaskProgress()
+			s.CheckTaskNotify()
+			s.DownloadFiles()
+		}),
+		fx.Provide(service.NewUserService),
+		fx.Provide(payment.NewAlipayService),
+		fx.Provide(payment.NewHuPiPay),
+		fx.Provide(payment.NewJPayService),
+		fx.Provide(payment.NewWechatService),
+		fx.Provide(service.NewSnowflake),
+		fx.Provide(service.NewXXLJobExecutor),
+		fx.Invoke(func(exec *service.XXLJobExecutor, config *types.AppConfig) {
+			if config.XXLConfig.Enabled {
+				go func() {
+					log.Fatal(exec.Run())
+				}()
+			}
+		}),
+
+		// 注册路由
+		fx.Invoke(func(s *core.AppServer, h *handler.ChatRoleHandler) {
+			group := s.Engine.Group("/api/app/")
+			group.GET("list", h.List)
+			group.GET("list/user", h.ListByUser)
+			group.POST("update", h.UpdateRole)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.UserHandler) {
+			group := s.Engine.Group("/api/user/")
+			group.POST("register", h.Register)
+			group.POST("login", h.Login)
+			group.GET("logout", h.Logout)
+			group.GET("session", h.Session)
+			group.GET("profile", h.Profile)
+			group.POST("profile/update", h.ProfileUpdate)
+			group.POST("password", h.UpdatePass)
+			group.POST("bind/mobile", h.BindMobile)
+			group.POST("bind/email", h.BindEmail)
+			group.POST("resetPass", h.ResetPass)
+			group.GET("clogin", h.CLogin)
+			group.GET("clogin/callback", h.CLoginCallback)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.ChatHandler) {
+			group := s.Engine.Group("/api/chat/")
+			group.GET("list", h.List)
+			group.GET("detail", h.Detail)
+			group.POST("update", h.Update)
+			group.GET("remove", h.Remove)
+			group.GET("history", h.History)
+			group.GET("clear", h.Clear)
+			group.POST("tokens", h.Tokens)
+			group.GET("stop", h.StopGenerate)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.NetHandler) {
+			s.Engine.POST("/api/upload", h.Upload)
+			s.Engine.POST("/api/upload/list", h.List)
+			s.Engine.GET("/api/upload/remove", h.Remove)
+			s.Engine.GET("/api/download", h.Download)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.SmsHandler) {
+			group := s.Engine.Group("/api/sms/")
+			group.POST("code", h.SendCode)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.CaptchaHandler) {
+			group := s.Engine.Group("/api/captcha/")
+			group.GET("get", h.Get)
+			group.POST("check", h.Check)
+			group.GET("slide/get", h.SlideGet)
+			group.POST("slide/check", h.SlideCheck)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.RedeemHandler) {
+			group := s.Engine.Group("/api/redeem/")
+			group.POST("verify", h.Verify)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.MidJourneyHandler) {
+			group := s.Engine.Group("/api/mj/")
+			group.POST("image", h.Image)
+			group.POST("upscale", h.Upscale)
+			group.POST("variation", h.Variation)
+			group.GET("jobs", h.JobList)
+			group.GET("imgWall", h.ImgWall)
+			group.GET("remove", h.Remove)
+			group.GET("publish", h.Publish)
+		}),
+		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.GET("imgWall", h.ImgWall)
+			group.GET("remove", h.Remove)
+			group.GET("publish", h.Publish)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.ConfigHandler) {
+			group := s.Engine.Group("/api/config/")
+			group.GET("get", h.Get)
+			group.GET("license", h.License)
+		}),
+
+		// 管理后台控制器
+		fx.Invoke(func(s *core.AppServer, h *admin.ConfigHandler) {
+			group := s.Engine.Group("/api/admin/config")
+			group.POST("update", h.Update)
+			group.GET("get", h.Get)
+			group.POST("active", h.Active)
+			group.GET("fixData", h.FixData)
+			group.GET("license", h.GetLicense)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *admin.ManagerHandler) {
+			group := s.Engine.Group("/api/admin/")
+			group.POST("login", h.Login)
+			group.GET("logout", h.Logout)
+			group.GET("session", h.Session)
+			group.GET("list", h.List)
+			group.POST("save", h.Save)
+			group.POST("enable", h.Enable)
+			group.GET("remove", h.Remove)
+			group.POST("resetPass", h.ResetPass)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *admin.ApiKeyHandler) {
+			group := s.Engine.Group("/api/admin/apikey/")
+			group.POST("save", h.Save)
+			group.GET("list", h.List)
+			group.POST("set", h.Set)
+			group.GET("remove", h.Remove)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *admin.UserHandler) {
+			group := s.Engine.Group("/api/admin/user/")
+			group.GET("list", h.List)
+			group.POST("save", h.Save)
+			group.GET("remove", h.Remove)
+			group.GET("loginLog", h.LoginLog)
+			group.POST("resetPass", h.ResetPass)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *admin.ChatAppHandler) {
+			group := s.Engine.Group("/api/admin/role/")
+			group.GET("list", h.List)
+			group.POST("save", h.Save)
+			group.POST("sort", h.Sort)
+			group.POST("set", h.Set)
+			group.GET("remove", h.Remove)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *admin.RedeemHandler) {
+			group := s.Engine.Group("/api/admin/redeem/")
+			group.GET("list", h.List)
+			group.POST("create", h.Create)
+			group.POST("set", h.Set)
+			group.GET("remove", h.Remove)
+			group.POST("export", h.Export)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *admin.DashboardHandler) {
+			group := s.Engine.Group("/api/admin/dashboard/")
+			group.GET("stats", h.Stats)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.ChatModelHandler) {
+			group := s.Engine.Group("/api/model/")
+			group.GET("list", h.List)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *admin.ChatModelHandler) {
+			group := s.Engine.Group("/api/admin/model/")
+			group.POST("save", h.Save)
+			group.GET("list", h.List)
+			group.POST("set", h.Set)
+			group.POST("sort", h.Sort)
+			group.GET("remove", h.Remove)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.PaymentHandler) {
+			group := s.Engine.Group("/api/payment/")
+			group.POST("doPay", h.Pay)
+			group.GET("payWays", h.GetPayWays)
+			group.POST("notify/alipay", h.AlipayNotify)
+			group.GET("notify/geek", h.GeekPayNotify)
+			group.POST("notify/wechat", h.WechatPayNotify)
+			group.POST("notify/hupi", 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)
+			group.GET("clear", h.Clear)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.OrderHandler) {
+			group := s.Engine.Group("/api/order/")
+			group.GET("list", h.List)
+			group.GET("query", h.Query)
+		}),
+		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.GET("list", h.List)
+			group.GET("hits", h.Hits)
+		}),
+
+		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(admin.NewUploadHandler),
+		fx.Invoke(func(s *core.AppServer, h *admin.UploadHandler) {
+			s.Engine.POST("/api/admin/upload", h.Upload)
+		}),
+
+		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)
+			group.GET("list", h.List)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *admin.ChatHandler) {
+			group := s.Engine.Group("/api/admin/chat/")
+			group.POST("list", h.List)
+			group.POST("message", h.Messages)
+			group.GET("history", h.History)
+			group.GET("remove", h.RemoveChat)
+			group.GET("message/remove", h.RemoveMessage)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *handler.PowerLogHandler) {
+			group := s.Engine.Group("/api/powerLog/")
+			group.POST("list", h.List)
+		}),
+		fx.Invoke(func(s *core.AppServer, h *admin.PowerLogHandler) {
+			group := s.Engine.Group("/api/admin/powerLog/")
+			group.POST("list", h.List)
+		}),
+		fx.Provide(admin.NewMenuHandler),
+		fx.Invoke(func(s *core.AppServer, h *admin.MenuHandler) {
+			group := s.Engine.Group("/api/admin/menu/")
+			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.Provide(handler.NewMenuHandler),
+		fx.Invoke(func(s *core.AppServer, h *handler.MenuHandler) {
+			group := s.Engine.Group("/api/menu/")
+			group.GET("list", h.List)
+		}),
+		fx.Provide(handler.NewMarkMapHandler),
+		fx.Invoke(func(s *core.AppServer, h *handler.MarkMapHandler) {
+			s.Engine.POST("/api/markMap/gen", h.Generate)
+		}),
+		fx.Provide(handler.NewDallJobHandler),
+		fx.Invoke(func(s *core.AppServer, h *handler.DallJobHandler) {
+			group := s.Engine.Group("/api/dall")
+			group.POST("image", h.Image)
+			group.GET("jobs", h.JobList)
+			group.GET("imgWall", h.ImgWall)
+			group.GET("remove", h.Remove)
+			group.GET("publish", h.Publish)
+			group.GET("models", h.GetModels)
+		}),
+		fx.Provide(handler.NewSunoHandler),
+		fx.Invoke(func(s *core.AppServer, h *handler.SunoHandler) {
+			group := s.Engine.Group("/api/suno")
+			group.POST("create", h.Create)
+			group.GET("list", h.List)
+			group.GET("remove", h.Remove)
+			group.GET("publish", h.Publish)
+			group.POST("update", h.Update)
+			group.GET("detail", h.Detail)
+			group.GET("play", h.Play)
+		}),
+		fx.Provide(handler.NewVideoHandler),
+		fx.Invoke(func(s *core.AppServer, h *handler.VideoHandler) {
+			group := s.Engine.Group("/api/video")
+			group.POST("luma/create", h.LumaCreate)
+			group.GET("list", h.List)
+			group.GET("remove", h.Remove)
+			group.GET("publish", h.Publish)
+		}),
+		fx.Provide(admin.NewChatAppTypeHandler),
+		fx.Invoke(func(s *core.AppServer, h *admin.ChatAppTypeHandler) {
+			group := s.Engine.Group("/api/admin/app/type")
+			group.POST("save", h.Save)
+			group.GET("list", h.List)
+			group.GET("remove", h.Remove)
+			group.POST("enable", h.Enable)
+			group.POST("sort", h.Sort)
+		}),
+		fx.Provide(handler.NewChatAppTypeHandler),
+		fx.Invoke(func(s *core.AppServer, h *handler.ChatAppTypeHandler) {
+			group := s.Engine.Group("/api/app/type")
+			group.GET("list", h.List)
+		}),
+		fx.Provide(handler.NewTestHandler),
+		fx.Invoke(func(s *core.AppServer, h *handler.TestHandler) {
+			group := s.Engine.Group("/api/test")
+			group.Any("sse", h.PostTest, h.SseTest)
+		}),
+		fx.Provide(service.NewWebsocketService),
+		fx.Provide(handler.NewWebsocketHandler),
+		fx.Invoke(func(s *core.AppServer, h *handler.WebsocketHandler) {
+			s.Engine.Any("/api/ws", h.Client)
+		}),
+		fx.Provide(handler.NewPromptHandler),
+		fx.Invoke(func(s *core.AppServer, h *handler.PromptHandler) {
+			group := s.Engine.Group("/api/prompt")
+			group.POST("/lyric", h.Lyric)
+			group.POST("/image", h.Image)
+			group.POST("/video", h.Video)
+			group.POST("/meta", h.MetaPrompt)
+		}),
+		fx.Invoke(func(s *core.AppServer, db *gorm.DB) {
+			go func() {
+				err := s.Run(db)
+				if err != nil {
+					logger.Error(err)
+					os.Exit(0)
+				}
+			}()
+		}),
+		fx.Provide(NewAppLifeCycle),
+		// 注册生命周期回调函数
+		fx.Invoke(func(lifecycle fx.Lifecycle, lc *AppLifecycle) {
+			lifecycle.Append(fx.Hook{
+				OnStart: func(ctx context.Context) error {
+					return lc.OnStart(ctx)
+				},
+				OnStop: func(ctx context.Context) error {
+					return lc.OnStop(ctx)
+				},
+			})
+		}),
+		fx.Provide(admin.NewImageHandler),
+		fx.Invoke(func(s *core.AppServer, h *admin.ImageHandler) {
+			group := s.Engine.Group("/api/admin/image")
+			group.POST("/list/mj", h.MjList)
+			group.POST("/list/sd", h.SdList)
+			group.POST("/list/dall", h.DallList)
+			group.GET("/remove", h.Remove)
+		}),
+		fx.Provide(admin.NewMediaHandler),
+		fx.Invoke(func(s *core.AppServer, h *admin.MediaHandler) {
+			group := s.Engine.Group("/api/admin/media")
+			group.POST("/list/suno", h.SunoList)
+			group.POST("/list/luma", h.LumaList)
+			group.GET("/remove", h.Remove)
+		}),
+		fx.Provide(handler.NewRealtimeHandler),
+		fx.Invoke(func(s *core.AppServer, h *handler.RealtimeHandler) {
+			s.Engine.Any("/api/realtime", h.Connection)
+			s.Engine.POST("/api/realtime/voice", h.VoiceChat)
+		}),
+	)
+	// 启动应用程序
+	go func() {
+		if err := app.Start(context.Background()); err != nil {
+			log.Fatal(err)
+		}
+	}()
+
+	// 监听退出信号
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+	<-quit
+
+	// 关闭应用程序
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	if err := app.Stop(ctx); err != nil {
+		log.Fatal(err)
+	}
+
+}

api/res/certs/alipay/alipayPublicCert.crt

@@ -0,0 +1,38 @@
+-----BEGIN CERTIFICATE-----
+MIIDszCCApugAwIBAgIQICMRB0rBU2/rZJbfJGMYIzANBgkqhkiG9w0BAQsFADCBkTELMAkGA1UE
+BhMCQ04xGzAZBgNVBAoMEkFudCBGaW5hbmNpYWwgdGVzdDElMCMGA1UECwwcQ2VydGlmaWNhdGlv
+biBBdXRob3JpdHkgdGVzdDE+MDwGA1UEAww1QW50IEZpbmFuY2lhbCBDZXJ0aWZpY2F0aW9uIEF1
+dGhvcml0eSBDbGFzcyAyIFIxIHRlc3QwHhcNMjMxMTA3MDYzNTQxWhcNMjQxMTA2MDYzNTQxWjCB
+hDELMAkGA1UEBhMCQ04xHzAdBgNVBAoMFm1ib25meTkwMTVAc2FuZGJveC5jb20xDzANBgNVBAsM
+BkFsaXBheTFDMEEGA1UEAww65pSv5LuY5a6dKOS4reWbvSnnvZHnu5zmioDmnK/mnInpmZDlhazl
+j7gtMjA4ODcyMTAyMDc1MDU4MTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKsoKcw5
+sxaiyV7mpWzDtnQ1K518eQLP0+dJlZAf06aBep/Aj9DIqrba/k7DHt8dKQvILMLAMpN1+2IRxbaO
+yxMa/laj3lZ1eHrB6F077O3D62oHcE3noZtXL0N1zZAxpmkNmYIHeLZS2oLMS4ANu47O/wpDC7BV
+HjdpZugtdPJ4mxdCpM9GDdLs7W4s5QI4PUPK4skFNMFoKI+0cYP/9ju87UP//IHC/K510GWNl+Gn
+Cvgag3AmiIB0utJNsGhxm6zT1T9tUWjW9iz/BxBKiPatsCX9VpPQzGnW7ZonRQtiZSokIlP2IPvl
+H5DcwpWUz3/LUY0SmKxnKOEYeOOqCW8CAwEAAaMSMBAwDgYDVR0PAQH/BAQDAgTwMA0GCSqGSIb3
+DQEBCwUAA4IBAQAtgxF2EzjOndEFxBUD9tFwcSt6XKGggOp52oft1pvynPg4ALTLafOtfEPDrFBH
+PwpYrSu9s9C8NJtaA2HrlCfBjIuwEFTXiN+HPvS0SwSPKt9AXEiTcOF8vDcGamEen8QI4fo5Jia7
+2VRKkerkww5/+FzSaVO7ZUKuL80M1QJStmAZc8kPPwdYOTTW2bGf8BcmSDL6SPElBkt7tCCRd4sn
++jq4cZ0yb2i77rBZCwHcTvfTqIBblPwLv4uGvg3+83BxIB5w6Kqp06bKEAPmobFY5IVHa+ON0/qi
+BXxXr+WQ3piKRVQEN64+PTAjSc67Ix1umvpLl3Ko6Ry7NJmpDcUn
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDszCCApugAwIBAgIQIBkIGbgVxq210KxLJ+YA/TANBgkqhkiG9w0BAQsFADCBhDELMAkGA1UE
+BhMCQ04xFjAUBgNVBAoMDUFudCBGaW5hbmNpYWwxJTAjBgNVBAsMHENlcnRpZmljYXRpb24gQXV0
+aG9yaXR5IHRlc3QxNjA0BgNVBAMMLUFudCBGaW5hbmNpYWwgQ2VydGlmaWNhdGlvbiBBdXRob3Jp
+dHkgUjEgdGVzdDAeFw0xOTA4MTkxMTE2MDBaFw0yNDA4MDExMTE2MDBaMIGRMQswCQYDVQQGEwJD
+TjEbMBkGA1UECgwSQW50IEZpbmFuY2lhbCB0ZXN0MSUwIwYDVQQLDBxDZXJ0aWZpY2F0aW9uIEF1
+dGhvcml0eSB0ZXN0MT4wPAYDVQQDDDVBbnQgRmluYW5jaWFsIENlcnRpZmljYXRpb24gQXV0aG9y
+aXR5IENsYXNzIDIgUjEgdGVzdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMh4FKYO
+ZyRQHD6eFbPKZeSAnrfjfU7xmS9Yoozuu+iuqZlb6Z0SPLUqqTZAFZejOcmr07ln/pwZxluqplxC
+5+B48End4nclDMlT5HPrDr3W0frs6Xsa2ZNcyil/iKNB5MbGll8LRAxntsKvZZj6vUTMb705gYgm
+VUMILwi/ZxKTQqBtkT/kQQ5y6nOZsj7XI5rYdz6qqOROrpvS/d7iypdHOMIM9Iz9DlL1mrCykbBi
+t25y+gTeXmuisHUwqaRpwtCGK4BayCqxRGbNipe6W73EK9lBrrzNtTr9NaysesT/v+l25JHCL9tG
+wpNr1oWFzk4IHVOg0ORiQ6SUgxZUTYcCAwEAAaMSMBAwDgYDVR0PAQH/BAQDAgTwMA0GCSqGSIb3
+DQEBCwUAA4IBAQBWThEoIaQoBX2YeRY/I8gu6TYnFXtyuCljANnXnM38ft+ikhE5mMNgKmJYLHvT
+yWWWgwHoSAWEuml7EGbE/2AK2h3k0MdfiWLzdmpPCRG/RJHk6UB1pMHPilI+c0MVu16OPpKbg5Vf
+LTv7dsAB40AzKsvyYw88/Ezi1osTXo6QQwda7uefvudirtb8FcQM9R66cJxl3kt1FXbpYwheIm/p
+j1mq64swCoIYu4NrsUYtn6CV542DTQMI5QdXkn+PzUUly8F6kDp+KpMNd0avfWNL5+O++z+F5Szy
+1CPta1D7EQ/eYmMP+mOQ35oifWIoFCpN6qQVBS/Hob1J/UUyg7BW
+-----END CERTIFICATE-----

api/res/certs/alipay/alipayRootCert.crt

@@ -0,0 +1,88 @@
+-----BEGIN CERTIFICATE-----
+MIIBszCCAVegAwIBAgIIaeL+wBcKxnswDAYIKoEcz1UBg3UFADAuMQswCQYDVQQG
+EwJDTjEOMAwGA1UECgwFTlJDQUMxDzANBgNVBAMMBlJPT1RDQTAeFw0xMjA3MTQw
+MzExNTlaFw00MjA3MDcwMzExNTlaMC4xCzAJBgNVBAYTAkNOMQ4wDAYDVQQKDAVO
+UkNBQzEPMA0GA1UEAwwGUk9PVENBMFkwEwYHKoZIzj0CAQYIKoEcz1UBgi0DQgAE
+MPCca6pmgcchsTf2UnBeL9rtp4nw+itk1Kzrmbnqo05lUwkwlWK+4OIrtFdAqnRT
+V7Q9v1htkv42TsIutzd126NdMFswHwYDVR0jBBgwFoAUTDKxl9kzG8SmBcHG5Yti
+W/CXdlgwDAYDVR0TBAUwAwEB/zALBgNVHQ8EBAMCAQYwHQYDVR0OBBYEFEwysZfZ
+MxvEpgXBxuWLYlvwl3ZYMAwGCCqBHM9VAYN1BQADSAAwRQIgG1bSLeOXp3oB8H7b
+53W+CKOPl2PknmWEq/lMhtn25HkCIQDaHDgWxWFtnCrBjH16/W3Ezn7/U/Vjo5xI
+pDoiVhsLwg==
+-----END CERTIFICATE-----
+
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
+
+-----BEGIN CERTIFICATE-----
+MIICiDCCAgygAwIBAgIIQX76UsB/30owDAYIKoZIzj0EAwMFADB6MQswCQYDVQQG
+EwJDTjEWMBQGA1UECgwNQW50IEZpbmFuY2lhbDEgMB4GA1UECwwXQ2VydGlmaWNh
+dGlvbiBBdXRob3JpdHkxMTAvBgNVBAMMKEFudCBGaW5hbmNpYWwgQ2VydGlmaWNh
+dGlvbiBBdXRob3JpdHkgRTEwHhcNMTkwNDI4MTYyMDQ0WhcNNDkwNDIwMTYyMDQ0
+WjB6MQswCQYDVQQGEwJDTjEWMBQGA1UECgwNQW50IEZpbmFuY2lhbDEgMB4GA1UE
+CwwXQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxMTAvBgNVBAMMKEFudCBGaW5hbmNp
+YWwgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgRTEwdjAQBgcqhkjOPQIBBgUrgQQA
+IgNiAASCCRa94QI0vR5Up9Yr9HEupz6hSoyjySYqo7v837KnmjveUIUNiuC9pWAU
+WP3jwLX3HkzeiNdeg22a0IZPoSUCpasufiLAnfXh6NInLiWBrjLJXDSGaY7vaokt
+rpZvAdmjXTBbMAsGA1UdDwQEAwIBBjAMBgNVHRMEBTADAQH/MB0GA1UdDgQWBBRZ
+4ZTgDpksHL2qcpkFkxD2zVd16TAfBgNVHSMEGDAWgBRZ4ZTgDpksHL2qcpkFkxD2
+zVd16TAMBggqhkjOPQQDAwUAA2gAMGUCMQD4IoqT2hTUn0jt7oXLdMJ8q4vLp6sg
+wHfPiOr9gxreb+e6Oidwd2LDnC4OUqCWiF8CMAzwKs4SnDJYcMLf2vpkbuVE4dTH
+Rglz+HGcTLWsFs4KxLsq7MuU+vJTBUeDJeDjdA==
+-----END CERTIFICATE-----
+
+-----BEGIN CERTIFICATE-----
+MIIDxTCCAq2gAwIBAgIUEMdk6dVgOEIS2cCP0Q43P90Ps5YwDQYJKoZIhvcNAQEF
+BQAwajELMAkGA1UEBhMCQ04xEzARBgNVBAoMCmlUcnVzQ2hpbmExHDAaBgNVBAsM
+E0NoaW5hIFRydXN0IE5ldHdvcmsxKDAmBgNVBAMMH2lUcnVzQ2hpbmEgQ2xhc3Mg
+MiBSb290IENBIC0gRzMwHhcNMTMwNDE4MDkzNjU2WhcNMzMwNDE4MDkzNjU2WjBq
+MQswCQYDVQQGEwJDTjETMBEGA1UECgwKaVRydXNDaGluYTEcMBoGA1UECwwTQ2hp
+bmEgVHJ1c3QgTmV0d29yazEoMCYGA1UEAwwfaVRydXNDaGluYSBDbGFzcyAyIFJv
+b3QgQ0EgLSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOPPShpV
+nJbMqqCw6Bz1kehnoPst9pkr0V9idOwU2oyS47/HjJXk9Rd5a9xfwkPO88trUpz5
+4GmmwspDXjVFu9L0eFaRuH3KMha1Ak01citbF7cQLJlS7XI+tpkTGHEY5pt3EsQg
+wykfZl/A1jrnSkspMS997r2Gim54cwz+mTMgDRhZsKK/lbOeBPpWtcFizjXYCqhw
+WktvQfZBYi6o4sHCshnOswi4yV1p+LuFcQ2ciYdWvULh1eZhLxHbGXyznYHi0dGN
+z+I9H8aXxqAQfHVhbdHNzi77hCxFjOy+hHrGsyzjrd2swVQ2iUWP8BfEQqGLqM1g
+KgWKYfcTGdbPB1MCAwEAAaNjMGEwHQYDVR0OBBYEFG/oAMxTVe7y0+408CTAK8hA
+uTyRMB8GA1UdIwQYMBaAFG/oAMxTVe7y0+408CTAK8hAuTyRMA8GA1UdEwEB/wQF
+MAMBAf8wDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBBQUAA4IBAQBLnUTfW7hp
+emMbuUGCk7RBswzOT83bDM6824EkUnf+X0iKS95SUNGeeSWK2o/3ALJo5hi7GZr3
+U8eLaWAcYizfO99UXMRBPw5PRR+gXGEronGUugLpxsjuynoLQu8GQAeysSXKbN1I
+UugDo9u8igJORYA+5ms0s5sCUySqbQ2R5z/GoceyI9LdxIVa1RjVX8pYOj8JFwtn
+DJN3ftSFvNMYwRuILKuqUYSHc2GPYiHVflDh5nDymCMOQFcFG3WsEuB+EYQPFgIU
+1DHmdZcz7Llx8UOZXX2JupWCYzK1XhJb+r4hK5ncf/w8qGtYlmyJpxk3hr1TfUJX
+Yf4Zr0fJsGuv
+-----END CERTIFICATE-----

api/res/certs/alipay/appPublicCert.crt

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDmTCCAoGgAwIBAgIQICMRB2LW76yahgdg3IFNPDANBgkqhkiG9w0BAQsFADCBkTELMAkGA1UE
+BhMCQ04xGzAZBgNVBAoMEkFudCBGaW5hbmNpYWwgdGVzdDElMCMGA1UECwwcQ2VydGlmaWNhdGlv
+biBBdXRob3JpdHkgdGVzdDE+MDwGA1UEAww1QW50IEZpbmFuY2lhbCBDZXJ0aWZpY2F0aW9uIEF1
+dGhvcml0eSBDbGFzcyAyIFIxIHRlc3QwHhcNMjMxMTA3MDU0NjE5WhcNMjQxMTExMDU0NjE5WjBr
+MQswCQYDVQQGEwJDTjEfMB0GA1UECgwWbWJvbmZ5OTAxNUBzYW5kYm94LmNvbTEPMA0GA1UECwwG
+QWxpcGF5MSowKAYDVQQDDCEyMDg4NzIxMDIwNzUwNTgxLTkwMjEwMDAxMzE2NTgwMjMwggEiMA0G
+CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCxihQPf1Q+g9ArgM46shVqL5sbRha/df95D1PsWyEq
+ANmWmG4zZ+ksYDVQrc4KzhSRoi56sm/7TDFYTmM6bW99e/nKW58WxyZB4ie5qA3F4n17psPyDqb8
+IokcQmCphSFDaXQD6AoXoLNtTM0vAI2cWxAgebZ/vsrdj5Ntjt+Rp3NYMCk1i5xovHcfILzLEGbX
+QXoT9fo5AhHotTWa6xHVLPUGY9qwLzQxHzBmvy5ZMfnOfJkm/mDisTSqAUB59F3dzU/1ARVkEZ1w
+Mgb4XohWBw6iurQfbMnH2mIomAAwwZVFv+sXDbL9yMbSMo/SjVsTQprn0Q0EnwLo7nmmOM6HAgMB
+AAGjEjAQMA4GA1UdDwEB/wQEAwIE8DANBgkqhkiG9w0BAQsFAAOCAQEAn3Y4/C1h9R6ONsBqX3/q
+XfHX7yX1FM0Y1x48X3/Yxk6HivAkTukhhhVYVKJsbrbzRqHDp9vhAP/FR6o6pAevaYMmLov0VMXU
+7oAuetgkaYEYkDuNen5/Hpdhqi2vTtdT+q9w8zHJd6MDQ0aoHgIxpLKw5vof2R1N4fwSgNXMiXE5
+kmllKQMem/+on2p+Sj80/2asxryHIGlH87qPzkffv+kIOkZthbTApTFLLjdVri2QHGe8/cc4xy01
+/9iR3IUzNahotT41lJ4bMevBY7XMAS3n5ekyABN/9ZRJqhWdXgmFCRN/u56qd6lDgu7R2M2QUoyc
+LuW5DfgRItKlmUB7sw==
+-----END CERTIFICATE-----

api/res/certs/alipay/privateKey.txt

@@ -0,0 +1 @@
+MIIEpQIBAAKCAQEAsYoUD39UPoPQK4DOOrIVai+bG0YWv3X/eQ9T7FshKgDZlphuM2fpLGA1UK3OCs4UkaIuerJv+0wxWE5jOm1vfXv5ylufFscmQeInuagNxeJ9e6bD8g6m/CKJHEJgqYUhQ2l0A+gKF6CzbUzNLwCNnFsQIHm2f77K3Y+TbY7fkadzWDApNYucaLx3HyC8yxBm10F6E/X6OQIR6LU1musR1Sz1BmPasC80MR8wZr8uWTH5znyZJv5g4rE0qgFAefRd3c1P9QEVZBGdcDIG+F6IVgcOorq0H2zJx9piKJgAMMGVRb/rFw2y/cjG0jKP0o1bE0Ka59ENBJ8C6O55pjjOhwIDAQABAoIBAFetNfz1R7hbxjlFshMAkVzQR8wvT9qbvl+dtzdZRcaFhu89NecDIP7+QDYor0FcxoGpU0TazDyRQyk2BQD8vHt+9zv9BVLtZLJSqoWgPbUFBi1DjS8EF2ka8RVYnn35NhUhhd7L//ftL88Bh673mfembQ9srDjoEy1Z01feoABAnCMkNFl986DmEwnarvEufXSDIgeN4ioMxha4NvfIPuI0zpVdV1O9sv+SGC+VEWZBtN3GNsaf4zS/f8FVGvTiU/Abz0gSw/iwSPHclDWQDTN3yFHf/tfqlzh0mH0WfhnuOBFWXzK+R7fbnM+asI9ttvzRcfpzgRGXdPcNcOv/6cECgYEA3DVqpi1k8MYfJixju6SG5gfyhM4VFksFmCMaNPgtatDMBKLMTgV/Ej6LXREojcy29uZl83F09pVlpd41eG39ULIPktixA/BqErQ2UaWh6kOxifycpu22Jh0r09hax6UgVrcBrrnCJEjcFsuJlrZvXQSzc3PBxjWy5gjabS5h9iECgYEAzmVAIh2frF01Y95zsLueAhhZwCtPanm6kf7ivR4r1plIX3b2sNRhWGmEHFgaCE6Braa0ogQ73Hd26kw4ZW+D6QMGC/zjCBEzDLLf++SjdVUHiY5AR4WHqXzq1jdAlsVyo9R661oAOp3lhiJVGLNXkHyEfEVPHsaxJh4osYSbX6cCgYEAx32Qx0i6eDFTyLZQB46uMrgiaVN04QRH5iJuvGvUYT8UhGKjaU8rZfDJOh+wOH2rhxMEaz1uc3C2bERY9mfWI4Ob/jFWc7YZsiYWS3Mcsuhubw4tMECLUg39RWZsHw8ls8kIuixIh6yFzhTH6YQOcRswIrhMZG8DScfdcSmiz2ECgYEAkWP1t5KSpkLKl11etcKUXfl1T8+yk9jIOowIgRw92WAFAWq2AH67TCKYM7dEL1HOO9tRJ0hAOt/U3ttuZtYVYBEHM26jJ02mXm2rJrA7DS4mrxmL4lYH6LbcXqZxU0Qnq4zEQgIWYzRTORf6Rfof1uJAGaJhR9bDd4yLMfGt2cUCgYEAo216Y61xOHUTA4AF1eekk+r+uOcQgQDvLXfs9FkDdJLk0mPG48/+eIYpPFnANJ/riF/DWOp8WGEe2IzA9yUFexzDbNQK8ha9kGcxaSAyiCwzjZ/t9/+hScDSV8kNqWSRSisu/YOFleEHbokT6mbLZ+gdqES8mUUanaEBzRQYGxo=

api/service/captcha_service.go

@@ -0,0 +1,110 @@
+package service
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"errors"
+	"fmt"
+	"geekai/core/types"
+	"github.com/imroc/req/v3"
+	"time"
+)
+
+type CaptchaService struct {
+	config types.ApiConfig
+	client *req.Client
+}
+
+func NewCaptchaService(config types.ApiConfig) *CaptchaService {
+	return &CaptchaService{
+		config: config,
+		client: req.C().SetTimeout(10 * time.Second),
+	}
+}
+
+func (s *CaptchaService) Get() (interface{}, error) {
+	if s.config.Token == "" {
+		return nil, errors.New("无效的 API Token")
+	}
+
+	url := fmt.Sprintf("%s/api/captcha/get", s.config.ApiURL)
+	var res types.BizVo
+	r, err := s.client.R().
+		SetHeader("AppId", s.config.AppId).
+		SetHeader("Authorization", fmt.Sprintf("Bearer %s", s.config.Token)).
+		SetSuccessResult(&res).Get(url)
+	if err != nil || r.IsErrorState() {
+		return nil, fmt.Errorf("请求 API 失败：%v", err)
+	}
+
+	if res.Code != types.Success {
+		return nil, fmt.Errorf("请求 API 失败：%s", res.Message)
+	}
+
+	return res.Data, nil
+}
+
+func (s *CaptchaService) Check(data interface{}) bool {
+	url := fmt.Sprintf("%s/api/captcha/check", s.config.ApiURL)
+	var res types.BizVo
+	r, err := s.client.R().
+		SetHeader("AppId", s.config.AppId).
+		SetHeader("Authorization", fmt.Sprintf("Bearer %s", s.config.Token)).
+		SetBodyJsonMarshal(data).
+		SetSuccessResult(&res).Post(url)
+	if err != nil || r.IsErrorState() {
+		return false
+	}
+
+	if res.Code != types.Success {
+		return false
+	}
+
+	return true
+}
+
+func (s *CaptchaService) SlideGet() (interface{}, error) {
+	if s.config.Token == "" {
+		return nil, errors.New("无效的 API Token")
+	}
+
+	url := fmt.Sprintf("%s/api/captcha/slide/get", s.config.ApiURL)
+	var res types.BizVo
+	r, err := s.client.R().
+		SetHeader("AppId", s.config.AppId).
+		SetHeader("Authorization", fmt.Sprintf("Bearer %s", s.config.Token)).
+		SetSuccessResult(&res).Get(url)
+	if err != nil || r.IsErrorState() {
+		return nil, fmt.Errorf("请求 API 失败：%v", err)
+	}
+
+	if res.Code != types.Success {
+		return nil, fmt.Errorf("请求 API 失败：%s", res.Message)
+	}
+
+	return res.Data, nil
+}
+
+func (s *CaptchaService) SlideCheck(data interface{}) bool {
+	url := fmt.Sprintf("%s/api/captcha/slide/check", s.config.ApiURL)
+	var res types.BizVo
+	r, err := s.client.R().
+		SetHeader("AppId", s.config.AppId).
+		SetHeader("Authorization", fmt.Sprintf("Bearer %s", s.config.Token)).
+		SetBodyJsonMarshal(data).
+		SetSuccessResult(&res).Post(url)
+	if err != nil || r.IsErrorState() {
+		return false
+	}
+
+	if res.Code != types.Success {
+		return false
+	}
+
+	return true
+}

api/service/dalle/service.go

@@ -0,0 +1,333 @@
+package dalle
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"fmt"
+	"geekai/core/types"
+	logger2 "geekai/logger"
+	"geekai/service"
+	"geekai/service/oss"
+	"geekai/store"
+	"geekai/store/model"
+	"geekai/utils"
+	"io"
+	"time"
+
+	"github.com/go-redis/redis/v8"
+
+	"github.com/imroc/req/v3"
+	"gorm.io/gorm"
+)
+
+var logger = logger2.GetLogger()
+
+// DALL-E 绘画服务
+
+type Service struct {
+	httpClient    *req.Client
+	db            *gorm.DB
+	uploadManager *oss.UploaderManager
+	taskQueue     *store.RedisQueue
+	notifyQueue   *store.RedisQueue
+	userService   *service.UserService
+	wsService     *service.WebsocketService
+	clientIds     map[uint]string
+}
+
+func NewService(db *gorm.DB, manager *oss.UploaderManager, redisCli *redis.Client, userService *service.UserService, wsService *service.WebsocketService) *Service {
+	return &Service{
+		httpClient:    req.C().SetTimeout(time.Minute * 3),
+		db:            db,
+		taskQueue:     store.NewRedisQueue("DallE_Task_Queue", redisCli),
+		notifyQueue:   store.NewRedisQueue("DallE_Notify_Queue", redisCli),
+		wsService:     wsService,
+		uploadManager: manager,
+		userService:   userService,
+		clientIds:     map[uint]string{},
+	}
+}
+
+// PushTask push a new mj task in to task queue
+func (s *Service) PushTask(task types.DallTask) {
+	logger.Infof("add a new DALL-E task to the task list: %+v", task)
+	s.taskQueue.RPush(task)
+}
+
+func (s *Service) Run() {
+	// 将数据库中未提交的人物加载到队列
+	var jobs []model.DallJob
+	s.db.Where("progress", 0).Find(&jobs)
+	for _, v := range jobs {
+		var task types.DallTask
+		err := utils.JsonDecode(v.TaskInfo, &task)
+		if err != nil {
+			logger.Errorf("decode task info with error: %v", err)
+			continue
+		}
+		task.Id = v.Id
+		s.PushTask(task)
+	}
+
+	logger.Info("Starting DALL-E job consumer...")
+	go func() {
+		for {
+			var task types.DallTask
+			err := s.taskQueue.LPop(&task)
+			if err != nil {
+				logger.Errorf("taking task with error: %v", err)
+				continue
+			}
+			logger.Infof("handle a new DALL-E task: %+v", task)
+			s.clientIds[task.Id] = task.ClientId
+			_, err = s.Image(task, false)
+			if err != nil {
+				logger.Errorf("error with image task: %v", err)
+				s.db.Model(&model.DallJob{Id: task.Id}).UpdateColumns(map[string]interface{}{
+					"progress": service.FailTaskProgress,
+					"err_msg":  err.Error(),
+				})
+				s.notifyQueue.RPush(service.NotifyMessage{ClientId: task.ClientId, UserId: int(task.UserId), JobId: int(task.Id), Message: service.TaskStatusFailed})
+			}
+		}
+	}()
+}
+
+type imgReq struct {
+	Model   string `json:"model"`
+	Prompt  string `json:"prompt"`
+	N       int    `json:"n,omitempty"`
+	Size    string `json:"size,omitempty"`
+	Quality string `json:"quality,omitempty"`
+	Style   string `json:"style,omitempty"`
+}
+
+type imgRes struct {
+	Created int64 `json:"created"`
+	Data    []struct {
+		RevisedPrompt string `json:"revised_prompt,omitempty"`
+		Url           string `json:"url,omitempty"`
+		B64Json       string `json:"b64_json,omitempty"`
+	} `json:"data"`
+}
+
+type ErrRes struct {
+	Error struct {
+		Code    interface{} `json:"code"`
+		Message string      `json:"message"`
+		Param   interface{} `json:"param"`
+		Type    string      `json:"type"`
+	} `json:"error"`
+}
+
+func (s *Service) Image(task types.DallTask, sync bool) (string, error) {
+	logger.Debugf("绘画参数：%+v", task)
+	prompt := task.Prompt
+	// translate prompt
+	if utils.HasChinese(prompt) {
+		content, err := utils.OpenAIRequest(s.db, fmt.Sprintf(service.TranslatePromptTemplate, prompt), task.TranslateModelId)
+		if err == nil {
+			prompt = content
+			logger.Debugf("重写后提示词：%s", prompt)
+		}
+	}
+
+	var chatModel model.ChatModel
+	s.db.Where("id = ?", task.ModelId).First(&chatModel)
+
+	// get image generation API KEY
+	var apiKey model.ApiKey
+	session := s.db.Where("enabled", true)
+	if chatModel.KeyId > 0 {
+		session = session.Where("id = ?", chatModel.KeyId)
+	} else {
+		session = session.Where("type = ?", "dalle")
+	}
+	err := session.Order("last_used_at ASC").First(&apiKey).Error
+	if err != nil {
+		return "", fmt.Errorf("no available Image Generation api key: %v", err)
+	}
+
+	var res imgRes
+	var errRes ErrRes
+	if len(apiKey.ProxyURL) > 5 {
+		s.httpClient.SetProxyURL(apiKey.ProxyURL).R()
+	}
+	apiURL := fmt.Sprintf("%s/v1/images/generations", apiKey.ApiURL)
+	reqBody := imgReq{
+		Model:   chatModel.Value,
+		Prompt:  prompt,
+		N:       1,
+		Size:    task.Size,
+		Style:   task.Style,
+		Quality: task.Quality,
+	}
+	logger.Infof("Channel:%s, API KEY:%s, BODY: %+v", apiURL, apiKey.Value, reqBody)
+	r, err := s.httpClient.R().SetHeader("Body-Type", "application/json").
+		SetHeader("Authorization", "Bearer "+apiKey.Value).
+		SetBody(reqBody).
+		SetErrorResult(&errRes).
+		SetSuccessResult(&res).
+		Post(apiURL)
+	if err != nil {
+		logger.Errorf("error with send request: %v", err)
+		return "", fmt.Errorf("error with send request: %v", err)
+	}
+
+	if r.IsErrorState() {
+		logger.Errorf("error with send request, status: %s, %+v", r.Status, errRes.Error)
+		return "", fmt.Errorf("error with send request, status: %s, %+v", r.Status, errRes.Error)
+	}
+
+	all, _ := io.ReadAll(r.Body)
+	logger.Debugf("response: %+v", string(all))
+
+	// update the api key last use time
+	s.db.Model(&apiKey).UpdateColumn("last_used_at", time.Now().Unix())
+	var imgURL string
+	var data = map[string]interface{}{
+		"progress": 100,
+		"prompt":   prompt,
+	}
+	// 如果返回的是base64，则需要上传到oss
+	if res.Data[0].B64Json != "" {
+		imgURL, err = s.uploadManager.GetUploadHandler().PutBase64(res.Data[0].B64Json)
+		if err != nil {
+			return "", fmt.Errorf("error with upload image: %v", err)
+		}
+		logger.Infof("upload image to oss: %s", imgURL)
+		data["img_url"] = imgURL
+	} else {
+		imgURL = res.Data[0].Url
+	}
+	data["org_url"] = imgURL
+	// update task progress
+	err = s.db.Model(&model.DallJob{Id: task.Id}).UpdateColumns(data).Error
+	if err != nil {
+		return "", fmt.Errorf("err with update database: %v", err)
+	}
+
+	s.notifyQueue.RPush(service.NotifyMessage{ClientId: task.ClientId, UserId: int(task.UserId), JobId: int(task.Id), Message: service.TaskStatusFailed})
+	var content string
+	if sync {
+		imgURL, err := s.downloadImage(task.Id, int(task.UserId), res.Data[0].Url)
+		if err != nil {
+			return "", fmt.Errorf("error with download image: %v", err)
+		}
+		content = fmt.Sprintf("```\n%s\n```\n下面是我为你创作的图片：\n\n![](%s)\n", prompt, imgURL)
+	}
+
+	return content, nil
+}
+
+func (s *Service) CheckTaskNotify() {
+	go func() {
+		logger.Info("Running DALL-E task notify checking ...")
+		for {
+			var message service.NotifyMessage
+			err := s.notifyQueue.LPop(&message)
+			if err != nil {
+				continue
+			}
+
+			logger.Debugf("notify message: %+v", message)
+			client := s.wsService.Clients.Get(message.ClientId)
+			if client == nil {
+				continue
+			}
+			utils.SendChannelMsg(client, types.ChDall, message.Message)
+		}
+	}()
+}
+
+func (s *Service) CheckTaskStatus() {
+	go func() {
+		logger.Info("Running DALL-E task status checking ...")
+		for {
+			// 检查未完成任务进度
+			var jobs []model.DallJob
+			s.db.Where("progress < ?", 100).Find(&jobs)
+			for _, job := range jobs {
+				// 超时的任务标记为失败
+				if time.Now().Sub(job.CreatedAt) > time.Minute*10 {
+					job.Progress = service.FailTaskProgress
+					job.ErrMsg = "任务超时"
+					s.db.Updates(&job)
+				}
+			}
+
+			// 找出失败的任务，并恢复其扣减算力
+			s.db.Where("progress", service.FailTaskProgress).Where("power > ?", 0).Find(&jobs)
+			for _, job := range jobs {
+				var task types.DallTask
+				err := utils.JsonDecode(job.TaskInfo, &task)
+				if err != nil {
+					continue
+				}
+				err = s.userService.IncreasePower(int(job.UserId), job.Power, model.PowerLog{
+					Type:   types.PowerRefund,
+					Model:  task.ModelName,
+					Remark: fmt.Sprintf("任务失败，退回算力。任务ID：%d，Err: %s", job.Id, job.ErrMsg),
+				})
+				if err != nil {
+					continue
+				}
+				// 更新任务状态
+				s.db.Model(&job).UpdateColumn("power", 0)
+			}
+			time.Sleep(time.Second * 10)
+		}
+	}()
+}
+
+func (s *Service) DownloadImages() {
+	go func() {
+		var items []model.DallJob
+		for {
+			res := s.db.Where("img_url = ? AND progress = ?", "", 100).Find(&items)
+			if res.Error != nil {
+				continue
+			}
+
+			// download images
+			for _, v := range items {
+				if v.OrgURL == "" {
+					continue
+				}
+
+				logger.Infof("try to download image: %s", v.OrgURL)
+				imgURL, err := s.downloadImage(v.Id, int(v.UserId), v.OrgURL)
+				if err != nil {
+					logger.Error("error with download image: %s, error: %v", imgURL, err)
+					continue
+				} else {
+					logger.Infof("download image %s successfully.", v.OrgURL)
+				}
+
+			}
+
+			time.Sleep(time.Second * 5)
+		}
+	}()
+}
+
+func (s *Service) downloadImage(jobId uint, userId int, orgURL string) (string, error) {
+	// sava image
+	imgURL, err := s.uploadManager.GetUploadHandler().PutUrlFile(orgURL, false)
+	if err != nil {
+		return "", err
+	}
+
+	// update img_url
+	res := s.db.Model(&model.DallJob{Id: jobId}).UpdateColumn("img_url", imgURL)
+	if res.Error != nil {
+		return "", err
+	}
+	s.notifyQueue.RPush(service.NotifyMessage{ClientId: s.clientIds[jobId], UserId: userId, JobId: int(jobId), Message: service.TaskStatusFinished})
+	return imgURL, nil
+}

api/service/license_service.go

@@ -0,0 +1,197 @@
+package service
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"fmt"
+	"geekai/core"
+	"geekai/core/types"
+	"geekai/store"
+	"time"
+
+	"github.com/imroc/req/v3"
+)
+
+type LicenseService struct {
+	config       types.ApiConfig
+	levelDB      *store.LevelDB
+	license      *types.License
+	urlWhiteList []string
+	machineId    string
+}
+
+func NewLicenseService(server *core.AppServer, levelDB *store.LevelDB) *LicenseService {
+	var license types.License
+	return &LicenseService{
+		config:    server.Config.ApiConfig,
+		levelDB:   levelDB,
+		license:   &license,
+		machineId: "",
+	}
+}
+
+type License struct {
+	Name      string              `json:"name"`
+	License   string              `json:"license"`
+	MachineId string              `json:"mid"`
+	ActiveAt  int64               `json:"active_at"`
+	ExpiredAt int64               `json:"expired_at"`
+	UserNum   int                 `json:"user_num"`
+	Configs   types.LicenseConfig `json:"configs"`
+}
+
+// ActiveLicense 激活 License
+func (s *LicenseService) ActiveLicense(license string, machineId string) error {
+	var res struct {
+		Code    types.BizCode `json:"code"`
+		Message string        `json:"message"`
+		Data    License       `json:"data"`
+	}
+	apiURL := fmt.Sprintf("%s/%s", s.config.ApiURL, "api/license/active")
+	response, err := req.C().R().
+		SetBody(map[string]string{"license": license, "machine_id": machineId}).
+		SetSuccessResult(&res).Post(apiURL)
+	if err != nil {
+		return fmt.Errorf("发送激活请求失败: %v", err)
+	}
+
+	if response.IsErrorState() {
+		return fmt.Errorf("发送激活请求失败：%v", response.Status)
+	}
+
+	if res.Code != types.Success {
+		return fmt.Errorf("激活失败：%v", res.Message)
+	}
+
+	s.license = &types.License{
+		Key:       license,
+		MachineId: machineId,
+		Configs:   res.Data.Configs,
+		ExpiredAt: res.Data.ExpiredAt,
+		IsActive:  true,
+	}
+	err = s.levelDB.Put(types.LicenseKey, s.license)
+	if err != nil {
+		return fmt.Errorf("保存许可证书失败：%v", err)
+	}
+	return nil
+}
+
+// SyncLicense 定期同步 License
+func (s *LicenseService) SyncLicense() {
+	go func() {
+		retryCounter := 0
+		for {
+			license, err := s.fetchLicense()
+			if err != nil {
+				retryCounter++
+				if retryCounter < 5 {
+					logger.Warn(err)
+				}
+				s.license.IsActive = false
+			} else {
+				s.license = license
+			}
+
+			urls, err := s.fetchUrlWhiteList()
+			if err == nil {
+				s.urlWhiteList = urls
+			}
+
+			time.Sleep(time.Second * 10)
+		}
+	}()
+}
+
+func (s *LicenseService) fetchLicense() (*types.License, error) {
+	//var res struct {
+	//	Code    types.BizCode `json:"code"`
+	//	Message string        `json:"message"`
+	//	Data    License       `json:"data"`
+	//}
+	//apiURL := fmt.Sprintf("%s/%s", s.config.ApiURL, "api/license/check")
+	//response, err := req.C().R().
+	//	SetBody(map[string]string{"license": s.license.Key, "machine_id": s.machineId}).
+	//	SetSuccessResult(&res).Post(apiURL)
+	//if err != nil {
+	//	return nil, fmt.Errorf("发送激活请求失败: %v", err)
+	//}
+	//if response.IsErrorState() {
+	//	return nil, fmt.Errorf("激活失败：%v", response.Status)
+	//}
+	//if res.Code != types.Success {
+	//	return nil, fmt.Errorf("激活失败：%v", res.Message)
+	//}
+
+	return &types.License{
+		Key:       "abc",
+		MachineId: "abc",
+		Configs: types.LicenseConfig{
+			UserNum: 10000,
+			DeCopy:  false,
+		},
+		ExpiredAt: 0,
+		IsActive:  true,
+	}, nil
+}
+
+func (s *LicenseService) fetchUrlWhiteList() ([]string, error) {
+	var res struct {
+		Code    types.BizCode `json:"code"`
+		Message string        `json:"message"`
+		Data    []string      `json:"data"`
+	}
+	apiURL := fmt.Sprintf("%s/%s", s.config.ApiURL, "api/license/urls")
+	response, err := req.C().R().SetSuccessResult(&res).Get(apiURL)
+	if err != nil {
+		return nil, fmt.Errorf("发送请求失败: %v", err)
+	}
+	if response.IsErrorState() {
+		return nil, fmt.Errorf("发送请求失败：%v", response.Status)
+	}
+	if res.Code != types.Success {
+		return nil, fmt.Errorf("获取白名单失败：%v", res.Message)
+	}
+
+	return res.Data, nil
+}
+
+// GetLicense 获取许可信息
+func (s *LicenseService) GetLicense() *types.License {
+	return s.license
+}
+
+// IsValidApiURL 判断是否合法的中转 URL
+func (s *LicenseService) IsValidApiURL(uri string) error {
+	// 获得许可授权的直接放行
+	return nil
+	//if s.license.IsActive {
+	//	if s.license.MachineId != s.machineId {
+	//		return errors.New("系统使用了盗版的许可证书")
+	//	}
+	//
+	//	if time.Now().Unix() > s.license.ExpiredAt {
+	//		return errors.New("系统许可证书已经过期")
+	//	}
+	//	return nil
+	//}
+	//
+	//if len(s.urlWhiteList) == 0 {
+	//	urls, err := s.fetchUrlWhiteList()
+	//	if err == nil {
+	//		s.urlWhiteList = urls
+	//	}
+	//}
+	//
+	//for _, v := range s.urlWhiteList {
+	//	if strings.HasPrefix(uri, v) {
+	//		return nil
+	//	}
+	//}
+	//return fmt.Errorf("当前 API 地址 %s 不在白名单列表当中。", uri)
+}

api/service/mj/client.go

@@ -0,0 +1,250 @@
+package mj
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"geekai/core/types"
+	logger2 "geekai/logger"
+	"geekai/service"
+	"geekai/store/model"
+	"geekai/utils"
+	"github.com/imroc/req/v3"
+	"gorm.io/gorm"
+	"io"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+// Client MidJourney client
+type Client struct {
+	client         *req.Client
+	licenseService *service.LicenseService
+	db             *gorm.DB
+}
+
+type ImageReq struct {
+	BotType       string      `json:"botType,omitempty"`
+	Prompt        string      `json:"prompt,omitempty"`
+	Dimensions    string      `json:"dimensions,omitempty"`
+	Base64Array   []string    `json:"base64Array,omitempty"`
+	AccountFilter interface{} `json:"accountFilter,omitempty"`
+	NotifyHook    string      `json:"notifyHook,omitempty"`
+	State         string      `json:"state,omitempty"`
+}
+
+type ImageRes struct {
+	Code        int    `json:"code"`
+	Description string `json:"description"`
+	Properties  struct {
+	} `json:"properties"`
+	Result  string `json:"result"`
+	Channel string `json:"channel,omitempty"`
+}
+
+type QueryRes struct {
+	Action  string `json:"action"`
+	Buttons []struct {
+		CustomId string `json:"customId"`
+		Emoji    string `json:"emoji"`
+		Label    string `json:"label"`
+		Style    int    `json:"style"`
+		Type     int    `json:"type"`
+	} `json:"buttons"`
+	Description string `json:"description"`
+	FailReason  string `json:"failReason"`
+	FinishTime  int    `json:"finishTime"`
+	Id          string `json:"id"`
+	ImageUrl    string `json:"imageUrl"`
+	Progress    string `json:"progress"`
+	Prompt      string `json:"prompt"`
+	PromptEn    string `json:"promptEn"`
+	Properties  struct {
+	} `json:"properties"`
+	StartTime  int    `json:"startTime"`
+	State      string `json:"state"`
+	Status     string `json:"status"`
+	SubmitTime int    `json:"submitTime"`
+}
+
+var logger = logger2.GetLogger()
+
+func NewClient(licenseService *service.LicenseService, db *gorm.DB) *Client {
+	return &Client{
+		client:         req.C().SetTimeout(time.Minute).SetUserAgent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36"),
+		licenseService: licenseService,
+		db:             db,
+	}
+}
+
+func (c *Client) Imagine(task types.MjTask) (ImageRes, error) {
+	apiPath := fmt.Sprintf("mj-%s/mj/submit/imagine", task.Mode)
+	prompt := fmt.Sprintf("%s %s", task.Prompt, task.Params)
+	if task.NegPrompt != "" {
+		prompt += fmt.Sprintf(" --no %s", task.NegPrompt)
+	}
+	body := ImageReq{
+		BotType:     "MID_JOURNEY",
+		Prompt:      prompt,
+		Base64Array: make([]string, 0),
+	}
+	// 生成图片 Base64 编码
+	if len(task.ImgArr) > 0 {
+		imageData, err := utils.DownloadImage(task.ImgArr[0], "")
+		if err != nil {
+			logger.Error("error with download image: ", err)
+		} else {
+			body.Base64Array = append(body.Base64Array, "data:image/png;base64,"+base64.StdEncoding.EncodeToString(imageData))
+		}
+
+	}
+	return c.doRequest(body, apiPath, task.ChannelId)
+}
+
+// Blend 融图
+func (c *Client) Blend(task types.MjTask) (ImageRes, error) {
+	apiPath := fmt.Sprintf("mj-%s/mj/submit/blend", task.Mode)
+	body := ImageReq{
+		BotType:     "MID_JOURNEY",
+		Dimensions:  "SQUARE",
+		Base64Array: make([]string, 0),
+	}
+	// 生成图片 Base64 编码
+	if len(task.ImgArr) > 0 {
+		for _, imgURL := range task.ImgArr {
+			imageData, err := utils.DownloadImage(imgURL, "")
+			if err != nil {
+				logger.Error("error with download image: ", err)
+			} else {
+				body.Base64Array = append(body.Base64Array, "data:image/png;base64,"+base64.StdEncoding.EncodeToString(imageData))
+			}
+		}
+	}
+	return c.doRequest(body, apiPath, task.ChannelId)
+}
+
+// SwapFace 换脸
+func (c *Client) SwapFace(task types.MjTask) (ImageRes, error) {
+	apiPath := fmt.Sprintf("mj-%s/mj/insight-face/swap", task.Mode)
+	// 生成图片 Base64 编码
+	if len(task.ImgArr) != 2 {
+		return ImageRes{}, errors.New("参数错误，必须上传2张图片")
+	}
+	var sourceBase64 string
+	var targetBase64 string
+	imageData, err := utils.DownloadImage(task.ImgArr[0], "")
+	if err != nil {
+		logger.Error("error with download image: ", err)
+	} else {
+		sourceBase64 = "data:image/png;base64," + base64.StdEncoding.EncodeToString(imageData)
+	}
+	imageData, err = utils.DownloadImage(task.ImgArr[1], "")
+	if err != nil {
+		logger.Error("error with download image: ", err)
+	} else {
+		targetBase64 = "data:image/png;base64," + base64.StdEncoding.EncodeToString(imageData)
+	}
+
+	body := gin.H{
+		"sourceBase64": sourceBase64,
+		"targetBase64": targetBase64,
+		"accountFilter": gin.H{
+			"instanceId": "",
+		},
+		"state": "",
+	}
+	return c.doRequest(body, apiPath, task.ChannelId)
+}
+
+// Upscale 放大指定的图片
+func (c *Client) Upscale(task types.MjTask) (ImageRes, error) {
+	body := map[string]string{
+		"customId": fmt.Sprintf("MJ::JOB::upsample::%d::%s", task.Index, task.MessageHash),
+		"taskId":   task.MessageId,
+	}
+	apiPath := fmt.Sprintf("mj-%s/mj/submit/action", task.Mode)
+	return c.doRequest(body, apiPath, task.ChannelId)
+}
+
+// Variation  以指定的图片的视角进行变换再创作，注意需要在对应的频道中关闭 Remix 变换，否则 Variation 指令将不会生效
+func (c *Client) Variation(task types.MjTask) (ImageRes, error) {
+	body := map[string]string{
+		"customId": fmt.Sprintf("MJ::JOB::variation::%d::%s", task.Index, task.MessageHash),
+		"taskId":   task.MessageId,
+	}
+	apiPath := fmt.Sprintf("mj-%s/mj/submit/action", task.Mode)
+
+	return c.doRequest(body, apiPath, task.ChannelId)
+}
+
+func (c *Client) doRequest(body interface{}, apiPath string, channel string) (ImageRes, error) {
+	var res ImageRes
+	session := c.db.Session(&gorm.Session{}).Where("type", "mj").Where("enabled", true)
+	if channel != "" {
+		session = session.Where("api_url", channel)
+	}
+
+	var apiKey model.ApiKey
+	err := session.Order("last_used_at ASC").First(&apiKey).Error
+	if err != nil {
+		return ImageRes{}, fmt.Errorf("no available MidJourney api key: %v", err)
+	}
+
+	if err = c.licenseService.IsValidApiURL(apiKey.ApiURL); err != nil {
+		return ImageRes{}, err
+	}
+
+	apiURL := fmt.Sprintf("%s/%s", apiKey.ApiURL, apiPath)
+	logger.Info("API URL: ", apiURL)
+	r, err := req.C().R().
+		SetHeader("Authorization", "Bearer "+apiKey.Value).
+		SetBody(body).
+		SetSuccessResult(&res).
+		Post(apiURL)
+	if err != nil {
+		return ImageRes{}, fmt.Errorf("请求 API 出错：%v", err)
+	}
+
+	if r.IsErrorState() {
+		errMsg, _ := io.ReadAll(r.Body)
+		return ImageRes{}, fmt.Errorf("API 返回错误：%s", string(errMsg))
+	}
+
+	// update the api key last used time
+	if err = c.db.Model(&apiKey).Update("last_used_at", time.Now().Unix()).Error; err != nil {
+		logger.Error("update api key last used time error: ", err)
+	}
+	res.Channel = apiKey.ApiURL
+	return res, nil
+}
+
+func (c *Client) QueryTask(taskId string, channel string) (QueryRes, error) {
+	var apiKey model.ApiKey
+	err := c.db.Where("type", "mj").Where("enabled", true).Where("api_url", channel).First(&apiKey).Error
+	if err != nil {
+		return QueryRes{}, fmt.Errorf("no available MidJourney api key: %v", err)
+	}
+	apiURL := fmt.Sprintf("%s/mj/task/%s/fetch", apiKey.ApiURL, taskId)
+	var res QueryRes
+	r, err := c.client.R().SetHeader("Authorization", "Bearer "+apiKey.Value).
+		SetSuccessResult(&res).
+		Get(apiURL)
+
+	if err != nil {
+		return QueryRes{}, err
+	}
+
+	if r.IsErrorState() {
+		return QueryRes{}, errors.New("error status:" + r.Status)
+	}
+
+	return res, nil
+}

api/service/mj/service.go

@@ -0,0 +1,340 @@
+package mj
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"fmt"
+	"geekai/core/types"
+	"geekai/service"
+	"geekai/service/oss"
+	"geekai/store"
+	"geekai/store/model"
+	"geekai/utils"
+	"github.com/go-redis/redis/v8"
+	"strings"
+	"time"
+
+	"gorm.io/gorm"
+)
+
+// Service MJ 绘画服务
+type Service struct {
+	client          *Client // MJ Client
+	taskQueue       *store.RedisQueue
+	notifyQueue     *store.RedisQueue
+	db              *gorm.DB
+	wsService       *service.WebsocketService
+	uploaderManager *oss.UploaderManager
+	userService     *service.UserService
+	clientIds       map[uint]string
+}
+
+func NewService(redisCli *redis.Client, db *gorm.DB, client *Client, manager *oss.UploaderManager, wsService *service.WebsocketService, userService *service.UserService) *Service {
+	return &Service{
+		db:              db,
+		taskQueue:       store.NewRedisQueue("MidJourney_Task_Queue", redisCli),
+		notifyQueue:     store.NewRedisQueue("MidJourney_Notify_Queue", redisCli),
+		client:          client,
+		wsService:       wsService,
+		uploaderManager: manager,
+		clientIds:       map[uint]string{},
+		userService:     userService,
+	}
+}
+
+func (s *Service) Run() {
+	// 将数据库中未提交的人物加载到队列
+	var jobs []model.MidJourneyJob
+	s.db.Where("task_id", "").Where("progress", 0).Find(&jobs)
+	for _, v := range jobs {
+		var task types.MjTask
+		err := utils.JsonDecode(v.TaskInfo, &task)
+		if err != nil {
+			logger.Errorf("decode task info with error: %v", err)
+			continue
+		}
+		task.Id = v.Id
+		s.clientIds[task.Id] = task.ClientId
+		s.PushTask(task)
+	}
+
+	logger.Info("Starting MidJourney job consumer for service")
+	go func() {
+		for {
+			var task types.MjTask
+			err := s.taskQueue.LPop(&task)
+			if err != nil {
+				logger.Errorf("taking task with error: %v", err)
+				continue
+			}
+
+			// translate prompt
+			if utils.HasChinese(task.Prompt) {
+				content, err := utils.OpenAIRequest(s.db, fmt.Sprintf(service.TranslatePromptTemplate, task.Prompt), task.TranslateModelId)
+				if err == nil {
+					task.Prompt = content
+				} else {
+					logger.Warnf("error with translate prompt: %v", err)
+				}
+			}
+			// translate negative prompt
+			if task.NegPrompt != "" && utils.HasChinese(task.NegPrompt) {
+				content, err := utils.OpenAIRequest(s.db, fmt.Sprintf(service.TranslatePromptTemplate, task.NegPrompt), task.TranslateModelId)
+				if err == nil {
+					task.NegPrompt = content
+				} else {
+					logger.Warnf("error with translate prompt: %v", err)
+				}
+			}
+
+			// use fast mode as default
+			if task.Mode == "" {
+				task.Mode = "fast"
+			}
+			s.clientIds[task.Id] = task.ClientId
+
+			var job model.MidJourneyJob
+			tx := s.db.Where("id = ?", task.Id).First(&job)
+			if tx.Error != nil {
+				logger.Error("任务不存在，任务ID：", task.TaskId)
+				continue
+			}
+
+			logger.Infof("handle a new MidJourney task: %+v", task)
+			var res ImageRes
+			switch task.Type {
+			case types.TaskImage:
+				res, err = s.client.Imagine(task)
+				break
+			case types.TaskUpscale:
+				res, err = s.client.Upscale(task)
+				break
+			case types.TaskVariation:
+				res, err = s.client.Variation(task)
+				break
+			case types.TaskBlend:
+				res, err = s.client.Blend(task)
+				break
+			case types.TaskSwapFace:
+				res, err = s.client.SwapFace(task)
+				break
+			}
+
+			if err != nil || (res.Code != 1 && res.Code != 22) {
+				var errMsg string
+				if err != nil {
+					errMsg = err.Error()
+				} else {
+					errMsg = fmt.Sprintf("%v,%s", err, res.Description)
+				}
+
+				logger.Error("绘画任务执行失败：", errMsg)
+				job.Progress = service.FailTaskProgress
+				job.ErrMsg = errMsg
+				// update the task progress
+				s.db.Updates(&job)
+				// 任务失败，通知前端
+				s.notifyQueue.RPush(service.NotifyMessage{ClientId: task.ClientId, UserId: task.UserId, JobId: int(job.Id), Message: service.TaskStatusFailed})
+				continue
+			}
+			logger.Infof("任务提交成功：%+v", res)
+			// 更新任务 ID/频道
+			job.TaskId = res.Result
+			job.MessageId = res.Result
+			job.ChannelId = res.Channel
+			s.db.Updates(&job)
+		}
+	}()
+}
+
+type CBReq struct {
+	Id          string      `json:"id"`
+	Action      string      `json:"action"`
+	Status      string      `json:"status"`
+	Prompt      string      `json:"prompt"`
+	PromptEn    string      `json:"promptEn"`
+	Description string      `json:"description"`
+	SubmitTime  int64       `json:"submitTime"`
+	StartTime   int64       `json:"startTime"`
+	FinishTime  int64       `json:"finishTime"`
+	Progress    string      `json:"progress"`
+	ImageUrl    string      `json:"imageUrl"`
+	FailReason  interface{} `json:"failReason"`
+	Properties  struct {
+		FinalPrompt string `json:"finalPrompt"`
+	} `json:"properties"`
+}
+
+func GetImageHash(action string) string {
+	split := strings.Split(action, "::")
+	if len(split) > 5 {
+		return split[4]
+	}
+	return split[len(split)-1]
+}
+
+func (s *Service) CheckTaskNotify() {
+	go func() {
+		for {
+			var message service.NotifyMessage
+			err := s.notifyQueue.LPop(&message)
+			if err != nil {
+				continue
+			}
+			logger.Debugf("receive a new mj notify message: %+v", message)
+			client := s.wsService.Clients.Get(message.ClientId)
+			if client == nil {
+				continue
+			}
+			utils.SendChannelMsg(client, types.ChMj, message.Message)
+		}
+	}()
+}
+
+func (s *Service) DownloadImages() {
+	go func() {
+		var items []model.MidJourneyJob
+		for {
+			res := s.db.Where("img_url = ? AND progress = ?", "", 100).Find(&items)
+			if res.Error != nil {
+				continue
+			}
+
+			// download images
+			for _, v := range items {
+				if v.OrgURL == "" {
+					continue
+				}
+
+				logger.Infof("try to download image: %s", v.OrgURL)
+				// 如果是返回的是 discord 图片地址，则使用代理下载
+				proxy := false
+				if strings.HasPrefix(v.OrgURL, "https://cdn.discordapp.com") {
+					proxy = true
+				}
+				imgURL, err := s.uploaderManager.GetUploadHandler().PutUrlFile(v.OrgURL, proxy)
+
+				if err != nil {
+					logger.Errorf("error with download image %s, %v", v.OrgURL, err)
+					continue
+				} else {
+					logger.Infof("download image %s successfully.", v.OrgURL)
+				}
+
+				v.ImgURL = imgURL
+				s.db.Updates(&v)
+
+				s.notifyQueue.RPush(service.NotifyMessage{
+					ClientId: s.clientIds[v.Id],
+					UserId:   v.UserId,
+					JobId:    int(v.Id),
+					Message:  service.TaskStatusFinished})
+			}
+
+			time.Sleep(time.Second * 5)
+		}
+	}()
+}
+
+// PushTask push a new mj task in to task queue
+func (s *Service) PushTask(task types.MjTask) {
+	logger.Debugf("add a new MidJourney task to the task list: %+v", task)
+	s.taskQueue.RPush(task)
+}
+
+// SyncTaskProgress 异步拉取任务
+func (s *Service) SyncTaskProgress() {
+	go func() {
+		var jobs []model.MidJourneyJob
+		for {
+			err := s.db.Where("progress < ?", 100).Find(&jobs).Error
+			if err != nil {
+				continue
+			}
+
+			for _, job := range jobs {
+				// 10 分钟还没完成的任务标记为失败
+				if time.Now().Sub(job.CreatedAt) > time.Minute*10 {
+					job.Progress = service.FailTaskProgress
+					job.ErrMsg = "任务超时"
+					s.db.Updates(&job)
+					continue
+				}
+
+				if job.ChannelId == "" {
+					continue
+				}
+
+				task, err := s.client.QueryTask(job.TaskId, job.ChannelId)
+				if err != nil {
+					logger.Errorf("error with query task: %v", err)
+					continue
+				}
+
+				// 任务执行失败了
+				if task.FailReason != "" {
+					s.db.Model(&model.MidJourneyJob{Id: job.Id}).UpdateColumns(map[string]interface{}{
+						"progress": service.FailTaskProgress,
+						"err_msg":  task.FailReason,
+					})
+					logger.Errorf("task failed: %v", task.FailReason)
+					s.notifyQueue.RPush(service.NotifyMessage{
+						ClientId: s.clientIds[job.Id],
+						UserId:   job.UserId,
+						JobId:    int(job.Id),
+						Message:  service.TaskStatusFailed})
+					continue
+				}
+
+				if len(task.Buttons) > 0 {
+					job.Hash = GetImageHash(task.Buttons[0].CustomId)
+				}
+				oldProgress := job.Progress
+				job.Progress = utils.IntValue(strings.Replace(task.Progress, "%", "", 1), 0)
+				if task.ImageUrl != "" {
+					job.OrgURL = task.ImageUrl
+				}
+				err = s.db.Updates(&job).Error
+				if err != nil {
+					logger.Errorf("error with update database: %v", err)
+					continue
+				}
+
+				// 通知前端更新任务进度
+				if oldProgress != job.Progress {
+					message := service.TaskStatusRunning
+					if job.Progress == 100 {
+						message = service.TaskStatusFinished
+					}
+					s.notifyQueue.RPush(service.NotifyMessage{
+						ClientId: s.clientIds[job.Id],
+						UserId:   job.UserId,
+						JobId:    int(job.Id),
+						Message:  message})
+				}
+			}
+
+			// 找出失败的任务，并恢复其扣减算力
+			s.db.Where("progress", service.FailTaskProgress).Where("power > ?", 0).Find(&jobs)
+			for _, job := range jobs {
+				err := s.userService.IncreasePower(job.UserId, job.Power, model.PowerLog{
+					Type:   types.PowerRefund,
+					Model:  "mid-journey",
+					Remark: fmt.Sprintf("任务失败，退回算力。任务ID：%d，Err: %s", job.Id, job.ErrMsg),
+				})
+				if err != nil {
+					continue
+				}
+				// 更新任务状态
+				s.db.Model(&job).UpdateColumn("power", 0)
+			}
+
+			time.Sleep(time.Second * 5)
+		}
+	}()
+}

api/service/oss/aliyun_oss.go

@@ -0,0 +1,137 @@
+package oss
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"bytes"
+	"encoding/base64"
+	"fmt"
+	"geekai/core/types"
+	"geekai/utils"
+	"net/url"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/aliyun/aliyun-oss-go-sdk/oss"
+	"github.com/gin-gonic/gin"
+)
+
+type AliYunOss struct {
+	config   *types.AliYunOssConfig
+	bucket   *oss.Bucket
+	proxyURL string
+}
+
+func NewAliYunOss(appConfig *types.AppConfig) (*AliYunOss, error) {
+	config := &appConfig.OSS.AliYun
+	// 创建 OSS 客户端
+	client, err := oss.New(config.Endpoint, config.AccessKey, config.AccessSecret)
+	if err != nil {
+		return nil, err
+	}
+
+	// 获取存储空间
+	bucket, err := client.Bucket(config.Bucket)
+	if err != nil {
+		return nil, err
+	}
+
+	if config.SubDir == "" {
+		config.SubDir = "gpt"
+	}
+
+	return &AliYunOss{
+		config:   config,
+		bucket:   bucket,
+		proxyURL: appConfig.ProxyURL,
+	}, nil
+
+}
+
+func (s AliYunOss) PutFile(ctx *gin.Context, name string) (File, error) {
+	// 解析表单
+	file, err := ctx.FormFile(name)
+	if err != nil {
+		return File{}, err
+	}
+	// 打开上传文件
+	src, err := file.Open()
+	if err != nil {
+		return File{}, err
+	}
+	defer src.Close()
+
+	fileExt := filepath.Ext(file.Filename)
+	objectKey := fmt.Sprintf("%s/%d%s", s.config.SubDir, time.Now().UnixMicro(), fileExt)
+	// 上传文件
+	err = s.bucket.PutObject(objectKey, src)
+	if err != nil {
+		return File{}, err
+	}
+
+	return File{
+		Name:   file.Filename,
+		ObjKey: objectKey,
+		URL:    fmt.Sprintf("%s/%s", s.config.Domain, objectKey),
+		Ext:    fileExt,
+		Size:   file.Size,
+	}, nil
+}
+
+func (s AliYunOss) PutUrlFile(fileURL string, useProxy bool) (string, error) {
+	var fileData []byte
+	var err error
+	if useProxy {
+		fileData, err = utils.DownloadImage(fileURL, s.proxyURL)
+	} else {
+		fileData, err = utils.DownloadImage(fileURL, "")
+	}
+	if err != nil {
+		return "", fmt.Errorf("error with download image: %v", err)
+	}
+	parse, err := url.Parse(fileURL)
+	if err != nil {
+		return "", fmt.Errorf("error with parse image URL: %v", err)
+	}
+	fileExt := utils.GetImgExt(parse.Path)
+	objectKey := fmt.Sprintf("%s/%d%s", s.config.SubDir, time.Now().UnixMicro(), fileExt)
+	// 上传文件字节数据
+	err = s.bucket.PutObject(objectKey, bytes.NewReader(fileData))
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%s/%s", s.config.Domain, objectKey), nil
+}
+
+func (s AliYunOss) PutBase64(base64Img string) (string, error) {
+	imageData, err := base64.StdEncoding.DecodeString(base64Img)
+	if err != nil {
+		return "", fmt.Errorf("error decoding base64:%v", err)
+	}
+	objectKey := fmt.Sprintf("%s/%d.png", s.config.SubDir, time.Now().UnixMicro())
+	// 上传文件字节数据
+	err = s.bucket.PutObject(objectKey, bytes.NewReader(imageData))
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%s/%s", s.config.Domain, objectKey), nil
+}
+
+func (s AliYunOss) Delete(fileURL string) error {
+	var objectKey string
+	if strings.HasPrefix(fileURL, "http") {
+		filename := filepath.Base(fileURL)
+		objectKey = fmt.Sprintf("%s/%s", s.config.SubDir, filename)
+	} else {
+		objectKey = fileURL
+	}
+	return s.bucket.DeleteObject(objectKey)
+}
+
+var _ Uploader = AliYunOss{}

api/service/oss/localstorage.go

@@ -0,0 +1,105 @@
+package oss
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"encoding/base64"
+	"fmt"
+	"geekai/core/types"
+	"geekai/utils"
+	"github.com/gin-gonic/gin"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type LocalStorage struct {
+	config   *types.LocalStorageConfig
+	proxyURL string
+}
+
+func NewLocalStorage(config *types.AppConfig) LocalStorage {
+	return LocalStorage{
+		config:   &config.OSS.Local,
+		proxyURL: config.ProxyURL,
+	}
+}
+
+func (s LocalStorage) PutFile(ctx *gin.Context, name string) (File, error) {
+	file, err := ctx.FormFile(name)
+	if err != nil {
+		return File{}, fmt.Errorf("error with get form: %v", err)
+	}
+
+	path, err := utils.GenUploadPath(s.config.BasePath, file.Filename, false)
+	if err != nil {
+		return File{}, fmt.Errorf("error with generate filename: %s", err.Error())
+	}
+	// 将文件保存到指定路径
+	err = ctx.SaveUploadedFile(file, path)
+	if err != nil {
+		return File{}, fmt.Errorf("error with save upload file: %s", err.Error())
+	}
+
+	ext := filepath.Ext(file.Filename)
+	return File{
+		Name:   file.Filename,
+		ObjKey: path,
+		URL:    utils.GenUploadUrl(s.config.BasePath, s.config.BaseURL, path),
+		Ext:    ext,
+		Size:   file.Size,
+	}, nil
+}
+
+func (s LocalStorage) PutUrlFile(fileURL string, useProxy bool) (string, error) {
+	parse, err := url.Parse(fileURL)
+	if err != nil {
+		return "", fmt.Errorf("error with parse image URL: %v", err)
+	}
+	filename := filepath.Base(parse.Path)
+	filePath, err := utils.GenUploadPath(s.config.BasePath, filename, true)
+	if err != nil {
+		return "", fmt.Errorf("error with generate image dir: %v", err)
+	}
+
+	if useProxy {
+		err = utils.DownloadFile(fileURL, filePath, s.proxyURL)
+	} else {
+		err = utils.DownloadFile(fileURL, filePath, "")
+	}
+	if err != nil {
+		return "", fmt.Errorf("error with download image: %v", err)
+	}
+
+	return utils.GenUploadUrl(s.config.BasePath, s.config.BaseURL, filePath), nil
+}
+
+func (s LocalStorage) PutBase64(base64Img string) (string, error) {
+	imageData, err := base64.StdEncoding.DecodeString(base64Img)
+	if err != nil {
+		return "", fmt.Errorf("error decoding base64:%v", err)
+	}
+	filePath, err := utils.GenUploadPath(s.config.BasePath, "", true)
+	err = os.WriteFile(filePath, imageData, 0644)
+	if err != nil {
+		return "", fmt.Errorf("error writing to file:%v", err)
+	}
+
+	return utils.GenUploadUrl(s.config.BasePath, s.config.BaseURL, filePath), nil
+}
+
+func (s LocalStorage) Delete(fileURL string) error {
+	if _, err := os.Stat(fileURL); err == nil {
+		return os.Remove(fileURL)
+	}
+	filePath := strings.Replace(fileURL, s.config.BaseURL, s.config.BasePath, 1)
+	return os.Remove(filePath)
+}
+
+var _ Uploader = LocalStorage{}

api/service/oss/minio_oss.go

@@ -0,0 +1,137 @@
+package oss
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"context"
+	"encoding/base64"
+	"fmt"
+	"geekai/core/types"
+	"geekai/utils"
+	"net/url"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/minio/minio-go/v7"
+	"github.com/minio/minio-go/v7/pkg/credentials"
+)
+
+type MiniOss struct {
+	config   *types.MiniOssConfig
+	client   *minio.Client
+	proxyURL string
+}
+
+func NewMiniOss(appConfig *types.AppConfig) (MiniOss, error) {
+	config := &appConfig.OSS.Minio
+	minioClient, err := minio.New(config.Endpoint, &minio.Options{
+		Creds:  credentials.NewStaticV4(config.AccessKey, config.AccessSecret, ""),
+		Secure: config.UseSSL,
+	})
+	if err != nil {
+		return MiniOss{}, err
+	}
+	if config.SubDir == "" {
+		config.SubDir = "gpt"
+	}
+	return MiniOss{config: config, client: minioClient, proxyURL: appConfig.ProxyURL}, nil
+}
+
+func (s MiniOss) PutUrlFile(fileURL string, useProxy bool) (string, error) {
+	var fileData []byte
+	var err error
+	if useProxy {
+		fileData, err = utils.DownloadImage(fileURL, s.proxyURL)
+	} else {
+		fileData, err = utils.DownloadImage(fileURL, "")
+	}
+	if err != nil {
+		return "", fmt.Errorf("error with download image: %v", err)
+	}
+	parse, err := url.Parse(fileURL)
+	if err != nil {
+		return "", fmt.Errorf("error with parse image URL: %v", err)
+	}
+	fileExt := filepath.Ext(parse.Path)
+	filename := fmt.Sprintf("%s/%d%s", s.config.SubDir, time.Now().UnixMicro(), fileExt)
+	info, err := s.client.PutObject(
+		context.Background(),
+		s.config.Bucket,
+		filename,
+		strings.NewReader(string(fileData)),
+		int64(len(fileData)),
+		minio.PutObjectOptions{ContentType: "image/png"})
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%s/%s/%s", s.config.Domain, s.config.Bucket, info.Key), nil
+}
+
+func (s MiniOss) PutFile(ctx *gin.Context, name string) (File, error) {
+	file, err := ctx.FormFile(name)
+	if err != nil {
+		return File{}, fmt.Errorf("error with get form: %v", err)
+	}
+	// Open the uploaded file
+	fileReader, err := file.Open()
+	if err != nil {
+		return File{}, fmt.Errorf("error opening file: %v", err)
+	}
+	defer fileReader.Close()
+
+	fileExt := utils.GetImgExt(file.Filename)
+	filename := fmt.Sprintf("%s/%d%s", s.config.SubDir, time.Now().UnixMicro(), fileExt)
+	info, err := s.client.PutObject(ctx, s.config.Bucket, filename, fileReader, file.Size, minio.PutObjectOptions{
+		ContentType: file.Header.Get("Body-Type"),
+	})
+	if err != nil {
+		return File{}, fmt.Errorf("error uploading to MinIO: %v", err)
+	}
+
+	return File{
+		Name:   file.Filename,
+		ObjKey: info.Key,
+		URL:    fmt.Sprintf("%s/%s/%s", s.config.Domain, s.config.Bucket, info.Key),
+		Ext:    fileExt,
+		Size:   file.Size,
+	}, nil
+}
+
+func (s MiniOss) PutBase64(base64Img string) (string, error) {
+	imageData, err := base64.StdEncoding.DecodeString(base64Img)
+	if err != nil {
+		return "", fmt.Errorf("error decoding base64:%v", err)
+	}
+	objectKey := fmt.Sprintf("%s/%d.png", s.config.SubDir, time.Now().UnixMicro())
+	info, err := s.client.PutObject(
+		context.Background(),
+		s.config.Bucket,
+		objectKey,
+		strings.NewReader(string(imageData)),
+		int64(len(imageData)),
+		minio.PutObjectOptions{ContentType: "image/png"})
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%s/%s/%s", s.config.Domain, s.config.Bucket, info.Key), nil
+}
+
+func (s MiniOss) Delete(fileURL string) error {
+	var objectKey string
+	if strings.HasPrefix(fileURL, "http") {
+		filename := filepath.Base(fileURL)
+		objectKey = fmt.Sprintf("%s/%s", s.config.SubDir, filename)
+	} else {
+		objectKey = fileURL
+	}
+	return s.client.RemoveObject(context.Background(), s.config.Bucket, objectKey, minio.RemoveObjectOptions{})
+}
+
+var _ Uploader = MiniOss{}

api/service/oss/qiniu_oss.go

@@ -0,0 +1,151 @@
+package oss
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"bytes"
+	"context"
+	"encoding/base64"
+	"fmt"
+	"geekai/core/types"
+	"geekai/utils"
+	"net/url"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/qiniu/go-sdk/v7/auth/qbox"
+	"github.com/qiniu/go-sdk/v7/storage"
+)
+
+type QinNiuOss struct {
+	config    *types.QiNiuOssConfig
+	mac       *qbox.Mac
+	putPolicy storage.PutPolicy
+	uploader  *storage.FormUploader
+	manager   *storage.BucketManager
+	proxyURL  string
+}
+
+func NewQiNiuOss(appConfig *types.AppConfig) QinNiuOss {
+	config := &appConfig.OSS.QiNiu
+	// build storage uploader
+	zone, ok := storage.GetRegionByID(storage.RegionID(config.Zone))
+	if !ok {
+		zone = storage.ZoneHuanan
+	}
+	storeConfig := storage.Config{Zone: &zone}
+	formUploader := storage.NewFormUploader(&storeConfig)
+	// generate token
+	mac := qbox.NewMac(config.AccessKey, config.AccessSecret)
+	putPolicy := storage.PutPolicy{
+		Scope: config.Bucket,
+	}
+	if config.SubDir == "" {
+		config.SubDir = "gpt"
+	}
+	return QinNiuOss{
+		config:    config,
+		mac:       mac,
+		putPolicy: putPolicy,
+		uploader:  formUploader,
+		manager:   storage.NewBucketManager(mac, &storeConfig),
+		proxyURL:  appConfig.ProxyURL,
+	}
+}
+
+func (s QinNiuOss) PutFile(ctx *gin.Context, name string) (File, error) {
+	// 解析表单
+	file, err := ctx.FormFile(name)
+	if err != nil {
+		return File{}, err
+	}
+	// 打开上传文件
+	src, err := file.Open()
+	if err != nil {
+		return File{}, err
+	}
+	defer src.Close()
+
+	fileExt := filepath.Ext(file.Filename)
+	key := fmt.Sprintf("%s/%d%s", s.config.SubDir, time.Now().UnixMicro(), fileExt)
+	// 上传文件
+	ret := storage.PutRet{}
+	extra := storage.PutExtra{}
+	err = s.uploader.Put(ctx, &ret, s.putPolicy.UploadToken(s.mac), key, src, file.Size, &extra)
+	if err != nil {
+		return File{}, err
+	}
+
+	return File{
+		Name:   file.Filename,
+		ObjKey: key,
+		URL:    fmt.Sprintf("%s/%s", s.config.Domain, ret.Key),
+		Ext:    fileExt,
+		Size:   file.Size,
+	}, nil
+
+}
+
+func (s QinNiuOss) PutUrlFile(fileURL string, useProxy bool) (string, error) {
+	var fileData []byte
+	var err error
+	if useProxy {
+		fileData, err = utils.DownloadImage(fileURL, s.proxyURL)
+	} else {
+		fileData, err = utils.DownloadImage(fileURL, "")
+	}
+	if err != nil {
+		return "", fmt.Errorf("error with download image: %v", err)
+	}
+	parse, err := url.Parse(fileURL)
+	if err != nil {
+		return "", fmt.Errorf("error with parse image URL: %v", err)
+	}
+	fileExt := utils.GetImgExt(parse.Path)
+	key := fmt.Sprintf("%s/%d%s", s.config.SubDir, time.Now().UnixMicro(), fileExt)
+	ret := storage.PutRet{}
+	extra := storage.PutExtra{}
+	// 上传文件字节数据
+	err = s.uploader.Put(context.Background(), &ret, s.putPolicy.UploadToken(s.mac), key, bytes.NewReader(fileData), int64(len(fileData)), &extra)
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%s/%s", s.config.Domain, ret.Key), nil
+}
+
+func (s QinNiuOss) PutBase64(base64Img string) (string, error) {
+	imageData, err := base64.StdEncoding.DecodeString(base64Img)
+	if err != nil {
+		return "", fmt.Errorf("error decoding base64:%v", err)
+	}
+	objectKey := fmt.Sprintf("%s/%d.png", s.config.SubDir, time.Now().UnixMicro())
+	ret := storage.PutRet{}
+	extra := storage.PutExtra{}
+	// 上传文件字节数据
+	err = s.uploader.Put(context.Background(), &ret, s.putPolicy.UploadToken(s.mac), objectKey, bytes.NewReader(imageData), int64(len(imageData)), &extra)
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%s/%s", s.config.Domain, ret.Key), nil
+}
+
+func (s QinNiuOss) Delete(fileURL string) error {
+	var objectKey string
+	if strings.HasPrefix(fileURL, "http") {
+		filename := filepath.Base(fileURL)
+		objectKey = fmt.Sprintf("%s/%s", s.config.SubDir, filename)
+	} else {
+		objectKey = fileURL
+	}
+
+	return s.manager.Delete(s.config.Bucket, objectKey)
+}
+
+var _ Uploader = QinNiuOss{}

api/service/oss/uploader.go

@@ -0,0 +1,29 @@
+package oss
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import "github.com/gin-gonic/gin"
+
+const Local = "LOCAL"
+const Minio = "MINIO"
+const QiNiu = "QINIU"
+const AliYun = "ALIYUN"
+
+type File struct {
+	Name   string `json:"name"`
+	ObjKey string `json:"obj_key"`
+	Size   int64  `json:"size"`
+	URL    string `json:"url"`
+	Ext    string `json:"ext"`
+}
+type Uploader interface {
+	PutFile(ctx *gin.Context, name string) (File, error)
+	PutUrlFile(url string, useProxy bool) (string, error)
+	PutBase64(imageData string) (string, error)
+	Delete(fileURL string) error
+}

api/service/oss/uploader_manager.go

@@ -0,0 +1,53 @@
+package oss
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"geekai/core/types"
+	"strings"
+)
+
+type UploaderManager struct {
+	handler Uploader
+}
+
+func NewUploaderManager(config *types.AppConfig) (*UploaderManager, error) {
+	active := Local
+	if config.OSS.Active != "" {
+		active = strings.ToUpper(config.OSS.Active)
+	}
+	var handler Uploader
+	switch active {
+	case Local:
+		handler = NewLocalStorage(config)
+		break
+	case Minio:
+		client, err := NewMiniOss(config)
+		if err != nil {
+			return nil, err
+		}
+		handler = client
+		break
+	case QiNiu:
+		handler = NewQiNiuOss(config)
+		break
+	case AliYun:
+		client, err := NewAliYunOss(config)
+		if err != nil {
+			return nil, err
+		}
+		handler = client
+		break
+	}
+
+	return &UploaderManager{handler: handler}, nil
+}
+
+func (m *UploaderManager) GetUploadHandler() Uploader {
+	return m.handler
+}

api/service/payment/alipay_service.go

@@ -0,0 +1,140 @@
+package payment
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"context"
+	"fmt"
+	"geekai/core/types"
+	logger2 "geekai/logger"
+	"github.com/go-pay/gopay"
+	"github.com/go-pay/gopay/alipay"
+	"net/http"
+	"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)
+	}
+
+	client, err := alipay.NewClient(config.AppId, priKey, !config.SandBox)
+	if err != nil {
+		return nil, fmt.Errorf("error with initialize alipay service: %v", err)
+	}
+
+	//client.DebugSwitch = gopay.DebugOn // 开启调试模式
+	client.SetLocation(alipay.LocationShanghai). // 设置时区，不设置或出错均为默认服务器时间
+							SetCharset(alipay.UTF8). // 设置字符编码，不设置默认 utf-8
+							SetSignType(alipay.RSA2) // 设置签名类型，不设置默认 RSA2
+
+	if err = client.SetCertSnByPath(config.PublicKey, config.RootCert, config.AlipayPublicKey); err != nil {
+		return nil, fmt.Errorf("error with load payment public key: %v", err)
+	}
+
+	return &AlipayService{config: &config, client: client}, nil
+}
+
+type AlipayParams struct {
+	OutTradeNo string `json:"out_trade_no"`
+	Subject    string `json:"subject"`
+	TotalFee   string `json:"total_fee"`
+	ReturnURL  string `json:"return_url"`
+	NotifyURL  string `json:"notify_url"`
+}
+
+func (s *AlipayService) PayMobile(params AlipayParams) (string, error) {
+	bm := make(gopay.BodyMap)
+	bm.Set("subject", params.Subject)
+	bm.Set("out_trade_no", params.OutTradeNo)
+	bm.Set("quit_url", params.ReturnURL)
+	bm.Set("total_amount", params.TotalFee)
+	bm.Set("product_code", "QUICK_WAP_WAY")
+	return s.client.SetNotifyUrl(params.NotifyURL).SetReturnUrl(params.ReturnURL).TradeWapPay(context.Background(), bm)
+}
+
+func (s *AlipayService) PayPC(params AlipayParams) (string, error) {
+	bm := make(gopay.BodyMap)
+	bm.Set("subject", params.Subject)
+	bm.Set("out_trade_no", params.OutTradeNo)
+	bm.Set("total_amount", params.TotalFee)
+	bm.Set("product_code", "FAST_INSTANT_TRADE_PAY")
+	return s.client.SetNotifyUrl(params.NotifyURL).SetReturnUrl(params.ReturnURL).TradePagePay(context.Background(), bm)
+}
+
+// TradeVerify 交易验证
+func (s *AlipayService) TradeVerify(request *http.Request) NotifyVo {
+	notifyReq, err := alipay.ParseNotifyToBodyMap(request) // c.Request 是 gin 框架的写法
+	if err != nil {
+		return NotifyVo{
+			Status:  Failure,
+			Message: "error with parse notify request: " + err.Error(),
+		}
+	}
+
+	_, err = alipay.VerifySignWithCert(s.config.AlipayPublicKey, notifyReq)
+	if err != nil {
+		return NotifyVo{
+			Status:  Failure,
+			Message: "error with verify sign: " + err.Error(),
+		}
+	}
+
+	return s.TradeQuery(request.Form.Get("out_trade_no"))
+}
+
+func (s *AlipayService) TradeQuery(outTradeNo string) NotifyVo {
+	bm := make(gopay.BodyMap)
+	bm.Set("out_trade_no", outTradeNo)
+
+	//查询订单
+	rsp, err := s.client.TradeQuery(context.Background(), bm)
+	if err != nil {
+		return NotifyVo{
+			Status:  Failure,
+			Message: "异步查询验证订单信息发生错误" + outTradeNo + err.Error(),
+		}
+	}
+
+	if rsp.Response.TradeStatus == "TRADE_SUCCESS" {
+		return NotifyVo{
+			Status:     Success,
+			OutTradeNo: rsp.Response.OutTradeNo,
+			TradeId:    rsp.Response.TradeNo,
+			Amount:     rsp.Response.TotalAmount,
+			Subject:    rsp.Response.Subject,
+			Message:    "OK",
+		}
+	} else {
+		return NotifyVo{
+			Status:  Failure,
+			Message: "异步查询验证订单信息发生错误" + outTradeNo,
+		}
+	}
+}
+
+func readKey(filename string) (string, error) {
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}

api/service/payment/geekpay_service.go

@@ -0,0 +1,139 @@
+package payment
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * Copyright 2023 The Geek-AI Authors. All rights reserved.
+// * Use of this source code is governed by a Apache-2.0 license
+// * that can be found in the LICENSE file.
+// * @Author yangjian102621@163.com
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+import (
+	"crypto/tls"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"geekai/core/types"
+	"geekai/utils"
+	"io"
+	"net/http"
+	"net/url"
+	"sort"
+	"strings"
+	"time"
+)
+
+// GeekPayService Geek 支付服务
+type GeekPayService struct {
+	config *types.GeekPayConfig
+}
+
+func NewJPayService(appConfig *types.AppConfig) *GeekPayService {
+	return &GeekPayService{
+		config: &appConfig.GeekPayConfig,
+	}
+}
+
+type GeekPayParams struct {
+	Method     string `json:"method"`       // 接口类型
+	Device     string `json:"device"`       // 设备类型
+	Type       string `json:"type"`         // 支付方式
+	OutTradeNo string `json:"out_trade_no"` // 商户订单号
+	Name       string `json:"name"`         // 商品名称
+	Money      string `json:"money"`        // 商品金额
+	ClientIP   string `json:"clientip"`     //用户IP地址
+	SubOpenId  string `json:"sub_openid"`   // 微信用户 openid，仅小程序支付需要
+	SubAppId   string `json:"sub_appid"`    // 小程序 AppId，仅小程序支付需要
+	NotifyURL  string `json:"notify_url"`
+	ReturnURL  string `json:"return_url"`
+}
+
+// Pay 支付订单
+func (s *GeekPayService) Pay(params GeekPayParams) (*GeekPayResp, error) {
+	p := map[string]string{
+		"pid": s.config.AppId,
+		//"method":       params.Method,
+		"device":       params.Device,
+		"type":         params.Type,
+		"out_trade_no": params.OutTradeNo,
+		"name":         params.Name,
+		"money":        params.Money,
+		"clientip":     params.ClientIP,
+		"notify_url":   params.NotifyURL,
+		"return_url":   params.ReturnURL,
+		"timestamp":    fmt.Sprintf("%d", time.Now().Unix()),
+	}
+	p["sign"] = s.Sign(p)
+	p["sign_type"] = "MD5"
+	return s.sendRequest(s.config.ApiURL, p)
+}
+
+func (s *GeekPayService) Sign(params map[string]string) string {
+	// 按字母顺序排序参数
+	var keys []string
+	for k := range params {
+		if params[k] == "" || k == "sign" || k == "sign_type" {
+			continue
+		}
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+
+	// 构建待签名字符串
+	var signStr strings.Builder
+	for _, k := range keys {
+		signStr.WriteString(k)
+		signStr.WriteString("=")
+		signStr.WriteString(params[k])
+		signStr.WriteString("&")
+	}
+	signString := strings.TrimSuffix(signStr.String(), "&") + s.config.PrivateKey
+
+	return utils.Md5(signString)
+}
+
+type GeekPayResp struct {
+	Code      int    `json:"code"`
+	Msg       string `json:"msg"`
+	TradeNo   string `json:"trade_no"`
+	PayURL    string `json:"payurl"`
+	QrCode    string `json:"qrcode"`
+	UrlScheme string `json:"urlscheme"` // 小程序跳转支付链接
+}
+
+func (s *GeekPayService) sendRequest(endpoint string, params map[string]string) (*GeekPayResp, error) {
+	form := url.Values{}
+	for k, v := range params {
+		form.Add(k, v)
+	}
+
+	apiURL := fmt.Sprintf("%s/mapi.php", endpoint)
+	logger.Infof(apiURL)
+
+	tr := &http.Transport{
+		TLSClientConfig: &tls.Config{
+			InsecureSkipVerify: true, // 取消 SSL 证书验证
+		},
+	}
+	client := &http.Client{Transport: tr}
+	resp, err := client.PostForm(apiURL, form)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	logger.Debugf(string(body))
+	if err != nil {
+		return nil, err
+	}
+
+	var r GeekPayResp
+	err = json.Unmarshal(body, &r)
+	if err != nil {
+		return nil, errors.New("当前支付渠道暂不支持")
+	}
+	if r.Code != 1 {
+		return nil, errors.New(r.Msg)
+	}
+	return &r, nil
+}