saw-go/handler/im.go

package handler

import (
	"StuAcaWorksAI/dao"
	"StuAcaWorksAI/proto"
	"StuAcaWorksAI/service"
	"StuAcaWorksAI/service/generalModel"
	"StuAcaWorksAI/worker"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/google/uuid"
	"github.com/gorilla/websocket"
	"log"
	"net/http"
	"strconv"
	"sync"
	"time"
)

type SMessage struct {
	Type      int    `json:"type" form:"type"`
	Msg       string `json:"msg" form:"msg"`
	ToID      int    `json:"to_id" form:"to_id"`
	SessionID int    `json:"session_id" form:"session_id"`
}

var (
	upgrader = websocket.Upgrader{
		ReadBufferSize:  1024,
		WriteBufferSize: 1024,
		CheckOrigin: func(r *http.Request) bool {
			// 允许所有来源的连接
			return true
		},
	}
)

// 创建一个用于存储WebSocket连接的map和互斥锁
var (
	clients    = make(map[*websocket.Conn]bool)
	clientsMux sync.Mutex
)

func SetUpIMGroup(router *gin.Engine) {
	imGroup := router.Group("/im")
	imGroup.POST("/send_message", SendMessage)
	imGroup.GET("/ai_chat_ws", SRMessage)
	imGroup.POST("/get_message", GetMessage)
	imGroup.GET("/kbase_text_ws", KBaseTextWS)

	//添加国外ai处理接口，服务之间调用
	imGroup.POST("/send_message_foreign_ai", SendMessageForeignAI)
	imGroup.POST("/receive_message_foreign_ai", ReceiveMessageForeignAI)
}

func GetMessage(c *gin.Context) {
	var req SMessage
	id, _ := c.Get("id")
	userID := int(id.(float64))
	if err := c.ShouldBind(&req); err == nil {
		err2, messages := service.FindMessageBySessionID(req.SessionID, userID)
		if err2 == nil {
			c.JSON(http.StatusOK, gin.H{"code": proto.SuccessCode, "message": "success", "data": messages})
		} else {
			c.JSON(http.StatusOK, gin.H{"error": err2.Error(), "code": proto.MsgSendFailed, "message": "failed"})
		}
	} else {
		c.JSON(http.StatusOK, gin.H{"error": err.Error(), "code": proto.ParameterError, "message": "failed"})
	}
}

func SendMessage(c *gin.Context) {
	var req SMessage
	id, _ := c.Get("id")
	userID := int(id.(float64))
	if err := c.ShouldBind(&req); err == nil {
		var err2 error
		var mid uint
		err2, mid = service.CreateGeneralMessageService(userID, req.ToID, req.Type, req.SessionID, req.Msg)
		if err2 == nil {
			c.JSON(http.StatusOK, gin.H{"code": proto.SuccessCode, "message": "success", "data": mid})
		} else {
			c.JSON(http.StatusOK, gin.H{"error": err2.Error(), "code": proto.MsgSendFailed, "message": "failed"})
		}
	} else {
		c.JSON(http.StatusOK, gin.H{"error": err.Error(), "code": proto.ParameterError, "message": "failed"})
	}
}

// ws长连接
func SRMessage(c *gin.Context) {
	id, _ := c.Get("id")
	userID := int(id.(float64))
	// 升级HTTP连接为WebSocket连接
	ws, err1 := upgrader.Upgrade(c.Writer, c.Request, nil)
	clients[ws] = true
	if err1 != nil {
		log.Println("升级为WebSocket时发生错误:", err1)
		return
	}
	subscribeAndHandleIMMessages(ws, userID)
}

