merge code for v4.1.8

api/handler/admin/chat_model_handler.go

@@ -43,6 +43,7 @@ func (h *ChatModelHandler) Save(c *gin.Context) {
 		Temperature float32 `json:"temperature"` // 模型温度
 		KeyId       int     `json:"key_id,omitempty"`
 		CreatedAt   int64   `json:"created_at"`
+		Type        string  `json:"type"`
 	}
 	if err := c.ShouldBindJSON(&data); err != nil {
 		resp.ERROR(c, types.InvalidArgs)
@@ -65,7 +66,7 @@ func (h *ChatModelHandler) Save(c *gin.Context) {
 	item.MaxContext = data.MaxContext
 	item.Temperature = data.Temperature
 	item.KeyId = data.KeyId
-
+	item.Type = data.Type
 	var res *gorm.DB
 	if data.Id > 0 {
 		res = h.DB.Save(&item)

api/handler/chat_model_handler.go

@@ -30,7 +30,7 @@ func NewChatModelHandler(app *core.AppServer, db *gorm.DB) *ChatModelHandler {
 func (h *ChatModelHandler) List(c *gin.Context) {
 	var items []model.ChatModel
 	var chatModels = make([]vo.ChatModel, 0)
-	session := h.DB.Session(&gorm.Session{}).Where("enabled", true)
+	session := h.DB.Session(&gorm.Session{}).Where("type", "chat").Where("enabled", true)
 	t := c.Query("type")
 	if t != "" {
 		session = session.Where("type", t)

api/handler/chat_openai_handler.go

@@ -17,10 +17,11 @@ import (
 	"geekai/store/model"
 	"geekai/store/vo"
 	"geekai/utils"
-	req2 "github.com/imroc/req/v3"
 	"io"
 	"strings"
 	"time"
+
+	req2 "github.com/imroc/req/v3"
 )
 
 type Usage struct {
@@ -172,16 +173,22 @@ func (h *ChatHandler) sendOpenAiMessage(
 			var apiRes types.BizVo
 			r, err := req2.C().R().SetHeader("Body-Type", "application/json").
 				SetHeader("Authorization", function.Token).
-				SetBody(params).
-				SetSuccessResult(&apiRes).Post(function.Action)
+				SetBody(params).Post(function.Action)
 			errMsg := ""
 			if err != nil {
 				errMsg = err.Error()
-			} else if r.IsErrorState() {
-				errMsg = r.Status
+			} else {
+				all, _ := io.ReadAll(r.Body)
+				err = json.Unmarshal(all, &apiRes)
+				if err != nil {
+					errMsg = err.Error()
+				} else if apiRes.Code != types.Success {
+					errMsg = apiRes.Message
+				}
 			}
-			if errMsg != "" || apiRes.Code != types.Success {
-				errMsg = "调用函数工具出错：" + apiRes.Message + errMsg
+
+			if errMsg != "" {
+				errMsg = "调用函数工具出错：" + errMsg
 				contents = append(contents, errMsg)
 			} else {
 				errMsg = utils.InterfaceToString(apiRes.Data)

api/handler/dalle_handler.go

@@ -8,6 +8,7 @@ package handler
 // * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 import (
+	"fmt"
 	"geekai/core"
 	"geekai/core/types"
 	"geekai/service"
@@ -17,14 +18,13 @@ import (
 	"geekai/store/vo"
 	"geekai/utils"
 	"geekai/utils/resp"
+
 	"github.com/gin-gonic/gin"
-	"github.com/go-redis/redis/v8"
 	"gorm.io/gorm"
 )
 
 type DallJobHandler struct {
 	BaseHandler
-	redis       *redis.Client
 	dallService *dalle.Service
 	uploader    *oss.UploaderManager
 	userService *service.UserService
@@ -42,49 +42,49 @@ func NewDallJobHandler(app *core.AppServer, db *gorm.DB, service *dalle.Service,
 	}
 }
 
-func (h *DallJobHandler) preCheck(c *gin.Context) bool {
-	user, err := h.GetLoginUser(c)
-	if err != nil {
-		resp.NotAuth(c)
-		return false
-	}
-	if user.Power < h.App.SysConfig.DallPower {
-		resp.ERROR(c, "当前用户剩余算力不足以完成本次绘画！")
-		return false
-	}
-
-	return true
-
-}
-
 // Image 创建一个绘画任务
 func (h *DallJobHandler) Image(c *gin.Context) {
-	if !h.preCheck(c) {
-		return
-	}
-
 	var data types.DallTask
 	if err := c.ShouldBindJSON(&data); err != nil || data.Prompt == "" {
 		resp.ERROR(c, types.InvalidArgs)
 		return
 	}
 
+	var chatModel model.ChatModel
+	if res := h.DB.Where("id = ?", data.ModelId).First(&chatModel); res.Error != nil {
+		resp.ERROR(c, "模型不存在")
+		return
+	}
+
+	// 检查用户剩余算力
+	user, err := h.GetLoginUser(c)
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+	if user.Power < chatModel.Power {
+		resp.ERROR(c, "当前用户剩余算力不足以完成本次绘画！")
+		return
+	}
+
 	idValue, _ := c.Get(types.LoginUserID)
 	userId := utils.IntValue(utils.InterfaceToString(idValue), 0)
 	task := types.DallTask{
 		ClientId:         data.ClientId,
 		UserId:           uint(userId),
+		ModelId:          chatModel.Id,
+		ModelName:        chatModel.Value,
 		Prompt:           data.Prompt,
 		Quality:          data.Quality,
 		Size:             data.Size,
 		Style:            data.Style,
-		Power:            h.App.SysConfig.DallPower,
 		TranslateModelId: h.App.SysConfig.TranslateModelId,
+		Power:            chatModel.Power,
 	}
 	job := model.DallJob{
 		UserId:   uint(userId),
 		Prompt:   data.Prompt,
-		Power:    task.Power,
+		Power:    chatModel.Power,
 		TaskInfo: utils.JsonEncode(task),
 	}
 	res := h.DB.Create(&job)
@@ -95,6 +95,17 @@ func (h *DallJobHandler) Image(c *gin.Context) {
 
 	task.Id = job.Id
 	h.dallService.PushTask(task)
+
+	// 扣减算力
+	err = h.userService.DecreasePower(int(user.Id), chatModel.Power, model.PowerLog{
+		Type:   types.PowerConsume,
+		Model:  chatModel.Value,
+		Remark: fmt.Sprintf("绘画提示词：%s", utils.CutWords(task.Prompt, 10)),
+	})
+	if err != nil {
+		resp.ERROR(c, "error with decrease power: "+err.Error())
+		return
+	}
 	resp.SUCCESS(c)
 }
 
@@ -210,3 +221,25 @@ func (h *DallJobHandler) Publish(c *gin.Context) {
 
 	resp.SUCCESS(c)
 }
+
+func (h *DallJobHandler) GetModels(c *gin.Context) {
+	var models []model.ChatModel
+	err := h.DB.Where("type", "img").Where("enabled", true).Find(&models).Error
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	var modelVos []vo.ChatModel
+	for _, v := range models {
+		var modelVo vo.ChatModel
+		err := utils.CopyObject(v, &modelVo)
+		if err != nil {
+			continue
+		}
+		modelVo.Id = v.Id
+		modelVos = append(modelVos, modelVo)
+	}
+
+	resp.SUCCESS(c, modelVos)
+}

api/handler/function_handler.go

@@ -12,6 +12,7 @@ import (
 	"fmt"
 	"geekai/core"
 	"geekai/core/types"
+	"geekai/service"
 	"geekai/service/dalle"
 	"geekai/service/oss"
 	"geekai/store/model"
@@ -32,6 +33,7 @@ type FunctionHandler struct {
 	config        types.ApiConfig
 	uploadManager *oss.UploaderManager
 	dallService   *dalle.Service
+	userService   *service.UserService
 }
 
 func NewFunctionHandler(
@@ -39,7 +41,8 @@ func NewFunctionHandler(
 	db *gorm.DB,
 	config *types.AppConfig,
 	manager *oss.UploaderManager,
-	dallService *dalle.Service) *FunctionHandler {
+	dallService *dalle.Service,
+	userService *service.UserService) *FunctionHandler {
 	return &FunctionHandler{
 		BaseHandler: BaseHandler{
 			App: server,
@@ -48,6 +51,7 @@ func NewFunctionHandler(
 		config:        config.ApiConfig,
 		uploadManager: manager,
 		dallService:   dallService,
+		userService:   userService,
 	}
 }
 
@@ -152,8 +156,12 @@ func (h *FunctionHandler) ZaoBao(c *gin.Context) {
 		SetHeader("AppId", h.config.AppId).
 		SetHeader("Authorization", fmt.Sprintf("Bearer %s", h.config.Token)).
 		SetSuccessResult(&res).Get(url)
-	if err != nil || r.IsErrorState() {
-		resp.ERROR(c, fmt.Sprintf("%v%v", err, r.Err))
+	if err != nil {
+		resp.ERROR(c, fmt.Sprintf("%v", err))
+		return
+	}
+	if r.IsErrorState() {
+		resp.ERROR(c, fmt.Sprintf("%v", r.Err))
 		return
 	}
 
@@ -167,7 +175,7 @@ func (h *FunctionHandler) ZaoBao(c *gin.Context) {
 	for _, v := range res.Data.Items {
 		builder = append(builder, v.Title)
 	}
-	builder = append(builder, fmt.Sprintf("%s", res.Data.Title))
+	builder = append(builder, res.Data.Title)
 	resp.SUCCESS(c, strings.Join(builder, "\n\n"))
 }
 
@@ -199,33 +207,48 @@ func (h *FunctionHandler) Dall3(c *gin.Context) {
 
 	// create dall task
 	prompt := utils.InterfaceToString(params["prompt"])
-	job := model.DallJob{
-		UserId: user.Id,
-		Prompt: prompt,
-		Power:  h.App.SysConfig.DallPower,
+	task := types.DallTask{
+		UserId:           user.Id,
+		Prompt:           prompt,
+		ModelId:          0,
+		ModelName:        "dall-e-3",
+		TranslateModelId: h.App.SysConfig.TranslateModelId,
+		N:                1,
+		Quality:          "standard",
+		Size:             "1024x1024",
+		Style:            "vivid",
+		Power:            h.App.SysConfig.DallPower,
 	}
-	res = h.DB.Create(&job)
-
-	if res.Error != nil {
-		resp.ERROR(c, "创建 DALL-E 绘图任务失败："+res.Error.Error())
+	job := model.DallJob{
+		UserId:   user.Id,
+		Prompt:   prompt,
+		Power:    h.App.SysConfig.DallPower,
+		TaskInfo: utils.JsonEncode(task),
+	}
+	err := h.DB.Create(&job).Error
+	if err != nil {
+		resp.ERROR(c, "创建 DALL-E 绘图任务失败："+err.Error())
 		return
 	}
 
-	content, err := h.dallService.Image(types.DallTask{
-		Id:      job.Id,
-		UserId:  user.Id,
-		Prompt:  job.Prompt,
-		N:       1,
-		Quality: "standard",
-		Size:    "1024x1024",
-		Style:   "vivid",
-		Power:   job.Power,
-	}, true)
+	task.Id = job.Id
+	content, err := h.dallService.Image(task, true)
 	if err != nil {
 		resp.ERROR(c, "任务执行失败："+err.Error())
 		return
 	}
 
+	// 扣减算力
+	err = h.userService.DecreasePower(int(user.Id), job.Power, model.PowerLog{
+		Type:   types.PowerConsume,
+		Model:  task.ModelName,
+		Remark: fmt.Sprintf("绘画提示词：%s", utils.CutWords(job.Prompt, 10)),
+	})
+	if err != nil {
+		resp.ERROR(c, "扣减算力失败："+err.Error())
+		return
+	}
+
 	resp.SUCCESS(c, content)
 }
 

api/handler/prompt_handler.go

@@ -12,13 +12,13 @@ import (
 	"geekai/core"
 	"geekai/core/types"
 	"geekai/service"
-	"geekai/service/oss"
-	"geekai/service/suno"
+	"geekai/store/model"
 	"geekai/utils"
 	"geekai/utils/resp"
+	"strings"
+
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
-	"strings"
 )
 
 // 提示词生成 handler
@@ -26,8 +26,6 @@ import (
 
 type PromptHandler struct {
 	BaseHandler
-	sunoService *suno.Service
-	uploader    *oss.UploaderManager
 	userService *service.UserService
 }
 
@@ -56,6 +54,15 @@ func (h *PromptHandler) Lyric(c *gin.Context) {
 		return
 	}
 
+	if h.App.SysConfig.PromptPower > 0 {
+		userId := h.GetLoginUserId(c)
+		h.userService.DecreasePower(int(userId), h.App.SysConfig.PromptPower, model.PowerLog{
+			Type:   types.PowerConsume,
+			Model:  h.getPromptModel(),
+			Remark: "生成歌词",
+		})
+	}
+
 	resp.SUCCESS(c, content)
 }
 
@@ -73,7 +80,14 @@ func (h *PromptHandler) Image(c *gin.Context) {
 		resp.ERROR(c, err.Error())
 		return
 	}
-
+	if h.App.SysConfig.PromptPower > 0 {
+		userId := h.GetLoginUserId(c)
+		h.userService.DecreasePower(int(userId), h.App.SysConfig.PromptPower, model.PowerLog{
+			Type:   types.PowerConsume,
+			Model:  h.getPromptModel(),
+			Remark: "生成绘画提示词",
+		})
+	}
 	resp.SUCCESS(c, strings.Trim(content, `"`))
 }
 
@@ -92,6 +106,15 @@ func (h *PromptHandler) Video(c *gin.Context) {
 		return
 	}
 
+	if h.App.SysConfig.PromptPower > 0 {
+		userId := h.GetLoginUserId(c)
+		h.userService.DecreasePower(int(userId), h.App.SysConfig.PromptPower, model.PowerLog{
+			Type:   types.PowerConsume,
+			Model:  h.getPromptModel(),
+			Remark: "生成视频脚本",
+		})
+	}
+
 	resp.SUCCESS(c, strings.Trim(content, `"`))
 }
 
@@ -121,3 +144,12 @@ func (h *PromptHandler) MetaPrompt(c *gin.Context) {
 
 	resp.SUCCESS(c, strings.Trim(content, `"`))
 }
+
+func (h *PromptHandler) getPromptModel() string {
+	if h.App.SysConfig.TranslateModelId > 0 {
+		var chatModel model.ChatModel
+		h.DB.Where("id", h.App.SysConfig.TranslateModelId).First(&chatModel)
+		return chatModel.Value
+	}
+	return "gpt-4o"
+}

api/handler/realtime_handler.go

@@ -1,15 +1,24 @@
 package handler
 
 import (
+	"encoding/json"
 	"fmt"
 	"geekai/core"
+	"geekai/core/types"
+	"geekai/service"
 	"geekai/store/model"
-	"github.com/gin-gonic/gin"
-	"github.com/gorilla/websocket"
-	"gorm.io/gorm"
+	"geekai/utils"
+	"geekai/utils/resp"
+	"io"
 	"net/http"
+	"regexp"
 	"strings"
 	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/gorilla/websocket"
+	"github.com/imroc/req/v3"
+	"gorm.io/gorm"
 )
 
 // * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@@ -23,10 +32,11 @@ import (
 
 type RealtimeHandler struct {
 	BaseHandler
+	userService *service.UserService
 }
 
-func NewRealtimeHandler(server *core.AppServer, db *gorm.DB) *RealtimeHandler {
-	return &RealtimeHandler{BaseHandler{App: server, DB: db}}
+func NewRealtimeHandler(server *core.AppServer, db *gorm.DB, userService *service.UserService) *RealtimeHandler {
+	return &RealtimeHandler{BaseHandler: BaseHandler{App: server, DB: db}, userService: userService}
 }
 
 func (h *RealtimeHandler) Connection(c *gin.Context) {
@@ -126,3 +136,74 @@ func sendError(ws *websocket.Conn, message string) {
 		logger.Error(err)
 	}
 }
+
+// OpenAI 实时语音对话，一次性对话
+func (h *RealtimeHandler) VoiceChat(c *gin.Context) {
+	var apiKey model.ApiKey
+	err := h.DB.Session(&gorm.Session{}).Where("type", "realtime").Where("enabled", true).First(&apiKey).Error
+	if err != nil {
+		resp.ERROR(c, fmt.Sprintf("error with fetch OpenAI API KEY：%v", err))
+		return
+	}
+
+	var response utils.OpenAIResponse
+	client := req.C()
+	if len(apiKey.ProxyURL) > 5 {
+		client.SetProxyURL(apiKey.ApiURL)
+	}
+	apiURL := fmt.Sprintf("%s/v1/chat/completions", apiKey.ApiURL)
+	logger.Infof("Sending %s request, API KEY:%s, PROXY: %s, Model: %s", apiKey.ApiURL, apiURL, apiKey.ProxyURL, "advanced-voice")
+	r, err := client.R().SetHeader("Body-Type", "application/json").
+		SetHeader("Authorization", "Bearer "+apiKey.Value).
+		SetBody(types.ApiRequest{
+			Model:       "advanced-voice",
+			Temperature: 0.9,
+			MaxTokens:   1024,
+			Stream:      false,
+			Messages: []interface{}{types.Message{
+				Role:    "user",
+				Content: "实时语音通话",
+			}},
+		}).Post(apiURL)
+	if err != nil {
+		resp.ERROR(c, fmt.Sprintf("请求 OpenAI API失败：%v", err))
+		return
+	}
+
+	if r.IsErrorState() {
+		resp.ERROR(c, fmt.Sprintf("请求 OpenAI API失败：%v", r.Status))
+		return
+	}
+
+	body, _ := io.ReadAll(r.Body)
+	err = json.Unmarshal(body, &response)
+	if err != nil {
+		resp.ERROR(c, fmt.Sprintf("解析API数据失败：%v, %s", err, string(body)))
+	}
+
+	// 更新 API KEY 的最后使用时间
+	h.DB.Model(&apiKey).UpdateColumn("last_used_at", time.Now().Unix())
+
+	// 扣减算力
+	userId := h.GetLoginUserId(c)
+	err = h.userService.DecreasePower(int(userId), h.App.SysConfig.AdvanceVoicePower, model.PowerLog{
+		Type:   types.PowerConsume,
+		Model:  "advanced-voice",
+		Remark: "实时语音通话",
+	})
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	logger.Infof("Response: %v", response.Choices[0].Message.Content)
+
+	// 提取链接
+	re := regexp.MustCompile(`\[(.*?)\]\((.*?)\)`)
+	links := re.FindAllStringSubmatch(response.Choices[0].Message.Content, -1)
+	var url = ""
+	if len(links) > 0 {
+		url = links[0][2]
+	}
+	resp.SUCCESS(c, url)
+}

api/handler/suno_handler.go

@@ -215,8 +215,8 @@ func (h *SunoHandler) Remove(c *gin.Context) {
 		return
 	}
 
-	// 只有失败，或者超时的任务才能删除
-	if job.Progress != service.FailTaskProgress || time.Now().Before(job.CreatedAt.Add(time.Minute*10)) {
+	// 只有失败或者已完成的任务可以删除
+	if !(job.Progress == service.FailTaskProgress || job.Progress == 100) {
 		resp.ERROR(c, "只有失败和超时(10分钟)的任务才能删除！")
 		return
 	}

api/handler/user_handler.go

@@ -184,7 +184,7 @@ func (h *UserHandler) Register(c *gin.Context) {
 		if h.App.SysConfig.InvitePower > 0 {
 			err := h.userService.IncreasePower(int(inviteCode.UserId), h.App.SysConfig.InvitePower, model.PowerLog{
 				Type:   types.PowerInvite,
-				Model:  "",
+				Model: "Invite",
 				Remark: fmt.Sprintf("邀请用户注册奖励，金额：%d，邀请码：%s，新用户：%s", h.App.SysConfig.InvitePower, inviteCode.Code, user.Username),
 			})
 			if err != nil {