import type { Friend, FriendLite, FriendRequest } from '../types'
|
|
import type { ImFriendApi } from '#/api/im/friend'
|
import type { ImFriendRequestApi } from '#/api/im/friend/request'
|
|
import { CommonStatusEnum } from '#/packages/constants/src'
|
|
import { acceptHMRUpdate, defineStore } from 'pinia'
|
|
import { blockFriend as apiBlockFriend, deleteFriend as apiDeleteFriend, getFriend as apiGetFriend, getMyFriendList as apiGetMyFriendList, pullMyFriendList as apiPullMyFriendList, unblockFriend as apiUnblockFriend, updateFriend as apiUpdateFriend } from '#/api/im/friend'
|
import { agreeFriendRequest as apiAgreeFriendRequest, applyFriendRequest as apiApplyFriendRequest, getMyFriendRequest as apiGetMyFriendRequest, getMyFriendRequestList as apiGetMyFriendRequestList, pullMyFriendRequestList as apiPullMyFriendRequestList, refuseFriendRequest as apiRefuseFriendRequest } from '#/api/im/friend/request'
|
import { getCurrentUserId } from '#/views/im/utils/auth'
|
|
import { FRIEND_REQUEST_PAGE_SIZE } from '../../utils/config'
|
import { ImConversationType, ImFriendRequestHandleResult } from '../../utils/constants'
|
import { getDb, StorageKeys } from '../../utils/db'
|
import { runIncrementalPull } from '../../utils/pull'
|
import { getFriendDisplayName } from '../../utils/user'
|
import { useConversationStore } from './conversationStore'
|
|
type PendingRequest = { epoch: number; promise: Promise<void>; userId: number; }
|
|
/** 当前正在进行的好友列表拉取；多 dispatcher 同时触发时复用同一 Promise，避免雪崩重拉 */
|
let pendingFetchFriends: null | PendingRequest = null
|
/** 当前正在进行的好友申请列表拉取；多端连续多条申请到达时复用同一 Promise，避免雪崩重拉 */
|
let pendingFetchRequests: null | PendingRequest = null
|
/** 当前正在进行的「加载更多申请」请求 */
|
let pendingLoadMoreRequests: null | PendingRequest = null
|
/** 当前正在进行的好友详情请求 */
|
const pendingFetchFriendInfos = new Map<string, Promise<void>>()
|
|
/** clear() 时递增；旧账号那次还没返回的请求 resolve 后比对一致才写 store，防跨账号数据泄漏 */
|
let storeEpoch = 0
|
|
/** 构建好友详情请求去重 key */
|
function getPendingFriendInfoKey(userId: number, friendUserId: number): string {
|
return `${userId}:${friendUserId}`
|
}
|
|
/** 好友通知 payload（对齐后端 BaseFriendNotification + 子类裁减后的字段） */
|
export interface FriendNotificationPayload {
|
operatorUserId: number
|
friendUserId: number
|
// FRIEND_REQUEST_* 系列：申请记录的核心字段（避免 payload 携带完整 DO）
|
requestId?: number
|
applyContent?: string
|
handleContent?: string
|
addSource?: number
|
// FRIEND_REQUEST_RECEIVED：申请方聚合字段，供前端直推 push 进列表，无需回拉
|
fromNickname?: string
|
fromAvatar?: string
|
// FRIEND_UPDATE：单边属性变更
|
displayName?: string
|
silent?: boolean
|
pinned?: boolean
|
// FRIEND_DELETE：是否级联清理本端相关数据（如私聊会话）
|
clear?: boolean
|
}
|
|
/**
|
* IM 好友 Store
|
*
|
* 负责：
|
* - 拉取 / 缓存当前登录用户的好友列表 + 申请列表
|
* - 申请-审批流程（apply / agree / refuse）+ 备注 / 免打扰 / 联系人置顶 / 拉黑
|
* - 接收 WebSocket 1201-1210 段位通知，按事件分发到 friendStore 内部各 dispatcher
|
*/
|
export const useFriendStore = defineStore('imFriendStore', {
|
state: () => ({
|
friends: [] as Friend[],
|
// 仅 fetchFriendList 成功后置位；loadFriendData（IDB）不置位，否则后台 SWR 刷新会被缓存命中跳过
|
loaded: false,
|
/** 我相关的好友申请列表（含我发起的 + 别人加我的；后端按 id 倒序游标分页） */
|
friendRequests: [] as FriendRequest[],
|
/** 是否还有更早的申请记录可加载；返回不满 page size 即置 false */
|
hasMoreFriendRequests: true
|
}),
|
|
getters: {
|
/**
|
* friendUserId → Friend 的 O(1) 索引；从 friends 数组派生，Pinia 在 friends 变化时自动重算
|
*
|
* 消息渲染需要按 senderId 反查发送人头像 / 备注，每条消息渲染都会 getFriend；
|
* 直接 find 时 N 条消息 × M 好友 = O(N×M)；建索引后单次读 O(1)，重建只在写好友（fetchFriendList / upsertFriend 等）时发生
|
*/
|
getFriendMap: (state): Map<number, Friend> => {
|
const map = new Map<number, Friend>()
|
for (const friend of state.friends) {
|
map.set(friend.friendUserId, friend)
|
}
|
return map
|
},
|
/** 按 friendUserId 找好友（含已软删的 DISABLE 记录，调用方自行判定） */
|
getFriend(): (friendUserId: number) => Friend | undefined {
|
return (friendUserId: number) => this.getFriendMap.get(friendUserId)
|
},
|
/** 当前生效的好友列表（过滤掉 DISABLE 软删记录） */
|
getActiveFriendList: (state): Friend[] => {
|
return state.friends.filter((friend) => friend.status !== CommonStatusEnum.DISABLE)
|
},
|
/** 当前生效好友的 Lite 视图（PickerPanel / 选人弹窗共用，自带拼音字段供分桶 / 搜索） */
|
getActiveFriendLiteList(): FriendLite[] {
|
return this.getActiveFriendList.map((friend: Friend) => ({
|
id: friend.friendUserId,
|
nickname: friend.nickname,
|
nicknamePinyin: friend.nicknamePinyin,
|
avatar: friend.avatar,
|
displayName: friend.displayName,
|
displayNamePinyin: friend.displayNamePinyin
|
}))
|
},
|
/** 判断对方是否是当前用户的有效好友（存在 + 非 DISABLE） */
|
isActiveFriend() {
|
return (friendUserId: number): boolean => {
|
const entry = this.getFriend(friendUserId)
|
return !!entry && entry.status !== CommonStatusEnum.DISABLE
|
}
|
},
|
/** 我的黑名单（blocked=true 且 ENABLE） */
|
getBlockedFriendList: (state): Friend[] => {
|
return state.friends.filter(
|
(friend) => friend.status !== CommonStatusEnum.DISABLE && friend.blocked === true
|
)
|
},
|
/** 未处理申请数（接收方=我）—— 实时派生，「新的朋友」红点用 */
|
getUnhandledRequestCount: (state): number => {
|
const currentUserId = getCurrentUserId()
|
return state.friendRequests.filter(
|
(request) =>
|
request.handleResult === ImFriendRequestHandleResult.UNHANDLED &&
|
request.toUserId === currentUserId
|
).length
|
}
|
},
|
|
actions: {
|
// ==================== 本地缓存 ====================
|
|
/** 从 IndexedDB 恢复好友和好友申请 */
|
async loadFriendData(): Promise<boolean> {
|
try {
|
const [friends, friendRequests] = await Promise.all([
|
getDb().getAll<Friend>('friends'),
|
getDb().getAll<FriendRequest>('friendRequests')
|
])
|
if (friends.length > 0) {
|
this.friends = friends
|
}
|
if (friendRequests.length > 0) {
|
this.friendRequests = friendRequests.toSorted(
|
(requestA, requestB) => requestB.id - requestA.id
|
)
|
this.hasMoreFriendRequests = friendRequests.length >= FRIEND_REQUEST_PAGE_SIZE
|
}
|
return friends.length > 0
|
} catch (error) {
|
console.warn('[IM friendStore] 本地好友缓存读取失败', error)
|
return false
|
}
|
},
|
|
/** 保存好友列表 */
|
saveFriendList(): void {
|
void getDb()
|
.transaction(['friends'], 'readwrite', async (tx) => {
|
const db = getDb()
|
await db.clearStore('friends', tx)
|
for (const friend of this.friends) {
|
if (friend.id) {
|
await db.put('friends', friend, tx)
|
}
|
}
|
})
|
.catch((error) => console.warn('[IM friendStore] 本地好友缓存写入失败', error))
|
},
|
|
/** 保存单个好友 */
|
async saveFriendRecord(friend: Friend | undefined): Promise<void> {
|
if (!friend?.id) {
|
return
|
}
|
await getDb().put('friends', friend)
|
},
|
|
/** 保存单个好友 */
|
saveFriend(friend: Friend | undefined): void {
|
void this.saveFriendRecord(friend).catch((error) =>
|
console.warn('[IM friendStore] 本地好友写入失败', error)
|
)
|
},
|
|
/** 保存好友申请列表 */
|
saveFriendRequestList(): void {
|
void getDb()
|
.transaction(['friendRequests'], 'readwrite', async (tx) => {
|
const db = getDb()
|
await db.clearStore('friendRequests', tx)
|
for (const request of this.friendRequests) {
|
await db.put('friendRequests', request, tx)
|
}
|
})
|
.catch((error) => console.warn('[IM friendStore] 本地好友申请缓存写入失败', error))
|
},
|
|
/** 保存单条好友申请 */
|
async saveFriendRequestRecord(request: FriendRequest | undefined): Promise<void> {
|
if (!request) {
|
return
|
}
|
await getDb().put('friendRequests', request)
|
},
|
|
/** 保存单条好友申请 */
|
saveFriendRequest(request: FriendRequest | undefined): void {
|
void this.saveFriendRequestRecord(request).catch((error) =>
|
console.warn('[IM friendStore] 本地好友申请写入失败', error)
|
)
|
},
|
|
// ==================== 远端拉取 ====================
|
|
/** 从后端拉取并覆盖本地列表（含 DISABLE 历史好友给已删对话兜底）；只同步 ENABLE 的会话信息，DISABLE 的不动 —— cascade 清会话由 WS dispatcher 按 payload.clear 处理，避免 fetchFriendList 覆盖用户「不清空聊天记录」的选择 */
|
async fetchFriendList(force = false) {
|
if (this.loaded && !force) {
|
return
|
}
|
// 快照 epoch；clear() 之后到 .then 之间触发的 epoch++ 表示账号已切，旧结果不能写入新 store
|
const requestEpoch = storeEpoch
|
const requestUserId = getCurrentUserId()
|
if (
|
pendingFetchFriends?.epoch === requestEpoch &&
|
pendingFetchFriends.userId === requestUserId
|
) {
|
return pendingFetchFriends.promise
|
}
|
const promise = apiGetMyFriendList()
|
.then((list) => {
|
if (requestEpoch !== storeEpoch || getCurrentUserId() !== requestUserId) {
|
return
|
}
|
this.friends = (list || []).map((friend) => convertFriend(friend))
|
this.loaded = true
|
const conversationStore = useConversationStore()
|
for (const friend of this.friends) {
|
if (friend.status === CommonStatusEnum.DISABLE) {
|
continue
|
}
|
conversationStore.updateConversation(ImConversationType.PRIVATE, friend.friendUserId, {
|
name: getFriendDisplayName(friend),
|
avatar: friend.avatar,
|
silent: friend.silent
|
})
|
}
|
this.saveFriendList()
|
})
|
.finally(() => {
|
if (
|
pendingFetchFriends?.epoch === requestEpoch &&
|
pendingFetchFriends.userId === requestUserId
|
) {
|
pendingFetchFriends = null
|
}
|
})
|
pendingFetchFriends = { epoch: requestEpoch, userId: requestUserId, promise }
|
return promise
|
},
|
|
/**
|
* 增量拉取好友变更并合并：进入 IM 首屏主数据恢复（空游标 = 首次全量增量拉）+ 重连 / 离线补偿
|
*
|
* 含已删除好友，按 status 走 upsert
|
*/
|
async pullFriends() {
|
// 快照 epoch；账号在拉取途中切换（clear() → epoch++）时丢弃旧账号那几页结果，防跨账号数据泄漏
|
const requestEpoch = storeEpoch
|
const requestUserId = getCurrentUserId()
|
const isActive = () => requestEpoch === storeEpoch && getCurrentUserId() === requestUserId
|
await runIncrementalPull(
|
StorageKeys.settings.friendPullCursor,
|
apiPullMyFriendList,
|
async (records) => {
|
if (!isActive()) {
|
return false
|
}
|
await Promise.all(records.map((vo) => this.upsertFriendForPull(convertFriend(vo))))
|
return true
|
},
|
isActive
|
)
|
// 置 loaded，供通讯录页 fetchFriendList(force=false) 复用缓存而非重复全量拉
|
if (isActive()) {
|
this.loaded = true
|
}
|
},
|
|
/** 按 friendUserId 获取详情并合并到本地（保证 nickname / avatar 最新） */
|
async fetchFriendInfo(friendUserId: number) {
|
const requestEpoch = storeEpoch
|
const requestUserId = getCurrentUserId()
|
if (!requestUserId) {
|
return
|
}
|
const key = getPendingFriendInfoKey(requestUserId, friendUserId)
|
const inflight = pendingFetchFriendInfos.get(key)
|
if (inflight) {
|
return inflight
|
}
|
const promise = (async () => {
|
try {
|
const data = await apiGetFriend(friendUserId)
|
if (!data) {
|
return
|
}
|
// clear() 已切账号：旧请求的好友详情不能再 upsert 进新账号的 friends
|
if (requestEpoch !== storeEpoch || getCurrentUserId() !== requestUserId) {
|
return
|
}
|
this.upsertFriend(convertFriend(data))
|
} catch (error) {
|
console.warn('[IM friendStore] fetchFriendInfo 失败', error)
|
}
|
})().finally(() => {
|
if (pendingFetchFriendInfos.get(key) === promise) {
|
pendingFetchFriendInfos.delete(key)
|
}
|
})
|
pendingFetchFriendInfos.set(key, promise)
|
return promise
|
},
|
|
// ==================== 申请-审批 ====================
|
|
/** 发起好友申请：成功后等待对方同意（不直接落地为好友） */
|
async applyFriendRequest(reqVO: ImFriendRequestApi.FriendRequestApplyReqVO): Promise<null | number> {
|
return await apiApplyFriendRequest(reqVO)
|
},
|
|
/** 同意一条好友申请；后端会双向落库 + 推 FRIEND_ADD，本端等通知到达再 upsertFriend */
|
async agreeFriendRequest(requestId: number) {
|
await apiAgreeFriendRequest(requestId)
|
await this.applyHandleResult(requestId, ImFriendRequestHandleResult.AGREED)
|
},
|
|
/** 拒绝一条好友申请 */
|
async refuseFriendRequest(requestId: number, handleContent?: string) {
|
await apiRefuseFriendRequest(requestId, handleContent)
|
await this.applyHandleResult(requestId, ImFriendRequestHandleResult.REFUSED, handleContent)
|
},
|
|
/** 把 handleResult 应用到本地申请记录；找不到就按 id 单查兜底 upsert，避免破坏 id 倒序 */
|
async applyHandleResult(
|
requestId: number,
|
result: number,
|
handleContent?: string
|
): Promise<void> {
|
const request = this.getFriendRequest(requestId)
|
if (request) {
|
request.handleResult = result
|
if (handleContent !== undefined) {
|
request.handleContent = handleContent
|
}
|
request.handleTime = Date.now()
|
this.saveFriendRequest(request)
|
return
|
}
|
await this.fetchFriendRequest(requestId)
|
},
|
|
/** 拉取「我相关」的好友申请列表首页（页面打开 / 收到 FRIEND_REQUEST_RECEIVED 时刷新）；pending 期间复用同一 Promise */
|
async fetchFriendRequestList() {
|
if (pendingFetchRequests) {
|
const currentUserId = getCurrentUserId()
|
if (
|
pendingFetchRequests.epoch === storeEpoch &&
|
pendingFetchRequests.userId === currentUserId
|
) {
|
return pendingFetchRequests.promise
|
}
|
}
|
const requestEpoch = storeEpoch
|
const requestUserId = getCurrentUserId()
|
const promise = apiGetMyFriendRequestList(FRIEND_REQUEST_PAGE_SIZE)
|
.then((list) => {
|
if (requestEpoch !== storeEpoch || getCurrentUserId() !== requestUserId) {
|
return
|
}
|
const items = (list || []).map((request) => convertFriendRequest(request))
|
this.friendRequests = items
|
// 不足一页即没有更多；满页可能还有，等 loadMore 拉到 0 条再确定
|
this.hasMoreFriendRequests = items.length >= FRIEND_REQUEST_PAGE_SIZE
|
this.saveFriendRequestList()
|
})
|
.finally(() => {
|
if (
|
pendingFetchRequests?.epoch === requestEpoch &&
|
pendingFetchRequests.userId === requestUserId
|
) {
|
pendingFetchRequests = null
|
}
|
})
|
pendingFetchRequests = { epoch: requestEpoch, userId: requestUserId, promise }
|
return promise
|
},
|
|
/** 加载更多申请（按本地最旧 requestId 游标分页）；无更多 / pending 中直接返回 */
|
async loadMoreFriendRequestList() {
|
const requestUserId = getCurrentUserId()
|
const hasSameFetchPending =
|
pendingFetchRequests?.epoch === storeEpoch && pendingFetchRequests.userId === requestUserId
|
if (!this.hasMoreFriendRequests || hasSameFetchPending) {
|
return
|
}
|
if (
|
pendingLoadMoreRequests?.epoch === storeEpoch &&
|
pendingLoadMoreRequests.userId === requestUserId
|
) {
|
return pendingLoadMoreRequests.promise
|
}
|
const oldest = this.friendRequests[this.friendRequests.length - 1]
|
if (!oldest) {
|
return this.fetchFriendRequestList()
|
}
|
const requestEpoch = storeEpoch
|
const promise = apiGetMyFriendRequestList(FRIEND_REQUEST_PAGE_SIZE, oldest.id)
|
.then((list) => {
|
if (requestEpoch !== storeEpoch || getCurrentUserId() !== requestUserId) {
|
return
|
}
|
const items = (list || []).map((request) => convertFriendRequest(request))
|
this.friendRequests.push(...items)
|
this.hasMoreFriendRequests = items.length >= FRIEND_REQUEST_PAGE_SIZE
|
this.saveFriendRequestList()
|
})
|
.finally(() => {
|
if (
|
pendingLoadMoreRequests?.epoch === requestEpoch &&
|
pendingLoadMoreRequests.userId === requestUserId
|
) {
|
pendingLoadMoreRequests = null
|
}
|
})
|
pendingLoadMoreRequests = { epoch: requestEpoch, userId: requestUserId, promise }
|
return promise
|
},
|
|
/** 按 id 查申请记录；列表是按 id 倒序的小列表，O(n) find 即可，不再维护 Map 索引 */
|
getFriendRequest(requestId: number): FriendRequest | undefined {
|
return this.friendRequests.find((request) => request.id === requestId)
|
},
|
|
/** 按 id 从后端单查并 upsert 到本地（dispatcher 兜底用，避免全量重拉）；后端带越权过滤 */
|
async fetchFriendRequest(requestId: number) {
|
const requestEpoch = storeEpoch
|
const requestUserId = getCurrentUserId()
|
const data = await apiGetMyFriendRequest(requestId)
|
if (!data) {
|
return
|
}
|
// clear() 已切账号：旧请求的申请记录不能再写进新账号的 friendRequests
|
if (requestEpoch !== storeEpoch || getCurrentUserId() !== requestUserId) {
|
return
|
}
|
this.upsertFriendRequest(convertFriendRequest(data))
|
},
|
|
/** 合并单条好友申请：已有则按 id 覆盖；新记录按 id 倒序插入（比本地最旧还老则跳过，留给 loadMore 带回） */
|
upsertFriendRequest(next: FriendRequest) {
|
void this.upsertFriendRequestForPull(next).catch((error) =>
|
console.warn('[IM friendStore] 本地好友申请写入失败', error)
|
)
|
},
|
|
/** 合并单条好友申请 */
|
async upsertFriendRequestForPull(next: FriendRequest): Promise<void> {
|
const existing = this.getFriendRequest(next.id)
|
if (existing) {
|
Object.assign(existing, next)
|
await this.saveFriendRequestRecord(existing)
|
return
|
}
|
// 比本地最旧 id 还老：不入列表，让 loadMore 自然带回，避免破坏 id 倒序 / 后续 loadMore 重复 push
|
const oldest = this.friendRequests[this.friendRequests.length - 1]
|
if (oldest && next.id < oldest.id) {
|
return
|
}
|
// 按 id 倒序找首个比自己小的位置插入；找不到则追加末尾
|
const insertIndex = this.friendRequests.findIndex((request) => request.id < next.id)
|
if (insertIndex === -1) {
|
this.friendRequests.push(next)
|
} else {
|
this.friendRequests.splice(insertIndex, 0, next)
|
}
|
await this.saveFriendRequestRecord(next)
|
},
|
|
/** 增量拉取好友申请变更并合并（重连 / 离线补偿）；按 update_time + id 游标，已处理的按 handleResult 覆盖 */
|
async pullFriendRequests() {
|
const requestEpoch = storeEpoch
|
const requestUserId = getCurrentUserId()
|
const isActive = () => requestEpoch === storeEpoch && getCurrentUserId() === requestUserId
|
await runIncrementalPull(
|
StorageKeys.settings.friendRequestPullCursor,
|
apiPullMyFriendRequestList,
|
async (records) => {
|
if (!isActive()) {
|
return false
|
}
|
await Promise.all(
|
records.map((vo) => this.upsertFriendRequestForPull(convertFriendRequest(vo)))
|
)
|
return true
|
},
|
isActive
|
)
|
},
|
|
// ==================== 好友关系操作 ====================
|
|
/** 删除好友（单向软删，本端置 DISABLE）；clear=true 时级联清理本地相关数据（如私聊会话），并透传后端给多端同步 */
|
async deleteFriend(friendUserId: number, clear: boolean = true) {
|
const requestEpoch = storeEpoch
|
const requestUserId = getCurrentUserId()
|
await apiDeleteFriend(friendUserId, clear)
|
if (requestEpoch !== storeEpoch || getCurrentUserId() !== requestUserId) {
|
return
|
}
|
this.removeFriend(friendUserId, clear)
|
},
|
|
/** 切换免打扰：同步会话的 silent 字段，避免会话列表 silent 图标等 1210 推到才更新 */
|
async setFriendSilent(friendUserId: number, silent: boolean) {
|
const requestEpoch = storeEpoch
|
const requestUserId = getCurrentUserId()
|
await apiUpdateFriend({ friendUserId, silent })
|
if (requestEpoch !== storeEpoch || getCurrentUserId() !== requestUserId) {
|
return
|
}
|
const friend = this.getFriend(friendUserId)
|
if (friend) {
|
friend.silent = silent
|
const conversationStore = useConversationStore()
|
conversationStore.updateConversation(ImConversationType.PRIVATE, friendUserId, { silent })
|
this.saveFriend(friend)
|
}
|
},
|
|
/** 切换联系人置顶 */
|
async setFriendPinned(friendUserId: number, pinned: boolean) {
|
const requestEpoch = storeEpoch
|
const requestUserId = getCurrentUserId()
|
await apiUpdateFriend({ friendUserId, pinned })
|
if (requestEpoch !== storeEpoch || getCurrentUserId() !== requestUserId) {
|
return
|
}
|
const friend = this.getFriend(friendUserId)
|
if (friend) {
|
friend.pinned = pinned
|
this.saveFriend(friend)
|
}
|
},
|
|
/** 拉黑好友：本端乐观更新 + 调接口；后端 FRIEND_BLOCK 推到时由 dispatcher 兜底同步多端 */
|
async blockFriend(friendUserId: number) {
|
const requestEpoch = storeEpoch
|
const requestUserId = getCurrentUserId()
|
await apiBlockFriend(friendUserId)
|
if (requestEpoch !== storeEpoch || getCurrentUserId() !== requestUserId) {
|
return
|
}
|
const friend = this.getFriend(friendUserId)
|
if (friend) {
|
friend.blocked = true
|
this.saveFriend(friend)
|
}
|
},
|
|
/** 移出黑名单：本端乐观更新 + 调接口；后端 FRIEND_UNBLOCK 推到时由 dispatcher 兜底同步多端 */
|
async unblockFriend(friendUserId: number) {
|
const requestEpoch = storeEpoch
|
const requestUserId = getCurrentUserId()
|
await apiUnblockFriend(friendUserId)
|
if (requestEpoch !== storeEpoch || getCurrentUserId() !== requestUserId) {
|
return
|
}
|
const friend = this.getFriend(friendUserId)
|
if (friend) {
|
friend.blocked = false
|
this.saveFriend(friend)
|
}
|
},
|
|
/** 修改好友展示备注（仅自己可见） */
|
async setFriendDisplayName(friendUserId: number, displayName: string) {
|
const requestEpoch = storeEpoch
|
const requestUserId = getCurrentUserId()
|
const value = displayName.trim()
|
// 后端 displayName 语义：null/undefined = 不改，"" = 清空，所以这里直接传 value（可能是空串）
|
await apiUpdateFriend({ friendUserId, displayName: value })
|
if (requestEpoch !== storeEpoch || getCurrentUserId() !== requestUserId) {
|
return
|
}
|
const friend = this.getFriend(friendUserId)
|
if (friend) {
|
friend.displayName = value
|
const conversationStore = useConversationStore()
|
conversationStore.updateConversation(ImConversationType.PRIVATE, friendUserId, {
|
name: getFriendDisplayName(friend)
|
})
|
this.saveFriend(friend)
|
}
|
},
|
|
/** 本地合并 / 新增某个好友（WebSocket 事件 & 手动刷新都用） */
|
upsertFriend(friend: Friend) {
|
void this.upsertFriendForPull(friend).catch((error) =>
|
console.warn('[IM friendStore] 本地好友写入失败', error)
|
)
|
},
|
|
/** 本地合并 / 新增某个好友 */
|
async upsertFriendForPull(friend: Friend): Promise<void> {
|
const index = this.friends.findIndex(
|
(existing) => existing.friendUserId === friend.friendUserId
|
)
|
if (index === -1) {
|
this.friends.push({
|
...friend,
|
status: friend.status ?? CommonStatusEnum.ENABLE
|
})
|
} else {
|
this.friends[index] = {
|
...this.friends[index],
|
...friend,
|
status: friend.status ?? CommonStatusEnum.ENABLE
|
}
|
}
|
const conversationStore = useConversationStore()
|
const merged = this.getFriend(friend.friendUserId)
|
conversationStore.updateConversation(ImConversationType.PRIVATE, friend.friendUserId, {
|
name: merged ? getFriendDisplayName(merged) : friend.nickname,
|
avatar: friend.avatar,
|
silent: friend.silent
|
})
|
await this.saveFriendRecord(merged)
|
},
|
|
/** 本地标记删除（WebSocket FRIEND_DELETE 事件触发；clear=true 时级联清相关数据如私聊会话） */
|
removeFriend(friendUserId: number, clear: boolean = true) {
|
const friend = this.getFriend(friendUserId)
|
if (friend) {
|
// blocked 不动，跟后端 deleteFriend0「删好友期间保留拉黑状态」对齐
|
friend.status = CommonStatusEnum.DISABLE
|
friend.deleteTime = Date.now()
|
}
|
if (clear) {
|
const conversationStore = useConversationStore()
|
conversationStore.removePrivateConversation(friendUserId)
|
}
|
this.saveFriend(friend)
|
},
|
|
// ==================== WebSocket 事件 dispatcher（1201-1210 段） ====================
|
|
/** FRIEND_REQUEST_RECEIVED(1203)：收到新申请；payload 已带申请方昵称 / 头像，按 requestId 直推 push 进列表 */
|
applyFriendRequestReceivedNotification(payload: FriendNotificationPayload) {
|
if (!payload.requestId) {
|
return
|
}
|
const currentUserId = getCurrentUserId()
|
const existingIndex = this.friendRequests.findIndex((item) => item.id === payload.requestId)
|
if (existingIndex !== -1) {
|
const existing = this.friendRequests.splice(existingIndex, 1)[0]
|
if (!existing) {
|
return
|
}
|
const next = {
|
...existing,
|
fromUserId: payload.operatorUserId,
|
toUserId: currentUserId,
|
handleResult: ImFriendRequestHandleResult.UNHANDLED,
|
applyContent: payload.applyContent,
|
addSource: payload.addSource,
|
createTime: Date.now(),
|
fromNickname: payload.fromNickname,
|
fromAvatar: payload.fromAvatar
|
}
|
this.friendRequests.unshift(next)
|
this.saveFriendRequest(next)
|
return
|
}
|
const next = {
|
id: payload.requestId,
|
fromUserId: payload.operatorUserId,
|
toUserId: currentUserId,
|
handleResult: ImFriendRequestHandleResult.UNHANDLED,
|
applyContent: payload.applyContent,
|
addSource: payload.addSource,
|
createTime: Date.now(),
|
fromNickname: payload.fromNickname,
|
fromAvatar: payload.fromAvatar
|
}
|
this.friendRequests.unshift(next)
|
this.saveFriendRequest(next)
|
},
|
|
/** FRIEND_REQUEST_APPROVED(1201)：我的申请被同意；按 requestId 更新状态（FRIEND_ADD 会另外推） */
|
applyFriendRequestApprovedNotification(payload: FriendNotificationPayload) {
|
if (!payload.requestId) {
|
return
|
}
|
void this.applyHandleResult(payload.requestId, ImFriendRequestHandleResult.AGREED)
|
},
|
|
/** FRIEND_REQUEST_REJECTED(1202)：我的申请被拒绝；按 requestId 更新状态 */
|
applyFriendRequestRejectedNotification(payload: FriendNotificationPayload) {
|
if (!payload.requestId) {
|
return
|
}
|
void this.applyHandleResult(
|
payload.requestId,
|
ImFriendRequestHandleResult.REFUSED,
|
payload.handleContent
|
)
|
},
|
|
/**
|
* FRIEND_ADD(1204)：新增好友；本端拉取好友详情并入库
|
* peerUserId 由 websocketStore 按帧 sender / receiver 算好传入：becomeFriends 单条入库后双方收到同一份 payload，
|
* 本端真正的「对端」是帧上的另一个用户，不是 payload.friendUserId（payload 里固定是 toUserId）。
|
*/
|
applyFriendAddNotification(_payload: FriendNotificationPayload, peerUserId: number) {
|
if (this.isActiveFriend(peerUserId)) {
|
return
|
}
|
void this.fetchFriendInfo(peerUserId)
|
},
|
|
/**
|
* FRIEND_DELETE(1205)：好友被删除；本端清理 + 按 payload.clear 决定是否级联清会话（多端跟主操作端一致）
|
* peerUserId 由 websocketStore 按帧 sender / receiver 算好传入；与 FRIEND_ADD 保持一致的 peer 推断
|
*/
|
applyFriendDeleteNotification(payload: FriendNotificationPayload, peerUserId: number) {
|
this.removeFriend(peerUserId, payload.clear !== false)
|
},
|
|
/** FRIEND_BLOCK(1207)：拉黑；多端同步 */
|
applyFriendBlockNotification(payload: FriendNotificationPayload) {
|
const friend = this.getFriend(payload.friendUserId)
|
if (friend) {
|
friend.blocked = true
|
this.saveFriend(friend)
|
}
|
},
|
|
/** FRIEND_UNBLOCK(1208)：移出黑名单；多端同步 */
|
applyFriendUnblockNotification(payload: FriendNotificationPayload) {
|
const friend = this.getFriend(payload.friendUserId)
|
if (friend) {
|
friend.blocked = false
|
this.saveFriend(friend)
|
}
|
},
|
|
/** FRIEND_INFO_UPDATED(1209)：好友资料变更（昵称 / 头像）；重拉详情 */
|
applyFriendInfoUpdatedNotification(payload: FriendNotificationPayload) {
|
void this.fetchFriendInfo(payload.friendUserId)
|
},
|
|
/** FRIEND_UPDATE(1210)：批量更新（备注 / 免打扰 / 联系人置顶）；多端同步 */
|
applyFriendUpdateNotification(payload: FriendNotificationPayload) {
|
const friend = this.getFriend(payload.friendUserId)
|
if (!friend) {
|
return
|
}
|
if (payload.displayName != null) {
|
friend.displayName = payload.displayName
|
}
|
if (payload.silent != null) {
|
friend.silent = payload.silent
|
}
|
if (payload.pinned != null) {
|
friend.pinned = payload.pinned
|
}
|
const conversationStore = useConversationStore()
|
conversationStore.updateConversation(ImConversationType.PRIVATE, payload.friendUserId, {
|
name: getFriendDisplayName(friend),
|
silent: friend.silent
|
})
|
this.saveFriend(friend)
|
},
|
|
/** 清空好友内存状态，并废弃未返回请求（pending Promise 置空 + storeEpoch++） */
|
clear() {
|
this.friends = []
|
this.friendRequests = []
|
this.loaded = false
|
this.hasMoreFriendRequests = true
|
pendingFetchFriends = null
|
pendingFetchRequests = null
|
pendingLoadMoreRequests = null
|
pendingFetchFriendInfos.clear()
|
storeEpoch++
|
}
|
}
|
})
|
|
function convertFriend(vo: ImFriendApi.FriendRespVO): Friend {
|
return {
|
id: vo.id,
|
friendUserId: vo.friendUserId,
|
nickname: vo.nickname || String(vo.friendUserId),
|
nicknamePinyin: vo.nicknamePinyin,
|
avatar: vo.avatar,
|
silent: !!vo.silent,
|
displayName: vo.displayName || '',
|
displayNamePinyin: vo.displayNamePinyin,
|
addSource: vo.addSource,
|
pinned: !!vo.pinned,
|
blocked: !!vo.blocked,
|
status: vo.status,
|
addTime: vo.addTime ? new Date(vo.addTime).getTime() : undefined,
|
deleteTime: vo.deleteTime ? new Date(vo.deleteTime).getTime() : undefined
|
}
|
}
|
|
function convertFriendRequest(vo: ImFriendRequestApi.FriendRequestRespVO): FriendRequest {
|
return {
|
id: vo.id,
|
fromUserId: vo.fromUserId,
|
toUserId: vo.toUserId,
|
handleResult: vo.handleResult,
|
applyContent: vo.applyContent,
|
handleContent: vo.handleContent,
|
addSource: vo.addSource,
|
handleTime: vo.handleTime ? new Date(vo.handleTime).getTime() : undefined,
|
createTime: vo.createTime ? new Date(vo.createTime).getTime() : 0,
|
fromNickname: vo.fromNickname,
|
fromAvatar: vo.fromAvatar,
|
toNickname: vo.toNickname,
|
toAvatar: vo.toAvatar
|
}
|
}
|
|
export const useFriendStoreWithOut = () => useFriendStore()
|
|
// dev: 让 Pinia 的 actions / state 改动支持 HMR，避免每次改 store 都得硬刷
|
if (import.meta.hot) {
|
import.meta.hot.accept(acceptHMRUpdate(useFriendStore, import.meta.hot))
|
}
|
