refactor: V3 版本重构已基本完成

api/go/handler/admin_handler.go

@@ -0,0 +1,29 @@
+package handler
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type AdminHandler struct {
+	BaseHandler
+	db *gorm.DB
+}
+
+func NewAdminHandler(config *types.AppConfig, app *core.AppServer, db *gorm.DB) *AdminHandler {
+	handler := AdminHandler{db: db}
+	handler.app = app
+	handler.config = config
+	return &handler
+}
+
+// Login 登录
+func (h *AdminHandler) Login(c *gin.Context) {
+
+}
+
+// Logout 注销
+func (h *AdminHandler) Logout(c *gin.Context) {
+}

api/go/handler/api_key_handler.go

@@ -0,0 +1,76 @@
+package handler
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"chatplus/utils/param"
+	"chatplus/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"net/http"
+)
+
+type ApiKeyHandler struct {
+	BaseHandler
+	db *gorm.DB
+}
+
+func NewApiKeyHandler(config *types.AppConfig, app *core.AppServer, db *gorm.DB) *ApiKeyHandler {
+	handler := ApiKeyHandler{db: db}
+	handler.app = app
+	handler.config = config
+	return &handler
+}
+
+func (h *ApiKeyHandler) Add(c *gin.Context) {
+	var data struct {
+		Key string
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	// 获取当前登录用户
+	var userId uint = 0
+	user, err := utils.GetLoginUser(c, h.db)
+	if err == nil {
+		userId = user.Id
+	}
+	var key = model.ApiKey{Value: data.Key, UserId: userId}
+	res := h.db.Create(&key)
+	if res.Error != nil {
+		c.JSON(http.StatusOK, types.BizVo{Code: types.Failed, Message: "操作失败"})
+		return
+	}
+	resp.SUCCESS(c, key)
+}
+
+func (h *ApiKeyHandler) List(c *gin.Context) {
+	page := param.GetInt(c, "page", 1)
+	pageSize := param.GetInt(c, "page_size", 20)
+	offset := (page - 1) * pageSize
+	var items []model.ApiKey
+	var keys = make([]vo.ApiKey, 0)
+	var total int64
+	h.db.Model(&model.ApiKey{}).Count(&total)
+	res := h.db.Offset(offset).Limit(pageSize).Find(&items)
+	if res.Error == nil {
+		for _, item := range items {
+			var key vo.ApiKey
+			err := utils.CopyObject(item, &key)
+			if err == nil {
+				key.Id = item.Id
+				key.CreatedAt = item.CreatedAt.Unix()
+				key.UpdatedAt = item.UpdatedAt.Unix()
+				keys = append(keys, key)
+			} else {
+				logger.Error(err)
+			}
+		}
+	}
+	pageVo := vo.NewPage(total, page, pageSize, keys)
+	resp.SUCCESS(c, pageVo)
+}

api/go/handler/base_handler.go

@@ -0,0 +1,14 @@
+package handler
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	logger2 "chatplus/logger"
+)
+
+var logger = logger2.GetLogger()
+
+type BaseHandler struct {
+	app    *core.AppServer
+	config *types.AppConfig
+}

api/go/handler/chat_handler.go

