freefire
99c0f0319d
新增： - BrandCropModal 品牌图裁剪弹窗 + cropImage 工具 - Markdown 行内短代码（inlineShortcodes + remark 插件） - MdDetails 折叠块、MdVideo 视频块组件 - directiveBlocks/inlineShortcodes 测试 其它： - 聊天后端（handler/service chat）调整 - Markdown 渲染链路、编辑器、全局样式与品牌相关面板更新
1386 lines
44 KiB
Go
1386 lines
44 KiB
Go
// 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("大厅已置顶且不可取消")
|
||
ErrChatSiteOwnerOnly = errors.New("仅站长可任命群管理员")
|
||
ErrChatInvalidRole = errors.New("无效的群成员角色")
|
||
ErrChatMuteDenied = errors.New("无权禁言该成员")
|
||
ErrChatCannotMuteOwner = errors.New("不能禁言群主或站长")
|
||
ErrChatAdminAccess = 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
|
||
}
|
||
// 过期禁言自动解除：惰性清理，不依赖定时任务
|
||
if m.Muted && m.MutedUntil != nil && m.MutedUntil.Before(time.Now()) {
|
||
m.Muted = false
|
||
m.MutedUntil = nil
|
||
_ = tx.Model(&model.ChatRoomMember{}).
|
||
Where("room_id = ? AND user_id = ?", roomID, userID).
|
||
Select("muted", "muted_until").
|
||
Updates(map[string]interface{}{"muted": false, "muted_until": nil}).Error
|
||
}
|
||
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.sender_id <> ? AND m.deleted_at IS NULL AND m.recalled_at IS NULL AND m.is_system = ?", roomIDs, userID, false).
|
||
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 {
|
||
// 会话列表预览不向前台下发已撤回正文
|
||
if r.LastMessage != nil && r.LastMessage.RecalledAt != nil {
|
||
r.LastMessage.Content = ""
|
||
}
|
||
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").Preload("User.Badges.Badge").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 {
|
||
// 关闭私聊会硬删成员行、丢失已读水位；主动重开视为已读历史，
|
||
// 否则重建行 last_read=0 会把全部历史消息重算成未读（列表徽标闪现）
|
||
_ = s.ensureMember(existing.ID, meID, existing.LastMessageID)
|
||
_ = 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)
|
||
}
|
||
|
||
// ensureMember 保证成员行存在；重建（如私聊关闭后重开）时可选恢复已读水位
|
||
func (s *ChatService) ensureMember(roomID, userID uint, readWatermark ...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 len(readWatermark) > 0 {
|
||
m.LastReadMessageID = readWatermark[0]
|
||
}
|
||
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 && op.Role != model.ChatRoleAdmin {
|
||
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 {
|
||
if !errors.Is(err, gorm.ErrRecordNotFound) {
|
||
return err
|
||
}
|
||
// 空库首次部署时启动播种因无用户跳过，这里就地补建大厅（自愈，不依赖重启）
|
||
if err := model.EnsureDefaultChatRoom(s.db); err != nil {
|
||
return err
|
||
}
|
||
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 WHEN role = 'admin' THEN 1 ELSE 2 END, created_at ASC").
|
||
Preload("User").Preload("User.Badges.Badge").
|
||
Find(&list).Error
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return list, nil
|
||
}
|
||
|
||
// Kick 群主/群管/全站监管踢人（不能踢群主；群管不能踢其他群管）
|
||
func (s *ChatService) Kick(operatorID, roomID, targetID uint, oversee bool) error {
|
||
if _, err := s.getRoom(roomID); err != nil {
|
||
return err
|
||
}
|
||
target, err := s.membership(s.db, roomID, targetID)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if target.Role == model.ChatRoleOwner {
|
||
return ErrChatOwnerOnly
|
||
}
|
||
if !oversee {
|
||
op, err := s.membership(s.db, roomID, operatorID)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if op.Role != model.ChatRoleOwner && op.Role != model.ChatRoleAdmin {
|
||
return ErrChatOwnerOnly
|
||
}
|
||
if target.Role == model.ChatRoleAdmin && op.Role != model.ChatRoleOwner {
|
||
return ErrChatOwnerOnly
|
||
}
|
||
}
|
||
return s.removeMember(roomID, targetID)
|
||
}
|
||
|
||
// SendSystemMessage 向房间落库一条系统提示消息（sender_id=0，is_system=true）。
|
||
// 只推进房间 updated_at，不推进 last_message_id：系统提示不作为会话预览，
|
||
// 也不参与排序顶置，避免禁言/解禁等管理动作在会话列表伪装成「新消息」。
|
||
// 失败返回 nil + error。
|
||
func (s *ChatService) SendSystemMessage(roomID uint, content string) (*model.ChatMessage, error) {
|
||
msg := &model.ChatMessage{
|
||
RoomID: roomID,
|
||
SenderID: 0,
|
||
Content: content,
|
||
IsSystem: true,
|
||
CreatedAt: time.Now(),
|
||
}
|
||
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).
|
||
Update("updated_at", time.Now()).Error
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return msg, nil
|
||
}
|
||
|
||
// SetMemberMute 禁言/解禁：群主、群管、全站监管；不可禁言群主或站点站长账号。
|
||
// duration 为禁言时长；0 表示永久禁言；muted=false 时忽略 duration 并清空 muted_until。
|
||
// 返回目标用户昵称（供广播系统提示使用）。
|
||
func (s *ChatService) SetMemberMute(operatorID, roomID, targetID uint, muted bool, duration time.Duration, oversee bool) (string, error) {
|
||
room, err := s.getRoom(roomID)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
if room.RoomType == model.ChatRoomTypeDirect {
|
||
return "", ErrChatOwnerOnly
|
||
}
|
||
target, err := s.membership(s.db, roomID, targetID)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
if target.Role == model.ChatRoleOwner {
|
||
return "", ErrChatCannotMuteOwner
|
||
}
|
||
var targetUser model.User
|
||
if err := s.db.Select("role", "nickname", "username").First(&targetUser, targetID).Error; err != nil {
|
||
return "", ErrChatUserGone
|
||
}
|
||
if targetUser.Role == model.RoleOwner {
|
||
return "", ErrChatCannotMuteOwner
|
||
}
|
||
if !oversee {
|
||
op, err := s.membership(s.db, roomID, operatorID)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
if op.Role != model.ChatRoleOwner && op.Role != model.ChatRoleAdmin {
|
||
return "", ErrChatMuteDenied
|
||
}
|
||
if target.Role == model.ChatRoleAdmin && op.Role != model.ChatRoleOwner {
|
||
return "", ErrChatMuteDenied
|
||
}
|
||
}
|
||
var mutedUntil *time.Time
|
||
if muted && duration > 0 {
|
||
t := time.Now().Add(duration)
|
||
mutedUntil = &t
|
||
}
|
||
if err := s.db.Model(&model.ChatRoomMember{}).
|
||
Where("room_id = ? AND user_id = ?", roomID, targetID).
|
||
Select("muted", "muted_until").
|
||
Updates(map[string]interface{}{"muted": muted, "muted_until": mutedUntil}).Error; err != nil {
|
||
return "", err
|
||
}
|
||
targetName := targetUser.Nickname
|
||
if targetName == "" {
|
||
targetName = targetUser.Username
|
||
}
|
||
return targetName, nil
|
||
}
|
||
|
||
// SetMemberRole 仅站点站长可任命/撤销群管理员（admin <-> member）；不可改群主
|
||
func (s *ChatService) SetMemberRole(operatorSiteRole model.Role, roomID, targetID uint, role string) error {
|
||
if operatorSiteRole != model.RoleOwner {
|
||
return ErrChatSiteOwnerOnly
|
||
}
|
||
if role != model.ChatRoleAdmin && role != model.ChatRoleMember {
|
||
return ErrChatInvalidRole
|
||
}
|
||
room, err := s.getRoom(roomID)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if room.RoomType != model.ChatRoomTypeGroup {
|
||
return ErrChatOwnerOnly
|
||
}
|
||
target, err := s.membership(s.db, roomID, targetID)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if target.Role == model.ChatRoleOwner || room.OwnerID == targetID {
|
||
return ErrChatOwnerOnly
|
||
}
|
||
return s.db.Model(&model.ChatRoomMember{}).
|
||
Where("room_id = ? AND user_id = ?", roomID, targetID).
|
||
Update("role", role).Error
|
||
}
|
||
|
||
// CountAdminRooms 用户作为群管理员的群数量
|
||
func (s *ChatService) CountAdminRooms(userID uint) (int64, error) {
|
||
var n int64
|
||
err := s.db.Model(&model.ChatRoomMember{}).
|
||
Joins("JOIN chat_rooms ON chat_rooms.id = chat_room_members.room_id").
|
||
Where("chat_room_members.user_id = ? AND chat_room_members.role = ? AND chat_rooms.deleted_at IS NULL AND chat_rooms.room_type = ?",
|
||
userID, model.ChatRoleAdmin, model.ChatRoomTypeGroup).
|
||
Count(&n).Error
|
||
return n, err
|
||
}
|
||
|
||
// ListAdminRoomIDs 用户作为群管理员的群 ID 列表
|
||
func (s *ChatService) ListAdminRoomIDs(userID uint) ([]uint, error) {
|
||
var ids []uint
|
||
err := s.db.Model(&model.ChatRoomMember{}).
|
||
Joins("JOIN chat_rooms ON chat_rooms.id = chat_room_members.room_id").
|
||
Where("chat_room_members.user_id = ? AND chat_room_members.role = ? AND chat_rooms.deleted_at IS NULL AND chat_rooms.room_type = ?",
|
||
userID, model.ChatRoleAdmin, model.ChatRoomTypeGroup).
|
||
Pluck("chat_room_members.room_id", &ids).Error
|
||
return ids, err
|
||
}
|
||
|
||
// CanAccessAdminMessages 可否进入后台消息管理
|
||
func (s *ChatService) CanAccessAdminMessages(actor *Actor) bool {
|
||
if actor == nil {
|
||
return false
|
||
}
|
||
if actor.HasSiteMessagePerm() {
|
||
return true
|
||
}
|
||
n, err := s.CountAdminRooms(actor.ID)
|
||
return err == nil && n > 0
|
||
}
|
||
|
||
// isChatRoomModerator 群主或群管理员
|
||
func (s *ChatService) isChatRoomModerator(userID, roomID uint) bool {
|
||
m, err := s.membership(s.db, roomID, userID)
|
||
if err != nil {
|
||
return false
|
||
}
|
||
return m.Role == model.ChatRoleOwner || m.Role == model.ChatRoleAdmin
|
||
}
|
||
|
||
// hasSiteGroupMessagePerm 站点消息管理 flag（不含超管/站长，调用方通常已判 oversee）
|
||
func (s *ChatService) hasSiteGroupMessagePerm(userID uint) bool {
|
||
var u model.User
|
||
if err := s.db.Select("can_manage_messages").First(&u, userID).Error; err != nil {
|
||
return false
|
||
}
|
||
return u.CanManageMessages
|
||
}
|
||
|
||
// canModerateRoomMessages 可撤回他人消息 / 看已撤回正文：全站监管、站点消息管（仅群）、群主/群管
|
||
func (s *ChatService) canModerateRoomMessages(userID, roomID uint, oversee bool) bool {
|
||
if oversee {
|
||
return true
|
||
}
|
||
if s.isChatRoomModerator(userID, roomID) {
|
||
return true
|
||
}
|
||
if !s.hasSiteGroupMessagePerm(userID) {
|
||
return false
|
||
}
|
||
room, err := s.getRoom(roomID)
|
||
if err != nil {
|
||
return false
|
||
}
|
||
return room.RoomType == model.ChatRoomTypeGroup
|
||
}
|
||
|
||
// 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("ed).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
|
||
}
|
||
if err := tx.Model(&model.ChatRoom{}).Where("id = ?", roomID).
|
||
Updates(map[string]interface{}{
|
||
"last_message_id": msg.ID,
|
||
"updated_at": time.Now(),
|
||
}).Error; err != nil {
|
||
return err
|
||
}
|
||
// 发送者同步推进已读水位，避免切房时把刚发出的消息算成未读
|
||
return tx.Model(&model.ChatRoomMember{}).
|
||
Where("room_id = ? AND user_id = ? AND last_read_message_id < ?", roomID, senderID, msg.ID).
|
||
Update("last_read_message_id", msg.ID).Error
|
||
})
|
||
if err != nil {
|
||
return nil, nil, err
|
||
}
|
||
if err := s.db.Preload("Sender").Preload("Sender.Badges.Badge").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
|
||
// Sender.Badges.Badge 嵌套预加载：消息气泡需展示发送者等级与徽章（与成员列表一致）
|
||
if err := q.Order("id DESC").Limit(size + 1).Preload("Sender").Preload("Sender.Badges.Badge").Preload("Recaller").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]
|
||
}
|
||
// 已撤回正文：监管者 / 站点消息管（群）/ 群主群管保留
|
||
seeRecalled := oversee || s.canModerateRoomMessages(userID, roomID, false)
|
||
if !seeRecalled {
|
||
for i := range msgs {
|
||
if msgs[i].RecalledAt != nil {
|
||
msgs[i].Content = ""
|
||
}
|
||
}
|
||
}
|
||
return msgs, hasMore, nil
|
||
}
|
||
|
||
// RecallMessage 撤回消息：本人；或群主/群管/站点消息管（群）/全站监管可撤他人。
|
||
// newly=true 表示本次刚打上撤回标记（已撤回的幂等调用为 false，避免重复回退角标）。
|
||
func (s *ChatService) RecallMessage(operatorID, roomID, messageID uint, oversee bool) (*model.ChatMessage, bool, error) {
|
||
if _, err := s.getRoom(roomID); err != nil {
|
||
return nil, false, err
|
||
}
|
||
var msg model.ChatMessage
|
||
if err := s.db.Where("id = ? AND room_id = ?", messageID, roomID).Preload("Sender").First(&msg).Error; err != nil {
|
||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||
return nil, false, ErrChatMsgNotFound
|
||
}
|
||
return nil, false, err
|
||
}
|
||
if msg.RecalledAt != nil {
|
||
return &msg, false, nil // 幂等
|
||
}
|
||
// 站长的消息禁止群主/群管/站点消息管撤回（仅全站监管可撤回）
|
||
if msg.Sender.Role == model.RoleOwner && !oversee {
|
||
return nil, false, ErrChatRecallDenied
|
||
}
|
||
if msg.SenderID == operatorID {
|
||
if !oversee {
|
||
if _, err := s.membership(s.db, roomID, operatorID); err != nil {
|
||
return nil, false, err
|
||
}
|
||
}
|
||
} else if !s.canModerateRoomMessages(operatorID, roomID, oversee) {
|
||
return nil, false, ErrChatRecallDenied
|
||
}
|
||
now := time.Now()
|
||
if err := s.db.Model(&msg).Updates(map[string]interface{}{
|
||
"recalled_at": now,
|
||
"recalled_by": operatorID,
|
||
}).Error; err != nil {
|
||
return nil, false, err
|
||
}
|
||
msg.RecalledAt = &now
|
||
msg.RecalledBy = operatorID
|
||
// 撤回的是房间当前预览消息时，回退 last_message_id 到最近一条未撤回的非系统消息：
|
||
// 撤回不在会话列表留下「已撤回」预览，也不让房间因此停留在列表前排，避免被当成新消息提醒。
|
||
var prevID uint
|
||
_ = s.db.Model(&model.ChatMessage{}).
|
||
Where("room_id = ? AND deleted_at IS NULL AND recalled_at IS NULL AND is_system = ?", roomID, false).
|
||
Order("id DESC").Limit(1).
|
||
Select("id").Row().Scan(&prevID)
|
||
_ = s.db.Model(&model.ChatRoom{}).
|
||
Where("id = ? AND last_message_id = ?", roomID, msg.ID).
|
||
Update("last_message_id", prevID).Error
|
||
_ = s.db.Preload("Sender").Preload("Sender.Badges.Badge").Preload("Recaller").First(&msg, msg.ID)
|
||
return &msg, true, nil
|
||
}
|
||
|
||
// AdminChatParticipant 管理端私聊双方摘要
|
||
type AdminChatParticipant struct {
|
||
ID uint `json:"id"`
|
||
Name string `json:"name"`
|
||
Avatar string `json:"avatar"`
|
||
}
|
||
|
||
// AdminChatMessageItem 管理端消息监管列表项（群聊 / 大厅 / 私聊）
|
||
type AdminChatMessageItem struct {
|
||
ID uint `json:"id"`
|
||
RoomID uint `json:"room_id"`
|
||
RoomName string `json:"room_name"`
|
||
RoomType string `json:"room_type"` // group | direct
|
||
IsDefault bool `json:"is_default"`
|
||
SenderID uint `json:"sender_id"`
|
||
SenderName string `json:"sender_name"`
|
||
SenderAvatar string `json:"sender_avatar"`
|
||
Participants []AdminChatParticipant `json:"participants,omitempty"` // 私聊双方
|
||
Content string `json:"content"`
|
||
RecalledAt *time.Time `json:"recalled_at,omitempty"`
|
||
CreatedAt time.Time `json:"created_at"`
|
||
}
|
||
|
||
// AdminListMessages 按房间类型分页；scope 限制可见房间；非全站监管脱敏已撤回正文。
|
||
// actor 为站长/超管：全站；HasSiteMessagePerm：全部群聊（无私聊）；否则仅群管房间。
|
||
func (s *ChatService) AdminListMessages(actor *Actor, page int, keyword, roomType string) ([]AdminChatMessageItem, int64, error) {
|
||
if actor == nil || !s.CanAccessAdminMessages(actor) {
|
||
return nil, 0, ErrChatAdminAccess
|
||
}
|
||
if page < 1 {
|
||
page = 1
|
||
}
|
||
fullOversee := CanOverseeChat(actor.Role)
|
||
siteGroup := actor.HasSiteMessagePerm() && !fullOversee
|
||
if roomType != model.ChatRoomTypeGroup && roomType != model.ChatRoomTypeDirect {
|
||
return nil, 0, errors.New("房间类型无效")
|
||
}
|
||
// 非全站监管不可看私聊
|
||
if roomType == model.ChatRoomTypeDirect && !fullOversee {
|
||
return []AdminChatMessageItem{}, 0, nil
|
||
}
|
||
const pageSize = 15
|
||
q := s.db.Model(&model.ChatMessage{}).
|
||
Joins("JOIN chat_rooms ON chat_rooms.id = chat_messages.room_id").
|
||
Joins("LEFT JOIN users ON users.id = chat_messages.sender_id").
|
||
Where("chat_rooms.deleted_at IS NULL AND chat_messages.deleted_at IS NULL").
|
||
Where("chat_rooms.room_type = ?", roomType)
|
||
|
||
if !fullOversee && !siteGroup {
|
||
ids, err := s.ListAdminRoomIDs(actor.ID)
|
||
if err != nil {
|
||
return nil, 0, err
|
||
}
|
||
if len(ids) == 0 {
|
||
return []AdminChatMessageItem{}, 0, nil
|
||
}
|
||
q = q.Where("chat_messages.room_id IN ?", ids)
|
||
} else if siteGroup {
|
||
q = q.Where("chat_rooms.room_type = ?", model.ChatRoomTypeGroup)
|
||
}
|
||
|
||
if kw := strings.TrimSpace(keyword); kw != "" {
|
||
like := "%" + kw + "%"
|
||
q = q.Where(
|
||
`chat_messages.content ILIKE ? OR chat_rooms.name ILIKE ? OR users.nickname ILIKE ? OR users.username ILIKE ?
|
||
OR EXISTS (
|
||
SELECT 1 FROM chat_room_members crm
|
||
JOIN users mu ON mu.id = crm.user_id
|
||
WHERE crm.room_id = chat_messages.room_id
|
||
AND (mu.nickname ILIKE ? OR mu.username ILIKE ?)
|
||
)`,
|
||
like, like, like, like, like, like,
|
||
)
|
||
}
|
||
var total int64
|
||
if err := q.Count(&total).Error; err != nil {
|
||
return nil, 0, err
|
||
}
|
||
var msgs []model.ChatMessage
|
||
if err := q.Preload("Sender").
|
||
Order("chat_messages.id DESC").
|
||
Offset((page - 1) * pageSize).
|
||
Limit(pageSize).
|
||
Find(&msgs).Error; err != nil {
|
||
return nil, 0, err
|
||
}
|
||
roomIDs := make([]uint, 0, len(msgs))
|
||
seen := map[uint]struct{}{}
|
||
for _, m := range msgs {
|
||
if _, ok := seen[m.RoomID]; !ok {
|
||
seen[m.RoomID] = struct{}{}
|
||
roomIDs = append(roomIDs, m.RoomID)
|
||
}
|
||
}
|
||
roomMap := map[uint]model.ChatRoom{}
|
||
if len(roomIDs) > 0 {
|
||
var rooms []model.ChatRoom
|
||
s.db.Where("id IN ?", roomIDs).Find(&rooms)
|
||
for _, r := range rooms {
|
||
roomMap[r.ID] = r
|
||
}
|
||
}
|
||
participantsByRoom := map[uint][]AdminChatParticipant{}
|
||
if roomType == model.ChatRoomTypeDirect && len(roomIDs) > 0 {
|
||
var members []model.ChatRoomMember
|
||
s.db.Where("room_id IN ?", roomIDs).Preload("User").Preload("User.Badges.Badge").Find(&members)
|
||
for i := range members {
|
||
name := members[i].User.Nickname
|
||
if name == "" {
|
||
name = members[i].User.Username
|
||
}
|
||
if name == "" {
|
||
name = "?"
|
||
}
|
||
participantsByRoom[members[i].RoomID] = append(participantsByRoom[members[i].RoomID], AdminChatParticipant{
|
||
ID: members[i].UserID, Name: name, Avatar: members[i].User.Avatar,
|
||
})
|
||
}
|
||
}
|
||
out := make([]AdminChatMessageItem, 0, len(msgs))
|
||
for _, m := range msgs {
|
||
r := roomMap[m.RoomID]
|
||
name := r.Name
|
||
parts := participantsByRoom[r.ID]
|
||
if r.IsDefault {
|
||
name = "全站大厅"
|
||
} else if r.RoomType == model.ChatRoomTypeDirect {
|
||
names := make([]string, 0, len(parts))
|
||
for _, p := range parts {
|
||
names = append(names, p.Name)
|
||
}
|
||
if len(names) > 0 {
|
||
name = strings.Join(names, " · ")
|
||
} else if name == "" {
|
||
name = "私聊"
|
||
}
|
||
}
|
||
content := m.Content
|
||
// 后台列表：仅全站监管可见已撤回正文；群管/消息管理员在前台会话内可看
|
||
if !fullOversee && m.RecalledAt != nil {
|
||
content = ""
|
||
}
|
||
item := AdminChatMessageItem{
|
||
ID: m.ID, RoomID: m.RoomID, RoomName: name, RoomType: r.RoomType, IsDefault: r.IsDefault,
|
||
SenderID: m.SenderID, Content: content, RecalledAt: m.RecalledAt, CreatedAt: m.CreatedAt,
|
||
Participants: parts,
|
||
}
|
||
if m.Sender.ID > 0 {
|
||
item.SenderName = m.Sender.Nickname
|
||
if item.SenderName == "" {
|
||
item.SenderName = m.Sender.Username
|
||
}
|
||
item.SenderAvatar = m.Sender.Avatar
|
||
}
|
||
out = append(out, item)
|
||
}
|
||
return out, total, 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.sender_id <> ? AND m.deleted_at IS NULL AND m.recalled_at IS NULL AND m.is_system = ?", userID, false).
|
||
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
|
||
}
|