func subscribeAndHandleIMMessages(ws *websocket.Conn, userId int) {
	ctx := context.Background()
	//随机字符串
	strRandom := uuid.NewString()
	chanel := "user_" + strconv.Itoa(userId) + "_ai_chat_msg_" + strRandom
	pubsub := worker.RedisClient.Subscribe(ctx, chanel)
	defer pubsub.Close()
	defer ws.Close()
	ch := pubsub.Channel()
	//定时器，每3秒发送一次心跳
	//ticker := time.NewTicker(3 * time.Second)
	//defer ticker.Stop()

	var sessionID uint
	sessionID = 0

	//接收客户端消息,发送消息
	done := make(chan struct{})
	go func() {
		defer close(done)
		for {
			_, message, err := ws.ReadMessage()
			log.Println("rec message:", string(message))
			if err != nil {
				log.Println("Read error:", err)
				break
			}
			var data proto.WSMessageReq
			err1 := json.Unmarshal(message, &data)
			if err1 != nil {
				log.Println("Error parsing JSON:", err1)
			}
			err = doReceiveGenChatMessage(userId, &sessionID, &data, chanel)
			if err != nil {
				log.Println("do receive gen chat message error:", err)
				//返回错误消息
				errMsg := proto.WSMessage{Code: proto.OperationFailed, ErrorMsg: "服务器处理错误", SessionID: int(sessionID)}
				errMsgStr, _ := json.Marshal(errMsg)
				worker.Publish(chanel, string(errMsgStr), time.Second*60)
				return
			}
		}
	}()

	go func() {
		//defer close(done)
		//从redis订阅消息
		for m := range ch {
			msg := m.Payload // 获取消息,消息格式为json
			if msg != "" {
				err2 := ws.WriteMessage(websocket.TextMessage, []byte(msg))
				if err2 != nil {
					// 发生错误，删除连接
					clientsMux.Lock()
					delete(clients, ws)
					clientsMux.Unlock()
					break
				}
			}
		}
		//查看done是否关闭
	}()

	//发送心跳包
	for {
		select {
		case <-done:
			//结束会话将context保存
			ctx2, ok := service.SessionContextMap[int(sessionID)]
			if !ok {
				log.Println("session context not found")
				return
			}
			err := service.UpdateSessionByID(int(sessionID), userId, "", ctx2)
			if err != nil {
				log.Println("update session context error:", err)
			}
			//保存的会话
			delete(service.SessionContextMap, int(sessionID))
			//客户端断开连接
			return
			//case t := <-ticker.C:
			//	//发送心跳
			//	err := ws.WriteMessage(websocket.PingMessage, nil)
			//	if err != nil {
			//		log.Println("Ping error:", err, t)
			//		return
			//	}
			//}
		}
	}

}

