@aochuang/client-sdk 1.0.377 → 1.0.378-wework

package/services/client-chat/client-chat-wechat/client-chat-session.js

@@ -242,37 +242,19 @@ export default class ClientChatSession {
 		}
 	}
 
-	_addGetSessionSerializeTask (pollRequest, serializeMethod, taskOptions = {}) {
-		if (!serializeMethod) {
-			return false
-		}
-		const messageId = taskOptions.messageId
-		if (messageId && pollRequest.serializeTaskMap[messageId]) {
-			return false
-		}
-		const task = {
-			messageId,
-			wechatTime: taskOptions.wechatTime || 0,
-			index: pollRequest.serializeTasks.length,
-			serializeMethod
-		}
-		pollRequest.serializeTasks.push(task)
-		if (messageId) {
-			pollRequest.serializeTaskMap[messageId] = task
-		}
-		return true
-	}
-
-	getSession (sessionId, serializeMethod, taskOptions = {}) {
+	getSession (sessionId, serializeMethod) {
 		if (this.sessionMap[sessionId]) {  
 			return Promise.resolve({
 				data: this.sessionMap[sessionId]
 			})
 		}
 		// 这里需要轮询从后端获取会话，后端会话更新和创建是异步的，所以要多轮训请求几次
+		// 同一个会话只会有一个轮询，轮询期间再次调用只把serializeMethod挂到这个轮询上，等结果回来后依次执行
 		let pollRequest = this.pollRequestMap[sessionId]
 		if (pollRequest && pollRequest.ps) {
-			this._addGetSessionSerializeTask(pollRequest, serializeMethod, taskOptions)
+			if (serializeMethod) {
+				pollRequest.serializeMethods.push(serializeMethod)
+			}
 			return pollRequest.ps
 		}
 
@@ -292,50 +274,33 @@ export default class ClientChatSession {
 				return Promise.reject(error)
 			})
 		})
-		pollRequest.serializeTasks = []
-		pollRequest.serializeTaskMap = {}
+		pollRequest.serializeMethods = serializeMethod ? [serializeMethod] : []
 		pollRequest.requestCount = 0
 		pollRequest.emptyResponseCount = 0
 		pollRequest.requestErrorCount = 0
 		pollRequest.lastRequestError = null
 		pollRequest.startedAt = Date.now()
