修复会话安全与实时消息

server/internal/handler/session.go

@@ -5,8 +5,10 @@ import (
 	"time"
 
 	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
 	"kefu-sys/server/internal/middleware"
 	"kefu-sys/server/internal/model"
+	"kefu-sys/server/internal/ws"
 )
 
 type SessionHandler struct{}
@@ -19,7 +21,6 @@ type SendMessageReq struct {
 }
 
 func (h *SessionHandler) SendMessage(c *gin.Context) {
-	tenantID := middleware.GetTenantID(c)
 	userID := middleware.GetUserID(c)
 	id := c.Param("id")
 
@@ -32,14 +33,18 @@ func (h *SessionHandler) SendMessage(c *gin.Context) {
 		req.Type = "text"
 	}
 
-	var session model.Session
-	if err := model.DB.Where("id = ? AND tenant_id = ?", id, tenantID).First(&session).Error; err != nil {
-		c.JSON(http.StatusNotFound, gin.H{"code": 404, "message": "会话不存在"})
+	session, ok := loadTenantSession(c, id)
+	if !ok {
+		return
+	}
+	if !canOperateSession(c, session) {
+		c.JSON(http.StatusForbidden, gin.H{"code": 403, "message": "无权向该会话发送消息"})
+		return
+	}
+	if session.Status == "ended" || session.Status == "archived" {
+		c.JSON(http.StatusConflict, gin.H{"code": 409, "message": "会话已结束"})
 		return
 	}
-
-	var maxSeq int
-	model.DB.Model(&model.Message{}).Where("session_id = ?", session.ID).Select("COALESCE(MAX(seq), 0)").Scan(&maxSeq)
 
 	msg := model.Message{
 		SessionID:  session.ID,
@@ -47,14 +52,14 @@ func (h *SessionHandler) SendMessage(c *gin.Context) {
 		SenderID:   &userID,
 		Content:    req.Content,
 		Type:       req.Type,
-		Seq:        maxSeq + 1,
 		SentAt:     time.Now(),
 	}
 
-	if err := model.DB.Create(&msg).Error; err != nil {
+	if err := model.CreateMessage(&msg); err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"code": 500, "message": "发送失败"})
 		return
 	}
+	broadcastSessionMessage(session, msg)
 
 	middleware.JSON(c, msg)
 }
@@ -66,7 +71,67 @@ type CreateSessionReq struct {
 }
 
 type AssignSessionReq struct {
-	AgentID uint `json:"agent_id" binding:"required"`
+	AgentID uint `json:"agent_id"`
+}
+
+func isTenantManager(c *gin.Context) bool {
+	return middleware.HasAnyRole(c, "admin", "supervisor")
+}
+
+func loadTenantSession(c *gin.Context, id string) (*model.Session, bool) {
+	var session model.Session
+	if err := model.DB.First(&session, id).Error; err != nil {
+		c.JSON(http.StatusNotFound, gin.H{"code": 404, "message": "会话不存在"})
+		return nil, false
+	}
+	if session.TenantID != middleware.GetTenantID(c) {
+		c.JSON(http.StatusForbidden, gin.H{"code": 403, "message": "无权访问其他租户会话"})
+		return nil, false
+	}
+	return &session, true
+}
+
+func canReadSession(c *gin.Context, session *model.Session) bool {
+	if isTenantManager(c) {
+		return true
+	}
+	if middleware.GetRole(c) == "agent" {
+		userID := middleware.GetUserID(c)
+		return session.Status == "waiting" || (session.AgentID != nil && *session.AgentID == userID)
+	}
+	return false
+}
+
+func canOperateSession(c *gin.Context, session *model.Session) bool {
+	if isTenantManager(c) {
+		return true
+	}
+	return middleware.GetRole(c) == "agent" && session.AgentID != nil && *session.AgentID == middleware.GetUserID(c)
+}
+
+func broadcastSessionMessage(session *model.Session, message model.Message) {
+	payload, err := ws.NewEvent("message", session.ID, message)
+	if err == nil {
+		ws.DefaultHub.BroadcastToSession(session.TenantID, session.ID, session.AgentID, payload)
+	}
+}
+
+func broadcastSessionUpdate(session *model.Session) {
+	payload, err := ws.NewEvent("session_updated", session.ID, gin.H{"status": session.Status})
+	if err == nil {
+		ws.DefaultHub.BroadcastToTenantStaff(session.TenantID, payload)
+	}
+}
+
+func loadAssignableAgent(tenantID, agentID uint) error {
+	var agent model.User
+	if err := model.DB.First(&agent, agentID).Error; err != nil {
+		return err
+	}
+	if agent.TenantID != tenantID || agent.Role != "agent" || agent.Status == "disabled" {
+		return gorm.ErrRecordNotFound
+	}
+	return nil
 }
 
 func (h *SessionHandler) List(c *gin.Context) {
@@ -79,6 +144,9 @@ func (h *SessionHandler) List(c *gin.Context) {
 	var total int64
 
 	query := model.DB.Where("tenant_id = ?", tenantID)
+	if middleware.GetRole(c) == "agent" {
+		query = query.Where("agent_id = ? OR status = ?", middleware.GetUserID(c), "waiting")
+	}
 	if status != "" {
 		query = query.Where("status = ?", status)
 	}
@@ -93,30 +161,53 @@ func (h *SessionHandler) List(c *gin.Context) {
 }
 
 func (h *SessionHandler) Get(c *gin.Context) {
-	tenantID := middleware.GetTenantID(c)
 	id := c.Param("id")
 
-	var session model.Session
-	if err := model.DB.Where("id = ? AND tenant_id = ?", id, tenantID).First(&session).Error; err != nil {
-		c.JSON(http.StatusNotFound, gin.H{"code": 404, "message": "会话不存在"})
+	session, ok := loadTenantSession(c, id)
+	if !ok {
+		return
+	}
+	if !canReadSession(c, session) {
+		c.JSON(http.StatusForbidden, gin.H{"code": 403, "message": "无权查看该会话"})
 		return
 	}
 
 	var messages []model.Message
-	model.DB.Where("session_id = ?", session.ID).Order("seq asc").Find(&messages)
+	if err := model.DB.Where("session_id = ?", session.ID).Order("seq asc").Find(&messages).Error; err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 500, "message": "查询消息失败"})
+		return
+	}
+	var events []model.SessionEvent
+	model.DB.Where("session_id = ?", session.ID).Order("created_at asc").Find(&events)
 
-	middleware.JSON(c, gin.H{"session": session, "messages": messages})
+	middleware.JSON(c, gin.H{"session": session, "messages": messages, "events": events})
 }
 
 func (h *SessionHandler) Create(c *gin.Context) {
+	if !isTenantManager(c) {
+		c.JSON(http.StatusForbidden, gin.H{"code": 403, "message": "仅主管或管理员可创建会话"})
+		return
+	}
 	var req CreateSessionReq
 	if err := c.ShouldBindJSON(&req); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "参数错误"})
 		return
 	}
 
