@aochuang/client-sdk 1.0.376 → 1.0.378

package/package.json

@@ -1,16 +1,9 @@
 {
   "name": "@aochuang/client-sdk",
-  "version": "1.0.376",
+  "version": "1.0.378",
   "description": "",
-  "files": [
-    "common",
-    "components",
-    "services",
-    "utils",
-    "dist"
-  ],
-  "exports": {
-    ".": "./components/index.js"
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
   },
   "repository": {
     "type": "git",

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

@@ -146,6 +146,21 @@ export default class ClientChatMessage {
 			}
 		}
 		if (fireEvent !== false) {
+			// 先执行onAddMessageSuccess再发add-message事件，保证会话的getSession轮询先由这里发起、更新会话的回调排在最前面，
+			// 外部监听add-message后再调getSession只是复用同一个轮询
+			// try/catch是为了避免回调里的异常把add-message事件吞掉（外部的新消息提醒、本地消息缓存都依赖这个事件）
+			try {
+				this.onAddMessageSuccess && this.onAddMessageSuccess({
+					data,
+					lastMessageTime,
+					isBeforeLastMessage
+				})
+			} catch (error) {
+				console.error('[client-chat-message] onAddMessageSuccess error', {
+					messageId: data.id,
+					error
+				})
+			}
 			// 如果消息包含这种情况，就不能往外发送add-message事件
 			// 因为例如群发的消息，他没有会话，导致前端在处理来了新消息通知铃声提醒，获取会话一直获取不到，然后会总是发送请求
 			if (!isBeforeLastMessage && !isAutoReadMessage(data) && !shouldIgnoreSessionByMessage(data) && !isDeletedMsg(data) && !isBlockedMsg(data)) {
@@ -153,11 +168,6 @@ export default class ClientChatMessage {
 					data
 				})	
 			}
-			this.onAddMessageSuccess && this.onAddMessageSuccess({
-				data,
-				lastMessageTime,
-				isBeforeLastMessage
-			})
 		}
 	}
 

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,20 +5,14 @@ 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({
@@ -27,13 +21,11 @@ export default class ClientChatAccount {
 			getAccountUnreadMessageNumMethod: null,
 			updateAccountMessageReadMethod: null,
 			deleteAccountSessionMethod: null,
-			getAccountGreetingUnreadMsgCountMethod: null,
 			onCurrentAccountChange: null,
 			onAccountAdded: null,
 			onAccountRemoved: null,
 			onUnreadMessageNumChange: null,
-			onDeleteAccountSession: null,
-			onAccountLoaded: null
+			onDeleteAccountSession: null
 		}, options)
 		if (!options.loadAccountDataMethod) {
 			throw new Error('缺少loadAccountDataMethod配置')
@@ -46,12 +38,10 @@ 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 () {
@@ -65,10 +55,6 @@ export default class ClientChatAccount {
 	get currentAccount () {
 		return this.data.currentAccount
 	}
-
-	get accountGreetingUnreadMsgCountData () {
-		return this.data.accountGreetingUnreadMsgCountData
-	}
 	
 	setCurrentAccount (accountId) {
 		let account = null
@@ -296,9 +282,6 @@ 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()
@@ -315,75 +298,9 @@ 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,7 +126,11 @@ export default class ClientChatContacts {
 		*/
 		roomBindMemberMap: {},
 		
-		modifiedAccountMap: {}
+		/**
+		 * 标记通讯录是否修改了
+		 * 如果修改了，比如接收到了分配好友的会话时，一定通讯录变了，变了的时候界面需要根据这个状态刷新通讯录
+		*/
+	    isModify: false
 	})
 	
 	friendMap = {}
@@ -233,6 +237,10 @@ export default class ClientChatContacts {
 		return this.data.roomGroupData
 	}
 	
+	get isModify () {
+		return this.data.isModify
+	}
+	
 	setRoomGroup (data) {
 		this.data.roomGroupData = []
 		if (data && data.length) {
@@ -483,10 +491,10 @@ export default class ClientChatContacts {
 				}
 			}
 			const qwAccountId = this.roomMap[id].qwAccountId
-			if (qwAccountId && this.data.accountBindRoomMap[qwAccountId] && this.data.accountBindRoomMap[qwAccountId][groupId]) {
-				const bindIndex = this.data.accountBindRoomMap[qwAccountId][groupId].indexOf(this.roomMap[id])
+			if (qwAccountId && this.data.accountBindFriendMap[qwAccountId] && this.data.accountBindFriendMap[qwAccountId][groupId]) {
+				const bindIndex = this.data.accountBindFriendMap[qwAccountId][groupId].indexOf(this.roomMap[id])
 				if (bindIndex >= 0) {
-					this.data.accountBindRoomMap[qwAccountId][groupId].splice(bindIndex, 1)
+					this.data.accountBindFriendMap[qwAccountId][groupId].splice(bindIndex, 1)
 				}
 			}
 		})
@@ -620,37 +628,6 @@ 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) {
@@ -761,52 +738,12 @@ export default class ClientChatContacts {
 		})
 	}
 	
-	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)
-		})
+	markModify () {
+		this.data.isModify = true
 	}
 	
-	unmarkModify (qwAccountId) {
-		if (qwAccountId) {
-			Vue.delete(this.data.modifiedAccountMap, qwAccountId)
-		}
+	unmarkModify () {
+		this.data.isModify = false
 	}
 	
 	reset () {
@@ -821,7 +758,6 @@ 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) {
@@ -833,4 +769,4 @@ export default class ClientChatContacts {
 			this.cancelRefreshRequest = null
 		}
 	}
-}
+}