release: v4.2.8

整合开源版 v4.2.8 功能：Sora2 视频、路由重构、手机站开关、DALL-E 参考图，以及启动时自动同步数据表字段等修复与优化。

Co-authored-by: Cursor <cursoragent@cursor.com>

.claude/commands/frontend-developer.md

@@ -0,0 +1,37 @@
+---
+name: frontend-developer
+description: Use this agent when you need assistance with frontend development tasks including Vue.js components, UI implementation, styling, responsive design, state management, or frontend architecture decisions. Examples: <example>Context: User is working on a Vue.js component and needs help with implementing a responsive layout. user: 'I need to create a mobile-friendly chat interface component' assistant: 'I'll use the frontend-developer agent to help design and implement this responsive chat component' <commentary>Since this involves frontend development work with Vue.js and responsive design, use the frontend-developer agent.</commentary></example> <example>Context: User encounters styling issues with Element Plus components. user: 'The Element Plus dialog is not displaying correctly on mobile devices' assistant: 'Let me use the frontend-developer agent to troubleshoot this mobile styling issue' <commentary>This is a frontend styling problem that requires expertise in Element Plus and responsive design.</commentary></example>
+color: purple
+---
+
+You are a Senior Frontend Development Engineer with deep expertise in modern web development technologies, particularly Vue.js 3, Element Plus, Vant, and responsive design patterns. You specialize in creating high-quality, maintainable frontend applications with excellent user experience.
+
+Your core responsibilities include:
+- Developing Vue.js 3 components using Composition API and best practices
+- Implementing responsive designs that work seamlessly across desktop and mobile devices
+- Working with Element Plus for desktop UI and Vant for mobile components
+- Managing application state using Pinia store patterns
+- Styling with Stylus preprocessor and Tailwind CSS utilities
+- Optimizing build processes with Vite and ensuring proper code organization
+- Implementing theme switching (dark/light mode) and accessibility features
+- Follow decoupled development, with HTML, CSS, and JS codes placed in separate files for easier maintenance
+
+When working on frontend tasks, you will:
+1. Analyze requirements and suggest the most appropriate Vue.js patterns and component structures
+2. Ensure responsive design principles are followed, considering both desktop and mobile viewports
+3. Choose appropriate UI components from Element Plus (desktop) or Vant (mobile) libraries
+4. Write clean, maintainable code following Vue.js 3 Composition API best practices
+5. Consider performance implications and suggest optimizations when relevant
+6. Ensure proper state management using Pinia when component state needs to be shared
+7. Follow the project's established patterns for routing, API integration, and component organization
+8. Provide specific code examples and explain the reasoning behind architectural decisions
+
+You have deep knowledge of:
+- Vue.js 3 ecosystem (Vue Router, Pinia, Composition API)
+- Modern CSS techniques and preprocessors (Stylus, Tailwind)
+- Component library integration (Element Plus, Vant)
+- Build tools and development workflow (Vite, npm scripts)
+- Cross-browser compatibility and mobile-first design principles
+- Performance optimization and code splitting strategies
+
+Always consider the user experience, code maintainability, and alignment with modern frontend development standards. When suggesting solutions, provide clear explanations and consider both immediate needs and long-term scalability.

.claude/commands/refactor.md

@@ -0,0 +1,6 @@
+重构当前页面代码
+
+1. 把当前页面 JS 代码全部抽离，然后是采用 Pinia 重构
+2. 把当前页面 CSS 代码全部抽离，如果是 stylus 语法代码，则需要改成 SCSS 语法代码
+3. 尽量做到代码的复用性，不要重复造轮子
+4. 移动端的 css 和 js 分别放到对应的 mobile 目录下，不要覆盖 PC 端的代码

.gitattributes

@@ -0,0 +1,5 @@
+web/src/assets/fonts filter=lfs diff=lfs merge=lfs -text
+web/src/assets/iconfont filter=lfs diff=lfs merge=lfs -text
+web/src/assets/img filter=lfs diff=lfs merge=lfs -text
+web/public filter=lfs diff=lfs merge=lfs -text
+api/res filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -14,3 +14,4 @@ logs
 *.njsproj
 *.sln
 *.sw?
+miniprogram

CHANGELOG.md

@@ -1,5 +1,40 @@
 # 更新日志
 
+## v4.2.8
+
+- Bug 修复：修复管理后台邮件配置报“参数错误”问题
+- 功能优化：手机端也不显示后端禁用的菜单功能页面
+- 功能优化：**聊天页面支持 Sora2 文生视频/图生视频功能** 🔥🔥🔥
+- 功能优化：**重构路由代码，优化路由加载逻辑，支持关闭手机站功能** 🔥🔥🔥
+- Bug 修复：修复用户算力扣减日志记录逻辑错误问题
+- 功能优化：优化 404 页面样式，兼容 PC 端和移动端
+- Bug 修复：ipv6 地址登录报错：Data too long for column 'last_login_ip'
+- Bug 修复：移动端登录页面输入密码的时候会覆盖在确认按钮上层
+- 功能优化：**移动端的 DALL-E 绘图页面支持上传参考图** 🔥🔥🔥
+- 功能优化：优化 WebFooter 组件，如果配置了备案号，则显示备案号，否则不显示
+- 功能优化：启动时自动同步 model 与数据表字段，缺列自动新建、多余列自动删除
+
+## v4.2.7
+
+- Bug 修复：修复超级管理员无法修改密码的 Bug
+- Bug 修复：微信登录配置更新后，没有同步更新到系统配置
+- 功能优化： 给 AI 对话 API 加上线程锁，确保同一个用户同时只有一个对话请求
+- 功能新增：支持即梦 AI 4.0 图片编辑，即梦 AI 数字人，动作迁移功能。🔥🔥🔥
+- 功能新增：新增 AI 对话编辑功能，并优化了重新生成逻辑
+
+## v4.2.6
+
+- 功能重构：优化系统配置管理功能，把 OSS，支付，短信，邮件等配置全部迁移到管理后台，无需通过修改配置文档的方式修改 🎉🎉🎉
+- 功能优化：重构 API 授权代码，采用中间件鉴权方式，实现更加精准的 API 鉴权 🎉🎉🎉
+- 功能优化：优化 PC 端的 Suno 音乐，视频生成，以及即梦 AI 页面 UI
+- 功能优化：重构登录和注册页面，兼容移动端和 PC 端，并且所有的登录组件共用了同一套组件代码，大大降低维护成本 🎉🎉🎉
+- 功能优化：管理后台增加模型批量删除功能
+- 功能优化：优化 Table 组件 UI，并支持 dark 主题
+- 功能优化：移动端对话页面支持上传文件和图片
+- 功能新增：新增微信扫码登录支持
+- 功能新增：新增安全监控，内容审核功能，支持敏感内容过滤拦截
+- 功能新增：DALL-E 绘图支持参 Google Banana 图片编辑功能
+
 ## v4.2.5
 
 - 功能优化：在代码右下角增加复制代码功能按钮，增加收起和展开代码功能

JIMENG_CONFIG_README.md

@@ -1,195 +0,0 @@
-# 即梦 AI 配置功能说明
-
-## 功能概述
-
-即梦 AI 配置功能允许管理员通过 Web 界面配置即梦 AI 的 API 密钥和算力消耗设置，支持动态配置更新，无需重启服务。
-
-## 功能特性
-
-### 1. 秘钥配置
-
-- AccessKey 和 SecretKey 配置
-- 支持密码显示/隐藏
-- 连接测试功能
-
-### 2. 算力配置
-
-- 文生图算力消耗
-- 图生图算力消耗
-- 图片编辑算力消耗
-- 图片特效算力消耗
-- 文生视频算力消耗
-- 图生视频算力消耗
-
-### 3. 动态配置
-
-- 配置实时生效
-- 无需重启服务
-- 支持配置验证
-
-## API 接口
-
-### 获取配置
-
-```
-GET /api/admin/jimeng/config
-```
-
-### 更新配置
-
-```
-POST /api/admin/jimeng/config
-Content-Type: application/json
-
-{
-  "config": {
-    "access_key": "your_access_key",
-    "secret_key": "your_secret_key",
-    "power": {
-      "text_to_image": 10,
-      "image_to_image": 15,
-      "image_edit": 20,
-      "image_effects": 25,
-      "text_to_video": 30,
-      "image_to_video": 35
-    }
-  }
-}
-```
-
-### 测试连接
-
-```
-POST /api/admin/jimeng/config/test
-Content-Type: application/json
-
-{
-  "config": {
-    "access_key": "your_access_key",
-    "secret_key": "your_secret_key"
-  }
-}
-```
-
-## 前端页面
-
-### 访问路径
-
-管理后台 -> 即梦 AI -> 配置设置
-
-### 页面功能
-
-1. **秘钥配置标签页**
-
-   - AccessKey 输入框（密码模式）
-   - SecretKey 输入框（密码模式）
-   - 测试连接按钮
-
-2. **算力配置标签页**
-
-   - 各种任务类型的算力消耗配置
-   - 数字输入框，支持 1-100 范围
-   - 提示信息说明
-
-3. **操作按钮**
-   - 保存配置
-   - 重置配置
-
-## 配置存储
-
-配置存储在数据库的`config`表中：
-
-- 配置键：`jimeng`
-- 配置值：JSON 格式的即梦 AI 配置
-
-## 默认配置
-
-如果配置不存在，系统会使用以下默认值：
-
-```json
-{
-  "access_key": "",
-  "secret_key": "",
-  "power": {
-    "text_to_image": 10,
-    "image_to_image": 15,
-    "image_edit": 20,
-    "image_effects": 25,
-    "text_to_video": 30,
-    "image_to_video": 35
-  }
-}
-```
-
-## 使用流程
-
-1. **初始配置**
-
-   - 访问管理后台即梦 AI 配置页面
-   - 填写 AccessKey 和 SecretKey
-   - 点击"测试连接"验证配置
-   - 调整各功能算力消耗
-   - 保存配置
-
-2. **配置更新**
-
-   - 修改需要更新的配置项
-   - 保存配置
-   - 配置立即生效
-
-3. **故障排查**
-   - 使用"测试连接"功能验证 API 密钥
-   - 检查配置是否正确保存
-   - 查看服务日志
-
-## 注意事项
-
-1. **权限要求**
-
-   - 只有管理员可以访问配置页面
-   - 需要有效的管理员登录会话
-
-2. **配置验证**
-
-   - AccessKey 和 SecretKey 不能为空
-   - 算力消耗必须大于 0
-   - 建议先测试连接再保存配置
-
-3. **服务影响**
-   - 配置更新不会影响正在进行的任务
-   - 新任务会使用更新后的配置
-   - 客户端配置会在下次请求时更新
-
-## 错误处理
-
-1. **配置加载失败**
-
-   - 使用默认配置
-   - 记录错误日志
-
-2. **连接测试失败**
-
-   - 显示具体错误信息
-   - 建议检查 API 密钥
-
-3. **配置保存失败**
-   - 显示错误信息
-   - 保留原有配置
-
-## 开发说明
-
-### 后端文件
-
-- `api/handler/admin/jimeng_handler.go` - 配置管理 API
-- `api/service/jimeng/service.go` - 配置服务逻辑
-- `api/core/types/jimeng.go` - 配置类型定义
-
-### 前端文件
-
-- `web/src/views/admin/jimeng/JimengSetting.vue` - 配置页面
-
-### 数据库
-
-- `config`表存储配置信息
-- 配置键：`jimeng`
-- 配置值：JSON 格式

README.md

@@ -1,13 +1,67 @@
-# GeekAI-PLUS
+# 🚀 GeekAI-PLUS：一站式 AI 创意生产力平台
+
+**重新定义 AI 创作体验，让每个人都能成为内容创作大师**
+
 基于 GeekAI 项目开发的高级版，增加了很多高级功能，比如思维导图，Dalle 绘画等。**高级版源码不会一次性开放，只提供镜像给大家免费使用**，源码会逐步逐步按照版同步迁移到[社区版（GeekAI）](https://github.com/yangjian102621/geekai)。所以如果大家想要二次开发，请移步去社区版。
 
+## ✨ 核心特色
+
+### 🎨 **全能 AI 创作矩阵**
+
+- **智能对话**：集成 ChatGPT、Claude 等多款顶级 AI 模型，支持角色扮演和专业对话
+- **图像生成**：整合 MidJourney、DALL-E、Stable Diffusion 三大主流 AI 绘画引擎
+- **音频创作**：Suno AI 音乐生成，从旋律到歌词一键创作专属音乐
+- **视频制作**：Luma 和 KeLing，即梦，Veo3 视频 AI，文本到视频，创意无限
+- **思维导图**：AI 辅助思维整理，复杂想法可视化呈现
+
+### 🏗️ **企业级技术架构**
+
+- **高性能后端**：Go + Gin + MySQL + Redis，支持高并发访问
+- **现代化前端**：Vue3 + Element Plus + Vant，桌面移动双端适配
+- **智能缓存**：多层缓存策略，响应速度提升 80%
+- **弹性部署**：Docker 容器化部署，一键启动，轻松扩展
+- **私有化部署**：支持私有化部署，私有化部署不支持升级，需要手动升级
+- **文档支持**：丰富且详细的部署和 API 开发文档支持，二次开发轻松上手
+
+### 💼 **商业化就绪**
+
+- **完整用户系统**：注册登录、权限管理、积分充值
+- **灵活计费模式**：支持按次付费、包月订阅等多种商业模式
+- **数据统计分析**：用户行为、消费记录、系统性能全方位监控
+- **管理后台**：功能完备的管理员界面，运营数据一目了然
+
+### 🎯 **用户体验优势**
+
+- **响应式设计**：完美适配桌面、平板、手机等全终端设备
+- **暗黑模式**：支持明暗主题切换，护眼舒适
+- **实时交互**：WebSocket 实时通信，创作过程流畅无卡顿
+- **文件管理**：支持多种云存储，作品安全可靠
+
+## 🎪 **应用场景**
+
+- **内容创作者**：博客写作、社交媒体素材、短视频制作
+- **企业营销**：品牌宣传材料、产品介绍、创意广告
+- **教育培训**：课件制作、知识图谱、互动内容
+- **个人娱乐**：AI 聊天、创意绘画、音乐创作
+
+## 🔥 **为什么选择 GeekAI-PLUS？**
+
+1. **技术领先**：集成当前最先进的 AI 技术，始终保持创新前沿
+2. **开箱即用**：完整的商业化解决方案，无需从零开发
+3. **高度定制**：模块化架构设计，支持个性化功能扩展
+4. **稳定可靠**：经过大量用户验证，性能稳定，安全可信
+5. **持续更新**：紧跟 AI 技术发展，功能持续迭代升级
+
 ## 演示站点
+
 [Geek-AI 创作系统](https://www.geekai.me)
 
 ## 文档地址
+
 [Geek-AI 文档](https://www.geekai.me/docs/)
 
 ## 部署
+
 1. 安装 docker 和 docker-compose 程序，这个自行解决。
 2. 直接在项目根目录运行启动命令:
    ```shell
@@ -15,5 +69,9 @@
    ```
 
 ## 功能截图
+
 请参考 [GeekAI 项目介绍](https://docs.geekai.me/info/)。
 
+---
+
+_让 AI 成为你最强大的创作伙伴，开启无限创意可能！_

api/.gitignore

@@ -16,6 +16,7 @@ tmp
 bin
 data
 config.toml
+config.toml.*.bak
 static/upload 
 static/audio
 storage.json 

api/config.sample.toml

@@ -1,6 +1,6 @@
 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"
+MysqlDns = "root:12345678@tcp(localhost:3306)/geekai?charset=utf8mb4&collation=utf8mb4_unicode_ci&parseTime=True&loc=Local"
 StaticDir = "./static" # 静态资源的目录
 StaticUrl = "/static" # 静态资源访问 URL
 TikaHost = "http://tika:9998"

api/core/app_server.go

@@ -8,117 +8,50 @@ package core
 // * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 import (
-	"bytes"
-	"context"
 	"fmt"
+	"geekai/core/middleware"
 	"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"
 )
 
-// AuthConfig 定义授权配置
-type AuthConfig struct {
-	ExactPaths  map[string]bool // 精确匹配的路径
-	PrefixPaths map[string]bool // 前缀匹配的路径
-}
-
-var authConfig = &AuthConfig{
-	ExactPaths: map[string]bool{
-		"/api/user/login":          false,
-		"/api/user/logout":         false,
-		"/api/user/resetPass":      false,
-		"/api/user/register":       false,
-		"/api/admin/login":         false,
-		"/api/admin/logout":        false,
-		"/api/admin/login/captcha": false,
-		"/api/app/list":            false,
-		"/api/app/type/list":       false,
-		"/api/app/list/user":       false,
-		"/api/model/list":          false,
-		"/api/mj/imgWall":          false,
-		"/api/mj/notify":           false,
-		"/api/invite/hits":         false,
-		"/api/sd/imgWall":          false,
-		"/api/dall/imgWall":        false,
-		"/api/product/list":        false,
-		"/api/menu/list":           false,
-		"/api/markMap/client":      false,
-		"/api/payment/doPay":       false,
-		"/api/payment/payWays":     false,
-		"/api/download":            false,
-		"/api/dall/models":         false,
-	},
-	PrefixPaths: map[string]bool{
-		"/api/test/":           false,
-		"/api/payment/notify/": false,
-		"/api/user/clogin":     false,
-		"/api/config/":         false,
-		"/api/function/":       false,
-		"/api/sms/":            false,
-		"/api/captcha/":        false,
-		"/static/":             false,
-	},
-}
-
 type AppServer struct {
 	Config    *types.AppConfig
 	Engine    *gin.Engine
 	SysConfig *types.SystemConfig // system config cache
+	Redis     *redis.Client
 }
 
-func NewServer(appConfig *types.AppConfig) *AppServer {
+func NewServer(appConfig *types.AppConfig, redis *redis.Client, sysConfig *types.SystemConfig) *AppServer {
 	gin.SetMode(gin.ReleaseMode)
 	gin.DefaultWriter = io.Discard
 	return &AppServer{
-		Config: appConfig,
-		Engine: gin.Default(),
+		Config:    appConfig,
+		Redis:     redis,
+		Engine:    gin.Default(),
+		SysConfig: sysConfig,
 	}
 }
 
-func (s *AppServer) Init(debug bool, client *redis.Client) {
-	s.Engine.Use(corsMiddleware())
-	s.Engine.Use(staticResourceMiddleware())
-	s.Engine.Use(authorizeMiddleware(s, client))
-	s.Engine.Use(parameterHandlerMiddleware())
+func (s *AppServer) Init(client *redis.Client) {
+	s.Engine.Use(middleware.ThumbMiddleware())
+	s.Engine.Use(middleware.ParameterHandlerMiddleware())
 	s.Engine.Use(errorHandler)
 	// 添加静态资源访问
 	s.Engine.Static("/static", s.Config.StaticDir)
 }
 
 func (s *AppServer) Run(db *gorm.DB) error {
-
-	// 重命名 config 表字段
-	if db.Migrator().HasColumn(&model.Config{}, "config_json") {
-		db.Migrator().RenameColumn(&model.Config{}, "config_json", "value")
-	}
-	if db.Migrator().HasColumn(&model.Config{}, "marker") {
-		db.Migrator().RenameColumn(&model.Config{}, "marker", "name")
-	}
-	if db.Migrator().HasIndex(&model.Config{}, "idx_chatgpt_configs_key") {
-		db.Migrator().DropIndex(&model.Config{}, "idx_chatgpt_configs_key")
-	}
-	if db.Migrator().HasIndex(&model.Config{}, "marker") {
-		db.Migrator().DropIndex(&model.Config{}, "marker")
-	}
-
 	// load system configs
 	var sysConfig model.Config
 	err := db.Where("name", "system").First(&sysConfig).Error
@@ -130,70 +63,17 @@ func (s *AppServer) Run(db *gorm.DB) error {
 		return fmt.Errorf("failed to decode system config: %v", err)
 	}
 
-	// 迁移数据表
-	logger.Info("Migrating database tables...")
-	db.AutoMigrate(
-		&model.ChatItem{},
-		&model.ChatMessage{},
-		&model.ChatRole{},
-		&model.ChatModel{},
-		&model.InviteCode{},
-		&model.InviteLog{},
-		&model.Menu{},
-		&model.Order{},
-		&model.Product{},
-		&model.User{},
-		&model.Function{},
-		&model.File{},
-		&model.Redeem{},
-		&model.Config{},
-		&model.ApiKey{},
-		&model.AdminUser{},
-		&model.AppType{},
-		&model.SdJob{},
-		&model.SunoJob{},
-		&model.PowerLog{},
-		&model.VideoJob{},
-		&model.MidJourneyJob{},
-		&model.UserLoginLog{},
-		&model.DallJob{},
-		&model.JimengJob{},
-	)
-	// 手动删除字段
-	if db.Migrator().HasColumn(&model.Order{}, "deleted_at") {
-		db.Migrator().DropColumn(&model.Order{}, "deleted_at")
-	}
-	if db.Migrator().HasColumn(&model.ChatItem{}, "deleted_at") {
-		db.Migrator().DropColumn(&model.ChatItem{}, "deleted_at")
-	}
-	if db.Migrator().HasColumn(&model.ChatMessage{}, "deleted_at") {
-		db.Migrator().DropColumn(&model.ChatMessage{}, "deleted_at")
-	}
-	if db.Migrator().HasColumn(&model.User{}, "chat_config") {
-		db.Migrator().DropColumn(&model.User{}, "chat_config")
-	}
-	if db.Migrator().HasColumn(&model.ChatModel{}, "category") {
-		db.Migrator().DropColumn(&model.ChatModel{}, "category")
-	}
-	if db.Migrator().HasColumn(&model.ChatModel{}, "description") {
-		db.Migrator().DropColumn(&model.ChatModel{}, "description")
-	}
-
-	logger.Info("Database tables migrated successfully")
-
 	// 统计安装信息
 	go func() {
 		info, err := host.Info()
 		if err == nil {
-			apiURL := fmt.Sprintf("%s/%s", s.Config.ApiConfig.ApiURL, "api/installs/push")
+			apiURL := fmt.Sprintf("%s/api/installs/push", types.GeekAPIURL)
 			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 {
+			if err == nil {
 				logger.Debugf("register install info success: %v", resp.String())
 			}
 		}
@@ -215,283 +95,3 @@ func errorHandler(c *gin.Context) {
 	//加载完 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)
-		} else {
-			c.Header("Access-Control-Allow-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) {
-		if !needLogin(c) {
-			c.Next()
-			return
-		}
-
-		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 == "" {
-			resp.NotAuth(c, "You should put Authorization in request headers")
-			c.Abort()
-			return
-		}
-
-		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"])
-			}
-			if isAdminApi {
-				return []byte(s.Config.AdminSession.SecretKey), nil
-			} else {
-				return []byte(s.Config.Session.SecretKey), nil
-			}
-
-		})
-
-		if err != nil {
-			resp.NotAuth(c, fmt.Sprintf("Error with parse auth token: %v", err))
-			c.Abort()
-			return
-		}
-
-		claims, ok := token.Claims.(jwt.MapClaims)
-		if !ok || !token.Valid {
-			resp.NotAuth(c, "Token is invalid")
-			c.Abort()
-			return
-		}
-
-		expr := utils.IntValue(utils.InterfaceToString(claims["expired"]), 0)
-		if expr > 0 && int64(expr) < time.Now().Unix() {
-			resp.NotAuth(c, "Token is expired")
-			c.Abort()
-			return
-		}
-
-		key := fmt.Sprintf("users/%v", claims["user_id"])
-		if isAdminApi {
-			key = fmt.Sprintf("admin/%v", claims["user_id"])
-		}
-		if _, err := client.Get(context.Background(), key).Result(); err != nil {
-			resp.NotAuth(c, "Token is not found in redis")
-			c.Abort()
-			return
-		}
-		c.Set(types.LoginUserID, claims["user_id"])
-		c.Next()
-	}
-}
-
-func needLogin(c *gin.Context) bool {
-	path := c.Request.URL.Path
-
-	// 如果不是 API 路径，不需要登录
-	if !strings.HasPrefix(path, "/api") {
-		return false
-	}
-
-	// 检查精确匹配的路径
-	if skip, exists := authConfig.ExactPaths[path]; exists {
-		return skip
-	}
-
-	// 检查前缀匹配的路径
-	for prefix, skip := range authConfig.PrefixPaths {
-		if strings.HasPrefix(path, prefix) {
-			return skip
-		}
-	}
-
-	return true
-}
-
-// 跳过授权
-func (s *AppServer) SkipAuth(url string, prefix bool) {
-	if prefix {
-		authConfig.PrefixPaths[url] = false
-	} else {
-		authConfig.ExactPaths[url] = false
-	}
-}
-
-// 统一参数处理
-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

@@ -11,10 +11,12 @@ import (
 	"bytes"
 	"geekai/core/types"
 	logger2 "geekai/logger"
+	"geekai/store/model"
 	"geekai/utils"
 	"os"
 
 	"github.com/BurntSushi/toml"
+	"gorm.io/gorm"
 )
 
 var logger = logger2.GetLogger()
@@ -30,7 +32,6 @@ func NewDefaultConfig() *types.AppConfig {
 			SecretKey: utils.RandString(64),
 			MaxAge:    86400,
 		},
-		ApiConfig: types.ApiConfig{},
 		OSS: types.OSSConfig{
 			Active: "local",
 			Local: types.LocalStorageConfig{
@@ -38,7 +39,6 @@ func NewDefaultConfig() *types.AppConfig {
 				BasePath: "./static/upload",
 			},
 		},
-		AlipayConfig: types.AlipayConfig{Enabled: false, SandBox: false},
 	}
 }
 
@@ -74,3 +74,98 @@ func SaveConfig(config *types.AppConfig) error {
 
 	return os.WriteFile(config.Path, buf.Bytes(), 0644)
 }
+
+func LoadSystemConfig(db *gorm.DB) *types.SystemConfig {
+	// 加载系统配置
+	var sysConfig model.Config
+	var baseConfig types.BaseConfig
+	db.Where("name", "system").First(&sysConfig)
+	err := utils.JsonDecode(sysConfig.Value, &baseConfig)
+	if err != nil {
+		logger.Error("load system config error: ", err)
+	}
+
+	// 加载验证码配置
+	var captchaConfig types.CaptchaConfig
+	sysConfig.Id = 0
+	db.Where("name", types.ConfigKeyCaptcha).First(&sysConfig)
+	err = utils.JsonDecode(sysConfig.Value, &captchaConfig)
+	if err != nil {
+		logger.Error("load geek service config error: ", err)
+	}
+
+	// 加载微信登录配置
+	var wxLoginConfig types.WxLoginConfig
+	sysConfig.Id = 0
+	db.Where("name", types.ConfigKeyWxLogin).First(&sysConfig)
+	err = utils.JsonDecode(sysConfig.Value, &wxLoginConfig)
+	if err != nil {
+		logger.Error("load wx login config error: ", err)
+	}
+
+	// 加载短信配置
+	var smsConfig types.SMSConfig
+	sysConfig.Id = 0
+	db.Where("name", types.ConfigKeySms).First(&sysConfig)
+	err = utils.JsonDecode(sysConfig.Value, &smsConfig)
+	if err != nil {
+		logger.Error("load sms config error: ", err)
+	}
+
+	// 加载 OSS 配置
+	var ossConfig types.OSSConfig
+	sysConfig.Id = 0
+	db.Where("name", types.ConfigKeyOss).First(&sysConfig)
+	err = utils.JsonDecode(sysConfig.Value, &ossConfig)
+	if err != nil {
+		logger.Error("load oss config error: ", err)
+	}
+
+	// 加载 SMTP 配置
+	var smtpConfig types.SmtpConfig
+	sysConfig.Id = 0
+	db.Where("name", types.ConfigKeySmtp).First(&sysConfig)
+	err = utils.JsonDecode(sysConfig.Value, &smtpConfig)
+	if err != nil {
+		logger.Error("load smtp config error: ", err)
+	}
+
+	// 加载支付配置
+	var paymentConfig types.PaymentConfig
+	sysConfig.Id = 0
+	db.Where("name", types.ConfigKeyPayment).First(&sysConfig)
+	err = utils.JsonDecode(sysConfig.Value, &paymentConfig)
+	if err != nil {
+		logger.Error("load payment config error: ", err)
+	}
+
+	// 加载文本审查配置
+	var moderationConfig types.ModerationConfig
+	sysConfig.Id = 0
+	db.Where("name", types.ConfigKeyModeration).First(&sysConfig)
+	err = utils.JsonDecode(sysConfig.Value, &moderationConfig)
+	if err != nil {
+		logger.Error("load moderation config error: ", err)
+	}
+
+	// 加载即梦AI配置
+	var jimengConfig types.JimengConfig
+	sysConfig.Id = 0
+	db.Where("name", types.ConfigKeyJimeng).First(&sysConfig)
+	err = utils.JsonDecode(sysConfig.Value, &jimengConfig)
+	if err != nil {
+		logger.Error("load jimeng config error: ", err)
+	}
+
+	return &types.SystemConfig{
+		Base:       baseConfig,
+		SMS:        smsConfig,
+		OSS:        ossConfig,
+		SMTP:       smtpConfig,
+		Payment:    paymentConfig,
+		Captcha:    captchaConfig,
+		WxLogin:    wxLoginConfig,
+		Moderation: moderationConfig,
+		Jimeng:     jimengConfig,
+	}
+}

api/core/middleware/auth.go

@@ -0,0 +1,112 @@
+package middleware
+
+import (
+	"context"
+	"fmt"
+	"geekai/core/types"
+	logger2 "geekai/logger"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/go-redis/redis/v8"
+	"github.com/golang-jwt/jwt"
+)
+
+var logger = logger2.GetLogger()
+
+// 前端用户授权验证
+func UserAuthMiddleware(secretKey string, redis *redis.Client) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		tokenString := c.GetHeader(types.UserAuthHeader)
+		if tokenString == "" {
+			resp.NotAuth(c, "无效的授权令牌")
+			c.Abort()
+			return
+		}
+
+		token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
+			if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
+				return nil, fmt.Errorf("不支持的令牌签名方法: %v", token.Header["alg"])
+			}
+			return []byte(secretKey), nil
+		})
+
+		if err != nil {
+			resp.NotAuth(c, fmt.Sprintf("解析授权令牌失败: %v", err))
+			c.Abort()
+			return
+		}
+
+		claims, ok := token.Claims.(jwt.MapClaims)
+		if !ok || !token.Valid {
+			resp.NotAuth(c, "令牌无效")
+			c.Abort()
+			return
+		}
+
+		expr := utils.IntValue(utils.InterfaceToString(claims["expired"]), 0)
+		if expr > 0 && int64(expr) < time.Now().Unix() {
+			resp.NotAuth(c, "令牌过期")
+			c.Abort()
+			return
+		}
+
+		key := fmt.Sprintf("users/%v", claims["user_id"])
+		if _, err := redis.Get(context.Background(), key).Result(); err != nil {
+			resp.NotAuth(c, "当前用户已退出登录")
+			c.Abort()
+			return
+		}
+		c.Set(types.LoginUserID, claims["user_id"])
+	}
+}
+
+// 管理后台用户授权验证
+func AdminAuthMiddleware(secretKey string, redis *redis.Client) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		tokenString := c.GetHeader(types.AdminAuthHeader)
+		if tokenString == "" {
+			resp.NotAuth(c, "无效的授权令牌")
+			c.Abort()
+			return
+		}
+
+		token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
+			if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
+				return nil, fmt.Errorf("不支持的令牌签名方法: %v", token.Header["alg"])
+			}
+			return []byte(secretKey), nil
+		})
+
+		if err != nil {
+			resp.NotAuth(c, fmt.Sprintf("解析授权令牌失败: %v", err))
+			c.Abort()
+			return
+		}
+
+		claims, ok := token.Claims.(jwt.MapClaims)
+		if !ok || !token.Valid {
+			resp.NotAuth(c, "令牌无效")
+			c.Abort()
+			return
+		}
+
+		expr := utils.IntValue(utils.InterfaceToString(claims["expired"]), 0)
+		if expr > 0 && int64(expr) < time.Now().Unix() {
+			resp.NotAuth(c, "令牌过期")
+			c.Abort()
+			return
+		}
+
+		key := fmt.Sprintf("admin/%v", claims["user_id"])
+		if _, err := redis.Get(context.Background(), key).Result(); err != nil {
+			resp.NotAuth(c, "当前用户已退出登录")
+			c.Abort()
+			return
+		}
+
+		c.Set(types.AdminUserID, claims["user_id"])
+	}
+}

api/core/middleware/parameter.go

@@ -0,0 +1,80 @@
+package middleware
+
+import (
+	"bytes"
+	"geekai/utils"
+	"io"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+)
+
+// 统一参数处理
+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]any
+			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 any) {
+	switch v := data.(type) {
+	case map[string]any:
+		for key, value := range v {
+			switch valueType := value.(type) {
+			case string:
+				v[key] = strings.TrimSpace(valueType)
+			case map[string]any, []any:
+				trimJSONStrings(value)
+			}
+		}
+	case []any:
+		for i, value := range v {
+			switch valueType := value.(type) {
+			case string:
+				v[i] = strings.TrimSpace(valueType)
+			case map[string]any, []any:
+				trimJSONStrings(value)
+			}
+		}
+	}
+}

api/core/middleware/rate_limit.go

@@ -0,0 +1,43 @@
+package middleware
+
+import (
+	"context"
+	"fmt"
+	"geekai/core/types"
+	"geekai/utils"
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/go-redis/redis/v8"
+)
+
+// RateLimitEvery 使用 Redis 做固定间隔限流：在 interval 内仅允许一次请求
+// Key 优先使用登录用户ID，若没有则退化为 route + IP
+func RateLimitEvery(redisClient *redis.Client, interval time.Duration) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		keyID := ""
+		if userID, ok := c.Get(types.LoginUserID); ok {
+			keyID = fmt.Sprintf("user:%s", utils.InterfaceToString(userID))
+		} else {
+			keyID = fmt.Sprintf("ip:%s", c.ClientIP())
+		}
+
+		fullPath := c.FullPath()
+		if fullPath == "" {
+			fullPath = c.Request.URL.Path
+		}
+		key := fmt.Sprintf("rl:%s:%s", fullPath, keyID)
+
+		okSet, err := redisClient.SetNX(context.Background(), key, 1, interval).Result()
+		if err != nil {
+			// Redis 异常时放行，避免误伤可用性
+			return
+		}
+		if !okSet {
+			c.JSON(http.StatusTooManyRequests, types.BizVo{Code: types.Failed, Message: "请求过于频繁，请稍后重试"})
+			c.Abort()
+			return
+		}
+	}
+}

api/core/middleware/thumb.go

@@ -0,0 +1,78 @@
+package middleware
+
+import (
+	"bytes"
+	"geekai/utils"
+	"image"
+	"image/jpeg"
+	"net/http"
+	"os"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"github.com/nfnt/resize"
+	"golang.org/x/image/webp"
+)
+
+// 缩略图中间件
+func ThumbMiddleware() 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 {
+				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/types/config.go

@@ -17,88 +17,17 @@ type AppConfig struct {
 	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
-	JimengConfig JimengConfig // 即梦AI配置
-}
-
-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
+	MysqlDns        string       // mysql 连接地址
+	StaticDir       string       // 静态资源目录
+	StaticUrl       string       // 静态资源 URL
+	Redis           RedisConfig  // redis 连接信息
+	SMS             SMSConfig    // send mobile message config
+	OSS             OSSConfig    // OSS config
+	SmtpConfig      SmtpConfig   // 邮件发送配置
+	AlipayConfig    AlipayConfig // 支付宝支付渠道配置
+	GeekPayConfig   EpayConfig   // GEEK 支付配置
+	WechatPayConfig WxPayConfig  // 微信支付渠道配置
+	TikaHost        string       // TiKa 服务器地址
 }
 
 type RedisConfig struct {
@@ -108,52 +37,32 @@ type RedisConfig struct {
 	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
-	BarLogo       string `json:"bar_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 会员每月赠送的算力值
+type BaseConfig struct {
+	Title      string `json:"title,omitempty"`       // 网站标题
+	Slogan     string `json:"slogan,omitempty"`      // 网站 slogan
+	AdminTitle string `json:"admin_title,omitempty"` // 管理后台标题
+	Logo       string `json:"logo,omitempty"`        // 圆形 Logo
+	BarLogo    string `json:"bar_logo,omitempty"`    // 条形 Logo
 
 	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"`     // 会员页面充值说明
+	OrderPayTimeout int `json:"order_pay_timeout,omitempty"` //订单支付超时时间，单位：分钟
 
+	InitPower         int            `json:"init_power,omitempty"`          // 新用户注册赠送算力值
+	DailyPower        int            `json:"daily_power,omitempty"`         // 每日签到赠送算力
+	InvitePower       int            `json:"invite_power,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 生成视频消耗算力
 	KeLingPowers      map[string]int `json:"keling_powers,omitempty"`       // 可灵生成视频消耗算力
 	AdvanceVoicePower int            `json:"advance_voice_power,omitempty"` // 高级语音对话消耗算力
-	PromptPower       int            `json:"prompt_power,omitempty"`        // 生成提示词消耗算力
 
 	WechatCardURL string `json:"wechat_card_url,omitempty"` // 微信客服地址
 
@@ -163,15 +72,45 @@ type SystemConfig struct {
 	SdNegPrompt string `json:"sd_neg_prompt"` // SD 默认反向提示词
 	MjMode      string `json:"mj_mode"`       // midjourney 默认的API模式，relax, fast, turbo
 
-	IndexNavs       []int  `json:"index_navs"`       // 首页显示的导航菜单
-	Copyright       string `json:"copyright"`        // 版权信息
-	DefaultNickname string `json:"default_nickname"` // 默认昵称
-	ICP             string `json:"icp"`              // ICP 备案号
-	MarkMapText     string `json:"mark_map_text"`    // 思维导入的默认文本
+	IndexNavs []int  `json:"index_navs"` // 首页显示的导航菜单
+	IndexPage string `json:"index_page"` // 首页显示的页面
+	Copyright string `json:"copyright"`  // 版权信息
+	ICP       string `json:"icp"`        // ICP 备案号
+	GaBeian   string `json:"ga_beian"`   // 公安备案号
 
-	EnabledVerify    bool     `json:"enabled_verify"`     // 是否启用验证码
 	EmailWhiteList   []string `json:"email_white_list"`   // 邮箱白名单列表
 	AssistantModelId int      `json:"assistant_model_id"` // 用来做提示词,翻译的AI模型 id
 	MaxFileSize      int      `json:"max_file_size"`      // 最大文件大小,单位：MB
 
+	EnableMobileSite bool `json:"enable_mobile_site"` // 是否开启手机站点
 }
+
+type SystemConfig struct {
+	Base       BaseConfig
+	Payment    PaymentConfig
+	OSS        OSSConfig
+	SMS        SMSConfig
+	SMTP       SmtpConfig
+	Captcha    CaptchaConfig
+	WxLogin    WxLoginConfig
+	Jimeng     JimengConfig
+	Moderation ModerationConfig
+}
+
+// 配置键名常量
+const (
+	ConfigKeySystem     = "system"
+	ConfigKeyNotice     = "notice"
+	ConfigKeyAgreement  = "agreement"
+	ConfigKeyPrivacy    = "privacy"
+	ConfigKeyMarkMap    = "mark_map"
+	ConfigKeyCaptcha    = "captcha"
+	ConfigKeyWxLogin    = "wx_login"
+	ConfigKeySms        = "sms"
+	ConfigKeySmtp       = "smtp"
+	ConfigKeyOss        = "oss"
+	ConfigKeyPayment    = "payment"
+	ConfigKeyModeration = "moderation"
+	ConfigKeyAI3D       = "ai3d"
+	ConfigKeyJimeng     = "jimeng"
+)

api/core/types/geekai.go

@@ -0,0 +1,33 @@
+package types
+
+import "os"
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * 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
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+// GeekAI 增值服务
+var GeekAPIURL = "https://sapi.geekai.me"
+
+func init() {
+	if os.Getenv("GEEK_API_URL") != "" {
+		GeekAPIURL = os.Getenv("GEEK_API_URL")
+	}
+}
+
+// CaptchaConfig 行为验证码配置
+type CaptchaConfig struct {
+	ApiKey  string `json:"api_key,omitempty"`
+	Type    string `json:"type,omitempty"` // 验证码类型, 可选值: "dot" 或 "slide"
+	Enabled bool   `json:"enabled,omitempty"`
+}
+
+// WxLoginConfig 微信登录配置
+type WxLoginConfig struct {
+	ApiKey    string `json:"api_key,omitempty"`
+	NotifyURL string `json:"notify_url,omitempty"` // 登录成功回调 URL
+	Enabled   bool   `json:"enabled,omitempty"`    // 是否启用微信登录
+}

api/core/types/jimeng.go

@@ -2,17 +2,65 @@ package types
 
 // JimengConfig 即梦AI配置
 type JimengConfig struct {
-	AccessKey string      `json:"access_key"`
-	SecretKey string      `json:"secret_key"`
-	Power     JimengPower `json:"power"`
+	// 即梦AI的AccessKey和SecretKey
+	AccessKey string `json:"access_key,omitempty"`
+	SecretKey string `json:"secret_key,omitempty"`
+	// 火山引擎大模型专用的验证方式
+	ApiKey string `json:"api_key,omitempty"`
+	// 算力配置
+	Powers map[string]int `json:"powers,omitempty"`
 }
 
-// JimengPower 即梦AI算力配置
-type JimengPower struct {
-	TextToImage  int `json:"text_to_image"`
-	ImageToImage int `json:"image_to_image"`
-	ImageEdit    int `json:"image_edit"`
-	ImageEffects int `json:"image_effects"`
-	TextToVideo  int `json:"text_to_video"`
-	ImageToVideo int `json:"image_to_video"`
+// JMTaskStatus 任务状态
+type JMTaskStatus string
+
+const (
+	JMTaskStatusSubmited   = JMTaskStatus("submited")   // 任务已提交
+	JMTaskStatusInQueue    = JMTaskStatus("in_queue")   // 任务排队中
+	JMTaskStatusGenerating = JMTaskStatus("generating") // 任务处理中
+	JMTaskStatusDone       = JMTaskStatus("done")       // 处理完成
+	JMTaskStatusNotFound   = JMTaskStatus("not_found")  // 任务未找到
+	JMTaskStatusSuccess    = JMTaskStatus("success")    // 任务成功
+	JMTaskStatusFailed     = JMTaskStatus("failed")     // 任务失败
+	JMTaskStatusExpired    = JMTaskStatus("expired")    // 任务过期
+)
+
+// JMTaskType 任务类型
+type JMTaskType string
+
+const (
+	JMTaskTypeImage          = JMTaskType("image")           // 文生图
+	JMTaskTypeVideo          = JMTaskType("video")           // 图生图
+	JMTaskTypeVirtualHuman   = JMTaskType("virtual_human")   // 图像编辑
+	JMTaskTypeActionTransfer = JMTaskType("action_transfer") // 图像特效
+)
+
+// JimengTaskRequest 即梦AI任务请求
+type JimengTaskRequest struct {
+	TaskType JMTaskType `json:"type"`    // 任务类型
+	ReqKey   string     `json:"req_key"` // 请求Key
+	Action   string     `json:"action"`  // 请求Action
+	Power    int        `json:"power"`   // 消耗算力
+	// 公共参数
+	Prompt    string   `json:"prompt,omitempty"`
+	ImageUrls []string `json:"image_urls,omitempty"`
+
+	// 图片生成参数
+	Size        string  `json:"size,omitempty"`
+	UsePreLLM   bool    `json:"use_pre_llm,omitempty"`
+	Scale       float64 `json:"scale,omitempty"`
+	ForceSingle bool    `json:"force_single,omitempty"`
+
+	// 视频生成参数
+	Duration       int    `json:"duration,omitempty"`    // 视频时长，单位：秒
+	TemplateId     string `json:"template_id,omitempty"` // 运镜模板ID
+	AspectRatio    string `json:"aspect_ratio,omitempty"`
+	CameraStrength string `json:"camera_strength,omitempty"` // 运镜强度
+
+	// 数字人视频生成参数
+	AudioURL     string `json:"audio_url,omitempty"`     // 音频URL
+	RecognizeKey string `json:"recognize_key,omitempty"` // 识别主体请求Key
+
+	// 视频动作迁移参数
+	VideoURL string `json:"video_url,omitempty"` // 动作视频URL
 }

api/core/types/moderation.go

@@ -0,0 +1,73 @@
+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 ModerationConfig struct {
+	Enable      bool                    `json:"enable,omitempty"` // 是否启用文本审查
+	Active      string                  `json:"active,omitempty"`
+	EnableGuide bool                    `json:"enable_guide,omitempty"` // 是否启用模型引导提示词
+	GuidePrompt string                  `json:"guide_prompt,omitempty"` // 模型引导提示词
+	Gitee       ModerationGiteeConfig   `json:"gitee,omitempty"`
+	Baidu       ModerationBaiduConfig   `json:"baidu,omitempty"`
+	Tencent     ModerationTencentConfig `json:"tencent,omitempty"`
+}
+
+const (
+	ModerationGitee   = "gitee"
+	ModerationBaidu   = "baidu"
+	ModerationTencent = "tencent"
+)
+
+// GiteeAI 文本审查配置
+type ModerationGiteeConfig struct {
+	ApiKey string `json:"api_key,omitempty"`
+	Model  string `json:"model,omitempty"` // 文本审核模型
+}
+
+// 百度文本审查配置
+type ModerationBaiduConfig struct {
+	AccessKey string `json:"access_key,omitempty"`
+	SecretKey string `json:"secret_key,omitempty"`
+}
+
+// 腾讯云文本审查配置
+type ModerationTencentConfig struct {
+	AccessKey string `json:"access_key,omitempty"`
+	SecretKey string `json:"secret_key,omitempty"`
+}
+
+type ModerationResult struct {
+	Flagged        bool               `json:"flagged,omitempty"`
+	Categories     map[string]bool    `json:"categories,omitempty"`
+	CategoryScores map[string]float64 `json:"category_scores,omitempty"`
+}
+
+var ModerationCategories = map[string]string{
+	"politic":  "内容涉及人物、事件或敏感的政治观点",
+	"porn":     "明确的色情内容",
+	"insult":   "具有侮辱、攻击性语言、人身攻击或冒犯性表达",
+	"violence": "包含暴力、血腥、攻击行为或煽动暴力的言论",
+	"illegal":  "涉及违法活动的内容，如诈骗、赌博等",
+	"terror":   "宣扬恐怖主义、极端暴力或煽动恐怖行为的内容",
+	"ad":       "垃圾广告或未经许可的推广内容",
+	"spam":     "无意义重复内容或诱导性信息",
+	"abuse":    "人身攻击、恶意辱骂或侮辱性言论",
+	"polity":   "涉及国家政治、领导人或政策的违规讨论内容",
+}
+
+// 敏感词来源
+const (
+	ModerationSourceChat   = "chat"
+	ModerationSourceMJ     = "mj"
+	ModerationSourceDalle  = "dalle"
+	ModerationSourceSD     = "sd"
+	ModerationSourceSuno   = "suno"
+	ModerationSourceVideo  = "video"
+	ModerationSourceJiMeng = "jimeng"
+)

api/core/types/order.go

@@ -11,29 +11,25 @@ type OrderStatus int
 
 const (
 	OrderNotPaid     = OrderStatus(0)
-	OrderScanned     = OrderStatus(1) // 已扫码
-	OrderPaidSuccess = OrderStatus(2)
+	OrderPaidSuccess = OrderStatus(2) // 已支付
+	OrderPaidFailed  = OrderStatus(3) // 已关闭
 )
 
 type OrderRemark struct {
-	Days     int     `json:"days"`  // 有效期
-	Power    int     `json:"power"` // 增加算力点数
-	Name     string  `json:"name"`  // 产品名称
-	Price    float64 `json:"price"`
-	Discount float64 `json:"discount"`
+	Days  int     `json:"days"`  // 有效期
+	Power int     `json:"power"` // 增加算力点数
+	Name  string  `json:"name"`  // 产品名称
+	Price float64 `json:"price"`
 }
 
-var PayMethods = map[string]string{
+// PayChannel 支付渠道
+var PayChannel = map[string]string{
 	"alipay": "支付宝商号",
-	"wechat": "微信商号",
-	"hupi":   "虎皮椒",
-	"geek":   "易支付",
+	"wxpay":  "微信商号",
+	"epay":   "易支付",
 }
-var PayNames = map[string]string{
+
+var PayWays = map[string]string{
 	"alipay": "支付宝",
 	"wxpay":  "微信支付",
-	"qqpay":  "QQ钱包",
-	"jdpay":  "京东支付",
-	"douyin": "抖音支付",
-	"paypal": "PayPal支付",
 }

api/core/types/oss.go

@@ -8,41 +8,39 @@ package types
 // * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 type OSSConfig struct {
-	Active string
-	Local  LocalStorageConfig
-	Minio  MiniOssConfig
-	QiNiu  QiNiuOssConfig
-	AliYun AliYunOssConfig
+	Active string             `json:"active,omitempty"`
+	Local  LocalStorageConfig `json:"local,omitempty"`
+	Minio  MiniOssConfig      `json:"minio,omitempty"`
+	QiNiu  QiNiuOssConfig     `json:"qiniu,omitempty"`
+	AliYun AliYunOssConfig    `json:"aliyun,omitempty"`
 }
+
 type MiniOssConfig struct {
-	Endpoint     string
-	AccessKey    string
-	AccessSecret string
-	Bucket       string
-	SubDir       string
-	UseSSL       bool
-	Domain       string
+	Endpoint     string `json:"endpoint,omitempty"`
+	AccessKey    string `json:"access_key,omitempty"`
+	AccessSecret string `json:"access_secret,omitempty"`
+	Bucket       string `json:"bucket,omitempty"`
+	UseSSL       bool   `json:"use_ssl,omitempty"`
+	Domain       string `json:"domain,omitempty"`
 }
 
 type QiNiuOssConfig struct {
-	Zone         string
-	AccessKey    string
-	AccessSecret string
-	Bucket       string
-	SubDir       string
-	Domain       string
+	Zone         string `json:"zone,omitempty"`
+	AccessKey    string `json:"access_key,omitempty"`
+	AccessSecret string `json:"access_secret,omitempty"`
+	Bucket       string `json:"bucket,omitempty"`
+	Domain       string `json:"domain,omitempty"`
 }
 
 type AliYunOssConfig struct {
-	Endpoint     string
-	AccessKey    string
-	AccessSecret string
-	Bucket       string
-	SubDir       string
-	Domain       string
+	Endpoint     string `json:"endpoint,omitempty"`
+	AccessKey    string `json:"access_key,omitempty"`
+	AccessSecret string `json:"access_secret,omitempty"`
+	Bucket       string `json:"bucket,omitempty"`
+	Domain       string `json:"domain,omitempty"`
 }
 
 type LocalStorageConfig struct {
-	BasePath string
-	BaseURL  string
+	BasePath string `json:"base_path,omitempty"`
+	BaseURL  string `json:"base_url,omitempty"`
 }

api/core/types/payment.go

@@ -0,0 +1,60 @@
+package types
+
+type PaymentConfig struct {
+	Alipay AlipayConfig `json:"alipay,omitempty"` // 支付宝支付渠道配置
+	Epay   EpayConfig   `json:"epay,omitempty"`   // 易支付配置
+	WxPay  WxPayConfig  `json:"wxpay,omitempty"`  // 微信支付渠道配置
+}
+
+// AlipayConfig 支付宝支付配置
+type AlipayConfig struct {
+	Enabled         bool   `json:"enabled,omitempty"`           // 是否启用该支付通道
+	SandBox         bool   `json:"sandbox,omitempty"`           // 是否沙盒环境
+	AppId           string `json:"app_id,omitempty"`            // 应用 ID
+	PrivateKey      string `json:"private_key,omitempty"`       // 应用私钥
+	AlipayPublicKey string `json:"alipay_public_key,omitempty"` // 支付宝公钥
+	Domain          string `json:"domain,omitempty"`            // 支付回调域名
+}
+
+func (c *AlipayConfig) Equal(other *AlipayConfig) bool {
+	return c.AppId == other.AppId &&
+		c.PrivateKey == other.PrivateKey &&
+		c.AlipayPublicKey == other.AlipayPublicKey &&
+		c.Domain == other.Domain
+}
+
+// WxPayConfig 微信支付配置
+type WxPayConfig struct {
+	Enabled    bool   `json:"enabled,omitempty"`     // 是否启用该支付通道
+	AppId      string `json:"app_id,omitempty"`      // 公众号的APPID,如：wxd678efh567hg6787
+	MchId      string `json:"mch_id,omitempty"`      // 直连商户的商户号，由微信支付生成并下发
+	SerialNo   string `json:"serial_no,omitempty"`   // 商户证书的证书序列号
+	PrivateKey string `json:"private_key,omitempty"` // 商户证书私钥
+	ApiV3Key   string `json:"api_v3_key,omitempty"`  // API V3 秘钥
+	Domain     string `json:"domain,omitempty"`      // 支付回调域名
+}
+
+func (c *WxPayConfig) Equal(other *WxPayConfig) bool {
+	return c.AppId == other.AppId &&
+		c.MchId == other.MchId &&
+		c.SerialNo == other.SerialNo &&
+		c.PrivateKey == other.PrivateKey &&
+		c.ApiV3Key == other.ApiV3Key &&
+		c.Domain == other.Domain
+}
+
+// EpayConfig 易支付配置
+type EpayConfig struct {
+	Enabled    bool   `json:"enabled,omitempty"`     // 是否启用该支付通道
+	AppId      string `json:"app_id,omitempty"`      // 商户 ID
+	PrivateKey string `json:"private_key,omitempty"` // 私钥
+	ApiURL     string `json:"api_url,omitempty"`     // z支付 API 网关
+	Domain     string `json:"domain,omitempty"`      // 支付回调域名
+}
+
+func (c *EpayConfig) Equal(other *EpayConfig) bool {
+	return c.AppId == other.AppId &&
+		c.PrivateKey == other.PrivateKey &&
+		c.ApiURL == other.ApiURL &&
+		c.Domain == other.Domain
+}

api/core/types/session.go

@@ -8,6 +8,7 @@ package types
 // * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 const LoginUserID = "LOGIN_USER_ID"
+const AdminUserID = "ADMIN_USER_ID"
 const LoginUserCache = "LOGIN_USER_CACHE"
 
 const UserAuthHeader = "Authorization"

api/core/types/sms.go

@@ -8,26 +8,23 @@ package types
 // * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 type SMSConfig struct {
-	Active string
-	Ali    SmsConfigAli
-	Bao    SmsConfigBao
+	Active string       `json:"active,omitempty"`
+	Ali    SmsConfigAli `json:"aliyun,omitempty"`
+	Bao    SmsConfigBao `json:"bao,omitempty"`
 }
 
 // SmsConfigAli 阿里云短信平台配置
 type SmsConfigAli struct {
-	AccessKey    string
-	AccessSecret string
-	Product      string
-	Domain       string
-	Sign         string // 短信签名
-	CodeTempId   string // 验证码短信模板 ID
+	AccessKey    string `json:"access_key,omitempty"`
+	AccessSecret string `json:"access_secret,omitempty"`
+	Sign         string `json:"sign,omitempty"`         // 短信签名
+	CodeTempId   string `json:"code_temp_id,omitempty"` // 验证码短信模板 ID
 }
 
 // SmsConfigBao 短信宝平台配置
 type SmsConfigBao struct {
-	Username     string //短信宝平台注册的用户名
-	Password     string //短信宝平台注册的密码
-	Domain       string //域名
-	Sign         string // 短信签名
-	CodeTemplate string // 验证码短信模板 匹配
+	Username     string `json:"username,omitempty"`      //短信宝平台注册的用户名
+	Password     string `json:"password,omitempty"`      //短信宝平台注册的密码
+	Sign         string `json:"sign,omitempty"`          // 短信签名
+	CodeTemplate string `json:"code_template,omitempty"` // 验证码短信模板 匹配
 }

api/core/types/smtp.go

@@ -0,0 +1,26 @@
+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 SmtpConfig struct {
+	UseTls   bool   `json:"use_tls,omitempty"`  // 是否使用 TLS 发送
+	Host     string `json:"host,omitempty"`     // 邮件服务器地址
+	Port     int    `json:"port,omitempty"`     // 邮件服务器端口
+	AppName  string `json:"app_name,omitempty"` // 应用名称
+	From     string `json:"from,omitempty"`     // 发件人邮箱地址
+	Password string `json:"password,omitempty"` // 发件人邮箱密码
+}
+
+func (s *SmtpConfig) Equal(other *SmtpConfig) bool {
+	return s.UseTls == other.UseTls &&
+		s.Host == other.Host &&
+		s.Port == other.Port &&
+		s.AppName == other.AppName &&
+		s.From == other.From &&
+		s.Password == other.Password
+}

api/core/types/task.go

@@ -70,17 +70,17 @@ type SdTaskParams struct {
 
 // DallTask DALL-E task
 type DallTask struct {
-	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
+	ModelId          uint     `json:"model_id"`
+	ModelName        string   `json:"model_name"`
+	ModelValue       string   `json:"model_value"`
+	Image            []string `json:"image,omitempty"`
+	Id               uint     `json:"id"`
+	UserId           uint     `json:"user_id"`
+	Prompt           string   `json:"prompt"`
+	AspectRatio      string   `json:"aspect_ratio"`
+	Size             string   `json:"size"`
+	Power            int      `json:"power"`
+	TranslateModelId int      `json:"translate_model_id"` // 提示词翻译模型ID
 }
 
 type SunoTask struct {

api/core/types/user_lock.go

@@ -0,0 +1,45 @@
+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 "sync"
+
+// UserLockManager 提供基于用户ID的TryLock功能，确保同一用户并发请求串行化
+type UserLockManager struct {
+	mu    sync.Mutex
+	locks map[uint]bool
+}
+
+func NewUserLockManager() *UserLockManager {
+	return &UserLockManager{mu: sync.Mutex{}, locks: make(map[uint]bool)}
+}
+
+// TryLock 尝试为指定用户加锁。若已被占用返回 false
+func (m *UserLockManager) TryLock(userId uint) bool {
+	if userId == 0 {
+		return true
+	}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.locks[userId] {
+		return false
+	}
+	m.locks[userId] = true
+	return true
+}
+
+// Unlock 释放指定用户的锁
+func (m *UserLockManager) Unlock(userId uint) {
+	if userId == 0 {
+		return
+	}
+	m.mu.Lock()
+	delete(m.locks, userId)
+	m.mu.Unlock()
+}

api/fresh.conf

@@ -4,7 +4,7 @@ build_name:        runner-build
 build_log:         runner-build-errors.log
 valid_ext:         .go, .tpl, .tmpl, .html
 no_rebuild_ext:    .tpl, .tmpl, .html, .js, .vue
-ignored:           assets, tmp, web, .git, .idea, test, data
+ignored:           assets, tmp, web, .git, .idea, test, data, static
 build_delay:       600
 colors:            1
 log_color_main:    cyan

api/go.mod

@@ -24,17 +24,16 @@ require (
 	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/go-rod/rod v0.116.2
+	github.com/golang-jwt/jwt v3.2.2+incompatible
 	github.com/google/go-tika v0.3.1
 	github.com/microcosm-cc/bluemonday v1.0.26
 	github.com/sashabaranov/go-openai v1.38.1
 	github.com/shirou/gopsutil v3.21.11+incompatible
 	github.com/shopspring/decimal v1.3.1
 	github.com/syndtr/goleveldb v1.0.0
+	github.com/volcengine/volcengine-go-sdk v1.1.34
 	golang.org/x/image v0.15.0
 )
 
@@ -50,13 +49,9 @@ require (
 	github.com/gorilla/css v1.0.0 // indirect
 	github.com/tklauser/go-sysconf v0.3.13 // indirect
 	github.com/tklauser/numcpus v0.7.0 // indirect
-	github.com/ysmood/fetchup v0.3.0 // indirect
-	github.com/ysmood/goob v0.4.0 // indirect
-	github.com/ysmood/got v0.40.0 // indirect
-	github.com/ysmood/gson v0.7.3 // indirect
-	github.com/ysmood/leakless v0.9.0 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
 	go.uber.org/mock v0.4.0 // indirect
+	gopkg.in/yaml.v2 v2.4.0 // indirect
 )
 
 require (
@@ -69,7 +64,6 @@ require (
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
 	github.com/gaukas/godicttls v0.0.3 // indirect
-	github.com/go-basic/ipv4 v1.0.0 // indirect
 	github.com/go-sql-driver/mysql v1.7.0 // indirect
 	github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 // indirect
 	github.com/goccy/go-json v0.10.2 // indirect

api/go.sum

@@ -46,8 +46,6 @@ 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=
@@ -80,8 +78,6 @@ github.com/go-playground/validator/v10 v10.14.0 h1:vgvQWe3XCz3gIeFDm/HnTIbj6UGmg
 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-rod/rod v0.116.2 h1:A5t2Ky2A+5eD/ZJQr1EfsQSe5rms5Xof/qj296e+ZqA=
-github.com/go-rod/rod v0.116.2/go.mod h1:H+CMO9SCNc2TJ2WfrG+pKhITz57uGNYU43qYHh438Mg=
 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=
@@ -89,6 +85,8 @@ github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4
 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 v3.2.2+incompatible h1:IfV12K8xAKAnZqdXVzCZ+TOjboZ2keLg81eXfW3O+oY=
+github.com/golang-jwt/jwt v3.2.2+incompatible/go.mod h1:8pz2t5EyA70fFQQSrl6XZXzqecmYZeUEB8OUGHkxJ+I=
 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/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
@@ -102,6 +100,7 @@ github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:W
 github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
 github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
 github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
 github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
 github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
@@ -112,6 +111,7 @@ github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMyw
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 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=
@@ -261,22 +261,8 @@ github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4d
 github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
 github.com/volcengine/volc-sdk-golang v1.0.23 h1:anOslb2Qp6ywnsbyq9jqR0ljuO63kg9PY+4OehIk5R8=
 github.com/volcengine/volc-sdk-golang v1.0.23/go.mod h1:AfG/PZRUkHJ9inETvbjNifTDgut25Wbkm2QoYBTbvyU=
-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/ysmood/fetchup v0.3.0 h1:UhYz9xnLEVn2ukSuK3KCgcznWpHMdrmbsPpllcylyu8=
-github.com/ysmood/fetchup v0.3.0/go.mod h1:hbysoq65PXL0NQeNzUczNYIKpwpkwFL4LXMDEvIQq9A=
-github.com/ysmood/goob v0.4.0 h1:HsxXhyLBeGzWXnqVKtmT9qM7EuVs/XOgkX7T6r1o1AQ=
-github.com/ysmood/goob v0.4.0/go.mod h1:u6yx7ZhS4Exf2MwciFr6nIM8knHQIE22lFpWHnfql18=
-github.com/ysmood/gop v0.2.0 h1:+tFrG0TWPxT6p9ZaZs+VY+opCvHU8/3Fk6BaNv6kqKg=
-github.com/ysmood/gop v0.2.0/go.mod h1:rr5z2z27oGEbyB787hpEcx4ab8cCiPnKxn0SUHt6xzk=
-github.com/ysmood/got v0.40.0 h1:ZQk1B55zIvS7zflRrkGfPDrPG3d7+JOza1ZkNxcc74Q=
-github.com/ysmood/got v0.40.0/go.mod h1:W7DdpuX6skL3NszLmAsC5hT7JAhuLZhByVzHTq874Qg=
-github.com/ysmood/gotrace v0.6.0 h1:SyI1d4jclswLhg7SWTL6os3L1WOKeNn/ZtzVQF8QmdY=
-github.com/ysmood/gotrace v0.6.0/go.mod h1:TzhIG7nHDry5//eYZDYcTzuJLYQIkykJzCRIo4/dzQM=
-github.com/ysmood/gson v0.7.3 h1:QFkWbTH8MxyUTKPkVWAENJhxqdBa4lYTQWqZCiLG6kE=
-github.com/ysmood/gson v0.7.3/go.mod h1:3Kzs5zDl21g5F/BlLTNcuAGAYLKt2lV5G8D1zF3RNmg=
-github.com/ysmood/leakless v0.9.0 h1:qxCG5VirSBvmi3uynXFkcnLMzkphdh3xx5FtrORwDCU=
-github.com/ysmood/leakless v0.9.0/go.mod h1:R8iAXPRaG97QJwqxs74RdwzcRHT1SWCGTNqY8q0JvMQ=
+github.com/volcengine/volcengine-go-sdk v1.1.34 h1:ha90JycCCTJNCse0UDziBgBsuX98ITOrkwYlDWcm7NI=
+github.com/volcengine/volcengine-go-sdk v1.1.34/go.mod h1:oxoVo+A17kvkwPkIeIHPVLjSw7EQAm+l/Vau1YGHN+A=
 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=
@@ -408,6 +394,8 @@ google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2
 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 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=

api/handler/admin/admin_handler.go

@@ -11,6 +11,7 @@ import (
 	"context"
 	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/handler"
 	logger2 "geekai/logger"
@@ -19,9 +20,10 @@ import (
 	"geekai/store/vo"
 	"geekai/utils"
 	"geekai/utils/resp"
+	"time"
+
 	"github.com/go-redis/redis/v8"
 	"github.com/golang-jwt/jwt/v5"
-	"time"
 
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
@@ -29,7 +31,7 @@ import (
 
 var logger = logger2.GetLogger()
 
-const SuperManagerID = 1
+const SuperUsername = "admin"
 
 type ManagerHandler struct {
 	handler.BaseHandler
@@ -45,6 +47,26 @@ func NewAdminHandler(app *core.AppServer, db *gorm.DB, client *redis.Client, cap
 	}
 }
 
+// RegisterRoutes 注册路由
+func (h *ManagerHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/admin/")
+
+	// 公开接口，不需要授权
+	group.POST("login", h.Login)
+	group.GET("logout", h.Logout)
+
+	// 需要管理员授权的接口
+	group.Use(middleware.AdminAuthMiddleware(h.App.Config.AdminSession.SecretKey, h.App.Redis))
+	{
+		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)
+	}
+}
+
 // Login 登录
 func (h *ManagerHandler) Login(c *gin.Context) {
 	var data struct {
@@ -59,19 +81,6 @@ func (h *ManagerHandler) Login(c *gin.Context) {
 		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 {
@@ -85,7 +94,7 @@ func (h *ManagerHandler) Login(c *gin.Context) {
 	}
 
 	// 超级管理员默认是ID:1
-	if manager.Id != SuperManagerID && manager.Status == false {
+	if manager.Username != SuperUsername && !manager.Status {
 		resp.ERROR(c, "该用户已被禁止登录，请联系超级管理员")
 		return
 	}
@@ -116,7 +125,7 @@ func (h *ManagerHandler) Login(c *gin.Context) {
 		IsSuperAdmin bool   `json:"is_super_admin"`
 		Token        string `json:"token"`
 	}{
-		IsSuperAdmin: manager.Id == 1,
+		IsSuperAdmin: manager.Username == SuperUsername,
 		Token:        tokenString,
 	}
 
@@ -135,16 +144,15 @@ func (h *ManagerHandler) Logout(c *gin.Context) {
 
 // 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)
+	id := h.GetAdminId(c)
+	if id == 0 {
+		resp.NotAuth(c, "当前用户已退出登录")
 		return
 	}
 	var manager model.AdminUser
-	res := h.DB.Where("id", id).First(&manager)
-	if res.Error != nil {
-		resp.NotAuth(c)
+	err := h.DB.Where("id", id).First(&manager).Error
+	if err != nil {
+		resp.NotAuth(c, "当前用户已退出登录")
 		return
 	}
 
@@ -219,12 +227,19 @@ func (h *ManagerHandler) Remove(c *gin.Context) {
 		return
 	}
 
-	if id == SuperManagerID {
+	var user model.AdminUser
+	res := h.DB.Where("id", id).First(&user)
+	if res.Error != nil {
+		resp.ERROR(c, res.Error.Error())
+		return
+	}
+
+	if user.Username == SuperUsername {
 		resp.ERROR(c, "超级管理员不能删除")
 		return
 	}
 
-	res := h.DB.Where("id", id).Delete(&model.AdminUser{})
+	res = h.DB.Where("id", id).Delete(&model.AdminUser{})
 	if res.Error != nil {
 		resp.ERROR(c, res.Error.Error())
 		return
@@ -255,8 +270,14 @@ func (h *ManagerHandler) Enable(c *gin.Context) {
 
 // ResetPass 重置密码
 func (h *ManagerHandler) ResetPass(c *gin.Context) {
-	id := h.GetLoginUserId(c)
-	if id != SuperManagerID {
+	id := h.GetAdminId(c)
+	var user model.AdminUser
+	res := h.DB.Where("id", id).First(&user)
+	if res.Error != nil {
+		resp.ERROR(c, res.Error.Error())
+		return
+	}
+	if user.Username != SuperUsername {
 		resp.ERROR(c, "只有超级管理员能够进行该操作")
 		return
 	}
@@ -270,13 +291,6 @@ func (h *ManagerHandler) ResetPass(c *gin.Context) {
 		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)

api/handler/admin/api_key_handler.go

@@ -10,6 +10,7 @@ package admin
 import (
 	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/handler"
 	"geekai/store/model"
@@ -30,6 +31,20 @@ func NewApiKeyHandler(app *core.AppServer, db *gorm.DB) *ApiKeyHandler {
 	return &ApiKeyHandler{BaseHandler: handler.BaseHandler{DB: db, App: app}}
 }
 
+// RegisterRoutes 注册路由
+func (h *ApiKeyHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/admin/apikey/")
+
+	// 需要管理员授权的接口
+	group.Use(middleware.AdminAuthMiddleware(h.App.Config.AdminSession.SecretKey, h.App.Redis))
+	{
+		group.GET("list", h.List)
+		group.POST("save", h.Save)
+		group.POST("set", h.Set)
+		group.GET("remove", h.Remove)
+	}
+}
+
 func (h *ApiKeyHandler) Save(c *gin.Context) {
 	var data struct {
 		Id       uint   `json:"id"`

api/handler/admin/chat_app_handler.go

@@ -10,6 +10,7 @@ package admin
 import (
 	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/handler"
 	"geekai/store/model"
@@ -30,14 +31,29 @@ func NewChatAppHandler(app *core.AppServer, db *gorm.DB) *ChatAppHandler {
 	return &ChatAppHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
 }
 
+// RegisterRoutes 注册路由
+func (h *ChatAppHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/admin/role/")
+
+	// 需要管理员授权的接口
+	group.Use(middleware.AdminAuthMiddleware(h.App.Config.AdminSession.SecretKey, h.App.Redis))
+	{
+		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)
+	}
+}
+
 // Save 创建或者更新某个角色
 func (h *ChatAppHandler) Save(c *gin.Context) {
-	var data vo.ChatRole
+	var data vo.ChatApp
 	if err := c.ShouldBindJSON(&data); err != nil {
 		resp.ERROR(c, types.InvalidArgs)
 		return
 	}
-	var role model.ChatRole
+	var role model.ChatApp
 	err := utils.CopyObject(data, &role)
 	if err != nil {
 		resp.ERROR(c, types.InvalidArgs)
@@ -65,8 +81,8 @@ func (h *ChatAppHandler) Save(c *gin.Context) {
 }
 
 func (h *ChatAppHandler) List(c *gin.Context) {
-	var items []model.ChatRole
-	var roles = make([]vo.ChatRole, 0)
+	var items []model.ChatApp
+	var roles = make([]vo.ChatApp, 0)
 	res := h.DB.Order("sort_num ASC").Find(&items)
 	if res.Error != nil {
 		resp.ERROR(c, "No data found")
@@ -107,7 +123,7 @@ func (h *ChatAppHandler) List(c *gin.Context) {
 	}
 
 	for _, v := range items {
-		var role vo.ChatRole
+		var role vo.ChatApp
 		err := utils.CopyObject(v, &role)
 		if err == nil {
 			role.Id = v.Id
@@ -135,7 +151,7 @@ func (h *ChatAppHandler) Sort(c *gin.Context) {
 	}
 
 	for index, id := range data.Ids {
-		err := h.DB.Model(&model.ChatRole{}).Where("id = ?", id).Update("sort_num", data.Sorts[index]).Error
+		err := h.DB.Model(&model.ChatApp{}).Where("id = ?", id).Update("sort_num", data.Sorts[index]).Error
 		if err != nil {
 			resp.ERROR(c, err.Error())
 			return
@@ -157,7 +173,7 @@ func (h *ChatAppHandler) Set(c *gin.Context) {
 		return
 	}
 
-	err := h.DB.Model(&model.ChatRole{}).Where("id = ?", data.Id).Update(data.Filed, data.Value).Error
+	err := h.DB.Model(&model.ChatApp{}).Where("id = ?", data.Id).Update(data.Filed, data.Value).Error
 	if err != nil {
 		resp.ERROR(c, err.Error())
 		return
@@ -172,9 +188,8 @@ func (h *ChatAppHandler) Remove(c *gin.Context) {
 		resp.ERROR(c, types.InvalidArgs)
 		return
 	}
-	res := h.DB.Where("id", id).Delete(&model.ChatRole{})
+	res := h.DB.Where("id", id).Delete(&model.ChatApp{})
 	if res.Error != nil {
-		logger.Error("error with update database：", res.Error)
 		resp.ERROR(c, "删除失败！")
 		return
 	}

api/handler/admin/chat_app_type_handler.go

@@ -2,12 +2,14 @@ package admin
 
 import (
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/handler"
 	"geekai/store/model"
 	"geekai/store/vo"
 	"geekai/utils"
 	"geekai/utils/resp"
+
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
 )
@@ -20,6 +22,21 @@ func NewChatAppTypeHandler(app *core.AppServer, db *gorm.DB) *ChatAppTypeHandler
 	return &ChatAppTypeHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
 }
 
+// RegisterRoutes 注册路由
+func (h *ChatAppTypeHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/admin/app/type/")
+
+	// 需要管理员授权的接口
+	group.Use(middleware.AdminAuthMiddleware(h.App.Config.AdminSession.SecretKey, h.App.Redis))
+	{
+		group.GET("list", h.List)
+		group.POST("save", h.Save)
+		group.GET("remove", h.Remove)
+		group.POST("enable", h.Enable)
+		group.POST("sort", h.Sort)
+	}
+}
+
 // Save 创建或更新App类型
 func (h *ChatAppTypeHandler) Save(c *gin.Context) {
 	var data struct {

api/handler/admin/chat_handler.go

@@ -9,6 +9,7 @@ package admin
 
 import (
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/handler"
 	"geekai/store/model"
@@ -28,16 +29,31 @@ func NewChatHandler(app *core.AppServer, db *gorm.DB) *ChatHandler {
 	return &ChatHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
 }
 
+// RegisterRoutes 注册路由
+func (h *ChatHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/admin/chat/")
+
+	// 需要管理员授权的接口
+	group.Use(middleware.AdminAuthMiddleware(h.App.Config.AdminSession.SecretKey, h.App.Redis))
+	{
+		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)
+	}
+}
+
 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"` // 消息数量
+	Username  string     `json:"username"`
+	UserId    uint       `json:"user_id"`
+	ChatId    string     `json:"chat_id"`
+	Title     string     `json:"title"`
+	Role      vo.ChatApp `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) {
@@ -87,7 +103,7 @@ func (h *ChatHandler) List(c *gin.Context) {
 		}
 		var messages []model.ChatMessage
 		var users []model.User
-		var roles []model.ChatRole
+		var roles []model.ChatApp
 		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)
@@ -95,7 +111,7 @@ func (h *ChatHandler) List(c *gin.Context) {
 		tokenMap := make(map[string]int)
 		userMap := make(map[uint]string)
 		msgMap := make(map[string]int)
-		roleMap := make(map[uint]vo.ChatRole)
+		roleMap := make(map[uint]vo.ChatApp)
 		for _, msg := range messages {
 			tokenMap[msg.ChatId] += msg.Tokens
 			msgMap[msg.ChatId] += 1
@@ -104,7 +120,7 @@ func (h *ChatHandler) List(c *gin.Context) {
 			userMap[user.Id] = user.Username
 		}
 		for _, r := range roles {
-			var roleVo vo.ChatRole
+			var roleVo vo.ChatApp
 			err := utils.CopyObject(r, &roleVo)
 			if err != nil {
 				continue

api/handler/admin/chat_model_handler.go

@@ -8,7 +8,9 @@ package admin
 // * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 import (
+	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/handler"
 	"geekai/store/model"
@@ -28,6 +30,22 @@ func NewChatModelHandler(app *core.AppServer, db *gorm.DB) *ChatModelHandler {
 	return &ChatModelHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
 }
 
+// RegisterRoutes 注册路由
+func (h *ChatModelHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/admin/model/")
+
+	// 需要管理员授权的接口
+	group.Use(middleware.AdminAuthMiddleware(h.App.Config.AdminSession.SecretKey, h.App.Redis))
+	{
+		group.GET("list", h.List)
+		group.POST("save", h.Save)
+		group.POST("set", h.Set)
+		group.POST("sort", h.Sort)
+		group.GET("remove", h.Remove)
+		group.POST("batch-remove", h.BatchRemove)
+	}
+}
+
 func (h *ChatModelHandler) Save(c *gin.Context) {
 	var data struct {
 		Id          uint              `json:"id"`
@@ -201,3 +219,33 @@ func (h *ChatModelHandler) Remove(c *gin.Context) {
 	}
 	resp.SUCCESS(c)
 }
+
+// BatchRemove 批量删除模型
+func (h *ChatModelHandler) BatchRemove(c *gin.Context) {
+	var data struct {
+		Ids []uint `json:"ids"`
+	}
+
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if len(data.Ids) == 0 {
+		resp.ERROR(c, "请选择要删除的模型")
+		return
+	}
+
+	// 执行批量删除
+	err := h.DB.Where("id IN ?", data.Ids).Delete(&model.ChatModel{}).Error
+	if err != nil {
+		logger.Error("批量删除模型失败：", err)
+		resp.ERROR(c, "批量删除失败："+err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, gin.H{
+		"message":       fmt.Sprintf("成功删除 %d 个模型", len(data.Ids)),
+		"deleted_count": len(data.Ids),
+	})
+}

api/handler/admin/config_handler.go

@@ -9,106 +9,378 @@ package admin
 
 import (
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/handler"
 	"geekai/service"
-	"geekai/store"
+	"geekai/service/oss"
+	"geekai/service/payment"
+	"geekai/service/sms"
 	"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
+	sysConfig       *types.SystemConfig
+	alipayService   *payment.AlipayService
+	wxpayService    *payment.WxPayService
+	epayService     *payment.EPayService
+	smsManager      *sms.SmsManager
+	uploaderManager *oss.UploaderManager
+	smtpService     *service.SmtpService
+	captchaService  *service.CaptchaService
+	wxLoginService  *service.WxLoginService
 }
 
-func NewConfigHandler(app *core.AppServer, db *gorm.DB, levelDB *store.LevelDB, licenseService *service.LicenseService) *ConfigHandler {
+func NewConfigHandler(
+	app *core.AppServer,
+	db *gorm.DB,
+	sysConfig *types.SystemConfig,
+	alipayService *payment.AlipayService,
+	wxpayService *payment.WxPayService,
+	epayService *payment.EPayService,
+	smsManager *sms.SmsManager,
+	uploaderManager *oss.UploaderManager,
+	smtpService *service.SmtpService,
+	captchaService *service.CaptchaService,
+	wxLoginService *service.WxLoginService,
+) *ConfigHandler {
 	return &ConfigHandler{
-		BaseHandler:    handler.BaseHandler{App: app, DB: db},
-		levelDB:        levelDB,
-		licenseService: licenseService,
+		BaseHandler:     handler.BaseHandler{App: app, DB: db},
+		sysConfig:       sysConfig,
+		alipayService:   alipayService,
+		wxpayService:    wxpayService,
+		epayService:     epayService,
+		smsManager:      smsManager,
+		uploaderManager: uploaderManager,
+		smtpService:     smtpService,
+		captchaService:  captchaService,
+		wxLoginService:  wxLoginService,
 	}
 }
 
-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"`
+// RegisterRoutes 注册路由
+func (h *ConfigHandler) RegisterRoutes() {
+	rg := h.App.Engine.Group("/api/admin/config")
+
+	// 需要管理员登录的接口
+	rg.Use(middleware.AdminAuthMiddleware(h.App.Config.AdminSession.SecretKey, h.App.Redis))
+	{
+		rg.POST("update/base", h.UpdateBase)
+		rg.POST("update/power", h.UpdatePower)
+		rg.POST("update/notice", h.UpdateNotice)
+		rg.POST("update/agreement", h.UpdateAgreement)
+		rg.POST("update/privacy", h.UpdatePrivacy)
+		rg.POST("update/mark_map", h.UpdateMarkMap)
+		rg.POST("update/captcha", h.UpdateCaptcha)
+		rg.POST("update/wx_login", h.UpdateWxLogin)
+		rg.POST("update/payment", h.UpdatePayment)
+		rg.POST("update/sms", h.UpdateSms)
+		rg.POST("update/oss", h.UpdateOss)
+		rg.POST("update/smtp", h.UpdateStmp)
+		rg.GET("get", h.Get)
 	}
+}
+
+// UpdateBase 更新基础配置
+func (h *ConfigHandler) UpdateBase(c *gin.Context) {
+	var data types.BaseConfig
 
 	if err := c.ShouldBindJSON(&data); err != nil {
-		logger.Errorf("Update config failed: %v", err)
 		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, "您无权修改版权信息，请先联系作者获取授权")
+	err := h.Update(types.ConfigKeySystem, data)
+	if err != nil {
+		resp.ERROR(c, err.Error())
 		return
 	}
 
-	// 如果要启用图形验证码功能，则检查是否配置了 API 服务
-	if data.Config.EnabledVerify && h.App.Config.ApiConfig.AppId == "" {
-		resp.ERROR(c, "启用验证码服务需要先配置 GeekAI 官方 API 服务 AppId 和 Token")
-		return
-	}
+	h.sysConfig.Base = data
 
-	value := utils.JsonEncode(&data.Config)
-	config := model.Config{Name: data.Key, Value: value}
-	res := h.DB.FirstOrCreate(&config, model.Config{Name: data.Key})
-	if res.Error != nil {
-		resp.ERROR(c, res.Error.Error())
-		return
-	}
-
-	if config.Id > 0 {
-		config.Value = 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("name", data.Key).First(&cfg)
-		var err error
-		if data.Key == "system" {
-			err = utils.JsonDecode(cfg.Value, &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.Value)
-	}
-
-	resp.SUCCESS(c, config)
+	resp.SUCCESS(c, data)
 }
 
-// Get 获取指定的系统配置
-func (h *ConfigHandler) Get(c *gin.Context) {
-	key := c.Query("key")
+// UpdatePower 更新系统配置
+func (h *ConfigHandler) UpdatePower(c *gin.Context) {
+	var data struct {
+		InitPower     int            `json:"init_power,omitempty"`      // 新用户注册赠送算力值
+		DailyPower    int            `json:"daily_power,omitempty"`     // 每日签到赠送算力
+		InvitePower   int            `json:"invite_power,omitempty"`    // 邀请新用户赠送算力值
+		MjPower       int            `json:"mj_power,omitempty"`        // MJ 绘画消耗算力
+		MjActionPower int            `json:"mj_action_power,omitempty"` // MJ 操作（放大，变换）消耗算力
+		SdPower       int            `json:"sd_power,omitempty"`        // SD 绘画消耗算力
+		SunoPower     int            `json:"suno_power,omitempty"`      // Suno 生成歌曲消耗算力
+		LumaPower     int            `json:"luma_power,omitempty"`      // Luma 生成视频消耗算力
+		KeLingPowers  map[string]int `json:"keling_powers,omitempty"`   // 可灵生成视频消耗算力
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	h.sysConfig.Base.InitPower = data.InitPower
+	h.sysConfig.Base.DailyPower = data.DailyPower
+	h.sysConfig.Base.InvitePower = data.InvitePower
+	h.sysConfig.Base.MjPower = data.MjPower
+	h.sysConfig.Base.MjActionPower = data.MjActionPower
+	h.sysConfig.Base.SdPower = data.SdPower
+	h.sysConfig.Base.SunoPower = data.SunoPower
+	h.sysConfig.Base.LumaPower = data.LumaPower
+	h.sysConfig.Base.KeLingPowers = data.KeLingPowers
+
+	err := h.Update(types.ConfigKeySystem, h.sysConfig.Base)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, h.sysConfig.Base)
+}
+
+// UpdateNotice 更新公告配置
+func (h *ConfigHandler) UpdateNotice(c *gin.Context) {
+	var data struct {
+		Content string `json:"content"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	err := h.Update(types.ConfigKeyNotice, data)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, data)
+}
+
+// UpdateAgreement 更新用户协议配置
+func (h *ConfigHandler) UpdateAgreement(c *gin.Context) {
+	var data struct {
+		Content string `json:"content"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	err := h.Update(types.ConfigKeyAgreement, data)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, data)
+}
+
+// UpdatePrivacy 更新隐私政策配置
+func (h *ConfigHandler) UpdatePrivacy(c *gin.Context) {
+	var data struct {
+		Content string `json:"content"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	err := h.Update(types.ConfigKeyPrivacy, data)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, data)
+}
+
+// UpdateMarkMap 更新思维导图配置
+func (h *ConfigHandler) UpdateMarkMap(c *gin.Context) {
+	var data struct {
+		Content string `json:"content"`
+	}
+
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	err := h.Update(types.ConfigKeyMarkMap, data)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, data)
+}
+
+// UpdateCaptcha 更新行为验证码配置
+func (h *ConfigHandler) UpdateCaptcha(c *gin.Context) {
+	var data types.CaptchaConfig
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	err := h.Update(types.ConfigKeyCaptcha, data)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	h.captchaService.UpdateConfig(data)
+	resp.SUCCESS(c, data)
+
+}
+
+// UpdatePayment 更新支付配置
+func (h *ConfigHandler) UpdatePayment(c *gin.Context) {
+	var data types.PaymentConfig
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	err := h.Update(types.ConfigKeyPayment, data)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// 如果启用状态发生改变，则需要更新支付服务配置
+	if data.WxPay.Enabled {
+		err = h.wxpayService.UpdateConfig(&data.WxPay)
+		if err != nil {
+			resp.ERROR(c, err.Error())
+			return
+		}
+	}
+	if data.Epay.Enabled {
+		h.epayService.UpdateConfig(&data.Epay)
+	}
+	if data.Alipay.Enabled {
+		err = h.alipayService.UpdateConfig(&data.Alipay)
+		if err != nil {
+			resp.ERROR(c, err.Error())
+			return
+		}
+	}
+
+	h.sysConfig.Payment = data
+	resp.SUCCESS(c, data)
+}
+
+// UpdateSms 更新短信配置
+func (h *ConfigHandler) UpdateSms(c *gin.Context) {
+	var data types.SMSConfig
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	err := h.Update(types.ConfigKeySms, data)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// 更新服务配置
+	h.smsManager.UpdateConfig(data)
+
+	resp.SUCCESS(c, data)
+}
+
+// UpdateOss 更新 Oss 配置
+func (h *ConfigHandler) UpdateOss(c *gin.Context) {
+	var data types.OSSConfig
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	err := h.Update(types.ConfigKeyOss, data)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// 更新服务配置
+	h.uploaderManager.UpdateConfig(data)
+	h.sysConfig.OSS = data
+
+	resp.SUCCESS(c, data)
+}
+
+// UpdateStmp 更新 Stmp 配置
+func (h *ConfigHandler) UpdateStmp(c *gin.Context) {
+	var data types.SmtpConfig
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	err := h.Update(types.ConfigKeySmtp, data)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// 更新服务配置
+	h.smtpService.UpdateConfig(&data)
+	h.sysConfig.SMTP = data
+	resp.SUCCESS(c, data)
+}
+
+// UpdateWxLogin 更新微信登录配置
+func (h *ConfigHandler) UpdateWxLogin(c *gin.Context) {
+	var data types.WxLoginConfig
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	err := h.Update(types.ConfigKeyWxLogin, data)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	h.wxLoginService.UpdateConfig(data)
+	h.sysConfig.WxLogin = data
+	resp.SUCCESS(c, data)
+}
+
+// Update 更新系统配置
+func (h *ConfigHandler) Update(name string, value any) error {
 	var config model.Config
-	res := h.DB.Where("name", key).First(&config)
+	err := h.DB.Where("name", name).First(&config).Error
+	if err != nil { // 不存在则创建
+		config.Name = name
+		config.Value = utils.JsonEncode(value)
+		return h.DB.Create(&config).Error
+	} else { // 存在则更新
+		config.Value = utils.JsonEncode(value)
+		return h.DB.Updates(&config).Error
+	}
+
+}
+
+// Get 获取指定名称的系统配置
+func (h *ConfigHandler) Get(c *gin.Context) {
+	name := c.Query("key")
+	var config model.Config
+	res := h.DB.Where("name", name).First(&config)
 	if res.Error != nil {
 		resp.ERROR(c, res.Error.Error())
 		return
 	}
 
-	var value map[string]interface{}
+	var value map[string]any
 	err := utils.JsonDecode(config.Value, &value)
 	if err != nil {
 		resp.ERROR(c, err.Error())
@@ -117,100 +389,3 @@ func (h *ConfigHandler) Get(c *gin.Context) {
 
 	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)
-
-}
-
-// 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, "当前升级版本没有数据需要修正！")
-	//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

@@ -13,10 +13,11 @@ import (
 	"geekai/handler"
 	"geekai/store/model"
 	"geekai/utils/resp"
+	"time"
+
 	"github.com/gin-gonic/gin"
 	"github.com/shopspring/decimal"
 	"gorm.io/gorm"
-	"time"
 )
 
 type DashboardHandler struct {
@@ -27,46 +28,161 @@ func NewDashboardHandler(app *core.AppServer, db *gorm.DB) *DashboardHandler {
 	return &DashboardHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
 }
 
+// RegisterRoutes 注册路由
+func (h *DashboardHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/admin/dashboard/")
+	group.GET("stats", h.Stats)
+}
+
+// statsVo 增加 recentOrders、recentUsers 字段
+// 最近订单
+type OrderBrief struct {
+	OrderNo   string    `json:"order_no"`
+	Amount    float64   `json:"amount"`
+	CreatedAt time.Time `json:"created_at"`
+}
+
+// 最近用户
+type UserBrief struct {
+	Nickname   string    `json:"nickname"`
+	Avatar     string    `json:"avatar"`
+	LastActive time.Time `json:"last_active"`
+}
+
 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"`
+	Users          int64                         `json:"users"`
+	Chats          int64                         `json:"chats"`
+	Tokens         int                           `json:"tokens"`
+	Income         float64                       `json:"income"`
+	Chart          map[string]map[string]float64 `json:"chart"`
+	TodayUsers     int64                         `json:"todayUsers"`
+	TodayChats     int64                         `json:"todayChats"`
+	TodayTokens    int                           `json:"todayTokens"`
+	TodayIncome    float64                       `json:"todayIncome"`
+	TodayOrders    int64                         `json:"todayOrders"`
+	TodayImageJobs int64                         `json:"todayImageJobs"`
+	TodayVideoJobs int64                         `json:"todayVideoJobs"`
+	TodayMusicJobs int64                         `json:"todayMusicJobs"`
+	Orders         int64                         `json:"orders"`
+	ImageJobs      int64                         `json:"imageJobs"`
+	VideoJobs      int64                         `json:"videoJobs"`
+	MusicJobs      int64                         `json:"musicJobs"`
+	RecentOrders   []OrderBrief                  `json:"recentOrders"`
+	RecentUsers    []UserBrief                   `json:"recentUsers"`
 }
 
 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
+
+	// 总用户数
+	h.DB.Model(&model.User{}).Count(&stats.Users)
+
+	// 今日新增用户
+	h.DB.Model(&model.User{}).Where("created_at > ?", zeroTime).Count(&stats.TodayUsers)
+
+	// 总对话数
+	h.DB.Model(&model.ChatItem{}).Count(&stats.Chats)
+
+	// 今日新增对话
+	h.DB.Model(&model.ChatItem{}).Where("created_at > ?", zeroTime).Count(&stats.TodayChats)
+
+	// 总算力消耗
+	var powerLogs []model.PowerLog
+	h.DB.Where("mark = ?", types.PowerSub).Find(&powerLogs)
+	for _, item := range powerLogs {
+		stats.Tokens += item.Amount
 	}
 
-	// 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
+	// 今日算力消耗
+	var todayPowerLogs []model.PowerLog
+	h.DB.Where("mark = ?", types.PowerSub).Where("created_at > ?", zeroTime).Find(&todayPowerLogs)
+	for _, item := range todayPowerLogs {
+		stats.TodayTokens += item.Amount
 	}
 
-	// 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 {
+	// 总收入
+	var allOrders []model.Order
+	h.DB.Where("status = ?", types.OrderPaidSuccess).Find(&allOrders)
+	for _, item := range allOrders {
 		stats.Income += item.Amount
 	}
 
+	// 今日收入
+	var todayOrders []model.Order
+	h.DB.Where("status = ?", types.OrderPaidSuccess).Where("created_at > ?", zeroTime).Find(&todayOrders)
+	for _, item := range todayOrders {
+		stats.TodayIncome += item.Amount
+	}
+
+	// 订单总数
+	h.DB.Model(&model.Order{}).Where("status = ?", types.OrderPaidSuccess).Count(&stats.Orders)
+
+	// 今日订单数
+	h.DB.Model(&model.Order{}).Where("status = ?", types.OrderPaidSuccess).Where("created_at > ?", zeroTime).Count(&stats.TodayOrders)
+
+	// 图片生成任务统计
+	var mjJobs, sdJobs, dallJobs, jimengImageJobs int64
+	h.DB.Model(&model.MidJourneyJob{}).Count(&mjJobs)
+	h.DB.Model(&model.SdJob{}).Count(&sdJobs)
+	h.DB.Model(&model.DallJob{}).Count(&dallJobs)
+	h.DB.Model(&model.JimengJob{}).Where("type IN ?", []string{"text_to_image", "image_to_image", "image_edit", "image_effects"}).Count(&jimengImageJobs)
+	stats.ImageJobs = mjJobs + sdJobs + dallJobs + jimengImageJobs
+
+	logger.Info("stats.ImageJobs", stats.ImageJobs)
+
+	// 今日图片生成任务统计
+	var todayMjJobs, todaySdJobs, todayDallJobs, todayJimengImageJobs int64
+	h.DB.Model(&model.MidJourneyJob{}).Where("created_at > ?", zeroTime).Count(&todayMjJobs)
+	h.DB.Model(&model.SdJob{}).Where("created_at > ?", zeroTime).Count(&todaySdJobs)
+	h.DB.Model(&model.DallJob{}).Where("created_at > ?", zeroTime).Count(&todayDallJobs)
+	h.DB.Model(&model.JimengJob{}).Where("type IN ?", []string{"text_to_image", "image_to_image", "image_edit", "image_effects"}).Where("created_at > ?", zeroTime).Count(&todayJimengImageJobs)
+	stats.TodayImageJobs = todayMjJobs + todaySdJobs + todayDallJobs + todayJimengImageJobs
+
+	// 视频生成任务统计
+	var videoJobs, jimengVideoJobs int64
+	h.DB.Model(&model.VideoJob{}).Count(&videoJobs)
+	h.DB.Model(&model.JimengJob{}).Where("type IN ?", []string{"text_to_video", "image_to_video"}).Count(&jimengVideoJobs)
+	stats.VideoJobs = videoJobs + jimengVideoJobs
+
+	// 今日视频生成任务统计
+	var todayVideoJobs, todayJimengVideoJobs int64
+	h.DB.Model(&model.VideoJob{}).Where("created_at > ?", zeroTime).Count(&todayVideoJobs)
+	h.DB.Model(&model.JimengJob{}).Where("type IN ?", []string{"text_to_video", "image_to_video"}).Where("created_at > ?", zeroTime).Count(&todayJimengVideoJobs)
+	stats.TodayVideoJobs = todayVideoJobs + todayJimengVideoJobs
+
+	// 音乐生成任务统计
+	h.DB.Model(&model.SunoJob{}).Count(&stats.MusicJobs)
+
+	// 今日音乐生成任务统计
+	h.DB.Model(&model.SunoJob{}).Where("created_at > ?", zeroTime).Count(&stats.TodayMusicJobs)
+
+	// recentOrders: 最近10条已支付订单
+	var orderList []model.Order
+	h.DB.Model(&model.Order{}).Where("status = ?", types.OrderPaidSuccess).Order("created_at desc").Limit(10).Find(&orderList)
+	for _, o := range orderList {
+		stats.RecentOrders = append(stats.RecentOrders, OrderBrief{
+			OrderNo:   o.OrderNo,
+			Amount:    o.Amount,
+			CreatedAt: o.CreatedAt,
+		})
+	}
+	// recentUsers: 最近10个注册用户
+	var userList []model.User
+	h.DB.Model(&model.User{}).Order("created_at desc").Limit(10).Find(&userList)
+	for _, u := range userList {
+		lastActive := u.UpdatedAt
+		if lastActive.IsZero() {
+			lastActive = u.CreatedAt
+		}
+		stats.RecentUsers = append(stats.RecentUsers, UserBrief{
+			Nickname:   u.Nickname,
+			Avatar:     u.Avatar,
+			LastActive: lastActive,
+		})
+	}
+
 	// 统计7天的订单的图表
 	startDate := now.Add(-7 * 24 * time.Hour).Format("2006-01-02")
 	var statsChart = make(map[string]map[string]float64)
@@ -81,23 +197,29 @@ func (h *DashboardHandler) Stats(c *gin.Context) {
 
 	// 统计用户7天增加的曲线
 	var users []model.User
-	res = h.DB.Model(&model.User{}).Where("created_at > ?", startDate).Find(&users)
-	if res.Error == nil {
+	err := h.DB.Model(&model.User{}).Where("created_at > ?", startDate).Find(&users).Error
+	if err == 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天算力消耗
+	var chartPowerLogs []model.PowerLog
+	err = h.DB.Where("mark = ?", types.PowerSub).Where("created_at > ?", startDate).Find(&chartPowerLogs).Error
+	if err == nil {
+		for _, item := range chartPowerLogs {
+			historyMessagesStatistic[item.CreatedAt.Format("2006-01-02")] += float64(item.Amount)
+		}
 	}
 
 	// 统计最近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()
+	var orders []model.Order
+	err = h.DB.Where("status = ?", types.OrderPaidSuccess).Where("created_at > ?", startDate).Find(&orders).Error
+	if err == nil {
+		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

api/handler/admin/function_handler.go

@@ -9,6 +9,7 @@ package admin
 
 import (
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/handler"
 	"geekai/store/model"
@@ -30,6 +31,21 @@ func NewFunctionHandler(app *core.AppServer, db *gorm.DB) *FunctionHandler {
 	return &FunctionHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
 }
 
+// RegisterRoutes 注册路由
+func (h *FunctionHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/admin/function/")
+
+	// 需要管理员授权的接口
+	group.Use(middleware.AdminAuthMiddleware(h.App.Config.AdminSession.SecretKey, h.App.Redis))
+	{
+		group.GET("list", h.List)
+		group.POST("save", h.Save)
+		group.POST("set", h.Set)
+		group.GET("remove", h.Remove)
+		group.GET("token", h.GenToken)
+	}
+}
+
 func (h *FunctionHandler) Save(c *gin.Context) {
 	var data vo.Function
 	if err := c.ShouldBindJSON(&data); err != nil {
@@ -119,7 +135,6 @@ func (h *FunctionHandler) GenToken(c *gin.Context) {
 	})
 	tokenString, err := token.SignedString([]byte(h.App.Config.Session.SecretKey))
 	if err != nil {
-		logger.Error("error with generate token", err)
 		resp.ERROR(c)
 		return
 	}

api/handler/admin/image_handler.go

@@ -10,6 +10,7 @@ package admin
 import (
 	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/handler"
 	"geekai/service"
@@ -33,6 +34,20 @@ func NewImageHandler(app *core.AppServer, db *gorm.DB, userService *service.User
 	return &ImageHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}, userService: userService, uploader: manager}
 }
 
+// RegisterRoutes 注册路由
+func (h *ImageHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/admin/image/")
+
+	// 需要管理员授权的接口
+	group.Use(middleware.AdminAuthMiddleware(h.App.Config.AdminSession.SecretKey, h.App.Redis))
+	{
+		group.POST("list/mj", h.MjList)
+		group.POST("list/sd", h.SdList)
+		group.POST("list/dall", h.DallList)
+		group.GET("remove", h.Remove)
+	}
+}
+
 type imageQuery struct {
 	Prompt    string   `json:"prompt"`
 	Username  string   `json:"username"`

api/handler/admin/jimeng_handler.go

@@ -21,18 +21,18 @@ import (
 // AdminJimengHandler 管理后台即梦AI处理器
 type AdminJimengHandler struct {
 	handler.BaseHandler
-	jimengService *jimeng.Service
-	userService   *service.UserService
-	uploader      *oss.UploaderManager
+	jimengClient *jimeng.Client
+	userService  *service.UserService
+	uploader     *oss.UploaderManager
 }
 
 // NewAdminJimengHandler 创建管理后台即梦AI处理器
-func NewAdminJimengHandler(app *core.AppServer, db *gorm.DB, jimengService *jimeng.Service, userService *service.UserService, uploader *oss.UploaderManager) *AdminJimengHandler {
+func NewAdminJimengHandler(app *core.AppServer, db *gorm.DB, jimengClient *jimeng.Client, userService *service.UserService, uploader *oss.UploaderManager) *AdminJimengHandler {
 	return &AdminJimengHandler{
-		BaseHandler:   handler.BaseHandler{App: app, DB: db},
-		jimengService: jimengService,
-		userService:   userService,
-		uploader:      uploader,
+		BaseHandler:  handler.BaseHandler{App: app, DB: db},
+		jimengClient: jimengClient,
+		userService:  userService,
+		uploader:     uploader,
 	}
 }
 
@@ -43,7 +43,6 @@ func (h *AdminJimengHandler) RegisterRoutes() {
 	rg.GET("/jobs/:id", h.JobDetail)
 	rg.POST("/jobs/remove", h.BatchRemove)
 	rg.GET("/stats", h.Stats)
-	rg.GET("/config", h.GetConfig)
 	rg.POST("/config/update", h.UpdateConfig)
 }
 
@@ -132,7 +131,7 @@ func (h *AdminJimengHandler) BatchRemove(c *gin.Context) {
 			continue // 跳过不存在的
 		}
 		tx := h.DB.Begin()
-		if job.Status != model.JMTaskStatusSuccess && job.Power > 0 {
+		if job.Status != types.JMTaskStatusSuccess && job.Power > 0 {
 			remark := fmt.Sprintf("任务未成功，退回算力。任务ID：%d，Err: %s", job.Id, job.ErrMsg)
 			err = h.userService.IncreasePower(job.UserId, job.Power, model.PowerLog{
 				Type:   types.PowerRefund,
@@ -173,7 +172,7 @@ func (h *AdminJimengHandler) BatchRemove(c *gin.Context) {
 // Stats 获取统计信息
 func (h *AdminJimengHandler) Stats(c *gin.Context) {
 	type StatResult struct {
-		Status model.JMTaskStatus `json:"status"`
+		Status types.JMTaskStatus `json:"status"`
 		Count  int64              `json:"count"`
 	}
 
@@ -199,13 +198,13 @@ func (h *AdminJimengHandler) Stats(c *gin.Context) {
 	for _, stat := range stats {
 		result["totalTasks"] = result["totalTasks"].(int64) + stat.Count
 		switch stat.Status {
-		case model.JMTaskStatusInQueue:
+		case types.JMTaskStatusInQueue:
 			result["pendingTasks"] = stat.Count
-		case model.JMTaskStatusSuccess:
+		case types.JMTaskStatusSuccess:
 			result["completedTasks"] = stat.Count
-		case model.JMTaskStatusGenerating:
+		case types.JMTaskStatusGenerating:
 			result["processingTasks"] = stat.Count
-		case model.JMTaskStatusFailed:
+		case types.JMTaskStatusFailed:
 			result["failedTasks"] = stat.Count
 		}
 	}
@@ -213,12 +212,6 @@ func (h *AdminJimengHandler) Stats(c *gin.Context) {
 	resp.SUCCESS(c, result)
 }
 
-// GetConfig 获取即梦AI配置
-func (h *AdminJimengHandler) GetConfig(c *gin.Context) {
-	jimengConfig := h.jimengService.GetConfig()
-	resp.SUCCESS(c, jimengConfig)
-}
-
 // UpdateConfig 更新即梦AI配置
 func (h *AdminJimengHandler) UpdateConfig(c *gin.Context) {
 	var req types.JimengConfig
@@ -238,59 +231,49 @@ func (h *AdminJimengHandler) UpdateConfig(c *gin.Context) {
 	}
 
 	// 验证算力配置
-	if req.Power.TextToImage <= 0 {
-		resp.ERROR(c, "文生图算力必须大于0")
+	if len(req.Powers) == 0 {
+		resp.ERROR(c, "请至少配置一个模型的积分")
 		return
 	}
-	if req.Power.ImageToImage <= 0 {
-		resp.ERROR(c, "图生图算力必须大于0")
-		return
-	}
-	if req.Power.ImageEdit <= 0 {
-		resp.ERROR(c, "图片编辑算力必须大于0")
-		return
-	}
-	if req.Power.ImageEffects <= 0 {
-		resp.ERROR(c, "图片特效算力必须大于0")
-		return
-	}
-	if req.Power.TextToVideo <= 0 {
-		resp.ERROR(c, "文生视频算力必须大于0")
-		return
-	}
-	if req.Power.ImageToVideo <= 0 {
-		resp.ERROR(c, "图生视频算力必须大于0")
-		return
+	for key, val := range req.Powers {
+		if val <= 0 {
+			resp.ERROR(c, fmt.Sprintf("模型 %s 的积分必须大于0", key))
+			return
+		}
 	}
 
 	// 保存配置
 	tx := h.DB.Begin()
 	value := utils.JsonEncode(&req)
-	config := model.Config{Name: "jimeng", Value: value}
+	var exist model.Config
+	tx.Where("name", types.ConfigKeyJimeng).First(&exist)
 
-	err := tx.FirstOrCreate(&config, model.Config{Name: "jimeng"}).Error
-	if err != nil {
-		resp.ERROR(c, "保存配置失败: "+err.Error())
-		return
-	}
-
-	if config.Id > 0 {
-		config.Value = value
-		err = tx.Updates(&config).Error
+	if exist.Id > 0 {
+		exist.Value = value
+		err := tx.Updates(&exist).Error
 		if err != nil {
 			resp.ERROR(c, "更新配置失败: "+err.Error())
 			return
 		}
+	} else {
+		exist.Name = types.ConfigKeyJimeng
+		exist.Value = value
+		err := tx.Create(&exist).Error
+		if err != nil {
+			resp.ERROR(c, "创建配置失败: "+err.Error())
+			return
+		}
 	}
 
 	// 更新服务中的客户端配置
-	updateErr := h.jimengService.UpdateClientConfig(req.AccessKey, req.SecretKey)
-	if updateErr != nil {
-		resp.ERROR(c, updateErr.Error())
+	err := h.jimengClient.UpdateConfig(req)
+	if err != nil {
+		resp.ERROR(c, err.Error())
 		tx.Rollback()
 		return
 	}
 	tx.Commit()
+	h.App.SysConfig.Jimeng = req
 
 	resp.SUCCESS(c, gin.H{"message": "配置更新成功"})
 }

api/handler/admin/media_handler.go

@@ -10,6 +10,7 @@ package admin
 import (
 	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/handler"
 	"geekai/service"
@@ -33,6 +34,19 @@ func NewMediaHandler(app *core.AppServer, db *gorm.DB, userService *service.User
 	return &MediaHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}, userService: userService, uploader: manager}
 }
 
+// RegisterRoutes 注册路由
+func (h *MediaHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/admin/media/")
+
+	// 需要管理员授权的接口
+	group.Use(middleware.AdminAuthMiddleware(h.App.Config.AdminSession.SecretKey, h.App.Redis))
+	{
+		group.POST("suno", h.SunoList)
+		group.POST("videos", h.Videos)
+		group.GET("remove", h.Remove)
+	}
+}
+
 type mediaQuery struct {
 	Type      string   `json:"type"` // 任务类型 luma, keling
 	Prompt    string   `json:"prompt"`

api/handler/admin/menu_handler.go

@@ -27,6 +27,16 @@ func NewMenuHandler(app *core.AppServer, db *gorm.DB) *MenuHandler {
 	return &MenuHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
 }
 
+// RegisterRoutes 注册路由
+func (h *MenuHandler) RegisterRoutes() {
+	group := h.App.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)
+}
+
 func (h *MenuHandler) Save(c *gin.Context) {
 	var data struct {
 		Id      uint   `json:"id"`

api/handler/admin/moderation_handler.go

@@ -0,0 +1,333 @@
+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/middleware"
+	"geekai/core/types"
+	"geekai/handler"
+	"geekai/service/moderation"
+	"geekai/store/model"
+	"geekai/utils"
+	"geekai/utils/resp"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type ModerationHandler struct {
+	handler.BaseHandler
+	sysConfig         *types.SystemConfig
+	moderationManager *moderation.ServiceManager
+}
+
+func NewModerationHandler(app *core.AppServer, db *gorm.DB, sysConfig *types.SystemConfig, moderationManager *moderation.ServiceManager) *ModerationHandler {
+	return &ModerationHandler{BaseHandler: handler.BaseHandler{DB: db, App: app}, sysConfig: sysConfig, moderationManager: moderationManager}
+}
+
+// RegisterRoutes 注册路由
+func (h *ModerationHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/admin/moderation/")
+
+	// 需要管理员授权的接口
+	group.Use(middleware.AdminAuthMiddleware(h.App.Config.AdminSession.SecretKey, h.App.Redis))
+	{
+		group.POST("list", h.List)
+		group.GET("remove", h.Remove)
+		group.POST("batch-remove", h.BatchRemove)
+		group.GET("source-list", h.GetSourceList)
+		group.POST("config", h.UpdateModeration)
+		group.POST("test", h.TestModeration)
+	}
+}
+
+// List 获取文本审核记录列表
+func (h *ModerationHandler) List(c *gin.Context) {
+	var data struct {
+		Username  string `json:"username"`
+		Source    string `json:"source"`
+		StartDate string `json:"start_date"`
+		EndDate   string `json:"end_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.Username != "" {
+		// 通过用户名查找用户ID
+		var user model.User
+		if err := h.DB.Where("username LIKE ?", "%"+data.Username+"%").First(&user).Error; err == nil {
+			session = session.Where("user_id", user.Id)
+		}
+	}
+
+	if data.Source != "" {
+		session = session.Where("source", data.Source)
+	}
+
+	if data.StartDate != "" && data.EndDate != "" {
+		startTime := data.StartDate + " 00:00:00"
+		endTime := data.EndDate + " 23:59:59"
+		session = session.Where("created_at >= ? AND created_at <= ?", startTime, endTime)
+	}
+
+	// 统计总数
+	var total int64
+	session.Model(&model.Moderation{}).Count(&total)
+
+	// 分页
+	page := data.Page
+	pageSize := data.PageSize
+	if page <= 0 {
+		page = 1
+	}
+	if pageSize <= 0 {
+		pageSize = 20
+	}
+
+	offset := (page - 1) * pageSize
+	session = session.Offset(offset).Limit(pageSize)
+
+	// 查询数据
+	var items []model.Moderation
+	err := session.Order("id DESC").Find(&items).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	// 获取用户信息
+	userIds := make([]uint, 0)
+	for _, item := range items {
+		userIds = append(userIds, item.UserId)
+	}
+
+	var users []model.User
+	if len(userIds) > 0 {
+		h.DB.Where("id IN ?", userIds).Find(&users)
+	}
+
+	userMap := make(map[uint]string)
+	for _, user := range users {
+		userMap[user.Id] = user.Username
+	}
+
+	// 转换为响应数据
+	list := make([]map[string]any, 0)
+	for _, item := range items {
+		var moderation types.ModerationResult
+		err := utils.JsonDecode(item.Result, &moderation)
+		if err != nil {
+			continue
+		}
+		var result []string
+		for value, label := range types.ModerationCategories {
+			if moderation.Categories[value] {
+				result = append(result, label)
+			}
+		}
+		list = append(list, map[string]any{
+			"id":         item.Id,
+			"user_id":    item.UserId,
+			"username":   userMap[item.UserId],
+			"source":     item.Source,
+			"input":      item.Input,
+			"output":     item.Output,
+			"result":     result,
+			"created_at": item.CreatedAt.Unix(),
+		})
+	}
+
+	resp.SUCCESS(c, map[string]any{
+		"items":     list,
+		"total":     total,
+		"page":      page,
+		"page_size": pageSize,
+	})
+}
+
+func (h *ModerationHandler) 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.Moderation{}).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	resp.SUCCESS(c)
+}
+
+// BatchRemove 批量删除文本审核记录
+func (h *ModerationHandler) BatchRemove(c *gin.Context) {
+	var data struct {
+		Ids []uint `json:"ids"`
+	}
+
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if len(data.Ids) == 0 {
+		resp.ERROR(c, "请选择要删除的记录")
+		return
+	}
+
+	err := h.DB.Where("id IN ?", data.Ids).Delete(&model.Moderation{}).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c)
+}
+
+// 获取 source 列表
+func (h *ModerationHandler) GetSourceList(c *gin.Context) {
+	sources := []gin.H{
+		{
+			"id":   types.ModerationSourceChat,
+			"name": "AI对话",
+		},
+		{
+			"id":   types.ModerationSourceMJ,
+			"name": "Midjourney 绘图",
+		},
+		{
+			"id":   types.ModerationSourceDalle,
+			"name": "Dalle 绘图",
+		},
+		{
+			"id":   types.ModerationSourceSD,
+			"name": "StableDiffusion 绘图",
+		},
+		{
+			"id":   types.ModerationSourceSuno,
+			"name": "Suno 音乐",
+		},
+		{
+			"id":   types.ModerationSourceVideo,
+			"name": "视频生成",
+		},
+		{
+			"id":   types.ModerationSourceJiMeng,
+			"name": "即梦AI",
+		},
+	}
+
+	resp.SUCCESS(c, sources)
+}
+
+// UpdateModeration 更新文本审查配置
+func (h *ModerationHandler) UpdateModeration(c *gin.Context) {
+	var data types.ModerationConfig
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	var config model.Config
+	err := h.DB.Where("name", types.ConfigKeyModeration).First(&config).Error
+	if err != nil {
+		config.Name = types.ConfigKeyModeration
+		config.Value = utils.JsonEncode(data)
+		err = h.DB.Create(&config).Error
+	} else {
+		config.Value = utils.JsonEncode(data)
+		err = h.DB.Updates(&config).Error
+	}
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	h.moderationManager.UpdateConfig(data)
+	h.sysConfig.Moderation = data
+
+	resp.SUCCESS(c, data)
+}
+
+// 测试结果类型，用于前端显示
+type ModerationTestResult struct {
+	IsAbnormal bool                   `json:"isAbnormal"`
+	Details    []ModerationTestDetail `json:"details"`
+}
+
+type ModerationTestDetail struct {
+	Category    string `json:"category"`
+	Description string `json:"description"`
+	Confidence  string `json:"confidence"`
+	IsCategory  bool   `json:"isCategory"`
+}
+
+// TestModeration 测试文本审查服务
+func (h *ModerationHandler) TestModeration(c *gin.Context) {
+	var data struct {
+		Text    string `json:"text"`
+		Service string `json:"service"`
+	}
+
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if data.Text == "" {
+		resp.ERROR(c, "测试文本不能为空")
+		return
+	}
+
+	// 检查是否启用了文本审查
+	if !h.sysConfig.Moderation.Enable {
+		resp.ERROR(c, "文本审查服务未启用")
+		return
+	}
+
+	// 获取当前激活的审核服务
+	service := h.moderationManager.GetService()
+	// 执行文本审核
+	result, err := service.Moderate(data.Text)
+	if err != nil {
+		resp.ERROR(c, "审核服务调用失败: "+err.Error())
+		return
+	}
+
+	// 转换为前端需要的格式
+	testResult := ModerationTestResult{
+		IsAbnormal: result.Flagged,
+		Details:    make([]ModerationTestDetail, 0),
+	}
+
+	// 构建详细信息
+	for category, description := range types.ModerationCategories {
+		score := result.CategoryScores[category]
+		isCategory := result.Categories[category]
+
+		testResult.Details = append(testResult.Details, ModerationTestDetail{
+			Category:    category,
+			Description: description,
+			Confidence:  fmt.Sprintf("%.2f", score),
+			IsCategory:  isCategory,
+		})
+	}
+
+	resp.SUCCESS(c, testResult)
+}

api/handler/admin/order_handler.go

@@ -29,6 +29,14 @@ func NewOrderHandler(app *core.AppServer, db *gorm.DB) *OrderHandler {
 	return &OrderHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
 }
 
+// RegisterRoutes 注册路由
+func (h *OrderHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/admin/order/")
+	group.POST("list", h.List)
+	group.GET("remove", h.Remove)
+	group.GET("clear", h.Clear)
+}
+
 func (h *OrderHandler) List(c *gin.Context) {
 	var data struct {
 		OrderNo  string   `json:"order_no"`
@@ -68,16 +76,16 @@ func (h *OrderHandler) List(c *gin.Context) {
 				order.Id = item.Id
 				order.CreatedAt = item.CreatedAt.Unix()
 				order.UpdatedAt = item.UpdatedAt.Unix()
-				payMethod, ok := types.PayMethods[item.PayWay]
+				payChannel, ok := types.PayChannel[item.Channel]
 				if !ok {
-					payMethod = item.PayWay
+					payChannel = item.Channel
 				}
-				payName, ok := types.PayNames[item.PayType]
+				payWays, ok := types.PayWays[item.PayWay]
 				if !ok {
-					payName = item.PayWay
+					payWays = item.PayWay
 				}
-				order.PayMethod = payMethod
-				order.PayName = payName
+				order.ChannelName = payChannel
+				order.PayName = payWays
 				list = append(list, order)
 			} else {
 				logger.Error(err)
@@ -121,8 +129,8 @@ func (h *OrderHandler) Clear(c *gin.Context) {
 	}
 	deleteIds := make([]uint, 0)
 	for _, order := range orders {
-		// 只删除 15 分钟内的未支付订单
-		if time.Now().After(order.CreatedAt.Add(time.Minute * 15)) {
+		// 只删除超时的未支付订单
+		if time.Now().After(order.CreatedAt.Add(time.Minute * time.Duration(h.App.SysConfig.Base.OrderPayTimeout))) {
 			deleteIds = append(deleteIds, order.Id)
 		}
 	}

api/handler/admin/power_log_handler.go

@@ -28,6 +28,12 @@ func NewPowerLogHandler(app *core.AppServer, db *gorm.DB) *PowerLogHandler {
 	return &PowerLogHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
 }
 
+// RegisterRoutes 注册路由
+func (h *PowerLogHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/admin/powerLog/")
+	group.POST("list", h.List)
+}
+
 func (h *PowerLogHandler) List(c *gin.Context) {
 	var data struct {
 		Username string   `json:"username"`

api/handler/admin/product_handler.go

@@ -15,9 +15,10 @@ import (
 	"geekai/store/vo"
 	"geekai/utils"
 	"geekai/utils/resp"
+	"time"
+
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
-	"time"
 )
 
 type ProductHandler struct {
@@ -28,14 +29,22 @@ func NewProductHandler(app *core.AppServer, db *gorm.DB) *ProductHandler {
 	return &ProductHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
 }
 
+// RegisterRoutes 注册路由
+func (h *ProductHandler) RegisterRoutes() {
+	group := h.App.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)
+}
+
 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"`
 	}
@@ -45,12 +54,10 @@ func (h *ProductHandler) Save(c *gin.Context) {
 	}
 
 	item := model.Product{
-		Name:     data.Name,
-		Price:    data.Price,
-		Discount: data.Discount,
-		Days:     data.Days,
-		Power:    data.Power,
-		Enabled:  data.Enabled}
+		Name:    data.Name,
+		Price:   data.Price,
+		Power:   data.Power,
+		Enabled: data.Enabled}
 	item.Id = data.Id
 	if item.Id > 0 {
 		item.CreatedAt = time.Unix(data.CreatedAt, 0)

api/handler/admin/redeem_handler.go

@@ -29,6 +29,16 @@ func NewRedeemHandler(app *core.AppServer, db *gorm.DB) *RedeemHandler {
 	return &RedeemHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
 }
 
+// RegisterRoutes 注册路由
+func (h *RedeemHandler) RegisterRoutes() {
+	group := h.App.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)
+}
+
 func (h *RedeemHandler) List(c *gin.Context) {
 	page := h.GetInt(c, "page", 1)
 	pageSize := h.GetInt(c, "page_size", 20)

api/handler/admin/upload_handler.go

@@ -9,6 +9,7 @@ package admin
 
 import (
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/handler"
 	"geekai/service/oss"
 	"geekai/store/model"
@@ -28,6 +29,17 @@ func NewUploadHandler(app *core.AppServer, db *gorm.DB, manager *oss.UploaderMan
 	return &UploadHandler{BaseHandler: handler.BaseHandler{DB: db, App: app}, uploaderManager: manager}
 }
 
+// RegisterRoutes 注册路由
+func (h *UploadHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/admin/upload")
+
+	// 需要管理员授权的接口
+	group.Use(middleware.AdminAuthMiddleware(h.App.Config.AdminSession.SecretKey, h.App.Redis))
+	{
+		group.POST("", h.Upload)
+	}
+}
+
 func (h *UploadHandler) Upload(c *gin.Context) {
 	// 判断文件大小
 	f, err := c.FormFile("file")
@@ -36,7 +48,7 @@ func (h *UploadHandler) Upload(c *gin.Context) {
 		return
 	}
 
-	if h.App.SysConfig.MaxFileSize > 0 && f.Size > int64(h.App.SysConfig.MaxFileSize)*1024*1024 {
+	if h.App.SysConfig.Base.MaxFileSize > 0 && f.Size > int64(h.App.SysConfig.Base.MaxFileSize)*1024*1024 {
 		resp.ERROR(c, "文件大小超过限制")
 		return
 	}

api/handler/admin/user_handler.go

@@ -10,30 +10,44 @@ package admin
 import (
 	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/handler"
-	"geekai/service"
 	"geekai/store/model"
 	"geekai/store/vo"
 	"geekai/utils"
 	"geekai/utils/resp"
 	"time"
 
+	"github.com/gin-gonic/gin"
 	"github.com/go-redis/redis/v8"
 	"github.com/golang-jwt/jwt/v5"
-
-	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
 )
 
 type UserHandler struct {
 	handler.BaseHandler
-	licenseService *service.LicenseService
-	redis          *redis.Client
+	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}
+func NewUserHandler(app *core.AppServer, db *gorm.DB, redisCli *redis.Client) *UserHandler {
+	return &UserHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}, redis: redisCli}
+}
+
+// RegisterRoutes 注册路由
+func (h *UserHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/admin/user/")
+
+	// 需要管理员授权的接口
+	group.Use(middleware.AdminAuthMiddleware(h.App.Config.AdminSession.SecretKey, h.App.Redis))
+	{
+		group.GET("list", h.List)
+		group.POST("save", h.Save)
+		group.GET("remove", h.Remove)
+		group.GET("loginLog", h.LoginLog)
+		group.GET("genLoginLink", h.GenLoginLink)
+		group.POST("resetPass", h.ResetPass)
+	}
 }
 
 // List 用户列表
@@ -98,13 +112,6 @@ func (h *UserHandler) Save(c *gin.Context) {
 		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
@@ -182,11 +189,7 @@ func (h *UserHandler) Save(c *gin.Context) {
 			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))
-		}
+		u.Nickname = fmt.Sprintf("用户@%d", utils.RandomNumber(6))
 		res = h.DB.Create(&u)
 		_ = utils.CopyObject(u, &userVo)
 		userVo.Id = u.Id

api/handler/base_handler.go

@@ -15,9 +15,10 @@ import (
 	logger2 "geekai/logger"
 	"geekai/store/model"
 	"geekai/utils"
-	"gorm.io/gorm"
 	"strings"
 
+	"gorm.io/gorm"
+
 	"github.com/gin-gonic/gin"
 )
 
@@ -69,6 +70,14 @@ func (h *BaseHandler) GetLoginUserId(c *gin.Context) uint {
 	return uint(utils.IntValue(utils.InterfaceToString(userId), 0))
 }
 
+func (h *BaseHandler) GetAdminId(c *gin.Context) uint {
+	userId, ok := c.Get(types.AdminUserID)
+	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
 }

api/handler/captcha_handler.go

@@ -8,23 +8,45 @@ package handler
 // * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 import (
+	"geekai/core"
 	"geekai/core/types"
 	"geekai/service"
 	"geekai/utils/resp"
+
 	"github.com/gin-gonic/gin"
 )
 
-// 今日头条函数实现
-
 type CaptchaHandler struct {
+	App     *core.AppServer
 	service *service.CaptchaService
 }
 
-func NewCaptchaHandler(s *service.CaptchaService) *CaptchaHandler {
-	return &CaptchaHandler{service: s}
+func NewCaptchaHandler(app *core.AppServer, s *service.CaptchaService, sysConfig *types.SystemConfig) *CaptchaHandler {
+	return &CaptchaHandler{App: app, service: s}
+}
+
+// RegisterRoutes 注册路由
+func (h *CaptchaHandler) RegisterRoutes() {
+	group := h.App.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)
+	group.GET("config", h.GetConfig)
+}
+
+func (h *CaptchaHandler) GetConfig(c *gin.Context) {
+	resp.SUCCESS(c, gin.H{"enabled": h.service.GetConfig().Enabled, "type": h.service.GetConfig().Type})
 }
 
 func (h *CaptchaHandler) Get(c *gin.Context) {
+	if !h.service.GetConfig().Enabled {
+		resp.ERROR(c, "验证码服务未启用")
+		return
+	}
+
 	data, err := h.service.Get()
 	if err != nil {
 		resp.ERROR(c, err.Error())
@@ -36,6 +58,11 @@ func (h *CaptchaHandler) Get(c *gin.Context) {
 
 // Check verify the captcha data
 func (h *CaptchaHandler) Check(c *gin.Context) {
+	if !h.service.GetConfig().Enabled {
+		resp.ERROR(c, "验证码服务未启用")
+		return
+	}
+
 	var data struct {
 		Key  string `json:"key"`
 		Dots string `json:"dots"`
@@ -55,6 +82,11 @@ func (h *CaptchaHandler) Check(c *gin.Context) {
 
 // SlideGet 获取滑动验证图片
 func (h *CaptchaHandler) SlideGet(c *gin.Context) {
+	if !h.service.GetConfig().Enabled {
+		resp.ERROR(c, "验证码服务未启用")
+		return
+	}
+
 	data, err := h.service.SlideGet()
 	if err != nil {
 		resp.ERROR(c, err.Error())
@@ -66,6 +98,11 @@ func (h *CaptchaHandler) SlideGet(c *gin.Context) {
 
 // SlideCheck 滑动验证结果校验
 func (h *CaptchaHandler) SlideCheck(c *gin.Context) {
+	if !h.service.GetConfig().Enabled {
+		resp.ERROR(c, "验证码服务未启用")
+		return
+	}
+
 	var data struct {
 		Key string `json:"key"`
 		X   int    `json:"x"`

api/handler/chat_app_handler.go

@@ -9,6 +9,7 @@ package handler
 
 import (
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/store/model"
 	"geekai/store/vo"
@@ -19,18 +20,31 @@ import (
 	"gorm.io/gorm"
 )
 
-type ChatRoleHandler struct {
+type ChatAppHandler struct {
 	BaseHandler
 }
 
-func NewChatRoleHandler(app *core.AppServer, db *gorm.DB) *ChatRoleHandler {
-	return &ChatRoleHandler{BaseHandler: BaseHandler{App: app, DB: db}}
+func NewChatAppHandler(app *core.AppServer, db *gorm.DB) *ChatAppHandler {
+	return &ChatAppHandler{BaseHandler: BaseHandler{App: app, DB: db}}
+}
+
+// RegisterRoutes 注册路由
+func (h *ChatAppHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/app/")
+	group.GET("list", h.List)
+
+	// 需要用户授权的接口
+	group.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis))
+	{
+		group.GET("list/user", h.ListByUser)
+		group.POST("update", h.UpdateApp)
+	}
 }
 
 // List 获取用户聊天应用列表
-func (h *ChatRoleHandler) List(c *gin.Context) {
+func (h *ChatAppHandler) List(c *gin.Context) {
 	tid := h.GetInt(c, "tid", 0)
-	var roles []model.ChatRole
+	var roles []model.ChatApp
 	session := h.DB.Where("enable", true)
 	if tid > 0 {
 		session = session.Where("tid", tid)
@@ -41,9 +55,9 @@ func (h *ChatRoleHandler) List(c *gin.Context) {
 		return
 	}
 
-	var roleVos = make([]vo.ChatRole, 0)
+	var roleVos = make([]vo.ChatApp, 0)
 	for _, r := range roles {
-		var v vo.ChatRole
+		var v vo.ChatApp
 		err := utils.CopyObject(r, &v)
 		if err == nil {
 			v.Id = r.Id
@@ -54,10 +68,10 @@ func (h *ChatRoleHandler) List(c *gin.Context) {
 }
 
 // ListByUser 获取用户添加的角色列表
-func (h *ChatRoleHandler) ListByUser(c *gin.Context) {
+func (h *ChatAppHandler) ListByUser(c *gin.Context) {
 	id := h.GetInt(c, "id", 0)
 	userId := h.GetLoginUserId(c)
-	var roles []model.ChatRole
+	var roles []model.ChatApp
 	session := h.DB.Where("enable", true)
 	// 如果用户没登录，则获取所有角色
 	if userId > 0 {
@@ -86,9 +100,9 @@ func (h *ChatRoleHandler) ListByUser(c *gin.Context) {
 		return
 	}
 
-	var roleVos = make([]vo.ChatRole, 0)
+	var roleVos = make([]vo.ChatApp, 0)
 	for _, r := range roles {
-		var v vo.ChatRole
+		var v vo.ChatApp
 		err := utils.CopyObject(r, &v)
 		if err == nil {
 			v.Id = r.Id
@@ -98,8 +112,8 @@ func (h *ChatRoleHandler) ListByUser(c *gin.Context) {
 	resp.SUCCESS(c, roleVos)
 }
 
-// UpdateRole 更新用户聊天角色
-func (h *ChatRoleHandler) UpdateRole(c *gin.Context) {
+// UpdateApp 更新用户聊天应用
+func (h *ChatAppHandler) UpdateApp(c *gin.Context) {
 	user, err := h.GetLoginUser(c)
 	if err != nil {
 		resp.NotAuth(c)

api/handler/chat_app_type_handler.go

@@ -19,6 +19,12 @@ func NewChatAppTypeHandler(app *core.AppServer, db *gorm.DB) *ChatAppTypeHandler
 	return &ChatAppTypeHandler{BaseHandler: BaseHandler{App: app, DB: db}}
 }
 
+// RegisterRoutes 注册路由
+func (h *ChatAppTypeHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/app/type/")
+	group.GET("list", h.List)
+}
+
 // List 获取App类型列表
 func (h *ChatAppTypeHandler) List(c *gin.Context) {
 	var items []model.AppType

api/handler/chat_handler.go

@@ -14,9 +14,12 @@ import (
 	"errors"
 	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/service"
+	"geekai/service/moderation"
 	"geekai/service/oss"
+	"geekai/service/sora"
 	"geekai/store/model"
 	"geekai/store/vo"
 	"geekai/utils"
@@ -39,6 +42,7 @@ import (
 const (
 	ChatEventStart        = "start"
 	ChatEventEnd          = "end"
+	ChatEventComplete     = "complete"
 	ChatEventError        = "error"
 	ChatEventMessageDelta = "message_delta"
 	ChatEventTitle        = "title"
@@ -54,44 +58,82 @@ type ChatInput struct {
 	Stream    bool            `json:"stream"`
 	Files     []vo.File       `json:"files"`
 	ChatModel model.ChatModel `json:"chat_model,omitempty"`
-	ChatRole  model.ChatRole  `json:"chat_role,omitempty"`
+	ChatRole  model.ChatApp   `json:"chat_role,omitempty"`
 	LastMsgId uint            `json:"last_msg_id,omitempty"` // 最后的消息ID，用于重新生成答案的时候过滤上下文
 }
 
 type ChatHandler struct {
 	BaseHandler
-	redis          *redis.Client
-	uploadManager  *oss.UploaderManager
-	licenseService *service.LicenseService
-	ReqCancelFunc  *types.LMap[string, context.CancelFunc] // HttpClient 请求取消 handle function
-	userService    *service.UserService
+	redis             *redis.Client
+	uploadManager     *oss.UploaderManager
+	ReqCancelFunc     *types.LMap[string, context.CancelFunc] // HttpClient 请求取消 handle function
+	userService       *service.UserService
+	moderationManager *moderation.ServiceManager
+	userLocks         *types.UserLockManager
+	soraService       *sora.SoraService
 }
 
-func NewChatHandler(app *core.AppServer, db *gorm.DB, redis *redis.Client, manager *oss.UploaderManager, licenseService *service.LicenseService, userService *service.UserService) *ChatHandler {
+func NewChatHandler(app *core.AppServer,
+	db *gorm.DB,
+	redis *redis.Client,
+	manager *oss.UploaderManager,
+	userService *service.UserService,
+	soraService *sora.SoraService,
+	moderationManager *moderation.ServiceManager) *ChatHandler {
 	return &ChatHandler{
-		BaseHandler:    BaseHandler{App: app, DB: db},
-		redis:          redis,
-		uploadManager:  manager,
-		licenseService: licenseService,
-		ReqCancelFunc:  types.NewLMap[string, context.CancelFunc](),
-		userService:    userService,
+		BaseHandler:       BaseHandler{App: app, DB: db},
+		redis:             redis,
+		uploadManager:     manager,
+		ReqCancelFunc:     types.NewLMap[string, context.CancelFunc](),
+		userService:       userService,
+		moderationManager: moderationManager,
+		userLocks:         types.NewUserLockManager(),
+		soraService:       soraService,
+	}
+}
+
+// RegisterRoutes 注册路由
+func (h *ChatHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/chat/")
+	// 其他接口需要用户授权
+	group.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis))
+	{
+		group.Any("message", h.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)
+		group.POST("tts", h.TextToSpeech)
 	}
 }
 
 // Chat 处理聊天请求
 func (h *ChatHandler) Chat(c *gin.Context) {
-	var input ChatInput
-	if err := c.ShouldBindJSON(&input); err != nil {
-		resp.ERROR(c, types.InvalidArgs)
-		return
-	}
-
 	// 设置SSE响应头
 	c.Header("Prompt-Type", "text/event-stream")
 	c.Header("Cache-Control", "no-cache")
 	c.Header("Connection", "keep-alive")
 	c.Header("X-Accel-Buffering", "no")
 
+	var input ChatInput
+	if err := c.ShouldBindJSON(&input); err != nil {
+		pushMessage(c, ChatEventError, types.InvalidArgs)
+		c.Abort()
+		return
+	}
+
+	// 用户级并发锁，确保同一用户同时只有一个对话请求
+	if !h.userLocks.TryLock(input.UserId) {
+		pushMessage(c, ChatEventError, "您有一个对话请求正在进行中，请稍后再试或先停止当前生成！")
+		c.Abort()
+		return
+	}
+	defer h.userLocks.Unlock(input.UserId)
+
 	ctx, cancel := context.WithCancel(c.Request.Context())
 	defer cancel()
 
@@ -113,7 +155,7 @@ func (h *ChatHandler) Chat(c *gin.Context) {
 	}
 
 	// 验证聊天角色
-	var chatRole model.ChatRole
+	var chatRole model.ChatApp
 	err := h.DB.First(&chatRole, input.RoleId).Error
 	if err != nil || !chatRole.Enable {
 		pushMessage(c, ChatEventError, "当前聊天角色不存在或者未启用，请更换角色之后再发起对话！")
@@ -166,7 +208,7 @@ func (h *ChatHandler) sendMessage(ctx context.Context, input ChatInput, c *gin.C
 	}
 
 	if userVo.Power < input.ChatModel.Power {
-		return fmt.Errorf("您当前剩余算力 %d 已不足以支付当前模型的单次对话需要消耗的算力 %d，[立即购买](/member)。", userVo.Power, input.ChatModel.Power)
+		return fmt.Errorf("您的算力不足，请购买算力。")
 	}
 
 	if userVo.ExpiredTime > 0 && userVo.ExpiredTime <= time.Now().Unix() {
@@ -229,17 +271,24 @@ func (h *ChatHandler) sendMessage(ctx context.Context, input ChatInput, c *gin.C
 	// 加载聊天上下文
 	chatCtx := make([]any, 0)
 	messages := make([]any, 0)
-	if h.App.SysConfig.EnableContext {
+	if h.App.SysConfig.Base.EnableContext {
 		_ = utils.JsonDecode(input.ChatRole.Context, &messages)
-		if h.App.SysConfig.ContextDeep > 0 {
+		if h.App.SysConfig.Base.ContextDeep > 0 {
 			var historyMessages []model.ChatMessage
 			dbSession := h.DB.Session(&gorm.Session{}).Where("chat_id", input.ChatId)
-			if input.LastMsgId > 0 { // 重新生成逻辑
+			if input.LastMsgId > 0 { // 重新生成和编辑逻辑
+				var lastMessage model.ChatMessage
+				err = dbSession.Where("id < ?", input.LastMsgId).Where("type", types.ReplyMsg).Order("id DESC").First(&lastMessage).Error
+				if err != nil {
+					input.LastMsgId = 0
+				} else {
+					input.LastMsgId = lastMessage.Id
+				}
 				dbSession = dbSession.Where("id < ?", input.LastMsgId)
 				// 删除对应的聊天记录
-				h.DB.Debug().Where("chat_id", input.ChatId).Where("id >= ?", input.LastMsgId).Delete(&model.ChatMessage{})
+				h.DB.Debug().Where("chat_id", input.ChatId).Where("id > ?", input.LastMsgId).Delete(&model.ChatMessage{})
 			}
-			err = dbSession.Limit(h.App.SysConfig.ContextDeep).Order("id DESC").Find(&historyMessages).Error
+			err = dbSession.Limit(h.App.SysConfig.Base.ContextDeep).Order("id DESC").Find(&historyMessages).Error
 			if err == nil {
 				for i := len(historyMessages) - 1; i >= 0; i-- {
 					msg := historyMessages[i]
@@ -267,7 +316,7 @@ func (h *ChatHandler) sendMessage(ctx context.Context, input ChatInput, c *gin.C
 			}
 
 			// 上下文的深度超出了模型的最大上下文深度
-			if len(chatCtx) >= h.App.SysConfig.ContextDeep {
+			if len(chatCtx) >= h.App.SysConfig.Base.ContextDeep {
 				break
 			}
 
@@ -277,6 +326,14 @@ func (h *ChatHandler) sendMessage(ctx context.Context, input ChatInput, c *gin.C
 	}
 	reqMgs := make([]any, 0)
 
+	// 添加引导提示词,防止模型生成违规内容
+	if h.App.SysConfig.Moderation.EnableGuide {
+		reqMgs = append(reqMgs, map[string]any{
+			"role":    "system",
+			"content": h.App.SysConfig.Moderation.GuidePrompt,
+		})
+	}
+
 	for i := len(chatCtx) - 1; i >= 0; i-- {
 		reqMgs = append(reqMgs, chatCtx[i])
 	}
@@ -287,24 +344,22 @@ func (h *ChatHandler) sendMessage(ctx context.Context, input ChatInput, c *gin.C
 	for _, file := range input.Files {
 		logger.Debugf("detected file: %+v", file.URL)
 		// 处理图片
-		if isImageURL(file.URL) {
+		if isImageURL(file.URL) || isVideoURL(file.URL) {
 			imgList = append(imgList, gin.H{
 				"type": "image_url",
 				"image_url": gin.H{
 					"url": file.URL,
 				},
 			})
-		} else {
-			// 如果不是逆向模型，则提取文件内容
-			modelValue := input.ChatModel.Value
-			if !(strings.Contains(modelValue, "-all") || strings.HasPrefix(modelValue, "gpt-4-gizmo") || strings.HasPrefix(modelValue, "claude")) {
-				content, err := utils.ReadFileContent(file.URL, h.App.Config.TikaHost)
-				if err != nil {
-					logger.Error("error with read file: ", err)
-					continue
-				} else {
-					fileContents = append(fileContents, fmt.Sprintf("%s 文件内容：%s", file.Name, content))
-				}
+		} else if isTextURL(file.URL) {
+			// 处理文件，提取文件内容
+			content, err := utils.ReadFileContent(file.URL, h.App.Config.TikaHost)
+			if err != nil {
+				logger.Error("error with read file: ", err)
+				continue
+			} else {
+				fileContents = append(fileContents, fmt.Sprintf("%s 文件内容：%s", file.Name, content))
+				logger.Debugf("fileContents: %s", fileContents)
 			}
 		}
 	}
@@ -320,16 +375,16 @@ func (h *ChatHandler) sendMessage(ctx context.Context, input ChatInput, c *gin.C
 	}
 
 	if len(imgList) > 0 {
-		imgList = append(imgList, map[string]interface{}{
+		imgList = append(imgList, map[string]any{
 			"type": "text",
 			"text": input.Prompt,
 		})
-		req.Messages = append(reqMgs, map[string]interface{}{
+		req.Messages = append(reqMgs, map[string]any{
 			"role":    "user",
 			"content": imgList,
 		})
 	} else {
-		req.Messages = append(reqMgs, map[string]interface{}{
+		req.Messages = append(reqMgs, map[string]any{
 			"role":    "user",
 			"content": finalPrompt,
 		})
@@ -357,23 +412,43 @@ func isImageURL(url string) bool {
 		".svg":  true,
 		".ico":  true,
 	}
+	return validImageExts[ext]
+}
 
-	if !validImageExts[ext] {
+// 判断是个链接是否是文本链接
+func isTextURL(url string) bool {
+	// 检查是否是有效的URL
+	if !strings.HasPrefix(url, "http://") && !strings.HasPrefix(url, "https://") {
 		return false
 	}
 
-	// 发送HEAD请求检查Content-Type
-	client := &http.Client{
-		Timeout: 5 * time.Second,
+	// 检查文件扩展名
+	ext := strings.ToLower(path.Ext(url))
+	validTextExts := map[string]bool{
+		".txt":  true,
+		".doc":  true,
+		".docx": true,
+		".pdf":  true,
 	}
-	resp, err := client.Head(url)
-	if err != nil {
+	return validTextExts[ext]
+}
+
+// 判断是个链接是否是视频
+func isVideoURL(url string) bool {
+	// 检查是否是有效的URL
+	if !strings.HasPrefix(url, "http://") && !strings.HasPrefix(url, "https://") {
 		return false
 	}
-	defer resp.Body.Close()
 
-	contentType := resp.Header.Get("Content-Type")
-	return strings.HasPrefix(contentType, "image/")
+	// 检查文件扩展名
+	ext := strings.ToLower(path.Ext(url))
+	validVideoExts := map[string]bool{
+		".mp4": true,
+		".avi": true,
+		".mov": true,
+		".wmv": true,
+	}
+	return validVideoExts[ext]
 }
 
 // Tokens 统计 token 数量
@@ -445,7 +520,7 @@ func (h *ChatHandler) StopGenerate(c *gin.Context) {
 func (h *ChatHandler) doRequest(ctx context.Context, req types.ApiRequest, input ChatInput, apiKey *model.ApiKey) (*http.Response, error) {
 	// if the chat model bind a KEY, use it directly
 	if input.ChatModel.KeyId > 0 {
-		h.DB.Where("id", input.ChatModel.KeyId).Find(apiKey)
+		h.DB.Where("id", input.ChatModel.KeyId).Where("enabled", true).Find(apiKey)
 	} else { // use the last unused key
 		h.DB.Where("type", "chat").Where("enabled", true).Order("last_used_at ASC").First(apiKey)
 	}
@@ -454,11 +529,6 @@ func (h *ChatHandler) doRequest(ctx context.Context, req types.ApiRequest, input
 		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)
 	var apiURL string
 	p, _ := url.Parse(apiKey.ApiURL)
@@ -516,6 +586,7 @@ func (h *ChatHandler) subUserPower(userVo vo.User, input ChatInput, promptTokens
 }
 
 func (h *ChatHandler) saveChatHistory(
+	c *gin.Context,
 	req types.ApiRequest,
 	usage Usage,
 	message types.Message,
@@ -524,6 +595,34 @@ func (h *ChatHandler) saveChatHistory(
 	promptCreatedAt time.Time,
 	replyCreatedAt time.Time) {
 
+	// 文本审核
+	if h.App.SysConfig.Moderation.Enable {
+		moderationResult, err := h.moderationManager.GetService().Moderate(usage.Content)
+		if err != nil {
+			logger.Error("failed to moderate content: ", err)
+		}
+		logger.Debugf("moderationResult: %+v", moderationResult)
+		if moderationResult.Flagged {
+			// 记录违规内容
+			moderation := model.Moderation{
+				UserId: userVo.Id,
+				Source: types.ModerationSourceChat,
+				Input:  usage.Prompt,
+				Output: usage.Content,
+				Result: utils.JsonEncode(moderationResult),
+			}
+			err = h.DB.Create(&moderation).Error
+			if err != nil {
+				logger.Error("failed to save moderation: ", err)
+			}
+			pushMessage(c, ChatEventError, "很抱歉，内容触发敏感词预警，AI 无法回答！！！")
+			// 更新用户算力
+			if input.ChatModel.Power > 0 {
+				h.subUserPower(userVo, input, 0, 0)
+			}
+			return
+		}
+	}
 	// 追加聊天记录
 	// for prompt
 	var promptTokens, replyTokens, totalTokens int
@@ -564,6 +663,16 @@ func (h *ChatHandler) saveChatHistory(
 		replyTokens, _ = utils.CalcTokens(message.Content, req.Model)
 		totalTokens = replyTokens + getTotalTokens(req)
 	}
+
+	// 如果是 Sora 相关模型，则下载视频
+	files := make([]vo.File, 0)
+	if strings.HasPrefix(req.Model, "sora") {
+		video, err := h.soraService.DownloadVideoURL(message.Content)
+		if err == nil {
+			files = append(files, *video)
+		}
+	}
+
 	historyReplyMsg := model.ChatMessage{
 		UserId: userVo.Id,
 		ChatId: input.ChatId,
@@ -572,7 +681,7 @@ func (h *ChatHandler) saveChatHistory(
 		Icon:   input.ChatRole.Icon,
 		Content: utils.JsonEncode(vo.MsgContent{
 			Text:  message.Content,
-			Files: input.Files,
+			Files: files,
 		}),
 		Tokens:      replyTokens,
 		TotalTokens: totalTokens,
@@ -586,6 +695,23 @@ func (h *ChatHandler) saveChatHistory(
 		logger.Error("failed to save reply history message: ", err)
 	}
 
+	// 发送完整聊天记录给前端
+	var messageVo vo.ChatMessage
+	err = utils.CopyObject(historyReplyMsg, &messageVo)
+	if err == nil {
+		// 解析内容
+		var content vo.MsgContent
+		err = utils.JsonDecode(historyReplyMsg.Content, &content)
+		if err != nil {
+			content.Text = historyReplyMsg.Content
+		}
+		content.Files = files
+		messageVo.Content = content
+		messageVo.CreatedAt = historyReplyMsg.CreatedAt.Unix()
+		messageVo.UpdatedAt = historyReplyMsg.UpdatedAt.Unix()
+		pushMessage(c, ChatEventComplete, messageVo)
+	}
+
 	// 更新用户算力
 	if input.ChatModel.Power > 0 {
 		h.subUserPower(userVo, input, promptTokens, replyTokens)
@@ -710,221 +836,3 @@ func (h *ChatHandler) TextToSpeech(c *gin.Context) {
 		logger.Error("写入音频数据到响应失败:", err)
 	}
 }
-
-// // OPenAI 消息发送实现
-// func (h *ChatHandler) sendOpenAiMessage(
-// 	req types.ApiRequest,
-// 	userVo vo.User,
-// 	ctx context.Context,
-// 	session *types.ChatSession,
-// 	role model.ChatRole,
-// 	prompt string,
-// 	c *gin.Context) error {
-// 	promptCreatedAt := time.Now() // 记录提问时间
-// 	start := time.Now()
-// 	var apiKey = model.ApiKey{}
-// 	response, err := h.doRequest(ctx, req, session, &apiKey)
-// 	logger.Info("HTTP请求完成，耗时：", time.Since(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("Prompt-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)
-// 		var reasoning = false
-
-// 		pushMessage(c, ChatEventStart, "开始响应")
-// 		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.Prompt == nil &&
-// 				responseBody.Choices[0].Delta.ToolCalls == nil &&
-// 				responseBody.Choices[0].Delta.ReasoningContent == "" {
-// 				continue
-// 			}
-
-// 			if responseBody.Choices[0].FinishReason == "stop" && len(contents) == 0 {
-// 				pushMessage(c, ChatEventError, "抱歉😔😔😔，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)
-// 					pushMessage(c, ChatEventMessageDelta, map[string]interface{}{
-// 						"type":    "text",
-// 						"content": 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 { // 正常输出结果
-// 				// 兼容思考过程
-// 				if responseBody.Choices[0].Delta.ReasoningContent != "" {
-// 					reasoningContent := responseBody.Choices[0].Delta.ReasoningContent
-// 					if !reasoning {
-// 						reasoningContent = fmt.Sprintf("<think>%s", reasoningContent)
-// 						reasoning = true
-// 					}
-
-// 					pushMessage(c, ChatEventMessageDelta, map[string]interface{}{
-// 						"type":    "text",
-// 						"content": reasoningContent,
-// 					})
-// 					contents = append(contents, reasoningContent)
-// 				} else if responseBody.Choices[0].Delta.Prompt != "" {
-// 					finalContent := responseBody.Choices[0].Delta.Prompt
-// 					if reasoning {
-// 						finalContent = fmt.Sprintf("</think>%s", responseBody.Choices[0].Delta.Prompt)
-// 						reasoning = false
-// 					}
-// 					contents = append(contents, utils.InterfaceToString(finalContent))
-// 					pushMessage(c, ChatEventMessageDelta, map[string]interface{}{
-// 						"type":    "text",
-// 						"content": finalContent,
-// 					})
-// 				}
-// 			}
-// 		} // 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]any)
-// 			_ = 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)
-// 			}
-// 			pushMessage(c, ChatEventMessageDelta, map[string]interface{}{
-// 				"type":    "text",
-// 				"content": errMsg,
-// 			})
-// 		}
-
-// 		// 消息发送成功
-// 		if len(contents) > 0 {
-// 			usage := Usage{
-// 				Prompt:           prompt,
-// 				Prompt:          strings.Join(contents, ""),
-// 				PromptTokens:     0,
-// 				CompletionTokens: 0,
-// 				TotalTokens:      0,
-// 			}
-// 			message.Prompt = usage.Prompt
-// 			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.Prompt
-// 		if strings.HasPrefix(req.Model, "o1-") {
-// 			content = fmt.Sprintf("AI思考结束，耗时：%d 秒。\n%s", time.Now().Unix()-session.Start, respVo.Choices[0].Message.Prompt)
-// 		}
-// 		pushMessage(c, ChatEventMessageDelta, map[string]interface{}{
-// 			"type":    "text",
-// 			"content": content,
-// 		})
-// 		respVo.Usage.Prompt = prompt
-// 		respVo.Usage.Prompt = content
-// 		h.saveChatHistory(req, respVo.Usage, respVo.Choices[0].Message, session, role, userVo, promptCreatedAt, time.Now())
-// 	}
-
-// 	return nil
-// }

api/handler/chat_item_handler.go

@@ -42,9 +42,9 @@ func (h *ChatHandler) List(c *gin.Context) {
 		modelValues = append(modelValues, chat.Model)
 	}
 
-	var roles []model.ChatRole
+	var roles []model.ChatApp
 	var models []model.ChatModel
-	roleMap := make(map[uint]model.ChatRole)
+	roleMap := make(map[uint]model.ChatApp)
 	modelMap := make(map[string]model.ChatModel)
 	h.DB.Where("id IN ?", roleIds).Find(&roles)
 	h.DB.Where("value IN ?", modelValues).Find(&models)
@@ -205,7 +205,7 @@ func (h *ChatHandler) Detail(c *gin.Context) {
 	}
 
 	// 填充角色名称
-	var role model.ChatRole
+	var role model.ChatApp
 	res = h.DB.Where("id", chatItem.RoleId).First(&role)
 	if res.Error != nil {
 		resp.ERROR(c, "Role not found")

api/handler/chat_model_handler.go

@@ -26,6 +26,12 @@ func NewChatModelHandler(app *core.AppServer, db *gorm.DB) *ChatModelHandler {
 	return &ChatModelHandler{BaseHandler: BaseHandler{App: app, DB: db}}
 }
 
+// RegisterRoutes 注册路由
+func (h *ChatModelHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/model/")
+	group.GET("list", h.List)
+}
+
 // List 模型列表
 func (h *ChatModelHandler) List(c *gin.Context) {
 	var items []model.ChatModel

api/handler/chat_openai_handler.go

@@ -212,6 +212,14 @@ func (h *ChatHandler) sendOpenAiMessage(
 			} else {
 				errMsg = utils.InterfaceToString(apiRes.Data)
 				contents = append(contents, errMsg)
+				// 扣减算力
+				if function.Power > 0 {
+					h.userService.DecreasePower(userVo.Id, function.Power, model.PowerLog{
+						Type:   types.PowerConsume,
+						Model:  function.Name,
+						Remark: fmt.Sprintf("函数调用，%s(%s)", function.Label, function.Name),
+					})
+				}
 			}
 			pushMessage(c, "text", errMsg)
 		}
@@ -226,7 +234,7 @@ func (h *ChatHandler) sendOpenAiMessage(
 				TotalTokens:      0,
 			}
 			message.Content = usage.Content
-			h.saveChatHistory(req, usage, message, input, userVo, promptCreatedAt, replyCreatedAt)
+			h.saveChatHistory(c, req, usage, message, input, userVo, promptCreatedAt, replyCreatedAt)
 		}
 	} else { // 非流式输出
 		var respVo OpenAIResVo
@@ -242,7 +250,7 @@ func (h *ChatHandler) sendOpenAiMessage(
 		pushMessage(c, "text", content)
 		respVo.Usage.Prompt = input.Prompt
 		respVo.Usage.Content = content
-		h.saveChatHistory(req, respVo.Usage, respVo.Choices[0].Message, input, userVo, promptCreatedAt, time.Now())
+		h.saveChatHistory(c, req, respVo.Usage, respVo.Choices[0].Message, input, userVo, promptCreatedAt, time.Now())
 	}
 
 	return nil

api/handler/config_handler.go

@@ -9,7 +9,6 @@ package handler
 
 import (
 	"geekai/core"
-	"geekai/service"
 	"geekai/store/model"
 	"geekai/utils"
 	"geekai/utils/resp"
@@ -20,11 +19,18 @@ import (
 
 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}
+func NewConfigHandler(app *core.AppServer, db *gorm.DB) *ConfigHandler {
+	return &ConfigHandler{BaseHandler: BaseHandler{App: app, DB: db}}
+}
+
+// RegisterRoutes 注册路由
+func (h *ConfigHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/config/")
+
+	// 无需授权的接口
+	group.GET("get", h.Get)
 }
 
 // Get 获取指定的系统配置
@@ -46,9 +52,3 @@ func (h *ConfigHandler) Get(c *gin.Context) {
 
 	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

@@ -10,9 +10,11 @@ package handler
 import (
 	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/service"
 	"geekai/service/dalle"
+	"geekai/service/moderation"
 	"geekai/service/oss"
 	"geekai/store/model"
 	"geekai/store/vo"
@@ -25,16 +27,18 @@ import (
 
 type DallJobHandler struct {
 	BaseHandler
-	dallService *dalle.Service
-	uploader    *oss.UploaderManager
-	userService *service.UserService
+	dallService       *dalle.Service
+	uploader          *oss.UploaderManager
+	userService       *service.UserService
+	moderationManager *moderation.ServiceManager
 }
 
-func NewDallJobHandler(app *core.AppServer, db *gorm.DB, service *dalle.Service, manager *oss.UploaderManager, userService *service.UserService) *DallJobHandler {
+func NewDallJobHandler(app *core.AppServer, db *gorm.DB, service *dalle.Service, manager *oss.UploaderManager, userService *service.UserService, moderationManager *moderation.ServiceManager) *DallJobHandler {
 	return &DallJobHandler{
-		dallService: service,
-		uploader:    manager,
-		userService: userService,
+		dallService:       service,
+		uploader:          manager,
+		userService:       userService,
+		moderationManager: moderationManager,
 		BaseHandler: BaseHandler{
 			App: app,
 			DB:  db,
@@ -42,6 +46,24 @@ func NewDallJobHandler(app *core.AppServer, db *gorm.DB, service *dalle.Service,
 	}
 }
 
+// RegisterRoutes 注册路由
+func (h *DallJobHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/dall/")
+
+	// 公开接口，不需要授权
+	group.GET("imgWall", h.ImgWall)
+	group.GET("models", h.GetModels)
+
+	// 需要用户授权的接口
+	group.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis))
+	{
+		group.POST("image", h.Image)
+		group.GET("jobs", h.JobList)
+		group.GET("remove", h.Remove)
+		group.GET("publish", h.Publish)
+	}
+}
+
 // Image 创建一个绘画任务
 func (h *DallJobHandler) Image(c *gin.Context) {
 	var data types.DallTask
@@ -50,6 +72,29 @@ func (h *DallJobHandler) Image(c *gin.Context) {
 		return
 	}
 
+	// 文本审核
+	if h.App.SysConfig.Moderation.Enable {
+		moderationResult, err := h.moderationManager.GetService().Moderate(data.Prompt)
+		if err != nil {
+			logger.Error("failed to moderate content: ", err)
+		}
+		if moderationResult.Flagged {
+			// 记录违规内容
+			moderation := model.Moderation{
+				UserId: h.GetLoginUserId(c),
+				Source: types.ModerationSourceDalle,
+				Input:  data.Prompt,
+				Result: utils.JsonEncode(moderationResult),
+			}
+			err = h.DB.Create(&moderation).Error
+			if err != nil {
+				logger.Error("failed to save moderation: ", err)
+			}
+			resp.ERROR(c, "当前创作内容包含敏感词，提示词未通过文本审核，请重新输入！")
+			return
+		}
+	}
+
 	var chatModel model.ChatModel
 	if res := h.DB.Where("id = ?", data.ModelId).First(&chatModel); res.Error != nil {
 		resp.ERROR(c, "模型不存在")
@@ -72,12 +117,13 @@ func (h *DallJobHandler) Image(c *gin.Context) {
 	task := types.DallTask{
 		UserId:           uint(userId),
 		ModelId:          chatModel.Id,
-		ModelName:        chatModel.Value,
+		ModelName:        chatModel.Name,
+		ModelValue:       chatModel.Value,
+		Image:            data.Image,
 		Prompt:           data.Prompt,
-		Quality:          data.Quality,
+		AspectRatio:      data.AspectRatio,
 		Size:             data.Size,
-		Style:            data.Style,
-		TranslateModelId: h.App.SysConfig.AssistantModelId,
+		TranslateModelId: h.App.SysConfig.Base.AssistantModelId,
 		Power:            chatModel.Power,
 	}
 	job := model.DallJob{
@@ -98,7 +144,7 @@ func (h *DallJobHandler) Image(c *gin.Context) {
 	// 扣减算力
 	err = h.userService.DecreasePower(user.Id, chatModel.Power, model.PowerLog{
 		Type:   types.PowerConsume,
-		Model:  chatModel.Value,
+		Model:  chatModel.Name,
 		Remark: fmt.Sprintf("绘画提示词：%s", utils.CutWords(task.Prompt, 10)),
 	})
 	if err != nil {

api/handler/function_handler.go

@@ -13,7 +13,6 @@ import (
 	"geekai/core"
 	"geekai/core/types"
 	"geekai/service"
-	"geekai/service/crawler"
 	"geekai/service/dalle"
 	"geekai/service/oss"
 	"geekai/store/model"
@@ -31,7 +30,6 @@ import (
 
 type FunctionHandler struct {
 	BaseHandler
-	config        types.ApiConfig
 	uploadManager *oss.UploaderManager
 	dallService   *dalle.Service
 	userService   *service.UserService
@@ -49,13 +47,23 @@ func NewFunctionHandler(
 			App: server,
 			DB:  db,
 		},
-		config:        config.ApiConfig,
 		uploadManager: manager,
 		dallService:   dallService,
 		userService:   userService,
 	}
 }
 
+// RegisterRoutes 注册路由
+func (h *FunctionHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/function/")
+	group.GET("list", h.List)
+
+	// 需要用户授权的接口
+	group.POST("weibo", h.WeiBo)
+	group.POST("zaobao", h.ZaoBao)
+	group.POST("dalle3", h.Dall3)
+}
+
 type resVo struct {
 	Code    types.BizCode `json:"code"`
 	Message string        `json:"message"`
@@ -107,16 +115,10 @@ func (h *FunctionHandler) WeiBo(c *gin.Context) {
 		return
 	}
 
-	if h.config.Token == "" {
-		resp.ERROR(c, "无效的 API Token")
-		return
-	}
-
-	url := fmt.Sprintf("%s/api/weibo/fetch", h.config.ApiURL)
+	url := fmt.Sprintf("%s/api/weibo/fetch", types.GeekAPIURL)
 	var res resVo
 	r, err := req.C().R().
-		SetHeader("AppId", h.config.AppId).
-		SetHeader("Authorization", fmt.Sprintf("Bearer %s", h.config.Token)).
+		SetHeader("Authorization", "Bearer geekai-plus").
 		SetSuccessResult(&res).Get(url)
 	if err != nil {
 		resp.ERROR(c, fmt.Sprintf("%v", err))
@@ -146,16 +148,10 @@ func (h *FunctionHandler) ZaoBao(c *gin.Context) {
 		return
 	}
 
-	if h.config.Token == "" {
-		resp.ERROR(c, "无效的 API Token")
-		return
-	}
-
-	url := fmt.Sprintf("%s/api/zaobao/fetch", h.config.ApiURL)
+	url := fmt.Sprintf("%s/api/zaobao/fetch", types.GeekAPIURL)
 	var res resVo
 	r, err := req.C().R().
-		SetHeader("AppId", h.config.AppId).
-		SetHeader("Authorization", fmt.Sprintf("Bearer %s", h.config.Token)).
+		SetHeader("Authorization", "Bearer geekai-plus").
 		SetSuccessResult(&res).Get(url)
 	if err != nil {
 		resp.ERROR(c, fmt.Sprintf("%v", err))
@@ -193,16 +189,23 @@ func (h *FunctionHandler) Dall3(c *gin.Context) {
 		return
 	}
 
+	var chatModel model.ChatModel
+	res := h.DB.Where("type = ?", "img").Where("enabled", true).First(&chatModel)
+	if res.Error != nil {
+		resp.ERROR(c, "没有找到可用的AI绘图模型！")
+		return
+	}
+
 	logger.Debugf("绘画参数：%+v", params)
 	var user model.User
-	res := h.DB.Where("id = ?", params["user_id"]).First(&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 绘图任务失败，算力不足")
+	if user.Power < chatModel.Power {
+		resp.ERROR(c, "创建绘图任务失败，算力不足")
 		return
 	}
 
@@ -211,24 +214,21 @@ func (h *FunctionHandler) Dall3(c *gin.Context) {
 	task := types.DallTask{
 		UserId:           user.Id,
 		Prompt:           prompt,
-		ModelId:          0,
-		ModelName:        "dall-e-3",
-		TranslateModelId: h.App.SysConfig.AssistantModelId,
-		N:                1,
-		Quality:          "standard",
-		Size:             "1024x1024",
-		Style:            "vivid",
-		Power:            h.App.SysConfig.DallPower,
+		ModelId:          chatModel.Id,
+		ModelValue:       chatModel.Value,
+		ModelName:        chatModel.Name,
+		TranslateModelId: h.App.SysConfig.Base.AssistantModelId,
+		Power:            chatModel.Power,
 	}
 	job := model.DallJob{
 		UserId:   user.Id,
 		Prompt:   prompt,
-		Power:    h.App.SysConfig.DallPower,
+		Power:    chatModel.Power,
 		TaskInfo: utils.JsonEncode(task),
 	}
 	err := h.DB.Create(&job).Error
 	if err != nil {
-		resp.ERROR(c, "创建 DALL-E 绘图任务失败："+err.Error())
+		resp.ERROR(c, "创建绘图任务失败："+err.Error())
 		return
 	}
 
@@ -253,76 +253,6 @@ func (h *FunctionHandler) Dall3(c *gin.Context) {
 	resp.SUCCESS(c, content)
 }
 
-// 实现一个联网搜索的函数工具，采用爬虫实现
-func (h *FunctionHandler) WebSearch(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
-	}
-
-	// 从参数中获取搜索关键词
-	keyword, ok := params["keyword"].(string)
-	if !ok || keyword == "" {
-		resp.ERROR(c, "搜索关键词不能为空")
-		return
-	}
-
-	// 从参数中获取最大页数，默认为1页
-	maxPages := 1
-	if pages, ok := params["max_pages"].(float64); ok {
-		maxPages = int(pages)
-	}
-
-	// 获取用户ID
-	userID, ok := params["user_id"].(float64)
-	if !ok {
-		resp.ERROR(c, "用户ID不能为空")
-		return
-	}
-
-	// 查询用户信息
-	var user model.User
-	res := h.DB.Where("id = ?", int(userID)).First(&user)
-	if res.Error != nil {
-		resp.ERROR(c, "用户不存在")
-		return
-	}
-
-	// 检查用户算力是否足够
-	searchPower := 1 // 每次搜索消耗1点算力
-	if user.Power < searchPower {
-		resp.ERROR(c, "算力不足，无法执行网络搜索")
-		return
-	}
-
-	// 执行网络搜索
-	searchResults, err := crawler.SearchWeb(keyword, maxPages)
-	if err != nil {
-		resp.ERROR(c, fmt.Sprintf("搜索失败: %v", err))
-		return
-	}
-
-	// 扣减用户算力
-	err = h.userService.DecreasePower(user.Id, searchPower, model.PowerLog{
-		Type:   types.PowerConsume,
-		Model:  "web_search",
-		Remark: fmt.Sprintf("网络搜索：%s", utils.CutWords(keyword, 10)),
-	})
-	if err != nil {
-		resp.ERROR(c, "扣减算力失败："+err.Error())
-		return
-	}
-
-	// 返回搜索结果
-	resp.SUCCESS(c, searchResults)
-}
-
 // List 获取所有的工具函数列表
 func (h *FunctionHandler) List(c *gin.Context) {
 	var items []model.Function

api/handler/invite_handler.go

@@ -8,14 +8,18 @@ package handler
 // * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 import (
+	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/store/model"
 	"geekai/store/vo"
 	"geekai/utils"
 	"geekai/utils/resp"
+	"strings"
+	"time"
+
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
-	"strings"
 )
 
 // InviteHandler 用户邀请
@@ -27,6 +31,23 @@ func NewInviteHandler(app *core.AppServer, db *gorm.DB) *InviteHandler {
 	return &InviteHandler{BaseHandler: BaseHandler{App: app, DB: db}}
 }
 
+// RegisterRoutes 注册路由
+func (h *InviteHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/invite/")
+
+	// 公开接口，不需要授权
+	group.GET("hits", h.Hits)
+
+	// 需要用户授权的接口
+	group.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis))
+	{
+		group.GET("code", h.Code)
+		group.GET("list", h.List)
+		group.GET("stats", h.Stats)
+		group.GET("rules", h.Rules)
+	}
+}
+
 // Code 获取当前用户邀请码
 func (h *InviteHandler) Code(c *gin.Context) {
 	userId := h.GetLoginUserId(c)
@@ -65,21 +86,34 @@ func (h *InviteHandler) List(c *gin.Context) {
 	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)
-			}
+	err := session.Order("id DESC").Offset(offset).Limit(pageSize).Find(&items).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	userIds := make([]uint, 0)
+	for _, item := range items {
+		userIds = append(userIds, item.UserId)
+	}
+	userMap := make(map[uint]model.User)
+	var users []model.User
+	h.DB.Model(&model.User{}).Where("id IN (?)", userIds).Find(&users)
+	for _, user := range users {
+		userMap[user.Id] = user
+	}
+
+	var list = make([]vo.InviteLog, 0)
+	for _, item := range items {
+		var v vo.InviteLog
+		err := utils.CopyObject(item, &v)
+		if err != nil {
+			continue
 		}
+		v.CreatedAt = item.CreatedAt.Unix()
+		v.Avatar = userMap[item.UserId].Avatar
+		list = append(list, v)
 	}
 	resp.SUCCESS(c, vo.NewPage(total, page, pageSize, list))
 }
@@ -90,3 +124,89 @@ func (h *InviteHandler) Hits(c *gin.Context) {
 	h.DB.Model(&model.InviteCode{}).Where("code = ?", code).UpdateColumn("hits", gorm.Expr("hits + ?", 1))
 	resp.SUCCESS(c)
 }
+
+// Stats 获取邀请统计
+func (h *InviteHandler) Stats(c *gin.Context) {
+	userId := h.GetLoginUserId(c)
+
+	// 获取邀请码
+	var inviteCode model.InviteCode
+	res := h.DB.Where("user_id = ?", userId).First(&inviteCode)
+	if res.Error != nil {
+		resp.ERROR(c, "邀请码不存在")
+		return
+	}
+
+	// 统计累计邀请数
+	var totalInvite int64
+	h.DB.Model(&model.InviteLog{}).Where("inviter_id = ?", userId).Count(&totalInvite)
+
+	// 统计今日邀请数
+	today := time.Now().Format("2006-01-02")
+	var todayInvite int64
+	h.DB.Model(&model.InviteLog{}).Where("inviter_id = ? AND DATE(created_at) = ?", userId, today).Count(&todayInvite)
+
+	// 获取系统配置中的邀请奖励
+	var config model.Config
+	var invitePower int = 200 // 默认值
+	if h.DB.Where("name = ?", "system").First(&config).Error == nil {
+		var configMap map[string]any
+		if utils.JsonDecode(config.Value, &configMap) == nil {
+			if power, ok := configMap["invite_power"].(float64); ok {
+				invitePower = int(power)
+			}
+		}
+	}
+
+	// 计算获得奖励总数
+	rewardTotal := int(totalInvite) * invitePower
+
+	// 构建邀请链接
+	inviteLink := fmt.Sprintf("%s/register?invite=%s", h.App.Config.StaticUrl, inviteCode.Code)
+
+	stats := vo.InviteStats{
+		InviteCount: int(totalInvite),
+		RewardTotal: rewardTotal,
+		TodayInvite: int(todayInvite),
+		InviteCode:  inviteCode.Code,
+		InviteLink:  inviteLink,
+	}
+
+	resp.SUCCESS(c, stats)
+}
+
+// Rules 获取奖励规则
+func (h *InviteHandler) Rules(c *gin.Context) {
+	// 获取系统配置中的邀请奖励
+	var config model.Config
+	var invitePower int = 200 // 默认值
+	if h.DB.Where("name = ?", "system").First(&config).Error == nil {
+		var configMap map[string]interface{}
+		if utils.JsonDecode(config.Value, &configMap) == nil {
+			if power, ok := configMap["invite_power"].(float64); ok {
+				invitePower = int(power)
+			}
+		}
+	}
+
+	rules := []vo.RewardRule{
+		{
+			Id:     1,
+			Title:  "好友注册",
+			Desc:   "好友通过邀请链接成功注册",
+			Icon:   "icon-user-fill",
+			Color:  "#1989fa",
+			Reward: invitePower,
+		},
+		{
+			Id:     2,
+			Title:  "好友首次充值",
+			Desc:   "好友首次充值任意金额",
+			Icon:   "icon-money",
+			Color:  "#07c160",
+			Reward: invitePower * 2, // 假设首次充值奖励是注册奖励的2倍
+		},
+	}
+
+	resp.SUCCESS(c, rules)
+}

api/handler/jimeng_handler.go

@@ -1,12 +1,14 @@
 package handler
 
 import (
+	"errors"
 	"fmt"
-
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/service"
 	"geekai/service/jimeng"
+	"geekai/service/moderation"
 	"geekai/store/model"
 	"geekai/store/vo"
 	"geekai/utils"
@@ -19,198 +21,83 @@ import (
 // JimengHandler 即梦AI处理器
 type JimengHandler struct {
 	BaseHandler
-	jimengService *jimeng.Service
-	userService   *service.UserService
+	jimengService     *jimeng.Service
+	userService       *service.UserService
+	moderationManager *moderation.ServiceManager
 }
 
 // NewJimengHandler 创建即梦AI处理器
-func NewJimengHandler(app *core.AppServer, jimengService *jimeng.Service, db *gorm.DB, userService *service.UserService) *JimengHandler {
+func NewJimengHandler(app *core.AppServer, jimengService *jimeng.Service, db *gorm.DB, userService *service.UserService, moderationManager *moderation.ServiceManager) *JimengHandler {
 	return &JimengHandler{
-		BaseHandler:   BaseHandler{App: app, DB: db},
-		jimengService: jimengService,
-		userService:   userService,
+		BaseHandler:       BaseHandler{App: app, DB: db},
+		jimengService:     jimengService,
+		userService:       userService,
+		moderationManager: moderationManager,
 	}
 }
 
 // RegisterRoutes 注册路由，新增统一任务接口
 func (h *JimengHandler) RegisterRoutes() {
-	rg := h.App.Engine.Group("/api/jimeng")
-	rg.POST("task", h.CreateTask)            // 只保留统一任务接口
-	rg.GET("power-config", h.GetPowerConfig) // 新增算力配置接口
-	rg.POST("jobs", h.Jobs)
-	rg.GET("remove", h.Remove)
-	rg.GET("retry", h.Retry)
-}
+	group := h.App.Engine.Group("/api/jimeng/")
+	group.GET("power-config", h.GetPowerConfig)
 
-// JimengTaskRequest 统一任务请求结构体
-// 支持所有生图和生成视频类型
-type JimengTaskRequest struct {
-	TaskType         string   `json:"task_type" binding:"required"`
-	Prompt           string   `json:"prompt"`
-	ImageInput       string   `json:"image_input"`
-	ImageUrls        []string `json:"image_urls"`
-	BinaryDataBase64 []string `json:"binary_data_base64"`
-	Scale            float64  `json:"scale"`
-	Width            int      `json:"width"`
-	Height           int      `json:"height"`
-	Gpen             float64  `json:"gpen"`
-	Skin             float64  `json:"skin"`
-	SkinUnifi        float64  `json:"skin_unifi"`
-	GenMode          string   `json:"gen_mode"`
-	Seed             int64    `json:"seed"`
-	UsePreLLM        bool     `json:"use_pre_llm"`
-	TemplateId       string   `json:"template_id"`
-	AspectRatio      string   `json:"aspect_ratio"`
+	// 需要用户授权的接口
+	group.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis))
+	{
+		group.POST("task", h.CreateTask)
+		group.POST("jobs", h.Jobs)
+		group.GET("remove", h.Remove)
+		group.GET("retry", h.Retry)
+	}
 }
 
 // CreateTask 统一任务创建接口
 func (h *JimengHandler) CreateTask(c *gin.Context) {
-	var req JimengTaskRequest
+	var req types.JimengTaskRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
 		resp.ERROR(c, types.InvalidArgs)
 		return
 	}
-	// 新增：除图像特效外，其他任务类型必须有提示词
-	if req.TaskType != "image_effects" && req.Prompt == "" {
-		resp.ERROR(c, "提示词不能为空")
+
+	// 文本审核
+	if h.App.SysConfig.Moderation.Enable && req.Prompt != "" {
+		moderationResult, err := h.moderationManager.GetService().Moderate(req.Prompt)
+		if err != nil {
+			logger.Error("failed to moderate content: ", err)
+		}
+		if moderationResult.Flagged {
+			// 记录违规内容
+			moderation := model.Moderation{
+				UserId: h.GetLoginUserId(c),
+				Source: types.ModerationSourceJiMeng,
+				Input:  req.Prompt,
+				Result: utils.JsonEncode(moderationResult),
+			}
+			err = h.DB.Create(&moderation).Error
+			if err != nil {
+				logger.Error("failed to save moderation: ", err)
+			}
+			resp.ERROR(c, "当前创作内容包含敏感词，请重新输入！")
+			return
+		}
+
+	}
+
+	if req.Prompt == "" && len(req.ImageUrls) == 0 {
+		resp.ERROR(c, "提示词和图片不能同时为空")
 		return
 	}
+
 	user, err := h.GetLoginUser(c)
 	if err != nil {
 		resp.NotAuth(c)
 		return
 	}
 
-	if req.Width == 0 {
-		req.Width = 1328
-	}
-	if req.Height == 0 {
-		req.Height = 1328
-	}
-	if req.Seed == 0 {
-		req.Seed = -1
-	}
-
-	var powerCost int
-	var taskType model.JMTaskType
-	var params map[string]any
-	var reqKey string
-	var modelName string
-
-	switch req.TaskType {
-	case "text_to_image":
-		powerCost = h.getPowerFromConfig(model.JMTaskTypeTextToImage)
-		taskType = model.JMTaskTypeTextToImage
-		reqKey = jimeng.ReqKeyTextToImage
-		modelName = "即梦文生图"
-		if req.Scale == 0 {
-			req.Scale = 2.5
-		}
-		params = map[string]any{
-			"seed":        req.Seed,
-			"scale":       req.Scale,
-			"width":       req.Width,
-			"height":      req.Height,
-			"use_pre_llm": req.UsePreLLM,
-		}
-	case "image_to_image":
-		powerCost = h.getPowerFromConfig(model.JMTaskTypeImageToImage)
-		taskType = model.JMTaskTypeImageToImage
-		reqKey = jimeng.ReqKeyImageToImagePortrait
-		modelName = "即梦图生图"
-		if req.Gpen == 0 {
-			req.Gpen = 0.4
-		}
-		if req.Skin == 0 {
-			req.Skin = 0.3
-		}
-		if req.GenMode == "" {
-			if req.Prompt != "" {
-				req.GenMode = jimeng.GenModeCreative
-			} else {
-				req.GenMode = jimeng.GenModeReference
-			}
-		}
-		params = map[string]any{
-			"image_input": req.ImageInput,
-			"width":       req.Width,
-			"height":      req.Height,
-			"gpen":        req.Gpen,
-			"skin":        req.Skin,
-			"skin_unifi":  req.SkinUnifi,
-			"gen_mode":    req.GenMode,
-			"seed":        req.Seed,
-		}
-	case "image_edit":
-		powerCost = h.getPowerFromConfig(model.JMTaskTypeImageEdit)
-		taskType = model.JMTaskTypeImageEdit
-		reqKey = jimeng.ReqKeyImageEdit
-		modelName = "即梦图像编辑"
-		if req.Scale == 0 {
-			req.Scale = 0.5
-		}
-		params = map[string]any{
-			"seed":  req.Seed,
-			"scale": req.Scale,
-		}
-		if len(req.ImageUrls) > 0 {
-			params["image_urls"] = req.ImageUrls
-		}
-		if len(req.BinaryDataBase64) > 0 {
-			params["binary_data_base64"] = req.BinaryDataBase64
-		}
-	case "image_effects":
-		powerCost = h.getPowerFromConfig(model.JMTaskTypeImageEffects)
-		taskType = model.JMTaskTypeImageEffects
-		reqKey = jimeng.ReqKeyImageEffects
-		modelName = "即梦图像特效"
-		if req.Width == 0 {
-			req.Width = 1328
-		}
-		if req.Height == 0 {
-			req.Height = 1328
-		}
-		params = map[string]any{
-			"image_input1": req.ImageInput,
-			"template_id":  req.TemplateId,
-			"width":        req.Width,
-			"height":       req.Height,
-		}
-	case "text_to_video":
-		powerCost = h.getPowerFromConfig(model.JMTaskTypeTextToVideo)
-		taskType = model.JMTaskTypeTextToVideo
-		reqKey = jimeng.ReqKeyTextToVideo
-		modelName = "即梦文生视频"
-		if req.Seed == 0 {
-			req.Seed = -1
-		}
-		if req.AspectRatio == "" {
-			req.AspectRatio = jimeng.AspectRatio16_9
-		}
-		params = map[string]any{
-			"seed":         req.Seed,
-			"aspect_ratio": req.AspectRatio,
-		}
-	case "image_to_video":
-		powerCost = h.getPowerFromConfig(model.JMTaskTypeImageToVideo)
-		taskType = model.JMTaskTypeImageToVideo
-		reqKey = jimeng.ReqKeyImageToVideo
-		modelName = "即梦图生视频"
-		if req.Seed == 0 {
-			req.Seed = -1
-		}
-		params = map[string]any{
-			"seed":         req.Seed,
-			"aspect_ratio": req.AspectRatio,
-		}
-		if len(req.ImageUrls) > 0 {
-			params["image_urls"] = req.ImageUrls
-		}
-		if len(req.BinaryDataBase64) > 0 {
-			params["binary_data_base64"] = req.BinaryDataBase64
-		}
-	default:
-		resp.ERROR(c, "不支持的任务类型")
+	// 获取算力消耗
+	powerCost, err := h.getTaskPower(req)
+	if err != nil {
+		resp.ERROR(c, "计算任务消耗积分失败: "+err.Error())
 		return
 	}
 
@@ -218,16 +105,9 @@ func (h *JimengHandler) CreateTask(c *gin.Context) {
 		resp.ERROR(c, fmt.Sprintf("算力不足，需要%d算力", powerCost))
 		return
 	}
+	req.Power = powerCost
 
-	taskReq := &jimeng.CreateTaskRequest{
-		Type:   taskType,
-		Prompt: req.Prompt,
-		Params: params,
-		ReqKey: reqKey,
-		Power:  powerCost,
-	}
-
-	job, err := h.jimengService.CreateTask(user.Id, taskReq)
+	job, err := h.jimengService.CreateTask(user.Id, &req)
 	if err != nil {
 		logger.Errorf("create jimeng task failed: %v", err)
 		resp.ERROR(c, "创建任务失败")
@@ -236,11 +116,42 @@ func (h *JimengHandler) CreateTask(c *gin.Context) {
 
 	h.userService.DecreasePower(user.Id, powerCost, model.PowerLog{
 		Type:   types.PowerConsume,
-		Model:  "jimeng",
-		Remark: fmt.Sprintf("%s，任务ID：%d", modelName, job.Id),
+		Model:  job.ReqKey,
+		Remark: h.getTaskRemark(req, job.Id),
 	})
 
-	resp.SUCCESS(c, job)
+	resp.SUCCESS(c)
+}
+
+func (h *JimengHandler) getTaskRemark(req types.JimengTaskRequest, jobId uint) string {
+	remark := fmt.Sprintf("即梦任务%s，任务ID：%d", req.ReqKey, jobId)
+	perUnit, ok := h.App.SysConfig.Jimeng.Powers[req.ReqKey]
+	if !ok || perUnit <= 0 {
+		return remark // Fallback if power not found or invalid
+	}
+	switch req.TaskType {
+	case types.JMTaskTypeImage:
+		remark = fmt.Sprintf("即梦图片生成，任务ID：%d，%d积分/张", jobId, perUnit)
+	case types.JMTaskTypeVideo:
+		seconds := 0
+		if perUnit > 0 {
+			seconds = req.Power / perUnit
+		}
+		remark = fmt.Sprintf("即梦视频生成，任务ID：%d，%d积分/秒, %d秒", jobId, perUnit, seconds)
+	case types.JMTaskTypeVirtualHuman:
+		seconds := 0
+		if perUnit > 0 {
+			seconds = req.Power / perUnit
+		}
+		remark = fmt.Sprintf("即梦数字人视频生成，任务ID：%d，%d积分/秒, %d秒", jobId, perUnit, seconds)
+	case types.JMTaskTypeActionTransfer:
+		seconds := 0
+		if perUnit > 0 {
+			seconds = req.Power / perUnit
+		}
+		remark = fmt.Sprintf("即梦视频动作迁移，任务ID：%d，%d积分/秒, %d秒", jobId, perUnit, seconds)
+	}
+	return remark
 }
 
 // Jobs 获取任务列表
@@ -265,17 +176,13 @@ func (h *JimengHandler) Jobs(c *gin.Context) {
 
 	switch req.Filter {
 	case "image":
-		query = query.Where("type IN (?)", []model.JMTaskType{
-			model.JMTaskTypeTextToImage,
-			model.JMTaskTypeImageToImage,
-			model.JMTaskTypeImageEdit,
-			model.JMTaskTypeImageEffects,
-		})
+		query = query.Where("type = ?", types.JMTaskTypeImage)
 	case "video":
-		query = query.Where("type IN (?)", []model.JMTaskType{
-			model.JMTaskTypeTextToVideo,
-			model.JMTaskTypeImageToVideo,
-		})
+		query = query.Where("type = ?", types.JMTaskTypeVideo)
+	case "virtual_human":
+		query = query.Where("type = ?", types.JMTaskTypeVirtualHuman)
+	case "action_transfer":
+		query = query.Where("type = ?", types.JMTaskTypeActionTransfer)
 	}
 
 	if len(req.Ids) > 0 {
@@ -333,31 +240,19 @@ func (h *JimengHandler) Remove(c *gin.Context) {
 		resp.ERROR(c, "无权限操作")
 		return
 	}
-	if job.Status != model.JMTaskStatusFailed {
-		resp.ERROR(c, "只有失败的任务才能删除")
+
+	// 正在运行中的任务不能删除
+	if job.Status == types.JMTaskStatusGenerating || job.Status == types.JMTaskStatusInQueue {
+		resp.ERROR(c, "正在运行中的任务不能删除，否则无法退回算力")
 		return
 	}
 
-	tx := h.DB.Begin()
-	if err := tx.Where("id = ? AND user_id = ?", jobId, user.Id).Delete(&model.JimengJob{}).Error; err != nil {
+	if err := h.DB.Where("id = ? AND user_id = ?", jobId, user.Id).Delete(&model.JimengJob{}).Error; err != nil {
 		logger.Errorf("delete jimeng job failed: %v", err)
 		resp.ERROR(c, "删除任务失败")
 		return
 	}
 
-	// 退回算力
-	err = h.userService.IncreasePower(user.Id, job.Power, model.PowerLog{
-		Type:   types.PowerRefund,
-		Model:  "jimeng",
-		Remark: fmt.Sprintf("删除任务，退回%d算力", job.Power),
-	})
-	if err != nil {
-		resp.ERROR(c, "退回算力失败")
-		tx.Rollback()
-		return
-	}
-	tx.Commit()
-
 	resp.SUCCESS(c, gin.H{})
 }
 
@@ -384,13 +279,13 @@ func (h *JimengHandler) Retry(c *gin.Context) {
 	}
 
 	// 只有失败的任务才能重试
-	if job.Status != model.JMTaskStatusFailed {
+	if job.Status != types.JMTaskStatusFailed {
 		resp.ERROR(c, "只有失败的任务才能重试")
 		return
 	}
 
 	// 重置任务状态
-	if err := h.jimengService.UpdateJobStatus(uint(jobId), model.JMTaskStatusInQueue, ""); err != nil {
+	if err := h.jimengService.UpdateJobStatus(uint(jobId), types.JMTaskStatusInQueue, ""); err != nil {
 		logger.Errorf("reset job status failed: %v", err)
 		resp.ERROR(c, "重置任务状态失败")
 		return
@@ -406,37 +301,56 @@ func (h *JimengHandler) Retry(c *gin.Context) {
 	resp.SUCCESS(c, gin.H{"message": "重试任务已提交"})
 }
 
-// getPowerFromConfig 从配置中获取指定类型的算力消耗
-func (h *JimengHandler) getPowerFromConfig(taskType model.JMTaskType) int {
-	config := h.jimengService.GetConfig()
-
-	switch taskType {
-	case model.JMTaskTypeTextToImage:
-		return config.Power.TextToImage
-	case model.JMTaskTypeImageToImage:
-		return config.Power.ImageToImage
-	case model.JMTaskTypeImageEdit:
-		return config.Power.ImageEdit
-	case model.JMTaskTypeImageEffects:
-		return config.Power.ImageEffects
-	case model.JMTaskTypeTextToVideo:
-		return config.Power.TextToVideo
-	case model.JMTaskTypeImageToVideo:
-		return config.Power.ImageToVideo
+func (h *JimengHandler) getTaskPower(req types.JimengTaskRequest) (int, error) {
+	logger.Debugf("getTaskPower req: %+v", req)
+	config := h.App.SysConfig.Jimeng
+	basePower, ok := config.Powers[req.ReqKey]
+	if !ok || basePower <= 0 {
+		return 0, errors.New("未配置模型积分或配置不合法")
+	}
+	switch req.TaskType {
+	case types.JMTaskTypeImage:
+		return basePower, nil
+	case types.JMTaskTypeVideo:
+		if req.Duration == 0 {
+			return 0, errors.New("视频时长不能为0")
+		}
+		return basePower * req.Duration, nil
+	case types.JMTaskTypeVirtualHuman:
+		if req.AudioURL == "" {
+			return 0, errors.New("音频URL不能为空")
+		}
+		audioDuration, err := utils.AudioDurationFromURL(req.AudioURL)
+		if err != nil {
+			return 0, err
+		}
+		seconds := int(audioDuration.Seconds())
+		if seconds <= 0 {
+			return 0, errors.New("音频时长无效")
+		}
+		return basePower * seconds, nil
+	case types.JMTaskTypeActionTransfer:
+		if req.VideoURL == "" {
+			return 0, errors.New("视频URL不能为空")
+		}
+		videoDuration, err := utils.VideoDurationMP4FromURL(req.VideoURL)
+		if err != nil {
+			return 0, err
+		}
+		seconds := int(videoDuration.Seconds())
+		if seconds <= 0 {
+			return 0, errors.New("视频时长无效")
+		}
+		return basePower * seconds, nil
 	default:
-		return 10
+		return 0, errors.New("任务类型不支持")
 	}
 }
 
 // GetPowerConfig 获取即梦各任务类型算力消耗配置
 func (h *JimengHandler) GetPowerConfig(c *gin.Context) {
-	config := h.jimengService.GetConfig()
+	config := h.App.SysConfig.Jimeng
 	resp.SUCCESS(c, gin.H{
-		"text_to_image":  config.Power.TextToImage,
-		"image_to_image": config.Power.ImageToImage,
-		"image_edit":     config.Power.ImageEdit,
-		"image_effects":  config.Power.ImageEffects,
-		"text_to_video":  config.Power.TextToVideo,
-		"image_to_video": config.Power.ImageToVideo,
+		"powers": config.Powers,
 	})
 }

api/handler/markmap_handler.go

@@ -10,6 +10,7 @@ package handler
 import (
 	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/service"
 	"geekai/store/model"
@@ -35,6 +36,17 @@ func NewMarkMapHandler(app *core.AppServer, db *gorm.DB, userService *service.Us
 	}
 }
 
+// RegisterRoutes 注册路由
+func (h *MarkMapHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/markMap/")
+
+	// 需要用户授权的接口
+	group.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis))
+	{
+		group.POST("gen", h.Generate)
+	}
+}
+
 // Generate 生成思维导图
 func (h *MarkMapHandler) Generate(c *gin.Context) {
 	var data struct {

api/handler/menu_handler.go

@@ -13,6 +13,7 @@ import (
 	"geekai/store/vo"
 	"geekai/utils"
 	"geekai/utils/resp"
+
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
 )
@@ -25,6 +26,13 @@ func NewMenuHandler(app *core.AppServer, db *gorm.DB) *MenuHandler {
 	return &MenuHandler{BaseHandler: BaseHandler{App: app, DB: db}}
 }
 
+// RegisterRoutes 注册路由
+func (h *MenuHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/menu/")
+	group.GET("list", h.List)
+	group.GET("list/all", h.ListAll)
+}
+
 // List 数据列表
 func (h *MenuHandler) List(c *gin.Context) {
 	index := h.GetBool(c, "index")
@@ -33,7 +41,7 @@ func (h *MenuHandler) List(c *gin.Context) {
 	session := h.DB.Session(&gorm.Session{})
 	session = session.Where("enabled", true)
 	if index {
-		session = session.Where("id IN ?", h.App.SysConfig.IndexNavs)
+		session = session.Where("id IN ?", h.App.SysConfig.Base.IndexNavs)
 	}
 	res := session.Order("sort_num ASC").Find(&items)
 	if res.Error == nil {
@@ -47,3 +55,20 @@ func (h *MenuHandler) List(c *gin.Context) {
 	}
 	resp.SUCCESS(c, list)
 }
+
+// ListAll 获取所有的菜单列表
+func (h *MenuHandler) ListAll(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)
+}

api/handler/mj_handler.go

@@ -10,9 +10,11 @@ package handler
 import (
 	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/service"
 	"geekai/service/mj"
+	"geekai/service/moderation"
 	"geekai/service/oss"
 	"geekai/store/model"
 	"geekai/store/vo"
@@ -27,18 +29,20 @@ import (
 
 type MidJourneyHandler struct {
 	BaseHandler
-	mjService   *mj.Service
-	snowflake   *service.Snowflake
-	uploader    *oss.UploaderManager
-	userService *service.UserService
+	mjService         *mj.Service
+	snowflake         *service.Snowflake
+	uploader          *oss.UploaderManager
+	userService       *service.UserService
+	moderationManager *moderation.ServiceManager
 }
 
-func NewMidJourneyHandler(app *core.AppServer, db *gorm.DB, snowflake *service.Snowflake, service *mj.Service, manager *oss.UploaderManager, userService *service.UserService) *MidJourneyHandler {
+func NewMidJourneyHandler(app *core.AppServer, db *gorm.DB, snowflake *service.Snowflake, service *mj.Service, manager *oss.UploaderManager, userService *service.UserService, moderationManager *moderation.ServiceManager) *MidJourneyHandler {
 	return &MidJourneyHandler{
-		snowflake:   snowflake,
-		mjService:   service,
-		uploader:    manager,
-		userService: userService,
+		snowflake:         snowflake,
+		mjService:         service,
+		uploader:          manager,
+		userService:       userService,
+		moderationManager: moderationManager,
 		BaseHandler: BaseHandler{
 			App: app,
 			DB:  db,
@@ -46,6 +50,25 @@ func NewMidJourneyHandler(app *core.AppServer, db *gorm.DB, snowflake *service.S
 	}
 }
 
+// RegisterRoutes 注册路由
+func (h *MidJourneyHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/mj/")
+
+	// 公开接口，不需要授权
+	group.GET("imgWall", h.ImgWall)
+
+	// 需要用户授权的接口
+	group.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis))
+	{
+		group.POST("image", h.Image)
+		group.POST("upscale", h.Upscale)
+		group.POST("variation", h.Variation)
+		group.GET("jobs", h.JobList)
+		group.GET("remove", h.Remove)
+		group.GET("publish", h.Publish)
+	}
+}
+
 func (h *MidJourneyHandler) preCheck(c *gin.Context) bool {
 	user, err := h.GetLoginUser(c)
 	if err != nil {
@@ -53,7 +76,7 @@ func (h *MidJourneyHandler) preCheck(c *gin.Context) bool {
 		return false
 	}
 
-	if user.Power < h.App.SysConfig.MjPower {
+	if user.Power < h.App.SysConfig.Base.MjPower {
 		resp.ERROR(c, "当前用户剩余算力不足以完成本次绘画！")
 		return false
 	}
@@ -90,6 +113,29 @@ func (h *MidJourneyHandler) Image(c *gin.Context) {
 		return
 	}
 
+	// 文本审核
+	if h.App.SysConfig.Moderation.Enable {
+		moderationResult, err := h.moderationManager.GetService().Moderate(data.Prompt)
+		if err != nil {
+			logger.Error("failed to moderate content: ", err)
+		}
+		if moderationResult.Flagged {
+			// 记录违规内容
+			moderation := model.Moderation{
+				UserId: h.GetLoginUserId(c),
+				Source: types.ModerationSourceMJ,
+				Input:  data.Prompt,
+				Result: utils.JsonEncode(moderationResult),
+			}
+			err = h.DB.Create(&moderation).Error
+			if err != nil {
+				logger.Error("failed to save moderation: ", err)
+			}
+			resp.ERROR(c, "当前创作内容包含敏感词，请重新输入！")
+			return
+		}
+	}
+
 	var params = ""
 	if data.Rate != "" && !strings.Contains(params, "--ar") {
 		params += " --ar " + data.Rate
@@ -159,8 +205,8 @@ func (h *MidJourneyHandler) Image(c *gin.Context) {
 		Params:           params,
 		UserId:           userId,
 		ImgArr:           data.ImgArr,
-		Mode:             h.App.SysConfig.MjMode,
-		TranslateModelId: h.App.SysConfig.AssistantModelId,
+		Mode:             h.App.SysConfig.Base.MjMode,
+		TranslateModelId: h.App.SysConfig.Base.AssistantModelId,
 	}
 	job := model.MidJourneyJob{
 		Type:      data.TaskType,
@@ -169,7 +215,7 @@ func (h *MidJourneyHandler) Image(c *gin.Context) {
 		TaskInfo:  utils.JsonEncode(task),
 		Progress:  0,
 		Prompt:    fmt.Sprintf("%s %s", data.Prompt, params),
-		Power:     h.App.SysConfig.MjPower,
+		Power:     h.App.SysConfig.Base.MjPower,
 		CreatedAt: time.Now(),
 	}
 	opt := "绘图"
@@ -232,7 +278,7 @@ func (h *MidJourneyHandler) Upscale(c *gin.Context) {
 		Index:       data.Index,
 		MessageId:   data.MessageId,
 		MessageHash: data.MessageHash,
-		Mode:        h.App.SysConfig.MjMode,
+		Mode:        h.App.SysConfig.Base.MjMode,
 	}
 	job := model.MidJourneyJob{
 		Type:      types.TaskUpscale.String(),
@@ -240,7 +286,7 @@ func (h *MidJourneyHandler) Upscale(c *gin.Context) {
 		TaskId:    taskId,
 		TaskInfo:  utils.JsonEncode(task),
 		Progress:  0,
-		Power:     h.App.SysConfig.MjActionPower,
+		Power:     h.App.SysConfig.Base.MjActionPower,
 		CreatedAt: time.Now(),
 	}
 	if res := h.DB.Create(&job); res.Error != nil || res.RowsAffected == 0 {
@@ -287,7 +333,7 @@ func (h *MidJourneyHandler) Variation(c *gin.Context) {
 		ChannelId:   data.ChannelId,
 		MessageId:   data.MessageId,
 		MessageHash: data.MessageHash,
-		Mode:        h.App.SysConfig.MjMode,
+		Mode:        h.App.SysConfig.Base.MjMode,
 	}
 	job := model.MidJourneyJob{
 		Type:      types.TaskVariation.String(),
@@ -296,7 +342,7 @@ func (h *MidJourneyHandler) Variation(c *gin.Context) {
 		TaskId:    taskId,
 		TaskInfo:  utils.JsonEncode(task),
 		Progress:  0,
-		Power:     h.App.SysConfig.MjActionPower,
+		Power:     h.App.SysConfig.Base.MjActionPower,
 		CreatedAt: time.Now(),
 	}
 	if res := h.DB.Create(&job); res.Error != nil || res.RowsAffected == 0 {

api/handler/net_handler.go

@@ -9,6 +9,7 @@ package handler
 
 import (
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/service/oss"
 	"geekai/store/model"
@@ -32,6 +33,22 @@ func NewNetHandler(app *core.AppServer, db *gorm.DB, manager *oss.UploaderManage
 	return &NetHandler{BaseHandler: BaseHandler{App: app, DB: db}, uploaderManager: manager}
 }
 
+// RegisterRoutes 注册路由
+func (h *NetHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/upload")
+
+	// 需要用户授权的接口
+	group.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis))
+	{
+		group.POST("", h.Upload)
+		group.POST("list", h.List)
+		group.GET("remove", h.Remove)
+	}
+
+	// 公开接口，不需要授权
+	h.App.Engine.GET("/api/download", h.Download)
+}
+
 func (h *NetHandler) Upload(c *gin.Context) {
 	file, err := h.uploaderManager.GetUploadHandler().PutFile(c, "file")
 	if err != nil {

api/handler/order_handler.go

@@ -9,12 +9,12 @@ package handler
 
 import (
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/store/model"
 	"geekai/store/vo"
 	"geekai/utils"
 	"geekai/utils/resp"
-	"time"
 
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
@@ -28,6 +28,18 @@ func NewOrderHandler(app *core.AppServer, db *gorm.DB) *OrderHandler {
 	return &OrderHandler{BaseHandler: BaseHandler{App: app, DB: db}}
 }
 
+// RegisterRoutes 注册路由
+func (h *OrderHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/order/")
+
+	// 需要用户授权的接口
+	group.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis))
+	{
+		group.GET("list", h.List)
+		group.GET("query", h.Query)
+	}
+}
+
 // List 订单列表
 func (h *OrderHandler) List(c *gin.Context) {
 	page := h.GetInt(c, "page", 1)
@@ -48,20 +60,21 @@ func (h *OrderHandler) List(c *gin.Context) {
 				order.Id = item.Id
 				order.CreatedAt = item.CreatedAt.Unix()
 				order.UpdatedAt = item.UpdatedAt.Unix()
-				payMethod, ok := types.PayMethods[item.PayWay]
+				payChannel, ok := types.PayChannel[item.Channel]
 				if !ok {
-					payMethod = item.PayWay
+					payChannel = item.PayWay
 				}
-				payName, ok := types.PayNames[item.PayType]
+				payWays, ok := types.PayWays[item.PayWay]
 				if !ok {
-					payName = item.PayWay
+					payWays = item.PayWay
 				}
-				order.PayMethod = payMethod
-				order.PayName = payName
+				order.ChannelName = payChannel
+				order.PayName = payWays
 				list = append(list, order)
 			} else {
 				logger.Error(err)
 			}
+
 		}
 	}
 	resp.SUCCESS(c, vo.NewPage(total, page, pageSize, list))
@@ -82,17 +95,8 @@ func (h *OrderHandler) Query(c *gin.Context) {
 		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++
-	}
+	var item model.Order
+	h.DB.Where("order_no = ?", orderNo).First(&item)
 
 	resp.SUCCESS(c, gin.H{"status": order.Status})
 }

api/handler/payment_handler.go

@@ -11,6 +11,7 @@ import (
 	"embed"
 	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/service"
 	"geekai/service/payment"
@@ -33,52 +34,149 @@ type PayWay struct {
 // 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 // 用来签名的随机秘钥
+	alipayService *payment.AlipayService
+	epayService   *payment.EPayService
+	wxpayService  *payment.WxPayService
+	snowflake     *service.Snowflake
+	userService   *service.UserService
+	fs            embed.FS
+	lock          sync.Mutex
+	config        *types.PaymentConfig
 }
 
 func NewPaymentHandler(
 	server *core.AppServer,
 	alipayService *payment.AlipayService,
-	huPiPayService *payment.HuPiPayService,
-	geekPayService *payment.GeekPayService,
-	wechatPayService *payment.WechatPayService,
+	geekPayService *payment.EPayService,
+	wxpayService *payment.WxPayService,
 	db *gorm.DB,
 	userService *service.UserService,
 	snowflake *service.Snowflake,
-	fs embed.FS) *PaymentHandler {
+	fs embed.FS,
+	sysConfig *types.SystemConfig) *PaymentHandler {
 	return &PaymentHandler{
-		alipayService:    alipayService,
-		huPiPayService:   huPiPayService,
-		geekPayService:   geekPayService,
-		wechatPayService: wechatPayService,
-		snowflake:        snowflake,
-		userService:      userService,
-		fs:               fs,
-		lock:             sync.Mutex{},
+		alipayService: alipayService,
+		epayService:   geekPayService,
+		wxpayService:  wxpayService,
+		snowflake:     snowflake,
+		userService:   userService,
+		fs:            fs,
+		lock:          sync.Mutex{},
 		BaseHandler: BaseHandler{
 			App: server,
 			DB:  db,
 		},
-		signKey: utils.RandString(32),
+		config: &sysConfig.Payment,
 	}
 }
 
-func (h *PaymentHandler) Pay(c *gin.Context) {
+// RegisterRoutes 注册路由
+func (h *PaymentHandler) RegisterRoutes() {
+	rg := h.App.Engine.Group("/api/payment/")
+
+	// 支付回调接口（公开）
+	rg.POST("notify/alipay", h.AlipayNotify)
+	rg.GET("notify/epay", h.EPayNotify)
+	rg.POST("notify/wxpay", h.WxpayNotify)
+
+	// 需要用户登录的接口
+	rg.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis))
+	{
+		rg.POST("create", h.CreateOrder)
+	}
+}
+
+func (h *PaymentHandler) StartSyncOrders() {
+	go func() {
+		for {
+			err := h.SyncOrders()
+			if err != nil {
+				logger.Error(err)
+			}
+			time.Sleep(time.Second * 5)
+		}
+	}()
+}
+
+// SyncOrders 同步订单状态
+func (h *PaymentHandler) SyncOrders() error {
+	defer func() {
+		if err := recover(); err != nil {
+			logger.Errorf("同步订单状态发生异常: %v", err)
+		}
+	}()
+	var orders []model.Order
+	err := h.DB.Where("status", types.OrderNotPaid).Where("checked", false).Find(&orders).Error
+	if err != nil {
+		return err
+	}
+
+	for _, order := range orders {
+		time.Sleep(time.Second * 1)
+		//超时15分钟的订单，直接标记为已关闭
+		if time.Now().After(order.CreatedAt.Add(time.Minute * 5)) {
+			h.DB.Model(&model.Order{}).Where("id", order.Id).Update("checked", true)
+			logger.Errorf("订单超时：%v", order)
+			continue
+		}
+		// 查询订单状态
+		var res payment.OrderInfo
+		switch order.Channel {
+		case payment.PayChannelEpay:
+			res, err = h.epayService.Query(order.OrderNo)
+			if err != nil {
+				logger.Errorf("error with query order info: %v", err)
+				continue
+			}
+			// 微信支付
+		case payment.PayChannelWX:
+			res, err = h.wxpayService.Query(order.OrderNo)
+			logger.Debugf("微信支付订单状态：%+v", res)
+			if err != nil {
+				logger.Errorf("error with query order info: %v", err)
+				continue
+			}
+		case payment.PayChannelAL:
+			res, err = h.alipayService.Query(order.OrderNo)
+			logger.Debugf("支付宝支付订单状态：%+v", res)
+			if err != nil {
+				logger.Errorf("error with query order info: %v", err)
+				continue
+			}
+		}
+
+		// 订单已关闭
+		if res.Closed() {
+			h.DB.Model(&model.Order{}).Where("id", order.Id).Updates(map[string]any{
+				"checked": true,
+				"status":  types.OrderPaidFailed,
+			})
+			logger.Errorf("订单已关闭：%v", order)
+			continue
+		}
+
+		// 订单未支付，不处理，继续轮询
+		if !res.Success() {
+			continue
+		}
+
+		// 订单支付成功
+		err = h.paySuccess(res)
+		if err != nil {
+			logger.Errorf("error with deal order: %v", err)
+			continue
+		}
+	}
+	return nil
+}
+
+func (h *PaymentHandler) CreateOrder(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"`
+		PayWay  string `json:"pay_way,omitempty"` // 支付方式：支付宝，微信
+		Pid     int    `json:"pid,omitempty"`
+		Device  string `json:"device,omitempty"`
+		Domain  string `json:"domain,omitempty"` // 支付回调域名
+		Channel string `json:"channel,omitempty"`
 	}
 	if err := c.ShouldBindJSON(&data); err != nil {
 		resp.ERROR(c, types.InvalidArgs)
@@ -86,7 +184,7 @@ func (h *PaymentHandler) Pay(c *gin.Context) {
 	}
 
 	var product model.Product
-	err := h.DB.Where("id", data.ProductId).First(&product).Error
+	err := h.DB.Where("id", data.Pid).First(&product).Error
 	if err != nil {
 		resp.ERROR(c, "Product not found")
 		return
@@ -97,136 +195,118 @@ func (h *PaymentHandler) Pay(c *gin.Context) {
 		resp.ERROR(c, "error with generate trade no: "+err.Error())
 		return
 	}
+	userId := h.GetLoginUserId(c)
 	var user model.User
-	err = h.DB.Where("id", data.UserId).First(&user).Error
+	err = h.DB.Where("id", userId).First(&user).Error
 	if err != nil {
 		resp.NotAuth(c)
 		return
 	}
 
-	amount := product.Discount
-	var payURL, returnURL, notifyURL string
+	amount := product.Price
+	var payURL, 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{
+	case "wxpay":
+		logger.Debugf("微信支付，%+v", data)
+		data.Channel = payment.PayChannelWX
+		// 优先使用微信官方支付
+		if h.config.WxPay.Enabled {
+			data.Channel = "wxpay"
+			if h.config.WxPay.Domain != "" {
+				data.Domain = h.config.WxPay.Domain
+			}
+			notifyURL = fmt.Sprintf("%s/api/payment/notify/wxpay", data.Domain)
+			payURL, err = h.wxpayService.Pay(payment.PayRequest{
 				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),
+				TotalFee:   fmt.Sprintf("%d", int(amount*100)),
 				Subject:    product.Name,
 				NotifyURL:  notifyURL,
 				ClientIP:   c.ClientIP(),
+				Device:     data.Device,
+				PayWay:     payment.PayWayWX,
 			})
-		} else {
-			payURL, err = h.wechatPayService.PayUrlNative(payment.WechatPayParams{
+			if err != nil {
+				resp.ERROR(c, err.Error())
+				return
+			}
+		} else if h.config.Epay.Enabled { // 聚合支付
+			logger.Debugf("聚合支付%+v", data)
+			data.Channel = payment.PayChannelEpay
+			if h.config.Epay.Domain != "" {
+				data.Domain = h.config.Epay.Domain
+			}
+			notifyURL = fmt.Sprintf("%s/api/payment/notify/epay", data.Domain)
+			params := payment.PayRequest{
 				OutTradeNo: orderNo,
-				TotalFee:   int(amount * 100),
 				Subject:    product.Name,
+				TotalFee:   fmt.Sprintf("%f", amount),
+				ClientIP:   c.ClientIP(),
+				Device:     data.Device,
+				PayWay:     payment.PayWayWX,
+				NotifyURL:  notifyURL,
+			}
+
+			r, err := h.epayService.Pay(params)
+			logger.Debugf("请求支付结果，%+v", r)
+			if err != nil {
+				resp.ERROR(c, err.Error())
+				return
+			} else {
+				payURL = r
+			}
+		} else {
+			resp.ERROR(c, "系统没有配置可用的支付渠道！")
+			return
+		}
+	case "alipay":
+		if h.config.Alipay.Enabled {
+			logger.Debugf("支付宝，%+v", data)
+			data.Channel = payment.PayChannelAL
+			if h.config.Alipay.Domain != "" { // 用于本地调试支付
+				data.Domain = h.config.Alipay.Domain
+			}
+			notifyURL = fmt.Sprintf("%s/api/payment/notify/alipay", data.Domain)
+			money := fmt.Sprintf("%.2f", amount)
+			payURL, err = h.alipayService.Pay(payment.PayRequest{
+				Device:     data.Device,
+				OutTradeNo: orderNo,
+				Subject:    product.Name,
+				TotalFee:   money,
 				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())
+			if err != nil {
+				resp.ERROR(c, "error with generate pay url: "+err.Error())
+				return
+			}
+		} else if h.config.Epay.Enabled { // 聚合支付
+			logger.Debugf("聚合支付，%+v", data)
+			data.Channel = payment.PayChannelEpay
+			if h.config.Epay.Domain != "" {
+				data.Domain = h.config.Epay.Domain
+			}
+			notifyURL = fmt.Sprintf("%s/api/payment/notify/epay", data.Domain)
+			params := payment.PayRequest{
+				OutTradeNo: orderNo,
+				Subject:    product.Name,
+				TotalFee:   fmt.Sprintf("%f", amount),
+				ClientIP:   c.ClientIP(),
+				Device:     data.Device,
+				PayWay:     data.PayWay,
+				NotifyURL:  notifyURL,
+			}
+
+			r, err := h.epayService.Pay(params)
+			if err != nil {
+				resp.ERROR(c, err.Error())
+				return
+			} else {
+				payURL = r
+			}
+		} else {
+			resp.ERROR(c, "系统没有配置可用的支付渠道！")
 			return
 		}
-		payURL = res.PayURL
 	default:
 		resp.ERROR(c, "不支持的支付渠道")
 		return
@@ -234,43 +314,40 @@ func (h *PaymentHandler) Pay(c *gin.Context) {
 
 	// 创建订单
 	remark := types.OrderRemark{
-		Days:     product.Days,
-		Power:    product.Power,
-		Name:     product.Name,
-		Price:    product.Price,
-		Discount: product.Discount,
+		Power: product.Power,
+		Name:  product.Name,
+		Price: product.Price,
 	}
 	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),
+		UserId:   user.Id,
+		Username: user.Username,
+		OrderNo:  orderNo,
+		Subject:  product.Name,
+		Amount:   amount,
+		Status:   types.OrderNotPaid,
+		PayWay:   data.PayWay,
+		Channel:  data.Channel,
+		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)
+	resp.SUCCESS(c, gin.H{"pay_url": payURL, "order_no": orderNo})
 }
 
-// 异步通知回调公共逻辑
-func (h *PaymentHandler) notify(orderNo string, tradeNo string) error {
+// 支付成功处理
+func (h *PaymentHandler) paySuccess(info payment.OrderInfo) error {
+	h.lock.Lock()
+	defer h.lock.Unlock()
+
 	var order model.Order
-	err := h.DB.Where("order_no = ?", orderNo).First(&order).Error
+	err := h.DB.Where("order_no", info.OutTradeNo).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
@@ -290,19 +367,21 @@ func (h *PaymentHandler) notify(orderNo string, tradeNo string) error {
 
 	// 增加用户算力
 	err = h.userService.IncreasePower(order.UserId, remark.Power, model.PowerLog{
-		Type:   types.PowerRecharge,
-		Model:  order.PayWay,
-		Remark: fmt.Sprintf("充值算力，金额：%f，订单号：%s", order.Amount, order.OrderNo),
+		Type:      types.PowerRecharge,
+		Model:     order.Subject,
+		Remark:    fmt.Sprintf("充值算力，金额：%f，订单号：%s", order.Amount, order.OrderNo),
+		CreatedAt: time.Now(),
 	})
 	if err != nil {
 		return err
 	}
 
 	// 更新订单状态
-	order.PayTime = time.Now().Unix()
+	order.PayTime = utils.Str2stamp(info.PayTime)
 	order.Status = types.OrderPaidSuccess
-	order.TradeNo = tradeNo
-	err = h.DB.Updates(&order).Error
+	order.TradeNo = info.TradeId
+	order.Checked = true
+	err = h.DB.Debug().Updates(&order).Error
 	if err != nil {
 		return fmt.Errorf("error with update order info: %v", err)
 	}
@@ -317,54 +396,6 @@ func (h *PaymentHandler) notify(orderNo string, tradeNo string) error {
 	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()
@@ -373,16 +404,15 @@ func (h *PaymentHandler) AlipayNotify(c *gin.Context) {
 		return
 	}
 
-	result := h.alipayService.TradeVerify(c.Request)
-	logger.Infof("收到支付宝商号订单支付回调：%+v", result)
-	if !result.Success() {
-		logger.Error("订单校验失败：", result.Message)
+	orderInfo, err := h.alipayService.Query(c.Request.Form.Get("out_trade_no"))
+	logger.Infof("收到支付宝商号订单支付回调：%+v", orderInfo)
+	if !orderInfo.Success() {
+		logger.Errorf("订单校验失败：%v", err)
 		c.String(http.StatusOK, "fail")
 		return
 	}
 
-	tradeNo := c.Request.Form.Get("trade_no")
-	err = h.notify(result.OutTradeNo, tradeNo)
+	err = h.paySuccess(orderInfo)
 	if err != nil {
 		logger.Error(err)
 		c.String(http.StatusOK, "fail")
@@ -392,28 +422,35 @@ func (h *PaymentHandler) AlipayNotify(c *gin.Context) {
 	c.String(http.StatusOK, "success")
 }
 
-// GeekPayNotify 支付异步回调
-func (h *PaymentHandler) GeekPayNotify(c *gin.Context) {
+// EPayNotify 易支付支付异步回调
+func (h *PaymentHandler) EPayNotify(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)
-	// 检查支付状态
+	logger.Infof("收到易支付订单支付回调：%+v", params)
+	// 检查支付状态, 如果未支付，则返回成功
 	if params["trade_status"] != "TRADE_SUCCESS" {
 		c.String(http.StatusOK, "success")
 		return
 	}
 
-	sign := h.geekPayService.Sign(params)
+	sign := h.epayService.Sign(params)
 	if sign != c.Query("sign") {
 		logger.Errorf("签名验证失败, %s, %s", sign, c.Query("sign"))
 		c.String(http.StatusOK, "fail")
 		return
 	}
+	// 查询订单状态
+	order, err := h.epayService.Query(params["out_trade_no"])
+	if err != nil {
+		logger.Error(err)
+		c.String(http.StatusOK, "fail")
+		return
+	}
 
-	err := h.notify(params["out_trade_no"], params["trade_no"])
+	err = h.paySuccess(order)
 	if err != nil {
 		logger.Error(err)
 		c.String(http.StatusOK, "fail")
@@ -423,26 +460,23 @@ func (h *PaymentHandler) GeekPayNotify(c *gin.Context) {
 	c.String(http.StatusOK, "success")
 }
 
-// WechatPayNotify 微信商户支付异步回调
-func (h *PaymentHandler) WechatPayNotify(c *gin.Context) {
+// WxpayNotify 微信商户支付异步回调
+func (h *PaymentHandler) WxpayNotify(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(),
-		})
+	orderInfo, err := h.wxpayService.TradeVerify(c.Request)
+	logger.Infof("收到微信商号订单支付回调：%+v", orderInfo)
+	if err != nil {
+		logger.Errorf("订单校验失败：%v", err)
+		c.JSON(http.StatusBadRequest, gin.H{"code": "FAIL"})
 		return
 	}
 
-	err = h.notify(result.OutTradeNo, result.TradeId)
+	err = h.paySuccess(orderInfo)
 	if err != nil {
 		logger.Error(err)
 		c.String(http.StatusOK, "fail")

api/handler/power_log_handler.go

@@ -9,11 +9,13 @@ package handler
 
 import (
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/store/model"
 	"geekai/store/vo"
 	"geekai/utils"
 	"geekai/utils/resp"
+	"time"
 
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
@@ -27,6 +29,18 @@ func NewPowerLogHandler(app *core.AppServer, db *gorm.DB) *PowerLogHandler {
 	return &PowerLogHandler{BaseHandler: BaseHandler{App: app, DB: db}}
 }
 
+// RegisterRoutes 注册路由
+func (h *PowerLogHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/powerLog/")
+
+	// 需要用户授权的接口
+	group.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis))
+	{
+		group.POST("list", h.List)
+		group.GET("stats", h.Stats)
+	}
+}
+
 func (h *PowerLogHandler) List(c *gin.Context) {
 	var data struct {
 		Model    string   `json:"model"`
@@ -72,3 +86,45 @@ func (h *PowerLogHandler) List(c *gin.Context) {
 	}
 	resp.SUCCESS(c, vo.NewPage(total, data.Page, data.PageSize, list))
 }
+
+// Stats 获取用户算力统计
+func (h *PowerLogHandler) Stats(c *gin.Context) {
+	userId := h.GetLoginUserId(c)
+	if userId == 0 {
+		resp.NotAuth(c)
+		return
+	}
+
+	// 获取用户信息（包含余额）
+	var user model.User
+	if err := h.DB.Where("id", userId).First(&user).Error; err != nil {
+		resp.ERROR(c, "用户不存在")
+		return
+	}
+
+	// 计算总消费（所有支出记录）
+	var totalConsume int64
+	h.DB.Model(&model.PowerLog{}).
+		Where("user_id", userId).
+		Where("mark", types.PowerSub).
+		Select("COALESCE(SUM(amount), 0)").
+		Scan(&totalConsume)
+
+	// 计算今日消费
+	today := time.Now().Format("2006-01-02")
+	var todayConsume int64
+	h.DB.Model(&model.PowerLog{}).
+		Where("user_id", userId).
+		Where("mark", types.PowerSub).
+		Where("DATE(created_at) = ?", today).
+		Select("COALESCE(SUM(amount), 0)").
+		Scan(&todayConsume)
+
+	stats := map[string]interface{}{
+		"total":   totalConsume,
+		"today":   todayConsume,
+		"balance": user.Power,
+	}
+
+	resp.SUCCESS(c, stats)
+}

api/handler/product_handler.go

@@ -13,6 +13,7 @@ import (
 	"geekai/store/vo"
 	"geekai/utils"
 	"geekai/utils/resp"
+
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
 )
@@ -25,6 +26,12 @@ func NewProductHandler(app *core.AppServer, db *gorm.DB) *ProductHandler {
 	return &ProductHandler{BaseHandler: BaseHandler{App: app, DB: db}}
 }
 
+// RegisterRoutes 注册路由
+func (h *ProductHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/product/")
+	group.GET("list", h.List)
+}
+
 // List 模型列表
 func (h *ProductHandler) List(c *gin.Context) {
 	var items []model.Product

api/handler/prompt_handler.go

@@ -10,12 +10,14 @@ package handler
 import (
 	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/service"
 	"geekai/store/model"
 	"geekai/utils"
 	"geekai/utils/resp"
 	"strings"
+	"time"
 
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
@@ -39,6 +41,20 @@ func NewPromptHandler(app *core.AppServer, db *gorm.DB, userService *service.Use
 	}
 }
 
+// RegisterRoutes 注册路由
+func (h *PromptHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/prompt/")
+
+	// 需要用户授权的接口
+	group.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis)).Use(middleware.RateLimitEvery(h.App.Redis, 30*time.Second))
+	{
+		group.POST("lyric", h.Lyric)
+		group.POST("image", h.Image)
+		group.POST("video", h.Video)
+		group.POST("meta", h.MetaPrompt)
+	}
+}
+
 // Lyric 生成歌词
 func (h *PromptHandler) Lyric(c *gin.Context) {
 	var data struct {
@@ -48,25 +64,12 @@ func (h *PromptHandler) Lyric(c *gin.Context) {
 		resp.ERROR(c, types.InvalidArgs)
 		return
 	}
-	content, err := utils.OpenAIRequest(h.DB, fmt.Sprintf(service.LyricPromptTemplate, data.Prompt), h.App.SysConfig.AssistantModelId)
+	content, err := utils.OpenAIRequest(h.DB, fmt.Sprintf(service.LyricPromptTemplate, data.Prompt), h.App.SysConfig.Base.AssistantModelId)
 	if err != nil {
 		resp.ERROR(c, err.Error())
 		return
 	}
 
-	if h.App.SysConfig.PromptPower > 0 {
-		userId := h.GetLoginUserId(c)
-		err = h.userService.DecreasePower(userId, h.App.SysConfig.PromptPower, model.PowerLog{
-			Type:   types.PowerConsume,
-			Model:  h.getPromptModel(),
-			Remark: "生成歌词",
-		})
-		if err != nil {
-			resp.ERROR(c, err.Error())
-			return
-		}
-	}
-
 	resp.SUCCESS(c, content)
 }
 
@@ -79,23 +82,12 @@ func (h *PromptHandler) Image(c *gin.Context) {
 		resp.ERROR(c, types.InvalidArgs)
 		return
 	}
-	content, err := utils.OpenAIRequest(h.DB, fmt.Sprintf(service.ImagePromptOptimizeTemplate, data.Prompt), h.App.SysConfig.AssistantModelId)
+	content, err := utils.OpenAIRequest(h.DB, fmt.Sprintf(service.ImagePromptOptimizeTemplate, data.Prompt), h.App.SysConfig.Base.AssistantModelId)
 	if err != nil {
 		resp.ERROR(c, err.Error())
 		return
 	}
-	if h.App.SysConfig.PromptPower > 0 {
-		userId := h.GetLoginUserId(c)
-		err = h.userService.DecreasePower(userId, h.App.SysConfig.PromptPower, model.PowerLog{
-			Type:   types.PowerConsume,
-			Model:  h.getPromptModel(),
-			Remark: "生成绘画提示词",
-		})
-		if err != nil {
-			resp.ERROR(c, err.Error())
-			return
-		}
-	}
+
 	resp.SUCCESS(c, strings.Trim(content, `"`))
 }
 
@@ -108,25 +100,12 @@ func (h *PromptHandler) Video(c *gin.Context) {
 		resp.ERROR(c, types.InvalidArgs)
 		return
 	}
-	content, err := utils.OpenAIRequest(h.DB, fmt.Sprintf(service.VideoPromptTemplate, data.Prompt), h.App.SysConfig.AssistantModelId)
+	content, err := utils.OpenAIRequest(h.DB, fmt.Sprintf(service.VideoPromptTemplate, data.Prompt), h.App.SysConfig.Base.AssistantModelId)
 	if err != nil {
 		resp.ERROR(c, err.Error())
 		return
 	}
 
-	if h.App.SysConfig.PromptPower > 0 {
-		userId := h.GetLoginUserId(c)
-		err = h.userService.DecreasePower(userId, h.App.SysConfig.PromptPower, model.PowerLog{
-			Type:   types.PowerConsume,
-			Model:  h.getPromptModel(),
-			Remark: "生成视频脚本",
-		})
-		if err != nil {
-			resp.ERROR(c, err.Error())
-			return
-		}
-	}
-
 	resp.SUCCESS(c, strings.Trim(content, `"`))
 }
 
@@ -158,9 +137,9 @@ func (h *PromptHandler) MetaPrompt(c *gin.Context) {
 }
 
 func (h *PromptHandler) getPromptModel() string {
-	if h.App.SysConfig.AssistantModelId > 0 {
+	if h.App.SysConfig.Base.AssistantModelId > 0 {
 		var chatModel model.ChatModel
-		h.DB.Where("id", h.App.SysConfig.AssistantModelId).First(&chatModel)
+		h.DB.Where("id", h.App.SysConfig.Base.AssistantModelId).First(&chatModel)
 		return chatModel.Value
 	}
 	return "gpt-4o"

api/handler/realtime_handler.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/service"
 	"geekai/store/model"
@@ -39,6 +40,18 @@ func NewRealtimeHandler(server *core.AppServer, db *gorm.DB, userService *servic
 	return &RealtimeHandler{BaseHandler: BaseHandler{App: server, DB: db}, userService: userService}
 }
 
+// RegisterRoutes 注册路由
+func (h *RealtimeHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/realtime/")
+
+	// 需要用户授权的接口
+	group.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis))
+	{
+		group.Any("", h.Connection)
+		group.POST("voice", h.VoiceChat)
+	}
+}
+
 func (h *RealtimeHandler) Connection(c *gin.Context) {
 	// 获取客户端请求中指定的子协议
 	clientProtocols := c.GetHeader("Sec-WebSocket-Protocol")
@@ -154,7 +167,7 @@ func (h *RealtimeHandler) VoiceChat(c *gin.Context) {
 		return
 	}
 
-	if user.Power < h.App.SysConfig.AdvanceVoicePower {
+	if user.Power < h.App.SysConfig.Base.AdvanceVoicePower {
 		resp.ERROR(c, "当前用户算力不足，无法使用该功能")
 		return
 	}
@@ -198,7 +211,7 @@ func (h *RealtimeHandler) VoiceChat(c *gin.Context) {
 	h.DB.Model(&apiKey).UpdateColumn("last_used_at", time.Now().Unix())
 
 	// 扣减算力
-	err = h.userService.DecreasePower(userId, h.App.SysConfig.AdvanceVoicePower, model.PowerLog{
+	err = h.userService.DecreasePower(userId, h.App.SysConfig.Base.AdvanceVoicePower, model.PowerLog{
 		Type:   types.PowerConsume,
 		Model:  "advanced-voice",
 		Remark: "实时语音通话",

api/handler/redeem_handler.go

@@ -10,14 +10,16 @@ package handler
 import (
 	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/service"
 	"geekai/store/model"
 	"geekai/utils/resp"
-	"github.com/gin-gonic/gin"
-	"gorm.io/gorm"
 	"sync"
 	"time"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
 )
 
 type RedeemHandler struct {
@@ -30,6 +32,17 @@ func NewRedeemHandler(app *core.AppServer, db *gorm.DB, userService *service.Use
 	return &RedeemHandler{BaseHandler: BaseHandler{App: app, DB: db}, userService: userService}
 }
 
+// RegisterRoutes 注册路由
+func (h *RedeemHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/redeem/")
+
+	// 需要用户授权的接口
+	group.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis))
+	{
+		group.POST("verify", h.Verify)
+	}
+}
+
 func (h *RedeemHandler) Verify(c *gin.Context) {
 	var data struct {
 		Code string `json:"code"`

api/handler/sd_handler.go

@@ -10,8 +10,10 @@ package handler
 import (
 	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/service"
+	"geekai/service/moderation"
 	"geekai/service/oss"
 	"geekai/service/sd"
 	"geekai/store"
@@ -28,12 +30,13 @@ import (
 
 type SdJobHandler struct {
 	BaseHandler
-	redis       *redis.Client
-	sdService   *sd.Service
-	uploader    *oss.UploaderManager
-	snowflake   *service.Snowflake
-	leveldb     *store.LevelDB
-	userService *service.UserService
+	redis             *redis.Client
+	sdService         *sd.Service
+	uploader          *oss.UploaderManager
+	snowflake         *service.Snowflake
+	leveldb           *store.LevelDB
+	userService       *service.UserService
+	moderationManager *moderation.ServiceManager
 }
 
 func NewSdJobHandler(app *core.AppServer,
@@ -42,13 +45,15 @@ func NewSdJobHandler(app *core.AppServer,
 	manager *oss.UploaderManager,
 	snowflake *service.Snowflake,
 	userService *service.UserService,
-	levelDB *store.LevelDB) *SdJobHandler {
+	levelDB *store.LevelDB,
+	moderationManager *moderation.ServiceManager) *SdJobHandler {
 	return &SdJobHandler{
-		sdService:   service,
-		uploader:    manager,
-		snowflake:   snowflake,
-		leveldb:     levelDB,
-		userService: userService,
+		sdService:         service,
+		uploader:          manager,
+		snowflake:         snowflake,
+		leveldb:           levelDB,
+		userService:       userService,
+		moderationManager: moderationManager,
 		BaseHandler: BaseHandler{
 			App: app,
 			DB:  db,
@@ -56,6 +61,23 @@ func NewSdJobHandler(app *core.AppServer,
 	}
 }
 
+// RegisterRoutes 注册路由
+func (h *SdJobHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/sd/")
+
+	// 公开接口，不需要授权
+	group.GET("imgWall", h.ImgWall)
+
+	// 需要用户授权的接口
+	group.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis))
+	{
+		group.POST("image", h.Image)
+		group.GET("jobs", h.JobList)
+		group.GET("remove", h.Remove)
+		group.GET("publish", h.Publish)
+	}
+}
+
 func (h *SdJobHandler) preCheck(c *gin.Context) bool {
 	user, err := h.GetLoginUser(c)
 	if err != nil {
@@ -63,7 +85,7 @@ func (h *SdJobHandler) preCheck(c *gin.Context) bool {
 		return false
 	}
 
-	if user.Power < h.App.SysConfig.SdPower {
+	if user.Power < h.App.SysConfig.Base.SdPower {
 		resp.ERROR(c, "当前用户剩余算力不足以完成本次绘画！")
 		return false
 	}
@@ -84,6 +106,29 @@ func (h *SdJobHandler) Image(c *gin.Context) {
 		return
 	}
 
+	if h.App.SysConfig.Moderation.Enable {
+		moderationResult, err := h.moderationManager.GetService().Moderate(data.Prompt)
+		if err != nil {
+			logger.Error("failed to moderate content: ", err)
+		}
+		if moderationResult.Flagged {
+			// 记录违规内容
+			moderation := model.Moderation{
+				UserId: h.GetLoginUserId(c),
+				Source: types.ModerationSourceSD,
+				Input:  data.Prompt,
+				Result: utils.JsonEncode(moderationResult),
+			}
+			err = h.DB.Create(&moderation).Error
+			if err != nil {
+				logger.Error("failed to save moderation: ", err)
+			}
+			resp.ERROR(c, "当前创作内容包含敏感词，请重新输入！")
+			return
+		}
+
+	}
+
 	if data.Width <= 0 {
 		data.Width = 512
 	}
@@ -131,7 +176,7 @@ func (h *SdJobHandler) Image(c *gin.Context) {
 			HdSteps:      data.HdSteps,
 		},
 		UserId:           userId,
-		TranslateModelId: h.App.SysConfig.AssistantModelId,
+		TranslateModelId: h.App.SysConfig.Base.AssistantModelId,
 	}
 
 	job := model.SdJob{
@@ -142,7 +187,7 @@ func (h *SdJobHandler) Image(c *gin.Context) {
 		TaskInfo:  utils.JsonEncode(task),
 		Prompt:    data.Prompt,
 		Progress:  0,
-		Power:     h.App.SysConfig.SdPower,
+		Power:     h.App.SysConfig.Base.SdPower,
 		CreatedAt: time.Now(),
 	}
 	res := h.DB.Create(&job)

api/handler/sms_handler.go

@@ -24,24 +24,31 @@ const CodeStorePrefix = "/verify/codes/"
 
 type SmsHandler struct {
 	BaseHandler
-	redis   *redis.Client
-	sms     *sms.ServiceManager
-	smtp    *service.SmtpService
-	captcha *service.CaptchaService
+	redis          *redis.Client
+	sms            *sms.SmsManager
+	smtp           *service.SmtpService
+	captchaService *service.CaptchaService
 }
 
 func NewSmsHandler(
 	app *core.AppServer,
 	client *redis.Client,
-	sms *sms.ServiceManager,
+	sms *sms.SmsManager,
 	smtp *service.SmtpService,
 	captcha *service.CaptchaService) *SmsHandler {
 	return &SmsHandler{
-		redis:       client,
-		sms:         sms,
-		captcha:     captcha,
-		smtp:        smtp,
-		BaseHandler: BaseHandler{App: app}}
+		redis:          client,
+		sms:            sms,
+		captchaService: captcha,
+		smtp:           smtp,
+		BaseHandler:    BaseHandler{App: app}}
+}
+
+// RegisterRoutes 注册路由
+func (h *SmsHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/sms/")
+	// 无需授权的接口
+	group.POST("code", h.SendCode)
 }
 
 // SendCode 发送验证码
@@ -56,12 +63,12 @@ func (h *SmsHandler) SendCode(c *gin.Context) {
 		resp.ERROR(c, types.InvalidArgs)
 		return
 	}
-	if h.App.SysConfig.EnabledVerify {
+	if h.captchaService.GetConfig().Enabled {
 		var check bool
 		if data.X != 0 {
-			check = h.captcha.SlideCheck(data)
+			check = h.captchaService.SlideCheck(data)
 		} else {
-			check = h.captcha.Check(data)
+			check = h.captchaService.Check(data)
 		}
 		if !check {
 			resp.ERROR(c, "请先完人机验证")
@@ -72,14 +79,14 @@ func (h *SmsHandler) SendCode(c *gin.Context) {
 	code := utils.RandomNumber(6)
 	var err error
 	if strings.Contains(data.Receiver, "@") { // email
-		if !utils.Contains(h.App.SysConfig.RegisterWays, "email") {
+		if !utils.Contains(h.App.SysConfig.Base.RegisterWays, "email") {
 			resp.ERROR(c, "系统已禁用邮箱注册！")
 			return
 		}
 		// 检查邮箱后缀是否在白名单
-		if len(h.App.SysConfig.EmailWhiteList) > 0 {
+		if len(h.App.SysConfig.Base.EmailWhiteList) > 0 {
 			inWhiteList := false
-			for _, suffix := range h.App.SysConfig.EmailWhiteList {
+			for _, suffix := range h.App.SysConfig.Base.EmailWhiteList {
 				if strings.HasSuffix(data.Receiver, suffix) {
 					inWhiteList = true
 					break
@@ -92,7 +99,7 @@ func (h *SmsHandler) SendCode(c *gin.Context) {
 		}
 		err = h.smtp.SendVerifyCode(data.Receiver, code)
 	} else {
-		if !utils.Contains(h.App.SysConfig.RegisterWays, "mobile") {
+		if !utils.Contains(h.App.SysConfig.Base.RegisterWays, "mobile") {
 			resp.ERROR(c, "系统已禁用手机号注册！")
 			return
 		}

api/handler/suno_handler.go

@@ -10,8 +10,10 @@ package handler
 import (
 	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/service"
+	"geekai/service/moderation"
 	"geekai/service/oss"
 	"geekai/service/suno"
 	"geekai/store/model"
@@ -26,20 +28,41 @@ import (
 
 type SunoHandler struct {
 	BaseHandler
-	sunoService *suno.Service
-	uploader    *oss.UploaderManager
-	userService *service.UserService
+	sunoService       *suno.Service
+	uploader          *oss.UploaderManager
+	userService       *service.UserService
+	moderationManager *moderation.ServiceManager
 }
 
-func NewSunoHandler(app *core.AppServer, db *gorm.DB, service *suno.Service, uploader *oss.UploaderManager, userService *service.UserService) *SunoHandler {
+func NewSunoHandler(app *core.AppServer, db *gorm.DB, service *suno.Service, uploader *oss.UploaderManager, userService *service.UserService, moderationManager *moderation.ServiceManager) *SunoHandler {
 	return &SunoHandler{
 		BaseHandler: BaseHandler{
 			App: app,
 			DB:  db,
 		},
-		sunoService: service,
-		uploader:    uploader,
-		userService: userService,
+		sunoService:       service,
+		uploader:          uploader,
+		userService:       userService,
+		moderationManager: moderationManager,
+	}
+}
+
+// RegisterRoutes 注册路由
+func (h *SunoHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/suno/")
+
+	// 公开接口，不需要授权
+	group.GET("play", h.Play)
+
+	// 需要用户授权的接口
+	group.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis))
+	{
+		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)
 	}
 }
 
@@ -64,13 +87,36 @@ func (h *SunoHandler) Create(c *gin.Context) {
 		return
 	}
 
+	if h.App.SysConfig.Moderation.Enable {
+		moderationResult, err := h.moderationManager.GetService().Moderate(data.Prompt)
+		if err != nil {
+			logger.Error("failed to moderate content: ", err)
+		}
+		if moderationResult.Flagged {
+			// 记录违规内容
+			moderation := model.Moderation{
+				UserId: h.GetLoginUserId(c),
+				Source: types.ModerationSourceSuno,
+				Input:  data.Prompt,
+				Result: utils.JsonEncode(moderationResult),
+			}
+			err = h.DB.Create(&moderation).Error
+			if err != nil {
+				logger.Error("failed to save moderation: ", err)
+			}
+			resp.ERROR(c, "当前创作内容包含敏感词，请重新输入！")
+			return
+		}
+
+	}
+
 	user, err := h.GetLoginUser(c)
 	if err != nil {
 		resp.NotAuth(c)
 		return
 	}
 
-	if user.Power < h.App.SysConfig.SunoPower {
+	if user.Power < h.App.SysConfig.Base.SunoPower {
 		resp.ERROR(c, "您的算力不足，请充值后再试！")
 		return
 	}
@@ -118,7 +164,7 @@ func (h *SunoHandler) Create(c *gin.Context) {
 		RefSongId:    data.RefSongId,
 		RefTaskId:    data.RefTaskId,
 		ExtendSecs:   data.ExtendSecs,
-		Power:        h.App.SysConfig.SunoPower,
+		Power:        h.App.SysConfig.Base.SunoPower,
 		SongId:       utils.RandString(32),
 	}
 	if data.Lyrics != "" {

api/handler/test_handler.go

@@ -1,21 +1,36 @@
 package handler
 
 import (
+	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/service"
 	"geekai/service/payment"
+	"net/http"
+
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
-	"net/http"
 )
 
 type TestHandler struct {
+	App       *core.AppServer
 	db        *gorm.DB
 	snowflake *service.Snowflake
-	js        *payment.GeekPayService
+	js        *payment.EPayService
 }
 
-func NewTestHandler(db *gorm.DB, snowflake *service.Snowflake, js *payment.GeekPayService) *TestHandler {
-	return &TestHandler{db: db, snowflake: snowflake, js: js}
+func NewTestHandler(app *core.AppServer, db *gorm.DB, snowflake *service.Snowflake, js *payment.EPayService) *TestHandler {
+	return &TestHandler{App: app, db: db, snowflake: snowflake, js: js}
+}
+
+// RegisterRoutes 注册路由
+func (h *TestHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/test/")
+
+	// 需要用户授权的接口
+	group.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis))
+	{
+		group.Any("sse", h.PostTest, h.SseTest)
+	}
 }
 
 func (h *TestHandler) SseTest(c *gin.Context) {

api/handler/user_handler.go

@@ -8,8 +8,10 @@ package handler
 // * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 import (
+	"context"
 	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/service"
 	"geekai/store"
@@ -20,8 +22,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/imroc/req/v3"
-
 	"github.com/go-redis/redis/v8"
 	"github.com/golang-jwt/jwt/v5"
 
@@ -35,9 +35,10 @@ type UserHandler struct {
 	searcher       *xdb.Searcher
 	redis          *redis.Client
 	levelDB        *store.LevelDB
-	licenseService *service.LicenseService
-	captcha        *service.CaptchaService
+	captchaService *service.CaptchaService
 	userService    *service.UserService
+	wxLoginService *service.WxLoginService
+	ipSearcher     *xdb.Searcher
 }
 
 func NewUserHandler(
@@ -48,15 +49,43 @@ func NewUserHandler(
 	levelDB *store.LevelDB,
 	captcha *service.CaptchaService,
 	userService *service.UserService,
-	licenseService *service.LicenseService) *UserHandler {
+	wxLoginService *service.WxLoginService,
+	ipSearcher *xdb.Searcher) *UserHandler {
 	return &UserHandler{
 		BaseHandler:    BaseHandler{DB: db, App: app},
 		searcher:       searcher,
 		redis:          client,
 		levelDB:        levelDB,
-		captcha:        captcha,
-		licenseService: licenseService,
+		captchaService: captcha,
 		userService:    userService,
+		wxLoginService: wxLoginService,
+		ipSearcher:     ipSearcher,
+	}
+}
+
+// RegisterRoutes 注册路由
+func (h *UserHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/user/")
+
+	// 公开接口，不需要授权
+	group.POST("register", h.Register)
+	group.POST("login", h.Login)
+	group.POST("resetPass", h.ResetPass)
+	group.GET("login/qrcode", h.GetWxLoginQRCode)
+	group.POST("login/callback", h.WxLoginCallback)
+	group.GET("login/status", h.GetWxLoginState)
+	group.GET("logout", h.Logout)
+
+	// 需要用户授权的接口
+	group.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis))
+	{
+		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.GET("signin", h.SignIn)
 	}
 }
 
@@ -80,12 +109,13 @@ func (h *UserHandler) Register(c *gin.Context) {
 		return
 	}
 
-	if h.App.SysConfig.EnabledVerify && data.RegWay == "username" {
+	// 人机验证
+	if h.captchaService.GetConfig().Enabled {
 		var check bool
 		if data.X != 0 {
-			check = h.captcha.SlideCheck(data)
+			check = h.captchaService.SlideCheck(data)
 		} else {
-			check = h.captcha.Check(data)
+			check = h.captchaService.Check(data)
 		}
 		if !check {
 			resp.ERROR(c, "请先完人机验证")
@@ -99,14 +129,6 @@ func (h *UserHandler) Register(c *gin.Context) {
 		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" {
@@ -125,30 +147,8 @@ func (h *UserHandler) Register(c *gin.Context) {
 		}
 	}
 
-	// 验证邀请码
-	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"}), // 默认只订阅通用助手角色
-		ChatConfig: "{}",
-		ChatModels: "{}",
-		Power:      h.App.SysConfig.InitPower,
-	}
-
 	// check if the username is existing
+	user := model.User{Username: data.Username, Password: data.Password}
 	var item model.User
 	session := h.DB.Session(&gorm.Session{})
 	if data.Mobile != "" {
@@ -168,78 +168,19 @@ func (h *UserHandler) Register(c *gin.Context) {
 		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 {
-		defaultNickname := h.App.SysConfig.DefaultNickname
-		if defaultNickname == "" {
-			defaultNickname = "极客学长"
-		}
-		user.Nickname = fmt.Sprintf("%s@%d", defaultNickname, utils.RandomNumber(6))
-	}
-
-	tx := h.DB.Begin()
-	if err := tx.Create(&user).Error; err != nil {
+	user, err := h.createNewUser(user, data.InviteCode)
+	if 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(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))
+	token, err := h.doLogin(&user, c.ClientIP())
 	if err != nil {
-		resp.ERROR(c, "Failed to generate token, "+err.Error())
+		resp.ERROR(c, 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})
+
+	resp.SUCCESS(c, gin.H{"token": token, "user_id": user.Id, "username": user.Username})
 }
 
 // Login 用户登录
@@ -255,15 +196,12 @@ func (h *UserHandler) Login(c *gin.Context) {
 		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 {
+	if h.captchaService.GetConfig().Enabled {
 		var check bool
 		if data.X != 0 {
-			check = h.captcha.SlideCheck(data)
+			check = h.captchaService.SlideCheck(data)
 		} else {
-			check = h.captcha.Check(data)
+			check = h.captchaService.Check(data)
 		}
 		if !check {
 			resp.ERROR(c, "请先完人机验证")
@@ -274,54 +212,28 @@ func (h *UserHandler) Login(c *gin.Context) {
 	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 {
+	if !user.Status {
 		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))
+	token, err := h.doLogin(&user, c.ClientIP())
 	if err != nil {
-		resp.ERROR(c, "Failed to generate token, "+err.Error())
+		resp.ERROR(c, 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})
+
+	resp.SUCCESS(c, gin.H{"token": token, "user_id": user.Id, "username": user.Username})
 }
 
 // Logout 注 销
@@ -333,134 +245,168 @@ func (h *UserHandler) Logout(c *gin.Context) {
 	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)
+// GetWxLoginQRCode 获取微信登录二维码URL
+func (h *UserHandler) GetWxLoginQRCode(c *gin.Context) {
+	if !h.wxLoginService.GetConfig().Enabled {
+		resp.ERROR(c, "微信登录功能未启用")
+		return
+	}
+
+	if h.wxLoginService.GetConfig().ApiKey == "" {
+		resp.ERROR(c, "微信登录服务令牌未配置")
+		return
+	}
+
+	state := utils.RandString(32)
+	qrCodeURL, err := h.wxLoginService.GetLoginQrCodeUrl(state)
 	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)
+	resp.SUCCESS(c, gin.H{
+		"url":   qrCodeURL,
+		"state": state,
+	})
 }
 
-// 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")
+// 查询微信登录状态
+func (h *UserHandler) GetWxLoginState(c *gin.Context) {
+	state := c.Query("state")
+	if state == "" {
+		resp.ERROR(c, "参数错误")
+		return
+	}
 
-	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)
+	status, err := h.wxLoginService.GetLoginStatus(state)
 	if err != nil {
 		resp.ERROR(c, err.Error())
 		return
 	}
-	if r.IsErrorState() {
-		resp.ERROR(c, "error with login http status: "+r.Status)
+
+	if status.Status != service.LoginStatusSuccess {
+		resp.SUCCESS(c, 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
+	h.DB.Where("openid = ?", status.OpenID).First(&user)
+	if user.Id == 0 {
+		// 创建新用户
+		user, err = h.createNewUser(model.User{OpenId: status.OpenID}, "")
 		if err != nil {
-			resp.ERROR(c, "绑定用户不存在")
+			resp.ERROR(c, err.Error())
 			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": ""})
+	token, err := h.doLogin(&user, c.ClientIP())
+	if err != nil {
+		resp.ERROR(c, err.Error())
 		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
-		}
+	status.Status = service.LoginStatusExpired
+	h.wxLoginService.SetLoginStatus(state, *status)
 
-		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"]),
-		}
+	status.Status = service.LoginStatusSuccess
+	status.Token = token
+	resp.SUCCESS(c, status)
+}
 
-		tx = h.DB.Create(&user)
-		if tx.Error != nil {
-			resp.ERROR(c, "保存数据失败")
-			logger.Error(tx.Error)
-			return
+// createNewUser 创建新用户
+func (h *UserHandler) createNewUser(user model.User, code string) (model.User, error) {
+	if user.OpenId != "" {
+		user.Platform = "wechat"
+		user.Nickname = fmt.Sprintf("微信用户@%d", utils.RandomNumber(6))
+		user.Username = fmt.Sprintf("wx@%d", utils.RandomNumber(8))
+		user.Password = "geekai123"
+	} else {
+		user.Nickname = fmt.Sprintf("用户@%d", utils.RandomNumber(6))
+		if user.Username == "" || user.Password == "" {
+			return user, fmt.Errorf("用户名或密码不能为空")
 		}
-		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()),
-		})
 	}
 
+	salt := utils.RandString(8)
+	user.Salt = salt
+	user.Password = utils.GenPassword(user.Password, salt)
+	user.Avatar = "/images/avatar/user.png"
+	user.Status = true
+	user.ChatRoles = utils.JsonEncode([]string{"gpt"})
+	user.ChatConfig = "{}"
+	user.ChatModels = "{}"
+	user.Power = h.App.SysConfig.Base.InitPower
+
+	// 创建用户
+	tx := h.DB.Begin()
+	if err := tx.Create(&user).Error; err != nil {
+		tx.Rollback()
+		return user, err
+	}
+
+	// 记录邀请关系
+	if code != "" {
+		var inviteCode model.InviteCode
+		err := h.DB.Where("code = ?", code).First(&inviteCode).Error
+		if err != nil {
+			logger.Error("无效的邀请码：", err.Error())
+			tx.Rollback()
+			return user, fmt.Errorf("无效的邀请码")
+		}
+
+		// 增加邀请数量
+		h.DB.Model(&model.InviteCode{}).Where("code = ?", code).UpdateColumn("reg_num", gorm.Expr("reg_num + ?", 1))
+		if h.App.SysConfig.Base.InvitePower > 0 {
+			err := h.userService.IncreasePower(inviteCode.UserId, h.App.SysConfig.Base.InvitePower, model.PowerLog{
+				Type:   types.PowerInvite,
+				Model:  "Invite",
+				Remark: fmt.Sprintf("邀请用户注册奖励，金额：%d，邀请码：%s，新用户：%s", h.App.SysConfig.Base.InvitePower, inviteCode.Code, user.Username),
+			})
+			if err != nil {
+				tx.Rollback()
+				return user, err
+			}
+
+			// 添加邀请记录
+			err = tx.Create(&model.InviteLog{
+				InviterId:  inviteCode.UserId,
+				UserId:     user.Id,
+				Username:   user.Username,
+				InviteCode: inviteCode.Code,
+				Remark:     fmt.Sprintf("奖励 %d 算力", h.App.SysConfig.Base.InvitePower),
+			}).Error
+			if err != nil {
+				tx.Rollback()
+				return user, err
+			}
+		}
+	}
+
+	tx.Commit()
+
+	return user, nil
+}
+
+// doLogin 执行登录操作
+func (h *UserHandler) doLogin(user *model.User, ip string) (string, error) {
+	// 更新最后登录时间和IP
+	user.LastLoginIp = ip
+	user.LastLoginAt = time.Now().Unix()
+	err := h.DB.Model(user).Updates(user).Error
+	if err != nil {
+		return "", fmt.Errorf("failed to update user: %v", err)
+	}
+
+	// 记录登录日志
+	h.DB.Create(&model.UserLoginLog{
+		UserId:       user.Id,
+		Username:     user.Username,
+		LoginIp:      ip,
+		LoginAddress: utils.Ip2Region(h.ipSearcher, ip),
+	})
+
 	// 创建 token
 	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
 		"user_id": user.Id,
@@ -468,17 +414,42 @@ func (h *UserHandler) CLoginCallback(c *gin.Context) {
 	})
 	tokenString, err := token.SignedString([]byte(h.App.Config.Session.SecretKey))
 	if err != nil {
-		resp.ERROR(c, "Failed to generate token, "+err.Error())
-		return
+		return "", fmt.Errorf("failed to generate token: %v", err)
 	}
+
 	// 保存到 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())
+	sessionKey := fmt.Sprintf("users/%d", user.Id)
+	if _, err = h.redis.Set(context.Background(), sessionKey, tokenString, 0).Result(); err != nil {
+		return "", fmt.Errorf("error with save token: %v", err)
+	}
+
+	return tokenString, nil
+}
+
+// WxLoginCallback 微信登录回调处理
+func (h *UserHandler) WxLoginCallback(c *gin.Context) {
+	var data struct {
+		OpenID string `json:"openid"`
+		State  string `json:"state"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
 		return
 	}
-	session["token"] = tokenString
-	resp.SUCCESS(c, session)
+
+	if data.OpenID == "" || data.State == "" {
+		resp.ERROR(c, "参数错误")
+		return
+	}
+
+	// 设置登录状态
+	status := service.LoginStatus{
+		Status: service.LoginStatusSuccess,
+		OpenID: data.OpenID,
+	}
+	h.wxLoginService.SetLoginStatus(data.State, status)
+
+	resp.SUCCESS(c, status)
 }
 
 // Session 获取/验证会话
@@ -742,11 +713,11 @@ func (h *UserHandler) SignIn(c *gin.Context) {
 
 	// 签到
 	h.levelDB.Put(key, true)
-	if h.App.SysConfig.DailyPower > 0 {
-		h.userService.IncreasePower(userId, h.App.SysConfig.DailyPower, model.PowerLog{
+	if h.App.SysConfig.Base.DailyPower > 0 {
+		h.userService.IncreasePower(userId, h.App.SysConfig.Base.DailyPower, model.PowerLog{
 			Type:   types.PowerSignIn,
 			Model:  "SignIn",
-			Remark: fmt.Sprintf("每日签到奖励，金额：%d", h.App.SysConfig.DailyPower),
+			Remark: fmt.Sprintf("每日签到奖励，金额：%d", h.App.SysConfig.Base.DailyPower),
 		})
 	}
 	resp.SUCCESS(c)

api/handler/video_handler.go

@@ -10,8 +10,10 @@ package handler
 import (
 	"fmt"
 	"geekai/core"
+	"geekai/core/middleware"
 	"geekai/core/types"
 	"geekai/service"
+	"geekai/service/moderation"
 	"geekai/service/oss"
 	"geekai/service/video"
 	"geekai/store/model"
@@ -26,20 +28,37 @@ import (
 
 type VideoHandler struct {
 	BaseHandler
-	videoService *video.Service
-	uploader     *oss.UploaderManager
-	userService  *service.UserService
+	videoService      *video.Service
+	uploader          *oss.UploaderManager
+	userService       *service.UserService
+	moderationManager *moderation.ServiceManager
 }
 
-func NewVideoHandler(app *core.AppServer, db *gorm.DB, service *video.Service, uploader *oss.UploaderManager, userService *service.UserService) *VideoHandler {
+func NewVideoHandler(app *core.AppServer, db *gorm.DB, service *video.Service, uploader *oss.UploaderManager, userService *service.UserService, moderationManager *moderation.ServiceManager) *VideoHandler {
 	return &VideoHandler{
 		BaseHandler: BaseHandler{
 			App: app,
 			DB:  db,
 		},
-		videoService: service,
-		uploader:     uploader,
-		userService:  userService,
+		videoService:      service,
+		uploader:          uploader,
+		userService:       userService,
+		moderationManager: moderationManager,
+	}
+}
+
+// RegisterRoutes 注册路由
+func (h *VideoHandler) RegisterRoutes() {
+	group := h.App.Engine.Group("/api/video/")
+
+	// 需要用户授权的接口
+	group.Use(middleware.UserAuthMiddleware(h.App.Config.Session.SecretKey, h.App.Redis))
+	{
+		group.POST("luma/create", h.LumaCreate)
+		group.POST("keling/create", h.KeLingCreate)
+		group.GET("list", h.List)
+		group.GET("remove", h.Remove)
+		group.GET("publish", h.Publish)
 	}
 }
 
@@ -62,13 +81,36 @@ func (h *VideoHandler) LumaCreate(c *gin.Context) {
 		return
 	}
 
+	if h.App.SysConfig.Moderation.Enable {
+		moderationResult, err := h.moderationManager.GetService().Moderate(data.Prompt)
+		if err != nil {
+			logger.Error("failed to moderate content: ", err)
+		}
+		if moderationResult.Flagged {
+			// 记录违规内容
+			moderation := model.Moderation{
+				UserId: h.GetLoginUserId(c),
+				Source: types.ModerationSourceVideo,
+				Input:  data.Prompt,
+				Result: utils.JsonEncode(moderationResult),
+			}
+			err = h.DB.Create(&moderation).Error
+			if err != nil {
+				logger.Error("failed to save moderation: ", err)
+			}
+			resp.ERROR(c, "当前创作内容包含敏感词，请重新输入！")
+			return
+		}
+
+	}
+
 	user, err := h.GetLoginUser(c)
 	if err != nil {
 		resp.NotAuth(c)
 		return
 	}
 
-	if user.Power < h.App.SysConfig.LumaPower {
+	if user.Power < h.App.SysConfig.Base.LumaPower {
 		resp.ERROR(c, "您的算力不足，请充值后再试！")
 		return
 	}
@@ -85,14 +127,14 @@ func (h *VideoHandler) LumaCreate(c *gin.Context) {
 		Type:             types.VideoLuma,
 		Prompt:           data.Prompt,
 		Params:           params,
-		TranslateModelId: h.App.SysConfig.AssistantModelId,
+		TranslateModelId: h.App.SysConfig.Base.AssistantModelId,
 	}
 	// 插入数据库
 	job := model.VideoJob{
 		UserId:   uint(userId),
 		Type:     types.VideoLuma,
 		Prompt:   data.Prompt,
-		Power:    h.App.SysConfig.LumaPower,
+		Power:    h.App.SysConfig.Base.LumaPower,
 		TaskInfo: utils.JsonEncode(task),
 	}
 	tx := h.DB.Create(&job)
@@ -147,7 +189,7 @@ func (h *VideoHandler) KeLingCreate(c *gin.Context) {
 
 	// 计算当前任务所需算力
 	key := fmt.Sprintf("%s_%s_%s", data.Model, data.Mode, data.Duration)
-	power := h.App.SysConfig.KeLingPowers[key]
+	power := h.App.SysConfig.Base.KeLingPowers[key]
 	if power == 0 {
 		resp.ERROR(c, "当前模型暂不支持")
 		return
@@ -181,7 +223,7 @@ func (h *VideoHandler) KeLingCreate(c *gin.Context) {
 		Type:             types.VideoKeLing,
 		Prompt:           data.Prompt,
 		Params:           params,
-		TranslateModelId: h.App.SysConfig.AssistantModelId,
+		TranslateModelId: h.App.SysConfig.Base.AssistantModelId,
 		Channel:          data.Channel,
 	}
 	// 插入数据库

api/main.go

@@ -19,10 +19,12 @@ import (
 	"geekai/service/dalle"
 	"geekai/service/jimeng"
 	"geekai/service/mj"
+	"geekai/service/moderation"
 	"geekai/service/oss"
 	"geekai/service/payment"
 	"geekai/service/sd"
 	"geekai/service/sms"
+	"geekai/service/sora"
 	"geekai/service/suno"
 	"geekai/service/video"
 	"geekai/store"
@@ -30,7 +32,7 @@ import (
 	"log"
 	"os"
 	"os/signal"
-	"strconv"
+	"runtime/debug"
 	"syscall"
 	"time"
 
@@ -71,15 +73,16 @@ func main() {
 	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)
+	defer func() {
+		if err := recover(); err != nil {
+			logger.Error("Panic Error:", err)
+			// 打印堆栈信息
+			if os.Getenv("GEEKAI_DEBUG") == "true" {
+				debug.PrintStack()
 			}
-		}()
-	}
+		}
+	}()
 
 	app := fx.New(
 		// 初始化配置应用配置
@@ -89,16 +92,16 @@ func main() {
 				log.Fatal(err)
 			}
 			config.Path = configFile
-			if debug {
-				_ = core.SaveConfig(config)
-			}
 			return config
 		}),
 		// 创建应用服务
 		fx.Provide(core.NewServer),
 		// 初始化
 		fx.Invoke(func(s *core.AppServer, client *redis.Client) {
-			s.Init(debug, client)
+			s.Init(client)
+		}),
+		fx.Provide(func(db *gorm.DB) *types.SystemConfig {
+			return core.LoadSystemConfig(db)
 		}),
 
 		// 初始化数据库
@@ -126,7 +129,7 @@ func main() {
 		}),
 
 		// 创建控制器
-		fx.Provide(handler.NewChatRoleHandler),
+		fx.Provide(handler.NewChatAppHandler),
 		fx.Provide(handler.NewUserHandler),
 		fx.Provide(handler.NewChatHandler),
 		fx.Provide(handler.NewNetHandler),
@@ -143,6 +146,12 @@ func main() {
 		fx.Provide(handler.NewPowerLogHandler),
 		fx.Provide(handler.NewJimengHandler),
 
+		fx.Provide(service.NewMigrationService),
+		fx.Invoke(func(migrationService *service.MigrationService) {
+			migrationService.StartMigrate()
+		}),
+
+		// 管理后台控制器
 		fx.Provide(admin.NewConfigHandler),
 		fx.Provide(admin.NewAdminHandler),
 		fx.Provide(admin.NewApiKeyHandler),
@@ -153,16 +162,12 @@ func main() {
 		fx.Provide(admin.NewChatModelHandler),
 		fx.Provide(admin.NewProductHandler),
 		fx.Provide(admin.NewOrderHandler),
-		fx.Provide(admin.NewChatHandler),
 		fx.Provide(admin.NewPowerLogHandler),
 		fx.Provide(admin.NewAdminJimengHandler),
 
-		// 创建服务
-		fx.Provide(sms.NewSendServiceManager),
-		fx.Provide(func(config *types.AppConfig) *service.CaptchaService {
-			return service.NewCaptchaService(config.ApiConfig)
-		}),
-		fx.Provide(oss.NewUploaderManager),
+		// 邮件服务
+		fx.Provide(service.NewSmtpService),
+		// Dalle 服务
 		fx.Provide(dalle.NewService),
 		fx.Invoke(func(s *dalle.Service) {
 			s.Run()
@@ -170,14 +175,6 @@ func main() {
 			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),
@@ -187,6 +184,9 @@ func main() {
 			s.DownloadImages()
 		}),
 
+		// Sora service
+		fx.Provide(sora.NewSoraService),
+
 		// Stable Diffusion 机器人
 		fx.Provide(sd.NewService),
 		fx.Invoke(func(s *sd.Service, config *types.AppConfig) {
@@ -208,302 +208,175 @@ func main() {
 		}),
 
 		// 即梦AI 服务
+		fx.Provide(jimeng.NewClient),
 		fx.Provide(jimeng.NewService),
 		fx.Invoke(func(service *jimeng.Service) {
 			service.Start()
 		}),
-		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.Provide(sms.NewAliYunSmsService),
+		fx.Provide(sms.NewBaoSmsService),
+		fx.Provide(sms.NewSmsManager),
+		fx.Provide(service.NewCaptchaService),
+		fx.Provide(service.NewWxLoginService),
+
+		// 支付服务
+		fx.Provide(payment.NewAlipayService),
+		fx.Provide(payment.NewEPayService),
+		fx.Provide(payment.NewWxpayService),
+
+		// 文件上传服务
+		fx.Provide(oss.NewLocalStorage),
+		fx.Provide(oss.NewMiniOss),
+		fx.Provide(oss.NewQiNiuOss),
+		fx.Provide(oss.NewAliYunOss),
+		fx.Provide(oss.NewUploaderManager),
+
+		// 用户服务
+		fx.Provide(service.NewUserService),
+
+		// 文本审查服务
+		fx.Provide(moderation.NewGiteeAIModeration),
+		fx.Provide(moderation.NewBaiduAIModeration),
+		fx.Provide(moderation.NewTencentAIModeration),
+		fx.Provide(moderation.NewServiceManager),
+		fx.Provide(admin.NewModerationHandler),
+		fx.Invoke(func(s *core.AppServer, h *admin.ModerationHandler) {
+			h.RegisterRoutes()
 		}),
 
 		// 注册路由
-		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.ChatAppHandler) {
+			h.RegisterRoutes()
 		}),
 		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)
-			group.GET("signin", h.SignIn)
+			h.RegisterRoutes()
 		}),
 		fx.Invoke(func(s *core.AppServer, h *handler.ChatHandler) {
-			group := s.Engine.Group("/api/chat/")
-			group.Any("message", h.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)
-			group.POST("tts", h.TextToSpeech)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		fx.Invoke(func(s *core.AppServer, h *handler.SmsHandler) {
-			group := s.Engine.Group("/api/sms/")
-			group.POST("code", h.SendCode)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		fx.Invoke(func(s *core.AppServer, h *handler.RedeemHandler) {
-			group := s.Engine.Group("/api/redeem/")
-			group.POST("verify", h.Verify)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 
-		// 管理后台控制器
+		// 管理后台路由注册
 		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)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		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.GET("genLoginLink", h.GenLoginLink)
-			group.POST("resetPass", h.ResetPass)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		fx.Invoke(func(s *core.AppServer, h *admin.DashboardHandler) {
-			group := s.Engine.Group("/api/admin/dashboard/")
-			group.GET("stats", h.Stats)
+			h.RegisterRoutes()
 		}),
 		fx.Invoke(func(s *core.AppServer, h *handler.ChatModelHandler) {
-			group := s.Engine.Group("/api/model/")
-			group.GET("list", h.List)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
+			h.StartSyncOrders()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		fx.Invoke(func(s *core.AppServer, h *handler.ProductHandler) {
-			group := s.Engine.Group("/api/product/")
-			group.GET("list", h.List)
+			h.RegisterRoutes()
 		}),
 
 		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)
+			h.RegisterRoutes()
 		}),
 
 		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)
+			h.RegisterRoutes()
 		}),
 
 		fx.Provide(admin.NewUploadHandler),
 		fx.Invoke(func(s *core.AppServer, h *admin.UploadHandler) {
-			s.Engine.POST("/api/admin/upload", h.Upload)
+			h.RegisterRoutes()
 		}),
 
 		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.POST("websearch", h.WebSearch)
-			group.GET("list", h.List)
+			h.RegisterRoutes()
 		}),
+		fx.Provide(admin.NewChatHandler),
 		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)
+			h.RegisterRoutes()
 		}),
 		fx.Invoke(func(s *core.AppServer, h *handler.PowerLogHandler) {
-			group := s.Engine.Group("/api/powerLog/")
-			group.POST("list", h.List)
+			h.RegisterRoutes()
 		}),
 		fx.Invoke(func(s *core.AppServer, h *admin.PowerLogHandler) {
-			group := s.Engine.Group("/api/admin/powerLog/")
-			group.POST("list", h.List)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		fx.Provide(handler.NewMenuHandler),
 		fx.Invoke(func(s *core.AppServer, h *handler.MenuHandler) {
-			group := s.Engine.Group("/api/menu/")
-			group.GET("list", h.List)
+			h.RegisterRoutes()
 		}),
 		fx.Provide(handler.NewMarkMapHandler),
 		fx.Invoke(func(s *core.AppServer, h *handler.MarkMapHandler) {
-			s.Engine.POST("/api/markMap/gen", h.Generate)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		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.POST("keling/create", h.KeLingCreate)
-			group.GET("list", h.List)
-			group.GET("remove", h.Remove)
-			group.GET("publish", h.Publish)
+			h.RegisterRoutes()
 		}),
 
 		// 即梦AI 路由
@@ -515,30 +388,19 @@ func main() {
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		fx.Invoke(func(s *core.AppServer, db *gorm.DB) {
 			go func() {
@@ -563,23 +425,15 @@ func main() {
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 		fx.Provide(admin.NewMediaHandler),
 		fx.Invoke(func(s *core.AppServer, h *admin.MediaHandler) {
-			group := s.Engine.Group("/api/admin/media")
-			group.POST("/suno", h.SunoList)
-			group.POST("/videos", h.Videos)
-			group.GET("/remove", h.Remove)
+			h.RegisterRoutes()
 		}),
 		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)
+			h.RegisterRoutes()
 		}),
 	)
 	// 启动应用程序

api/res/certs/alipay/alipayPublicCert.crt

@@ -1,38 +0,0 @@
------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

@@ -1,88 +0,0 @@
------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-----
-MIIF0zCCA7ugAwIBAgIIH8+hjWpIDREwDQYJKoZIhvcNAQELBQAwejELMAkGA1UE
-BhMCQ04xFjAUBgNVBAoMDUFudCBGaW5hbmNpYWwxIDAeBgNVBAsMF0NlcnRpZmlj
-YXRpb24gQXV0aG9yaXR5MTEwLwYDVQQDDChBbnQgRmluYW5jaWFsIENlcnRpZmlj
-YXRpb24gQXV0aG9yaXR5IFIxMB4XDTE4MDMyMTEzNDg0MFoXDTM4MDIyODEzNDg0
-MFowejELMAkGA1UEBhMCQ04xFjAUBgNVBAoMDUFudCBGaW5hbmNpYWwxIDAeBgNV
-BAsMF0NlcnRpZmljYXRpb24gQXV0aG9yaXR5MTEwLwYDVQQDDChBbnQgRmluYW5j
-aWFsIENlcnRpZmljYXRpb24gQXV0aG9yaXR5IFIxMIICIjANBgkqhkiG9w0BAQEF
-AAOCAg8AMIICCgKCAgEAtytTRcBNuur5h8xuxnlKJetT65cHGemGi8oD+beHFPTk
-rUTlFt9Xn7fAVGo6QSsPb9uGLpUFGEdGmbsQ2q9cV4P89qkH04VzIPwT7AywJdt2
-xAvMs+MgHFJzOYfL1QkdOOVO7NwKxH8IvlQgFabWomWk2Ei9WfUyxFjVO1LVh0Bp
-dRBeWLMkdudx0tl3+21t1apnReFNQ5nfX29xeSxIhesaMHDZFViO/DXDNW2BcTs6
-vSWKyJ4YIIIzStumD8K1xMsoaZBMDxg4itjWFaKRgNuPiIn4kjDY3kC66Sl/6yTl
-YUz8AybbEsICZzssdZh7jcNb1VRfk79lgAprm/Ktl+mgrU1gaMGP1OE25JCbqli1
-Pbw/BpPynyP9+XulE+2mxFwTYhKAwpDIDKuYsFUXuo8t261pCovI1CXFzAQM2w7H
-DtA2nOXSW6q0jGDJ5+WauH+K8ZSvA6x4sFo4u0KNCx0ROTBpLif6GTngqo3sj+98
-SZiMNLFMQoQkjkdN5Q5g9N6CFZPVZ6QpO0JcIc7S1le/g9z5iBKnifrKxy0TQjtG
-PsDwc8ubPnRm/F82RReCoyNyx63indpgFfhN7+KxUIQ9cOwwTvemmor0A+ZQamRe
-9LMuiEfEaWUDK+6O0Gl8lO571uI5onYdN1VIgOmwFbe+D8TcuzVjIZ/zvHrAGUcC
-AwEAAaNdMFswCwYDVR0PBAQDAgEGMAwGA1UdEwQFMAMBAf8wHQYDVR0OBBYEFF90
-tATATwda6uWx2yKjh0GynOEBMB8GA1UdIwQYMBaAFF90tATATwda6uWx2yKjh0Gy
-nOEBMA0GCSqGSIb3DQEBCwUAA4ICAQCVYaOtqOLIpsrEikE5lb+UARNSFJg6tpkf
-tJ2U8QF/DejemEHx5IClQu6ajxjtu0Aie4/3UnIXop8nH/Q57l+Wyt9T7N2WPiNq
-JSlYKYbJpPF8LXbuKYG3BTFTdOVFIeRe2NUyYh/xs6bXGr4WKTXb3qBmzR02FSy3
-IODQw5Q6zpXj8prYqFHYsOvGCEc1CwJaSaYwRhTkFedJUxiyhyB5GQwoFfExCVHW
-05ZFCAVYFldCJvUzfzrWubN6wX0DD2dwultgmldOn/W/n8at52mpPNvIdbZb2F41
-T0YZeoWnCJrYXjq/32oc1cmifIHqySnyMnavi75DxPCdZsCOpSAT4j4lAQRGsfgI
-kkLPGQieMfNNkMCKh7qjwdXAVtdqhf0RVtFILH3OyEodlk1HYXqX5iE5wlaKzDop
-PKwf2Q3BErq1xChYGGVS+dEvyXc/2nIBlt7uLWKp4XFjqekKbaGaLJdjYP5b2s7N
-1dM0MXQ/f8XoXKBkJNzEiM3hfsU6DOREgMc1DIsFKxfuMwX3EkVQM1If8ghb6x5Y
-jXayv+NLbidOSzk4vl5QwngO/JYFMkoc6i9LNwEaEtR9PhnrdubxmrtM+RjfBm02
-77q3dSWFESFQ4QxYWew4pHE0DpWbWy/iMIKQ6UZ5RLvB8GEcgt8ON7BBJeMc+Dyi
-kT9qhqn+lw==
------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

@@ -1,19 +0,0 @@
------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

@@ -1 +0,0 @@
-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

@@ -8,35 +8,38 @@ package service
 // * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 import (
-	"errors"
 	"fmt"
 	"geekai/core/types"
-	"github.com/imroc/req/v3"
 	"time"
+
+	"github.com/imroc/req/v3"
 )
 
 type CaptchaService struct {
-	config types.ApiConfig
+	config types.CaptchaConfig
 	client *req.Client
 }
 
-func NewCaptchaService(config types.ApiConfig) *CaptchaService {
+func NewCaptchaService(sysConfig *types.SystemConfig) *CaptchaService {
 	return &CaptchaService{
-		config: config,
+		config: sysConfig.Captcha,
 		client: req.C().SetTimeout(10 * time.Second),
 	}
 }
 
-func (s *CaptchaService) Get() (interface{}, error) {
-	if s.config.Token == "" {
-		return nil, errors.New("无效的 API Token")
-	}
+func (s *CaptchaService) UpdateConfig(config types.CaptchaConfig) {
+	s.config = config
+}
 
-	url := fmt.Sprintf("%s/api/captcha/get", s.config.ApiURL)
+func (s *CaptchaService) GetConfig() types.CaptchaConfig {
+	return s.config
+}
+
+func (s *CaptchaService) Get() (any, error) {
+	url := fmt.Sprintf("%s/api/captcha/get", types.GeekAPIURL)
 	var res types.BizVo
 	r, err := s.client.R().
-		SetHeader("AppId", s.config.AppId).
-		SetHeader("Authorization", fmt.Sprintf("Bearer %s", s.config.Token)).
+		SetHeader("Authorization", fmt.Sprintf("Bearer %s", s.config.ApiKey)).
 		SetSuccessResult(&res).Get(url)
 	if err != nil || r.IsErrorState() {
 		return nil, fmt.Errorf("请求 API 失败：%v", err)
@@ -49,12 +52,11 @@ func (s *CaptchaService) Get() (interface{}, error) {
 	return res.Data, nil
 }
 
-func (s *CaptchaService) Check(data interface{}) bool {
-	url := fmt.Sprintf("%s/api/captcha/check", s.config.ApiURL)
+func (s *CaptchaService) Check(data any) bool {
+	url := fmt.Sprintf("%s/api/captcha/check", types.GeekAPIURL)
 	var res types.BizVo
 	r, err := s.client.R().
-		SetHeader("AppId", s.config.AppId).
-		SetHeader("Authorization", fmt.Sprintf("Bearer %s", s.config.Token)).
+		SetHeader("Authorization", fmt.Sprintf("Bearer %s", s.config.ApiKey)).
 		SetBodyJsonMarshal(data).
 		SetSuccessResult(&res).Post(url)
 	if err != nil || r.IsErrorState() {
@@ -68,16 +70,11 @@ func (s *CaptchaService) Check(data interface{}) bool {
 	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)
+func (s *CaptchaService) SlideGet() (any, error) {
+	url := fmt.Sprintf("%s/api/captcha/slide/get", types.GeekAPIURL)
 	var res types.BizVo
 	r, err := s.client.R().
-		SetHeader("AppId", s.config.AppId).
-		SetHeader("Authorization", fmt.Sprintf("Bearer %s", s.config.Token)).
+		SetHeader("Authorization", fmt.Sprintf("Bearer %s", s.config.ApiKey)).
 		SetSuccessResult(&res).Get(url)
 	if err != nil || r.IsErrorState() {
 		return nil, fmt.Errorf("请求 API 失败：%v", err)
@@ -90,12 +87,11 @@ func (s *CaptchaService) SlideGet() (interface{}, error) {
 	return res.Data, nil
 }
 
-func (s *CaptchaService) SlideCheck(data interface{}) bool {
-	url := fmt.Sprintf("%s/api/captcha/slide/check", s.config.ApiURL)
+func (s *CaptchaService) SlideCheck(data any) bool {
+	url := fmt.Sprintf("%s/api/captcha/slide/check", types.GeekAPIURL)
 	var res types.BizVo
 	r, err := s.client.R().
-		SetHeader("AppId", s.config.AppId).
-		SetHeader("Authorization", fmt.Sprintf("Bearer %s", s.config.Token)).
+		SetHeader("Authorization", fmt.Sprintf("Bearer %s", s.config.ApiKey)).
 		SetBodyJsonMarshal(data).
 		SetSuccessResult(&res).Post(url)
 	if err != nil || r.IsErrorState() {

api/service/crawler/service.go

@@ -1,333 +0,0 @@
-package crawler
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"geekai/logger"
-	"net/url"
-	"strings"
-	"time"
-
-	"github.com/go-rod/rod"
-	"github.com/go-rod/rod/lib/launcher"
-	"github.com/go-rod/rod/lib/proto"
-)
-
-// Service 网络爬虫服务
-type Service struct {
-	browser *rod.Browser
-}
-
-// NewService 创建一个新的爬虫服务
-func NewService() (*Service, error) {
-	// 启动浏览器
-	path, _ := launcher.LookPath()
-	u := launcher.New().Bin(path).
-		Headless(true).                    // 无头模式
-		Set("disable-web-security", "").   // 禁用网络安全限制
-		Set("disable-gpu", "").            // 禁用 GPU 加速
-		Set("no-sandbox", "").             // 禁用沙箱模式
-		Set("disable-setuid-sandbox", ""). // 禁用 setuid 沙箱
-		MustLaunch()
-
-	browser := rod.New().ControlURL(u).MustConnect()
-
-	return &Service{
-		browser: browser,
-	}, nil
-}
-
-// SearchResult 搜索结果
-type SearchResult struct {
-	Title   string `json:"title"`   // 标题
-	URL     string `json:"url"`     // 链接
-	Content string `json:"content"` // 内容摘要
-}
-
-// WebSearch 网络搜索
-func (s *Service) WebSearch(keyword string, maxPages int) ([]SearchResult, error) {
-	if keyword == "" {
-		return nil, errors.New("搜索关键词不能为空")
-	}
-
-	if maxPages <= 0 {
-		maxPages = 1
-	}
-	if maxPages > 10 {
-		maxPages = 10 // 最多搜索 10 页
-	}
-
-	results := make([]SearchResult, 0)
-
-	// 使用百度搜索
-	searchURL := fmt.Sprintf("https://www.baidu.com/s?wd=%s", url.QueryEscape(keyword))
-
-	// 设置页面超时
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	// 创建页面
-	page := s.browser.MustPage()
-	defer page.MustClose()
-
-	// 设置视口大小
-	err := page.SetViewport(&proto.EmulationSetDeviceMetricsOverride{
-		Width:  1280,
-		Height: 800,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("设置视口失败: %v", err)
-	}
-
-	// 导航到搜索页面
-	err = page.Context(ctx).Navigate(searchURL)
-	if err != nil {
-		return nil, fmt.Errorf("导航到搜索页面失败: %v", err)
-	}
-
-	// 等待搜索结果加载完成
-	err = page.WaitLoad()
-	if err != nil {
-		return nil, fmt.Errorf("等待页面加载完成失败: %v", err)
-	}
-
-	// 分析当前页面的搜索结果
-	for i := 0; i < maxPages; i++ {
-		if i > 0 {
-			// 点击下一页按钮
-			nextPage, err := page.Element("a.n")
-			if err != nil || nextPage == nil {
-				break // 没有下一页
-			}
-
-			err = nextPage.Click(proto.InputMouseButtonLeft, 1)
-			if err != nil {
-				break // 点击下一页失败
-			}
-
-			// 等待新页面加载
-			err = page.WaitLoad()
-			if err != nil {
-				break
-			}
-		}
-
-		// 提取搜索结果
-		resultElements, err := page.Elements(".result, .c-container")
-		if err != nil || resultElements == nil {
-			continue
-		}
-
-		for _, result := range resultElements {
-			// 获取标题
-			titleElement, err := result.Element("h3, .t")
-			if err != nil || titleElement == nil {
-				continue
-			}
-
-			title, err := titleElement.Text()
-			if err != nil {
-				continue
-			}
-
-			// 获取 URL
-			linkElement, err := titleElement.Element("a")
-			if err != nil || linkElement == nil {
-				continue
-			}
-
-			href, err := linkElement.Attribute("href")
-			if err != nil || href == nil {
-				continue
-			}
-
-			// 获取内容摘要 - 尝试多个可能的选择器
-			var contentElement *rod.Element
-			var content string
-
-			// 尝试多个可能的选择器来适应不同版本的百度搜索结果
-			selectors := []string{".content-right_8Zs40", ".c-abstract", ".content_LJ0WN", ".content"}
-			for _, selector := range selectors {
-				contentElement, err = result.Element(selector)
-				if err == nil && contentElement != nil {
-					content, _ = contentElement.Text()
-					if content != "" {
-						break
-					}
-				}
-			}
-
-			// 如果所有选择器都失败，尝试直接从结果块中提取文本
-			if content == "" {
-				// 获取结果元素的所有文本
-				fullText, err := result.Text()
-				if err == nil && fullText != "" {
-					// 简单处理：从全文中移除标题，剩下的可能是摘要
-					fullText = strings.Replace(fullText, title, "", 1)
-					// 清理文本
-					content = strings.TrimSpace(fullText)
-					// 限制内容长度
-					if len(content) > 200 {
-						content = content[:200] + "..."
-					}
-				}
-			}
-
-			// 添加到结果集
-			results = append(results, SearchResult{
-				Title:   title,
-				URL:     *href,
-				Content: content,
-			})
-
-			// 限制结果数量，每页最多 10 条
-			if len(results) >= 10*maxPages {
-				break
-			}
-		}
-	}
-
-	// 获取真实 URL（百度搜索结果中的 URL 是短链接，需要跳转获取真实 URL）
-	for i, result := range results {
-		realURL, err := s.getRedirectURL(result.URL)
-		if err == nil && realURL != "" {
-			results[i].URL = realURL
-		}
-	}
-
-	return results, nil
-}
-
-// 获取真实 URL
-func (s *Service) getRedirectURL(shortURL string) (string, error) {
-	// 创建页面
-	page, err := s.browser.Page(proto.TargetCreateTarget{URL: ""})
-	if err != nil {
-		return shortURL, err // 返回原始URL
-	}
-	defer func() {
-		_ = page.Close()
-	}()
-
-	// 导航到短链接
-	err = page.Navigate(shortURL)
-	if err != nil {
-		return shortURL, err // 返回原始URL
-	}
-
-	// 等待重定向完成
-	time.Sleep(2 * time.Second)
-
-	// 获取当前 URL
-	info, err := page.Info()
-	if err != nil {
-		return shortURL, err // 返回原始URL
-	}
-
-	return info.URL, nil
-}
-
-// Close 关闭浏览器
-func (s *Service) Close() error {
-	if s.browser != nil {
-		err := s.browser.Close()
-		s.browser = nil
-		return err
-	}
-	return nil
-}
-
-// SearchWeb 封装的搜索方法
-func SearchWeb(keyword string, maxPages int) (string, error) {
-	// 添加panic恢复机制
-	defer func() {
-		if r := recover(); r != nil {
-			log := logger.GetLogger()
-			log.Errorf("爬虫服务崩溃: %v", r)
-		}
-	}()
-
-	service, err := NewService()
-	if err != nil {
-		return "", fmt.Errorf("创建爬虫服务失败: %v", err)
-	}
-	defer service.Close()
-
-	// 设置超时上下文
-	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
-	defer cancel()
-
-	// 使用goroutine和通道来处理超时
-	resultChan := make(chan []SearchResult, 1)
-	errChan := make(chan error, 1)
-
-	go func() {
-		results, err := service.WebSearch(keyword, maxPages)
-		if err != nil {
-			errChan <- err
-			return
-		}
-		resultChan <- results
-	}()
-
-	// 等待结果或超时
-	select {
-	case <-ctx.Done():
-		return "", fmt.Errorf("搜索超时: %v", ctx.Err())
-	case err := <-errChan:
-		return "", fmt.Errorf("搜索失败: %v", err)
-	case results := <-resultChan:
-		if len(results) == 0 {
-			return "未找到关于 \"" + keyword + "\" 的相关搜索结果", nil
-		}
-
-		// 格式化结果
-		var builder strings.Builder
-		builder.WriteString(fmt.Sprintf("为您找到关于 \"%s\" 的 %d 条搜索结果：\n\n", keyword, len(results)))
-
-		for i, result := range results {
-			// // 尝试打开链接获取实际内容
-			// page := service.browser.MustPage()
-			// defer page.MustClose()
-
-			// // 设置页面超时
-			// pageCtx, pageCancel := context.WithTimeout(context.Background(), 10*time.Second)
-			// defer pageCancel()
-
-			// // 导航到目标页面
-			// err := page.Context(pageCtx).Navigate(result.URL)
-			// if err == nil {
-			// 	// 等待页面加载
-			// 	_ = page.WaitLoad()
-
-			// 	// 获取页面标题
-			// 	title, err := page.Eval("() => document.title")
-			// 	if err == nil && title.Value.String() != "" {
-			// 		result.Title = title.Value.String()
-			// 	}
-
-			// 	// 获取页面主要内容
-			// 	if content, err := page.Element("body"); err == nil {
-			// 		if text, err := content.Text(); err == nil {
-			// 			// 清理并截取内容
-			// 			text = strings.TrimSpace(text)
-			// 			if len(text) > 200 {
-			// 				text = text[:200] + "..."
-			// 			}
-			// 			result.Prompt = text
-			// 		}
-			// 	}
-			// }
-
-			builder.WriteString(fmt.Sprintf("%d. **%s**\n", i+1, result.Title))
-			builder.WriteString(fmt.Sprintf("   链接: %s\n", result.URL))
-			if result.Content != "" {
-				builder.WriteString(fmt.Sprintf("   摘要: %s\n", result.Content))
-			}
-			builder.WriteString("\n")
-		}
-
-		return builder.String(), nil
-	}
-}

api/service/dalle/dalle_service.go

@@ -94,12 +94,12 @@ func (s *Service) Run() {
 }
 
 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"`
+	Model          string   `json:"model"`
+	Image          []string `json:"image,omitempty"`
+	Prompt         string   `json:"prompt"`
+	AspectRatio    string   `json:"aspect_ratio,omitempty"`
+	Size           string   `json:"size,omitempty"`
+	ResponseFormat string   `json:"response_format,omitempty"`
 }
 
 type imgRes struct {
@@ -113,30 +113,21 @@ type imgRes struct {
 
 type ErrRes struct {
 	Error struct {
-		Code    interface{} `json:"code"`
-		Message string      `json:"message"`
-		Param   interface{} `json:"param"`
-		Type    string      `json:"type"`
+		Code    any    `json:"code"`
+		Message string `json:"message"`
+		Param   any    `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
 	if task.ModelId > 0 {
 		s.db.Where("id", task.ModelId).First(&chatModel)
 	} else {
-		s.db.Where("value", task.ModelName).First(&chatModel)
+		s.db.Where("value", task.ModelValue).First(&chatModel)
 	}
 
 	// get image generation API KEY
@@ -159,13 +150,18 @@ func (s *Service) Image(task types.DallTask, sync bool) (string, error) {
 	}
 	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,
+		Model:          chatModel.Value,
+		Prompt:         task.Prompt,
+		AspectRatio:    task.AspectRatio,
+		Size:           task.Size,
+		ResponseFormat: "url",
 	}
+
+	// 图片编辑
+	if len(task.Image) > 0 {
+		reqBody.Image = task.Image
+	}
+
 	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).
@@ -186,9 +182,9 @@ func (s *Service) Image(task types.DallTask, sync bool) (string, error) {
 	// 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{}{
+	var data = map[string]any{
 		"progress": 100,
-		"prompt":   prompt,
+		"prompt":   task.Prompt,
 	}
 	// 如果返回的是base64，则需要上传到oss
 	if res.Data[0].B64Json != "" {
@@ -210,11 +206,7 @@ func (s *Service) Image(task types.DallTask, sync bool) (string, error) {
 
 	var content string
 	if sync {
-		imgURL, err := s.downloadImage(task.Id, 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)
+		content = fmt.Sprintf("```\n%s\n```\n下面是我为你创作的图片：\n\n![](%s)\n", task.Prompt, imgURL)
 	}
 
 	return content, nil

api/service/jimeng/client.go

@@ -1,26 +1,42 @@
 package jimeng
 
 import (
+	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
+	"geekai/core/types"
 	"net/http"
 	"net/url"
+	"strings"
+	"time"
 
 	"github.com/volcengine/volc-sdk-golang/base"
 	"github.com/volcengine/volc-sdk-golang/service/visual"
+	"github.com/volcengine/volcengine-go-sdk/service/arkruntime"
+	"github.com/volcengine/volcengine-go-sdk/service/arkruntime/model"
+	"github.com/volcengine/volcengine-go-sdk/volcengine"
 )
 
 // Client 即梦API客户端
 type Client struct {
 	visual *visual.Visual
+	config types.JimengConfig
 }
 
 // NewClient 创建即梦API客户端
-func NewClient(accessKey, secretKey string) *Client {
+func NewClient(sysConfig *types.SystemConfig) *Client {
+
+	client := &Client{}
+	client.UpdateConfig(sysConfig.Jimeng)
+	return client
+}
+
+func (c *Client) UpdateConfig(config types.JimengConfig) error {
 	// 使用官方SDK的visual实例
 	visualInstance := visual.NewInstance()
-	visualInstance.Client.SetAccessKey(accessKey)
-	visualInstance.Client.SetSecretKey(secretKey)
+	visualInstance.Client.SetAccessKey(config.AccessKey)
+	visualInstance.Client.SetSecretKey(config.SecretKey)
 
 	// 添加即梦AI专有的API配置
 	jimengApis := map[string]*base.ApiInfo{
@@ -40,6 +56,22 @@ func NewClient(accessKey, secretKey string) *Client {
 				"Version": []string{"2022-08-31"},
 			},
 		},
+		"CVSubmitTask": {
+			Method: http.MethodPost,
+			Path:   "/",
+			Query: url.Values{
+				"Action":  []string{"CVSubmitTask"},
+				"Version": []string{"2022-08-31"},
+			},
+		},
+		"CVGetResult": {
+			Method: http.MethodPost,
+			Path:   "/",
+			Query: url.Values{
+				"Action":  []string{"CVGetResult"},
+				"Version": []string{"2022-08-31"},
+			},
+		},
 		"CVProcess": {
 			Method: http.MethodPost,
 			Path:   "/",
@@ -55,13 +87,52 @@ func NewClient(accessKey, secretKey string) *Client {
 		visualInstance.Client.ApiInfoList[name] = info
 	}
 
-	return &Client{
-		visual: visualInstance,
+	c.config = config
+	c.visual = visualInstance
+
+	return c.testConnection()
+}
+
+// GetErrorMessage 根据错误代码获取对应的错误信息
+func GetErrorMessage(code int) string {
+	if message, exists := errorCodeMessages[code]; exists {
+		return message
 	}
+	return fmt.Sprintf("未知错误代码: %d", code)
+}
+
+// HandleResponseError 处理响应错误，根据错误代码返回详细的错误信息
+func HandleResponseError(code int, message string) error {
+	if code == ECSuccess {
+		return nil
+	}
+	return errors.New(GetErrorMessage(code))
+}
+
+// testConnection 测试即梦AI连接
+func (c *Client) testConnection() error {
+
+	// 使用一个简单的查询任务来测试连接
+	testReq := &QueryTaskRequest{
+		ReqKey: "test_connection",
+		TaskId: "test_task_id_12345",
+	}
+
+	_, err := c.QueryTask(testReq, ASyncActionGetResult)
+	// 即使任务不存在，只要不是认证错误就说明连接正常
+	if err != nil {
+		// 检查是否是认证错误
+		if strings.Contains(err.Error(), "InvalidAccessKey") {
+			return fmt.Errorf("认证失败，请检查AccessKey和SecretKey是否正确")
+		}
+		// 其他错误（如任务不存在）说明连接正常
+		return nil
+	}
+	return nil
 }
 
 // SubmitTask 提交异步任务
-func (c *Client) SubmitTask(req *SubmitTaskRequest) (*SubmitTaskResponse, error) {
+func (c *Client) SubmitTask(req map[string]any) (*SubmitTaskResponse, error) {
 	// 直接将请求转为map[string]interface{}
 	reqBodyBytes, err := json.Marshal(req)
 	if err != nil {
@@ -70,9 +141,14 @@ func (c *Client) SubmitTask(req *SubmitTaskRequest) (*SubmitTaskResponse, error)
 
 	// 直接使用序列化后的字节
 	jsonBody := reqBodyBytes
+	action := ASyncActionSubmit
+	if v, ok := req["action"]; ok {
+		action = v.(string)
+		delete(req, "action")
+	}
 
 	// 调用SDK的JSON方法
-	respBody, statusCode, err := c.visual.Client.Json("CVSync2AsyncSubmitTask", nil, string(jsonBody))
+	respBody, statusCode, err := c.visual.Client.Json(action, nil, string(jsonBody))
 	if err != nil {
 		return nil, fmt.Errorf("submit task failed (status: %d): %w", statusCode, err)
 	}
@@ -85,11 +161,70 @@ func (c *Client) SubmitTask(req *SubmitTaskRequest) (*SubmitTaskResponse, error)
 		return nil, fmt.Errorf("unmarshal response failed: %w", err)
 	}
 
+	// 检查响应错误代码
+	if err := HandleResponseError(result.Code, result.Message); err != nil {
+		return nil, err
+	}
+
 	return &result, nil
 }
 
+// 识别数字人主体
+func (c *Client) AvatarRecognition(imgUrl string, reqKey string) error {
+	params := map[string]any{
+		"image_url": imgUrl,
+		"req_key":   reqKey,
+	}
+	reqBodyBytes, err := json.Marshal(params)
+	if err != nil {
+		return fmt.Errorf("marshal request failed: %w", err)
+	}
+	// 调用SDK的JSON方法
+	respBody, statusCode, err := c.visual.Client.Json(SyncActionSubmit, nil, string(reqBodyBytes))
+	if err != nil {
+		return fmt.Errorf("submit task failed (status: %d): %w", statusCode, err)
+	}
+
+	// 解析响应
+	var result SubmitTaskResponse
+	if err := json.Unmarshal(respBody, &result); err != nil {
+		return fmt.Errorf("unmarshal response failed: %w", err)
+	}
+
+	// 检查响应错误代码
+	if err := HandleResponseError(result.Code, result.Message); err != nil {
+		return err
+	}
+
+	// 等待任务完成
+	for {
+		resp, err := c.QueryTask(&QueryTaskRequest{
+			ReqKey: reqKey,
+			TaskId: result.Data.TaskId,
+		}, SyncActionGetResult)
+		if err != nil {
+			return fmt.Errorf("query task failed: %w", err)
+		}
+		if resp.Data.Status != types.JMTaskStatusDone {
+			time.Sleep(time.Second * 3)
+			continue
+		}
+		var respData map[string]int
+		if err := json.Unmarshal([]byte(resp.Data.RespData), &respData); err != nil {
+			return fmt.Errorf("unmarshal response failed: %w", err)
+		}
+		logger.Debugf("Jimeng AvatarRecognition Response: %+v", resp)
+		if respData["status"] == 1 {
+			return nil
+		} else {
+			return errors.New("不包含人、类人、拟人等主体")
+		}
+
+	}
+}
+
 // QueryTask 查询任务结果
-func (c *Client) QueryTask(req *QueryTaskRequest) (*QueryTaskResponse, error) {
+func (c *Client) QueryTask(req *QueryTaskRequest, action string) (*QueryTaskResponse, error) {
 	// 序列化请求
 	jsonBody, err := json.Marshal(req)
 	if err != nil {
@@ -97,7 +232,7 @@ func (c *Client) QueryTask(req *QueryTaskRequest) (*QueryTaskResponse, error) {
 	}
 
 	// 调用SDK的JSON方法
-	respBody, statusCode, err := c.visual.Client.Json("CVSync2AsyncGetResult", nil, string(jsonBody))
+	respBody, statusCode, err := c.visual.Client.Json(action, nil, string(jsonBody))
 	if err != nil {
 		return nil, fmt.Errorf("query task failed (status: %d): %w", statusCode, err)
 	}
@@ -110,30 +245,37 @@ func (c *Client) QueryTask(req *QueryTaskRequest) (*QueryTaskResponse, error) {
 		return nil, fmt.Errorf("unmarshal response failed: %w", err)
 	}
 
-	return &result, nil
-}
-
-// SubmitSyncTask 提交同步任务（仅用于文生图）
-func (c *Client) SubmitSyncTask(req *SubmitTaskRequest) (*QueryTaskResponse, error) {
-	// 序列化请求
-	jsonBody, err := json.Marshal(req)
-	if err != nil {
-		return nil, fmt.Errorf("marshal request failed: %w", err)
-	}
-
-	// 调用SDK的JSON方法
-	respBody, statusCode, err := c.visual.Client.Json("CVProcess", nil, string(jsonBody))
-	if err != nil {
-		return nil, fmt.Errorf("submit sync task failed (status: %d): %w", statusCode, err)
-	}
-
-	logger.Infof("Jimeng SubmitSyncTask Response: %s", string(respBody))
-
-	// 解析响应，同步任务直接返回结果
-	var result QueryTaskResponse
-	if err := json.Unmarshal(respBody, &result); err != nil {
-		return nil, fmt.Errorf("unmarshal response failed: %w", err)
+	// 检查响应错误代码
+	if err := HandleResponseError(result.Code, result.Message); err != nil {
+		return nil, err
 	}
 
 	return &result, nil
 }
+
+// SubmitSyncImageTask 提交同步生图任务
+func (c *Client) SubmitSyncImageTask(req types.JimengTaskRequest) (*model.ImagesResponse, error) {
+	// 配置火山引擎访问密钥，目前只支持API Key验证
+	client := arkruntime.NewClientWithApiKey(c.config.ApiKey)
+	// 构造生图请求
+	sequentialImageGeneration := model.SequentialImageGeneration("disabled")
+	generateReq := model.GenerateImagesRequest{
+		Model:                     req.ReqKey,                                               // 模型名称
+		Prompt:                    req.Prompt,                                               // 提示词
+		Size:                      volcengine.String(req.Size),                              // 图片尺寸
+		SequentialImageGeneration: &sequentialImageGeneration,                               // 禁用序列生成
+		ResponseFormat:            volcengine.String(model.GenerateImagesResponseFormatURL), // 响应格式为 URL
+		Watermark:                 volcengine.Bool(false),                                   // 不添加水印
+		OptimizePrompt:            volcengine.Bool(true),                                    // 优化提示词
+	}
+	if len(req.ImageUrls) > 0 {
+		generateReq.Image = req.ImageUrls
+	}
+	// 调用生图 API
+	resp, err := client.GenerateImages(context.Background(), generateReq)
+	if err != nil {
+		return nil, err
+	}
+
+	return &resp, nil
+}

api/service/jimeng/service.go

@@ -4,20 +4,19 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"strconv"
 	"strings"
 	"time"
 
 	"gorm.io/gorm"
 
+	"geekai/core/types"
 	logger2 "geekai/logger"
+	"geekai/service"
 	"geekai/service/oss"
 	"geekai/store"
 	"geekai/store/model"
 	"geekai/utils"
 
-	"geekai/core/types"
-
 	"github.com/go-redis/redis/v8"
 )
 
@@ -25,38 +24,31 @@ var logger = logger2.GetLogger()
 
 // Service 即梦服务（合并了消费者功能）
 type Service struct {
-	db        *gorm.DB
-	redis     *redis.Client
-	taskQueue *store.RedisQueue
-	client    *Client
-	ctx       context.Context
-	cancel    context.CancelFunc
-	running   bool
-	uploader  *oss.UploaderManager
+	db          *gorm.DB
+	redis       *redis.Client
+	taskQueue   *store.RedisQueue
+	client      *Client
+	ctx         context.Context
+	cancel      context.CancelFunc
+	running     bool
+	uploader    *oss.UploaderManager
+	userService *service.UserService
 }
 
 // NewService 创建即梦服务
-func NewService(db *gorm.DB, redisCli *redis.Client, uploader *oss.UploaderManager) *Service {
+func NewService(db *gorm.DB, redisCli *redis.Client, uploader *oss.UploaderManager, client *Client, userService *service.UserService) *Service {
 	taskQueue := store.NewRedisQueue("JimengTaskQueue", redisCli)
-	// 从数据库加载配置
-	var config model.Config
-	db.Where("name = ?", "Jimeng").First(&config)
-	var jimengConfig types.JimengConfig
-	if config.Id > 0 {
-		_ = utils.JsonDecode(config.Value, &jimengConfig)
-	}
-	client := NewClient(jimengConfig.AccessKey, jimengConfig.SecretKey)
-
 	ctx, cancel := context.WithCancel(context.Background())
 	return &Service{
-		db:        db,
-		redis:     redisCli,
-		taskQueue: taskQueue,
-		client:    client,
-		ctx:       ctx,
-		cancel:    cancel,
-		running:   false,
-		uploader:  uploader,
+		db:          db,
+		redis:       redisCli,
+		taskQueue:   taskQueue,
+		client:      client,
+		ctx:         ctx,
+		cancel:      cancel,
+		running:     false,
+		uploader:    uploader,
+		userService: userService,
 	}
 }
 
@@ -107,35 +99,29 @@ func (s *Service) processNextTask() {
 
 	if err := s.ProcessTask(jobId); err != nil {
 		logger.Errorf("process jimeng task failed: job_id=%d, error=%v", jobId, err)
-		s.UpdateJobStatus(jobId, model.JMTaskStatusFailed, err.Error())
+		s.UpdateJobStatus(jobId, types.JMTaskStatusFailed, err.Error())
 	} else {
 		logger.Infof("Jimeng task processed successfully: job_id=%d", jobId)
 	}
 }
 
 // CreateTask 创建任务
-func (s *Service) CreateTask(userId uint, req *CreateTaskRequest) (*model.JimengJob, error) {
+func (s *Service) CreateTask(userId uint, req *types.JimengTaskRequest) (*model.JimengJob, error) {
 	// 生成任务ID
 	taskId := utils.RandString(20)
 
-	// 序列化任务参数
-	paramsJson, err := json.Marshal(req.Params)
-	if err != nil {
-		return nil, fmt.Errorf("marshal task params failed: %w", err)
-	}
-
 	// 创建任务记录
 	job := &model.JimengJob{
-		UserId:     userId,
-		TaskId:     taskId,
-		Type:       req.Type,
-		ReqKey:     req.ReqKey,
-		Prompt:     req.Prompt,
-		TaskParams: string(paramsJson),
-		Status:     model.JMTaskStatusInQueue,
-		Power:      req.Power,
-		CreatedAt:  time.Now(),
-		UpdatedAt:  time.Now(),
+		UserId:    userId,
+		TaskId:    taskId,
+		Type:      req.TaskType,
+		ReqKey:    req.ReqKey,
+		Prompt:    req.Prompt,
+		Params:    utils.JsonEncode(req),
+		Status:    types.JMTaskStatusSubmited,
+		Power:     req.Power,
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
 	}
 
 	// 保存到数据库
@@ -160,25 +146,71 @@ func (s *Service) ProcessTask(jobId uint) error {
 	}
 
 	// 更新任务状态为处理中
-	if err := s.UpdateJobStatus(job.Id, model.JMTaskStatusGenerating, ""); err != nil {
+	if err := s.UpdateJobStatus(job.Id, types.JMTaskStatusGenerating, ""); err != nil {
 		return fmt.Errorf("update job status failed: %w", err)
 	}
 
+	// 解析任务参数
+	var req types.JimengTaskRequest
+	err := utils.JsonDecode(job.Params, &req)
+	if err != nil {
+		return fmt.Errorf("parse task params failed: %w", err)
+	}
+
 	// 构建请求并提交任务
-	req, err := s.buildTaskRequest(&job)
+	params, err := s.buildTaskRequest(&req)
 	if err != nil {
 		return s.handleTaskError(job.Id, fmt.Sprintf("build task request failed: %v", err))
 	}
 
-	logger.Infof("提交即梦任务: %+v", req)
+	// 数字人任务，先识别主体
+	if req.TaskType == types.JMTaskTypeVirtualHuman {
+		if err := s.client.AvatarRecognition(req.ImageUrls[0], req.RecognizeKey); err != nil {
+			return s.handleTaskError(job.Id, fmt.Sprintf("avatar recognition failed: %v", err))
+		}
+	}
 
-	// 提交异步任务
-	resp, err := s.client.SubmitTask(req)
+	// 同步任务 ，后台执行
+	if req.ReqKey == DoubaoSeedream40ReqKey {
+		go func() {
+			resp, err := s.client.SubmitSyncImageTask(req)
+			if err != nil {
+				_ = s.handleTaskError(job.Id, fmt.Sprintf("submit task failed: %v", err))
+				return
+			}
+			logger.Infof("同步任务提交成功: %+v", resp)
+			// 更新原始数据
+			rawData, _ := json.Marshal(resp)
+			updates := map[string]any{
+				"raw_data": string(rawData),
+			}
+			if resp.Error != nil {
+				updates["status"] = types.JMTaskStatusFailed
+				updates["err_msg"] = resp.Error.Message
+				s.db.Model(&model.JimengJob{}).Where("id = ?", job.Id).Updates(updates)
+				return
+			}
+
+			// 更新任务状态
+			updates["status"] = types.JMTaskStatusSuccess
+			// 下载图片
+			imgUrl, err := s.uploader.GetUploadHandler().PutUrlFile(*resp.Data[0].Url, ".png", false)
+			if err == nil {
+				updates["img_url"] = imgUrl
+			}
+			s.db.Model(&model.JimengJob{}).Where("id = ?", job.Id).Updates(updates)
+		}()
+		return nil
+	}
+
+	logger.Debugf("提交即梦任务: %+v", params)
+	// 异步任务 ，前台执行
+	resp, err := s.client.SubmitTask(params)
 	if err != nil {
 		return s.handleTaskError(job.Id, fmt.Sprintf("submit task failed: %v", err))
 	}
 
-	if resp.Code != 10000 {
+	if resp.Code != CodeSuccess {
 		return s.handleTaskError(job.Id, fmt.Sprintf("submit task failed: %s", resp.Message))
 	}
 
@@ -187,6 +219,7 @@ func (s *Service) ProcessTask(jobId uint) error {
 	if err := s.db.Model(&model.JimengJob{}).Where("id = ?", job.Id).Updates(map[string]any{
 		"task_id":    resp.Data.TaskId,
 		"raw_data":   string(rawData),
+		"status":     types.JMTaskStatusInQueue, // 把任务状态改成排队中，以便开启轮询
 		"updated_at": time.Now(),
 	}).Error; err != nil {
 		logger.Errorf("update jimeng job task_id failed: %v", err)
@@ -196,172 +229,51 @@ func (s *Service) ProcessTask(jobId uint) error {
 }
 
 // buildTaskRequest 构建任务请求（统一的参数解析）
-func (s *Service) buildTaskRequest(job *model.JimengJob) (*SubmitTaskRequest, error) {
-	// 解析任务参数
+func (s *Service) buildTaskRequest(req *types.JimengTaskRequest) (map[string]any, error) {
 	var params map[string]any
-	if err := json.Unmarshal([]byte(job.TaskParams), &params); err != nil {
+	err := utils.JsonDecode(utils.JsonEncode(req), &params)
+	if err != nil {
 		return nil, fmt.Errorf("parse task params failed: %w", err)
 	}
-
-	// 构建基础请求
-	req := &SubmitTaskRequest{
-		ReqKey: job.ReqKey,
-		Prompt: job.Prompt,
-	}
-
-	// 根据任务类型设置特定参数
-	switch job.Type {
-	case model.JMTaskTypeTextToImage:
-		s.setTextToImageParams(req, params)
-	case model.JMTaskTypeImageToImage:
-		s.setImageToImageParams(req, params)
-	case model.JMTaskTypeImageEdit:
-		s.setImageEditParams(req, params)
-	case model.JMTaskTypeImageEffects:
-		s.setImageEffectsParams(req, params)
-	case model.JMTaskTypeTextToVideo:
-		s.setTextToVideoParams(req, params)
-	case model.JMTaskTypeImageToVideo:
-		s.setImageToVideoParams(req, params)
-	default:
-		return nil, fmt.Errorf("unsupported task type: %s", job.Type)
-	}
-
-	return req, nil
-}
-
-// setTextToImageParams 设置文生图参数
-func (s *Service) setTextToImageParams(req *SubmitTaskRequest, params map[string]any) {
-	if seed, ok := params["seed"]; ok {
-		if seedVal, err := strconv.ParseInt(fmt.Sprintf("%.0f", seed), 10, 64); err == nil {
-			req.Seed = seedVal
-		}
-	}
-	if scale, ok := params["scale"]; ok {
-		if scaleVal, ok := scale.(float64); ok {
-			req.Scale = scaleVal
-		}
-	}
-	if width, ok := params["width"]; ok {
-		if widthVal, ok := width.(float64); ok {
-			req.Width = int(widthVal)
-		}
-	}
-	if height, ok := params["height"]; ok {
-		if heightVal, ok := height.(float64); ok {
-			req.Height = int(heightVal)
-		}
-	}
-	if usePreLlm, ok := params["use_pre_llm"]; ok {
-		if usePreLlmVal, ok := usePreLlm.(bool); ok {
-			req.UsePreLLM = usePreLlmVal
-		}
-	}
-}
-
-// setImageToImageParams 设置图生图参数
-func (s *Service) setImageToImageParams(req *SubmitTaskRequest, params map[string]any) {
-	if imageInput, ok := params["image_input"].(string); ok {
-		req.ImageInput = imageInput
-	}
-	if gpen, ok := params["gpen"]; ok {
-		if gpenVal, ok := gpen.(float64); ok {
-			req.Gpen = gpenVal
-		}
-	}
-	if skin, ok := params["skin"]; ok {
-		if skinVal, ok := skin.(float64); ok {
-			req.Skin = skinVal
-		}
-	}
-	if skinUnifi, ok := params["skin_unifi"]; ok {
-		if skinUnifiVal, ok := skinUnifi.(float64); ok {
-			req.SkinUnifi = skinUnifiVal
-		}
-	}
-	if genMode, ok := params["gen_mode"].(string); ok {
-		req.GenMode = genMode
-	}
-	s.setCommonParams(req, params) // 复用通用参数
-}
-
-// setImageEditParams 设置图像编辑参数
-func (s *Service) setImageEditParams(req *SubmitTaskRequest, params map[string]any) {
-	if imageUrls, ok := params["image_urls"].([]any); ok {
-		for _, url := range imageUrls {
-			if urlStr, ok := url.(string); ok {
-				req.ImageUrls = append(req.ImageUrls, urlStr)
+	// 把 size 转成 width 和 height
+	if size, ok := params["size"]; ok {
+		if sizeStr, ok := size.(string); ok {
+			if strings.Contains(sizeStr, "x") {
+				sizes := strings.Split(sizeStr, "x")
+				params["width"] = sizes[0]
+				params["height"] = sizes[1]
 			}
 		}
+		delete(params, "size")
 	}
-	if binaryData, ok := params["binary_data_base64"].([]any); ok {
-		for _, data := range binaryData {
-			if dataStr, ok := data.(string); ok {
-				req.BinaryDataBase64 = append(req.BinaryDataBase64, dataStr)
-			}
-		}
-	}
-	if scale, ok := params["scale"]; ok {
-		if scaleVal, ok := scale.(float64); ok {
-			req.Scale = scaleVal
-		}
-	}
-	s.setCommonParams(req, params)
-}
 
-// setImageEffectsParams 设置图像特效参数
-func (s *Service) setImageEffectsParams(req *SubmitTaskRequest, params map[string]any) {
-	if imageInput1, ok := params["image_input1"].(string); ok {
-		req.ImageInput1 = imageInput1
-	}
-	if templateId, ok := params["template_id"].(string); ok {
-		req.TemplateId = templateId
-	}
-	if width, ok := params["width"]; ok {
-		if widthVal, ok := width.(float64); ok {
-			req.Width = int(widthVal)
+	// duration 转成 frames
+	if duration, ok := params["duration"]; ok {
+		if secs, ok := duration.(int); ok {
+			params["frames"] = secs*24 + 1
 		}
+		delete(params, "duration")
 	}
-	if height, ok := params["height"]; ok {
-		if heightVal, ok := height.(float64); ok {
-			req.Height = int(heightVal)
-		}
-	}
-}
 
-// setTextToVideoParams 设置文生视频参数
-func (s *Service) setTextToVideoParams(req *SubmitTaskRequest, params map[string]any) {
-	if aspectRatio, ok := params["aspect_ratio"].(string); ok {
-		req.AspectRatio = aspectRatio
+	// 单独处理图片特效任务
+	if req.ReqKey == ImageEffectReqKey {
+		params["image_input1"] = req.ImageUrls[0]
+		delete(params, "image_urls")
 	}
-	s.setCommonParams(req, params)
-}
 
-// setImageToVideoParams 设置图生视频参数
-func (s *Service) setImageToVideoParams(req *SubmitTaskRequest, params map[string]any) {
-	s.setImageEditParams(req, params) // 复用图像编辑的参数设置
-	if aspectRatio, ok := params["aspect_ratio"].(string); ok {
-		req.AspectRatio = aspectRatio
+	// 动作迁移，数字人任务参数处理
+	if req.TaskType == types.JMTaskTypeVirtualHuman || req.TaskType == types.JMTaskTypeActionTransfer {
+		params["image_url"] = req.ImageUrls[0]
+		delete(params, "image_urls")
+	}
+	if req.RecognizeKey != "" {
+		delete(params, "recognize_key")
 	}
-}
 
-// setCommonParams 设置通用参数（seed, width, height等）
-func (s *Service) setCommonParams(req *SubmitTaskRequest, params map[string]any) {
-	if seed, ok := params["seed"]; ok {
-		if seedVal, err := strconv.ParseInt(fmt.Sprintf("%.0f", seed), 10, 64); err == nil {
-			req.Seed = seedVal
-		}
-	}
-	if width, ok := params["width"]; ok {
-		if widthVal, ok := width.(float64); ok {
-			req.Width = int(widthVal)
-		}
-	}
-	if height, ok := params["height"]; ok {
-		if heightVal, ok := height.(float64); ok {
-			req.Height = int(heightVal)
-		}
-	}
+	// 删除多余参数，剩下的就是各个任务自己专有参数了
+	delete(params, "type")
+	delete(params, "power")
+	return params, nil
 }
 
 // pollTaskStatus 轮询任务状态
@@ -369,29 +281,32 @@ func (s *Service) pollTaskStatus() {
 
 	for {
 		var jobs []model.JimengJob
-		s.db.Where("status IN (?)", []model.JMTaskStatus{model.JMTaskStatusGenerating, model.JMTaskStatusInQueue}).Find(&jobs)
-		if len(jobs) == 0 {
-			logger.Debugf("no jimeng task to poll, sleep 10s")
-			time.Sleep(10 * time.Second)
-			continue
-		}
+		// 找出排队中和处理中的任务进行轮询
+		s.db.Where("status IN (?)", []types.JMTaskStatus{
+			types.JMTaskStatusGenerating,
+			types.JMTaskStatusInQueue}).Find(&jobs)
 
 		for _, job := range jobs {
 			// 任务超时处理
-			if job.UpdatedAt.Before(time.Now().Add(-5 * time.Minute)) {
+			if job.UpdatedAt.Before(time.Now().Add(-10 * time.Minute)) {
 				s.handleTaskError(job.Id, "task timeout")
 				continue
 			}
 
+			// 豆包生图 4.0 是同步任务，不需要轮询
+			if job.ReqKey == DoubaoSeedream40ReqKey {
+				continue
+			}
+
 			// 查询任务状态
 			resp, err := s.client.QueryTask(&QueryTaskRequest{
 				ReqKey:  job.ReqKey,
 				TaskId:  job.TaskId,
 				ReqJson: `{"return_url":true}`,
-			})
+			}, ASyncActionGetResult)
 
 			if err != nil {
-				logger.Errorf("query jimeng task status failed: %v", err)
+				s.handleTaskError(job.Id, fmt.Sprintf("query task failed: %s", err.Error()))
 				continue
 			}
 
@@ -399,13 +314,13 @@ func (s *Service) pollTaskStatus() {
 			rawData, _ := json.Marshal(resp)
 			s.db.Model(&model.JimengJob{}).Where("id = ?", job.Id).Update("raw_data", string(rawData))
 
-			if resp.Code != 10000 {
+			if resp.Code != CodeSuccess {
 				s.handleTaskError(job.Id, fmt.Sprintf("query task failed: %s", resp.Message))
 				continue
 			}
 
 			switch resp.Data.Status {
-			case model.JMTaskStatusDone:
+			case types.JMTaskStatusDone:
 				// 判断任务是否成功
 				if resp.Message != "Success" {
 					s.handleTaskError(job.Id, fmt.Sprintf("task failed: %s", resp.Data.AlgorithmBaseResp.StatusMessage))
@@ -414,7 +329,7 @@ func (s *Service) pollTaskStatus() {
 
 				// 任务完成，更新结果
 				updates := map[string]any{
-					"status":     model.JMTaskStatusSuccess,
+					"status":     types.JMTaskStatusSuccess,
 					"updated_at": time.Now(),
 				}
 
@@ -437,24 +352,37 @@ func (s *Service) pollTaskStatus() {
 				}
 
 				s.db.Model(&model.JimengJob{}).Where("id = ?", job.Id).Updates(updates)
-			case model.JMTaskStatusInQueue, model.JMTaskStatusGenerating:
+			case types.JMTaskStatusInQueue, types.JMTaskStatusGenerating:
 				// 任务处理中
-				s.UpdateJobStatus(job.Id, model.JMTaskStatusGenerating, "")
+				s.UpdateJobStatus(job.Id, types.JMTaskStatusGenerating, "")
 
-			case model.JMTaskStatusNotFound:
+			case types.JMTaskStatusNotFound:
 				// 任务未找到
 				s.handleTaskError(job.Id, "task not found")
 
-			case model.JMTaskStatusExpired:
-				// 任务过期
-				s.handleTaskError(job.Id, "task expired")
-
+			case types.JMTaskStatusExpired:
+				continue
 			default:
 				logger.Warnf("unknown task status: %s", resp.Data.Status)
 			}
 
 		}
 
+		// 找出失败的任务，并恢复其扣减算力
+		s.db.Where("status = ?", types.JMTaskStatusFailed).Where("power > ?", 0).Find(&jobs)
+		for _, job := range jobs {
+			err := s.userService.IncreasePower(job.UserId, job.Power, model.PowerLog{
+				Type:   types.PowerRefund,
+				Model:  job.ReqKey,
+				Remark: fmt.Sprintf("任务失败，退回算力。任务ID：%d", job.Id),
+			})
+			if err != nil {
+				continue
+			}
+			// 更新任务状态
+			s.db.Model(&job).UpdateColumn("power", 0)
+		}
+
 		time.Sleep(5 * time.Second)
 
 	}
@@ -462,7 +390,7 @@ func (s *Service) pollTaskStatus() {
 }
 
 // UpdateJobStatus 更新任务状态
-func (s *Service) UpdateJobStatus(jobId uint, status model.JMTaskStatus, errMsg string) error {
+func (s *Service) UpdateJobStatus(jobId uint, status types.JMTaskStatus, errMsg string) error {
 	updates := map[string]any{
 		"status":     status,
 		"updated_at": time.Now(),
@@ -476,7 +404,7 @@ func (s *Service) UpdateJobStatus(jobId uint, status model.JMTaskStatus, errMsg
 // handleTaskError 处理任务错误
 func (s *Service) handleTaskError(jobId uint, errMsg string) error {
 	logger.Errorf("Jimeng task error (job_id: %d): %s", jobId, errMsg)
-	return s.UpdateJobStatus(jobId, model.JMTaskStatusFailed, errMsg)
+	return s.UpdateJobStatus(jobId, types.JMTaskStatusFailed, errMsg)
 }
 
 // PushTaskToQueue 推送任务到队列（用于手动重试）
@@ -487,8 +415,8 @@ func (s *Service) PushTaskToQueue(jobId uint) error {
 // GetTaskStats 获取任务统计信息
 func (s *Service) GetTaskStats() (map[string]any, error) {
 	type StatResult struct {
-		Status string `json:"status"`
-		Count  int64  `json:"count"`
+		Status types.JMTaskStatus `json:"status"`
+		Count  int64              `json:"count"`
 	}
 
 	var stats []StatResult
@@ -510,7 +438,7 @@ func (s *Service) GetTaskStats() (map[string]any, error) {
 
 	for _, stat := range stats {
 		result["total"] = result["total"].(int64) + stat.Count
-		result[stat.Status] = stat.Count
+		result[string(stat.Status)] = stat.Count
 	}
 
 	return result, nil
@@ -524,77 +452,3 @@ func (s *Service) GetJob(jobId uint) (*model.JimengJob, error) {
 	}
 	return &job, nil
 }
-
-// testConnection 测试即梦AI连接
-func (s *Service) testConnection(accessKey, secretKey string) error {
-	testClient := NewClient(accessKey, secretKey)
-
-	// 使用一个简单的查询任务来测试连接
-	testReq := &QueryTaskRequest{
-		ReqKey: "test_connection",
-		TaskId: "test_task_id_12345",
-	}
-
-	_, err := testClient.QueryTask(testReq)
-	// 即使任务不存在，只要不是认证错误就说明连接正常
-	if err != nil {
-		// 检查是否是认证错误
-		if strings.Contains(err.Error(), "InvalidAccessKey") {
-			return fmt.Errorf("认证失败，请检查AccessKey和SecretKey是否正确")
-		}
-		// 其他错误（如任务不存在）说明连接正常
-		return nil
-	}
-	return nil
-}
-
-// UpdateClientConfig 更新客户端配置
-func (s *Service) UpdateClientConfig(accessKey, secretKey string) error {
-	// 创建新的客户端
-	newClient := NewClient(accessKey, secretKey)
-
-	// 测试新客户端是否可用
-	err := s.testConnection(accessKey, secretKey)
-	if err != nil {
-		return err
-	}
-
-	// 更新客户端
-	s.client = newClient
-	return nil
-}
-
-var defaultPower = types.JimengPower{
-	TextToImage:  20,
-	ImageToImage: 20,
-	ImageEdit:    20,
-	ImageEffects: 20,
-	TextToVideo:  300,
-	ImageToVideo: 300,
-}
-
-// GetConfig 获取即梦AI配置
-func (s *Service) GetConfig() *types.JimengConfig {
-	var config model.Config
-	err := s.db.Where("name", "jimeng").First(&config).Error
-	if err != nil {
-		// 如果配置不存在，返回默认配置
-		return &types.JimengConfig{
-			AccessKey: "",
-			SecretKey: "",
-			Power:     defaultPower,
-		}
-	}
-
-	var jimengConfig types.JimengConfig
-	err = utils.JsonDecode(config.Value, &jimengConfig)
-	if err != nil {
-		return &types.JimengConfig{
-			AccessKey: "",
-			SecretKey: "",
-			Power:     defaultPower,
-		}
-	}
-
-	return &jimengConfig
-}

api/service/jimeng/types.go

@@ -1,43 +1,9 @@
 package jimeng
 
-import "geekai/store/model"
-
-// ReqKey 常量定义
-const (
-	ReqKeyTextToImage          = "high_aes_general_v30l_zt2i" // 文生图
-	ReqKeyImageToImagePortrait = "i2i_portrait_photo"         // 图生图人像写真
-	ReqKeyImageEdit            = "seededit_v3.0"              // 图像编辑
-	ReqKeyImageEffects         = "i2i_multi_style_zx2x"       // 图像特效
-	ReqKeyTextToVideo          = "jimeng_vgfm_t2v_l20"        // 文生视频
-	ReqKeyImageToVideo         = "jimeng_vgfm_i2v_l20"        // 图生视频
+import (
+	"geekai/core/types"
 )
 
-// SubmitTaskRequest 提交任务请求
-type SubmitTaskRequest struct {
-	ReqKey string `json:"req_key"`
-	// 文生图参数
-	Prompt    string  `json:"prompt,omitempty"`
-	Seed      int64   `json:"seed,omitempty"`
-	Scale     float64 `json:"scale,omitempty"`
-	Width     int     `json:"width,omitempty"`
-	Height    int     `json:"height,omitempty"`
-	UsePreLLM bool    `json:"use_pre_llm,omitempty"`
-	// 图生图参数
-	ImageInput       string   `json:"image_input,omitempty"`
-	ImageUrls        []string `json:"image_urls,omitempty"`
-	BinaryDataBase64 []string `json:"binary_data_base64,omitempty"`
-	Gpen             float64  `json:"gpen,omitempty"`
-	Skin             float64  `json:"skin,omitempty"`
-	SkinUnifi        float64  `json:"skin_unifi,omitempty"`
-	GenMode          string   `json:"gen_mode,omitempty"`
-	// 图像编辑参数
-	// 图像特效参数
-	ImageInput1 string `json:"image_input1,omitempty"`
-	TemplateId  string `json:"template_id,omitempty"`
-	// 视频生成参数
-	AspectRatio string `json:"aspect_ratio,omitempty"`
-}
-
 // SubmitTaskResponse 提交任务响应
 type SubmitTaskResponse struct {
 	Code        int    `json:"code"`
@@ -73,7 +39,7 @@ type QueryTaskResponse struct {
 		ImageUrls         []string           `json:"image_urls"`
 		VideoUrl          string             `json:"video_url"`
 		RespData          string             `json:"resp_data"`
-		Status            model.JMTaskStatus `json:"status"`
+		Status            types.JMTaskStatus `json:"status"`
 		LlmResult         string             `json:"llm_result"`
 		PeResult          string             `json:"pe_result"`
 		PredictTagsResult string             `json:"predict_tags_result"`
@@ -83,9 +49,73 @@ type QueryTaskResponse struct {
 	} `json:"data"`
 }
 
+const CodeSuccess = 10000
+
+// 即梦AI错误代码常量
+const (
+	// 成功
+	ECSuccess = 10000
+
+	// 请求参数错误 (50200-50215)
+	ECReqInvalidArgs     = 50200 // 参数错误
+	ECReqMissingArgs     = 50201 // 缺少参数
+	ECParseArgs          = 50204 // 参数类型错误/参数缺失
+	ECImageSizeLimited   = 50205 // 图像尺寸超过限制
+	ECImageEmpty         = 50206 // 请求参数中没有获取到图像
+	ECImageDecodeError   = 50207 // 图像解码错误
+	ECVideoEmpty         = 50209 // 请求参数中没有获取到视频
+	ECVideoDecodeError   = 50210 // 视频解码错误
+	ECVideoSizeLimited   = 50211 // 视频尺寸超过限制
+	ECReqBodySizeLimited = 50213 // 请求Body过大
+	ECVideoTimeTooLong   = 50214 // 输入视频时长过大
+	ECRPCProcess         = 50215 // 请求处理失败
+
+	// 算法服务错误 (60102-60208)
+	ECJPFaceDetect      = 60102 // 算法服务需要输入人脸图，但未检测到
+	ECFSLeaderRiskError = 60208 // 输入图片中包含敏感信息，未通过审核
+
+	// 权限和系统错误 (50400-50501)
+	ECAuth        = 50400 // 权限校验失败
+	ECReqMethod   = 50402 // 访问的接口不存在
+	ECReqLimit    = 50429 // 超过调用QPS限制
+	ECInternal    = 50500 // 服务器内部错误
+	ECRPCInternal = 50501 // 服务器内部RPC错误
+)
+
+// 错误代码到错误信息的映射
+var errorCodeMessages = map[int]string{
+	// 成功
+	ECSuccess: "请求成功",
+
+	// 请求参数错误
+	ECReqInvalidArgs:     "参数错误，检查入参及MIME类型",
+	ECReqMissingArgs:     "缺少参数，检查入参及MIME类型",
+	ECParseArgs:          "参数类型错误/参数缺失，检查入参及MIME类型",
+	ECImageSizeLimited:   "图像尺寸超过限制，参考接口文档入参要求部分",
+	ECImageEmpty:         "请求参数中没有获取到图像，检查入参",
+	ECImageDecodeError:   "图像解码错误：没有获取到图像或者通过image_base64参数传递图像是base64解码错误，检查输出图片或检查base64是否错误携带前缀",
+	ECVideoEmpty:         "请求参数中没有获取到视频。输入为视频时可能返回此错误，检查入参",
+	ECVideoDecodeError:   "视频解码错误。输入为视频时可能返回此错误，检查输入视频是否不正确",
+	ECVideoSizeLimited:   "视频尺寸超过限制。输入为视频时可能返回此错误，检查输入视频大小",
+	ECReqBodySizeLimited: "请求Body过大，超出接口限制，检查请求Body大小",
+	ECVideoTimeTooLong:   "输入视频时长过大，检查输入视频时长",
+	ECRPCProcess:         "由于输入的图片、视频、参数等不满足要求，导致请求处理失败。若接口文档中有具体说明，优先参考其具体含义，按照具体服务说明进行检查",
+
+	// 算法服务错误
+	ECJPFaceDetect:      "算法服务需要输入人脸图，但未检测到，检查输入图片是否包含人脸",
+	ECFSLeaderRiskError: "输入图片中包含敏感信息，未通过审核",
+
+	// 权限和系统错误
+	ECAuth:        "权限校验失败，请检查是否已创建应用并开通服务或签名，参考接入指南及快速接入",
+	ECReqMethod:   "访问的接口不存在，检查入参",
+	ECReqLimit:    "超过调用QPS限制，购买QPS增项包",
+	ECInternal:    "服务器内部错误，提工单",
+	ECRPCInternal: "服务器内部RPC错误，提工单",
+}
+
 // CreateTaskRequest 创建任务请求
 type CreateTaskRequest struct {
-	Type      model.JMTaskType `json:"type"`
+	Type      types.JMTaskType `json:"type"`
 	Prompt    string           `json:"prompt"`
 	Params    map[string]any   `json:"params"`
 	ReqKey    string           `json:"req_key"`
@@ -93,53 +123,14 @@ type CreateTaskRequest struct {
 	Power     int              `json:"power,omitempty"`
 }
 
-// LogoInfo 水印信息
-type LogoInfo struct {
-	AddLogo         bool    `json:"add_logo"`
-	Position        int     `json:"position"`
-	Language        int     `json:"language"`
-	Opacity         float64 `json:"opacity"`
-	LogoTextContent string  `json:"logo_text_content"`
-}
-
-// ReqJsonConfig 查询配置
-type ReqJsonConfig struct {
-	ReturnUrl bool      `json:"return_url"`
-	LogoInfo  *LogoInfo `json:"logo_info,omitempty"`
-}
-
-// ImageEffectTemplate 图像特效模板
 const (
-	TemplateIdFelt3DPolaroid             = "felt_3d_polaroid"                        // 毛毡3d拍立得风格
-	TemplateIdMyWorld                    = "my_world"                                // 像素世界风
-	TemplateIdMyWorldUniversal           = "my_world_universal"                      // 像素世界-万物通用版
-	TemplateIdPlasticBubbleFigure        = "plastic_bubble_figure"                   // 盲盒玩偶风
-	TemplateIdPlasticBubbleFigureCartoon = "plastic_bubble_figure_cartoon_text"      // 塑料泡罩人偶-文字卡头版
-	TemplateIdFurryDreamDoll             = "furry_dream_doll"                        // 毛绒玩偶风
-	TemplateIdMicroLandscapeMiniWorld    = "micro_landscape_mini_world"              // 迷你世界玩偶风
-	TemplateIdMicroLandscapeProfessional = "micro_landscape_mini_world_professional" // 微型景观小世界-职业版
-	TemplateIdAcrylicOrnaments           = "acrylic_ornaments"                       // 亚克力挂饰
-	TemplateIdFeltKeychain               = "felt_keychain"                           // 毛毡钥匙扣
-	TemplateIdLofiPixelCharacter         = "lofi_pixel_character_mini_card"          // Lofi像素人物小卡
-	TemplateIdAngelFigurine              = "angel_figurine"                          // 天使形象手办
-	TemplateIdLyingInFluffyBelly         = "lying_in_fluffy_belly"                   // 躺在毛茸茸肚皮里
-	TemplateIdGlassBall                  = "glass_ball"                              // 玻璃球
+	ImageEffectReqKey      = "i2i_multi_style_zx2x"
+	DoubaoSeedream40ReqKey = "doubao-seedream-4-0-250828"
 )
 
-// AspectRatio 视频宽高比
 const (
-	AspectRatio16_9 = "16:9" // 1280×720
-	AspectRatio9_16 = "9:16" // 720×1280
-	AspectRatio1_1  = "1:1"  // 960×960
-	AspectRatio4_3  = "4:3"  // 960×720
-	AspectRatio3_4  = "3:4"  // 720×960
-	AspectRatio21_9 = "21:9" // 1680×720
-	AspectRatio9_21 = "9:21" // 720×1680
-)
-
-// GenMode 生成模式
-const (
-	GenModeCreative      = "creative"       // 提示词模式
-	GenModeReference     = "reference"      // 全参考模式
-	GenModeReferenceChar = "reference_char" // 人物参考模式
+	ASyncActionSubmit    = "CVSync2AsyncSubmitTask" // 异步提交任务
+	SyncActionSubmit     = "CVSubmitTask"           // 同步提交任务
+	ASyncActionGetResult = "CVSync2AsyncGetResult"  // 异步获取结果
+	SyncActionGetResult  = "CVGetResult"            // 同步获取结果
 )

api/service/license_service.go

@@ -1,204 +0,0 @@
-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"
-	"geekai/core/types"
-	"geekai/store"
-	"strings"
-	"time"
-
-	"github.com/imroc/req/v3"
-	"github.com/shirou/gopsutil/host"
-)
-
-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
-	var machineId string
-	err := levelDB.Get(types.LicenseKey, &license)
-	logger.Infof("License: %+v", server.SysConfig)
-	info, err := host.Info()
-	if err == nil {
-		machineId = info.HostID
-	}
-	logger.Infof("License: %+v", license)
-	return &LicenseService{
-		config:    server.Config.ApiConfig,
-		levelDB:   levelDB,
-		license:   &license,
-		machineId: 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.Debug(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:       res.Data.License,
-		MachineId: res.Data.MachineId,
-		Configs:   res.Data.Configs,
-		ExpiredAt: res.Data.ExpiredAt,
-		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 {
-	// 获得许可授权的直接放行
-	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/migration_service.go

@@ -0,0 +1,408 @@
+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 (
+	"encoding/json"
+	"fmt"
+	"geekai/core/types"
+	"geekai/store"
+	"geekai/store/model"
+	"strings"
+	"sync"
+
+	"github.com/go-redis/redis/v8"
+	"gorm.io/gorm"
+	"gorm.io/gorm/schema"
+)
+
+const (
+	// 迁移状态Redis key
+	MigrationStatusKey = "config_migration:status"
+	// 迁移完成标志
+	MigrationCompleted = "completed"
+)
+
+// MigrationService 配置迁移服务
+type MigrationService struct {
+	db          *gorm.DB
+	redisClient *redis.Client
+	appConfig   *types.AppConfig
+	levelDB     *store.LevelDB
+}
+
+func NewMigrationService(db *gorm.DB, redisClient *redis.Client, appConfig *types.AppConfig, levelDB *store.LevelDB) *MigrationService {
+	return &MigrationService{
+		db:          db,
+		redisClient: redisClient,
+		appConfig:   appConfig,
+		levelDB:     levelDB,
+	}
+}
+
+func (s *MigrationService) StartMigrate() {
+	// 表结构同步必须在对外服务前完成，避免缺列导致业务报错
+	s.TableMigration()
+	go func() {
+		_ = s.MigrateConfig(s.appConfig)
+	}()
+}
+
+// 迁移配置内容
+func (s *MigrationService) MigrateConfigContent() error {
+	// 用户协议
+	if err := s.saveConfig(types.ConfigKeyPrivacy, map[string]string{
+		"content": "用户协议内容",
+	}); err != nil {
+		return fmt.Errorf("迁移配置内容失败: %v", err)
+	}
+	// 隐私政策
+	if err := s.saveConfig(types.ConfigKeyAgreement, map[string]string{
+		"content": "隐私政策内容",
+	}); err != nil {
+		return fmt.Errorf("迁移配置内容失败: %v", err)
+	}
+	// 思维导图
+	if err := s.saveConfig(types.ConfigKeyMarkMap, map[string]string{
+		"content": `# GeekAI 演示站
+
+- 完整的开源系统，前端应用和后台管理系统皆可开箱即用。
+- 基于 Websocket 实现，完美的打字机体验。
+- 内置了各种预训练好的角色应用,轻松满足你的各种聊天和应用需求。
+- 支持 OPenAI，Azure，文心一言，讯飞星火，清华 ChatGLM等多个大语言模型。
+- 支持 MidJourney / Stable Diffusion AI 绘画集成，开箱即用。
+- 支持使用个人微信二维码作为充值收费的支付渠道，无需企业支付通道。
+- 已集成支付宝支付功能，微信支付，支持多种会员套餐和点卡购买功能。
+- 集成插件 API 功能，可结合大语言模型的 function 功能开发各种强大的插件。`,
+	}); err != nil {
+		return fmt.Errorf("迁移配置内容失败: %v", err)
+	}
+
+	// 微信登录配置
+	if err := s.saveConfig(types.ConfigKeyWxLogin, map[string]string{
+		"api_key":    "",
+		"notify_url": "",
+		"enabled":    "false",
+	}); err != nil {
+		return fmt.Errorf("迁移配置内容失败: %v", err)
+	}
+
+	// 验证码配置
+	if err := s.saveConfig(types.ConfigKeyCaptcha, map[string]string{
+		"api_key": "",
+		"type":    "dot",
+		"enabled": "false",
+	}); err != nil {
+		return fmt.Errorf("迁移配置内容失败: %v", err)
+	}
+
+	// 文本审核
+	if err := s.saveConfig(types.ConfigKeyModeration, map[string]any{
+		"enable":       "false",
+		"active":       "gitee",
+		"enable_guide": "false",
+		"guide_prompt": "",
+		"gitee": map[string]string{
+			"api_key": "",
+			"model":   "Security-semantic-filtering",
+		},
+		"baidu": map[string]string{
+			"access_key": "",
+			"secret_key": "",
+		},
+		"tencent": map[string]string{
+			"access_key": "",
+			"secret_key": "",
+		},
+	}); err != nil {
+		return fmt.Errorf("迁移配置内容失败: %v", err)
+	}
+
+	return nil
+}
+
+// 永不删除的保护列（大小写不敏感）
+var protectedColumns = map[string]struct{}{
+	"id":         {},
+	"created_at": {},
+	"updated_at": {},
+}
+
+// allModels 全部需要同步的数据表 model
+func allModels() []any {
+	return []any{
+		&model.AdminUser{},
+		&model.ApiKey{},
+		&model.AppType{},
+		&model.ChatApp{},
+		&model.ChatItem{},
+		&model.ChatMessage{},
+		&model.ChatModel{},
+		&model.Config{},
+		&model.DallJob{},
+		&model.File{},
+		&model.Function{},
+		&model.InviteCode{},
+		&model.InviteLog{},
+		&model.JimengJob{},
+		&model.Menu{},
+		&model.MidJourneyJob{},
+		&model.Moderation{},
+		&model.Order{},
+		&model.PowerLog{},
+		&model.Product{},
+		&model.Redeem{},
+		&model.SdJob{},
+		&model.SunoJob{},
+		&model.User{},
+		&model.UserLoginLog{},
+		&model.VideoJob{},
+	}
+}
+
+// 数据表迁移：先处理字段重命名（保数据），再全量同步 schema
+func (s *MigrationService) TableMigration() {
+	logger.Info("开始数据表迁移...")
+	s.renameColumns()
+	if err := s.SyncAllModels(); err != nil {
+		logger.Errorf("同步数据表字段失败: %v", err)
+		return
+	}
+	logger.Info("数据表迁移完成")
+}
+
+// renameColumns 只处理「改名」场景：删旧加新会丢数据，必须先 Rename
+func (s *MigrationService) renameColumns() {
+	m := s.db.Migrator()
+
+	if m.HasColumn(&model.JimengJob{}, "task_params") {
+		_ = m.RenameColumn(&model.JimengJob{}, "task_params", "params")
+	}
+	if m.HasColumn(&model.Order{}, "pay_type") {
+		_ = m.RenameColumn(&model.Order{}, "pay_type", "channel")
+	}
+	if m.HasColumn(&model.Config{}, "config_json") {
+		_ = m.RenameColumn(&model.Config{}, "config_json", "value")
+	}
+	if m.HasColumn(&model.Config{}, "marker") {
+		_ = m.RenameColumn(&model.Config{}, "marker", "name")
+	}
+	if m.HasIndex(&model.Config{}, "idx_chatgpt_configs_key") {
+		_ = m.DropIndex(&model.Config{}, "idx_chatgpt_configs_key")
+	}
+	if m.HasIndex(&model.Config{}, "marker") {
+		_ = m.DropIndex(&model.Config{}, "marker")
+	}
+}
+
+// SyncAllModels 按 model 定义同步所有数据表：缺列新建，多余列删除
+func (s *MigrationService) SyncAllModels() error {
+	var firstErr error
+	for _, m := range allModels() {
+		if err := s.syncModel(m); err != nil {
+			logger.Errorf("同步 model %T 失败: %v", m, err)
+			if firstErr == nil {
+				firstErr = err
+			}
+		}
+	}
+	return firstErr
+}
+
+func (s *MigrationService) syncModel(dst any) error {
+	tableName := s.tableName(dst)
+	if err := s.db.AutoMigrate(dst); err != nil {
+		return fmt.Errorf("AutoMigrate %s: %w", tableName, err)
+	}
+	if err := s.dropUnusedColumns(dst); err != nil {
+		return fmt.Errorf("drop unused columns %s: %w", tableName, err)
+	}
+	logger.Infof("已同步数据表: %s", tableName)
+	return nil
+}
+
+func (s *MigrationService) dropUnusedColumns(dst any) error {
+	dbCols, err := s.db.Migrator().ColumnTypes(dst)
+	if err != nil {
+		return err
+	}
+	modelCols, err := s.modelColumnNames(dst)
+	if err != nil {
+		return err
+	}
+
+	for _, col := range dbCols {
+		name := col.Name()
+		if s.isProtectedColumn(name) {
+			continue
+		}
+		if _, ok := modelCols[strings.ToLower(name)]; ok {
+			continue
+		}
+		logger.Infof("删除多余字段: %s.%s", s.tableName(dst), name)
+		if err := s.db.Migrator().DropColumn(dst, name); err != nil {
+			return fmt.Errorf("DropColumn %s: %w", name, err)
+		}
+	}
+	return nil
+}
+
+func (s *MigrationService) modelColumnNames(dst any) (map[string]struct{}, error) {
+	parsed, err := schema.Parse(dst, &schemaCache, s.db.Config.NamingStrategy)
+	if err != nil {
+		return nil, err
+	}
+	cols := make(map[string]struct{}, len(parsed.Fields))
+	for _, field := range parsed.Fields {
+		if field.DBName == "" || field.IgnoreMigration {
+			continue
+		}
+		cols[strings.ToLower(field.DBName)] = struct{}{}
+	}
+	return cols, nil
+}
+
+func (s *MigrationService) isProtectedColumn(name string) bool {
+	_, ok := protectedColumns[strings.ToLower(name)]
+	return ok
+}
+
+func (s *MigrationService) tableName(dst any) string {
+	stmt := &gorm.Statement{DB: s.db}
+	if err := stmt.Parse(dst); err != nil {
+		return fmt.Sprintf("%T", dst)
+	}
+	return stmt.Schema.Table
+}
+
+// schema.Parse 进程内复用的 schema cache
+var schemaCache sync.Map
+
+// 迁移配置数据
+func (s *MigrationService) MigrateConfig(config *types.AppConfig) error {
+
+	logger.Info("开始迁移配置到数据库...")
+
+	// 迁移支付配置
+	if err := s.migratePaymentConfig(config); err != nil {
+		logger.Errorf("迁移支付配置失败: %v", err)
+		return err
+	}
+
+	// 迁移存储配置
+	if err := s.migrateStorageConfig(config); err != nil {
+		logger.Errorf("迁移存储配置失败: %v", err)
+		return err
+	}
+
+	// 迁移通信配置
+	if err := s.migrateCommunicationConfig(config); err != nil {
+		logger.Errorf("迁移通信配置失败: %v", err)
+		return err
+	}
+
+	// 迁移配置内容
+	if err := s.MigrateConfigContent(); err != nil {
+		logger.Errorf("迁移配置内容失败: %v", err)
+		return err
+	}
+
+	logger.Info("配置迁移完成")
+	return nil
+}
+
+// 迁移支付配置
+func (s *MigrationService) migratePaymentConfig(config *types.AppConfig) error {
+
+	paymentConfig := types.PaymentConfig{
+		Alipay: config.AlipayConfig,
+		Epay:   config.GeekPayConfig,
+		WxPay:  config.WechatPayConfig,
+	}
+	if err := s.saveConfig(types.ConfigKeyPayment, paymentConfig); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// 迁移存储配置
+func (s *MigrationService) migrateStorageConfig(config *types.AppConfig) error {
+
+	ossConfig := types.OSSConfig{
+		Active: config.OSS.Active,
+		Local:  config.OSS.Local,
+		Minio:  config.OSS.Minio,
+		QiNiu:  config.OSS.QiNiu,
+		AliYun: config.OSS.AliYun,
+	}
+	return s.saveConfig(types.ConfigKeyOss, ossConfig)
+}
+
+// 迁移通信配置
+func (s *MigrationService) migrateCommunicationConfig(config *types.AppConfig) error {
+	// SMTP配置
+	smtpConfig := map[string]any{
+		"use_tls":  config.SmtpConfig.UseTls,
+		"host":     config.SmtpConfig.Host,
+		"port":     config.SmtpConfig.Port,
+		"app_name": config.SmtpConfig.AppName,
+		"from":     config.SmtpConfig.From,
+		"password": config.SmtpConfig.Password,
+	}
+	if err := s.saveConfig(types.ConfigKeySmtp, smtpConfig); err != nil {
+		return err
+	}
+
+	// 短信配置
+	smsConfig := map[string]any{
+		"active": strings.ToLower(config.SMS.Active),
+		"aliyun": map[string]any{
+			"access_key":    config.SMS.Ali.AccessKey,
+			"access_secret": config.SMS.Ali.AccessSecret,
+			"sign":          config.SMS.Ali.Sign,
+			"code_temp_id":  config.SMS.Ali.CodeTempId,
+		},
+		"bao": map[string]any{
+			"username":      config.SMS.Bao.Username,
+			"password":      config.SMS.Bao.Password,
+			"sign":          config.SMS.Bao.Sign,
+			"code_template": config.SMS.Bao.CodeTemplate,
+		},
+	}
+	return s.saveConfig(types.ConfigKeySms, smsConfig)
+}
+
+// 保存配置到数据库
+func (s *MigrationService) saveConfig(key string, config any) error {
+	// 检查是否已存在
+	var existingConfig model.Config
+	if err := s.db.Where("name", key).First(&existingConfig).Error; err == nil {
+		// 配置已存在，跳过
+		logger.Infof("配置 %s 已存在，跳过迁移", key)
+		return nil
+	}
+
+	// 序列化配置
+	configJSON, err := json.Marshal(config)
+	if err != nil {
+		return err
+	}
+
+	// 保存到数据库
+	newConfig := model.Config{
+		Name:  key,
+		Value: string(configJSON),
+	}
+	if err := s.db.Create(&newConfig).Error; err != nil {
+		return err
+	}
+
+	logger.Infof("成功迁移配置 %s", key)
+	return nil
+}

api/service/mj/client.go

@@ -13,7 +13,6 @@ import (
 	"fmt"
 	"geekai/core/types"
 	logger2 "geekai/logger"
-	"geekai/service"
 	"geekai/store/model"
 	"geekai/utils"
 	"github.com/imroc/req/v3"
@@ -26,9 +25,8 @@ import (
 
 // Client MidJourney client
 type Client struct {
-	client         *req.Client
-	licenseService *service.LicenseService
-	db             *gorm.DB
+	client *req.Client
+	db     *gorm.DB
 }
 
 type ImageReq struct {
@@ -77,11 +75,10 @@ type QueryRes struct {
 
 var logger = logger2.GetLogger()
 
-func NewClient(licenseService *service.LicenseService, db *gorm.DB) *Client {
+func NewClient(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,
+		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"),
+		db:     db,
 	}
 }
 
@@ -198,10 +195,6 @@ func (c *Client) doRequest(body interface{}, apiPath string, channel string) (Im
 		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().

api/service/mj/service.go

@@ -67,25 +67,6 @@ func (s *Service) Run() {
 				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"

api/service/moderation/baidu_moderation.go

@@ -0,0 +1,33 @@
+package moderation
+
+// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// * 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"
+	"geekai/core/types"
+)
+
+type BaiduAIModeration struct {
+	config types.ModerationBaiduConfig
+}
+
+func NewBaiduAIModeration(sysConfig *types.SystemConfig) *BaiduAIModeration {
+	return &BaiduAIModeration{
+		config: sysConfig.Moderation.Baidu,
+	}
+}
+
+func (s *BaiduAIModeration) UpdateConfig(config types.ModerationBaiduConfig) {
+	s.config = config
+}
+
+func (s *BaiduAIModeration) Moderate(text string) (types.ModerationResult, error) {
+	return types.ModerationResult{}, errors.New("not implemented")
+}
+
+var _ Service = (*BaiduAIModeration)(nil)