+	tenantID := middleware.GetTenantID(c)
+	var channel model.Channel
+	if err := model.DB.Where("id = ? AND tenant_id = ? AND status = ?", req.ChannelID, tenantID, "enabled").First(&channel).Error; err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "渠道不存在或未启用"})
+		return
+	}
+	var customer model.Customer
+	if err := model.DB.Where("id = ? AND tenant_id = ?", req.CustomerID, tenantID).First(&customer).Error; err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "客户不存在"})
+		return
+	}
+
 	session := model.Session{
-		TenantID:   middleware.GetTenantID(c),
+		TenantID:   tenantID,
 		ChannelID:  req.ChannelID,
 		CustomerID: req.CustomerID,
 		Priority:   req.Priority,
@@ -136,57 +227,120 @@ func (h *SessionHandler) Create(c *gin.Context) {
 }
 
 func (h *SessionHandler) Assign(c *gin.Context) {
-	tenantID := middleware.GetTenantID(c)
 	id := c.Param("id")
+	session, ok := loadTenantSession(c, id)
+	if !ok {
+		return
+	}
 	var req AssignSessionReq
 	if err := c.ShouldBindJSON(&req); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "参数错误"})
 		return
 	}
 
+	if session.Status != "waiting" {
+		c.JSON(http.StatusConflict, gin.H{"code": 409, "message": "会话已被分配"})
+		return
+	}
+	if middleware.GetRole(c) == "agent" {
+		req.AgentID = middleware.GetUserID(c)
+	} else if !isTenantManager(c) {
+		c.JSON(http.StatusForbidden, gin.H{"code": 403, "message": "无权分配会话"})
+		return
+	}
+	if req.AgentID == 0 {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "请选择目标客服"})
+		return
+	}
+	if err := loadAssignableAgent(session.TenantID, req.AgentID); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "目标客服不存在或不可用"})
+		return
+	}
+
 	result := model.DB.Model(&model.Session{}).
-		Where("id = ? AND tenant_id = ? AND status = ?", id, tenantID, "waiting").
+		Where("id = ? AND tenant_id = ? AND status = ?", session.ID, session.TenantID, "waiting").
 		Updates(map[string]interface{}{"agent_id": req.AgentID, "status": "active"})
 
+	if result.Error != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 500, "message": "分配失败"})
+		return
+	}
 	if result.RowsAffected == 0 {
-		c.JSON(http.StatusNotFound, gin.H{"code": 404, "message": "会话不存在或已被分配"})
+		c.JSON(http.StatusConflict, gin.H{"code": 409, "message": "会话已被分配"})
 		return
 	}
 
