merge code for v4.1.4

2025-11-09 18:53:43 +08:00 · 2025-01-18 23:20:41 +08:00
parent 59dfa95bf8 dfd2be1265
commit 596b700d63
124 changed files with 3455 additions and 12960 deletions
--- a/api/config.sample.toml
+++ b/api/config.sample.toml
@@ -71,6 +71,15 @@ TikaHost = "http://tika:9998"
  AccessToken = "xxl-job-api-token" # 执行器 API 通信 token
  RegistryKey = "chatgpt-plus" # 任务注册 key

+ [SmtpConfig] # 注意，阿里云服务器禁用了25号端口，请使用 465 端口，并开启 TLS 连接
+   UseTls = false
+   Host = "smtp.163.com"
+   Port = 25
+   AppName = "极客学长"
+   From = "test@163.com" # 发件邮箱人地址
+   Password = "" #邮箱 stmp 服务授权码
+
+# 支付宝商户支付
 [AlipayConfig]
  Enabled = false # 启用支付宝支付通道
  SandBox = false # 是否启用沙盒模式
@@ -80,31 +89,13 @@ TikaHost = "http://tika:9998"
  PublicKey = "certs/alipay/appPublicCert.crt" # 应用公钥证书
  AlipayPublicKey = "certs/alipay/alipayPublicCert.crt" # 支付宝公钥证书
  RootCert = "certs/alipay/alipayRootCert.crt" # 支付宝根证书
-  NotifyURL = "https://ai.r9it.com/api/payment/alipay/notify" # 支付异步回调地址

+# 虎皮椒支付
 [HuPiPayConfig]
  Enabled = false
-  Name = "wechat"
  AppId = ""
  AppSecret = ""
  ApiURL = "https://api.xunhupay.com"
-  NotifyURL = "https://ai.r9it.com/api/payment/hupipay/notify"
-
-[SmtpConfig] # 注意，阿里云服务器禁用了25号端口，请使用 465 端口，并开启 TLS 连接
-  UseTls = false
-  Host = "smtp.163.com"
-  Port = 25
-  AppName = "极客学长"
-  From = "test@163.com" # 发件邮箱人地址
-  Password = "" #邮箱 stmp 服务授权码
-
-[JPayConfig] # PayJs 支付配置
-  Enabled = false
-  Name = "wechat" # 请不要改动
-  AppId = "" # 商户 ID
-  PrivateKey = "" # 秘钥
-  ApiURL = "https://payjs.cn"
-  NotifyURL = "https://ai.r9it.com/api/payment/payjs/notify" # 异步回调地址，域名改成你自己的

 # 微信商户支付
 [WechatPayConfig]
@@ -114,6 +105,11 @@ TikaHost = "http://tika:9998"
  SerialNo = "" # API 证书序列号
  PrivateKey = "certs/alipay/privateKey.txt" # API 证书私钥文件路径，跟支付宝一样，把私钥文件拷贝到对应的路径，证书路径要映射到容器内
  ApiV3Key = "" # APIV3 私钥，这个是你自己在微信支付平台设置的
-  NotifyURL = "https://ai.r9it.com/api/payment/wechat/notify" # 支付成功异步回调地址，域名改成自己的
-  ReturnURL = "" # 支付成功同步回调地址