@@ -0,0 +1,453 @@
+package handler
+
+import (
+	"bufio"
+	"bytes"
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"chatplus/utils/param"
+	"chatplus/utils/resp"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"github.com/gorilla/websocket"
+	"gorm.io/gorm"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+const ErrorMsg = "抱歉，AI 助手开小差了，请马上联系管理员去盘它。"
+
+type ChatHandler struct {
+	BaseHandler
+	db *gorm.DB
+}
+
+func NewChatHandler(config *types.AppConfig,
+	app *core.AppServer,
+	db *gorm.DB) *ChatHandler {
+	handler := ChatHandler{db: db}
+	handler.app = app
+	handler.config = config
+	return &handler
+}
+
+// ChatHandle 处理聊天 WebSocket 请求
+func (h *ChatHandler) ChatHandle(c *gin.Context) {
+	ws, err := (&websocket.Upgrader{CheckOrigin: func(r *http.Request) bool { return true }}).Upgrade(c.Writer, c.Request, nil)
+	if err != nil {
+		logger.Error(err)
+		return
+	}
+	sessionId := c.Query("sessionId")
+	roleId := param.GetInt(c, "roleId", 0)
+	chatId := c.Query("chatId")
+	chatModel := c.Query("model")
+	session, ok := h.app.ChatSession[sessionId]
+	if !ok {
+		logger.Info("用户未登录")
+		c.Abort()
+		return
+	}
+
+	// use old chat data override the chat model and role ID
+	var chat model.ChatItem
+	res := h.db.Where("chat_id=?", chatId).First(&chat)
+	if res.Error == nil {
+		chatModel = chat.Model
+		roleId = int(chat.RoleId)
+	}
+
+	session.ChatId = chatId
+	session.Model = chatModel
+	logger.Infof("New websocket connected, IP: %s, UserId: %s", c.Request.RemoteAddr, session.Username)
+	client := core.NewWsClient(ws)
+	var chatRole model.ChatRole
+	res = h.db.First(&chatRole, roleId)
+	if res.Error != nil || !chatRole.Enable {
+		replyMessage(client, "当前聊天角色不存在或者未启用！！！")
+		c.Abort()
+		return
+	}
+
+	// 保存会话连接
+	h.app.ChatClients[chatId] = client
+	go func() {
+		for {
+			_, message, err := client.Receive()
+			if err != nil {
+				logger.Error(err)
+				client.Close()
+				delete(h.app.ChatClients, chatId)
+				delete(h.app.ReqCancelFunc, chatId)
+				return
+			}
+			logger.Info("Receive a message: ", string(message))
+			//replyMessage(client, "这是一条测试消息！")
+			ctx, cancel := context.WithCancel(context.Background())
+			h.app.ReqCancelFunc[chatId] = cancel
+			// 回复消息
+			err = h.sendMessage(ctx, session, chatRole, string(message), client)
+			if err != nil {
+				logger.Error(err)
+			} else {
+				replyChunkMessage(client, types.WsMessage{Type: types.WsEnd})
+				logger.Info("回答完毕: " + string(message))
+			}
+
+		}
+	}()
+}
+
+// 将消息发送给 ChatGPT 并获取结果，通过 WebSocket 推送到客户端
+func (h *ChatHandler) sendMessage(ctx context.Context, session types.ChatSession, role model.ChatRole, prompt string, ws core.Client) error {
+	promptCreatedAt := time.Now() // 记录提问时间
+
+	var user model.User
+	res := h.db.Model(&model.User{}).First(&user, session.UserId)
+	if res.Error != nil {
+		replyMessage(ws, "非法用户，请联系管理员！")
+		return res.Error
+	}
+	var userVo vo.User
+	err := utils.CopyObject(user, &userVo)
+	userVo.Id = user.Id
+	if err != nil {
+		return errors.New("User 对象转换失败，" + err.Error())
+	}
+
+	if userVo.Status == false {
+		replyMessage(ws, "您的账号已经被禁用，如果疑问，请联系管理员！")
+		replyMessage(ws, "![](images/wx.png)")
+		return nil
+	}
+
+	if userVo.Calls <= 0 {
+		replyMessage(ws, "您的对话次数已经用尽，请联系管理员充值！")
+		replyMessage(ws, "![](images/wx.png)")
+		return nil
+	}
+
+	if userVo.ExpiredTime > 0 && userVo.ExpiredTime <= time.Now().Unix() {
+		replyMessage(ws, "您的账号已经过期，请联系管理员！")
+		replyMessage(ws, "![](images/wx.png)")
+		return nil
+	}
+	var req = types.ApiRequest{
+		Model:       session.Model,
+		Temperature: userVo.ChatConfig.Temperature,
+		MaxTokens:   userVo.ChatConfig.MaxTokens,
+		Stream:      true,
+	}
+
+	// 加载聊天上下文
+	var chatCtx []types.Message
+	if userVo.ChatConfig.EnableContext {
+		if v, ok := h.app.ChatContexts[session.ChatId]; ok {
+			chatCtx = v
+		} else {
+			// 加载角色信息
+			var messages []types.Message
+			err := utils.JsonDecode(role.Context, &messages)
+			if err == nil {
+				chatCtx = messages
+			}
+			// TODO: 这里默认加载最近 4 条聊天记录作为上下文，后期应该做成可配置的
+			var historyMessages []model.HistoryMessage
+			res := h.db.Where("chat_id = ?", session.ChatId).Limit(4).Order("created_at desc").Find(&historyMessages)
+			if res.Error == nil {
+				for _, msg := range historyMessages {
+					ms := types.Message{Role: "user", Content: msg.Content}
+					if msg.Type == types.REPLY_MSG {
+						ms.Role = "assistant"
+					}
+					chatCtx = append(chatCtx, ms)
+				}
+			}
+		}
+		logger.Info("聊天上下文：", chatCtx)
+	}
+	req.Messages = append(chatCtx, types.Message{
+		Role:    "user",
+		Content: prompt,
+	})
+	var apiKey string
+	response, err := h.doRequest(ctx, userVo, &apiKey, req)
+	if err != nil {
+		if strings.Contains(err.Error(), "context canceled") {
+			logger.Info("用户取消了请求：", prompt)
+			return nil
+		} else {
+			logger.Error(err)
+		}
+
+		replyMessage(ws, ErrorMsg)
+		replyMessage(ws, "![](images/wx.png)")
+		return err
+	} else {
+		defer response.Body.Close()
+	}
+
+	contentType := response.Header.Get("Content-Type")
+	if strings.Contains(contentType, "text/event-stream") {
+		replyCreatedAt := time.Now()
+		// 循环读取 Chunk 消息
+		var message = types.Message{}
+		var contents = make([]string, 0)
+		var responseBody = types.ApiResponse{}
+		reader := bufio.NewReader(response.Body)
+		for {
+			line, err := reader.ReadString('\n')
+			if err != nil {
+				if strings.Contains(err.Error(), "context canceled") {
+					logger.Info("用户取消了请求：", prompt)
+				} else {
+					logger.Error(err)
+				}
+				break
+			}
+			if !strings.Contains(line, "data:") {
+				continue
+			}
+
+			err = json.Unmarshal([]byte(line[6:]), &responseBody)
+			if err != nil { // 数据解析出错
+				logger.Error(err, line)
+				replyMessage(ws, ErrorMsg)
+				replyMessage(ws, "![](images/wx.png)")
+				break
+			}
+
+			// 初始化 role
+			if responseBody.Choices[0].Delta.Role != "" && message.Role == "" {
+				message.Role = responseBody.Choices[0].Delta.Role
+				replyChunkMessage(ws, types.WsMessage{Type: types.WsStart})
+				continue
+			} else if responseBody.Choices[0].FinishReason != "" {
+				break // 输出完成或者输出中断了
+			} else {
+				content := responseBody.Choices[0].Delta.Content
+				contents = append(contents, content)
+				replyChunkMessage(ws, types.WsMessage{
+					Type:    types.WsMiddle,
+					Content: responseBody.Choices[0].Delta.Content,
+				})
+			}
+		} // end for
+
+		// 消息发送成功
+		if len(contents) > 0 {
+			// 更新用户的对话次数
+			res := h.db.Model(&user).UpdateColumn("calls", gorm.Expr("calls - ?", 1))
+			if res.Error != nil {
+				return res.Error
+			}
+
+			if message.Role == "" {
+				message.Role = "assistant"
+			}
+			message.Content = strings.Join(contents, "")
+			useMsg := types.Message{Role: "user", Content: prompt}
+
+			// 更新上下文消息
+			if userVo.ChatConfig.EnableContext {
+				chatCtx = append(chatCtx, useMsg)  // 提问消息
+				chatCtx = append(chatCtx, message) // 回复消息
+				h.app.ChatContexts[session.ChatId] = chatCtx
+			}
+
+			// 追加聊天记录
+			if userVo.ChatConfig.EnableHistory {
+				// for prompt
+				token, err := utils.CalcTokens(prompt, req.Model)
+				if err != nil {
+					logger.Error(err)
+				}
+				historyUserMsg := model.HistoryMessage{
+					UserId:  userVo.Id,
+					ChatId:  session.ChatId,
+					RoleId:  role.Id,
+					Type:    types.PROMPT_MSG,
+					Icon:    user.Avatar,
+					Content: prompt,
+					Tokens:  token,
+				}
+				historyUserMsg.CreatedAt = promptCreatedAt
+				historyUserMsg.UpdatedAt = promptCreatedAt
+				res := h.db.Save(&historyUserMsg)
+				if res.Error != nil {
+					logger.Error("failed to save prompt history message: ", res.Error)
+				}
+
+				// for reply
+				token, err = utils.CalcTokens(message.Content, req.Model)
+				if err != nil {
+					logger.Error(err)
+				}
+				historyReplyMsg := model.HistoryMessage{
+					UserId:  userVo.Id,
+					ChatId:  session.ChatId,
+					RoleId:  role.Id,
+					Type:    types.REPLY_MSG,
+					Icon:    role.Icon,
+					Content: message.Content,
+					Tokens:  token,
+				}
+				historyReplyMsg.CreatedAt = replyCreatedAt
+				historyReplyMsg.UpdatedAt = replyCreatedAt
+				res = h.db.Create(&historyReplyMsg)
+				if res.Error != nil {
+					logger.Error("failed to save reply history message: ", res.Error)
+				}
+			}
+
+			// 保存当前会话
+			var chatItem model.ChatItem
+			res = h.db.Where("chat_id = ?", session.ChatId).First(&chatItem)
+			if res.Error != nil {
+				chatItem.ChatId = session.ChatId
+				chatItem.UserId = session.UserId
+				chatItem.RoleId = role.Id
+				chatItem.Model = session.Model
+				if utf8.RuneCountInString(prompt) > 30 {
+					chatItem.Title = string([]rune(prompt)[:30]) + "..."
+				} else {
+					chatItem.Title = prompt
+				}
+				h.db.Create(&chatItem)
+			}
+		}
+	} else {
+		body, err := io.ReadAll(response.Body)
+		if err != nil {
+			return fmt.Errorf("error with reading response: %v", err)
+		}
+		var res types.ApiError
+		err = json.Unmarshal(body, &res)
+		if err != nil {
+			return fmt.Errorf("error with decode response: %v", err)
+		}
+
+		// OpenAI API 调用异常处理
+		// TODO: 是否考虑重发消息？
+		if strings.Contains(res.Error.Message, "This key is associated with a deactivated account") {
+			replyMessage(ws, "请求 OpenAI API 失败：API KEY 所关联的账户被禁用。")
+			// 移除当前 API key
+			h.db.Where("value = ?", apiKey).Delete(&model.ApiKey{})
+		} else if strings.Contains(res.Error.Message, "You exceeded your current quota") {
+			replyMessage(ws, "请求 OpenAI API 失败：API KEY 触发并发限制，请稍后再试。")
+		} else if strings.Contains(res.Error.Message, "This model's maximum context length") {
+			replyMessage(ws, "当前会话上下文长度超出限制，已为您删减会话上下文！")
+			// 只保留最近的三条记录
+			chatContext := h.app.ChatContexts[session.ChatId]
+			chatContext = chatContext[len(chatContext)-3:]
+			h.app.ChatContexts[session.ChatId] = chatContext
+			return h.sendMessage(ctx, session, role, prompt, ws)
+		} else {
+			replyMessage(ws, "请求 OpenAI API 失败："+res.Error.Message)
+		}
+	}
+
+	return nil
+}
+
+// 发送请求到 OpenAI 服务器
+// useOwnApiKey: 是否使用了用户自己的 API KEY
+func (h *ChatHandler) doRequest(ctx context.Context, user vo.User, apiKey *string, req types.ApiRequest) (*http.Response, error) {
+	var client *http.Client
+	requestBody, err := json.Marshal(req)
+	if err != nil {
+		return nil, err
+	}
+	// 创建 HttpClient 请求对象
+	request, err := http.NewRequest(http.MethodPost, h.app.ChatConfig.ApiURL, bytes.NewBuffer(requestBody))
+	if err != nil {
+		return nil, err
+	}
+
+	request = request.WithContext(ctx)
+	request.Header.Add("Content-Type", "application/json")
+
+	proxyURL := h.config.ProxyURL
+	if proxyURL == "" {
+		client = &http.Client{}
+	} else { // 使用代理
+		uri := url.URL{}
+		proxy, _ := uri.Parse(proxyURL)
+		client = &http.Client{
+			Transport: &http.Transport{
+				Proxy: http.ProxyURL(proxy),
+			},
+		}
+	}
+	// 查询当前用户是否导入了自己的 API KEY
+	if user.ChatConfig.ApiKey != "" {
+		logger.Info("使用用户自己的 API KEY: ", user.ChatConfig.ApiKey)
+		*apiKey = user.ChatConfig.ApiKey
+	} else { // 获取系统的 API KEY
+		var key model.ApiKey
+		res := h.db.Where("user_id = ?", 0).Order("last_used_at ASC").First(&key)
+		if res.Error != nil {
+			return nil, errors.New("no available key, please import key")
+		}
+		*apiKey = key.Value
+		// 更新 API KEY 的最后使用时间
+		h.db.Model(&key).UpdateColumn("last_used_at", time.Now().Unix())
+	}
+
+	logger.Infof("Sending OpenAI request, KEY: %s, PROXY: %s, Model: %s", *apiKey, proxyURL, req.Model)
+	request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", *apiKey))
+	return client.Do(request)
+}
+
+// 回复客户片段端消息
+func replyChunkMessage(client core.Client, message types.WsMessage) {
+	msg, err := json.Marshal(message)
+	if err != nil {
+		logger.Errorf("Error for decoding json data: %v", err.Error())
+		return
+	}
+	err = client.(*core.WsClient).Send(msg)
+	if err != nil {
+		logger.Errorf("Error for reply message: %v", err.Error())
+	}
+}
+
+// 回复客户端一条完整的消息
+func replyMessage(ws core.Client, message string) {
+	replyChunkMessage(ws, types.WsMessage{Type: types.WsStart})
+	replyChunkMessage(ws, types.WsMessage{Type: types.WsMiddle, Content: message})
+	replyChunkMessage(ws, types.WsMessage{Type: types.WsEnd})
+}
+
+// Tokens 统计 token 数量
+func (h *ChatHandler) Tokens(c *gin.Context) {
+	text := c.Query("text")
+	md := c.Query("model")
+	tokens, err := utils.CalcTokens(text, md)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, tokens)
+}
+
+// StopGenerate 停止生成
+func (h *ChatHandler) StopGenerate(c *gin.Context) {
+	chatId := c.Query("chat_id")
+	if cancel, ok := h.app.ReqCancelFunc[chatId]; ok {
+		cancel()
+		delete(h.app.ReqCancelFunc, chatId)
+	}
+	resp.SUCCESS(c, types.OkMsg)
+}