func doReceiveGenChatMessage(userId int, sessionID *uint, data *proto.WSMessageReq, chanel string) error {
	var model dao.Model
	//查看请求功能类型
	//models, funcs := service.FindFuncModelByFunction(data.Function, userId)
	models, funcs, mferr := service.FindFuncModelListByFunctionV2(data.Function)
	if mferr != nil {
		return mferr
	}

	//log.Println("find function model by function:", models, funcs)
	//log.Println("funcs:", len(funcs), "\tmodels:", len(models))
	if len(funcs) == 0 {
		return errors.New("function not exist")
	}
	if len(models) == 0 {
		//log.Println("doReceiveGenChatMessage models:", models)
		return errors.New("model not exist")
	}
	var err error
	sessionName := ""
	if data.IsImage || data.IsFile {
		var fileMsg proto.UserFileMessage
		err = json.Unmarshal([]byte(data.Msg), &fileMsg)
		if err != nil {
			log.Println("Error parsing JSON:", err)
		}
		sessionName = fileMsg.Text
	} else {
		sessionName = data.Msg
	}

	//前端传入的sessionID为0，则新会话
	*sessionID = uint(data.SessionID)
	if *sessionID == 0 {
		//创建会话
		if sessionName == "" {
			sessionName = "新会话"
		}
		sessionType := proto.SessionTypeUserWithModelGeneration //默认通用聊天
		if data.Function == "gen-prompt" {
			sessionType = proto.SessionTypeUserPrompt //提示词会话
		}
		err, *sessionID = service.CreateSession(userId, sessionType, sessionName)
		if err != nil {
			log.Println("Create session error:", err)
		}
		log.Println("create session id:", *sessionID)
		//会话名称过长，使用ai进行总结
		if len(sessionName) > 30 && data.Function == "gen-chat" { //只有在通用聊天时才进行ai总结
			//通过ai总结会话名称
			go func() {
				sessionErr := service.UpdateSessionNameByAIAndID(int(*sessionID), userId, sessionName)
				if sessionErr != nil {
					log.Println("update ai session name error:", sessionErr)
					return
				} //更新会话名称
			}()
		}

	}
	//获取模型
	for _, v := range models {
		if v.ID == data.ModelID {
			model = v
			break
		}
	}
	if model.ID == 0 {
		//说明前端传入的模型id不正确，取第一个模型
		model = models[0]
	}

	//解析模型参数
	var modelParam proto.ModelParam
	err = json.Unmarshal([]byte(model.Parameter), &modelParam)
	if err != nil {
		return err
	}
	modelParam.Url = model.Url
	modelParam.System = funcs[0].Info //系统功能
	//设置模型temperature及其他参数
	checkAndSetModelTemperatureParam(&modelParam, data, &model)
	imContext := proto.IMParamContext{UserID: userId, SessionID: int(*sessionID), FunctionID: int(funcs[0].ID), ModelID: int(model.ID), Question: data.Msg, Channel: chanel, ModelType: model.Type}

	var userMsgID uint
	status := proto.MsgHasRead
	if data.IsImage || data.IsFile {
		status = proto.UserToModelImageMsgType //图片类型
	}
	//将消息存入数据库
	err, userMsgID = service.CreateMessage(proto.UserToModelMsgType, int(*sessionID), userId, int(model.ID), data.Msg, status, int(funcs[0].ID))
	log.Println("create user message id:", userMsgID)
	if err != nil {
		return err
	} //机器人id为2,消息类型为1,状态为1
	imContext.QuestionMessageID = int(userMsgID)

	//若为知识库消息，需要先根据用户消息获取知识库查询内容让ai进行最终结果生成
	if data.IsKBase {
		//根据会话ID获取对应知识库消息
		kbaseMsg, err2 := service.FindKnowledgeBaseBySessionID(*sessionID, uint(userId))
		if err2 != nil {
			log.Println("find knowledge base by session id error:", err2)
			service.WSReturnErrorMessage(imContext.Channel, "find knowledge base error:"+err2.Error(), proto.WSKBaseSessionError)
			return err2
		}
		data.KBaseID = kbaseMsg.ID
		err2 = service.SelectKBaseContentByQuery(&imContext, data)
		if err2 != nil {
			log.Println("select kbase content error:", err2)
			service.WSReturnErrorMessage(imContext.Channel, "select kbase error:"+err2.Error(), proto.WSKBaseServerError)
			return err2
		}
		if data.KBaseType == "query" {
			//若为查询直接返回
			return nil
		}
	}
	//需要后续处理
	//err, _ = service.WSReceiveMessageService(userId, int(*sessionID), chanel, *data, model, modelParam)
	err, _ = service.WSReceiveMessageServiceV2(modelParam, &imContext)
	return err
}

func KBaseTextWS(c *gin.Context) {
	id, _ := c.Get("id")
	userID := int(id.(float64))
	//query参数
	kBaseSercerID := c.Query("kbase_server_id")
	if kBaseSercerID == "" {
		c.JSON(http.StatusOK, gin.H{"code": proto.ParameterError, "message": "kbase_server_id不能为空"})
		return
	}
	// 升级HTTP连接为WebSocket连接
	ws, err1 := upgrader.Upgrade(c.Writer, c.Request, nil)
	if err1 != nil {
		log.Println("升级为WebSocket时发生错误:", err1)
		return
	}
	subscribeAndHandleKBaseTextMessages(ws, userID, kBaseSercerID)
}