+# 易支付
+[GeekPayConfig]
+  Enabled = true
+  AppId = "" # 商户ID
+  PrivateKey = "" # 商户私钥
+  ApiURL = "https://pay.geekai.cn"
+  Methods = ["alipay", "wxpay", "qqpay", "jdpay", "douyin", "paypal"] # 支持的支付方式
--- a/api/core/app_server.go
+++ b/api/core/app_server.go
@@ -65,13 +65,13 @@ func (s *AppServer) Init(debug bool, client *redis.Client) {
 func (s *AppServer) Run(db *gorm.DB) error {
 	// load system configs
 	var sysConfig model.Config
-	res := db.Where("marker", "system").First(&sysConfig)
-	if res.Error != nil {
-		return res.Error
-	}
-	err := utils.JsonDecode(sysConfig.Config, &s.SysConfig)
+	err := db.Where("marker", "system").First(&sysConfig).Error
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to load system config: %v", err)
+	}
+	err = utils.JsonDecode(sysConfig.Config, &s.SysConfig)
+	if err != nil {
+		return fmt.Errorf("failed to decode system config: %v", err)
 	}
 	logger.Infof("http://%s", s.Config.Listen)
 	return s.Engine.Run(s.Config.Listen)
@@ -204,7 +204,9 @@ func needLogin(c *gin.Context) bool {
 		c.Request.URL.Path == "/api/chat/history" ||
 		c.Request.URL.Path == "/api/chat/detail" ||
 		c.Request.URL.Path == "/api/chat/list" ||
-		c.Request.URL.Path == "/api/role/list" ||
+		c.Request.URL.Path == "/api/app/list" ||
+		c.Request.URL.Path == "/api/app/type/list" ||
+		c.Request.URL.Path == "/api/app/list/user" ||
 		c.Request.URL.Path == "/api/model/list" ||
 		c.Request.URL.Path == "/api/mj/imgWall" ||
 		c.Request.URL.Path == "/api/mj/client" ||
@@ -217,10 +219,6 @@ func needLogin(c *gin.Context) bool {
 		c.Request.URL.Path == "/api/product/list" ||
 		c.Request.URL.Path == "/api/menu/list" ||
 		c.Request.URL.Path == "/api/markMap/client" ||
-		c.Request.URL.Path == "/api/payment/alipay/notify" ||
-		c.Request.URL.Path == "/api/payment/hupipay/notify" ||
-		c.Request.URL.Path == "/api/payment/payjs/notify" ||
-		c.Request.URL.Path == "/api/payment/wechat/notify" ||
 		c.Request.URL.Path == "/api/payment/doPay" ||
 		c.Request.URL.Path == "/api/payment/payWays" ||
 		c.Request.URL.Path == "/api/suno/client" ||
@@ -229,6 +227,7 @@ func needLogin(c *gin.Context) bool {
 		c.Request.URL.Path == "/api/download" ||
 		c.Request.URL.Path == "/api/video/client" ||
 		strings.HasPrefix(c.Request.URL.Path, "/api/test") ||
+		strings.HasPrefix(c.Request.URL.Path, "/api/payment/notify/") ||
 		strings.HasPrefix(c.Request.URL.Path, "/api/user/clogin") ||
 		strings.HasPrefix(c.Request.URL.Path, "/api/config/") ||
 		strings.HasPrefix(c.Request.URL.Path, "/api/function/") ||
--- a/api/core/types/chat.go
+++ b/api/core/types/chat.go
@@ -9,14 +9,14 @@ package types

 // ApiRequest API 请求实体
 type ApiRequest struct {
-	Model       string        `json:"model,omitempty"` // 兼容百度文心一言
-	Temperature float32       `json:"temperature"`
-	MaxTokens   int           `json:"max_tokens,omitempty"` // 兼容百度文心一言
-	Stream      bool          `json:"stream"`
-	Messages    []interface{} `json:"messages,omitempty"`
-	Prompt      []interface{} `json:"prompt,omitempty"` // 兼容 ChatGLM
-	Tools       []Tool        `json:"tools,omitempty"`
-	Functions   []interface{} `json:"functions,omitempty"` // 兼容中转平台
+	Model               string        `json:"model,omitempty"`
+	Temperature         float32       `json:"temperature"`
+	MaxTokens           int           `json:"max_tokens,omitempty"`
+	MaxCompletionTokens int           `json:"max_completion_tokens,omitempty"` // 兼容GPT O1 模型
+	Stream              bool          `json:"stream,omitempty"`
+	Messages            []interface{} `json:"messages,omitempty"`
+	Tools               []Tool        `json:"tools,omitempty"`
+	Functions           []interface{} `json:"functions,omitempty"` // 兼容中转平台

 	ToolChoice string `json:"tool_choice,omitempty"`

@@ -57,7 +57,9 @@ type ChatSession struct {
 	ClientIP  string    `json:"client_ip"` // 客户端 IP
 	ChatId    string    `json:"chat_id"`   // 客户端聊天会话 ID, 多会话模式专用字段
 	Model     ChatModel `json:"model"`     // GPT 模型
-	Tools     string    `json:"tools"`     // 函数
+	Start     int64     `json:"start"`     // 开始请求时间戳
+	Tools     []int     `json:"tools"`     // 工具函数列表
+	Stream    bool      `json:"stream"`    // 是否采用流式输出
 }

 type ChatModel struct {
--- a/api/core/types/config.go
+++ b/api/core/types/config.go
@@ -12,24 +12,23 @@ import (
 )

 type AppConfig struct {
-	Path         string `toml:"-"`
-	Listen       string
-	Session      Session
-	AdminSession Session
-	ProxyURL     string
-	MysqlDns     string      // mysql 连接地址
-	StaticDir    string      // 静态资源目录
-	StaticUrl    string      // 静态资源 URL
-	Redis        RedisConfig // redis 连接信息
-	ApiConfig    ApiConfig   // ChatPlus API authorization configs
-	SMS          SMSConfig   // send mobile message config
-	OSS          OSSConfig   // OSS config
-
+	Path            string `toml:"-"`
+	Listen          string
+	Session         Session
+	AdminSession    Session
+	ProxyURL        string
+	MysqlDns        string      // mysql 连接地址
+	StaticDir       string      // 静态资源目录
+	StaticUrl       string      // 静态资源 URL
+	Redis           RedisConfig // redis 连接信息
+	ApiConfig       ApiConfig   // ChatPlus API authorization configs
+	SMS             SMSConfig   // send mobile message config
+	OSS             OSSConfig   // OSS config
+	SmtpConfig      SmtpConfig  // 邮件发送配置
 	XXLConfig       XXLConfig
 	AlipayConfig    AlipayConfig    // 支付宝支付渠道配置
 	HuPiPayConfig   HuPiPayConfig   // 虎皮椒支付配置
-	SmtpConfig      SmtpConfig      // 邮件发送配置
-	JPayConfig      JPayConfig      // payjs 支付配置
+	GeekPayConfig   GeekPayConfig   // GEEK 支付配置
 	WechatPayConfig WechatPayConfig // 微信支付渠道配置
 	TikaHost        string          // TiKa 服务器地址
 }
@@ -58,8 +57,8 @@ type AlipayConfig struct {
 	PublicKey       string // 用户公钥文件路径
 	AlipayPublicKey string // 支付宝公钥文件路径
 	RootCert        string // Root 秘钥路径
-	NotifyURL       string // 异步通知回调
-	ReturnURL       string // 支付成功返回地址
+	NotifyURL       string // 异步通知地址
+	ReturnURL       string // 同步通知地址
 }

 type WechatPayConfig struct {
@@ -69,29 +68,27 @@ type WechatPayConfig struct {
 	SerialNo   string // 商户证书的证书序列号
 	PrivateKey string // 用户私钥文件路径
 	ApiV3Key   string // API V3 秘钥
-	NotifyURL  string // 异步通知回调
-	ReturnURL  string // 支付成功返回地址
+	NotifyURL  string // 异步通知地址
 }

 type HuPiPayConfig struct { //虎皮椒第四方支付配置
 	Enabled   bool   // 是否启用该支付通道
-	Name      string // 支付名称，如：wechat/alipay
 	AppId     string // App ID
 	AppSecret string // app 密钥
 	ApiURL    string // 支付网关
-	NotifyURL string // 异步通知回调
-	ReturnURL string // 支付成功返回地址
+	NotifyURL string // 异步通知地址
+	ReturnURL string // 同步通知地址
 }

-// JPayConfig PayJs 支付配置
-type JPayConfig struct {
+// GeekPayConfig GEEK支付配置
+type GeekPayConfig struct {
 	Enabled    bool
-	Name       string // 支付名称，默认 wechat
-	AppId      string // 商户 ID
-	PrivateKey string // 私钥
-	ApiURL     string // API 网关
-	NotifyURL  string // 异步回调地址
-	ReturnURL  string // 支付成功返回地址
+	AppId      string   // 商户 ID
+	PrivateKey string   // 私钥
+	ApiURL     string   // API 网关
+	NotifyURL  string   // 异步通知地址
+	ReturnURL  string   // 同步通知地址
+	Methods    []string // 支付方式
 }

 type XXLConfig struct { // XXL 任务调度配置
@@ -167,5 +164,6 @@ type SystemConfig struct {
 	Copyright   string `json:"copyright"`     // 版权信息
 	MarkMapText string `json:"mark_map_text"` // 思维导入的默认文本

-	EnabledVerify bool `json:"enabled_verify"` // 是否启用验证码
+	EnabledVerify  bool     `json:"enabled_verify"`   // 是否启用验证码
+	EmailWhiteList []string `json:"email_white_list"` // 邮箱白名单列表
 }
--- a/api/core/types/order.go
+++ b/api/core/types/order.go
@@ -22,3 +22,18 @@ type OrderRemark struct {
 	Price    float64 `json:"price"`
 	Discount float64 `json:"discount"`
 }
+
+var PayMethods = map[string]string{
+	"alipay": "支付宝商号",
+	"wechat": "微信商号",
+	"hupi":   "虎皮椒",
+	"geek":   "易支付",
+}
+var PayNames = map[string]string{
+	"alipay": "支付宝",
+	"wxpay":  "微信支付",
+	"qqpay":  "QQ钱包",
+	"jdpay":  "京东支付",
+	"douyin": "抖音支付",
+	"paypal": "PayPal支付",
+}
--- a/api/core/types/web.go
+++ b/api/core/types/web.go
@@ -17,8 +17,8 @@ type BizVo struct {
 	Data     interface{} `json:"data,omitempty"`
 }

-// WsMessage Websocket message
-type WsMessage struct {
+// ReplyMessage 对话回复消息结构
+type ReplyMessage struct {
 	Type    WsMsgType   `json:"type"` // 消息类别，start, end, img
 	Content interface{} `json:"content"`
 }
@@ -26,12 +26,18 @@ type WsMessage struct {
 type WsMsgType string

 const (
-	WsStart  = WsMsgType("start")
-	WsMiddle = WsMsgType("middle")
-	WsEnd    = WsMsgType("end")
-	WsErr    = WsMsgType("error")
+	WsContent = WsMsgType("content") // 输出内容
+	WsEnd     = WsMsgType("end")
+	WsErr     = WsMsgType("error")
 )

+// InputMessage 对话输入消息结构
+type InputMessage struct {
+	Content string `json:"content"`
+	Tools   []int  `json:"tools"`  // 允许调用工具列表
+	Stream  bool   `json:"stream"` // 是否采用流式输出
+}
+
 type BizCode int

 const (
--- a/api/go.mod
+++ b/api/go.mod
@@ -29,7 +29,6 @@ require (
 	github.com/go-pay/gopay v1.5.101
 	github.com/google/go-tika v0.3.1
 	github.com/microcosm-cc/bluemonday v1.0.26
-	github.com/shirou/gopsutil v3.21.11+incompatible
 	github.com/shopspring/decimal v1.3.1
 	github.com/syndtr/goleveldb v1.0.0
 	golang.org/x/image v0.15.0
@@ -45,6 +44,7 @@ require (
 	github.com/go-pay/xtime v0.0.2 // indirect
 	github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db // indirect
 	github.com/gorilla/css v1.0.0 // indirect
+	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
 	github.com/tklauser/go-sysconf v0.3.13 // indirect
 	github.com/tklauser/numcpus v0.7.0 // indirect
 	github.com/yusufpapurcu/wmi v1.2.4 // indirect
--- a/api/handler/admin/api_key_handler.go
+++ b/api/handler/admin/api_key_handler.go
@@ -74,7 +74,6 @@ func (h *ApiKeyHandler) Save(c *gin.Context) {
 func (h *ApiKeyHandler) List(c *gin.Context) {
 	status := h.GetBool(c, "status")
 	t := h.GetTrim(c, "type")
-	platform := h.GetTrim(c, "platform")

 	session := h.DB.Session(&gorm.Session{})
 	if status {
@@ -83,9 +82,6 @@ func (h *ApiKeyHandler) List(c *gin.Context) {
 	if t != "" {
 		session = session.Where("type", t)
 	}
-	if platform != "" {
-		session = session.Where("platform", platform)
-	}

 	var items []model.ApiKey
 	var keys = make([]vo.ApiKey, 0)
--- a/api/handler/admin/chat_role_handler.go
+++ b/api/handler/admin/chat_role_handler.go
@@ -22,16 +22,16 @@ import (
 	"gorm.io/gorm"
 )

-type ChatRoleHandler struct {
+type ChatAppHandler struct {
 	handler.BaseHandler
 }

-func NewChatRoleHandler(app *core.AppServer, db *gorm.DB) *ChatRoleHandler {
-	return &ChatRoleHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
+func NewChatAppHandler(app *core.AppServer, db *gorm.DB) *ChatAppHandler {
+	return &ChatAppHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}}
 }

 // Save 创建或者更新某个角色
-func (h *ChatRoleHandler) Save(c *gin.Context) {
+func (h *ChatAppHandler) Save(c *gin.Context) {
 	var data vo.ChatRole
 	if err := c.ShouldBindJSON(&data); err != nil {
 		resp.ERROR(c, types.InvalidArgs)
@@ -64,7 +64,7 @@ func (h *ChatRoleHandler) Save(c *gin.Context) {
 	resp.SUCCESS(c, data)
 }

-func (h *ChatRoleHandler) List(c *gin.Context) {
+func (h *ChatAppHandler) List(c *gin.Context) {
 	var items []model.ChatRole
 	var roles = make([]vo.ChatRole, 0)
 	res := h.DB.Order("sort_num ASC").Find(&items)
@@ -75,13 +75,18 @@ func (h *ChatRoleHandler) List(c *gin.Context) {

 	// initialize model mane for role
 	modelIds := make([]int, 0)
+	typeIds := make([]int, 0)
 	for _, v := range items {
 		if v.ModelId > 0 {
 			modelIds = append(modelIds, v.ModelId)
 		}
+		if v.Tid > 0 {
+			typeIds = append(typeIds, v.Tid)
+		}
 	}

 	modelNameMap := make(map[int]string)
+	typeNameMap := make(map[int]string)
 	if len(modelIds) > 0 {
 		var models []model.ChatModel
 		tx := h.DB.Where("id IN ?", modelIds).Find(&models)
@@ -91,6 +96,15 @@ func (h *ChatRoleHandler) List(c *gin.Context) {
 			}
 		}
 	}
+	if len(typeIds) > 0 {
+		var appTypes []model.AppType
+		tx := h.DB.Where("id IN ?", typeIds).Find(&appTypes)
+		if tx.Error == nil {
+			for _, m := range appTypes {
+				typeNameMap[int(m.Id)] = m.Name
+			}
+		}
+	}

 	for _, v := range items {
 		var role vo.ChatRole
@@ -100,6 +114,7 @@ func (h *ChatRoleHandler) List(c *gin.Context) {
 			role.CreatedAt = v.CreatedAt.Unix()
 			role.UpdatedAt = v.UpdatedAt.Unix()
 			role.ModelName = modelNameMap[role.ModelId]
+			role.TypeName = typeNameMap[role.Tid]
 			roles = append(roles, role)
 		}
 	}
@@ -108,7 +123,7 @@ func (h *ChatRoleHandler) List(c *gin.Context) {
 }

 // Sort 更新角色排序
-func (h *ChatRoleHandler) Sort(c *gin.Context) {
+func (h *ChatAppHandler) Sort(c *gin.Context) {
 	var data struct {
 		Ids   []uint `json:"ids"`
 		Sorts []int  `json:"sorts"`
@@ -130,7 +145,7 @@ func (h *ChatRoleHandler) Sort(c *gin.Context) {
 	resp.SUCCESS(c)
 }

-func (h *ChatRoleHandler) Set(c *gin.Context) {
+func (h *ChatAppHandler) Set(c *gin.Context) {
 	var data struct {
 		Id    uint        `json:"id"`
 		Filed string      `json:"filed"`
@@ -150,7 +165,7 @@ func (h *ChatRoleHandler) Set(c *gin.Context) {
 	resp.SUCCESS(c)
 }

-func (h *ChatRoleHandler) Remove(c *gin.Context) {
+func (h *ChatAppHandler) Remove(c *gin.Context) {
 	id := h.GetInt(c, "id", 0)

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

 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
@@ -67,6 +68,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]
+				if !ok {
+					payMethod = item.PayWay
+				}
+				payName, ok := types.PayNames[item.PayType]
+				if !ok {
+					payName = item.PayWay
+				}
+				order.PayMethod = payMethod
+				order.PayName = payName
 				list = append(list, order)
 			} else {
 				logger.Error(err)
@@ -92,7 +103,7 @@ func (h *OrderHandler) Remove(c *gin.Context) {
 			return
 		}

-		err := h.DB.Unscoped().Where("id = ?", id).Delete(&model.Order{}).Error
+		err := h.DB.Where("id = ?", id).Delete(&model.Order{}).Error
 		if err != nil {
 			resp.ERROR(c, err.Error())
 			return
@@ -102,8 +113,20 @@ func (h *OrderHandler) Remove(c *gin.Context) {
 }

 func (h *OrderHandler) Clear(c *gin.Context) {
-
-	err := h.DB.Unscoped().Where("status <> ?", 2).Where("pay_time", 0).Delete(&model.Order{}).Error
+	var orders []model.Order
+	err := h.DB.Where("status <> ?", 2).Where("pay_time", 0).Find(&orders).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+	deleteIds := make([]uint, 0)
+	for _, order := range orders {
+		// 只删除 15 分钟内的未支付订单
+		if time.Now().After(order.CreatedAt.Add(time.Minute * 15)) {
+			deleteIds = append(deleteIds, order.Id)
+		}
+	}
+	err = h.DB.Where("id IN ?", deleteIds).Delete(&model.Order{}).Error
 	if err != nil {
 		resp.ERROR(c, err.Error())
 		return
--- a/api/handler/admin/user_handler.go
+++ b/api/handler/admin/user_handler.go
@@ -17,6 +17,7 @@ import (
 	"geekai/store/vo"
 	"geekai/utils"
 	"geekai/utils/resp"
+	"github.com/go-redis/redis/v8"
 	"time"

 	"github.com/gin-gonic/gin"
@@ -26,10 +27,11 @@ import (
 type UserHandler struct {
 	handler.BaseHandler
 	licenseService *service.LicenseService
+	redis          *redis.Client
 }

-func NewUserHandler(app *core.AppServer, db *gorm.DB, licenseService *service.LicenseService) *UserHandler {
-	return &UserHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}, licenseService: licenseService}
+func NewUserHandler(app *core.AppServer, db *gorm.DB, licenseService *service.LicenseService, redisCli *redis.Client) *UserHandler {
+	return &UserHandler{BaseHandler: handler.BaseHandler{App: app, DB: db}, licenseService: licenseService, redis: redisCli}
 }

 // List 用户列表
@@ -73,6 +75,8 @@ func (h *UserHandler) Save(c *gin.Context) {
 		Id          uint     `json:"id"`
 		Password    string   `json:"password"`
 		Username    string   `json:"username"`
+		Mobile      string   `json:"mobile"`
+		Email       string   `json:"email"`
 		ChatRoles   []string `json:"chat_roles"`
 		ChatModels  []int    `json:"chat_models"`
 		ExpiredTime string   `json:"expired_time"`
@@ -102,6 +106,8 @@ func (h *UserHandler) Save(c *gin.Context) {
 		}
 		var oldPower = user.Power
 		user.Username = data.Username
+		user.Email = data.Email
+		user.Mobile = data.Mobile
 		user.Status = data.Status
 		user.Vip = data.Vip
 		user.Power = data.Power
@@ -109,7 +115,8 @@ func (h *UserHandler) Save(c *gin.Context) {
 		user.ChatModels = utils.JsonEncode(data.ChatModels)
 		user.ExpiredTime = utils.Str2stamp(data.ExpiredTime)

-		res = h.DB.Select("username", "status", "vip", "power", "chat_roles_json", "chat_models_json", "expired_time").Updates(&user)
+		res = h.DB.Select("username", "mobile", "email", "status", "vip", "power", "chat_roles_json", "chat_models_json", "expired_time").Updates(&user)
+
 		if res.Error != nil {
 			logger.Error("error with update database：", res.Error)
 			resp.ERROR(c, res.Error.Error())
@@ -135,6 +142,13 @@ func (h *UserHandler) Save(c *gin.Context) {
 				CreatedAt: time.Now(),
 			})
 		}
+		// 如果禁用了用户，则将用户踢下线
+		if user.Status == false {
+			key := fmt.Sprintf("users/%v", user.Id)
+			if _, err := h.redis.Del(c, key).Result(); err != nil {
+				logger.Error("error with delete session: ", err)
+			}
+		}
 	} else {
 		// 检查用户是否已经存在
 		h.DB.Where("username", data.Username).First(&user)
@@ -147,6 +161,8 @@ func (h *UserHandler) Save(c *gin.Context) {
 		u := model.User{
 			Username:    data.Username,
 			Password:    utils.GenPassword(data.Password, salt),
+			Mobile:      data.Mobile,
+			Email:       data.Email,
 			Avatar:      "/images/avatar/user.png",
 			Salt:        salt,
 			Power:       data.Power,
@@ -262,7 +278,7 @@ func (h *UserHandler) Remove(c *gin.Context) {
 		}
 	}
 	if err != nil {
-		resp.ERROR(c, "删除失败")
+		resp.ERROR(c, err.Error())
 		tx.Rollback()
 		return
 	}
--- a/api/handler/base_handler.go
+++ b/api/handler/base_handler.go
@@ -8,13 +8,13 @@ package handler
 // * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 import (
+	"errors"
+	"fmt"
 	"geekai/core"
 	"geekai/core/types"
 	logger2 "geekai/logger"
 	"geekai/store/model"
 	"geekai/utils"
-	"errors"
-	"fmt"
 	"gorm.io/gorm"
 	"strings"

@@ -85,7 +85,7 @@ func (h *BaseHandler) GetLoginUser(c *gin.Context) (model.User, error) {
 	}

 	var user model.User
-	res := h.DB.First(&user, userId)
+	res := h.DB.Where("id", userId).First(&user)
 	// 更新缓存
 	if res.Error == nil {
 		c.Set(types.LoginUserCache, user)
--- a/api/handler/chat_app_type_handler.go
+++ b/api/handler/chat_app_type_handler.go
@@ -0,0 +1,44 @@
+package handler
+
+import (
+	"geekai/core"
+	"geekai/store/model"
+	"geekai/store/vo"
+	"geekai/utils"
+	"geekai/utils/resp"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type ChatAppTypeHandler struct {
+	BaseHandler
+}
+
+func NewChatAppTypeHandler(app *core.AppServer, db *gorm.DB) *ChatAppTypeHandler {
+	return &ChatAppTypeHandler{BaseHandler: BaseHandler{App: app, DB: db}}
+}
+
+// List 获取App类型列表
+func (h *ChatAppTypeHandler) List(c *gin.Context) {
+	var items []model.AppType
+	var appTypes = make([]vo.AppType, 0)
+	err := h.DB.Where("enabled", true).Order("sort_num ASC").Find(&items).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	for _, v := range items {
+		var appType vo.AppType
+		err = utils.CopyObject(v, &appType)
+		if err != nil {
+			continue
+		}
+		appType.Id = v.Id
+		appType.CreatedAt = v.CreatedAt.Unix()
+		appTypes = append(appTypes, appType)
+	}
+
+	resp.SUCCESS(c, appTypes)
+}
--- a/api/handler/chat_role_handler.go
+++ b/api/handler/chat_role_handler.go
@@ -29,10 +29,37 @@ func NewChatRoleHandler(app *core.AppServer, db *gorm.DB) *ChatRoleHandler {

 // List 获取用户聊天应用列表
 func (h *ChatRoleHandler) List(c *gin.Context) {
+	tid := h.GetInt(c, "tid", 0)
+	var roles []model.ChatRole
+	session := h.DB.Where("enable", true)
+	if tid > 0 {
+		session = session.Where("tid", tid)
+	}
+	err := session.Order("sort_num ASC").Find(&roles).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	var roleVos = make([]vo.ChatRole, 0)
+	for _, r := range roles {
+		var v vo.ChatRole
+		err := utils.CopyObject(r, &v)
+		if err == nil {
+			v.Id = r.Id
+			roleVos = append(roleVos, v)
+		}
+	}
+	resp.SUCCESS(c, roleVos)
+}
+
+// ListByUser 获取用户添加的角色列表
+func (h *ChatRoleHandler) ListByUser(c *gin.Context) {
 	id := h.GetInt(c, "id", 0)
 	userId := h.GetLoginUserId(c)
 	var roles []model.ChatRole
-	query := h.DB.Where("enable", true)
+	session := h.DB.Where("enable", true)
+	// 如果用户没登录，则获取所有角色
 	if userId > 0 {
 		var user model.User
 		h.DB.First(&user, userId)
@@ -42,12 +69,16 @@ func (h *ChatRoleHandler) List(c *gin.Context) {
 			resp.ERROR(c, "角色解析失败！")
 			return
 		}
-		query = query.Where("marker IN ?", roleKeys)
+		// 保证用户至少有一个角色可用
+		if len(roleKeys) > 0 {
+			session = session.Where("marker IN ?", roleKeys)
+		}
 	}
+
 	if id > 0 {
-		query = query.Or("id", id)
+		session = session.Or("id", id)
 	}
-	res := h.DB.Where("enable", true).Order("sort_num ASC").Find(&roles)
+	res := session.Order("sort_num ASC").Find(&roles)
 	if res.Error != nil {
 		resp.ERROR(c, res.Error.Error())
 		return
--- a/api/handler/chatimpl/chat_handler.go
+++ b/api/handler/chatimpl/chat_handler.go
@@ -73,13 +73,12 @@ func (h *ChatHandler) ChatHandle(c *gin.Context) {
 	roleId := h.GetInt(c, "role_id", 0)
 	chatId := c.Query("chat_id")
 	modelId := h.GetInt(c, "model_id", 0)
-	tools := c.Query("tools")

 	client := types.NewWsClient(ws)
 	var chatRole model.ChatRole
 	res := h.DB.First(&chatRole, roleId)
 	if res.Error != nil || !chatRole.Enable {
-		utils.ReplyMessage(client, "当前聊天角色不存在或者未启用，连接已关闭！！！")
+		utils.ReplyErrorMessage(client, "当前聊天角色不存在或者未启用，对话已关闭！！！")
 		c.Abort()
 		return
 	}
@@ -91,7 +90,7 @@ func (h *ChatHandler) ChatHandle(c *gin.Context) {
 	var chatModel model.ChatModel
 	res = h.DB.First(&chatModel, modelId)
 	if res.Error != nil || chatModel.Enabled == false {
-		utils.ReplyMessage(client, "当前AI模型暂未启用，连接已关闭！！！")
+		utils.ReplyErrorMessage(client, "当前AI模型暂未启用，对话已关闭！！！")
 		c.Abort()
 		return
 	}
@@ -100,7 +99,6 @@ func (h *ChatHandler) ChatHandle(c *gin.Context) {
 		SessionId: sessionId,
 		ClientIP:  c.ClientIP(),
 		UserId:    h.GetLoginUserId(c),
-		Tools:     tools,
 	}

 	// use old chat data override the chat model and role ID
@@ -137,20 +135,16 @@ func (h *ChatHandler) ChatHandle(c *gin.Context) {
 				return
 			}

-			var message types.WsMessage
+			var message types.InputMessage
 			err = utils.JsonDecode(string(msg), &message)
 			if err != nil {
 				continue
 			}

-			// 心跳消息
-			if message.Type == "heartbeat" {
-				logger.Debug("收到 Chat 心跳消息：", message.Content)
-				continue
-			}
-
-			logger.Info("Receive a message: ", message.Content)
+			logger.Infof("Receive a message:%+v", message)

+			session.Tools = message.Tools
+			session.Stream = message.Stream
 			ctx, cancel := context.WithCancel(context.Background())
 			h.ReqCancelFunc.Put(sessionId, cancel)
 			// 回复消息
@@ -159,7 +153,7 @@ func (h *ChatHandler) ChatHandle(c *gin.Context) {
 				logger.Error(err)
 				utils.ReplyMessage(client, err.Error())
 			} else {
-				utils.ReplyChunkMessage(client, types.WsMessage{Type: types.WsEnd})
+				utils.ReplyChunkMessage(client, types.ReplyMessage{Type: types.WsEnd})
 				logger.Infof("回答完毕: %v", message.Content)
 			}

@@ -208,16 +202,22 @@ func (h *ChatHandler) sendMessage(ctx context.Context, session *types.ChatSessio
 	}

 	var req = types.ApiRequest{
-		Model:  session.Model.Value,
-		Stream: true,
+		Model: session.Model.Value,
+	}
+	// 兼容 GPT-O1 模型
+	if strings.HasPrefix(session.Model.Value, "o1-") {
+		utils.ReplyContent(ws, "AI 正在思考...\n")
+		req.Stream = false
+		session.Start = time.Now().Unix()
+	} else {
+		req.MaxTokens = session.Model.MaxTokens
+		req.Temperature = session.Model.Temperature
+		req.Stream = session.Stream
 	}
-	req.Temperature = session.Model.Temperature
-	req.MaxTokens = session.Model.MaxTokens

-	if session.Tools != "" {
-		toolIds := strings.Split(session.Tools, ",")
+	if len(session.Tools) > 0 && !strings.HasPrefix(session.Model.Value, "o1-") {
 		var items []model.Function
-		res = h.DB.Where("enabled", true).Where("id IN ?", toolIds).Find(&items)
+		res = h.DB.Where("enabled", true).Where("id IN ?", session.Tools).Find(&items)
 		if res.Error == nil {
 			var tools = make([]types.Tool, 0)
 			for _, v := range items {
@@ -279,7 +279,7 @@ func (h *ChatHandler) sendMessage(ctx context.Context, session *types.ChatSessio

 		for i := len(messages) - 1; i >= 0; i-- {
 			v := messages[i]
-			tks, _ := utils.CalcTokens(v.Content, req.Model)
+			tks, _ = utils.CalcTokens(v.Content, req.Model)
 			// 上下文 token 超出了模型的最大上下文长度
 			if tokens+tks >= session.Model.MaxContext {
 				break
@@ -450,7 +450,7 @@ func (h *ChatHandler) doRequest(ctx context.Context, req types.ApiRequest, sessi
 	if err != nil {
 		return nil, err
 	}
-	logger.Debugf(utils.JsonEncode(req))
+	logger.Debugf("对话请求消息体：%+v", req)

 	apiURL := fmt.Sprintf("%s/v1/chat/completions", apiKey.ApiURL)
 	// 创建 HttpClient 请求对象
@@ -502,8 +502,7 @@ func (h *ChatHandler) subUserPower(userVo vo.User, session *types.ChatSession, p

 func (h *ChatHandler) saveChatHistory(
 	req types.ApiRequest,
-	prompt string,
-	contents []string,
+	usage Usage,
 	message types.Message,
 	chatCtx []types.Message,
 	session *types.ChatSession,
@@ -511,12 +510,8 @@ func (h *ChatHandler) saveChatHistory(
 	userVo vo.User,
 	promptCreatedAt time.Time,
 	replyCreatedAt time.Time) {
-	if message.Role == "" {
-		message.Role = "assistant"
-	}
-	message.Content = strings.Join(contents, "")
-	useMsg := types.Message{Role: "user", Content: prompt}

+	useMsg := types.Message{Role: "user", Content: usage.Prompt}
 	// 更新上下文消息，如果是调用函数则不需要更新上下文
 	if h.App.SysConfig.EnableContext {
 		chatCtx = append(chatCtx, useMsg)  // 提问消息
@@ -526,42 +521,52 @@ func (h *ChatHandler) saveChatHistory(

 	// 追加聊天记录
 	// for prompt
-	promptToken, err := utils.CalcTokens(prompt, req.Model)
-	if err != nil {
-		logger.Error(err)
+	var promptTokens, replyTokens, totalTokens int
+	if usage.PromptTokens > 0 {
+		promptTokens = usage.PromptTokens
+	} else {
+		promptTokens, _ = utils.CalcTokens(usage.Content, req.Model)
 	}
+
 	historyUserMsg := model.ChatMessage{
-		UserId:     userVo.Id,
-		ChatId:     session.ChatId,
-		RoleId:     role.Id,
-		Type:       types.PromptMsg,
-		Icon:       userVo.Avatar,
-		Content:    template.HTMLEscapeString(prompt),
-		Tokens:     promptToken,
-		UseContext: true,
-		Model:      req.Model,
+		UserId:      userVo.Id,
+		ChatId:      session.ChatId,
+		RoleId:      role.Id,
+		Type:        types.PromptMsg,
+		Icon:        userVo.Avatar,
+		Content:     template.HTMLEscapeString(usage.Prompt),
+		Tokens:      promptTokens,
+		TotalTokens: promptTokens,
+		UseContext:  true,
+		Model:       req.Model,
 	}
 	historyUserMsg.CreatedAt = promptCreatedAt
 	historyUserMsg.UpdatedAt = promptCreatedAt
-	err = h.DB.Save(&historyUserMsg).Error
+	err := h.DB.Save(&historyUserMsg).Error
 	if err != nil {
 		logger.Error("failed to save prompt history message: ", err)
 	}

 	// for reply
 	// 计算本次对话消耗的总 token 数量
-	replyTokens, _ := utils.CalcTokens(message.Content, req.Model)
-	totalTokens := replyTokens + getTotalTokens(req)
+	if usage.CompletionTokens > 0 {
+		replyTokens = usage.CompletionTokens
+		totalTokens = usage.TotalTokens
+	} else {
+		replyTokens, _ = utils.CalcTokens(message.Content, req.Model)
+		totalTokens = replyTokens + getTotalTokens(req)
+	}
 	historyReplyMsg := model.ChatMessage{
-		UserId:     userVo.Id,
-		ChatId:     session.ChatId,
-		RoleId:     role.Id,
-		Type:       types.ReplyMsg,
-		Icon:       role.Icon,
-		Content:    message.Content,
-		Tokens:     totalTokens,
-		UseContext: true,
-		Model:      req.Model,
+		UserId:      userVo.Id,
+		ChatId:      session.ChatId,
+		RoleId:      role.Id,
+		Type:        types.ReplyMsg,
+		Icon:        role.Icon,
+		Content:     usage.Content,
+		Tokens:      replyTokens,
+		TotalTokens: totalTokens,
+		UseContext:  true,
+		Model:       req.Model,
 	}
 	historyReplyMsg.CreatedAt = replyCreatedAt
 	historyReplyMsg.UpdatedAt = replyCreatedAt
@@ -572,7 +577,7 @@ func (h *ChatHandler) saveChatHistory(

 	// 更新用户算力
 	if session.Model.Power > 0 {
-		h.subUserPower(userVo, session, promptToken, replyTokens)
+		h.subUserPower(userVo, session, promptTokens, replyTokens)
 	}
 	// 保存当前会话
 	var chatItem model.ChatItem
@@ -582,10 +587,10 @@ func (h *ChatHandler) saveChatHistory(
 		chatItem.UserId = userVo.Id
 		chatItem.RoleId = role.Id
 		chatItem.ModelId = session.Model.Id
-		if utf8.RuneCountInString(prompt) > 30 {
-			chatItem.Title = string([]rune(prompt)[:30]) + "..."
+		if utf8.RuneCountInString(usage.Prompt) > 30 {
+			chatItem.Title = string([]rune(usage.Prompt)[:30]) + "..."
 		} else {
-			chatItem.Title = prompt
+			chatItem.Title = usage.Prompt
 		}
 		chatItem.Model = req.Model
 		err = h.DB.Create(&chatItem).Error
--- a/api/handler/chatimpl/openai_handler.go
+++ b/api/handler/chatimpl/openai_handler.go
@@ -23,6 +23,32 @@ import (
 	"time"
 )

+type Usage struct {
+	Prompt           string `json:"prompt,omitempty"`
+	Content          string `json:"content,omitempty"`
+	PromptTokens     int    `json:"prompt_tokens"`
+	CompletionTokens int    `json:"completion_tokens"`
+	TotalTokens      int    `json:"total_tokens"`
+}
+
+type OpenAIResVo struct {
+	Id                string `json:"id"`
+	Object            string `json:"object"`
+	Created           int    `json:"created"`
+	Model             string `json:"model"`
+	SystemFingerprint string `json:"system_fingerprint"`
+	Choices           []struct {
+		Index   int `json:"index"`
+		Message struct {
+			Role    string `json:"role"`
+			Content string `json:"content"`
+		} `json:"message"`
+		Logprobs     interface{} `json:"logprobs"`
+		FinishReason string      `json:"finish_reason"`
+	} `json:"choices"`
+	Usage Usage `json:"usage"`
+}
+
 // OPenAI 消息发送实现
 func (h *ChatHandler) sendOpenAiMessage(
 	chatCtx []types.Message,
@@ -49,17 +75,21 @@ func (h *ChatHandler) sendOpenAiMessage(
 		defer response.Body.Close()
 	}

+	if response.StatusCode != 200 {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("请求 OpenAI API 失败：%d, %v", response.StatusCode, string(body))
+	}
+
 	contentType := response.Header.Get("Content-Type")
 	if strings.Contains(contentType, "text/event-stream") {
 		replyCreatedAt := time.Now() // 记录回复时间
 		// 循环读取 Chunk 消息
-		var message = types.Message{}
+		var message = types.Message{Role: "assistant"}
 		var contents = make([]string, 0)
 		var function model.Function
 		var toolCall = false
 		var arguments = make([]string, 0)
 		scanner := bufio.NewScanner(response.Body)
-		var isNew = true
 		for scanner.Scan() {
 			line := scanner.Text()
 			if !strings.Contains(line, "data:") || len(line) < 30 {
@@ -106,8 +136,7 @@ func (h *ChatHandler) sendOpenAiMessage(
 				if res.Error == nil {
 					toolCall = true
 					callMsg := fmt.Sprintf("正在调用工具 `%s` 作答 ...\n\n", function.Label)
-					utils.ReplyChunkMessage(ws, types.WsMessage{Type: types.WsStart})
-					utils.ReplyChunkMessage(ws, types.WsMessage{Type: types.WsMiddle, Content: callMsg})
+					utils.ReplyChunkMessage(ws, types.ReplyMessage{Type: types.WsContent, Content: callMsg})
 					contents = append(contents, callMsg)
 				}
 				continue
@@ -124,12 +153,8 @@ func (h *ChatHandler) sendOpenAiMessage(
 			} else {
 				content := responseBody.Choices[0].Delta.Content
 				contents = append(contents, utils.InterfaceToString(content))
-				if isNew {
-					utils.ReplyChunkMessage(ws, types.WsMessage{Type: types.WsStart})
-					isNew = false
-				}
-				utils.ReplyChunkMessage(ws, types.WsMessage{
-					Type:    types.WsMiddle,
+				utils.ReplyChunkMessage(ws, types.ReplyMessage{
+					Type:    types.WsContent,
 					Content: utils.InterfaceToString(responseBody.Choices[0].Delta.Content),
 				})
 			}
@@ -161,14 +186,14 @@ func (h *ChatHandler) sendOpenAiMessage(
 			}
 			if errMsg != "" || apiRes.Code != types.Success {
 				msg := "调用函数工具出错：" + apiRes.Message + errMsg
-				utils.ReplyChunkMessage(ws, types.WsMessage{
-					Type:    types.WsMiddle,
+				utils.ReplyChunkMessage(ws, types.ReplyMessage{
+					Type:    types.WsContent,
 					Content: msg,
 				})
 				contents = append(contents, msg)
 			} else {
-				utils.ReplyChunkMessage(ws, types.WsMessage{
-					Type:    types.WsMiddle,
+				utils.ReplyChunkMessage(ws, types.ReplyMessage{
+					Type:    types.WsContent,
 					Content: apiRes.Data,
 				})
 				contents = append(contents, utils.InterfaceToString(apiRes.Data))
@@ -177,11 +202,34 @@ func (h *ChatHandler) sendOpenAiMessage(

 		// 消息发送成功
 		if len(contents) > 0 {
-			h.saveChatHistory(req, prompt, contents, message, chatCtx, session, role, userVo, promptCreatedAt, replyCreatedAt)
+			usage := Usage{
+				Prompt:           prompt,
+				Content:          strings.Join(contents, ""),
+				PromptTokens:     0,
+				CompletionTokens: 0,
+				TotalTokens:      0,
+			}
+			message.Content = usage.Content
+			h.saveChatHistory(req, usage, message, chatCtx, session, role, userVo, promptCreatedAt, replyCreatedAt)
 		}
-	} else {
-		body, _ := io.ReadAll(response.Body)
-		return fmt.Errorf("请求 OpenAI API 失败：%s", body)
+	} else { // 非流式输出
+		var respVo OpenAIResVo
+		body, err := io.ReadAll(response.Body)
+		if err != nil {
+			return fmt.Errorf("读取响应失败：%v", body)
+		}
+		err = json.Unmarshal(body, &respVo)
+		if err != nil {
+			return fmt.Errorf("解析响应失败：%v", body)
+		}
+		content := respVo.Choices[0].Message.Content
+		if strings.HasPrefix(req.Model, "o1-") {
+			content = fmt.Sprintf("AI思考结束，耗时：%d 秒。\n%s", time.Now().Unix()-session.Start, respVo.Choices[0].Message.Content)
+		}
+		utils.ReplyMessage(ws, content)
+		respVo.Usage.Prompt = prompt
+		respVo.Usage.Content = content
+		h.saveChatHistory(req, respVo.Usage, respVo.Choices[0].Message, chatCtx, session, role, userVo, promptCreatedAt, time.Now())
 	}

 	return nil
--- a/api/handler/dalle_handler.go
+++ b/api/handler/dalle_handler.go
@@ -73,7 +73,7 @@ func (h *DallJobHandler) Client(c *gin.Context) {
 				return
 			}

-			var message types.WsMessage
+			var message types.ReplyMessage
 			err = utils.JsonDecode(string(msg), &message)
 			if err != nil {
 				continue
--- a/api/handler/markmap_handler.go
+++ b/api/handler/markmap_handler.go
@@ -64,7 +64,7 @@ func (h *MarkMapHandler) Client(c *gin.Context) {
 				return
 			}

-			var message types.WsMessage
+			var message types.ReplyMessage
 			err = utils.JsonDecode(string(msg), &message)
 			if err != nil {
 				continue
@@ -85,7 +85,9 @@ func (h *MarkMapHandler) Client(c *gin.Context) {
 			err = h.sendMessage(client, utils.InterfaceToString(message.Content), modelId, userId)
 			if err != nil {
 				logger.Error(err)
-				utils.ReplyChunkMessage(client, types.WsMessage{Type: types.WsErr, Content: err.Error()})
+				utils.ReplyErrorMessage(client, err.Error())
+			} else {
+				utils.ReplyMessage(client, types.ReplyMessage{Type: types.WsEnd})
 			}

 		}
@@ -148,7 +150,6 @@ func (h *MarkMapHandler) sendMessage(client *types.WsClient, prompt string, mode
 	if strings.Contains(contentType, "text/event-stream") {
 		// 循环读取 Chunk 消息
 		scanner := bufio.NewScanner(response.Body)
-		var isNew = true
 		for scanner.Scan() {
 			line := scanner.Text()
 			if !strings.Contains(line, "data:") || len(line) < 30 {
@@ -169,17 +170,13 @@ func (h *MarkMapHandler) sendMessage(client *types.WsClient, prompt string, mode
 				break
 			}

-			if isNew {
-				utils.ReplyChunkMessage(client, types.WsMessage{Type: types.WsStart})
-				isNew = false
-			}
-			utils.ReplyChunkMessage(client, types.WsMessage{
-				Type:    types.WsMiddle,
+			utils.ReplyChunkMessage(client, types.ReplyMessage{
+				Type:    types.WsContent,
 				Content: utils.InterfaceToString(responseBody.Choices[0].Delta.Content),
 			})
 		} // end for

-		utils.ReplyChunkMessage(client, types.WsMessage{Type: types.WsEnd})
+		utils.ReplyChunkMessage(client, types.ReplyMessage{Type: types.WsEnd})

 	} else {
 		body, _ := io.ReadAll(response.Body)
--- a/api/handler/upload_handler.go
+++ b/api/handler/upload_handler.go
@@ -64,7 +64,9 @@ func (h *NetHandler) Upload(c *gin.Context) {

 func (h *NetHandler) List(c *gin.Context) {
 	var data struct {
-		Urls []string `json:"urls,omitempty"`
+		Urls     []string `json:"urls,omitempty"`
+		Page     int      `json:"page"`
+		PageSize int      `json:"page_size"`
 	}
 	if err := c.ShouldBindJSON(&data); err != nil {
 		resp.ERROR(c, types.InvalidArgs)
@@ -79,21 +81,32 @@ func (h *NetHandler) List(c *gin.Context) {
 	if len(data.Urls) > 0 {
 		session = session.Where("url IN ?", data.Urls)
 	}
-	session.Find(&items)
-	if len(items) > 0 {
-		for _, v := range items {
-			var file vo.File
-			err := utils.CopyObject(v, &file)
-			if err != nil {
-				logger.Error(err)
-				continue
-			}
-			file.CreatedAt = v.CreatedAt.Unix()
-			files = append(files, file)
-		}
+	// 统计总数
+	var total int64
+	session.Model(&model.File{}).Count(&total)
+
+	if data.Page > 0 && data.PageSize > 0 {
+		offset := (data.Page - 1) * data.PageSize
+		session = session.Offset(offset).Limit(data.PageSize)
+	}
+	err := session.Order("id desc").Find(&items).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
 	}

-	resp.SUCCESS(c, files)
+	for _, v := range items {
+		var file vo.File
+		err := utils.CopyObject(v, &file)
+		if err != nil {
+			logger.Error(err)
+			continue
+		}
+		file.CreatedAt = v.CreatedAt.Unix()
+		files = append(files, file)
+	}
+
+	resp.SUCCESS(c, vo.NewPage(total, data.Page, data.PageSize, files))
 }

 // Remove remove files
--- a/api/handler/order_handler.go
+++ b/api/handler/order_handler.go
@@ -48,6 +48,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]
+				if !ok {
+					payMethod = item.PayWay
+				}
+				payName, ok := types.PayNames[item.PayType]
+				if !ok {
+					payName = item.PayWay
+				}
+				order.PayMethod = payMethod
+				order.PayName = payName
 				list = append(list, order)
 			} else {
 				logger.Error(err)
--- a/api/handler/payment_handler.go
+++ b/api/handler/payment_handler.go
@@ -9,7 +9,6 @@ package handler

 import (
 	"embed"
-	"encoding/base64"
 	"fmt"
 	"geekai/core"
 	"geekai/core/types"
@@ -19,9 +18,7 @@ import (
 	"geekai/utils"
 	"geekai/utils/resp"
 	"github.com/shopspring/decimal"
-	"math"
 	"net/http"
-	"net/url"
 	"sync"
 	"time"

@@ -34,21 +31,15 @@ type PayWay struct {
 	Value string `json:"value"`
 }

-var (
-	PayWayAlipay = PayWay{Name: "支付宝", Value: "alipay"}
-	PayWayXunHu  = PayWay{Name: "虎皮椒", Value: "hupi"}
-	PayWayJs     = PayWay{Name: "PayJS", Value: "payjs"}
-	PayWayWechat = PayWay{Name: "微信支付", Value: "wechat"}
-)
-
 // PaymentHandler 支付服务回调 handler
 type PaymentHandler struct {
 	BaseHandler
 	alipayService    *payment.AlipayService
 	huPiPayService   *payment.HuPiPayService
-	jsPayService     *payment.JPayService
+	geekPayService   *payment.GeekPayService
 	wechatPayService *payment.WechatPayService
 	snowflake        *service.Snowflake
+	userService      *service.UserService
 	fs               embed.FS
 	lock             sync.Mutex
 	signKey          string // 用来签名的随机秘钥
@@ -58,17 +49,19 @@ func NewPaymentHandler(
 	server *core.AppServer,
 	alipayService *payment.AlipayService,
 	huPiPayService *payment.HuPiPayService,
-	jsPayService *payment.JPayService,
+	geekPayService *payment.GeekPayService,
 	wechatPayService *payment.WechatPayService,
 	db *gorm.DB,
+	userService *service.UserService,
 	snowflake *service.Snowflake,
 	fs embed.FS) *PaymentHandler {
 	return &PaymentHandler{
 		alipayService:    alipayService,
 		huPiPayService:   huPiPayService,
-		jsPayService:     jsPayService,
+		geekPayService:   geekPayService,
 		wechatPayService: wechatPayService,
 		snowflake:        snowflake,
+		userService:      userService,
 		fs:               fs,
 		lock:             sync.Mutex{},
 		BaseHandler: BaseHandler{
@@ -79,309 +72,146 @@ func NewPaymentHandler(
 	}
 }

-func (h *PaymentHandler) DoPay(c *gin.Context) {
-	orderNo := h.GetTrim(c, "order_no")
-	payWay := h.GetTrim(c, "pay_way")
-	t := h.GetInt(c, "t", 0)
-	sign := h.GetTrim(c, "sign")
-	signStr := fmt.Sprintf("%s-%s-%d-%s", orderNo, payWay, t, h.signKey)
-	newSign := utils.Sha256(signStr)
-	if newSign != sign {
-		resp.ERROR(c, "订单签名错误！")
-		return
+func (h *PaymentHandler) Pay(c *gin.Context) {
+	var data struct {
+		PayWay    string `json:"pay_way"`
+		PayType   string `json:"pay_type"`
+		ProductId int    `json:"product_id"`
+		UserId    int    `json:"user_id"`
+		Device    string `json:"device"`
+		Host      string `json:"host"`
 	}
-
-	// 检查二维码是否过期
-	if time.Now().Unix()-int64(t) > int64(h.App.SysConfig.OrderPayTimeout) {
-		resp.ERROR(c, "支付二维码已过期，请重新生成！")
-		return
-	}
-
-	if orderNo == "" {
+	if err := c.ShouldBindJSON(&data); err != nil {
 		resp.ERROR(c, types.InvalidArgs)
 		return
 	}

-	var order model.Order
-	res := h.DB.Where("order_no = ?", orderNo).First(&order)
-	if res.Error != nil {
-		resp.ERROR(c, "Order not found")
+	var product model.Product
+	err := h.DB.Where("id", data.ProductId).First(&product).Error
+	if err != nil {
+		resp.ERROR(c, "Product not found")
 		return
 	}

-	// fix: 这里先检查一下订单状态，如果已经支付了，就直接返回
-	if order.Status == types.OrderPaidSuccess {
-		resp.ERROR(c, "订单已支付成功，无需重复支付！")
+	orderNo, err := h.snowflake.Next(false)
+	if err != nil {
+		resp.ERROR(c, "error with generate trade no: "+err.Error())
+		return
+	}
+	var user model.User
+	err = h.DB.Where("id", data.UserId).First(&user).Error
+	if err != nil {
+		resp.NotAuth(c)
 		return
 	}

-	// 更新扫码状态
-	h.DB.Model(&order).UpdateColumn("status", types.OrderScanned)
-
-	if payWay == "alipay" { // 支付宝
-		amount := fmt.Sprintf("%.2f", order.Amount)
-		uri, err := h.alipayService.PayUrlMobile(order.OrderNo, amount, order.Subject)
+	amount, _ := decimal.NewFromFloat(product.Price).Sub(decimal.NewFromFloat(product.Discount)).Float64()
+	var payURL, returnURL, notifyURL string
+	switch data.PayWay {
+	case "alipay":
+		if h.App.Config.AlipayConfig.NotifyURL != "" { // 用于本地调试支付
+			notifyURL = h.App.Config.AlipayConfig.NotifyURL
+		} else {
+			notifyURL = fmt.Sprintf("%s/api/payment/notify/alipay", data.Host)
+		}
+		if h.App.Config.AlipayConfig.ReturnURL != "" { // 用于本地调试支付
+			returnURL = h.App.Config.AlipayConfig.ReturnURL
+		} else {
+			returnURL = fmt.Sprintf("%s/payReturn", data.Host)
+		}
+		money := fmt.Sprintf("%.2f", amount)
+		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
 		}
-
-		c.Redirect(302, uri)
-		return
-	} else if payWay == "hupi" { // 虎皮椒支付
-		params := payment.HuPiPayReq{
-			Version:      "1.1",
-			TradeOrderId: orderNo,
-			TotalFee:     fmt.Sprintf("%f", order.Amount),
-			Title:        order.Subject,
-			NotifyURL:    h.App.Config.HuPiPayConfig.NotifyURL,
-			WapName:      "极客学长",
+		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)
 		}
-		r, err := h.huPiPayService.Pay(params)
+		payURL, err = h.wechatPayService.PayUrlNative(payment.WechatPayParams{
+			OutTradeNo: orderNo,
+			TotalFee:   int(amount * 100),
+			Subject:    product.Name,
+			NotifyURL:  notifyURL,
+		})
 		if err != nil {
 			resp.ERROR(c, err.Error())
 			return
 		}
-
-		c.Redirect(302, r.URL)
-	}
-	resp.ERROR(c, "Invalid operations")
-}
-
-// PayQrcode 生成支付 URL 二维码
-func (h *PaymentHandler) PayQrcode(c *gin.Context) {
-	var data struct {
-		PayWay    string `json:"pay_way"` // 支付方式
-		ProductId uint   `json:"product_id"`
-	}
-	if err := c.ShouldBindJSON(&data); err != nil {
-		resp.ERROR(c, types.InvalidArgs)
-		return
-	}
-
-	var product model.Product
-	res := h.DB.First(&product, data.ProductId)
-	if res.Error != nil {
-		resp.ERROR(c, "Product not found")
-		return
-	}
-
-	orderNo, err := h.snowflake.Next(false)
-	if err != nil {
-		resp.ERROR(c, "error with generate trade no: "+err.Error())
-		return
-	}
-	user, err := h.GetLoginUser(c)
-	if err != nil {
-		resp.NotAuth(c)
-		return
-	}
-
-	var payWay string
-	var notifyURL string
-	switch data.PayWay {
+		break
 	case "hupi":
-		payWay = PayWayXunHu.Value
-		notifyURL = h.App.Config.HuPiPayConfig.NotifyURL
-		break
-	case "payjs":
-		payWay = PayWayJs.Value
-		notifyURL = h.App.Config.JPayConfig.NotifyURL
-		break
-	case "alipay":
-		payWay = PayWayAlipay.Value
-		notifyURL = h.App.Config.AlipayConfig.NotifyURL
-		break
-	default:
-		payWay = PayWayWechat.Value
-		notifyURL = h.App.Config.WechatPayConfig.NotifyURL
-
-	}
-	// 创建订单
-	remark := types.OrderRemark{
-		Days:     product.Days,
-		Power:    product.Power,
-		Name:     product.Name,
-		Price:    product.Price,
-		Discount: product.Discount,
-	}
-
-	amount, _ := decimal.NewFromFloat(product.Price).Sub(decimal.NewFromFloat(product.Discount)).Float64()
-	order := model.Order{
-		UserId:    user.Id,
-		Username:  user.Username,
-		ProductId: product.Id,
-		OrderNo:   orderNo,
-		Subject:   product.Name,
-		Amount:    amount,
-		Status:    types.OrderNotPaid,
-		PayWay:    payWay,
-		Remark:    utils.JsonEncode(remark),
-	}
-	res = h.DB.Create(&order)
-	if res.Error != nil || res.RowsAffected == 0 {
-		resp.ERROR(c, "error with create order: "+res.Error.Error())
-		return
-	}
-
-	// PayJs 单独处理，只能用官方生成的二维码
-	if data.PayWay == "payjs" {
-		params := payment.JPayReq{
-			TotalFee:   int(math.Ceil(order.Amount * 100)),
-			OutTradeNo: order.OrderNo,
-			Subject:    product.Name,
-		}
-		r := h.jsPayService.Pay(params)
-		if r.IsOK() {
-			resp.SUCCESS(c, gin.H{"order_no": order.OrderNo, "image": r.Qrcode})
-			return
+		if h.App.Config.HuPiPayConfig.NotifyURL != "" {
+			notifyURL = h.App.Config.HuPiPayConfig.NotifyURL
 		} else {
-			resp.ERROR(c, "error with generating payment qrcode: "+r.ReturnMsg)
-			return
+			notifyURL = fmt.Sprintf("%s/api/payment/notify/hupi", data.Host)
 		}
-	}
-
-	var logo string
-	if data.PayWay == "alipay" {
-		logo = "res/img/alipay.jpg"
-	} else if data.PayWay == "hupi" {
-		if h.App.Config.HuPiPayConfig.Name == "wechat" {
-			logo = "res/img/wechat-pay.jpg"
+		if h.App.Config.HuPiPayConfig.ReturnURL != "" {
+			returnURL = h.App.Config.HuPiPayConfig.ReturnURL
 		} else {
-			logo = "res/img/alipay.jpg"
+			returnURL = fmt.Sprintf("%s/payReturn", data.Host)
 		}
-	} else if data.PayWay == "wechat" {
-		logo = "res/img/wechat-pay.jpg"
-	}
-
-	file, err := h.fs.Open(logo)
-	if err != nil {
-		resp.ERROR(c, "error with open qrcode log file: "+err.Error())
-		return
-	}
-
-	parse, err := url.Parse(notifyURL)
-	if err != nil {
-		resp.ERROR(c, err.Error())
-		return
-	}
-	timestamp := time.Now().Unix()
-	signStr := fmt.Sprintf("%s-%s-%d-%s", orderNo, data.PayWay, timestamp, h.signKey)
-	sign := utils.Sha256(signStr)
-	var imageURL string
-	if data.PayWay == "wechat" {
-		payUrl, err := h.wechatPayService.PayUrlNative(order.OrderNo, int(math.Floor(order.Amount*100)), product.Name)
-		if err != nil {
-			resp.ERROR(c, "error with generating wechat payment qrcode: "+err.Error())
-			return
-		} else {
-			imageURL = payUrl
-		}
-	} else {
-		imageURL = fmt.Sprintf("%s://%s/api/payment/doPay?order_no=%s&pay_way=%s&t=%d&sign=%s", parse.Scheme, parse.Host, orderNo, data.PayWay, timestamp, sign)
-	}
-	imgData, err := utils.GenQrcode(imageURL, 400, file)
-	if err != nil {
-		resp.ERROR(c, err.Error())
-		return
-	}
-	imgDataBase64 := base64.StdEncoding.EncodeToString(imgData)
-	resp.SUCCESS(c, gin.H{"order_no": orderNo, "image": fmt.Sprintf("data:image/jpg;base64, %s", imgDataBase64), "url": imageURL})
-}
-
-// Mobile 移动端支付
-func (h *PaymentHandler) Mobile(c *gin.Context) {
-	var data struct {
-		PayWay    string `json:"pay_way"` // 支付方式
-		ProductId uint   `json:"product_id"`
-	}
-	if err := c.ShouldBindJSON(&data); err != nil {
-		resp.ERROR(c, types.InvalidArgs)
-		return
-	}
-
-	var product model.Product
-	res := h.DB.First(&product, data.ProductId)
-	if res.Error != nil {
-		resp.ERROR(c, "Product not found")
-		return
-	}
-
-	orderNo, err := h.snowflake.Next(false)
-	if err != nil {
-		resp.ERROR(c, "error with generate trade no: "+err.Error())
-		return
-	}
-	user, err := h.GetLoginUser(c)
-	if err != nil {
-		resp.NotAuth(c)
-		return
-	}
-
-	amount, _ := decimal.NewFromFloat(product.Price).Sub(decimal.NewFromFloat(product.Discount)).Float64()
-	var payWay string
-	var notifyURL, returnURL string
-	var payURL string
-	switch data.PayWay {
-	case "hupi":
-		payWay = PayWayXunHu.Name
-		notifyURL = h.App.Config.HuPiPayConfig.NotifyURL
-		returnURL = h.App.Config.HuPiPayConfig.ReturnURL
-		parse, _ := url.Parse(h.App.Config.HuPiPayConfig.ReturnURL)
-		baseURL := fmt.Sprintf("%s://%s", parse.Scheme, parse.Host)
-		params := payment.HuPiPayReq{
+		r, err := h.huPiPayService.Pay(payment.HuPiPayParams{
 			Version:      "1.1",
 			TradeOrderId: orderNo,
 			TotalFee:     fmt.Sprintf("%f", amount),
 			Title:        product.Name,
 			NotifyURL:    notifyURL,
 			ReturnURL:    returnURL,
-			CallbackURL:  returnURL,
-			WapName:      "极客学长",
-			WapUrl:       baseURL,
-			Type:         "WAP",
-		}
-		r, err := h.huPiPayService.Pay(params)
+			WapName:      "GeekAI助手",
+		})
 		if err != nil {
-			errMsg := "error with generating Pay Hupi URL: " + err.Error()
-			logger.Error(errMsg)
-			resp.ERROR(c, errMsg)
+			resp.ERROR(c, err.Error())
 			return
 		}
 		payURL = r.URL
-	case "payjs":
-		payWay = PayWayJs.Name
-		notifyURL = h.App.Config.JPayConfig.NotifyURL
-		returnURL = h.App.Config.JPayConfig.ReturnURL
-		totalFee := decimal.NewFromFloat(product.Price).Sub(decimal.NewFromFloat(product.Discount)).Mul(decimal.NewFromInt(100)).IntPart()
-		params := url.Values{}
-		params.Add("total_fee", fmt.Sprintf("%d", totalFee))
-		params.Add("out_trade_no", orderNo)
-		params.Add("body", product.Name)
-		params.Add("notify_url", notifyURL)
-		params.Add("auto", "0")
-		payURL = h.jsPayService.PayH5(params)
-	case "alipay":
-		payWay = PayWayAlipay.Name
-		payURL, err = h.alipayService.PayUrlMobile(orderNo, fmt.Sprintf("%.2f", amount), product.Name)
+		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 {
-			errMsg := "error with generating Alipay URL: " + err.Error()
-			resp.ERROR(c, errMsg)
-			return
-		}
-	case "wechat":
-		payWay = PayWayWechat.Name
-		payURL, err = h.wechatPayService.PayUrlH5(orderNo, int(amount*100), product.Name, c.ClientIP())
-		if err != nil {
-			errMsg := "error with generating Wechat URL: " + err.Error()
-			logger.Error(errMsg)
-			resp.ERROR(c, errMsg)
+			resp.ERROR(c, err.Error())
 			return
 		}
+		payURL = res.PayURL
 	default:
-		resp.ERROR(c, "Unsupported pay way: "+data.PayWay)
+		resp.ERROR(c, "不支持的支付渠道")
 		return
 	}
+
 	// 创建订单
 	remark := types.OrderRemark{
 		Days:     product.Days,
@@ -390,7 +220,6 @@ func (h *PaymentHandler) Mobile(c *gin.Context) {
 		Price:    product.Price,
 		Discount: product.Discount,
 	}
-
 	order := model.Order{
 		UserId:    user.Id,
 		Username:  user.Username,
@@ -399,26 +228,24 @@ func (h *PaymentHandler) Mobile(c *gin.Context) {
 		Subject:   product.Name,
 		Amount:    amount,
 		Status:    types.OrderNotPaid,
-		PayWay:    payWay,
+		PayWay:    data.PayWay,
+		PayType:   data.PayType,
 		Remark:    utils.JsonEncode(remark),
 	}
-	res = h.DB.Create(&order)
-	if res.Error != nil || res.RowsAffected == 0 {
-		resp.ERROR(c, "error with create order: "+res.Error.Error())
+	err = h.DB.Create(&order).Error
+	if err != nil {
+		resp.ERROR(c, "error with create order: "+err.Error())
 		return
 	}
-
-	resp.SUCCESS(c, gin.H{"url": payURL, "order_no": orderNo})
+	resp.SUCCESS(c, payURL)
 }

 // 异步通知回调公共逻辑
 func (h *PaymentHandler) notify(orderNo string, tradeNo string) error {
 	var order model.Order
-	res := h.DB.Where("order_no = ?", orderNo).First(&order)
-	if res.Error != nil {
-		err := fmt.Errorf("error with fetch order: %v", res.Error)
-		logger.Error(err)
-		return err
+	err := h.DB.Where("order_no = ?", orderNo).First(&order).Error
+	if err != nil {
+		return fmt.Errorf("error with fetch order: %v", err)
 	}

 	h.lock.Lock()
@@ -430,45 +257,24 @@ func (h *PaymentHandler) notify(orderNo string, tradeNo string) error {
 	}

 	var user model.User
-	res = h.DB.First(&user, order.UserId)
-	if res.Error != nil {
-		err := fmt.Errorf("error with fetch user info: %v", res.Error)
-		logger.Error(err)
-		return err
+	err = h.DB.First(&user, order.UserId).Error
+	if err != nil {
+		return fmt.Errorf("error with fetch user info: %v", err)
 	}

 	var remark types.OrderRemark
-	err := utils.JsonDecode(order.Remark, &remark)
+	err = utils.JsonDecode(order.Remark, &remark)
 	if err != nil {
-		err := fmt.Errorf("error with decode order remark: %v", err)
-		logger.Error(err)
-		return err
+		return fmt.Errorf("error with decode order remark: %v", err)
 	}

-	var opt string
-	var power int
-	if remark.Days > 0 { // VIP 充值
-		if user.ExpiredTime >= time.Now().Unix() {
-			user.ExpiredTime = time.Unix(user.ExpiredTime, 0).AddDate(0, 0, remark.Days).Unix()
-			opt = "VIP充值，VIP 没到期，只延期不增加算力"
-		} else {
-			user.ExpiredTime = time.Now().AddDate(0, 0, remark.Days).Unix()
-			user.Power += h.App.SysConfig.VipMonthPower
-			power = h.App.SysConfig.VipMonthPower
-			opt = "VIP充值"
-		}
-		user.Vip = true
-	} else { // 充值点卡，直接增加次数即可
-		user.Power += remark.Power
-		opt = "点卡充值"
-		power = remark.Power
-	}
-
-	// 更新用户信息
-	res = h.DB.Updates(&user)
-	if res.Error != nil {
-		err := fmt.Errorf("error with update user info: %v", res.Error)
-		logger.Error(err)
+	// 增加用户算力
+	err = h.userService.IncreasePower(int(order.UserId), remark.Power, model.PowerLog{
+		Type:   types.PowerRecharge,
+		Model:  order.PayWay,
+		Remark: fmt.Sprintf("充值算力，金额：%f，订单号：%s", order.Amount, order.OrderNo),
+	})
+	if err != nil {
 		return err
 	}

@@ -476,29 +282,16 @@ func (h *PaymentHandler) notify(orderNo string, tradeNo string) error {
 	order.PayTime = time.Now().Unix()
 	order.Status = types.OrderPaidSuccess
 	order.TradeNo = tradeNo
-	res = h.DB.Updates(&order)
-	if res.Error != nil {
-		err := fmt.Errorf("error with update order info: %v", res.Error)
-		logger.Error(err)
-		return err
+	err = h.DB.Updates(&order).Error
+	if err != nil {
+		return fmt.Errorf("error with update order info: %v", err)
 	}

 	// 更新产品销量
-	h.DB.Model(&model.Product{}).Where("id = ?", order.ProductId).UpdateColumn("sales", gorm.Expr("sales + ?", 1))
-
-	// 记录算力充值日志
-	if power > 0 {
-		h.DB.Create(&model.PowerLog{
-			UserId:    user.Id,
-			Username:  user.Username,
-			Type:      types.PowerRecharge,
-			Amount:    power,
-			Balance:   user.Power,
-			Mark:      types.PowerAdd,
-			Model:     order.PayWay,
-			Remark:    fmt.Sprintf("%s，金额：%f，订单号：%s", opt, order.Amount, order.OrderNo),
-			CreatedAt: time.Now(),
-		})
+	err = h.DB.Model(&model.Product{}).Where("id = ?", order.ProductId).
+		UpdateColumn("sales", gorm.Expr("sales + ?", 1)).Error
+	if err != nil {
+		return fmt.Errorf("error with update product sales: %v", err)
 	}

 	return nil
@@ -506,20 +299,22 @@ func (h *PaymentHandler) notify(orderNo string, tradeNo string) error {

 // GetPayWays 获取支付方式
 func (h *PaymentHandler) GetPayWays(c *gin.Context) {
-	data := gin.H{}
+	payWays := make([]gin.H, 0)
 	if h.App.Config.AlipayConfig.Enabled {
-		data["alipay"] = gin.H{"name": "alipay"}
+		payWays = append(payWays, gin.H{"pay_way": "alipay", "pay_type": "alipay"})
 	}
 	if h.App.Config.HuPiPayConfig.Enabled {
-		data["hupi"] = gin.H{"name": h.App.Config.HuPiPayConfig.Name}
+		payWays = append(payWays, gin.H{"pay_way": "hupi", "pay_type": "wxpay"})
 	}
-	if h.App.Config.JPayConfig.Enabled {
-		data["payjs"] = gin.H{"name": h.App.Config.JPayConfig.Name}
+	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 {
-		data["wechat"] = gin.H{"name": "wechat"}
+		payWays = append(payWays, gin.H{"pay_way": "wechat", "pay_type": "wxpay"})
 	}
-	resp.SUCCESS(c, data)
+	resp.SUCCESS(c, payWays)
 }

 // HuPiPayNotify 虎皮椒支付异步回调
@@ -532,15 +327,17 @@ func (h *PaymentHandler) HuPiPayNotify(c *gin.Context) {

 	orderNo := c.Request.Form.Get("trade_order_id")
 	tradeNo := c.Request.Form.Get("open_order_id")
-	logger.Infof("收到虎皮椒订单支付回调，订单 NO：%s，交易流水号：%s", orderNo, tradeNo)
+	logger.Infof("收到虎皮椒订单支付回调，%+v", c.Request.Form)

-	if err = h.huPiPayService.Check(tradeNo); err != nil {
+	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
 	}
@@ -556,18 +353,18 @@ func (h *PaymentHandler) AlipayNotify(c *gin.Context) {
 		return
 	}

-	// TODO：验证交易签名
-	res := h.alipayService.TradeVerify(c.Request)
-	logger.Infof("验证支付结果：%+v", res)
-	if !res.Success() {
-		logger.Error("订单校验失败：", res.Message)
+	result := h.alipayService.TradeVerify(c.Request)
+	logger.Infof("收到支付宝商号订单支付回调：%+v", result)
+	if !result.Success() {
+		logger.Error("订单校验失败：", result.Message)
 		c.String(http.StatusOK, "fail")
 		return
 	}

 	tradeNo := c.Request.Form.Get("trade_no")
-	err = h.notify(res.OutTradeNo, tradeNo)
+	err = h.notify(result.OutTradeNo, tradeNo)
 	if err != nil {
+		logger.Error(err)
 		c.String(http.StatusOK, "fail")
 		return
 	}
@@ -575,33 +372,30 @@ func (h *PaymentHandler) AlipayNotify(c *gin.Context) {
 	c.String(http.StatusOK, "success")
 }

-// PayJsNotify PayJs 支付异步回调
-func (h *PaymentHandler) PayJsNotify(c *gin.Context) {
-	err := c.Request.ParseForm()
-	if err != nil {
+// GeekPayNotify 支付异步回调
+func (h *PaymentHandler) GeekPayNotify(c *gin.Context) {
+	var params = make(map[string]string)
+	for k := range c.Request.URL.Query() {
+		params[k] = c.Query(k)
+	}
+
+	logger.Infof("收到GeekPay订单支付回调：%+v", params)
+	// 检查支付状态
+	if params["trade_status"] != "TRADE_SUCCESS" {
+		c.String(http.StatusOK, "success")
+		return
+	}
+
+	sign := h.geekPayService.Sign(params)
+	if sign != c.Query("sign") {
+		logger.Errorf("签名验证失败, %s, %s", sign, c.Query("sign"))
 		c.String(http.StatusOK, "fail")
 		return
 	}

-	orderNo := c.Request.Form.Get("out_trade_no")
-	returnCode := c.Request.Form.Get("return_code")
-	logger.Infof("收到PayJs订单支付回调，订单 NO：%s，支付结果代码：%v", orderNo, returnCode)
-	// 支付失败
-	if returnCode != "1" {
-		return
-	}
-
-	// 校验订单支付状态
-	tradeNo := c.Request.Form.Get("payjs_order_id")
-	err = h.jsPayService.TradeVerify(tradeNo)
-	if err != nil {
-		logger.Error("订单校验失败：", err)
-		c.String(http.StatusOK, "fail")
-		return
-	}
-
-	err = h.notify(orderNo, tradeNo)
+	err := h.notify(params["out_trade_no"], params["trade_no"])
 	if err != nil {
+		logger.Error(err)
 		c.String(http.StatusOK, "fail")
 		return
 	}
@@ -618,6 +412,7 @@ func (h *PaymentHandler) WechatPayNotify(c *gin.Context) {
 	}

 	result := h.wechatPayService.TradeVerify(c.Request)
+	logger.Infof("收到微信商号订单支付回调：%+v", result)
 	if !result.Success() {
 		logger.Error("订单校验失败：", err)
 		c.JSON(http.StatusBadRequest, gin.H{
@@ -629,6 +424,7 @@ func (h *PaymentHandler) WechatPayNotify(c *gin.Context) {

 	err = h.notify(result.OutTradeNo, result.TradeId)
 	if err != nil {
+		logger.Error(err)
 		c.String(http.StatusOK, "fail")
 		return
 	}
--- a/api/handler/sms_handler.go
+++ b/api/handler/sms_handler.go
@@ -76,6 +76,20 @@ func (h *SmsHandler) SendCode(c *gin.Context) {
 			resp.ERROR(c, "系统已禁用邮箱注册！")
 			return
 		}
+		// 检查邮箱后缀是否在白名单
+		if len(h.App.SysConfig.EmailWhiteList) > 0 {
+			inWhiteList := false
+			for _, suffix := range h.App.SysConfig.EmailWhiteList {
+				if strings.HasSuffix(data.Receiver, suffix) {
+					inWhiteList = true
+					break
+				}
+			}
+			if !inWhiteList {
+				resp.ERROR(c, "邮箱后缀不在白名单中")
+				return
+			}
+		}
 		err = h.smtp.SendVerifyCode(data.Receiver, code)
 	} else {
 		if !utils.Contains(h.App.SysConfig.RegisterWays, "mobile") {
--- a/api/handler/suno_handler.go
+++ b/api/handler/suno_handler.go
@@ -86,6 +86,17 @@ func (h *SunoHandler) Create(c *gin.Context) {
 		return
 	}

+	user, err := h.GetLoginUser(c)
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+
+	if user.Power < h.App.SysConfig.SunoPower {
+		resp.ERROR(c, "您的算力不足，请充值后再试！")
+		return
+	}
+
 	// 歌曲拼接
 	if data.SongId != "" && data.Type == 3 {
 		var song model.SunoJob
@@ -143,7 +154,7 @@ func (h *SunoHandler) Create(c *gin.Context) {
 	})

 	// update user's power
-	err := h.userService.DecreasePower(job.UserId, job.Power, model.PowerLog{
+	err = h.userService.DecreasePower(job.UserId, job.Power, model.PowerLog{
 		Type:      types.PowerConsume,
 		Remark:    fmt.Sprintf("Suno 文生歌曲，%s", job.ModelName),
 		CreatedAt: time.Now(),
@@ -225,6 +236,13 @@ func (h *SunoHandler) Remove(c *gin.Context) {
 		resp.ERROR(c, err.Error())
 		return
 	}
+
+	// 只有失败，或者超时的任务才能删除
+	if job.Progress != service.FailTaskProgress || time.Now().Before(job.CreatedAt.Add(time.Minute*10)) {
+		resp.ERROR(c, "只有失败和超时(10分钟)的任务才能删除！")
+		return
+	}
+
 	// 删除任务
 	tx := h.DB.Begin()
 	if err := tx.Delete(&job).Error; err != nil {
@@ -233,18 +251,16 @@ func (h *SunoHandler) Remove(c *gin.Context) {
 		return
 	}

-	// 如果任务未完成，或者任务失败，则恢复用户算力
-	if job.Progress != 100 {
-		err := h.userService.IncreasePower(job.UserId, job.Power, model.PowerLog{
-			Type:   types.PowerRefund,
-			Model:  job.ModelName,
-			Remark: fmt.Sprintf("Suno 任务失败，退回算力。任务ID：%s，Err:%s", job.TaskId, job.ErrMsg),
-		})
-		if err != nil {
-			tx.Rollback()
-			resp.ERROR(c, err.Error())
-			return
-		}
+	// 恢复用户算力
+	err = h.userService.IncreasePower(job.UserId, job.Power, model.PowerLog{
+		Type:   types.PowerRefund,
+		Model:  job.ModelName,
+		Remark: fmt.Sprintf("Suno 任务失败，退回算力。任务ID：%s，Err:%s", job.TaskId, job.ErrMsg),
+	})
+	if err != nil {
+		tx.Rollback()
+		resp.ERROR(c, err.Error())
+		return
 	}
 	tx.Commit()

--- a/api/handler/test_handler.go
+++ b/api/handler/test_handler.go
@@ -11,10 +11,10 @@ import (
 type TestHandler struct {
 	db        *gorm.DB
 	snowflake *service.Snowflake
-	js        *payment.JPayService
+	js        *payment.GeekPayService
 }

-func NewTestHandler(db *gorm.DB, snowflake *service.Snowflake, js *payment.JPayService) *TestHandler {
+func NewTestHandler(db *gorm.DB, snowflake *service.Snowflake, js *payment.GeekPayService) *TestHandler {
 	return &TestHandler{db: db, snowflake: snowflake, js: js}
 }

--- a/api/handler/user_handler.go
+++ b/api/handler/user_handler.go
@@ -74,6 +74,20 @@ func (h *UserHandler) Register(c *gin.Context) {
 		resp.ERROR(c, types.InvalidArgs)
 		return
 	}
+
+	if h.App.SysConfig.EnabledVerify && data.RegWay == "username" {
+		var check bool
+		if data.X != 0 {
+			check = h.captcha.SlideCheck(data)
+		} else {
+			check = h.captcha.Check(data)
+		}
+		if !check {
+			resp.ERROR(c, "请先完人机验证")
+			return
+		}
+	}
+
 	data.Password = strings.TrimSpace(data.Password)
 	if len(data.Password) < 8 {
 		resp.ERROR(c, "密码长度不能少于8个字符")
@@ -230,8 +244,10 @@ 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 {
+	if h.App.SysConfig.EnabledVerify && needVerify {
 		var check bool
 		if data.X != 0 {
 			check = h.captcha.SlideCheck(data)
@@ -247,12 +263,14 @@ 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
 	}
@@ -285,11 +303,13 @@ func (h *UserHandler) Login(c *gin.Context) {
 		return
 	}
 	// 保存到 redis
-	key := fmt.Sprintf("users/%d", user.Id)
-	if _, err := h.redis.Set(c, key, tokenString, 0).Result(); err != nil {
+	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})
 }

@@ -587,7 +607,7 @@ func (h *UserHandler) ResetPass(c *gin.Context) {
 		session = session.Where("email", data.Email)
 		key = CodeStorePrefix + data.Email
 	} else if data.Type == "mobile" {
-		session = session.Where("mobile", data.Email)
+		session = session.Where("mobile", data.Mobile)
 		key = CodeStorePrefix + data.Mobile
 	} else {
 		resp.ERROR(c, "验证类别错误")
--- a/api/handler/video_handler.go
+++ b/api/handler/video_handler.go
@@ -22,6 +22,7 @@ import (
 	"github.com/gorilla/websocket"
 	"gorm.io/gorm"
 	"net/http"
+	"time"
 )

 type VideoHandler struct {
@@ -77,6 +78,18 @@ func (h *VideoHandler) LumaCreate(c *gin.Context) {
 		resp.ERROR(c, types.InvalidArgs)
 		return
 	}
+
+	user, err := h.GetLoginUser(c)
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+
+	if user.Power < h.App.SysConfig.LumaPower {
+		resp.ERROR(c, "您的算力不足，请充值后再试！")
+		return
+	}
+
 	if data.Prompt == "" {
 		resp.ERROR(c, "prompt is needed")
 		return
@@ -113,7 +126,7 @@ func (h *VideoHandler) LumaCreate(c *gin.Context) {
 	})

 	// update user's power
-	err := h.userService.DecreasePower(job.UserId, job.Power, model.PowerLog{
+	err = h.userService.DecreasePower(job.UserId, job.Power, model.PowerLog{
 		Type:   types.PowerConsume,
 		Model:  "luma",
 		Remark: fmt.Sprintf("Luma 文生视频，任务ID：%d", job.Id),
@@ -184,6 +197,12 @@ func (h *VideoHandler) Remove(c *gin.Context) {
 		resp.ERROR(c, err.Error())
 		return
 	}
+	// 只有失败或者超时的任务才能删除
+	if job.Progress != service.FailTaskProgress || time.Now().Before(job.CreatedAt.Add(time.Minute*30)) {
+		resp.ERROR(c, "只有失败和超时(30分钟)的任务才能删除！")
+		return
+	}
+
 	// 删除任务
 	tx := h.DB.Begin()
 	if err := tx.Delete(&job).Error; err != nil {
@@ -192,18 +211,16 @@ func (h *VideoHandler) Remove(c *gin.Context) {
 		return
 	}

-	// 如果任务未完成，或者任务失败，则恢复用户算力
-	if job.Progress != 100 {
-		err = h.userService.IncreasePower(job.UserId, job.Power, model.PowerLog{
-			Type:   types.PowerRefund,
-			Model:  "luma",
-			Remark: fmt.Sprintf("Luma 任务失败，退回算力。任务ID：%s，Err:%s", job.TaskId, job.ErrMsg),
-		})
-		if err != nil {
-			tx.Rollback()
-			resp.ERROR(c, err.Error())
-			return
-		}
+	// 恢复算力
+	err = h.userService.IncreasePower(job.UserId, job.Power, model.PowerLog{
+		Type:   types.PowerRefund,
+		Model:  "luma",
+		Remark: fmt.Sprintf("Luma 任务失败，退回算力。任务ID：%s，Err:%s", job.TaskId, job.ErrMsg),
+	})
+	if err != nil {
+		tx.Rollback()
+		resp.ERROR(c, err.Error())
+		return
 	}
 	tx.Commit()

--- a/api/main.go
+++ b/api/main.go
@@ -146,7 +146,7 @@ func main() {
 		fx.Provide(admin.NewAdminHandler),
 		fx.Provide(admin.NewApiKeyHandler),
 		fx.Provide(admin.NewUserHandler),
-		fx.Provide(admin.NewChatRoleHandler),
+		fx.Provide(admin.NewChatAppHandler),
 		fx.Provide(admin.NewRedeemHandler),
 		fx.Provide(admin.NewDashboardHandler),
 		fx.Provide(admin.NewChatModelHandler),
@@ -226,8 +226,9 @@ func main() {

 		// 注册路由
 		fx.Invoke(func(s *core.AppServer, h *handler.ChatRoleHandler) {
-			group := s.Engine.Group("/api/role/")
+			group := s.Engine.Group("/api/app/")
 			group.GET("list", h.List)
+			group.GET("list/user", h.ListByUser)
 			group.POST("update", h.UpdateRole)
 		}),
 		fx.Invoke(func(s *core.AppServer, h *handler.UserHandler) {
@@ -306,11 +307,12 @@ func main() {

 		// 管理后台控制器
 		fx.Invoke(func(s *core.AppServer, h *admin.ConfigHandler) {
-			group := s.Engine.Group("/api/admin/")
-			group.POST("config/update", h.Update)
-			group.GET("config/get", h.Get)
+			group := s.Engine.Group("/api/admin/config")
+			group.POST("update", h.Update)
+			group.GET("get", h.Get)
 			group.POST("active", h.Active)
-			group.GET("config/get/license", h.GetLicense)
+			group.GET("fixData", h.FixData)
+			group.GET("license", h.GetLicense)
 		}),
 		fx.Invoke(func(s *core.AppServer, h *admin.ManagerHandler) {
 			group := s.Engine.Group("/api/admin/")
@@ -338,7 +340,7 @@ func main() {
 			group.GET("loginLog", h.LoginLog)
 			group.POST("resetPass", h.ResetPass)
 		}),
-		fx.Invoke(func(s *core.AppServer, h *admin.ChatRoleHandler) {
+		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)
@@ -371,14 +373,12 @@ func main() {
 		}),
 		fx.Invoke(func(s *core.AppServer, h *handler.PaymentHandler) {
 			group := s.Engine.Group("/api/payment/")
-			group.GET("doPay", h.DoPay)
+			group.POST("doPay", h.Pay)
 			group.GET("payWays", h.GetPayWays)
-			group.POST("qrcode", h.PayQrcode)
-			group.POST("mobile", h.Mobile)
-			group.POST("alipay/notify", h.AlipayNotify)
-			group.POST("hupipay/notify", h.HuPiPayNotify)
-			group.POST("payjs/notify", h.PayJsNotify)
-			group.POST("wechat/notify", h.WechatPayNotify)
+			group.POST("notify/alipay", h.AlipayNotify)
+			group.GET("notify/geek", h.GeekPayNotify)
+			group.POST("notify/wechat", h.WechatPayNotify)
+			group.POST("notify/hupi", h.HuPiPayNotify)
 		}),
 		fx.Invoke(func(s *core.AppServer, h *admin.ProductHandler) {
 			group := s.Engine.Group("/api/admin/product/")
@@ -502,6 +502,20 @@ func main() {
 			group.GET("remove", h.Remove)
 			group.GET("publish", h.Publish)
 		}),
+		fx.Provide(admin.NewChatAppTypeHandler),
+		fx.Invoke(func(s *core.AppServer, h *admin.ChatAppTypeHandler) {
+			group := s.Engine.Group("/api/admin/app/type")
+			group.POST("save", h.Save)
+			group.GET("list", h.List)
+			group.GET("remove", h.Remove)
+			group.POST("enable", h.Enable)
+			group.POST("sort", h.Sort)
+		}),
+		fx.Provide(handler.NewChatAppTypeHandler),
+		fx.Invoke(func(s *core.AppServer, h *handler.ChatAppTypeHandler) {
+			group := s.Engine.Group("/api/app/type")
+			group.GET("list", h.List)
+		}),
 		fx.Provide(handler.NewTestHandler),
 		fx.Invoke(func(s *core.AppServer, h *handler.TestHandler) {
 			group := s.Engine.Group("/api/test")
@@ -511,7 +525,8 @@ func main() {
 			go func() {
 				err := s.Run(db)
 				if err != nil {
-					log.Fatal(err)
+					logger.Error(err)
+					os.Exit(0)
 				}
 			}()
 		}),
--- a/api/res/img/geek-pay.jpg
+++ b/api/res/img/geek-pay.jpg
--- a/api/res/img/qq-pay.jpg
+++ b/api/res/img/qq-pay.jpg
--- a/api/service/payment/alipay_service.go
+++ b/api/service/payment/alipay_service.go
@@ -44,9 +44,7 @@ func NewAlipayService(appConfig *types.AppConfig) (*AlipayService, error) {
 	//client.DebugSwitch = gopay.DebugOn // 开启调试模式
 	client.SetLocation(alipay.LocationShanghai). // 设置时区，不设置或出错均为默认服务器时间
 		SetCharset(alipay.UTF8). // 设置字符编码，不设置默认 utf-8
-		SetSignType(alipay.RSA2). // 设置签名类型，不设置默认 RSA2
-		SetReturnUrl(config.ReturnURL). // 设置返回URL
-		SetNotifyUrl(config.NotifyURL)
+		SetSignType(alipay.RSA2) // 设置签名类型，不设置默认 RSA2

 	if err = client.SetCertSnByPath(config.PublicKey, config.RootCert, config.AlipayPublicKey); err != nil {
 		return nil, fmt.Errorf("error with load payment public key: %v", err)
@@ -55,23 +53,33 @@ func NewAlipayService(appConfig *types.AppConfig) (*AlipayService, error) {
 	return &AlipayService{config: &config, client: client}, nil
 }

-func (s *AlipayService) PayUrlMobile(outTradeNo string, amount string, subject string) (string, error) {
+type AlipayParams struct {
+	OutTradeNo string `json:"out_trade_no"`
+	Subject    string `json:"subject"`
+	TotalFee   string `json:"total_fee"`
+	ReturnURL  string `json:"return_url"`
+	NotifyURL  string `json:"notify_url"`
+}
+
+func (s *AlipayService) PayMobile(params AlipayParams) (string, error) {
 	bm := make(gopay.BodyMap)
-	bm.Set("subject", subject)
-	bm.Set("out_trade_no", outTradeNo)
-	bm.Set("quit_url", s.config.ReturnURL)
-	bm.Set("total_amount", amount)
+	bm.Set("subject", params.Subject)
+	bm.Set("out_trade_no", params.OutTradeNo)
+	bm.Set("quit_url", params.ReturnURL)
+	bm.Set("total_amount", params.TotalFee)
+	bm.Set("return_url", params.ReturnURL)
+	bm.Set("notify_url", params.NotifyURL)
 	bm.Set("product_code", "QUICK_WAP_WAY")
 	return s.client.TradeWapPay(context.Background(), bm)
 }

-func (s *AlipayService) PayUrlPc(outTradeNo string, amount string, subject string) (string, error) {
+func (s *AlipayService) PayPC(params AlipayParams) (string, error) {
 	bm := make(gopay.BodyMap)
-	bm.Set("subject", subject)
-	bm.Set("out_trade_no", outTradeNo)
-	bm.Set("total_amount", amount)
+	bm.Set("subject", params.Subject)
+	bm.Set("out_trade_no", params.OutTradeNo)
+	bm.Set("total_amount", params.TotalFee)
 	bm.Set("product_code", "FAST_INSTANT_TRADE_PAY")
-	return s.client.TradePagePay(context.Background(), bm)
+	return s.client.SetNotifyUrl(params.NotifyURL).SetReturnUrl(params.ReturnURL).TradePagePay(context.Background(), bm)
 }

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

-type HuPiPayReq struct {
+type HuPiPayParams struct {
 	AppId        string `json:"appid"`
 	Version      string `json:"version"`
 	TradeOrderId string `json:"trade_order_id"`
@@ -53,7 +53,7 @@ type HuPiPayReq struct {
 	WapUrl       string `json:"wap_url"`
 }

-type HuPiResp struct {
+type HuPiPayResp struct {
 	Openid    interface{} `json:"openid"`
 	UrlQrcode string      `json:"url_qrcode"`
 	URL       string      `json:"url"`
@@ -62,7 +62,7 @@ type HuPiResp struct {
 }

 // Pay 执行支付请求操作
-func (s *HuPiPayService) Pay(params HuPiPayReq) (HuPiResp, error) {
+func (s *HuPiPayService) Pay(params HuPiPayParams) (HuPiPayResp, error) {
 	data := url.Values{}
 	simple := strconv.FormatInt(time.Now().Unix(), 10)
 	params.AppId = s.appId
@@ -80,22 +80,22 @@ func (s *HuPiPayService) Pay(params HuPiPayReq) (HuPiResp, error) {
 	apiURL := fmt.Sprintf("%s/payment/do.html", s.apiURL)
 	resp, err := http.PostForm(apiURL, data)
 	if err != nil {
-		return HuPiResp{}, fmt.Errorf("error with requst api: %v", err)
+		return HuPiPayResp{}, fmt.Errorf("error with requst api: %v", err)
 	}
 	defer resp.Body.Close()
 	all, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return HuPiResp{}, fmt.Errorf("error with reading response: %v", err)
+		return HuPiPayResp{}, fmt.Errorf("error with reading response: %v", err)
 	}

-	var res HuPiResp
+	var res HuPiPayResp
 	err = utils.JsonDecode(string(all), &res)
 	if err != nil {
-		return HuPiResp{}, fmt.Errorf("error with decode payment result: %v", err)
+		return HuPiPayResp{}, fmt.Errorf("error with decode payment result: %v", err)
 	}

 	if res.ErrCode != 0 {
-		return HuPiResp{}, fmt.Errorf("error with generate pay url: %s", res.ErrMsg)
+		return HuPiPayResp{}, fmt.Errorf("error with generate pay url: %s", res.ErrMsg)
 	}

 	return res, nil
@@ -127,10 +127,10 @@ func (s *HuPiPayService) Sign(params url.Values) string {
 }

 // Check 校验订单状态
-func (s *HuPiPayService) Check(tradeNo string) error {
+func (s *HuPiPayService) Check(outTradeNo string) error {
 	data := url.Values{}
 	data.Add("appid", s.appId)
-	data.Add("open_order_id", tradeNo)
+	data.Add("out_trade_order", outTradeNo)
 	stamp := strconv.FormatInt(time.Now().Unix(), 10)
 	data.Add("time", stamp)
 	data.Add("nonce_str", stamp)
--- a/api/service/payment/payjs_service.go
+++ b/api/service/payment/payjs_service.go
@@ -1,153 +0,0 @@
-package payment
-
-// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-// * Copyright 2023 The Geek-AI Authors. All rights reserved.
-// * Use of this source code is governed by a Apache-2.0 license
-// * that can be found in the LICENSE file.
-// * @Author yangjian102621@163.com
-// * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-import (
-	"crypto/md5"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"geekai/core/types"
-	"geekai/utils"
-	"io"
-	"net/http"
-	"net/url"
-	"sort"
-	"strings"
-)
-
-type JPayService struct {
-	config *types.JPayConfig
-}
-
-func NewJPayService(appConfig *types.AppConfig) *JPayService {
-	return &JPayService{
-		config: &appConfig.JPayConfig,
-	}
-}
-
-type JPayReq struct {
-	TotalFee   int    `json:"total_fee"`
-	OutTradeNo string `json:"out_trade_no"`
-	Subject    string `json:"body"`
-	NotifyURL  string `json:"notify_url"`
-	ReturnURL  string `json:"callback_url"`
-}
-type JPayReps struct {
-	OutTradeNo string `json:"out_trade_no"`
-	OrderId    string `json:"payjs_order_id"`
-	ReturnCode int    `json:"return_code"`
-	ReturnMsg  string `json:"return_msg"`
-	Sign       string `json:"Sign"`
-	TotalFee   string `json:"total_fee"`
-	CodeUrl    string `json:"code_url,omitempty"`
-	Qrcode     string `json:"qrcode,omitempty"`
-}
-
-func (r JPayReps) IsOK() bool {
-	return r.ReturnMsg == "SUCCESS"
-}
-
-func (js *JPayService) Pay(param JPayReq) JPayReps {
-	param.NotifyURL = js.config.NotifyURL
-	var p = url.Values{}
-	encode := utils.JsonEncode(param)
-	m := make(map[string]interface{})
-	_ = utils.JsonDecode(encode, &m)
-	for k, v := range m {
-		p.Add(k, fmt.Sprintf("%v", v))
-	}
-	p.Add("mchid", js.config.AppId)
-
-	p.Add("sign", js.sign(p))
-
-	cli := http.Client{}
-	apiURL := fmt.Sprintf("%s/api/native", js.config.ApiURL)
-	r, err := cli.PostForm(apiURL, p)
-	if err != nil {
-		return JPayReps{ReturnMsg: err.Error()}
-	}
-	defer r.Body.Close()
-	bs, err := io.ReadAll(r.Body)
-	if err != nil {
-		return JPayReps{ReturnMsg: err.Error()}
-	}
-
-	var data JPayReps
-	err = utils.JsonDecode(string(bs), &data)
-	if err != nil {
-		return JPayReps{ReturnMsg: err.Error()}
-	}
-	return data
-}
-
-func (js *JPayService) PayH5(p url.Values) string {
-	p.Add("mchid", js.config.AppId)
-	p.Add("sign", js.sign(p))
-	return fmt.Sprintf("%s/api/cashier?%s", js.config.ApiURL, p.Encode())
-}
-
-func (js *JPayService) sign(params url.Values) string {
-	params.Del(`sign`)
-	var keys = make([]string, 0, 0)
-	for key := range params {
-		if params.Get(key) != `` {
-			keys = append(keys, key)
-		}
-	}
-	sort.Strings(keys)
-
-	var pList = make([]string, 0, 0)
-	for _, key := range keys {
-		var value = strings.TrimSpace(params.Get(key))
-		if len(value) > 0 {
-			pList = append(pList, key+"="+value)
-		}
-	}
-	var src = strings.Join(pList, "&")
-	src += "&key=" + js.config.PrivateKey
-
-	md5bs := md5.Sum([]byte(src))
-	md5res := hex.EncodeToString(md5bs[:])
-	return strings.ToUpper(md5res)
-}
-
-// TradeVerify 查询订单支付状态
-// @param tradeNo 支付平台交易 ID
-func (js *JPayService) TradeVerify(tradeNo string) error {
-	apiURL := fmt.Sprintf("%s/api/check", js.config.ApiURL)
-	params := url.Values{}
-	params.Add("payjs_order_id", tradeNo)
-	params.Add("sign", js.sign(params))
-	data := strings.NewReader(params.Encode())
-	resp, err := http.Post(apiURL, "application/x-www-form-urlencoded", data)
-	if err != nil {
-		return fmt.Errorf("error with http reqeust: %v", err)
-	}
-	defer resp.Body.Close()
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return fmt.Errorf("error with reading response: %v", err)
-	}
-
-	var r struct {
-		ReturnCode int `json:"return_code"`
-		Status     int `json:"status"`
-	}
-	err = utils.JsonDecode(string(body), &r)
-	if err != nil {
-		return fmt.Errorf("error with decode response: %v", err)
-	}
-
-	if r.ReturnCode == 1 && r.Status == 1 {
-		return nil
-	} else {
-		logger.Errorf("PayJs 支付验证响应：%s", string(body))
-		return errors.New("order not paid")
-	}
-}
--- a/api/service/payment/wepay_service.go
+++ b/api/service/payment/wepay_service.go
@@ -46,18 +46,27 @@ func NewWechatService(appConfig *types.AppConfig) (*WechatPayService, error) {
 	return &WechatPayService{config: &config, client: client}, nil
 }

-func (s *WechatPayService) PayUrlNative(outTradeNo string, amount int, subject string) (string, error) {
+type WechatPayParams struct {
+	OutTradeNo string `json:"out_trade_no"`
+	TotalFee   int    `json:"total_fee"`
+	Subject    string `json:"subject"`
+	ClientIP   string `json:"client_ip"`
+	ReturnURL  string `json:"return_url"`
+	NotifyURL  string `json:"notify_url"`
+}
+
+func (s *WechatPayService) PayUrlNative(params WechatPayParams) (string, error) {
 	expire := time.Now().Add(10 * time.Minute).Format(time.RFC3339)
 	// 初始化 BodyMap
 	bm := make(gopay.BodyMap)
 	bm.Set("appid", s.config.AppId).
 		Set("mchid", s.config.MchId).
-		Set("description", subject).
-		Set("out_trade_no", outTradeNo).
+		Set("description", params.Subject).
+		Set("out_trade_no", params.OutTradeNo).
 		Set("time_expire", expire).
-		Set("notify_url", s.config.NotifyURL).
+		Set("notify_url", params.NotifyURL).
 		SetBodyMap("amount", func(bm gopay.BodyMap) {
-			bm.Set("total", amount).
+			bm.Set("total", params.TotalFee).
 				Set("currency", "CNY")
 		})

@@ -71,22 +80,22 @@ func (s *WechatPayService) PayUrlNative(outTradeNo string, amount int, subject s
 	return wxRsp.Response.CodeUrl, nil
 }

-func (s *WechatPayService) PayUrlH5(outTradeNo string, amount int, subject string, ip string) (string, error) {
+func (s *WechatPayService) PayUrlH5(params WechatPayParams) (string, error) {
 	expire := time.Now().Add(10 * time.Minute).Format(time.RFC3339)
 	// 初始化 BodyMap
 	bm := make(gopay.BodyMap)
 	bm.Set("appid", s.config.AppId).
 		Set("mchid", s.config.MchId).
-		Set("description", subject).
-		Set("out_trade_no", outTradeNo).
+		Set("description", params.Subject).
+		Set("out_trade_no", params.OutTradeNo).
 		Set("time_expire", expire).
-		Set("notify_url", s.config.NotifyURL).
+		Set("notify_url", params.NotifyURL).
 		SetBodyMap("amount", func(bm gopay.BodyMap) {
-			bm.Set("total", amount).
+			bm.Set("total", params.TotalFee).
 				Set("currency", "CNY")
 		}).
 		SetBodyMap("scene_info", func(bm gopay.BodyMap) {
-			bm.Set("payer_client_ip", ip).
+			bm.Set("payer_client_ip", params.ClientIP).
 				SetBodyMap("h5_info", func(bm gopay.BodyMap) {
 					bm.Set("type", "Wap")
 				})
--- a/api/service/smtp_sms_service.go
+++ b/api/service/smtp_sms_service.go
@@ -29,7 +29,7 @@ func NewSmtpService(appConfig *types.AppConfig) *SmtpService {

 func (s *SmtpService) SendVerifyCode(to string, code int) error {
 	subject := fmt.Sprintf("%s 注册验证码", s.config.AppName)
-	body := fmt.Sprintf("您正在注册 %s 账户，注册验证码为 %d，请不要告诉他人。如非本人操作，请忽略此邮件。", s.config.AppName, code)
+	body := fmt.Sprintf("【%s】：您的验证码为 %d，请不要告诉他人。如非本人操作，请忽略此邮件。", s.config.AppName, code)

 	auth := smtp.PlainAuth("", s.config.From, s.config.Password, s.config.Host)
 	if s.config.UseTls {
--- a/api/service/video/luma.go
+++ b/api/service/video/luma.go
@@ -82,6 +82,17 @@ func (s *Service) Run() {
 				logger.Errorf("taking task with error: %v", err)
 				continue
 			}
+
+			// translate prompt
+			if utils.HasChinese(task.Prompt) {
+				content, err := utils.OpenAIRequest(s.db, fmt.Sprintf(service.TranslatePromptTemplate, task.Prompt), "gpt-4o-mini")
+				if err == nil {
+					task.Prompt = content
+				} else {
+					logger.Warnf("error with translate prompt: %v", err)
+				}
+			}
+
 			var r LumaRespVo
 			r, err = s.LumaCreate(task)
 			if err != nil {
--- a/api/store/model/app_type.go
+++ b/api/store/model/app_type.go
@@ -0,0 +1,12 @@
+package model
+
+import "time"
+
+type AppType struct {
+	Id        uint `gorm:"primarykey"`
+	Name      string
+	Icon      string
+	Enabled   bool
+	SortNum   int
+	CreatedAt time.Time
+}
--- a/api/store/model/chat_history.go
+++ b/api/store/model/chat_history.go
@@ -4,16 +4,17 @@ import "gorm.io/gorm"

 type ChatMessage struct {
 	BaseModel
-	ChatId     string // 会话 ID
-	UserId     uint   // 用户 ID
-	RoleId     uint   // 角色 ID
-	Model      string // AI模型
-	Type       string
-	Icon       string
-	Tokens     int
-	Content    string
-	UseContext bool // 是否可以作为聊天上下文
-	DeletedAt  gorm.DeletedAt
+	ChatId      string // 会话 ID
+	UserId      uint   // 用户 ID
+	RoleId      uint   // 角色 ID
+	Model       string // AI模型
+	Type        string
+	Icon        string
+	Tokens      int
+	TotalTokens int // 总 token 消耗
+	Content     string
+	UseContext  bool // 是否可以作为聊天上下文
+	DeletedAt   gorm.DeletedAt
 }

 func (ChatMessage) TableName() string {
--- a/api/store/model/chat_role.go
+++ b/api/store/model/chat_role.go
@@ -2,6 +2,7 @@ package model

 type ChatRole struct {
 	BaseModel
+	Tid      int
 	Key      string `gorm:"column:marker;unique"` // 角色唯一标识
 	Name     string // 角色名称
 	Context  string `gorm:"column:context_json"` // 角色语料信息 json
--- a/api/store/model/order.go
+++ b/api/store/model/order.go
@@ -2,7 +2,6 @@ package model

 import (
 	"geekai/core/types"
-	"gorm.io/gorm"
 )

 // Order 充值订单
@@ -18,6 +17,6 @@ type Order struct {
 	Status    types.OrderStatus
 	Remark    string
 	PayTime   int64
-	PayWay    string // 支付方式
-	DeletedAt gorm.DeletedAt
+	PayWay    string // 支付渠道
+	PayType   string // 支付类型
 }
--- a/api/store/vo/app_type.go
+++ b/api/store/vo/app_type.go
@@ -0,0 +1,10 @@
+package vo
+
+type AppType struct {
+	Id        uint   `json:"id"`
+	Name      string `json:"name"`
+	Icon      string `json:"icon"`
+	SortNum   int    `json:"sort_num"`
+	Enabled   bool   `json:"enabled"`
+	CreatedAt int64  `json:"created_at"`
+}
--- a/api/store/vo/chat_role.go
+++ b/api/store/vo/chat_role.go
@@ -4,7 +4,8 @@ import "geekai/core/types"

 type ChatRole struct {
 	BaseVo
-	Key       string          `json:"key"`        // 角色唯一标识
+	Key       string          `json:"key"` // 角色唯一标识
+	Tid       int             `json:"tid"`
 	Name      string          `json:"name"`       // 角色名称
 	Context   []types.Message `json:"context"`    // 角色语料信息
 	HelloMsg  string          `json:"hello_msg"`  // 打招呼的消息
@@ -13,4 +14,5 @@ type ChatRole struct {
 	SortNum   int             `json:"sort"`       // 排序
 	ModelId   int             `json:"model_id"`   // 绑定模型 ID
 	ModelName string          `json:"model_name"` // 模型名称
+	TypeName  string          `json:"type_name"`  // 分类名称
 }
--- a/api/store/vo/order.go
+++ b/api/store/vo/order.go
@@ -16,5 +16,8 @@ type Order struct {
 	Status    types.OrderStatus `json:"status"`
 	PayTime   int64             `json:"pay_time"`
 	PayWay    string            `json:"pay_way"`
+	PayType   string            `json:"pay_type"`
+	PayMethod string            `json:"pay_method"`
+	PayName   string            `json:"pay_name"`
 	Remark    types.OrderRemark `json:"remark"`
 }
--- a/api/utils/net.go
+++ b/api/utils/net.go
@@ -9,6 +9,7 @@ package utils

 import (
 	"encoding/json"
+	"fmt"
 	"geekai/core/types"
 	logger2 "geekai/logger"
 	"io"
@@ -33,9 +34,17 @@ func ReplyChunkMessage(client *types.WsClient, message interface{}) {

 // ReplyMessage 回复客户端一条完整的消息
 func ReplyMessage(ws *types.WsClient, message interface{}) {
-	ReplyChunkMessage(ws, types.WsMessage{Type: types.WsStart})
-	ReplyChunkMessage(ws, types.WsMessage{Type: types.WsMiddle, Content: message})
-	ReplyChunkMessage(ws, types.WsMessage{Type: types.WsEnd})
+	ReplyChunkMessage(ws, types.ReplyMessage{Type: types.WsContent, Content: message})
+	ReplyChunkMessage(ws, types.ReplyMessage{Type: types.WsEnd})
+}
+
+func ReplyContent(ws *types.WsClient, message interface{}) {
+	ReplyChunkMessage(ws, types.ReplyMessage{Type: types.WsContent, Content: message})
+}
+
+// ReplyErrorMessage 向客户端发送错误消息
+func ReplyErrorMessage(ws *types.WsClient, message interface{}) {
+	ReplyChunkMessage(ws, types.ReplyMessage{Type: types.WsErr, Content: message})
 }

 func DownloadImage(imageURL string, proxy string) ([]byte, error) {
@@ -68,3 +77,11 @@ func DownloadImage(imageURL string, proxy string) ([]byte, error) {

 	return imageBytes, nil
 }
+
+func GetBaseURL(strURL string) string {
+	u, err := url.Parse(strURL)
+	if err != nil {
+		return ""
+	}
+	return fmt.Sprintf("%s://%s", u.Scheme, u.Host)
+}
--- a/api/utils/strings.go
+++ b/api/utils/strings.go
@@ -12,6 +12,7 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
+	"regexp"
 	"strings"
 	"time"
 	"unicode"
@@ -134,3 +135,17 @@ func GenRedeemCode(codeLength int) (string, error) {
 	}
 	return hex.EncodeToString(bytes), nil
 }
+
+// IsValidEmail 检查给定的字符串是否是有效的电子邮件地址
+func IsValidEmail(email string) bool {
+	// 这个正则表达式匹配大多数常见的邮箱格式
+	emailRegex := regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
+	return emailRegex.MatchString(email)
+}
+
+// IsValidMobile 检查给定的字符串是否是有效的中国大陆手机号
+func IsValidMobile(phone string) bool {
+	// 支持 13x, 14x, 15x, 16x, 17x, 18x, 19x 开头的号码
+	phoneRegex := regexp.MustCompile(`^1[3-9]\d{9}$`)
+	return phoneRegex.MatchString(phone)
+}