api/go/handler/chat_history_handler.go

@@ -0,0 +1,157 @@
+package handler
+
+import (
+	"chatplus/core/types"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"chatplus/utils/param"
+	"chatplus/utils/resp"
+	"github.com/gin-gonic/gin"
+)
+
+// List 获取会话列表
+func (h *ChatHandler) List(c *gin.Context) {
+	userId := param.GetInt(c, "user_id", 0)
+	if userId == 0 {
+		resp.ERROR(c, "The parameter 'user_id' is needed.")
+		return
+	}
+	var items = make([]vo.ChatItem, 0)
+	var chats []model.ChatItem
+	res := h.db.Where("user_id = ?", userId).Order("id DESC").Find(&chats)
+	if res.Error == nil {
+		var roleIds = make([]uint, 0)
+		for _, chat := range chats {
+			roleIds = append(roleIds, chat.RoleId)
+		}
+		var roles []model.ChatRole
+		res = h.db.Find(&roles, roleIds)
+		if res.Error == nil {
+			roleMap := make(map[uint]model.ChatRole)
+			for _, role := range roles {
+				roleMap[role.Id] = role
+			}
+
+			for _, chat := range chats {
+				var item vo.ChatItem
+				err := utils.CopyObject(chat, &item)
+				if err == nil {
+					item.Id = chat.Id
+					item.Icon = roleMap[chat.RoleId].Icon
+					items = append(items, item)
+				}
+			}
+		}
+
+	}
+	resp.SUCCESS(c, items)
+}
+
+// Update 更新会话标题
+func (h *ChatHandler) Update(c *gin.Context) {
+	var data struct {
+		Id    uint   `json:"id"`
+		Title string `json:"title"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	var m = model.ChatItem{}
+	m.Id = data.Id
+	res := h.db.Model(&m).UpdateColumn("title", data.Title)
+	if res.Error != nil {
+		resp.ERROR(c, "Failed to update database")
+		return
+	}
+
+	resp.SUCCESS(c, types.OkMsg)
+}
+
+// Remove 删除会话
+func (h *ChatHandler) Remove(c *gin.Context) {
+	chatId := param.GetTrim(c, "chat_id")
+	if chatId == "" {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	user, err := utils.GetLoginUser(c, h.db)
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+
+	res := h.db.Where("user_id = ? AND chat_id = ?", user.Id, chatId).Delete(&model.ChatItem{})
+	if res.Error != nil {
+		resp.ERROR(c, "Failed to update database")
+		return
+	}
+
+	// 清空会话上下文
+	delete(h.app.ChatContexts, chatId)
+	resp.SUCCESS(c, types.OkMsg)
+}
+
+// History 获取聊天历史记录
+func (h *ChatHandler) History(c *gin.Context) {
+	chatId := c.Query("chat_id") // 会话 ID
+	user, err := utils.GetLoginUser(c, h.db)
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+	var items []model.HistoryMessage
+	var messages = make([]vo.HistoryMessage, 0)
+	res := h.db.Where("chat_id = ? AND user_id = ?", chatId, user.Id).Find(&items)
+	if res.Error != nil {
+		resp.ERROR(c, "No history message")
+		return
+	} else {
+		for _, item := range items {
+			var v vo.HistoryMessage
+			err := utils.CopyObject(item, &v)
+			v.CreatedAt = item.CreatedAt.Unix()
+			v.UpdatedAt = item.UpdatedAt.Unix()
+			if err == nil {
+				messages = append(messages, v)
+			}
+		}
+	}
+
+	resp.SUCCESS(c, messages)
+}
+
+// Clear 清空所有聊天记录
+func (h *ChatHandler) Clear(c *gin.Context) {
+	// 获取当前登录用户所有的聊天会话
+	user, err := utils.GetLoginUser(c, h.db)
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+
+	var chats []model.ChatItem
+	res := h.db.Where("user_id = ?", user.Id).Find(&chats)
+	if res.Error != nil {
+		resp.ERROR(c, "No chats found")
+		return
+	}
+	// 清空聊天记录
+	for _, chat := range chats {
+		err := h.db.Where("chat_id = ? AND user_id = ?", chat.ChatId, user.Id).Delete(&model.HistoryMessage{})
+		if err != nil {
+			logger.Warnf("Failed to delele chat history for ChatID: %s", chat.ChatId)
+		}
+		// 清空会话上下文
+		delete(h.app.ChatContexts, chat.ChatId)
+	}
+	// 删除所有的会话记录
+	res = h.db.Where("user_id = ?", user.Id).Delete(&model.ChatItem{})
+	if res.Error != nil {
+		resp.ERROR(c, "Failed to remove chat from database.")
+		return
+	}
+
+	resp.SUCCESS(c, types.OkMsg)
+}

api/go/handler/chat_role_handler.go

@@ -0,0 +1,92 @@
+package handler
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/service"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"github.com/gin-gonic/gin"
+	"strconv"
+)
+
+type ChatRoleHandler struct {
+	BaseHandler
+	service *service.ChatRoleService
+}
+
+func NewChatRoleHandler(config *types.AppConfig, app *core.AppServer, service *service.ChatRoleService) *ChatRoleHandler {
+	handler := &ChatRoleHandler{service: service}
+	handler.app = app
+	handler.config = config
+	return handler
+}
+
+// List get user list
+func (h *ChatRoleHandler) List(c *gin.Context) {
+	var roles []model.ChatRole
+	res := h.service.DB.Find(&roles)
+	if res.Error != nil {
+		resp.ERROR(c, "No roles found,"+res.Error.Error())
+		return
+	}
+	userId, err := strconv.Atoi(c.Query("user_id"))
+	if err == nil && userId > 0 {
+		var user model.User
+		h.service.DB.First(&user, userId)
+		var roleMap map[string]int
+		err := utils.JsonDecode(user.ChatRoles, &roleMap)
+		if err == nil {
+			for index, r := range roles {
+				if _, ok := roleMap[r.Key]; !ok {
+					roles = append(roles[:index], roles[index+1:]...)
+				}
+			}
+		}
+	}
+	// 转成 vo
+	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)
+}
+
+// Add 添加一个聊天角色
+func (h *ChatRoleHandler) Add(c *gin.Context) {
+	var data vo.ChatRole
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	if data.Key == "" || data.Name == "" || data.Icon == "" {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	err := h.service.Create(data)
+	if err != nil {
+		resp.ERROR(c, "Save failed: "+err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, data)
+}
+
+// Get 获取指定的角色
+func (h *ChatRoleHandler) Get(c *gin.Context) {
+
+}
+
+// Update 更新某个聊天角色信息，这里只允许更改名称以及启用和禁用角色操作
+func (h *ChatRoleHandler) Update(c *gin.Context) {
+
+}

api/go/handler/config_handler.go

@@ -0,0 +1,77 @@
+package handler
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/store/model"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+type ConfigHandler struct {
+	BaseHandler
+	db *gorm.DB
+}
+
+func NewConfigHandler(config *types.AppConfig, app *core.AppServer, db *gorm.DB) *ConfigHandler {
+	handler := ConfigHandler{db: db}
+	handler.app = app
+	handler.config = config
+	return &handler
+}
+
+func (h *ConfigHandler) Update(c *gin.Context) {
+	var data struct {
+		Key    string                 `json:"key"`
+		Config map[string]interface{} `json:"config"`
+	}
+
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	str := utils.JsonEncode(&data.Config)
+	config := model.Config{Key: data.Key, Config: str}
+	res := h.db.FirstOrCreate(&config, model.Config{Key: data.Key})
+	if res.Error != nil {
+		resp.ERROR(c, res.Error.Error())
+		return
+	}
+
+	if config.Id > 0 {
+		config.Config = str
+		res := h.db.Updates(&config)
+		if res.Error != nil {
+			resp.ERROR(c, res.Error.Error())
+			return
+		}
+	}
+
+	resp.SUCCESS(c, config)
+}
+
+func (h *ConfigHandler) Get(c *gin.Context) {
+	key := c.Query("key")
+	var config model.Config
+	res := h.db.Where("marker", key).First(&config)
+	if res.Error != nil {
+		resp.ERROR(c, res.Error.Error())
+		return
+	}
+
+	var m map[string]interface{}
+	err := utils.JsonDecode(config.Config, &m)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, m)
+}
+
+// AllGptModels 获取所有的 GPT 模型
+func (h *ConfigHandler) AllGptModels(c *gin.Context) {
+	resp.SUCCESS(c, types.GptModels)
+}

api/go/handler/user_handler.go

@@ -0,0 +1,308 @@
+package handler
+
+import (
+	"chatplus/core"
+	"chatplus/core/types"
+	"chatplus/store/model"
+	"chatplus/store/vo"
+	"chatplus/utils"
+	"chatplus/utils/resp"
+	"fmt"
+	"github.com/gin-contrib/sessions"
+	"github.com/gin-gonic/gin"
+	"github.com/lionsoul2014/ip2region/binding/golang/xdb"
+	"gorm.io/gorm"
+	"strings"
+	"time"
+)
+
+type UserHandler struct {
+	BaseHandler
+	db       *gorm.DB
+	searcher *xdb.Searcher
+}
+
+func NewUserHandler(config *types.AppConfig, app *core.AppServer, db *gorm.DB, searcher *xdb.Searcher) *UserHandler {
+	handler := &UserHandler{db: db, searcher: searcher}
+	handler.app = app
+	handler.config = config
+	return handler
+}
+
+// Register user register
+func (h *UserHandler) Register(c *gin.Context) {
+	// parameters process
+	var data struct {
+		Username string `json:"username"`
+		Password string `json:"password"`
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	data.Username = strings.TrimSpace(data.Username)
+	data.Password = strings.TrimSpace(data.Password)
+
+	if len(data.Username) < 5 {
+		resp.ERROR(c, "用户名长度不能少于5个字符")
+		return
+	}
+	if len(data.Password) < 8 {
+		resp.ERROR(c, "密码长度不能少于8个字符")
+		return
+	}
+
+	// check if the username is exists
+	var item model.User
+	tx := h.db.Where("username = ?", data.Username).First(&item)
+	if tx.RowsAffected > 0 {
+		resp.ERROR(c, "用户名已存在")
+		return
+	}
+	// 默认订阅所有角色
+	var chatRoles []model.ChatRole
+	h.db.Find(&chatRoles)
+	var roleMap = make(map[string]int)
+	for _, r := range chatRoles {
+		roleMap[r.Key] = 1
+	}
+
+	salt := utils.RandString(8)
+	user := model.User{
+		Username:  data.Username,
+		Password:  utils.GenPassword(data.Password, salt),
+		Nickname:  fmt.Sprintf("极客学长@%d", utils.RandomNumber(5)),
+		Avatar:    "images/avatar/user.png",
+		Salt:      salt,
+		Status:    true,
+		ChatRoles: utils.JsonEncode(roleMap),
+		ChatConfig: utils.JsonEncode(types.ChatConfig{
+			Temperature:   h.app.ChatConfig.Temperature,
+			MaxTokens:     h.app.ChatConfig.MaxTokens,
+			EnableContext: h.app.ChatConfig.EnableContext,
+			EnableHistory: true,
+			Model:         h.app.ChatConfig.Model,
+			ApiKey:        "",
+		}),
+	}
+	res := h.db.Create(&user)
+	if res.Error != nil {
+		resp.ERROR(c, "保存数据失败")
+		logger.Error(res.Error)
+		return
+	}
+
+	resp.SUCCESS(c, user)
+}
+
+func (h *UserHandler) List(c *gin.Context) {
+	var users []model.User
+	res := h.db.Find(&users)
+	if res.Error != nil {
+		resp.ERROR(c, "No user found")
+		logger.Error("get user failed: ", res.Error.Error())
+		return
+	}
+
+	// 转成 VO 输出
+	var userVos = make([]vo.User, 0)
+	for _, u := range users {
+		logger.Info(u)
+		var v vo.User
+		err := utils.CopyObject(u, &v)
+		if err == nil {
+			v.Id = u.Id
+			v.CreatedAt = u.CreatedAt.Unix()
+			v.UpdatedAt = u.UpdatedAt.Unix()
+			userVos = append(userVos, v)
+		}
+	}
+	resp.SUCCESS(c, userVos)
+}
+
+// Login 用户登录
+func (h *UserHandler) Login(c *gin.Context) {
+	var data struct {
+		Username string
+		Password string
+	}
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+	var user model.User
+	res := h.db.Where("username = ?", data.Username).First(&user)
+	if res.Error != nil {
+		resp.ERROR(c, "用户名不存在")
+		return
+	}
+
+	password := utils.GenPassword(data.Password, user.Salt)
+	if password != user.Password {
+		resp.ERROR(c, "用户名或密码错误")
+		return
+	}
+
+	// 更新最后登录时间和IP
+	user.LastLoginIp = c.ClientIP()
+	user.LastLoginAt = time.Now().Unix()
+	h.db.Model(&user).Updates(user)
+
+	sessionId := utils.RandString(42)
+	c.Header(types.TokenSessionName, sessionId)
+	err := utils.SetLoginUser(c, user.Id)
+	if err != nil {
+		resp.ERROR(c, "保存会话失败")
+		logger.Error("Error for save session: ", err)
+		return
+	}
+
+	// 记录登录信息在服务器
+	h.app.ChatSession[sessionId] = types.ChatSession{ClientIP: c.ClientIP(), UserId: user.Id, Username: data.Username, SessionId: sessionId}
+
+	// 加载用户订阅的聊天角色
+	var roleMap map[string]int
+	err = utils.JsonDecode(user.ChatRoles, &roleMap)
+	var chatRoles interface{}
+	if err == nil {
+		roleKeys := make([]string, 0)
+		for key := range roleMap {
+			roleKeys = append(roleKeys, key)
+		}
+		var roles []model.ChatRole
+		res = h.db.Where("marker IN ?", roleKeys).Find(&roles)
+		if res.Error == err {
+			type Item struct {
+				Name string
+				Key  string
+				Icon string
+			}
+			items := make([]Item, 0)
+			for _, r := range roles {
+				items = append(items, Item{Name: r.Name, Key: r.Key, Icon: r.Icon})
+			}
+			chatRoles = items
+		}
+	}
+
+	h.db.Create(&model.UserLoginLog{
+		UserId:       user.Id,
+		Username:     user.Username,
+		LoginIp:      c.ClientIP(),
+		LoginAddress: utils.Ip2Region(h.searcher, c.ClientIP()),
+	})
+	var chatConfig types.ChatConfig
+	err = utils.JsonDecode(user.ChatConfig, &chatConfig)
+	if err != nil {
+		resp.ERROR(c, err.Error())
+		return
+	}
+
+	resp.SUCCESS(c, gin.H{
+		"session_id":     sessionId,
+		"id":             user.Id,
+		"nickname":       user.Nickname,
+		"avatar":         user.Avatar,
+		"username":       user.Username,
+		"tokens":         user.Tokens,
+		"calls":          user.Calls,
+		"expiredTime":    user.ExpiredTime,
+		"chatRoles":      chatRoles,
+		"api_key":        chatConfig.ApiKey,
+		"model":          chatConfig.Model,
+		"temperature":    chatConfig.Temperature,
+		"max_tokens":     chatConfig.MaxTokens,
+		"enable_context": chatConfig.EnableContext,
+		"enable_history": chatConfig.EnableHistory,
+	})
+}
+
+// Logout 注 销
+func (h *UserHandler) Logout(c *gin.Context) {
+	sessionId := c.GetHeader(types.TokenSessionName)
+	session := sessions.Default(c)
+	session.Delete(sessionId)
+	err := session.Save()
+	if err != nil {
+		logger.Error("Error for save session: ", err)
+	}
+	// 删除 websocket 会话列表
+	delete(h.app.ChatSession, sessionId)
+	// 关闭 socket 连接
+	if client, ok := h.app.ChatClients[sessionId]; ok {
+		client.Close()
+	}
+	resp.SUCCESS(c)
+}
+
+// Session 获取/验证会话
+func (h *UserHandler) Session(c *gin.Context) {
+	sessionId := c.GetHeader(types.TokenSessionName)
+	if session, ok := h.app.ChatSession[sessionId]; ok && session.ClientIP == c.ClientIP() {
+		resp.SUCCESS(c, session)
+	} else {
+		resp.NotAuth(c)
+	}
+
+}
+
+func (h *UserHandler) ProfileUpdate(c *gin.Context) {
+	var data vo.User
+	if err := c.ShouldBindJSON(&data); err != nil {
+		resp.ERROR(c, types.InvalidArgs)
+		return
+	}
+
+	user, err := utils.GetLoginUser(c, h.db)
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+	h.db.First(&user, user.Id)
+	user.Nickname = data.Nickname
+	user.Avatar = data.Avatar
+
+	var chatConfig types.ChatConfig
+	err = utils.JsonDecode(user.ChatConfig, &chatConfig)
+	if err != nil {
+		resp.ERROR(c, "用户配置解析失败")
+		return
+	}
+
+	chatConfig.EnableHistory = data.ChatConfig.EnableHistory
+	chatConfig.EnableContext = data.ChatConfig.EnableContext
+	chatConfig.Model = data.ChatConfig.Model
+	chatConfig.MaxTokens = data.ChatConfig.MaxTokens
+	chatConfig.ApiKey = data.ChatConfig.ApiKey
+	chatConfig.Temperature = data.ChatConfig.Temperature
+
+	user.ChatConfig = utils.JsonEncode(chatConfig)
+	res := h.db.Updates(&user)
+	if res.Error != nil {
+		resp.ERROR(c, "更新用户信息失败")
+		return
+	}
+	resp.SUCCESS(c)
+}
+
+func (h *UserHandler) Profile(c *gin.Context) {
+	user, err := utils.GetLoginUser(c, h.db)
+	if err != nil {
+		resp.NotAuth(c)
+		return
+	}
+
+	h.db.First(&user, user.Id)
+	var userVo vo.User
+	err = utils.CopyObject(user, &userVo)
+	if err != nil {
+		logger.Error("对象拷贝失败：", err.Error())
+		resp.ERROR(c, "获取用户信息失败")
+		return
+	}
+
+	userVo.Id = user.Id
+	userVo.CreatedAt = user.CreatedAt.Unix()
+	userVo.UpdatedAt = user.UpdatedAt.Unix()
+	resp.SUCCESS(c, userVo)
+}