func subscribeAndHandleKBaseTextMessages(ws *websocket.Conn, userId int, kBaseServerID string) {
	ctx := context.Background()
	chanel := fmt.Sprintf("kbase_server_id_%s", kBaseServerID) // 频道名称
	//设置KBaseServerID可用状态，加入可用集合
	setKey := "kbase_server_id_set_is_available"
	worker.SetRedisSetAdd(setKey, kBaseServerID)
	pubsub := worker.RedisClient.Subscribe(ctx, chanel)
	defer func() {
		//设置KBaseServerID不可用状态，删除可用集合
		worker.SetRedisSetRemove(setKey, kBaseServerID)
		pubsub.Close()
		ws.Close()
	}()

	ch := pubsub.Channel()

	//接收客户端消息,发送消息
	done := make(chan struct{})
	go func() {
		defer close(done)
		for {
			_, message, err := ws.ReadMessage()
			var data proto.KnowledgeBaseServerResponse
			//log.Println("rec message:", string(message))
			if err != nil {
				log.Println("Read error:", err)
				break
			}
			err1 := json.Unmarshal(message, &data)
			if err1 != nil {
				log.Println("Error parsing JSON:", err1)
				continue
			}
			service.CreateAIStreamMsg(userId, data.IMContext.ModelID, data.IMContext.SessionID, data, proto.KnowledgeBaseServerResponseType) //将消息存入数据库
			//这里主要将接收到的消息转到对应协程
			//目标chanel
			targetChanel := fmt.Sprintf("kbase_%s", data.KnowledgeBase.UUID)
			//将消息转入
			err = worker.RedisClient.Publish(ctx, targetChanel, message).Err()
			if err != nil {
				log.Println("KBase Text WS Publish error:", err)
			}
		}
	}()

	go func() {
		//defer close(done)
		//从redis订阅消息
		for m := range ch {
			msg := m.Payload // 获取消息,消息格式为json
			if msg != "" {
				err2 := ws.WriteMessage(websocket.TextMessage, []byte(msg))
				if err2 != nil {
					break
				}
			}
		}
	}()

	for {
		select {
		case <-done:
			return
		}
	}
}

func checkAndSetModelTemperatureParam(modelParam *proto.ModelParam, data *proto.WSMessageReq, model *dao.Model) {
	isErrParam := false
	if data.Temperature < 0 || data.Temperature > 2 {
		isErrParam = true
	} else {
		modelParam.Temperature = data.Temperature
	}
	if model.Type == proto.ModelTypeDouBao {
		if data.TopP < 0 || data.TopP > 1 {
			isErrParam = true
		} else {
			modelParam.TopP = data.TopP
		}
	} else if model.Type == proto.ModelTypeSpark {
		if data.TopK < 0 || data.TopK > 1 {
			isErrParam = true
		} else {
			modelParam.TopK = data.TopK
		}
	} else {
		isErrParam = true
	}

	if isErrParam {
		modelParam.SetDefaultParams()
	}
}

func SendMessageForeignAI(c *gin.Context) {
	id, _ := c.Get("user_id")
	userID := id.(int)
	user := service.GetUserByIDWithCache(userID)
	var resp proto.GenerateResp
	var req proto.SendMessageForeignAIRRequest
	if user.Role == "admin" {
		//解析请求参数
		if err := c.ShouldBind(&req); err == nil {
			reqBytes, _ := json.Marshal(req)
			log.Println("SendMessageForeignAI req:", string(reqBytes))
			//校验参数
			if req.ModelParam.Model == "" || req.ModelParam.Url == "" || req.ModelParam.APIKey == "" {
				resp.Code = proto.ParameterError
				resp.Message = "模型必要参数不能为空"
			} else {
				//处理
				generalModel.OpenAIForeignAI(req.ModelParam, &req.IMParamContext, req.PlatForm, req.MessageContent)
				//返回结果
				resp.Code = proto.SuccessCode
				resp.Message = "success"
			}
		} else {
			resp.Code = proto.ParameterError
			resp.Message = "参数错误"
		}
	} else {
		resp.Code = proto.PermissionDenied
		resp.Message = "没有权限"
	}
	c.JSON(http.StatusOK, resp)
}

func ReceiveMessageForeignAI(c *gin.Context) {
	id, _ := c.Get("user_id")
	userID := id.(int)
	user := service.GetUserByIDWithCache(userID)
	var resp proto.GenerateResp
	var req proto.ReceiveMessageForeignAIRRequest
	if user.Role == "admin" {
		//解析请求参数
		if err := c.ShouldBind(&req); err == nil {
			//校验参数
			if req.IMParamContext.SessionID == 0 || req.ChatCompletionChunk.Choices == nil {
				resp.Code = proto.ParameterError
				resp.Message = "模型必要参数不能为空"
			} else {
				generalModel.OpenAIForeignAIResponseToGeneralMassageAndSendMsgQueue(&req)
				resp.Code = proto.SuccessCode
				resp.Message = "success"
			}
		} else {
			resp.Code = proto.ParameterError
			resp.Message = "参数错误"
		}

	} else {
		resp.Code = proto.PermissionDenied
		resp.Message = "没有权限"
	}
	c.JSON(http.StatusOK, resp)
}