feat: 实时消息与管理端运营能力

新增群聊/私信与公共 WebSocket 总线，站长用户内容档案，并将通知与待审角标改为推送驱动；同步精简管理仪表盘并修复主题换肤 DOM 冲突。 Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-15 22:58:16 +08:00
parent 29db9ae9b5
commit 42c395a864
55 changed files with 7607 additions and 346 deletions
--- a/backend/service/actor.go
+++ b/backend/service/actor.go
@@ -1,6 +1,8 @@
 package service

 import (
+	"strings"
+
 	"github.com/freefire/jiang13-bbs/model"
 )

@@ -107,9 +109,53 @@ func (s *AuthService) GetUserBoardIDs(id uint) ([]uint, error) {

 // GetUserIDByUsername 按用户名查 ID（登录失败审计用），用户不存在返回 0
 func (s *AuthService) GetUserIDByUsername(username string) uint {
+	username = strings.TrimSpace(username)
+	if username == "" {
+		return 0
+	}
 	var u model.User
 	if err := s.db.Select("id").Where("username = ?", username).First(&u).Error; err != nil {
 		return 0
 	}
 	return u.ID
 }
+
+// ListBoardModeratorIDs 可审核指定板块的用户 ID：
+// 站长/超管/全站管理员 + 被授权该板的板块管理员（未封禁、未删除）
+func (s *AuthService) ListBoardModeratorIDs(boardID uint) ([]uint, error) {
+	var ids []uint
+	// 全站可审：admin / super_admin / owner
+	if err := s.db.Model(&model.User{}).
+		Where("deleted_at IS NULL AND banned = ? AND role IN ?", false,
+			[]string{string(model.RoleAdmin), string(model.RoleSuperAdmin), string(model.RoleOwner)}).
+		Pluck("id", &ids).Error; err != nil {
+		return nil, err
+	}
+	// 板块管理员（授权该板）
+	var boardAdminIDs []uint
+	if err := s.db.Model(&model.UserBoard{}).
+		Select("user_boards.user_id").
+		Joins("JOIN users ON users.id = user_boards.user_id").
+		Where("user_boards.board_id = ? AND users.deleted_at IS NULL AND users.banned = ? AND users.role = ?",
+			boardID, false, string(model.RoleBoardAdmin)).
+		Pluck("user_boards.user_id", &boardAdminIDs).Error; err != nil {
+		return nil, err
+	}
+	seen := make(map[uint]struct{}, len(ids)+len(boardAdminIDs))
+	out := make([]uint, 0, len(ids)+len(boardAdminIDs))
+	for _, id := range ids {
+		if _, ok := seen[id]; ok {
+			continue
+		}
+		seen[id] = struct{}{}
+		out = append(out, id)
+	}
+	for _, id := range boardAdminIDs {
+		if _, ok := seen[id]; ok {
+			continue
+		}
+		seen[id] = struct{}{}
+		out = append(out, id)
+	}
+	return out, nil
+}
--- a/backend/service/admin_user.go
+++ b/backend/service/admin_user.go
@@ -22,6 +22,8 @@ var (
 	ErrBoardRequired = errors.New("板块管理员至少需要授权一个板块")
 	// ErrBoardNotFound 授权的板块不存在
 	ErrBoardNotFound = errors.New("部分板块不存在")
+	// ErrOwnerOnly 仅站长可访问用户内容档案
+	ErrOwnerOnly = errors.New("仅站长可查看用户内容档案")
 )

 // onlineThreshold last_seen_at 在该窗口内视为在线
@@ -197,9 +199,10 @@ func (s *AdminUserService) toItems(users []model.User) []AdminUserItem {
 	commentCounts := map[uint]int64{}

 	var postRows []countRow
+	// 列表计数统一为「已发布」口径，与评论一致；全量含驳回/软删见内容档案
 	s.db.Model(&model.Post{}).
 		Select("user_id, COUNT(*) AS cnt").
-		Where("user_id IN ?", ids).
+		Where("user_id IN ? AND status = ?", ids, model.ContentStatusPublished).
 		Group("user_id").Scan(&postRows)
 	for _, r := range postRows {
 		postCounts[r.UserID] = r.Cnt
@@ -433,3 +436,240 @@ func invalidateUserSessions(tx *gorm.DB, userID uint) error {
 	return tx.Model(&model.RefreshToken{}).Where("user_id = ? AND revoked = ?", userID, false).
 		Updates(map[string]any{"revoked": true, "token_cipher": ""}).Error
 }
+
+// ===== 站长用户内容档案（仅 owner） =====
+
+func requireOwnerActor(actor *Actor) error {
+	if actor == nil || actor.Role != model.RoleOwner {
+		return ErrOwnerOnly
+	}
+	return nil
+}
+
+func normalizeAuditPage(page, size int) (int, int) {
+	if page < 1 {
+		page = 1
+	}
+	if size < 1 || size > 50 {
+		size = 20
+	}
+	return page, size
+}
+
+// AdminUserAuditProfile 站长查看用户档案摘要
+type AdminUserAuditProfile struct {
+	User            AdminUserItem `json:"user"`
+	PostsTotal      int64         `json:"posts_total"`      // 含各状态与软删
+	CommentsTotal   int64         `json:"comments_total"`   // 含各状态与软删
+	MessagesTotal   int64         `json:"messages_total"`   // 含撤回与软删
+	PublishedPosts  int64         `json:"published_posts"`
+	PublishedComments int64       `json:"published_comments"`
+}
+
+// AdminAuditPostItem 审计帖子行
+type AdminAuditPostItem struct {
+	ID        uint       `json:"id"`
+	Title     string     `json:"title"`
+	Content   string     `json:"content"`
+	Status    string     `json:"status"`
+	Deleted   bool       `json:"deleted"`
+	BoardID   uint       `json:"board_id"`
+	BoardName string     `json:"board_name"`
+	CreatedAt time.Time  `json:"created_at"`
+	DeletedAt *time.Time `json:"deleted_at,omitempty"`
+}
+
+// AdminAuditCommentItem 审计评论行
+type AdminAuditCommentItem struct {
+	ID        uint       `json:"id"`
+	PostID    uint       `json:"post_id"`
+	Content   string     `json:"content"`
+	Status    string     `json:"status"`
+	Deleted   bool       `json:"deleted"`
+	CreatedAt time.Time  `json:"created_at"`
+	DeletedAt *time.Time `json:"deleted_at,omitempty"`
+}
+
+// AdminAuditMessageItem 审计聊天消息行
+type AdminAuditMessageItem struct {
+	ID        uint       `json:"id"`
+	RoomID    uint       `json:"room_id"`
+	RoomName  string     `json:"room_name"`
+	RoomType  string     `json:"room_type"`
+	Content   string     `json:"content"`
+	Recalled  bool       `json:"recalled"`
+	Deleted   bool       `json:"deleted"`
+	CreatedAt time.Time  `json:"created_at"`
+	DeletedAt *time.Time `json:"deleted_at,omitempty"`
+}
+
+// GetAuditProfile 站长：用户摘要 + 全量计数
+func (s *AdminUserService) GetAuditProfile(actor *Actor, userID uint) (*AdminUserAuditProfile, error) {
+	if err := requireOwnerActor(actor); err != nil {
+		return nil, err
+	}
+	item, err := s.getItem(s.db, userID)
+	if err != nil {
+		return nil, err
+	}
+	out := &AdminUserAuditProfile{User: *item}
+	s.db.Unscoped().Model(&model.Post{}).Where("user_id = ?", userID).Count(&out.PostsTotal)
+	s.db.Unscoped().Model(&model.Comment{}).Where("user_id = ?", userID).Count(&out.CommentsTotal)
+	s.db.Unscoped().Model(&model.ChatMessage{}).Where("sender_id = ?", userID).Count(&out.MessagesTotal)
+	s.db.Model(&model.Post{}).Where("user_id = ? AND status = ?", userID, model.ContentStatusPublished).Count(&out.PublishedPosts)
+	s.db.Model(&model.Comment{}).Where("user_id = ? AND status = ?", userID, model.ContentStatusPublished).Count(&out.PublishedComments)
+	return out, nil
+}
+
+// ListAuditPosts 站长：用户全部帖子（含软删）
+func (s *AdminUserService) ListAuditPosts(actor *Actor, userID uint, page, size int) ([]AdminAuditPostItem, int64, int, error) {
+	if err := requireOwnerActor(actor); err != nil {
+		return nil, 0, page, err
+	}
+	page, size = normalizeAuditPage(page, size)
+	if err := s.db.First(&model.User{}, userID).Error; err != nil {
+		return nil, 0, page, err
+	}
+	q := s.db.Unscoped().Model(&model.Post{}).Where("user_id = ?", userID)
+	var total int64
+	if err := q.Count(&total).Error; err != nil {
+		return nil, 0, page, err
+	}
+	var posts []model.Post
+	if err := q.Preload("Board").Order("id DESC").
+		Offset((page - 1) * size).Limit(size).Find(&posts).Error; err != nil {
+		return nil, 0, page, err
+	}
+	items := make([]AdminAuditPostItem, 0, len(posts))
+	for _, p := range posts {
+		it := AdminAuditPostItem{
+			ID:        p.ID,
+			Title:     p.Title,
+			Content:   truncateStr(p.Content, 240),
+			Status:    p.Status,
+			BoardID:   p.BoardID,
+			BoardName: p.Board.Name,
+			CreatedAt: p.CreatedAt,
+		}
+		if p.DeletedAt.Valid {
+			it.Deleted = true
+			t := p.DeletedAt.Time
+			it.DeletedAt = &t
+		}
+		items = append(items, it)
+	}
+	return items, total, page, nil
+}
+
+// ListAuditComments 站长：用户全部评论（含软删）
+func (s *AdminUserService) ListAuditComments(actor *Actor, userID uint, page, size int) ([]AdminAuditCommentItem, int64, int, error) {
+	if err := requireOwnerActor(actor); err != nil {
+		return nil, 0, page, err
+	}
+	page, size = normalizeAuditPage(page, size)
+	if err := s.db.First(&model.User{}, userID).Error; err != nil {
+		return nil, 0, page, err
+	}
+	q := s.db.Unscoped().Model(&model.Comment{}).Where("user_id = ?", userID)
+	var total int64
+	if err := q.Count(&total).Error; err != nil {
+		return nil, 0, page, err
+	}
+	var comments []model.Comment
+	if err := q.Order("id DESC").
+		Offset((page - 1) * size).Limit(size).Find(&comments).Error; err != nil {
+		return nil, 0, page, err
+	}
+	items := make([]AdminAuditCommentItem, 0, len(comments))
+	for _, c := range comments {
+		it := AdminAuditCommentItem{
+			ID:        c.ID,
+			PostID:    c.PostID,
+			Content:   truncateStr(c.Content, 240),
+			Status:    c.Status,
+			CreatedAt: c.CreatedAt,
+		}
+		if c.DeletedAt.Valid {
+			it.Deleted = true
+			t := c.DeletedAt.Time
+			it.DeletedAt = &t
+		}
+		items = append(items, it)
+	}
+	return items, total, page, nil
+}
+
+// ListAuditMessages 站长：用户发出的全部聊天消息（含撤回/软删）
+func (s *AdminUserService) ListAuditMessages(actor *Actor, userID uint, page, size int) ([]AdminAuditMessageItem, int64, int, error) {
+	if err := requireOwnerActor(actor); err != nil {
+		return nil, 0, page, err
+	}
+	page, size = normalizeAuditPage(page, size)
+	if err := s.db.First(&model.User{}, userID).Error; err != nil {
+		return nil, 0, page, err
+	}
+	q := s.db.Unscoped().Model(&model.ChatMessage{}).Where("sender_id = ?", userID)
+	var total int64
+	if err := q.Count(&total).Error; err != nil {
+		return nil, 0, page, err
+	}
+	var msgs []model.ChatMessage
+	if err := q.Order("id DESC").
+		Offset((page - 1) * size).Limit(size).Find(&msgs).Error; err != nil {
+		return nil, 0, page, err
+	}
+
+	roomIDs := make([]uint, 0, len(msgs))
+	seen := map[uint]struct{}{}
+	for _, m := range msgs {
+		if _, ok := seen[m.RoomID]; ok {
+			continue
+		}
+		seen[m.RoomID] = struct{}{}
+		roomIDs = append(roomIDs, m.RoomID)
+	}
+	roomMap := map[uint]model.ChatRoom{}
+	if len(roomIDs) > 0 {
+		var rooms []model.ChatRoom
+		_ = s.db.Unscoped().Where("id IN ?", roomIDs).Find(&rooms)
+		for _, r := range rooms {
+			roomMap[r.ID] = r
+		}
+	}
+
+	items := make([]AdminAuditMessageItem, 0, len(msgs))
+	for _, m := range msgs {
+		room := roomMap[m.RoomID]
+		name := room.Name
+		if name == "" {
+			if room.RoomType == model.ChatRoomTypeDirect {
+				name = "私聊"
+			} else if room.IsDefault {
+				name = "全站大厅"
+			} else {
+				name = "群聊"
+			}
+		}
+		content := m.Content
+		recalled := m.RecalledAt != nil
+		if recalled && content == "" {
+			content = "（已撤回的消息）"
+		}
+		it := AdminAuditMessageItem{
+			ID:        m.ID,
+			RoomID:    m.RoomID,
+			RoomName:  name,
+			RoomType:  room.RoomType,
+			Content:   truncateStr(content, 240),
+			Recalled:  recalled,
+			CreatedAt: m.CreatedAt,
+		}
+		if m.DeletedAt.Valid {
+			it.Deleted = true
+			t := m.DeletedAt.Time
+			it.DeletedAt = &t
+		}
+		items = append(items, it)
+	}
+	return items, total, page, nil
+}
--- a/backend/service/chat.go
+++ b/backend/service/chat.go
@@ -0,0 +1,992 @@
+// Package service 群聊业务（二期）。
+//
+// 铁律：消息先落库再由 handler 经 WS 广播，WS 不承担可靠投递；
+// 未读数以成员行 last_read_message_id 为水位做 SQL 对账，离线期间不丢消息。
+package service
+
+import (
+	"errors"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/freefire/jiang13-bbs/model"
+	"gorm.io/gorm"
+)
+
+var (
+	ErrChatNotFound        = errors.New("会话不存在")
+	ErrChatNotMember       = errors.New("不是会话成员")
+	ErrChatNameInvalid     = errors.New("群名称需为 2-32 个字符")
+	ErrChatDescInvalid     = errors.New("群简介不能超过 200 个字符")
+	ErrChatContentEmpty    = errors.New("消息内容不能为空")
+	ErrChatContentTooLong  = errors.New("单条消息不能超过 2000 个字符")
+	ErrChatMuted           = errors.New("你已被群主禁言")
+	ErrChatOwnerOnly       = errors.New("仅群主可执行该操作")
+	ErrChatOwnerLeave      = errors.New("群主不能直接退出，请先解散该群")
+	ErrChatPrivateInvite   = errors.New("私密群需邀请才能加入")
+	ErrChatDefaultLeave    = errors.New("默认大厅不可退出")
+	ErrChatDefaultDissolve = errors.New("默认大厅不可解散")
+	ErrChatRecallDenied    = errors.New("无权撤回该消息")
+	ErrChatMsgNotFound     = errors.New("消息不存在")
+	ErrChatDMSelf          = errors.New("不能与自己私聊")
+	ErrChatDMDissolve      = errors.New("私聊会话不可解散")
+	ErrChatUserGone        = errors.New("用户不存在或已封禁")
+	ErrChatHallPinFixed    = errors.New("大厅已置顶且不可取消")
+)
+
+// CanOverseeChat 站长/超管可旁路查看全部群并撤回任意消息
+func CanOverseeChat(role model.Role) bool {
+	return role == model.RoleOwner || role == model.RoleSuperAdmin
+}
+
+const (
+	chatNameMinRune = 2
+	chatNameMaxRune = 32
+	chatDescMaxRune = 200
+	chatMsgMaxRune  = 2000
+	chatMentionMax  = 20
+)
+
+// chatMentionRe @提醒匹配：用户名 3-32 位字母/数字/下划线/连字符；
+// 是否有效最终以"群成员精确匹配"为准，名单外的 @ 原样当普通文本
+var chatMentionRe = regexp.MustCompile(`@([A-Za-z0-9_-]{3,32})`)
+
+// ChatService 群聊服务
+type ChatService struct {
+	db    *gorm.DB
+	notif *NotificationService
+}
+
+func NewChatService(db *gorm.DB, notif *NotificationService) *ChatService {
+	return &ChatService{db: db, notif: notif}
+}
+
+// RoomView 会话列表/详情聚合视图
+type RoomView struct {
+	model.ChatRoom
+	Joined      bool        `json:"joined"`
+	MyRole      string      `json:"my_role"`
+	UnreadCount int64       `json:"unread_count"`
+	Pinned      bool        `json:"pinned"`      // 对当前用户是否置顶（含大厅强制）
+	PinForced   bool        `json:"pin_forced"`  // 大厅强制置顶，不可取消
+	Peer        *model.User `json:"peer,omitempty"` // 私聊对方（仅 direct）
+}
+
+// UnreadRoom 单个会话的未读计数
+type UnreadRoom struct {
+	RoomID uint  `gorm:"column:room_id" json:"room_id"`
+	Count  int64 `gorm:"column:cnt" json:"count"`
+}
+
+func directKey(a, b uint) string {
+	if a > b {
+		a, b = b, a
+	}
+	return strconv.FormatUint(uint64(a), 10) + ":" + strconv.FormatUint(uint64(b), 10)
+}
+
+func (s *ChatService) getRoom(roomID uint) (*model.ChatRoom, error) {
+	var room model.ChatRoom
+	err := s.db.First(&room, roomID).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, ErrChatNotFound
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &room, nil
+}
+
+func (s *ChatService) membership(tx *gorm.DB, roomID, userID uint) (*model.ChatRoomMember, error) {
+	var m model.ChatRoomMember
+	err := tx.Where("room_id = ? AND user_id = ?", roomID, userID).First(&m).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, ErrChatNotMember
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &m, nil
+}
+
+// Membership 供 WS 握手后动态订阅房间鉴权
+func (s *ChatService) Membership(roomID, userID uint) (*model.ChatRoomMember, error) {
+	return s.membership(s.db, roomID, userID)
+}
+
+// unreadCounts 批量计算访问者在给定群集合中的未读数（消息 ID 大于已读水位即未读）
+func (s *ChatService) unreadCounts(userID uint, roomIDs []uint) map[uint]int64 {
+	out := make(map[uint]int64)
+	if userID == 0 || len(roomIDs) == 0 {
+		return out
+	}
+	var rows []UnreadRoom
+	s.db.Table("chat_messages AS m").
+		Select("m.room_id AS room_id, count(*) AS cnt").
+		Joins("JOIN chat_room_members AS rm ON rm.room_id = m.room_id AND rm.user_id = ?", userID).
+		Where("m.room_id IN ? AND m.id > rm.last_read_message_id AND m.deleted_at IS NULL AND m.recalled_at IS NULL", roomIDs).
+		Group("m.room_id").
+		Scan(&rows)
+	for _, r := range rows {
+		out[r.RoomID] = r.Count
+	}
+	return out
+}
+
+// toViews 批量填充 joined/角色/未读（避免 N+1）
+func (s *ChatService) toViews(rooms []model.ChatRoom, userID uint) []RoomView {
+	ids := make([]uint, 0, len(rooms))
+	for i := range rooms {
+		ids = append(ids, rooms[i].ID)
+	}
+	memberMap := make(map[uint]model.ChatRoomMember)
+	if userID != 0 && len(ids) > 0 {
+		var ms []model.ChatRoomMember
+		s.db.Where("user_id = ? AND room_id IN ?", userID, ids).Find(&ms)
+		for _, m := range ms {
+			memberMap[m.RoomID] = m
+		}
+	}
+	unread := s.unreadCounts(userID, ids)
+	views := make([]RoomView, 0, len(rooms))
+	for _, r := range rooms {
+		v := RoomView{ChatRoom: r, UnreadCount: unread[r.ID]}
+		if r.IsDefault {
+			v.Pinned = true
+			v.PinForced = true
+		}
+		if m, ok := memberMap[r.ID]; ok {
+			v.Joined = true
+			v.MyRole = m.Role
+			if m.PinnedAt != nil {
+				v.Pinned = true
+			}
+		}
+		views = append(views, v)
+	}
+	s.attachPeers(views, userID)
+	sortRoomViews(views, memberMap)
+	return views
+}
+
+// sortRoomViews：大厅强制置顶 > 个人置顶(pinned_at DESC) > last_message_id DESC
+func sortRoomViews(views []RoomView, memberMap map[uint]model.ChatRoomMember) {
+	sort.SliceStable(views, func(i, j int) bool {
+		a, b := views[i], views[j]
+		if a.IsDefault != b.IsDefault {
+			return a.IsDefault
+		}
+		aPin, bPin := !a.IsDefault && a.Pinned, !b.IsDefault && b.Pinned
+		if aPin != bPin {
+			return aPin
+		}
+		if aPin && bPin {
+			var at, bt time.Time
+			if m, ok := memberMap[a.ID]; ok && m.PinnedAt != nil {
+				at = *m.PinnedAt
+			}
+			if m, ok := memberMap[b.ID]; ok && m.PinnedAt != nil {
+				bt = *m.PinnedAt
+			}
+			if !at.Equal(bt) {
+				return at.After(bt)
+			}
+		}
+		if a.LastMessageID != b.LastMessageID {
+			return a.LastMessageID > b.LastMessageID
+		}
+		return a.ID > b.ID
+	})
+}
+
+// attachPeers 为私聊会话填充对方用户信息
+func (s *ChatService) attachPeers(views []RoomView, viewerID uint) {
+	directIDs := make([]uint, 0)
+	for i := range views {
+		if views[i].RoomType == model.ChatRoomTypeDirect {
+			directIDs = append(directIDs, views[i].ID)
+		}
+	}
+	if len(directIDs) == 0 {
+		return
+	}
+	var members []model.ChatRoomMember
+	s.db.Where("room_id IN ? AND user_id <> ?", directIDs, viewerID).Preload("User").Find(&members)
+	peerByRoom := make(map[uint]*model.User, len(members))
+	for i := range members {
+		u := members[i].User
+		peerByRoom[members[i].RoomID] = &u
+	}
+	for i := range views {
+		if p, ok := peerByRoom[views[i].ID]; ok {
+			views[i].Peer = p
+			if views[i].Name == "" && p != nil {
+				views[i].Name = p.Nickname
+				if views[i].Name == "" {
+					views[i].Name = p.Username
+				}
+			}
+		}
+	}
+}
+
+// CreateRoom 建群：任意登录用户可建；isPrivate 时仅邀请可进；memberIDs 为初始成员（不含创建者）
+func (s *ChatService) CreateRoom(creatorID uint, name, description string, isPrivate bool, memberIDs []uint) (*RoomView, error) {
+	name = strings.TrimSpace(name)
+	description = strings.TrimSpace(description)
+	if l := len([]rune(name)); l < chatNameMinRune || l > chatNameMaxRune {
+		return nil, ErrChatNameInvalid
+	}
+	if len([]rune(description)) > chatDescMaxRune {
+		return nil, ErrChatDescInvalid
+	}
+	// 去重、排除自己
+	seen := map[uint]struct{}{creatorID: {}}
+	cleanIDs := make([]uint, 0, len(memberIDs))
+	for _, id := range memberIDs {
+		if id == 0 {
+			continue
+		}
+		if _, ok := seen[id]; ok {
+			continue
+		}
+		seen[id] = struct{}{}
+		cleanIDs = append(cleanIDs, id)
+	}
+	room := model.ChatRoom{
+		Name:        name,
+		Description: description,
+		OwnerID:     creatorID,
+		RoomType:    model.ChatRoomTypeGroup,
+		IsPrivate:   isPrivate,
+		MemberCount: 1 + len(cleanIDs),
+	}
+	err := s.db.Transaction(func(tx *gorm.DB) error {
+		if err := tx.Create(&room).Error; err != nil {
+			return err
+		}
+		m := model.ChatRoomMember{RoomID: room.ID, UserID: creatorID, Role: model.ChatRoleOwner}
+		if err := tx.Create(&m).Error; err != nil {
+			return err
+		}
+		for _, uid := range cleanIDs {
+			mm := model.ChatRoomMember{RoomID: room.ID, UserID: uid, Role: model.ChatRoleMember}
+			if err := tx.Create(&mm).Error; err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	var full model.ChatRoom
+	if err := s.db.Preload("Owner").First(&full, room.ID).Error; err != nil {
+		return nil, err
+	}
+	v := RoomView{ChatRoom: full, Joined: true, MyRole: model.ChatRoleOwner}
+	return &v, nil
+}
+
+// ListRooms 会话列表。joinedOnly=true 时仅已加入（IM 侧栏）；否则公开群 + 已加入私密（站长旁路可见全部）
+func (s *ChatService) ListRooms(userID uint, oversee, joinedOnly bool, q string, page, size int) ([]RoomView, int64, error) {
+	if page < 1 {
+		page = 1
+	}
+	if size < 1 || size > 50 {
+		size = 20
+	}
+	query := s.db.Model(&model.ChatRoom{})
+	if joinedOnly && userID > 0 {
+		query = query.Where("id IN (SELECT room_id FROM chat_room_members WHERE user_id = ?)", userID)
+	} else if !oversee {
+		if userID == 0 {
+			query = query.Where("is_private = ? AND room_type = ?", false, model.ChatRoomTypeGroup)
+		} else {
+			query = query.Where(
+				"(is_private = ? AND room_type = ?) OR id IN (SELECT room_id FROM chat_room_members WHERE user_id = ?)",
+				false, model.ChatRoomTypeGroup, userID,
+			)
+		}
+	}
+	if q = strings.TrimSpace(q); q != "" {
+		esc := strings.NewReplacer(`\`, `\\`, `%`, `\%`, `_`, `\_`).Replace(q)
+		query = query.Where(`name ILIKE ? ESCAPE '\'`, "%"+esc+"%")
+	}
+	var total int64
+	if err := query.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+	var rooms []model.ChatRoom
+	// 已加入列表需按个人置顶排序：先全量取出再内存排序分页（会话量通常很小）
+	if joinedOnly && userID > 0 {
+		if err := query.
+			Preload("Owner").Preload("LastMessage.Sender").
+			Find(&rooms).Error; err != nil {
+			return nil, 0, err
+		}
+		views := s.toViews(rooms, userID)
+		start := (page - 1) * size
+		if start >= len(views) {
+			return []RoomView{}, total, nil
+		}
+		end := start + size
+		if end > len(views) {
+			end = len(views)
+		}
+		return views[start:end], total, nil
+	}
+	if err := query.
+		Order("is_default DESC, last_message_id DESC, id DESC").
+		Offset((page - 1) * size).Limit(size).
+		Preload("Owner").Preload("LastMessage.Sender").
+		Find(&rooms).Error; err != nil {
+		return nil, 0, err
+	}
+	return s.toViews(rooms, userID), total, nil
+}
+
+// SetRoomPinned 当前用户置顶/取消置顶（大厅强制置顶不可取消）
+func (s *ChatService) SetRoomPinned(userID, roomID uint, pinned bool) (*RoomView, error) {
+	room, err := s.getRoom(roomID)
+	if err != nil {
+		return nil, err
+	}
+	if room.IsDefault {
+		return nil, ErrChatHallPinFixed
+	}
+	m, err := s.membership(s.db, roomID, userID)
+	if err != nil {
+		return nil, err
+	}
+	if pinned {
+		now := time.Now()
+		if err := s.db.Model(m).Update("pinned_at", now).Error; err != nil {
+			return nil, err
+		}
+	} else {
+		if err := s.db.Model(m).Update("pinned_at", nil).Error; err != nil {
+			return nil, err
+		}
+	}
+	return s.RoomDetail(userID, roomID, false)
+}
+
+// GetOrCreateDM 获取或创建与对方的一对一私聊（幂等）
+func (s *ChatService) GetOrCreateDM(meID, peerID uint) (*RoomView, error) {
+	if peerID == 0 || peerID == meID {
+		return nil, ErrChatDMSelf
+	}
+	var peer model.User
+	if err := s.db.Where("id = ? AND banned = ? AND deleted_at IS NULL", peerID, false).First(&peer).Error; err != nil {
+		return nil, ErrChatUserGone
+	}
+	key := directKey(meID, peerID)
+	var existing model.ChatRoom
+	err := s.db.Where("room_type = ? AND direct_key = ?", model.ChatRoomTypeDirect, key).First(&existing).Error
+	if err == nil {
+		_ = s.ensureMember(existing.ID, meID)
+		_ = s.ensureMember(existing.ID, peerID)
+		return s.RoomDetail(meID, existing.ID, false)
+	}
+	if !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, err
+	}
+	room := model.ChatRoom{
+		Name:        "",
+		OwnerID:     meID,
+		RoomType:    model.ChatRoomTypeDirect,
+		DirectKey:   key,
+		IsPrivate:   true,
+		MemberCount: 2,
+	}
+	err = s.db.Transaction(func(tx *gorm.DB) error {
+		if e := tx.Create(&room).Error; e != nil {
+			return e
+		}
+		ms := []model.ChatRoomMember{
+			{RoomID: room.ID, UserID: meID, Role: model.ChatRoleMember},
+			{RoomID: room.ID, UserID: peerID, Role: model.ChatRoleMember},
+		}
+		return tx.Create(&ms).Error
+	})
+	if err != nil {
+		if e2 := s.db.Where("room_type = ? AND direct_key = ?", model.ChatRoomTypeDirect, key).First(&existing).Error; e2 == nil {
+			return s.RoomDetail(meID, existing.ID, false)
+		}
+		return nil, err
+	}
+	return s.RoomDetail(meID, room.ID, false)
+}
+
+func (s *ChatService) ensureMember(roomID, userID uint) error {
+	_, err := s.membership(s.db, roomID, userID)
+	if err == nil {
+		return nil
+	}
+	if !errors.Is(err, ErrChatNotMember) {
+		return err
+	}
+	m := model.ChatRoomMember{RoomID: roomID, UserID: userID, Role: model.ChatRoleMember}
+	if e := s.db.Create(&m).Error; e != nil {
+		return e
+	}
+	return s.db.Model(&model.ChatRoom{}).Where("id = ?", roomID).
+		UpdateColumn("member_count", gorm.Expr("GREATEST(member_count + 1, 0)")).Error
+}
+
+// ListMemberIDs 房间全部成员 ID（发消息后推未读角标用）
+func (s *ChatService) ListMemberIDs(roomID uint) ([]uint, error) {
+	var ids []uint
+	err := s.db.Model(&model.ChatRoomMember{}).Where("room_id = ?", roomID).Pluck("user_id", &ids).Error
+	return ids, err
+}
+
+// SearchUsersForChat 按用户名/昵称搜索可发起私聊的用户（排除自己、封禁）
+func (s *ChatService) SearchUsersForChat(meID uint, q string, limit int) ([]model.User, error) {
+	q = strings.TrimSpace(q)
+	if q == "" {
+		return nil, nil
+	}
+	if limit < 1 || limit > 20 {
+		limit = 10
+	}
+	esc := strings.NewReplacer(`\`, `\\`, `%`, `\%`, `_`, `\_`).Replace(q)
+	like := "%" + esc + "%"
+	var users []model.User
+	err := s.db.Select("id", "username", "nickname", "avatar", "role").
+		Where("id <> ? AND banned = ? AND deleted_at IS NULL AND (username ILIKE ? ESCAPE '\\' OR nickname ILIKE ? ESCAPE '\\')",
+			meID, false, like, like).
+		Order("username ASC").Limit(limit).Find(&users).Error
+	return users, err
+}
+
+// RoomDetail 群详情：成员或监管者可读；公开非成员返回 joined=false（可预览元数据）
+func (s *ChatService) RoomDetail(userID, roomID uint, oversee bool) (*RoomView, error) {
+	room, err := s.getRoom(roomID)
+	if err != nil {
+		return nil, err
+	}
+	_, memErr := s.membership(s.db, roomID, userID)
+	isMember := memErr == nil
+	if !isMember && !oversee {
+		if room.IsPrivate {
+			return nil, ErrChatNotFound // 私密非成员伪装不存在
+		}
+		// 公开非成员：允许预览
+	} else if memErr != nil && !oversee && !errors.Is(memErr, ErrChatNotMember) {
+		return nil, memErr
+	}
+	if err := s.db.Preload("Owner").Preload("LastMessage.Sender").First(room, roomID).Error; err != nil {
+		return nil, err
+	}
+	views := s.toViews([]model.ChatRoom{*room}, userID)
+	v := views[0]
+	if oversee && !v.Joined {
+		v.Joined = true // 监管旁路按已加入展示，可看历史
+		v.MyRole = "overseer"
+	}
+	return &v, nil
+}
+
+// Join 加入公开群（私密/私聊拒绝；幂等）
+func (s *ChatService) Join(userID, roomID uint) (member *model.ChatRoomMember, joined bool, err error) {
+	room, err := s.getRoom(roomID)
+	if err != nil {
+		return nil, false, err
+	}
+	if room.RoomType == model.ChatRoomTypeDirect {
+		return nil, false, ErrChatNotFound
+	}
+	if room.IsPrivate {
+		return nil, false, ErrChatPrivateInvite
+	}
+	if m, mErr := s.membership(s.db, roomID, userID); mErr == nil {
+		return m, false, nil
+	} else if !errors.Is(mErr, ErrChatNotMember) {
+		return nil, false, mErr
+	}
+	m := model.ChatRoomMember{RoomID: roomID, UserID: userID, Role: model.ChatRoleMember}
+	err = s.db.Transaction(func(tx *gorm.DB) error {
+		if e := tx.Create(&m).Error; e != nil {
+			return e
+		}
+		return tx.Model(&model.ChatRoom{}).Where("id = ?", roomID).
+			UpdateColumn("member_count", gorm.Expr("GREATEST(member_count + 1, 0)")).Error
+	})
+	if err != nil {
+		if existing, qErr := s.membership(s.db, roomID, userID); qErr == nil {
+			return existing, false, nil
+		}
+		return nil, false, err
+	}
+	return &m, true, nil
+}
+
+// InviteMembers 群主（或监管）拉人入群；返回实际新加入的用户 ID
+func (s *ChatService) InviteMembers(operatorID, roomID uint, userIDs []uint, oversee bool) ([]uint, error) {
+	room, err := s.getRoom(roomID)
+	if err != nil {
+		return nil, err
+	}
+	if room.RoomType == model.ChatRoomTypeDirect {
+		return nil, ErrChatOwnerOnly
+	}
+	if !oversee {
+		op, err := s.membership(s.db, roomID, operatorID)
+		if err != nil {
+			return nil, err
+		}
+		if op.Role != model.ChatRoleOwner {
+			return nil, ErrChatOwnerOnly
+		}
+	}
+	added := make([]uint, 0)
+	for _, uid := range userIDs {
+		if uid == 0 {
+			continue
+		}
+		if _, mErr := s.membership(s.db, roomID, uid); mErr == nil {
+			continue
+		}
+		var u model.User
+		if err := s.db.Select("id").Where("id = ? AND banned = ? AND deleted_at IS NULL", uid, false).First(&u).Error; err != nil {
+			continue
+		}
+		m := model.ChatRoomMember{RoomID: roomID, UserID: uid, Role: model.ChatRoleMember}
+		if room.OwnerID == uid {
+			m.Role = model.ChatRoleOwner
+		}
+		err := s.db.Transaction(func(tx *gorm.DB) error {
+			if e := tx.Create(&m).Error; e != nil {
+				return e
+			}
+			return tx.Model(&model.ChatRoom{}).Where("id = ?", roomID).
+				UpdateColumn("member_count", gorm.Expr("GREATEST(member_count + 1, 0)")).Error
+		})
+		if err == nil {
+			added = append(added, uid)
+		}
+	}
+	return added, nil
+}
+
+// EnsureDefaultMembership 将用户加入默认大厅（注册后调用，幂等）
+func (s *ChatService) EnsureDefaultMembership(userID uint) error {
+	var room model.ChatRoom
+	if err := s.db.Where("is_default = ?", true).First(&room).Error; err != nil {
+		return nil // 尚无大厅则跳过
+	}
+	if _, err := s.membership(s.db, room.ID, userID); err == nil {
+		return nil
+	}
+	m := model.ChatRoomMember{RoomID: room.ID, UserID: userID, Role: model.ChatRoleMember}
+	return s.db.Transaction(func(tx *gorm.DB) error {
+		if e := tx.Create(&m).Error; e != nil {
+			return e
+		}
+		return tx.Model(&model.ChatRoom{}).Where("id = ?", room.ID).
+			UpdateColumn("member_count", gorm.Expr("GREATEST(member_count + 1, 0)")).Error
+	})
+}
+
+// Leave 普通成员退出群聊（群主不可退出；默认大厅不可退出；私聊可退出）
+func (s *ChatService) Leave(userID, roomID uint) error {
+	room, err := s.getRoom(roomID)
+	if err != nil {
+		return err
+	}
+	if room.IsDefault {
+		return ErrChatDefaultLeave
+	}
+	m, err := s.membership(s.db, roomID, userID)
+	if err != nil {
+		return err
+	}
+	if room.RoomType != model.ChatRoomTypeDirect && m.Role == model.ChatRoleOwner {
+		return ErrChatOwnerLeave
+	}
+	return s.removeMember(roomID, userID)
+}
+
+// removeMember 删除成员行并把群人数 -1（不小于 0）
+func (s *ChatService) removeMember(roomID, userID uint) error {
+	return s.db.Transaction(func(tx *gorm.DB) error {
+		res := tx.Where("room_id = ? AND user_id = ?", roomID, userID).Delete(&model.ChatRoomMember{})
+		if res.Error != nil {
+			return res.Error
+		}
+		if res.RowsAffected == 0 {
+			return nil
+		}
+		return tx.Model(&model.ChatRoom{}).Where("id = ?", roomID).
+			UpdateColumn("member_count", gorm.Expr("GREATEST(member_count - 1, 0)")).Error
+	})
+}
+
+// Dissolve 群主解散群（默认大厅/私聊不可解散）
+func (s *ChatService) Dissolve(userID, roomID uint, oversee bool) error {
+	room, err := s.getRoom(roomID)
+	if err != nil {
+		return err
+	}
+	if room.IsDefault {
+		return ErrChatDefaultDissolve
+	}
+	if room.RoomType == model.ChatRoomTypeDirect {
+		return ErrChatDMDissolve
+	}
+	if !oversee {
+		m, err := s.membership(s.db, roomID, userID)
+		if err != nil {
+			return err
+		}
+		if m.Role != model.ChatRoleOwner {
+			return ErrChatOwnerOnly
+		}
+	}
+	return s.db.Transaction(func(tx *gorm.DB) error {
+		if err := tx.Delete(&model.ChatRoom{}, roomID).Error; err != nil {
+			return err
+		}
+		return tx.Where("room_id = ?", roomID).Delete(&model.ChatRoomMember{}).Error
+	})
+}
+
+// UpdateRoom 群主修改群名称/简介
+func (s *ChatService) UpdateRoom(userID, roomID uint, name, description string) (*model.ChatRoom, error) {
+	name = strings.TrimSpace(name)
+	description = strings.TrimSpace(description)
+	if l := len([]rune(name)); l < chatNameMinRune || l > chatNameMaxRune {
+		return nil, ErrChatNameInvalid
+	}
+	if len([]rune(description)) > chatDescMaxRune {
+		return nil, ErrChatDescInvalid
+	}
+	room, err := s.getRoom(roomID)
+	if err != nil {
+		return nil, err
+	}
+	m, err := s.membership(s.db, roomID, userID)
+	if err != nil {
+		return nil, err
+	}
+	if m.Role != model.ChatRoleOwner {
+		return nil, ErrChatOwnerOnly
+	}
+	if err := s.db.Model(room).Updates(map[string]interface{}{
+		"name":        name,
+		"description": description,
+	}).Error; err != nil {
+		return nil, err
+	}
+	return s.getRoom(roomID)
+}
+
+// ListMembers 成员名单：成员或监管者可查看
+func (s *ChatService) ListMembers(userID, roomID uint, oversee bool) ([]model.ChatRoomMember, error) {
+	if _, err := s.getRoom(roomID); err != nil {
+		return nil, err
+	}
+	if !oversee {
+		if _, err := s.membership(s.db, roomID, userID); err != nil {
+			return nil, err
+		}
+	}
+	var list []model.ChatRoomMember
+	err := s.db.Where("room_id = ?", roomID).
+		Order("CASE WHEN role = 'owner' THEN 0 ELSE 1 END, created_at ASC").
+		Preload("User").
+		Find(&list).Error
+	if err != nil {
+		return nil, err
+	}
+	return list, nil
+}
+
+// Kick 群主踢人（不能踢群主）
+func (s *ChatService) Kick(operatorID, roomID, targetID uint) error {
+	if _, err := s.getRoom(roomID); err != nil {
+		return err
+	}
+	op, err := s.membership(s.db, roomID, operatorID)
+	if err != nil {
+		return err
+	}
+	if op.Role != model.ChatRoleOwner {
+		return ErrChatOwnerOnly
+	}
+	target, err := s.membership(s.db, roomID, targetID)
+	if err != nil {
+		return err
+	}
+	if target.Role == model.ChatRoleOwner {
+		return ErrChatOwnerOnly
+	}
+	return s.removeMember(roomID, targetID)
+}
+
+// SendMessage 发送群消息：成员且未被禁言；可选引用回复；解析@并落提醒通知。
+func (s *ChatService) SendMessage(senderID, roomID uint, content string, replyToID uint) (*model.ChatMessage, []uint, error) {
+	content = strings.TrimSpace(content)
+	if content == "" {
+		return nil, nil, ErrChatContentEmpty
+	}
+	if len([]rune(content)) > chatMsgMaxRune {
+		return nil, nil, ErrChatContentTooLong
+	}
+	if _, err := s.getRoom(roomID); err != nil {
+		return nil, nil, err
+	}
+	m, err := s.membership(s.db, roomID, senderID)
+	if err != nil {
+		return nil, nil, err
+	}
+	if m.Muted {
+		return nil, nil, ErrChatMuted
+	}
+
+	replySnap := ""
+	if replyToID > 0 {
+		var quoted model.ChatMessage
+		if err := s.db.Where("id = ? AND room_id = ?", replyToID, roomID).
+			Preload("Sender").First(&quoted).Error; err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return nil, nil, ErrChatMsgNotFound
+			}
+			return nil, nil, err
+		}
+		name := quoted.Sender.Nickname
+		if name == "" {
+			name = quoted.Sender.Username
+		}
+		if quoted.RecalledAt != nil {
+			replySnap = name + ": （已撤回的消息）"
+		} else {
+			snippet := quoted.Content
+			rs := []rune(snippet)
+			if len(rs) > 80 {
+				snippet = string(rs[:80]) + "…"
+			}
+			replySnap = name + ": " + snippet
+		}
+	}
+
+	mentionIDs := s.resolveMentions(roomID, senderID, content)
+
+	msg := &model.ChatMessage{
+		RoomID:     roomID,
+		SenderID:   senderID,
+		Content:    content,
+		ReplyToID:  replyToID,
+		ReplySnap:  replySnap,
+		MentionIDs: joinMentionIDs(mentionIDs),
+	}
+	err = s.db.Transaction(func(tx *gorm.DB) error {
+		if err := tx.Create(msg).Error; err != nil {
+			return err
+		}
+		return tx.Model(&model.ChatRoom{}).Where("id = ?", roomID).
+			Updates(map[string]interface{}{
+				"last_message_id": msg.ID,
+				"updated_at":      time.Now(),
+			}).Error
+	})
+	if err != nil {
+		return nil, nil, err
+	}
+	if err := s.db.Preload("Sender").First(msg, msg.ID).Error; err != nil {
+		return nil, nil, err
+	}
+	for _, uid := range mentionIDs {
+		s.notif.CreateMention(uid, senderID, roomID, msg.ID, content)
+	}
+	return msg, mentionIDs, nil
+}
+
+// resolveMentions 文本中 @用户名 → 群成员用户 ID（去重、排除自己、上限 20）
+func (s *ChatService) resolveMentions(roomID, senderID uint, content string) []uint {
+	matches := chatMentionRe.FindAllStringSubmatch(content, -1)
+	if len(matches) == 0 {
+		return nil
+	}
+	nameSet := make(map[string]struct{}, len(matches))
+	names := make([]string, 0, len(matches))
+	for _, mt := range matches {
+		name := strings.ToLower(mt[1])
+		if _, ok := nameSet[name]; ok {
+			continue
+		}
+		nameSet[name] = struct{}{}
+		names = append(names, name)
+	}
+	if len(names) == 0 {
+		return nil
+	}
+	// 用户名大小写不敏感匹配（注册名唯一但比较时统一 lower）
+	var users []model.User
+	s.db.Where("LOWER(username) IN ? AND banned = ?", names, false).Find(&users)
+	if len(users) == 0 {
+		return nil
+	}
+	userIDs := make([]uint, 0, len(users))
+	for _, u := range users {
+		userIDs = append(userIDs, u.ID)
+	}
+	var memberIDs []uint
+	s.db.Model(&model.ChatRoomMember{}).
+		Where("room_id = ? AND user_id IN ?", roomID, userIDs).
+		Pluck("user_id", &memberIDs)
+	seen := make(map[uint]struct{}, len(memberIDs))
+	out := make([]uint, 0, len(memberIDs))
+	for _, id := range memberIDs {
+		if id == senderID {
+			continue
+		}
+		if _, ok := seen[id]; ok {
+			continue
+		}
+		seen[id] = struct{}{}
+		out = append(out, id)
+		if len(out) >= chatMentionMax {
+			break
+		}
+	}
+	return out
+}
+
+func joinMentionIDs(ids []uint) string {
+	if len(ids) == 0 {
+		return ""
+	}
+	parts := make([]string, len(ids))
+	for i, id := range ids {
+		parts[i] = strconv.FormatUint(uint64(id), 10)
+	}
+	return strings.Join(parts, ",")
+}
+
+// ListMessages 历史消息分页：成员或监管者可取；已撤回消息仍返回（前端显示占位）
+func (s *ChatService) ListMessages(userID, roomID, beforeID uint, size int, oversee bool) ([]model.ChatMessage, bool, error) {
+	if size < 1 || size > 50 {
+		size = 30
+	}
+	if _, err := s.getRoom(roomID); err != nil {
+		return nil, false, err
+	}
+	if !oversee {
+		if _, err := s.membership(s.db, roomID, userID); err != nil {
+			return nil, false, err
+		}
+	}
+	q := s.db.Where("room_id = ?", roomID)
+	if beforeID > 0 {
+		q = q.Where("id < ?", beforeID)
+	}
+	var msgs []model.ChatMessage
+	if err := q.Order("id DESC").Limit(size + 1).Preload("Sender").Find(&msgs).Error; err != nil {
+		return nil, false, err
+	}
+	hasMore := len(msgs) > size
+	if hasMore {
+		msgs = msgs[:size]
+	}
+	for i, j := 0, len(msgs)-1; i < j; i, j = i+1, j-1 {
+		msgs[i], msgs[j] = msgs[j], msgs[i]
+	}
+	// 对非监管者清空已撤回正文
+	if !oversee {
+		for i := range msgs {
+			if msgs[i].RecalledAt != nil {
+				msgs[i].Content = ""
+			}
+		}
+	}
+	return msgs, hasMore, nil
+}
+
+// RecallMessage 撤回消息：群主可撤自己的；监管者可撤任意；标记 RecalledAt 不清行
+func (s *ChatService) RecallMessage(operatorID, roomID, messageID uint, oversee bool) (*model.ChatMessage, error) {
+	if _, err := s.getRoom(roomID); err != nil {
+		return nil, err
+	}
+	var msg model.ChatMessage
+	if err := s.db.Where("id = ? AND room_id = ?", messageID, roomID).First(&msg).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, ErrChatMsgNotFound
+		}
+		return nil, err
+	}
+	if msg.RecalledAt != nil {
+		return &msg, nil // 幂等
+	}
+	if !oversee {
+		m, err := s.membership(s.db, roomID, operatorID)
+		if err != nil {
+			return nil, err
+		}
+		// 群主/成员仅可撤回自己的消息；监管者可撤任意
+		if msg.SenderID != operatorID {
+			_ = m // 成员校验已通过
+			return nil, ErrChatRecallDenied
+		}
+	}
+	now := time.Now()
+	if err := s.db.Model(&msg).Updates(map[string]interface{}{
+		"recalled_at": now,
+		"recalled_by": operatorID,
+		"content":     "",
+	}).Error; err != nil {
+		return nil, err
+	}
+	msg.RecalledAt = &now
+	msg.RecalledBy = operatorID
+	msg.Content = ""
+	_ = s.db.Preload("Sender").First(&msg, msg.ID)
+	return &msg, nil
+}
+
+// MarkRead 把已读水位推进到指定消息（单调不减；messageID=0 或超过最新则取最新）
+func (s *ChatService) MarkRead(userID, roomID, messageID uint) error {
+	room, err := s.getRoom(roomID)
+	if err != nil {
+		return err
+	}
+	if _, err := s.membership(s.db, roomID, userID); err != nil {
+		return err
+	}
+	if messageID == 0 || messageID > room.LastMessageID {
+		messageID = room.LastMessageID
+	}
+	return s.db.Model(&model.ChatRoomMember{}).
+		Where("room_id = ? AND user_id = ? AND last_read_message_id < ?", roomID, userID, messageID).
+		Update("last_read_message_id", messageID).Error
+}
+
+// UnreadSummary 当前用户所有群的未读明细与总数
+func (s *ChatService) UnreadSummary(userID uint) (int64, []UnreadRoom, error) {
+	var rows []UnreadRoom
+	err := s.db.Table("chat_messages AS m").
+		Select("m.room_id AS room_id, count(*) AS cnt").
+		Joins("JOIN chat_room_members AS rm ON rm.room_id = m.room_id AND rm.user_id = ?", userID).
+		Where("m.id > rm.last_read_message_id AND m.deleted_at IS NULL AND m.recalled_at IS NULL").
+		Group("m.room_id").
+		Scan(&rows).Error
+	if err != nil {
+		return 0, nil, err
+	}
+	var total int64
+	for _, r := range rows {
+		total += r.Count
+	}
+	return total, rows, nil
+}
+
+// TotalUnread 供 /me SSR 一次调用（Header 红点直出）
+func (s *ChatService) TotalUnread(userID uint) int64 {
+	total, _, _ := s.UnreadSummary(userID)
+	return total
+}
--- a/backend/service/comment.go
+++ b/backend/service/comment.go
@@ -35,16 +35,16 @@ const maxReplyDepth = 10

 // ListFloorPaged 楼层分页获取帖子评论树：
 // 分页与楼层号只针对主评论（parent_id IS NULL），每楼附带全部子评论（时间正序）。
+// viewer 可为作者本人或该板可审者时并入 pending；游客仅 published。
 // 返回：树根列表、楼层数、全部评论数（含回复）。
-func (s *CommentService) ListFloorPaged(postID uint, page, size int) ([]CommentNode, int64, int64, error) {
+func (s *CommentService) ListFloorPaged(postID, boardID, viewerID uint, actor *Actor, page, size int) ([]CommentNode, int64, int64, error) {
 	if page < 1 {
 		page = 1
 	}
 	if size < 1 || size > 100 {
 		size = 20
 	}
-	base := s.db.Model(&model.Comment{}).
-		Where("post_id = ? AND status = ?", postID, model.ContentStatusPublished)
+	base := applyCommentListVisibility(s.db.Model(&model.Comment{}).Where("post_id = ?", postID), boardID, viewerID, actor)

 	var floors, totalComments int64
 	if err := base.Session(&gorm.Session{}).
@@ -75,11 +75,9 @@ func (s *CommentService) ListFloorPaged(postID uint, page, size int) ([]CommentN
 	for i, r := range roots {
 		rootIDs[i] = r.ID
 	}
+	replyQ := applyCommentListVisibility(s.db.Where("root_id IN (?)", rootIDs), boardID, viewerID, actor)
 	var replies []model.Comment
-	if err := s.db.Where("root_id IN (?) AND status = ?", rootIDs, model.ContentStatusPublished).
-		Order("created_at ASC").
-		Preload("User").
-		Find(&replies).Error; err != nil {
+	if err := replyQ.Order("created_at ASC").Preload("User").Find(&replies).Error; err != nil {
 		return nil, 0, 0, err
 	}

@@ -120,6 +118,20 @@ func (s *CommentService) ListFloorPaged(postID uint, page, size int) ([]CommentN
 	return result, floors, totalComments, nil
 }

+// applyCommentListVisibility 评论流可见性：published，或 pending 且（作者 / 该板可审）
+func applyCommentListVisibility(db *gorm.DB, boardID, viewerID uint, actor *Actor) *gorm.DB {
+	if viewerID == 0 || actor == nil {
+		return db.Where("status = ?", model.ContentStatusPublished)
+	}
+	if actor.CanModerateBoard(boardID) {
+		return db.Where("status IN ?", []string{model.ContentStatusPublished, model.ContentStatusPending})
+	}
+	return db.Where(
+		"status = ? OR (status = ? AND user_id = ?)",
+		model.ContentStatusPublished, model.ContentStatusPending, viewerID,
+	)
+}
+
 // Create 创建评论（parentID 为 nil 时发主评论/楼层，否则发为对应评论的子回复）。
 // status 由 handler 按角色计算：管理团队直发 published，普通用户进入 pending；
 // pending 评论不计入 comment_count，审核通过时才 +1。
--- a/backend/service/moderation.go
+++ b/backend/service/moderation.go
@@ -158,9 +158,9 @@ func (s *ModerationService) PendingCounts(actor *Actor) (posts int64, comments i
 	return
 }

-// ApprovePost 帖子审核通过
-func (s *ModerationService) ApprovePost(actor *Actor, id uint) error {
-	return s.db.Transaction(func(tx *gorm.DB) error {
+// ApprovePost 帖子审核通过；成功时返回板块 ID 供 feed 广播
+func (s *ModerationService) ApprovePost(actor *Actor, id uint) (boardID uint, err error) {
+	err = s.db.Transaction(func(tx *gorm.DB) error {
 		var post model.Post
 		if err := tx.First(&post, id).Error; err != nil {
 			return err
@@ -174,10 +174,12 @@ func (s *ModerationService) ApprovePost(actor *Actor, id uint) error {
 		if err := tx.Model(&post).Update("status", model.ContentStatusPublished).Error; err != nil {
 			return err
 		}
+		boardID = post.BoardID
 		s.notif.Create(post.UserID, actor.ID, model.NotificationTypeApproved, post.ID, 0,
 			"你的帖子《"+post.Title+"》已通过审核")
 		return nil
 	})
+	return boardID, err
 }

 // RejectPost 帖子审核拒绝（标记 rejected，不物理删除；作者仍可在详情页看到结果）
@@ -202,15 +204,15 @@ func (s *ModerationService) RejectPost(actor *Actor, id uint) error {
 	})
 }

-// ApproveComment 评论审核通过（通过时才计入帖子评论数）
-func (s *ModerationService) ApproveComment(actor *Actor, id uint) error {
-	return s.db.Transaction(func(tx *gorm.DB) error {
+// ApproveComment 评论审核通过（通过时才计入帖子评论数）；成功时返回帖子 ID 与板块 ID
+func (s *ModerationService) ApproveComment(actor *Actor, id uint) (postID, boardID uint, err error) {
+	err = s.db.Transaction(func(tx *gorm.DB) error {
 		var cm model.Comment
 		if err := tx.First(&cm, id).Error; err != nil {
 			return err
 		}
 		var post model.Post
-		if err := tx.Select("id", "board_id", "title").First(&post, cm.PostID).Error; err != nil {
+		if err := tx.Select("id", "board_id", "title", "user_id").First(&post, cm.PostID).Error; err != nil {
 			return err
 		}
 		if !actor.CanModerateBoard(post.BoardID) {
@@ -226,6 +228,8 @@ func (s *ModerationService) ApproveComment(actor *Actor, id uint) error {
 			UpdateColumn("comment_count", gorm.Expr("comment_count + 1")).Error; err != nil {
 			return err
 		}
+		postID = cm.PostID
+		boardID = post.BoardID
 		s.notif.Create(cm.UserID, actor.ID, model.NotificationTypeApproved, cm.PostID, cm.ID,
 			"你在帖子《"+post.Title+"》下的评论已通过审核")
 		// 评论此时才公开，补发送业务通知（以评论者为 actor）：
@@ -240,6 +244,7 @@ func (s *ModerationService) ApproveComment(actor *Actor, id uint) error {
 		}
 		return nil
 	})
+	return postID, boardID, err
 }

 // RejectComment 评论审核拒绝
--- a/backend/service/notification.go
+++ b/backend/service/notification.go
@@ -8,6 +8,8 @@ import (
 // NotificationService 通知服务
 type NotificationService struct {
 	db *gorm.DB
+	// OnNotifyNew 落库成功后回调（用于 WS 推送红点）；可为 nil
+	OnNotifyNew func(userID uint)
 }

 func NewNotificationService(db *gorm.DB) *NotificationService {
@@ -33,7 +35,38 @@ func (s *NotificationService) Create(userID, actorID uint, notifType string, pos
 		IsRead:    false,
 	}
 	// 通知创建失败不影响主流程，忽略错误
-	_ = s.db.Create(n).Error
+	if err := s.db.Create(n).Error; err != nil {
+		return
+	}
+	if s.OnNotifyNew != nil {
+		s.OnNotifyNew(userID)
+	}
+}
+
+// CreateMention 创建群聊 @ 提醒（PostID=0，用 RoomID/MessageID 关联）。
+// 返回创建出的通知 ID（0 表示未创建），供 handler 实时推送。
+func (s *NotificationService) CreateMention(userID, actorID, roomID, messageID uint, content string) uint {
+	if userID == 0 || actorID == 0 || userID == actorID || roomID == 0 {
+		return 0
+	}
+	if runes := []rune(content); len(runes) > 100 {
+		content = string(runes[:100])
+	}
+	n := &model.Notification{
+		UserID:    userID,
+		ActorID:   actorID,
+		Type:      model.NotificationTypeMention,
+		RoomID:    roomID,
+		MessageID: messageID,
+		Content:   content,
+	}
+	if err := s.db.Create(n).Error; err != nil {
+		return 0
+	}
+	if s.OnNotifyNew != nil {
+		s.OnNotifyNew(userID)
+	}
+	return n.ID
 }

 // List 获取用户通知列表（分页，按时间倒序）
@@ -52,7 +85,7 @@ func (s *NotificationService) List(userID uint, page, size int) ([]model.Notific
 	var list []model.Notification
 	offset := (page - 1) * size
 	if err := query.Order("created_at DESC").Offset(offset).Limit(size).
-		Preload("Actor").Preload("Post").Find(&list).Error; err != nil {
+		Preload("Actor").Preload("Post").Preload("Room").Find(&list).Error; err != nil {
 		return nil, 0, err
 	}
 	return list, total, nil
--- a/backend/service/post.go
+++ b/backend/service/post.go
@@ -29,9 +29,11 @@ type PostListQuery struct {
 	BoardID     uint
 	Page        int
 	Size        int
-	Sort        string // latest | hot
+	Sort        string // latest | hot | new
 	Keyword     string // 搜索关键词
 	Recommended bool   // 仅精华帖
+	ViewerID    uint   // 当前查看者（0=游客）
+	Actor       *Actor // 查看者权限快照；nil 仅 published
 }

 // toPostListItems 将 Post 模型批量转为不含正文的列表项
@@ -42,7 +44,7 @@ func toPostListItems(posts []model.Post) []PostListItem {
 			ID: p.ID, BoardID: p.BoardID, UserID: p.UserID,
 			Title: p.Title, Tags: p.Tags, PostType: p.PostType,
 			Pinned: p.Pinned, Recommended: p.Recommended, LikeCount: p.LikeCount, ViewCount: p.ViewCount,
-			CommentCount: p.CommentCount, CreatedAt: p.CreatedAt,
+			CommentCount: p.CommentCount, Status: p.Status, CreatedAt: p.CreatedAt,
 			Board: p.Board, User: p.User,
 		})
 	}
@@ -76,6 +78,7 @@ type PostListItem struct {
 	LikeCount    int            `json:"like_count"`
 	ViewCount    int            `json:"view_count"`
 	CommentCount int            `json:"comment_count"`
+	Status       string         `json:"status"`
 	Liked        bool           `json:"liked"`
 	CreatedAt    time.Time      `json:"created_at"`
 	LastReply    *LastReplyInfo `json:"last_reply,omitempty"`
@@ -145,6 +148,26 @@ func (s *PostService) fillLastReply(items []PostListItem) {
 	}
 }

+// applyListVisibility 公开流可见性：published，或 pending 且（作者本人 / 该板可审者）
+func applyListVisibility(db *gorm.DB, viewerID uint, actor *Actor) *gorm.DB {
+	if viewerID == 0 || actor == nil {
+		return db.Where("status = ?", model.ContentStatusPublished)
+	}
+	if model.RoleLevel(actor.Role) >= model.RoleLevel(model.RoleAdmin) {
+		return db.Where("status IN ?", []string{model.ContentStatusPublished, model.ContentStatusPending})
+	}
+	if actor.Role == model.RoleBoardAdmin && len(actor.BoardIDs) > 0 {
+		return db.Where(
+			"status = ? OR (status = ? AND (user_id = ? OR board_id IN ?))",
+			model.ContentStatusPublished, model.ContentStatusPending, viewerID, actor.BoardIDs,
+		)
+	}
+	return db.Where(
+		"status = ? OR (status = ? AND user_id = ?)",
+		model.ContentStatusPublished, model.ContentStatusPending, viewerID,
+	)
+}
+
 // List 获取帖子列表
 func (s *PostService) List(q PostListQuery) ([]PostListItem, int64, error) {
 	if q.Page < 1 {
@@ -154,7 +177,7 @@ func (s *PostService) List(q PostListQuery) ([]PostListItem, int64, error) {
 		q.Size = 20
 	}

-	query := s.db.Model(&model.Post{}).Where("status = ?", model.ContentStatusPublished)
+	query := applyListVisibility(s.db.Model(&model.Post{}), q.ViewerID, q.Actor)
 	if q.BoardID > 0 {
 		query = query.Where("board_id = ?", q.BoardID)
 	}
@@ -196,15 +219,26 @@ func (s *PostService) List(q PostListQuery) ([]PostListItem, int64, error) {
 	return items, total, nil
 }

-// ListByUser 获取指定用户发布的帖子（公开已发布）
-func (s *PostService) ListByUser(userID uint, page, size int) ([]PostListItem, int64, error) {
+// ListByUser 获取指定用户发布的帖子。
+// viewer 为本人或全站可审者时并入 pending；板块管理员仅并入其授权板的 pending。
+func (s *PostService) ListByUser(userID, viewerID uint, actor *Actor, page, size int) ([]PostListItem, int64, error) {
 	if page < 1 {
 		page = 1
 	}
 	if size < 1 || size > 50 {
 		size = 20
 	}
-	query := s.db.Model(&model.Post{}).Where("user_id = ? AND status = ?", userID, model.ContentStatusPublished)
+	query := s.db.Model(&model.Post{}).Where("user_id = ?", userID)
+	if viewerID == userID || (actor != nil && model.RoleLevel(actor.Role) >= model.RoleLevel(model.RoleAdmin)) {
+		query = query.Where("status IN ?", []string{model.ContentStatusPublished, model.ContentStatusPending})
+	} else if actor != nil && actor.Role == model.RoleBoardAdmin && len(actor.BoardIDs) > 0 {
+		query = query.Where(
+			"status = ? OR (status = ? AND board_id IN ?)",
+			model.ContentStatusPublished, model.ContentStatusPending, actor.BoardIDs,
+		)
+	} else {
+		query = query.Where("status = ?", model.ContentStatusPublished)
+	}
 	var total int64
 	if err := query.Count(&total).Error; err != nil {
 		return nil, 0, err
@@ -229,6 +263,15 @@ func (s *PostService) GetAuthorID(postID uint) (uint, error) {
 	return post.UserID, nil
 }

+// GetBoardID 获取帖子所属板块 ID（不增加浏览量）
+func (s *PostService) GetBoardID(postID uint) (uint, error) {
+	var post model.Post
+	if err := s.db.Select("board_id").First(&post, postID).Error; err != nil {
+		return 0, err
+	}
+	return post.BoardID, nil
+}
+
 // CountByUser 统计用户发帖数
 func (s *PostService) CountByUser(userID uint) (int64, error) {
 	var total int64
--- a/backend/service/ratelimit.go
+++ b/backend/service/ratelimit.go
@@ -66,6 +66,7 @@ const (
 	RateRegister = "register"
 	RatePost     = "post"
 	RateComment  = "comment"
+	RateChat     = "chat" // 群聊发消息
 )

 // DefaultRateLimiter 创建默认速率限制器
@@ -75,5 +76,6 @@ func DefaultRateLimiter() *RateLimiter {
 	rl.SetLimit(RateRegister, 10) // 注册 10/分钟
 	rl.SetLimit(RatePost, 10)     // 发帖 10/分钟
 	rl.SetLimit(RateComment, 30)  // 评论 30/分钟
+	rl.SetLimit(RateChat, 30)     // 群聊消息 30/分钟
 	return rl
 }