-		this._addGetSessionSerializeTask(pollRequest, serializeMethod, taskOptions)
 		this.pollRequestMap[sessionId] = pollRequest
 		this._addGetSessionLog('创建会话轮询', {
-			sessionId,
-			messageId: taskOptions.messageId,
-			wechatTime: taskOptions.wechatTime,
-			taskCount: pollRequest.serializeTasks.length
+			sessionId
 		})
 		pollRequest.ps = pollRequest.start().then(rs => {
 			if (!rs.data) {
 				return Promise.reject('未找到会话' + sessionId)
 			}
 			/**
-			 * 轮询合并上下文，会依次传给每个 serializeMethod（见 client-chat.js onCmdNewMessage 里 getSession 的回调）
+			 * 轮询合并上下文，会依次传给每个 serializeMethod（见 client-chat.js onAddMessageSuccess 里 getSession 的回调）
 			 * baseLastMsgTime     服务端返回的会话 lastMsgTime，用来判断某条消息服务端是否已经算进 unreadMsgCount
-			 * processedMessageIds 本次轮询期间处理过的所有消息 id
-			 * skippedMessageIds   服务端返回的会话已经包含（wechatTime <= baseLastMsgTime）、本地不再给会话未读 +1 的消息 id
-			 * unreadMessageIds    本地给会话未读 +1 的消息 id
 			 * accountUnreadDelta  本次轮询期间需要累加到工作微信号（账号）未读数量上的条数。
-			 *                     注意它和 unreadMessageIds.length 不同：账号未读初始值是登录时取的，不包含本次收到的任何消息，
-			 *                     所以被 skip 的消息也要算进来；只有"正在看当前会话被直接标记已读"的消息不算
+			 *                     账号未读初始值是登录时取的，不包含本次收到的任何消息，所以服务端已经算进会话 unreadMsgCount 的消息也要算进来；
+			 *                     只有"正在看当前会话被直接标记已读"的消息不算
 			 */
 			const context = {
 				baseLastMsgTime: rs.data.lastMsgTime || 0,
-				processedMessageIds: [],
-				skippedMessageIds: [],
-				unreadMessageIds: [],
 				accountUnreadDelta: 0
 			}
-			const serializeTasks = pollRequest.serializeTasks.slice().sort((a, b) => {
-				return a.wechatTime - b.wechatTime || a.index - b.index
-			})
-			serializeTasks.forEach(task => {
-				rs = task.serializeMethod(rs, context) || rs
-				if (task.messageId) {
-					context.processedMessageIds.push(task.messageId)
-				}
+			pollRequest.serializeMethods.forEach(method => {
+				rs = method(rs, context) || rs
 			})
 			// wechatAccountId 传 null 表示非分页来源，onAddSession 会把未读同步到账号；
 			// 同时带上 unreadDelta，让账号只累加本次新增的条数，而不是服务端返回的整个 unreadMsgCount（那里面的存量部分账号初始值已经包含了）
@@ -353,9 +318,7 @@ export default class ClientChatSession {
 				lastMsgTime: rs.data.lastMsgTime,
 				lastMsgId: rs.data.lastMsgId,
 				unreadMsgCount: rs.data.unreadMsgCount,
-				processedMessageCount: context.processedMessageIds.length,
-				skippedMessageCount: context.skippedMessageIds.length,
-				unreadMessageCount: context.unreadMessageIds.length,
+				mergedCount: pollRequest.serializeMethods.length,
 				accountUnreadDelta: context.accountUnreadDelta,
 				hasSessionMap: !!this.sessionMap[sessionId],
 				hasAllSessionGroup: !!this._getSessionBySessionGroup(sessionId, ALL_WECHAT_ACCOUNT_ID),

package/services/client-chat/client-chat-wechat/client-chat.js

@@ -437,22 +437,6 @@ class ClientChat {
 				}
 				const localSession = this.session.findSession(({ session }) => session.conversationId === sessionId)
 				if (!localSession) {
-					if (!this.session.pollRequestMap[sessionId]) {
-						this.socket.addLog({
-							group: 'client-chat-message:onAddMessageSuccess',
-							content: {
-								title: '未获取到会话，开始从服务端获取',
-								data: {
-									sessionId,
-									accountId,
-									wechatFriendId: data.wechatFriendId,
-									wechatAccountId: data.wechatAccountId,
-									messageId: data.id,
-									wechatTime: data.wechatTime
-								}
-							}
-						})
-					}
 					return this.session.getSession(sessionId, (rs, context) => {
 						if (rs && rs.data) {
 							const isAfterServerMessage = data.wechatTime > context.baseLastMsgTime
@@ -467,19 +451,16 @@ class ClientChat {
 							// 正在看这个会话并且允许自动标记已读
 							const isCurrentSessionRead = this.sessionManage.currentSession && this.sessionManage.currentSession.conversationId === sessionId && this.shouldMarkCurrentSessionRead(sessionId, data)
 							// 会话未读数量：isAfterServerMessage 为 true 表示这条消息比服务端返回的会话 lastMsgTime 新，
-							// 服务端返回的 unreadMsgCount 还没算它，需要本地 +1；否则服务端已经算进去了，skip 掉避免重复
+							// 服务端返回的 unreadMsgCount 还没算它，需要本地 +1；否则服务端已经算进去了，不再重复 +1
 							if (!data.isSend && isAfterServerMessage) {
 								if (isCurrentSessionRead) {
 									rs.data.unreadMsgCount = 0
 								} else {
 									rs.data.unreadMsgCount = (rs.data.unreadMsgCount || 0) + 1
-									context.unreadMessageIds.push(data.id)
 								}
-							} else {
-								context.skippedMessageIds.push(data.id)
 							}
 							// 账号未读数量：和会话未读数量的判断口径不一样。
-							// 账号未读初始值是登录时从服务端取的，不包含这条新消息，所以不管这条消息有没有被服务端算进会话的 unreadMsgCount（即不管是否被 skip），
+							// 账号未读初始值是登录时从服务端取的，不包含这条新消息，所以不管这条消息有没有被服务端算进会话的 unreadMsgCount，
 							// 账号都要 +1。唯一不加的情况是"正在看当前会话并被直接标记已读"（此时会话未读被置 0，不会再通过 onSessionReadChange 扣减账号）。
 							// 这个累计值会通过 addSession(rs.data, null, { unreadDelta }) 传给 onAddSession，账号只累加这个增量而不是整个 unreadMsgCount
 							if (!data.isSend && !(isAfterServerMessage && isCurrentSessionRead)) {
@@ -487,9 +468,6 @@ class ClientChat {
 							}
 						}
 						return rs
-					}, {
-						messageId: data.id,
-						wechatTime: data.wechatTime
 					}).catch(() => {})
 					} else {
 						this.session.updateSession(sessionId, ({ session }) => {
@@ -584,22 +562,6 @@ class ClientChat {
 				// 更新会话未读消息数量
 				const localSession = this.session.findSession(({ session }) => session.conversationId === sessionId)
 				if (!localSession) {
-					if (!this.session.pollRequestMap[sessionId]) {
-						this.socket.addLog({
-							group: 'client-chat-message:onAddMessageSuccess',
-							content: {
-								title: '未获取到会话，开始从服务端获取',
-								data: {
-									sessionId,
-									accountId,
-									wechatChatroomId: data.wechatChatroomId,
-									wechatAccountId: data.wechatAccountId,
-									messageId: data.id,
-									wechatTime: data.wechatTime
-								}
-							}
-						})
-					}
 					return this.session.getSession(sessionId, (rs, context) => {
 						if (rs && rs.data) {
 							const isAfterServerMessage = data.wechatTime > context.baseLastMsgTime
@@ -614,22 +576,19 @@ class ClientChat {
 							// 正在看这个会话并且允许自动标记已读
 							const isCurrentSessionRead = this.sessionManage.currentSession && this.sessionManage.currentSession.conversationId === sessionId && this.shouldMarkCurrentSessionRead(sessionId, data)
 							// 会话未读数量：isAfterServerMessage 为 true 表示这条消息比服务端返回的会话 lastMsgTime 新，
-							// 服务端返回的 unreadMsgCount 还没算它，需要本地 +1；否则服务端已经算进去了，skip 掉避免重复
+							// 服务端返回的 unreadMsgCount 还没算它，需要本地 +1；否则服务端已经算进去了，不再重复 +1
 							if (!data.isSend && isAfterServerMessage) {
 								if (isCurrentSessionRead) {
 									rs.data.unreadMsgCount = 0
 								} else {
 									rs.data.unreadMsgCount = (rs.data.unreadMsgCount || 0) + 1
-									context.unreadMessageIds.push(data.id)
 									if (atMessage) {
 										rs.data.lastAtMsgContent = appendLastAtMsgContent(rs.data.lastAtMsgContent, atMessage)
 									}
 								}
-							} else {
-								context.skippedMessageIds.push(data.id)
 							}
 							// 账号未读数量：和会话未读数量的判断口径不一样。
-							// 账号未读初始值是登录时从服务端取的，不包含这条新消息，所以不管这条消息有没有被服务端算进会话的 unreadMsgCount（即不管是否被 skip），
+							// 账号未读初始值是登录时从服务端取的，不包含这条新消息，所以不管这条消息有没有被服务端算进会话的 unreadMsgCount，
 							// 账号都要 +1。唯一不加的情况是"正在看当前会话并被直接标记已读"（此时会话未读被置 0，不会再通过 onSessionReadChange 扣减账号）。
 							// 这个累计值会通过 addSession(rs.data, null, { unreadDelta }) 传给 onAddSession，账号只累加这个增量而不是整个 unreadMsgCount
 							if (!data.isSend && !(isAfterServerMessage && isCurrentSessionRead)) {
@@ -637,9 +596,6 @@ class ClientChat {
 							}
 						}
 						return rs
-					}, {
-						messageId: data.id,
-						wechatTime: data.wechatTime
 					}).catch(() => {})
 					} else {
 						this.session.updateSession(sessionId, ({ session }) => {

package/services/client-chat/client-chat-wechat/docs//350/264/246/345/217/267/346/234/252/350/257/273/346/225/260/351/207/217/344/270/216/344/274/232/350/257/235/346/234/252/350/257/273/346/225/260/351/207/217/344/270/215/344/270/200/350/207/264/351/227/256/351/242/230/344/277/256/345/244/215.md

@@ -84,13 +84,15 @@ SDK 里维护着两套彼此独立的本地"账本"：
   ```js
   // 会话未读：只在服务端没算过这条消息时 +1（原逻辑不变）
   if (!data.isSend && isAfterServerMessage) { ... }
-  // 账号未读：不管是否被 skip 都 +1，只有"正在看当前会话被直接标记已读"不加
+  // 账号未读：不管服务端是否已经算进会话 unreadMsgCount 都 +1，只有"正在看当前会话被直接标记已读"不加
   if (!data.isSend && !(isAfterServerMessage && isCurrentSessionRead)) {
       context.accountUnreadDelta += 1
   }
   ```
 
-  注意 `accountUnreadDelta` **不等于** `unreadMessageIds.length`：被 skip 的消息表示服务端返回的会话已经把它算进 `unreadMsgCount`，但账号初始值是登录时取的，仍然不含这条，所以账号还是要 +1。
+  注意 `accountUnreadDelta` **不等于** 本次给会话 `unreadMsgCount` +1 的条数：`isAfterServerMessage` 为 false 的消息表示服务端返回的会话已经把它算进 `unreadMsgCount`，但账号初始值是登录时取的，仍然不含这条，所以账号还是要 +1。
+
+  `getSession(sessionId, serializeMethod)` 只按 `sessionId` 聚合：同一个会话轮询期间的所有回调按调用顺序依次执行，不再依赖消息 id / 时间做去重或排序（消息层 `addMessage` 已按 id 去重）。
 
 - `onAddSession`（第 132 行附近）：
 

package/services/client-chat/client-chat-wework/client-chat-account.js

@@ -5,14 +5,20 @@ export default class ClientChatAccount {
 	data = Vue.observable({
 		accountData: [],
 		accountUnreadMessageNumData: [],
+		accountGreetingUnreadMsgCountData: {},
 		currentAccount: null
 	})
 		
 	loadAccountDataMethod = null
 	
 	getAccountUnreadMessageNumMethod = null
+
+	getAccountGreetingUnreadMsgCountMethod = null
 	
 	accountMap = {}
+
+	// 好友请求数量请求合并，key为账号id列表
+	greetingUnreadRequestMap = {}
 	
 	constructor (options) {
 		options = Object.assign({
@@ -21,11 +27,13 @@ export default class ClientChatAccount {
 			getAccountUnreadMessageNumMethod: null,
 			updateAccountMessageReadMethod: null,
 			deleteAccountSessionMethod: null,
+			getAccountGreetingUnreadMsgCountMethod: null,
 			onCurrentAccountChange: null,
 			onAccountAdded: null,
 			onAccountRemoved: null,
 			onUnreadMessageNumChange: null,
-			onDeleteAccountSession: null
+			onDeleteAccountSession: null,
+			onAccountLoaded: null
 		}, options)
 		if (!options.loadAccountDataMethod) {
 			throw new Error('缺少loadAccountDataMethod配置')
@@ -38,10 +46,12 @@ export default class ClientChatAccount {
 		this.getAccountUnreadMessageNumMethod = options.getAccountUnreadMessageNumMethod
 		this.updateAccountMessageReadMethod = options.updateAccountMessageReadMethod
 		this.deleteAccountSessionMethod = options.deleteAccountSessionMethod
+		this.getAccountGreetingUnreadMsgCountMethod = options.getAccountGreetingUnreadMsgCountMethod
 		this.onAccountAdded = options.onAccountAdded
 		this.onAccountRemoved = options.onAccountRemoved,
 		this.onUnreadMessageNumChange = options.onUnreadMessageNumChange
 		this.onDeleteAccountSession = options.onDeleteAccountSession
+		this.onAccountLoaded = options.onAccountLoaded
 	}
 	
 	get accountData () {
@@ -55,6 +65,10 @@ export default class ClientChatAccount {
 	get currentAccount () {
 		return this.data.currentAccount
 	}
+
+	get accountGreetingUnreadMsgCountData () {
+		return this.data.accountGreetingUnreadMsgCountData
+	}
 	
 	setCurrentAccount (accountId) {
 		let account = null
@@ -282,6 +296,9 @@ export default class ClientChatAccount {
 		this._cacheLoadPromise = this.loadAccountDataMethod()
 		this._cacheLoadPromise.then(rs => {
 			this.setAccountData(rs.data)
+			this.onAccountLoaded && this.onAccountLoaded({
+				data: rs.data
+			})
 		})
 		this.cancelConnectRequest = () => {
 			this._cacheLoadPromise.abort()
@@ -298,9 +315,75 @@ export default class ClientChatAccount {
 		return this.loadData()
 	}
 	
+	/**
+	 * 设置指定企微账号的待处理好友请求数量，并重算all
+	*/
+	setAccountGreetingUnreadMsgCount (params) {
+		if (!params || !params.qwAccountId) {
+			throw new Error('缺少必须参数')
+		}
+		Vue.set(this.data.accountGreetingUnreadMsgCountData, params.qwAccountId, params.count || 0)
+		this.updateAllAccountGreetingUnreadMsgCount()
+	}
+
+	updateAllAccountGreetingUnreadMsgCount () {
+		const allCount = Object.keys(this.data.accountGreetingUnreadMsgCountData).reduce((rs, key) => {
+			return key === 'all' ? rs : rs + (this.data.accountGreetingUnreadMsgCountData[key] || 0)
+		}, 0)
+		Vue.set(this.data.accountGreetingUnreadMsgCountData, 'all', allCount)
+	}
+
+	/**
+	 * 获取待处理好友请求数量
+	 * qwAccountIds不传则刷新所有账号；后端数量为0的账号不返回，所以先置0再覆盖
+	*/
+	getAccountGreetingUnreadMsgCount (params) {
+		if (!this.getAccountGreetingUnreadMsgCountMethod) {
+			return Promise.reject(new Error('getAccountGreetingUnreadMsgCountMethod未定义'))
+		}
+		let qwAccountIds = (params || {}).qwAccountIds
+		if (qwAccountIds && !Array.isArray(qwAccountIds)) {
+			qwAccountIds = [qwAccountIds]
+		}
+		qwAccountIds = (qwAccountIds || []).filter((id, index, data) => id && data.indexOf(id) === index).map(String)
+		const isAll = !qwAccountIds.length
+		const requestKey = isAll ? 'all' : qwAccountIds.slice().sort().join(',')
+		if (this.greetingUnreadRequestMap[requestKey]) {
+			return this.greetingUnreadRequestMap[requestKey]
+		}
+		const request = this.getAccountGreetingUnreadMsgCountMethod({
+			qwAccountIds: isAll ? undefined : qwAccountIds
+		}).then(rs => {
+			const targetIds = isAll ? Object.keys(this.accountMap) : qwAccountIds
+			targetIds.forEach(id => {
+				Vue.set(this.data.accountGreetingUnreadMsgCountData, id, 0)
+			})
+			;((rs && rs.data) || []).forEach(item => {
+				if (item && item.qwAccountId) {
+					Vue.set(this.data.accountGreetingUnreadMsgCountData, String(item.qwAccountId), item.count || 0)
+				}
+			})
+			this.updateAllAccountGreetingUnreadMsgCount()
+			return this.data.accountGreetingUnreadMsgCountData
+		}).finally(() => {
+			delete this.greetingUnreadRequestMap[requestKey]
+		})
+		this.greetingUnreadRequestMap[requestKey] = request
+		return request
+	}
+
+	/**
+	 * 刷新所有账号的待处理好友请求数量
+	*/
+	refreshAllAccountGreetingUnreadMsgCount () {
+		return this.getAccountGreetingUnreadMsgCount()
+	}
+	
 	reset () {
 		this.data.accountData = []
 		this.data.accountUnreadMessageNumData = []
+		this.data.accountGreetingUnreadMsgCountData = {}
+		this.greetingUnreadRequestMap = {}
 		if (this.cancelConnectRequest) {
 			this.cancelConnectRequest()
 		}

package/services/client-chat/client-chat-wework/client-chat-concats.js

@@ -126,11 +126,7 @@ export default class ClientChatContacts {
 		*/
 		roomBindMemberMap: {},
 		
-		/**
-		 * 标记通讯录是否修改了
-		 * 如果修改了，比如接收到了分配好友的会话时，一定通讯录变了，变了的时候界面需要根据这个状态刷新通讯录
-		*/
-	    isModify: false
+		modifiedAccountMap: {}
 	})
 	
 	friendMap = {}
@@ -237,10 +233,6 @@ export default class ClientChatContacts {
 		return this.data.roomGroupData
 	}
 	
-	get isModify () {
-		return this.data.isModify
-	}
-	
 	setRoomGroup (data) {
 		this.data.roomGroupData = []
 		if (data && data.length) {
@@ -491,10 +483,10 @@ export default class ClientChatContacts {
 				}
 			}
 			const qwAccountId = this.roomMap[id].qwAccountId
-			if (qwAccountId && this.data.accountBindFriendMap[qwAccountId] && this.data.accountBindFriendMap[qwAccountId][groupId]) {
-				const bindIndex = this.data.accountBindFriendMap[qwAccountId][groupId].indexOf(this.roomMap[id])
+			if (qwAccountId && this.data.accountBindRoomMap[qwAccountId] && this.data.accountBindRoomMap[qwAccountId][groupId]) {
+				const bindIndex = this.data.accountBindRoomMap[qwAccountId][groupId].indexOf(this.roomMap[id])
 				if (bindIndex >= 0) {
-					this.data.accountBindFriendMap[qwAccountId][groupId].splice(bindIndex, 1)
+					this.data.accountBindRoomMap[qwAccountId][groupId].splice(bindIndex, 1)
 				}
 			}
 		})
@@ -628,6 +620,37 @@ export default class ClientChatContacts {
 			return rs
 		})
 	}
+
+	/**
+	 * 强制从服务端刷新好友资料，绕过本地缓存。
+	 */
+	refreshFriend (friendId) {
+		if (!friendId) {
+			return Promise.reject('缺少好友id')
+		}
+		if (!this.getContactsFriendMethod) {
+			return Promise.reject(new Error('getContactsFriendMethod未定义'))
+		}
+		return this.getContactsFriendMethod({
+			id: friendId
+		}).then(rs => {
+			if (!rs || !rs.data) {
+				return Promise.reject('未找到好友' + friendId)
+			}
+			if (this.friendMap[friendId]) {
+				const nextKeys = Object.keys(rs.data)
+				Object.keys(this.friendMap[friendId]).forEach(key => {
+					if (!nextKeys.includes(key)) {
+						Vue.delete(this.friendMap[friendId], key)
+					}
+				})
+				this.updateFriend(friendId, rs.data)
+			} else {
+				this.addFriend(rs.data)
+			}
+			return rs
+		})
+	}
 	
 	setRoomMemberData (roomId, data) {
 		if (!roomId) {
@@ -738,12 +761,52 @@ export default class ClientChatContacts {
 		})
 	}
 	
-	markModify () {
-		this.data.isModify = true
+	refreshRoom (id) {
+		if (!id) {
+			return Promise.reject('缺少群id')
+		}
+		if (!this.getContactsRoomMethod) {
+			return Promise.reject(new Error('getContactsRoomMethod未定义'))
+		}
+		return this.getContactsRoomMethod({
+			id
+		}).then(rs => {
+			if (!rs || !rs.data) {
+				return Promise.reject('未找到群' + id)
+			}
+			const localRoom = this.roomMap[id]
+			if (localRoom) {
+				this.removeRoom(id)
+				const nextKeys = Object.keys(rs.data)
+				Object.keys(localRoom).forEach(key => {
+					if (!nextKeys.includes(key)) {
+						Vue.delete(localRoom, key)
+					}
+				})
+				Object.keys(rs.data).forEach(key => {
+					Vue.set(localRoom, key, rs.data[key])
+				})
+			}
+			this.addRoom(localRoom || rs.data)
+			return rs
+		})
+	}
+
+	isModify (qwAccountId) {
+		return !!(qwAccountId && this.data.modifiedAccountMap[qwAccountId])
+	}
+
+	markModify (qwAccountIds) {
+		const ids = Array.isArray(qwAccountIds) ? qwAccountIds : [qwAccountIds]
+		ids.filter(Boolean).forEach(id => {
+			Vue.set(this.data.modifiedAccountMap, id, true)
+		})
 	}
 	
-	unmarkModify () {
-		this.data.isModify = false
+	unmarkModify (qwAccountId) {
+		if (qwAccountId) {
+			Vue.delete(this.data.modifiedAccountMap, qwAccountId)
+		}
 	}
 	
 	reset () {
@@ -758,6 +821,7 @@ export default class ClientChatContacts {
 		this.data.groupBindRoomMap = {}
 		this.data.accountBindFriendMap = {}
 		this.data.accountBindRoomMap = {}
+		this.data.modifiedAccountMap = {}
 		this._cacheFriendGroupCountMap = null
 		this._cacheRoomGroupCountMap = null
 		if (this.cancelConnectRequest) {
@@ -769,4 +833,4 @@ export default class ClientChatContacts {
 			this.cancelRefreshRequest = null
 		}
 	}
-}
+}