+	model.DB.Create(&model.SessionEvent{SessionID: session.ID, OperatorID: middleware.GetUserID(c), Action: "assign", Detail: "会话分配"})
+	session.AgentID = &req.AgentID
+	session.Status = "active"
+	broadcastSessionUpdate(session)
 	middleware.JSON(c, gin.H{"message": "分配成功"})
 }
 
 func (h *SessionHandler) Transfer(c *gin.Context) {
-	tenantID := middleware.GetTenantID(c)
 	id := c.Param("id")
+	session, ok := loadTenantSession(c, id)
+	if !ok {
+		return
+	}
+	if !canOperateSession(c, session) {
+		c.JSON(http.StatusForbidden, gin.H{"code": 403, "message": "无权转接该会话"})
+		return
+	}
 	var req AssignSessionReq
 	if err := c.ShouldBindJSON(&req); err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "参数错误"})
 		return
 	}
 
-	model.DB.Model(&model.Session{}).
-		Where("id = ? AND tenant_id = ?", id, tenantID).
+	if err := loadAssignableAgent(session.TenantID, req.AgentID); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "目标客服不存在或不可用"})
+		return
+	}
+	result := model.DB.Model(&model.Session{}).
+		Where("id = ? AND tenant_id = ? AND status = ?", session.ID, session.TenantID, "active").
 		Update("agent_id", req.AgentID)
+	if result.Error != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 500, "message": "转接失败"})
+		return
+	}
+	if result.RowsAffected == 0 {
+		c.JSON(http.StatusConflict, gin.H{"code": 409, "message": "会话不可转接"})
+		return
+	}
 
 	model.DB.Create(&model.SessionEvent{
-		SessionID:  parseID(id),
+		SessionID:  session.ID,
 		OperatorID: middleware.GetUserID(c),
 		Action:     "transfer",
 		Detail:     "会话转接",
 	})
+	session.AgentID = &req.AgentID
+	broadcastSessionUpdate(session)
 
 	middleware.JSON(c, gin.H{"message": "转接成功"})
 }
 
 func (h *SessionHandler) End(c *gin.Context) {
-	tenantID := middleware.GetTenantID(c)
 	id := c.Param("id")
 	reason := c.Query("reason")
+	session, ok := loadTenantSession(c, id)
+	if !ok {
+		return
+	}
+	if !canOperateSession(c, session) {
+		c.JSON(http.StatusForbidden, gin.H{"code": 403, "message": "无权结束该会话"})
+		return
+	}
+	if reason == "" {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "请填写结束原因"})
+		return
+	}
+	now := time.Now()
 
 	result := model.DB.Model(&model.Session{}).
-		Where("id = ? AND tenant_id = ?", id, tenantID).
-		Updates(map[string]interface{}{"status": "ended", "end_reason": reason})
+		Where("id = ? AND tenant_id = ? AND status <> ?", session.ID, session.TenantID, "ended").
+		Updates(map[string]interface{}{"status": "ended", "end_reason": reason, "ended_at": now})
 
 	if result.RowsAffected == 0 {
 		c.JSON(http.StatusNotFound, gin.H{"code": 404, "message": "会话不存在"})
@@ -194,33 +348,43 @@ func (h *SessionHandler) End(c *gin.Context) {
 	}
 
 	model.DB.Create(&model.SessionEvent{
-		SessionID:  parseID(id),
+		SessionID:  session.ID,
 		OperatorID: middleware.GetUserID(c),
 		Action:     "end",
 		Detail:     "结束会话: " + reason,
 	})
+	session.Status = "ended"
+	session.EndedAt = &now
+	broadcastSessionUpdate(session)
 
 	middleware.JSON(c, gin.H{"message": "已结束"})
 }
 
 func (h *SessionHandler) UpdatePriority(c *gin.Context) {
-	tenantID := middleware.GetTenantID(c)
 	id := c.Param("id")
 	priority := c.Query("priority")
+	session, ok := loadTenantSession(c, id)
+	if !ok {
+		return
+	}
+	if !canOperateSession(c, session) {
+		c.JSON(http.StatusForbidden, gin.H{"code": 403, "message": "无权更新该会话"})
+		return
+	}
+	if priority != "urgent" && priority != "normal" {
+		c.JSON(http.StatusBadRequest, gin.H{"code": 400, "message": "优先级无效"})
+		return
+	}
 
-	model.DB.Model(&model.Session{}).
-		Where("id = ? AND tenant_id = ?", id, tenantID).
+	result := model.DB.Model(&model.Session{}).
+		Where("id = ? AND tenant_id = ?", session.ID, session.TenantID).
 		Update("priority", priority)
+	if result.Error != nil || result.RowsAffected == 0 {
+		c.JSON(http.StatusInternalServerError, gin.H{"code": 500, "message": "更新失败"})
+		return
+	}
+	session.Priority = priority
+	broadcastSessionUpdate(session)
 
 	middleware.JSON(c, gin.H{"message": "已更新"})
 }
-
-func parseID(s string) uint {
-	var id uint
-	for _, c := range s {
-		if c >= '0' && c <= '9' {
-			id = id*10 + uint(c-'0')
-		}
-	}
-	return id
-}