import type { Conversation, GroupLite, Message, QuoteMessage, User } from '../home/types'
|
|
import { useUserStore } from '#/packages/stores/src'
|
|
import { getCurrentUserId } from '#/views/im/utils/auth'
|
|
import { useFriendStore } from '../home/store/friendStore'
|
import { useGroupStore } from '../home/store/groupStore'
|
import {
|
ImContentType,
|
ImConversationType,
|
type ImConversationTypeValue,
|
ImRtcCallEndReason
|
} from './constants'
|
import { formatCallDuration } from './time'
|
|
export type { QuoteMessage } from '../home/types'
|
|
// ====================================================================
|
// IM 消息 content 编解码 & 展示工具
|
// ====================================================================
|
// 约定：消息的 content 字段统一存 JSON 字符串，字段名、结构对齐后端
|
// cn.iocoder.yudao.module.im.service.websocket.notification.message.* 下的 DTO。
|
// 各类消息 payload interface 字段对齐后端；解析统一用 parseMessage<T>，
|
// 序列化直接 JSON.stringify(payload)。
|
// ====================================================================
|
|
// ==================== 客户端 ID ====================
|
|
/** 生成客户端消息 ID（纯 UUID），用于前端去重 & ACK 回写 */
|
export const generateClientMessageId = (): string => {
|
if (globalThis.crypto?.randomUUID) {
|
return globalThis.crypto.randomUUID()
|
}
|
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replaceAll(/[xy]/g, (char) => {
|
const random = Math.trunc(Math.random() * 16)
|
const value = char === 'x' ? random : (random & 0x3) | 0x8
|
return value.toString(16)
|
})
|
}
|
|
// ==================== 私聊对端 userId ====================
|
|
/**
|
* 私聊消息 / DTO 的对端 userId：自己发的对端是 receiver，别人发的对端是 sender
|
*
|
* 收口 4 处旧 inline（websocketStore.convertPrivateMessage / handlePrivateMessage / computeFriendPeerId
|
* 和 useMessagePuller.getPrivatePeerId），结构类型只要 senderId / receiverId 两个字段，REST 与 WS DTO 都满足
|
*/
|
export function getPrivateMessagePeerId(
|
message: { receiverId: number; senderId: number; },
|
currentUserId: number
|
): number {
|
return message.senderId === currentUserId ? message.receiverId : message.senderId
|
}
|
|
// ==================== 文本片段（tip 文案 + TEXT 气泡共用） ====================
|
// 既用于灰条 tip（"XX 邀请 YY 加入群聊"），也用于 TEXT 气泡正文（@xxx 高亮 + URL 自动识别）。
|
// mention 段携带 userId 用于挂点击弹 UserInfoCard；link 段携带 href 用于 <a> 跳转；
|
// text 段是纯文本兜底。渲染层（tip-segments.vue）按 type 分发统一处理。
|
|
export type TipSegment =
|
| { href: string; text: string; type: 'link'; }
|
| { text: string; type: 'mention'; userId: number; }
|
| { text: string; type: 'text'; }
|
|
export const tipText = (text: string): TipSegment => ({ type: 'text', text })
|
|
export const tipMention = (userId: number, text: string): TipSegment => ({
|
type: 'mention',
|
userId,
|
text
|
})
|
|
export const tipLink = (href: string, text: string): TipSegment => ({
|
type: 'link',
|
href,
|
text
|
})
|
|
export const segmentsToText = (segments: TipSegment[]): string =>
|
segments.map((s) => s.text).join('')
|
|
/** 多个 userId 用同一个分隔符插值成 segments，每个 user 单独成 mention 段 */
|
export function joinMentionSegments(
|
userIds: number[],
|
separator: string,
|
resolveName: (userId: number) => string
|
): TipSegment[] {
|
return userIds.flatMap((id, index) =>
|
index === 0
|
? [tipMention(id, resolveName(id))]
|
: [tipText(separator), tipMention(id, resolveName(id))]
|
)
|
}
|
|
/** mention 候选；name 用于匹配文本字面量，displayName 用于覆盖渲染（不传则按 name 渲染） */
|
export interface MentionCandidate {
|
userId: number
|
/** 用来在 content 中前缀匹配的字面量（不含 @） */
|
name: string
|
/**
|
* 渲染时强制使用的显示名（不含 @）
|
*
|
* 用于「历史消息 content 里写的是备注名 / 群昵称，但接收端要按真实昵称渲染」的场景；
|
* 候选可以携带多种字面量（match 用），但 displayName 统一指向 nickname，
|
* 让所有历史 / 新消息的 @ 都收敛到一致的展示
|
*/
|
displayName?: string
|
/**
|
* 歧义标记：同 name 对应多个 userId 时为 true
|
*
|
* parser 仍会按 name 命中（最长优先），但命中后整段吃成普通文本——
|
* 避免「@张三」被剔除后，短前缀候选「@张」抢匹配错绑
|
*/
|
ambiguous?: boolean
|
}
|
|
/** URL 锚定正则；终止于空白、中文、@（避免吞掉下一个 mention）、< > " '（防 HTML / 引号串入）；y 标志走 sticky 匹配，省 text.slice */
|
const URL_STICKY_REGEX = /(https?:\/\/[^\s一-龥@<>"']+|www\.[^\s一-龥@<>"']+)/iy
|
|
/** URL 末尾常见标点剔除，避免吞掉句末中英文标点 */
|
const URL_TRAILING_PUNCTUATION = /[.,!?;:)\]、，。！？；：）】]+$/
|
|
/** 最短 URL：`www.ab` / `http:/` 这种孤段不算链接 */
|
const URL_MIN_LENGTH = 6
|
|
/**
|
* 文本气泡 content 拆段：mention 段按候选最长前缀匹配，URL 段走锚定正则，剩余归 text
|
*
|
* mentions 不传或匹配不上时，@xxx 退化为普通 text；解析与渲染解耦，工具函数本身不依赖 store
|
*/
|
export function parseTextSegments(text: string, mentions: MentionCandidate[] = []): TipSegment[] {
|
if (!text) {
|
return []
|
}
|
// 「@张三丰」不能被「@张三」截胡，候选按 name 长度倒序
|
const sortedMentions =
|
mentions.length > 1 ? mentions.toSorted((a, b) => b.name.length - a.name.length) : mentions
|
const out: TipSegment[] = []
|
let buffer = ''
|
|
const flush = () => {
|
if (buffer) {
|
out.push(tipText(buffer))
|
buffer = ''
|
}
|
}
|
|
let i = 0
|
while (i < text.length) {
|
if (text[i] === '@' && sortedMentions.length > 0) {
|
const matched = sortedMentions.find((m) => m.name && text.startsWith(m.name, i + 1))
|
if (matched) {
|
if (matched.ambiguous) {
|
// 同字面量对应多 userId，无法判定意图；整段累入 buffer 让短前缀候选没机会再扫这段
|
buffer += '@' + matched.name
|
} else {
|
flush()
|
// 渲染统一走 displayName（即真实昵称），让历史 content 里残留的备注 / 群昵称也收敛到 nickname
|
out.push(tipMention(matched.userId, '@' + (matched.displayName || matched.name)))
|
}
|
i += 1 + matched.name.length
|
continue
|
}
|
}
|
const head = text[i]
|
if (head === 'h' || head === 'H' || head === 'w' || head === 'W') {
|
URL_STICKY_REGEX.lastIndex = i
|
const linkMatch = URL_STICKY_REGEX.exec(text)
|
if (linkMatch) {
|
const urlText = linkMatch[0].replace(URL_TRAILING_PUNCTUATION, '')
|
if (urlText.length >= URL_MIN_LENGTH) {
|
flush()
|
const href = /^https?:\/\//i.test(urlText) ? urlText : `https://${urlText}`
|
out.push(tipLink(href, urlText))
|
i += urlText.length
|
continue
|
}
|
}
|
}
|
buffer += text[i]
|
i += 1
|
}
|
flush()
|
return out
|
}
|
|
// ==================== 引用消息 ====================
|
|
/** 引用容器：5 种普通消息(TEXT / IMAGE / FILE / VOICE / VIDEO)都可携带 quote */
|
interface Quotable {
|
quote?: QuoteMessage
|
}
|
|
// ==================== 消息 payload ====================
|
|
/** 文本消息 payload（对齐后端 TextMessage） */
|
export interface TextMessage extends Quotable {
|
content: string
|
}
|
|
/** 图片消息 payload（对齐后端 ImageMessage） */
|
export interface ImageMessage extends Quotable {
|
url: string
|
/** 缩略图 URL */
|
thumbnailUrl?: string
|
/** 图片宽度 */
|
width?: number
|
/** 图片高度 */
|
height?: number
|
/** 文件大小（字节） */
|
size?: number
|
}
|
|
/** 语音消息 payload（对齐后端 AudioMessage；ImContentType 保留 VOICE 命名） */
|
export interface AudioMessage extends Quotable {
|
url: string
|
/** 时长（秒） */
|
duration: number
|
/** 文件大小（字节） */
|
size?: number
|
}
|
|
/** 文件消息 payload（对齐后端 FileMessage） */
|
export interface FileMessage extends Quotable {
|
url: string
|
name: string
|
size: number
|
/** MIME 类型 */
|
type?: string
|
}
|
|
/** 视频消息 payload（对齐后端 VideoMessage；暂未接入渲染） */
|
export interface VideoMessage extends Quotable {
|
url: string
|
/** 封面 URL */
|
coverUrl?: string
|
/** 时长（秒） */
|
duration?: number
|
width?: number
|
height?: number
|
/** 文件大小（字节） */
|
size?: number
|
}
|
|
/**
|
* 名片消息 payload（对齐后端 CardMessage）
|
*
|
* 按 targetType 区分用户名片 / 群名片：
|
* - PRIVATE：targetId = 用户编号，name = 用户昵称（取真实昵称，非备注）
|
* - GROUP：targetId = 群编号，name = 群名，可带 memberCount
|
*/
|
export interface CardMessage extends Quotable {
|
/** 名片对象类型 */
|
targetType: ImConversationTypeValue
|
/** 目标对象编号：PRIVATE 时 = userId；GROUP 时 = groupId */
|
targetId: number
|
/** 显示名快照：PRIVATE 时 = 用户昵称；GROUP 时 = 群名 */
|
name: string
|
/** 头像（快照） */
|
avatar?: string
|
/** 群成员数（仅 targetType = GROUP；接收端展示「N 人群聊」） */
|
memberCount?: number
|
}
|
|
/**
|
* 名片转发的源对象（RecommendCardDialog 入参）；字段与 CardMessage 1:1，无 quote
|
*/
|
export type CardTarget = Omit<CardMessage, 'quote'>
|
|
/** 用户对象 → 用户名片源（PRIVATE）；缺 id 返回 null 让调用方 v-bind 绑定为不渲染 */
|
export function toUserCardTarget(user: null | undefined | User): CardTarget | null {
|
if (!user?.id) {
|
return null
|
}
|
return {
|
targetType: ImConversationType.PRIVATE,
|
targetId: user.id,
|
name: user.nickname || '',
|
avatar: user.avatar
|
}
|
}
|
|
/** 群对象 → 群名片源（GROUP）；缺 id 返回 null */
|
export function toGroupCardTarget(group: GroupLite | null | undefined): CardTarget | null {
|
if (!group?.id) {
|
return null
|
}
|
return {
|
targetType: ImConversationType.GROUP,
|
targetId: group.id,
|
name: group.name || '',
|
avatar: group.showImage || group.showImageThumb,
|
memberCount: group.memberCount
|
}
|
}
|
|
/**
|
* 名片标签 + 图标（按 targetType 二分），统一聊天气泡 / 引用预览 / 历史摘要 / 后台预览的文案与图标
|
*
|
* 缺失 / 非法 targetType 走「个人名片」兜底，避免老消息或脏数据导致 UI 空白
|
*/
|
export function getCardLabelInfo(card: null | undefined | { targetType?: number }): {
|
icon: string
|
label: string
|
} {
|
if (card?.targetType === ImConversationType.GROUP) {
|
return { label: '群名片', icon: 'ant-design:usergroup-outlined' }
|
}
|
return { label: '个人名片', icon: 'ant-design:user-outlined' }
|
}
|
|
/** 表情消息 payload（对齐后端 FaceMessage；Unicode emoji 仍走 TEXT，本类型只承载贴图 / 自定义表情包） */
|
export interface FaceMessage extends Quotable {
|
/** 表情图 URL */
|
url: string
|
/** 渲染宽度（像素），避免布局抖动；可选，缺失时调用方走 CSS max-w 兜底 */
|
width?: number
|
/** 渲染高度（像素），可选 */
|
height?: number
|
/** 表情名（系统包通常有，个人表情包通常无） */
|
name?: string
|
}
|
|
/** 合并转发的单条内嵌消息快照（对齐后端 MergeMessage.Item） */
|
export interface MergeMessageItem {
|
/** 原消息编号；仅做溯源标识 */
|
messageId: number
|
/** 发送人编号 */
|
senderId: number
|
/** 发送人昵称快照；对端可能不在原会话里，无法实时查到 */
|
senderNickname: string
|
/** 发送人头像快照 */
|
senderAvatar?: string
|
/** 内容类型，对齐 ImContentType */
|
type: number
|
/** 原消息 content（JSON）；嵌套合并消息时仍按本结构层层展开 */
|
content: string
|
/** 发送时间戳（毫秒） */
|
sendTime: number
|
}
|
|
/** 合并转发消息 payload（对齐后端 MergeMessage） */
|
export interface MergeMessage {
|
title: string // 合并标题；例：「张三和李四的聊天记录」「群聊的聊天记录」
|
messages: MergeMessageItem[] // 内嵌的完整消息快照
|
}
|
|
/** 频道素材消息 payload（对齐后端 MaterialMessage） */
|
export interface MaterialMessage {
|
materialId?: number
|
channelId?: number // 频道编号；转发后渲染卡片底部的频道头像 + 名称
|
title?: string
|
coverUrl?: string
|
summary?: string
|
url?: string // 跳转链接；为空时点击在客户端内置详情页按 materialId 拉 content 渲染；非空则跳 url
|
}
|
|
// ==================== 合并转发 payload 构造 ====================
|
|
/** 单个发送人的快照昵称 / 头像 */
|
interface SenderSnapshot {
|
nickname: string
|
avatar: string
|
}
|
|
/**
|
* 一次性构造 senderId → SenderSnapshot 映射；避免 N 条消息逐条 find 群成员
|
*
|
* 群聊从 group.members 一次性 indexBy；私聊只需 self + friend；外加全体 senderId 上做 friend 兜底
|
*/
|
function buildSenderSnapshotMap(
|
senderIds: number[],
|
conversation: Conversation
|
): Map<number, SenderSnapshot> {
|
const userStore = useUserStore()
|
const friendStore = useFriendStore()
|
const selfUserId = getCurrentUserId()
|
const result = new Map<number, SenderSnapshot>()
|
|
let groupMembers: Map<number, { avatar?: string; nickname: string; }> | null = null
|
if (conversation.type === ImConversationType.GROUP) {
|
const group = useGroupStore().getGroup(conversation.targetId)
|
groupMembers = new Map((group?.members || []).map((m) => [m.userId, m]))
|
}
|
|
for (const senderId of senderIds) {
|
if (result.has(senderId)) {
|
continue
|
}
|
if (senderId === selfUserId) {
|
result.set(senderId, {
|
nickname: userStore.userInfo?.nickname || String(senderId),
|
avatar: userStore.userInfo?.avatar || ''
|
})
|
continue
|
}
|
const member = groupMembers?.get(senderId)
|
if (member?.nickname) {
|
result.set(senderId, { nickname: member.nickname, avatar: member.avatar || '' })
|
continue
|
}
|
const friend = friendStore.getFriend(senderId)
|
result.set(senderId, {
|
nickname: friend?.nickname || String(senderId),
|
avatar: friend?.avatar || ''
|
})
|
}
|
return result
|
}
|
|
/** 把单条 Message 转成 MergeMessageItem 快照；剥离 quote 防引用穿透 */
|
function mapMessageToMergeItem(
|
message: Message,
|
senderSnapshots: Map<number, SenderSnapshot>
|
): MergeMessageItem {
|
const snapshot = senderSnapshots.get(message.senderId)
|
return {
|
messageId: message.id || 0,
|
senderId: message.senderId,
|
senderNickname: snapshot?.nickname ?? String(message.senderId),
|
senderAvatar: snapshot?.avatar ?? '',
|
type: message.type,
|
content: removeQuotePayload(message.content),
|
sendTime: message.sendTime
|
}
|
}
|
|
/** 合并转发标题：私聊「{对方} 和 {自己} 的聊天记录」；群聊「{群名} 的聊天记录」 */
|
export function buildMergeTitle(conversation: Conversation): string {
|
if (conversation.type === ImConversationType.GROUP) {
|
return `${conversation.name || '群聊'} 的聊天记录`
|
}
|
const myName = useUserStore().userInfo?.nickname || '我'
|
return `${conversation.name || '对方'} 和 ${myName} 的聊天记录`
|
}
|
|
/** 把一组 Message 打包成 MergeMessage payload；调用方负责按 sendTime 排序后传入 */
|
export function buildMergeMessagePayload(
|
messages: Message[],
|
conversation: Conversation
|
): MergeMessage {
|
const senderIds = messages.map((m) => m.senderId)
|
const senderSnapshots = buildSenderSnapshotMap(senderIds, conversation)
|
return {
|
title: buildMergeTitle(conversation),
|
messages: messages.map((m) => mapMessageToMergeItem(m, senderSnapshots))
|
}
|
}
|
|
/** 「添加到表情」的可发起源：FACE / IMAGE 都允许（GIF 图片也常被收藏） */
|
export interface AddableFacePayload {
|
url: string
|
width: number
|
height: number
|
name?: string
|
}
|
|
/**
|
* 从消息抽取「添加到表情」的 payload；当前内容类型不可添加返回 null
|
*
|
* 调用方（MessageItem 的右键菜单）按 nullable 决定是否展示「添加到表情」入口
|
*/
|
export function extractAddableFace(message: Message): AddableFacePayload | null {
|
if (message.type === ImContentType.FACE) {
|
const face = parseMessage<FaceMessage>(message.content)
|
if (!face?.url) {
|
return null
|
}
|
return { url: face.url, width: face.width || 200, height: face.height || 200, name: face.name }
|
}
|
if (message.type === ImContentType.IMAGE) {
|
const image = parseMessage<ImageMessage>(message.content)
|
if (!image?.url) {
|
return null
|
}
|
return { url: image.url, width: image.width || 200, height: image.height || 200 }
|
}
|
return null
|
}
|
|
/** 解析消息 content（JSON 字符串）为指定 payload，非法 JSON 返回 null */
|
export const parseMessage = <T>(content: string): null | T => {
|
try {
|
return JSON.parse(content) as T
|
} catch {
|
return null
|
}
|
}
|
|
/** 序列化消息 payload 为 content JSON 字符串；与 parseMessage 对称 */
|
export const serializeMessage = <T>(payload: T): string => JSON.stringify(payload)
|
|
/** `URL.createObjectURL(file)` 生成的 URL 前缀；占位 / revoke / 重传旧值识别共用 */
|
export const BLOB_URL_PREFIX = 'blob:'
|
|
/**
|
* 媒体 payload 里可能包含 blob URL 的字段（图片/文件/视频/语音都对齐这套 url 字段命名）
|
*
|
* 跟随 ImageMessage / VideoMessage / FileMessage / AudioMessage interface 定义同步：
|
* - url：主体资源（占位时是 blob URL，ack 后是真实 URL）
|
* - coverUrl：视频封面（commit 后是真实 URL；占位阶段不设以避免传 blob 当 poster 在部分浏览器退化）
|
* - thumbnailUrl：图片缩略图（当前未占位时使用 blob，预留）
|
*/
|
const MEDIA_BLOB_URL_FIELDS = ['url', 'coverUrl', 'thumbnailUrl'] as const
|
|
/**
|
* 释放 content 中媒体 payload 字段上的 blob URL 内存映射
|
*
|
* 仅扫描 url / coverUrl / thumbnailUrl 三个已知字段，避免 regex 全文 grep 误伤 quote.content 里嵌套的同名 blob URL。
|
* 仅对当前 document 内创建的 blob URL 有效；IndexedDB 恢复出来的旧 blob URL 已随旧 document 失效，调它无害但无意义
|
*/
|
export const revokeBlobUrlsInContent = (content: string): void => {
|
if (!content || !content.includes(BLOB_URL_PREFIX)) {
|
return
|
}
|
const payload = parseMessage<Record<string, unknown>>(content)
|
if (!payload) {
|
return
|
}
|
for (const field of MEDIA_BLOB_URL_FIELDS) {
|
const value = payload[field]
|
if (typeof value === 'string' && value.startsWith(BLOB_URL_PREFIX)) {
|
URL.revokeObjectURL(value)
|
}
|
}
|
}
|
|
// ==================== 引用消息 helper ====================
|
|
/** 把 quote 合进 payload(序列化前调用);quote 缺失时原样返回 */
|
export const withQuotePayload = <T extends Quotable>(payload: T, quote?: QuoteMessage): T => {
|
if (!quote) {
|
return payload
|
}
|
return { ...payload, quote }
|
}
|
|
/**
|
* 从 content JSON 字符串里清掉 quote 字段
|
*
|
* 客户端乐观渲染构造 quote 时调用,避免"回复一条带引用的消息"造成 quote 嵌套滚雪球;
|
* 与后端 ImMessageUtils.removeQuote 对齐
|
*/
|
export const removeQuotePayload = (content: string): string => {
|
if (!content || !content.includes('"quote"')) {
|
return content
|
}
|
const parsed = parseMessage<Record<string, unknown>>(content)
|
if (!parsed || !('quote' in parsed)) {
|
return content
|
}
|
delete parsed.quote
|
return JSON.stringify(parsed)
|
}
|
|
/** 由 Message 派生 QuoteMessage 用于乐观渲染;ack 后会被服务端权威版本覆盖 */
|
export const buildQuoteFromMessage = (message: Message): QuoteMessage => {
|
return {
|
messageId: message.id || 0,
|
senderId: message.senderId,
|
type: message.type,
|
content: removeQuotePayload(message.content)
|
}
|
}
|
|
/** 从已序列化 message.content 中解出 quote;非 JSON / 无 quote 返回 null */
|
export const getQuoteFromMessage = (content: string): null | QuoteMessage => {
|
// 长会话每条消息渲染都走 quote computed,非引用消息字符串预扫直接返回,免一次 JSON.parse
|
if (!content || !content.includes('"quote"')) {
|
return null
|
}
|
const parsed = parseMessage<Quotable>(content)
|
return parsed?.quote ?? null
|
}
|
|
// ==================== 撤回 ====================
|
|
/**
|
* 从后端下发的撤回 RecallMessage content 中解析出被撤回的原消息 id
|
* content 形如 `{"messageId": 123}`，若不含 messageId 则返回 0（表示这条不是撤回消息）
|
*/
|
export const parseRecallMessageId = (content: string): number => {
|
try {
|
const parsed = JSON.parse(content)
|
return parsed?.messageId == null ? 0 : Number(parsed.messageId)
|
} catch {
|
return 0
|
}
|
}
|
|
// ==================== 新消息提示音 ====================
|
|
import tipAudioUrl from '#/assets/audio/im/message-tip.mp3'
|
|
/**
|
* 新消息提示音，带 1 秒节流：短时间内多条消息只响一次，避免疲劳轰炸。
|
*
|
* 浏览器自动播放策略要求页面有过用户交互；若无法播放会静默失败。
|
*/
|
let __lastPlayAudioTipAt = 0
|
let __tipAudio: HTMLAudioElement | null = null
|
export const playAudioTip = () => {
|
const now = Date.now()
|
if (now - __lastPlayAudioTipAt < 1000) {
|
return
|
}
|
__lastPlayAudioTipAt = now
|
try {
|
if (!__tipAudio) {
|
__tipAudio = new Audio(tipAudioUrl)
|
__tipAudio.preload = 'auto'
|
}
|
__tipAudio.currentTime = 0
|
const playPromise = __tipAudio.play()
|
if (playPromise && typeof playPromise.catch === 'function') {
|
playPromise.catch((error) => console.debug('[IM] playAudioTip 失败', error))
|
}
|
} catch (error) {
|
console.debug('[IM] playAudioTip 失败', error)
|
}
|
}
|
|
// ==================== 文件图标 ====================
|
|
/**
|
* 按文件扩展名挑文件图标 + 颜色，对齐微信观感
|
*
|
* message-item.vue（主气泡）和 reply-preview.vue（引用预览）共用同一份映射，避免视觉两处不一致
|
*/
|
export function getFileIconInfo(filename: string | undefined): { color: string; icon: string; } {
|
const ext = (filename || '').split('.').pop()?.toLowerCase() || ''
|
if (ext === 'pdf') {
|
return { icon: 'ant-design:file-pdf-filled', color: '#ed5757' }
|
}
|
if (['doc', 'docx'].includes(ext)) {
|
return { icon: 'ant-design:file-word-filled', color: '#2b7cd3' }
|
}
|
if (['xls', 'xlsx'].includes(ext)) {
|
return { icon: 'ant-design:file-excel-filled', color: '#1f7244' }
|
}
|
if (['ppt', 'pptx'].includes(ext)) {
|
return { icon: 'ant-design:file-ppt-filled', color: '#d24726' }
|
}
|
if (['7z', 'gz', 'rar', 'tar', 'zip'].includes(ext)) {
|
return { icon: 'ant-design:file-zip-filled', color: '#f0ad4e' }
|
}
|
if (['bmp', 'gif', 'jpeg', 'jpg', 'png', 'svg', 'webp'].includes(ext)) {
|
return { icon: 'ant-design:file-image-filled', color: '#9c27b0' }
|
}
|
if (['avi', 'flv', 'mkv', 'mov', 'mp4', 'wmv'].includes(ext)) {
|
return { icon: 'ant-design:video-camera-filled', color: '#9c27b0' }
|
}
|
if (['aac', 'flac', 'mp3', 'ogg', 'wav'].includes(ext)) {
|
return { icon: 'ant-design:audio-filled', color: '#9c27b0' }
|
}
|
if (['json', 'log', 'md', 'txt', 'xml'].includes(ext)) {
|
return { icon: 'ant-design:file-text-filled', color: '#909399' }
|
}
|
return { icon: 'ant-design:file-filled', color: '#909399' }
|
}
|
|
// ==================== 管理后台展示工具 ====================
|
|
/** 详情弹窗里把 content JSON 美化成 2 缩进 */
|
export const formatJson = (content?: string): string => {
|
if (!content) return ''
|
try {
|
return JSON.stringify(JSON.parse(content), null, 2)
|
} catch {
|
return content
|
}
|
}
|
|
// ==================== 群广播事件 payload + 文案 ====================
|
|
// 群广播事件 payload；对齐后端 GroupNotificationMessage 子类聚合字段
|
export type GroupNotificationPayload = {
|
addSource?: number
|
// 全群封禁
|
banned?: boolean
|
displayUserName?: string
|
// 自由进群事件
|
entrantUserId?: number
|
memberUserIds?: number[]
|
// PIN 事件携带的被置顶消息展示数据
|
message?: {
|
atUserIds?: number[]
|
content: string
|
groupId: number
|
id: number
|
receiverUserIds?: number[]
|
senderId: number
|
sendTime: string
|
type: number
|
}
|
messageId?: number
|
// 禁言事件
|
mutedUserId?: number
|
muteEndTime?: string
|
newAvatar?: string
|
newJoinApproval?: boolean
|
newName?: string
|
newNotice?: string
|
newOwnerUserId?: number
|
oldAvatar?: string
|
oldJoinApproval?: boolean
|
oldName?: string
|
oldNotice?: string
|
operatorUserId?: number
|
}
|
|
/**
|
* 群广播事件 segments
|
*
|
* resolveName 由调用方注入（默认场景传 getSenderDisplayName）；
|
* operatorNameOverride 仅覆盖 operator 段文案，mention userId 仍用 payload.operatorUserId
|
*/
|
export function resolveGroupNotificationSegments(
|
message: { content?: string; targetId?: number; type?: number; },
|
resolveName: (userId: number) => string,
|
operatorNameOverride?: string
|
): TipSegment[] {
|
let payload: GroupNotificationPayload
|
try {
|
payload = JSON.parse(message.content || '{}')
|
} catch {
|
return []
|
}
|
// ENTER 主语是 entrant 而非 operator，独立处理；其它 case 都以 operatorUserId 为主语
|
if (message.type === ImContentType.GROUP_MEMBER_ENTER) {
|
const entrantId = payload.entrantUserId ?? payload.operatorUserId
|
return entrantId ? [tipMention(entrantId, resolveName(entrantId)), tipText(' 加入了群聊')] : []
|
}
|
if (!payload.operatorUserId) {
|
return []
|
}
|
const operatorSegment = tipMention(
|
payload.operatorUserId,
|
operatorNameOverride ?? resolveName(payload.operatorUserId)
|
)
|
const memberSegments = joinMentionSegments(payload.memberUserIds || [], '、', resolveName)
|
|
switch (message.type) {
|
case ImContentType.GROUP_ADMIN_ADD: {
|
return [operatorSegment, tipText(' 将 '), ...memberSegments, tipText(' 设为管理员')]
|
}
|
case ImContentType.GROUP_ADMIN_REMOVE: {
|
return [operatorSegment, tipText(' 撤销了 '), ...memberSegments, tipText(' 的管理员身份')]
|
}
|
case ImContentType.GROUP_BANNED: {
|
return [operatorSegment, tipText(payload.banned ? ' 封禁了该群' : ' 解封了该群')]
|
}
|
case ImContentType.GROUP_CANCEL_MUTED: {
|
return [operatorSegment, tipText(' 关闭了全群禁言')]
|
}
|
case ImContentType.GROUP_CREATE: {
|
return [operatorSegment, tipText(' 创建了群聊')]
|
}
|
case ImContentType.GROUP_DISSOLVE: {
|
return [operatorSegment, tipText(' 解散了群聊')]
|
}
|
case ImContentType.GROUP_INFO_UPDATE: {
|
return payload.newAvatar
|
? [operatorSegment, tipText(' 更换了群头像')]
|
: [operatorSegment, tipText(' 更新了群信息')]
|
}
|
case ImContentType.GROUP_MEMBER_CANCEL_MUTED: {
|
return payload.mutedUserId
|
? [
|
operatorSegment,
|
tipText(' 解除了 '),
|
tipMention(payload.mutedUserId, resolveName(payload.mutedUserId)),
|
tipText(' 的禁言')
|
]
|
: []
|
}
|
case ImContentType.GROUP_MEMBER_INVITE: {
|
return [operatorSegment, tipText(' 邀请 '), ...memberSegments, tipText(' 加入群聊')]
|
}
|
case ImContentType.GROUP_MEMBER_KICK: {
|
return [operatorSegment, tipText(' 移出了 '), ...memberSegments]
|
}
|
case ImContentType.GROUP_MEMBER_MUTED: {
|
return payload.mutedUserId
|
? [
|
operatorSegment,
|
tipText(' 将 '),
|
tipMention(payload.mutedUserId, resolveName(payload.mutedUserId)),
|
tipText(' 禁言')
|
]
|
: []
|
}
|
case ImContentType.GROUP_MEMBER_NICKNAME_UPDATE: {
|
return [operatorSegment, tipText(` 修改群昵称为 "${payload.displayUserName ?? ''}"`)]
|
}
|
case ImContentType.GROUP_MEMBER_QUIT: {
|
return [operatorSegment, tipText(' 退出了群聊')]
|
}
|
case ImContentType.GROUP_MESSAGE_PIN: {
|
return [operatorSegment, tipText(' 置顶了一条消息')]
|
}
|
case ImContentType.GROUP_MESSAGE_UNPIN: {
|
return [operatorSegment, tipText(' 取消了一条置顶消息')]
|
}
|
case ImContentType.GROUP_MUTED: {
|
return [operatorSegment, tipText(' 开启了全群禁言')]
|
}
|
case ImContentType.GROUP_NAME_UPDATE: {
|
return [operatorSegment, tipText(` 将群名修改为 "${payload.newName ?? ''}"`)]
|
}
|
case ImContentType.GROUP_NOTICE_UPDATE: {
|
return [operatorSegment, tipText(' 更新了群公告')]
|
}
|
case ImContentType.GROUP_OWNER_TRANSFER: {
|
return payload.newOwnerUserId
|
? [
|
operatorSegment,
|
tipText(' 已将群主转让给 '),
|
tipMention(payload.newOwnerUserId, resolveName(payload.newOwnerUserId))
|
]
|
: []
|
}
|
default: {
|
return []
|
}
|
}
|
}
|
|
/** 群广播事件中文文案 */
|
export function resolveGroupNotificationText(
|
message: { content?: string; targetId?: number; type?: number; },
|
resolveName: (userId: number) => string,
|
operatorNameOverride?: string
|
): string {
|
return segmentsToText(
|
resolveGroupNotificationSegments(message, resolveName, operatorNameOverride)
|
)
|
}
|
|
// ==================== 好友事件 ====================
|
|
/** 会话内好友事件 segments */
|
export function resolveFriendNotificationSegments(message: { type?: number }): TipSegment[] {
|
switch (message.type) {
|
case ImContentType.FRIEND_ADD: {
|
return [tipText('你们已经是好友了，开始聊天吧')]
|
}
|
case ImContentType.FRIEND_DELETE: {
|
return [tipText('你已删除好友')]
|
}
|
default: {
|
return []
|
}
|
}
|
}
|
|
/** 会话内好友事件文案：FRIEND_ADD / FRIEND_DELETE 渲染成灰色提示气泡，文案固定不依赖 payload */
|
export function resolveFriendNotificationText(message: { type?: number }): string {
|
return segmentsToText(resolveFriendNotificationSegments(message))
|
}
|
|
// ==================== RTC 通话事件 ====================
|
|
// RTC_CALL_START payload；仅群聊；用于聊天 tip 文案「{inviter} 发起了{voice/video}通话」
|
export type RtcCallStartPayload = {
|
conversationType?: number
|
inviterAvatar?: string
|
inviterNickname?: string
|
inviterUserId?: number
|
mediaType?: number
|
room?: string
|
}
|
|
// RTC_CALL_END payload；私聊准气泡 + 群聊「通话已结束 [时长 X]」共用
|
export type RtcCallEndPayload = {
|
conversationType?: number
|
durationSeconds?: number
|
endReason?: number
|
mediaType?: number
|
operatorAvatar?: string
|
operatorNickname?: string
|
operatorUserId?: number
|
room?: string
|
}
|
|
/** 解析 RTC_CALL_START / RTC_CALL_END 消息 content；解析失败返回 null */
|
export function parseRtcCallPayload(
|
content?: string
|
): null | (RtcCallEndPayload & RtcCallStartPayload) {
|
return content ? parseMessage<RtcCallEndPayload & RtcCallStartPayload>(content) : null
|
}
|
|
/**
|
* 会话内通话事件 segments（RTC_CALL_START / RTC_CALL_END）
|
* <p>
|
* 群聊两段式：START「{inviter} 发起了语音通话」+ END「语音通话已经结束」
|
* <p>
|
* 私聊气泡走 {@link resolveRtcCallPrivateBubbleText}
|
*/
|
export function resolveRtcCallTipSegments(message: {
|
content?: string
|
selfSend?: boolean
|
type?: number
|
}): TipSegment[] {
|
const payload = parseRtcCallPayload(message.content)
|
if (!payload) {
|
return []
|
}
|
if (message.type === ImContentType.RTC_CALL_START) {
|
return payload.inviterUserId
|
? [
|
tipMention(payload.inviterUserId, resolveRtcInviterLabel(payload)),
|
tipText(' 发起了语音通话')
|
]
|
: []
|
}
|
if (message.type === ImContentType.RTC_CALL_END) {
|
return [tipText('语音通话已经结束')]
|
}
|
return []
|
}
|
|
/** 取 RTC 通话发起人展示名；昵称为空时回退「用户 {id}」 */
|
function resolveRtcInviterLabel(payload: RtcCallStartPayload): string {
|
return payload.inviterNickname?.trim() || `用户 ${payload.inviterUserId ?? ''}`
|
}
|
|
/**
|
* 会话列表最后一条预览文案（RTC_CALL_START / RTC_CALL_END）
|
* <p>
|
* 私聊：START / END 都展示「[语音通话]」，对齐 [图片] / [语音] 风格
|
* <p>
|
* 群聊：START「{inviter} 发起了语音通话」、END「语音通话已经结束」，与聊天 tip 同源
|
*/
|
export function resolveRtcCallLastContent(
|
message: { content?: string; type?: number; },
|
conversationType: number
|
): string {
|
if (conversationType === ImConversationType.PRIVATE) {
|
return '[语音通话]'
|
}
|
if (message.type === ImContentType.RTC_CALL_END) {
|
return '语音通话已经结束'
|
}
|
if (message.type === ImContentType.RTC_CALL_START) {
|
const payload = parseRtcCallPayload(message.content)
|
if (payload) {
|
return `${resolveRtcInviterLabel(payload)} 发起了语音通话`
|
}
|
}
|
return ''
|
}
|
|
/**
|
* 私聊 RTC_CALL_END 气泡内文案；按 operatorUserId 是不是自己渲染两端不同文案（对齐微信）
|
* <p>
|
* 文案规则：
|
* HANGUP duration > 0 → 「通话时长 N」（双方一致）
|
* HANGUP duration ≤ 0 → 「通话中断」（未接通的兜底）
|
* CANCEL → 操作者「已取消」/ 另一方「对方已取消」
|
* REJECT → 操作者「已拒绝」/ 另一方「对方已拒绝」
|
* BUSY → 操作者「忙线未接听」/ 另一方「对方忙线中」
|
* NO_ANSWER → 操作者「未接听」/ 另一方「对方未接听」（振铃超时 Job 触发）
|
* ERROR → 「通话中断 [N]」（接通后异常断开；duration > 0 时带时长）
|
*/
|
export function resolveRtcCallPrivateBubbleText(payload: null | RtcCallEndPayload): string {
|
if (!payload) {
|
return '通话已结束'
|
}
|
const duration = payload.durationSeconds ?? 0
|
const hasDuration = duration > 0
|
const isOperator = payload.operatorUserId === getCurrentUserId()
|
switch (payload.endReason) {
|
case ImRtcCallEndReason.BUSY: {
|
return isOperator ? '忙线未接听' : '对方忙线中'
|
}
|
case ImRtcCallEndReason.CANCEL: {
|
return isOperator ? '已取消' : '对方已取消'
|
}
|
case ImRtcCallEndReason.ERROR: {
|
return hasDuration ? `通话中断 ${formatCallDuration(duration)}` : '通话中断'
|
}
|
case ImRtcCallEndReason.HANGUP: {
|
return hasDuration ? `通话时长 ${formatCallDuration(duration)}` : '通话中断'
|
}
|
case ImRtcCallEndReason.NO_ANSWER: {
|
return isOperator ? '未接听' : '对方未接听'
|
}
|
case ImRtcCallEndReason.REJECT: {
|
return isOperator ? '已拒绝' : '对方已拒绝'
|
}
|
default: {
|
return hasDuration ? `通话时长 ${formatCallDuration(duration)}` : '通话已结束'
|
}
|
}
|
}
|
|
/** 会话内通话事件文案 */
|
export function resolveRtcCallTipText(message: {
|
content?: string
|
selfSend?: boolean
|
type?: number
|
}): string {
|
return segmentsToText(resolveRtcCallTipSegments(message))
|
}
|
|
/**
|
* RTC_CALL_END 结束原因兜底文案；前端 toast / console 兜底用
|
* <p>
|
* 缺 operator 信息（同步响应 + WS push 兜底场景）时的通用文案；细分文案（按发送方视角）走 {@link resolveRtcCallPrivateBubbleText}
|
*/
|
export function resolveCallEndReasonText(reason: number | undefined): string {
|
switch (reason) {
|
case ImRtcCallEndReason.BUSY: {
|
return '对方忙线中'
|
}
|
case ImRtcCallEndReason.CANCEL: {
|
return '对方已取消'
|
}
|
case ImRtcCallEndReason.ERROR: {
|
return '通话异常'
|
}
|
case ImRtcCallEndReason.HANGUP: {
|
return '通话已结束'
|
}
|
case ImRtcCallEndReason.REJECT: {
|
return '对方已拒绝'
|
}
|
default: {
|
return '通话已断开'
|
}
|
}
|
}
|
