@aochuang/client-sdk 1.0.278

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

@@ -0,0 +1,1048 @@
+import Vue from 'vue'
+import { isEmptyObject } from '../../../utils/util.js'
+import { createSessionId } from './utils.js'
+import { createPollRequest } from '../../../utils/util.js'
+
+const ALL_WECHAT_ACCOUNT_ID = 'all'
+
+const loopLoadAssignSessionData = (fetchFn, params) => {
+	let lastPs = null
+	let lastRs = null
+	let result = []
+	const loopFn = (params, total) => {
+	  const { taskId, size, ...nextParams } = params
+	  lastPs = fetchFn(Object.assign({}, nextParams, {
+		size,
+	    taskId,
+		total
+	  }))
+	  lastRs = lastPs.then(rs => {
+		result = result.concat(rs.data || [])
+	    if (rs.data.length < size) {
+			return result
+	    } else {
+	      return loopFn(params, result.length)
+	    }
+	  })
+	  return lastRs
+	}
+	loopFn(params, result.length)
+	if (lastRs) {
+		lastRs.abort = () => {
+			lastPs && lastPs.abort && lastPs.abort()
+		}
+	}
+	return lastRs
+}
+
+export default class ClientChatSession {
+	data = Vue.observable({
+		// 加载会话数据中
+		loading: false,
+		// 加载分配任务会话中
+		loadAssignTaskSessioning: false,
+		/**
+		 * 按照groupField分组的会话数据集合
+		*/
+		sessionGroupData: {},
+		/**
+		 * 按照groupField统计的未读会话总数
+		*/
+		// sessionUnreadCountMap: {},
+		/**
+		 * 按照groupField统计的免打扰会话 
+		 */
+		sessionMuteMap: {},
+		/**
+		 * 新增会话时回调
+		 * 如果会话的targetId对应的好友或者群不存在的时候隐藏起来 
+		*/
+		onBeforeAddSession: null,
+		/**
+		 * 置顶会话
+		*/
+		stickyTopSessionMethod: null,
+		/**
+		 * 免打扰会话
+		*/
+		muteNotificationSessionMethod: null,
+		/**
+		 * 删除会话
+		*/
+		deleteSessionMethod: null,
+		/**
+		 * 虚拟会话数据
+		*/
+		virtualSessionData: []
+	})
+
+	pollRequestMap = {}
+	
+	accountIds = []
+	
+	sessionMap = {}
+	
+	// 根据lastMsgTime记录的最早的历史聊天会话，后面分页加载数据需要
+	/**
+	 * {
+	 * 		wechatAccountId: {
+	 * 			lastMsgTime: null,
+	 *			lastUpdateTime: null
+	 * 		}
+	 * }
+	 */
+	lastSessionInfo = {}
+	
+	getSessionMethod = null
+	
+	// 为了兼容老代码，当作所有微号的会话数据用
+	get sessionData () {
+		return this.sessionGroupData[ALL_WECHAT_ACCOUNT_ID]
+	}
+	
+	get sessionGroupData () {
+		return this.data.sessionGroupData
+	}
+	
+	// get sessionUnreadCountMap () {
+	// 	return this.data.sessionUnreadCountMap
+	// }
+	
+	get sessionMuteMap () {
+		return this.data.sessionMuteMap
+	}
+	
+	get loading () {
+		return this.data.loading
+	}
+	
+	get loadAssignTaskSessioning () {
+		return this.data.loadAssignTaskSessioning
+	}
+	
+	constructor (options) {
+		options = Object.assign({
+			name: null,
+			onBeforeAddSession: null,
+			onAddSession: null,
+			loadSessionDataMethod: null, 
+			loadAssignTaskSessionDataMethod: null,
+			getNextUnreadSessionMethod: null,
+			stickyTopSessionMethod: null,
+			muteNotificationSessionMethod: null,
+			getSessionMethod: null,
+			updateSessionReadMethod: null,
+			starSessionMethod: null,
+			unstarSessionMethod: null,
+			onSessionReadChange: null,
+			onUpdateSession: null,
+			onRemoveSession: null,
+			onDeleteSession: null,
+			onClearVirtualSession: null,
+			onBeforeCreate: null
+		}, options)
+		// 实例化前时间，方便外面组合通用配置
+		if (options.onBeforeCreate) {
+			options.onBeforeCreate({
+				options,
+				instance: this
+			})
+		}
+		if (!options.loadSessionDataMethod) {
+			throw new Error('缺少loadSessionDataMethod配置')
+		}
+		if (!options.updateSessionReadMethod) {
+			throw new Error('缺少updateSessionReadMethod配置')
+		}
+		if (!options.getSessionMethod) {
+			throw new Error('缺少getSessionMethod配置')
+		}
+		if (!options.loadAssignTaskSessionDataMethod) {
+			throw new Error('缺少loadAssignTaskSessionDataMethod配置')
+		}
+		this.name = options.name
+		this.onBeforeAddSession = options.onBeforeAddSession
+		this.onAddSession = options.onAddSession
+		this.loadSessionData = options.loadSessionDataMethod
+		this.updateSessionRead = options.updateSessionReadMethod
+		this.getSessionMethod = options.getSessionMethod
+		this.loadAssignTaskSessionDataMethod = options.loadAssignTaskSessionDataMethod
+		this.stickyTopSessionMethod = options.stickyTopSessionMethod
+		this.muteNotificationSessionMethod = options.muteNotificationSessionMethod
+		this.starSessionMethod = options.starSessionMethod
+		this.unstarSessionMethod = options.unstarSessionMethod
+		this.deleteSessionMethod = options.deleteSessionMethod
+		this.onSessionReadChange = options.onSessionReadChange
+		this.onUpdateSession = options.onUpdateSession
+		this.onRemoveSession = options.onRemoveSession
+		this.onDeleteSession = options.onDeleteSession
+		this.onClearVirtualSession = options.onClearVirtualSession
+	}
+
+	generateSessionId (accountId, targetId) {
+		return createSessionId(accountId, targetId)
+	}
+	
+	/**
+	 * 设置会话数据
+	 * @params { Object } data - 会话数据集合
+	 * @params { String } wechatAccountId - 如果传wechatAccountId那么后面addSession的时候如果传wechatAccountId那么才会更新lastUpdateTime或者lastMsgTime，本质的意思是只有通过reload和loadData才刷新lastUpdateTime或者lastMsgTime，避免这个时间乱套了
+	*/
+	setSessionData (data, wechatAccountId, reset = true) {
+		if (reset) {
+			this.sessionMap = {}
+			this.data.sessionGroupData = {}
+			// this.data.sessionUnreadCountMap = {}
+			this.data.sessionMuteMap = {}
+		}
+		if (data && data.length) {
+			data.forEach(item => {
+				if (item.isDeleted) {
+					this.removeSession(item.conversationId)
+				} else {
+					this.addSession(item, wechatAccountId)
+				}
+			})
+		}
+	}
+	
+	refreshSession (sessionId) {
+		return this.getSessionMethod({
+			id: sessionId
+		}).then(rs => {
+			if (rs.data) {
+				const session = this.findSession(({ session }) => {
+					if (session.conversationId === sessionId) {
+						return true
+					}
+				})
+				if (session) {
+					this.updateSession(sessionId, rs.data)
+				} else {
+					this.addSession(rs.data)
+				}
+				return rs
+			} else {
+				return Promise.reject('未找到会话' + sessionId)
+			}
+		})
+	}
+
+	getSession (sessionId, serializeMethod) {
+		if (this.sessionMap[sessionId]) {
+			return Promise.resolve({
+				data: this.sessionMap[sessionId]
+			})
+		}
+		// 这里需要轮询从后端获取会话，后端会话更新和创建是异步的，所以要多轮训请求几次
+		if (this.pollRequestMap[sessionId]) {
+			this.pollRequestMap[sessionId].stop()
+		}
+		const pollRequest = createPollRequest(({ done, fail }) => {
+			return this.getSessionMethod({
+				id: sessionId
+			}).then((rs) => {
+				if (rs.data) {
+					done(rs)
+				}
+			})
+		})
+		this.pollRequestMap[sessionId] = pollRequest
+		return pollRequest.start().then(rs => {
+			if (serializeMethod) {
+				rs = serializeMethod(rs)
+			}
+			if (rs.data) {
+				this.addSession(rs.data)
+				return rs
+			} else {
+				return Promise.reject('未找到会话' + sessionId)
+			}
+		}).finally(() => {
+			if (this.pollRequestMap[sessionId] === pollRequest) {
+				delete this.pollRequestMap[sessionId]
+			}
+		})
+	}
+	
+	findSession (findFn) {
+		let result 
+		for (let i in this.sessionMap) {
+			if (findFn({
+				session: this.sessionMap[i]
+			})) {
+				result = this.sessionMap[i]
+				break
+			}
+		}
+		return result
+	}
+	
+	getSortField (time) {
+		const step = 1000 * 60 * 60 * 24
+		const day = Math.floor(time / step)
+		const milliseconds = time - (day * step)
+		return {
+			day: Math.abs(day - 1000000), // 排序，由大到小
+			milliseconds: Math.abs(milliseconds - 86400000) // 排序，由大到小
+		}
+	}
+	
+	_getSessionBySessionGroup (sessionId, wechatAccountId) {
+		if (!wechatAccountId) {
+			return
+		}
+		const session = this.sessionMap[sessionId]
+		if (!session) {
+			return 
+		}
+		const topField = session.stickyOnTop ? 0 : 1 // 置顶
+		const sortFields = this.getSortField(session.lastMsgTime)
+		if (!this.data.sessionGroupData[wechatAccountId]) {
+			return
+		}
+		if (!this.data.sessionGroupData[wechatAccountId][topField]) {
+			return
+		}
+		if (!this.data.sessionGroupData[wechatAccountId][topField][sortFields.day]) {
+			return
+		}
+		if (!this.data.sessionGroupData[wechatAccountId][topField][sortFields.day][sortFields.milliseconds]) {
+			return
+		}
+		return this.data.sessionGroupData[wechatAccountId][topField][sortFields.day][sortFields.milliseconds].find(v => v.conversationId === sessionId)
+	}
+	
+	_getLastSessionBySessionGroup (wechatAccountId) {
+		if (!wechatAccountId || !this._lastUpdateSessionMap || !this._lastUpdateSessionMap[wechatAccountId]) {
+			return
+		}
+		const sessionGroupData = this._lastUpdateSessionMap[wechatAccountId].lastMsgTime
+		if (!sessionGroupData) {
+			return
+		}
+		let result
+		Object.keys(sessionGroupData).reverse().some(topField => {
+			if (sessionGroupData[topField]) {
+				return Object.keys(sessionGroupData[topField]).reverse().some(dayKey => {
+					if (sessionGroupData[topField][dayKey]) {
+						return Object.keys(sessionGroupData[topField][dayKey]).reverse().some(milliseconds => {
+							if (sessionGroupData[topField][dayKey][milliseconds] && sessionGroupData[topField][dayKey][milliseconds].length) {
+								const sortItems = sessionGroupData[topField][dayKey][milliseconds].sort((a, b) => {
+									return a.lastMsgTime - b.lastMsgTime
+								})
+								result = sortItems[0]
+								return true
+							}
+						})
+					}
+				})
+			}
+		})
+		return result
+	}
+
+	/**
+	 * 获取会话置顶数据
+	*/
+	_getStickyOnTopSessionData (wechatAccountId) {
+		if (!wechatAccountId) {
+			return []
+		}
+		const sessionGroupData = this.data.sessionGroupData[wechatAccountId]
+		if (!sessionGroupData) {
+			return []
+		}
+		return Object.keys(sessionGroupData).reduce((rs, topKey) => {
+			if (topKey == 0 && sessionGroupData[topKey]) {
+				Object.keys(sessionGroupData[topKey]).forEach(dayKey => {
+					if (sessionGroupData[topKey][dayKey]) {
+						Object.keys(sessionGroupData[topKey][dayKey]).forEach(milliseconds => {
+							rs = rs.concat(sessionGroupData[topKey][dayKey][milliseconds] || [])
+						})
+					}
+				})
+			}
+			return rs
+		}, [])
+	}
+
+	/**
+	 * 新增会话
+	 * @params { Object } - data 会话数据
+	 * @params { String } - wechatAccountId  如果传wechatAccountId那么后面addSession的时候如果传wechatAccountId那么才会更新lastUpdateTime或者lastMsgTime，本质的意思是只有通过reload和loadData才刷新lastUpdateTime或者lastMsgTime，避免这个时间乱套了
+	 * 现在的逻辑是每个微号自己存自己的会话数据，只是会话是引用的，比如全部微信和指定微号会有相同的会话，这个会话数据是引用关系，方便后续更新和删除操作
+	 * {
+     *		"conversationId": "3d5398c24f1ae633047202fe17276571ef5e537e",
+     *		"lastMsgContent": "wxid_ofo60wv6hxeg22:\n群收款消息",
+	 *		"lastMsgId": "8a3bf26d3abc52976c099f67a6d509864c87f632",
+	 *		"lastMsgTime": 1723456430000,
+ 	 *		"lastMsgType": 1,
+	 *		"lastUpdateTime": 1723456614979,
+	 *		"mute": false,
+	 *		"stickyOnTop": false,
+	 *		"targetId": "659bb02ebe1ffca423f5dede29b61145b705fbad",
+	 *		"type": 1, // 0 好友，1 群聊
+	 *		"unreadMsgCount": 3,
+	 *		"wechatAccountId": "2a39a725814acf07502299ab2285fff8d44377f5"
+	 *	}
+	*/
+	addSession (data, wechatAccountId) {
+		if (!data || !data.conversationId) {
+			throw new Error('缺少必须参数conversationId')
+		}
+		if (!data.wechatAccountId) {
+			throw new Error('缺少必须参数wechatAccountId')
+		}
+		if (this.onBeforeAddSession && this.onBeforeAddSession({
+			data
+		}) === false) {
+			return
+		}
+		let nextData = data
+		// 如果会话已经存在，那么取已经存在的，以后有需要可以用data更新已经存在的会话，保持引用关系
+		if (this.sessionMap[data.conversationId]) {
+			nextData = this.sessionMap[data.conversationId]
+		} else {
+			this.sessionMap[data.conversationId] = nextData
+		}
+		const topField = nextData.stickyOnTop ? 0 : 1 // 置顶
+		if (wechatAccountId && wechatAccountId !== ALL_WECHAT_ACCOUNT_ID && nextData.wechatAccountId !== wechatAccountId) {
+			throw new Error('会话的wechatAccount和加载分组的wechatAccountId不一致')
+		}
+		const groupIds = []
+		// 传了wechatAccountId，是分页加载的，这里要保持分页加载数据的链路不受动态加载的影响
+		if (wechatAccountId) {
+			groupIds.push(wechatAccountId)
+			// 传了wechatAccountId才记录lastMsgTime和lastUpdateTime
+			const lastFields = ['lastMsgTime', 'lastUpdateTime']
+			groupIds.forEach(groupId => {
+				lastFields.forEach(lastField => {
+					const lastUpdateSortFields = this.getSortField(nextData[lastField])
+					if (!lastUpdateSortFields) {
+						return
+					}
+					if (!this._lastUpdateSessionMap) {
+						this._lastUpdateSessionMap = {}
+					}
+					if (!this._lastUpdateSessionMap[groupId]) {
+						this._lastUpdateSessionMap[groupId] = {}
+					}
+					if (!this._lastUpdateSessionMap[groupId][lastField]) {
+						this._lastUpdateSessionMap[groupId][lastField] = {}
+					}
+					if (!this._lastUpdateSessionMap[groupId][lastField][topField]) {
+						this._lastUpdateSessionMap[groupId][lastField][topField] = {}
+					}
+					if (!this._lastUpdateSessionMap[groupId][lastField][topField][lastUpdateSortFields.day]) {
+						this._lastUpdateSessionMap[groupId][lastField][topField][lastUpdateSortFields.day] = {}
+					}
+					if (!this._lastUpdateSessionMap[groupId][lastField][topField][lastUpdateSortFields.day][lastUpdateSortFields.milliseconds]) {
+						this._lastUpdateSessionMap[groupId][lastField][topField][lastUpdateSortFields.day][lastUpdateSortFields.milliseconds] = []
+					}
+					this._lastUpdateSessionMap[groupId][lastField][topField][lastUpdateSortFields.day][lastUpdateSortFields.milliseconds].push(nextData)
+				})
+			})
+		} else {
+			groupIds.push(nextData.wechatAccountId)
+			groupIds.push(ALL_WECHAT_ACCOUNT_ID)
+		}
+		// 分组的
+		const sortFields = this.getSortField(nextData.lastMsgTime)
+		groupIds.forEach(groupId => {
+			// 如果已经在分组里面了，就不新增了，
+			if (this._getSessionBySessionGroup(nextData.conversationId, groupId)) {
+				return
+			}
+			if (!this.data.sessionGroupData[groupId]) {
+				Vue.set(this.data.sessionGroupData, groupId, {})
+			}
+			if (!this.data.sessionGroupData[groupId][topField]) {
+				Vue.set(this.data.sessionGroupData[groupId], topField, {})
+			}
+			if (!this.data.sessionGroupData[groupId][topField][sortFields.day]) {
+				Vue.set(this.data.sessionGroupData[groupId][topField], sortFields.day, {})
+			}
+			if (!this.data.sessionGroupData[groupId][topField][sortFields.day][sortFields.milliseconds]) {
+				Vue.set(this.data.sessionGroupData[groupId][topField][sortFields.day], sortFields.milliseconds, [])
+			}
+			this.data.sessionGroupData[groupId][topField][sortFields.day][sortFields.milliseconds].push(nextData)
+		})
+		// if (typeof this.data.sessionUnreadCountMap[groupField] !== 'number') {
+		// 	Vue.set(this.data.sessionUnreadCountMap, groupField, 0)
+		// }
+		// if (data.unreadMsgCount) {
+		// 	this.data.sessionUnreadCountMap[groupField] += data.unreadMsgCount
+		// }
+		if (nextData.mute) {
+			if (!this.data.sessionMuteMap[nextData.wechatAccountId]) {
+				Vue.set(this.data.sessionMuteMap, nextData.wechatAccountId, {})
+			}
+			Vue.set(this.data.sessionMuteMap[nextData.wechatAccountId], nextData.conversationId, nextData)
+		}
+		// 检测一下是不是存在一样的虚拟会话，存在的话就删除
+		const virtualSessionIndex = this.data.virtualSessionData.findIndex(v => v.conversationId === nextData.conversationId)
+		if (virtualSessionIndex > -1) {
+			this.data.virtualSessionData.splice(virtualSessionIndex, 1)
+		}
+		this.onAddSession && this.onAddSession({
+			session: data
+		})
+	}
+	
+	removeSession (conversationId) {
+		if (!this.sessionMap[conversationId]) {
+			return
+		}
+		const session = this.sessionMap[conversationId]
+		if (!session) {
+			return
+		}
+		const topField = session.stickyOnTop ? 0 : 1 // 置顶
+		const groupIds = [session.wechatAccountId, ALL_WECHAT_ACCOUNT_ID]
+		const sortFields = this.getSortField(session.lastMsgTime)
+		groupIds.forEach(groupId => {
+			if (!this.data.sessionGroupData[groupId] || !this.data.sessionGroupData[groupId][topField]) {
+				return
+			}
+			const groupSession = this.data.sessionGroupData[groupId][topField]
+			if (groupSession[sortFields.day] && groupSession[sortFields.day][sortFields.milliseconds]) {
+				const groupIndex = groupSession[sortFields.day][sortFields.milliseconds].indexOf(this.sessionMap[conversationId])
+				if (groupIndex >= 0) {
+					groupSession[sortFields.day][sortFields.milliseconds].splice(groupIndex, 1)
+				}
+				if (!groupSession[sortFields.day][sortFields.milliseconds].length) {
+					Vue.delete(groupSession[sortFields.day], sortFields.milliseconds)
+				}
+				if (isEmptyObject(groupSession[sortFields.day])) {
+					Vue.delete(groupSession, sortFields.day)
+				}
+				if (isEmptyObject(this.data.sessionGroupData[groupId][topField])) {
+					Vue.delete(this.data.sessionGroupData[groupId], topField)
+				}
+				if (isEmptyObject(this.data.sessionGroupData[groupId])) {
+					Vue.delete(this.data.sessionGroupData, groupId)
+				}
+			}
+		})
+		if (this.data.sessionMuteMap[session.wechatAccountId]) {
+			delete this.data.sessionMuteMap[session.wechatAccountId][conversationId]
+		}
+		const lastFields = ['lastMsgTime', 'lastUpdateTime']
+		groupIds.forEach(groupId => {
+			if (!this._lastUpdateSessionMap || !this._lastUpdateSessionMap[groupId]) {
+				return
+			}
+			lastFields.forEach(lastField => {
+				if (!this._lastUpdateSessionMap[groupId][lastField]) {
+					return
+				}
+				Object.keys(this._lastUpdateSessionMap[groupId][lastField]).forEach(topField => {
+					if (!this._lastUpdateSessionMap[groupId][lastField][topField]) {
+						return
+					}
+					const loastUpdateSortFields = this.getSortField(session.lastUpdateTime)
+					if (this._lastUpdateSessionMap[groupId][lastField][topField][loastUpdateSortFields.day] && this._lastUpdateSessionMap[groupId][lastField][topField][loastUpdateSortFields.day][loastUpdateSortFields.milliseconds]) {
+						const index = this._lastUpdateSessionMap[groupId][lastField][topField][loastUpdateSortFields.day][loastUpdateSortFields.milliseconds].indexOf(session)
+						if (index >= 0) {
+							this._lastUpdateSessionMap[groupId][lastField][topField][loastUpdateSortFields.day][loastUpdateSortFields.milliseconds].splice(index, 1)
+						}
+						if (!this._lastUpdateSessionMap[groupId][lastField][topField][loastUpdateSortFields.day][loastUpdateSortFields.milliseconds].length) {
+							Vue.delete(this._lastUpdateSessionMap[groupId][lastField][topField][loastUpdateSortFields.day], loastUpdateSortFields.milliseconds)
+						}
+						if (isEmptyObject(this._lastUpdateSessionMap[groupId][lastField][topField][loastUpdateSortFields.day])) {
+							Vue.delete(this._lastUpdateSessionMap[groupId][lastField][topField], loastUpdateSortFields.day)
+						}
+					}
+				})
+			})
+		})
+		delete this.sessionMap[conversationId]
+		this.onRemoveSession && this.onRemoveSession({
+			session
+		})
+	}
+	
+	/**
+	 * 设置会话未读消息数量
+	 * @param sessionId - 会话id
+	 * @param props | callback - 修改时数据或者回调，会把会话的未读数量作为上下文提供
+	*/
+	updateSession (sessionId, callback) {
+		let session = this.sessionMap[sessionId]
+		if (!session) {
+			session = this.data.virtualSessionData.find(v => v.conversationId === sessionId)
+		}
+		if (!session) {
+			return
+		}
+		let nextProps = null
+		const changeProps = {}
+		if (typeof callback === 'function') {
+			nextProps = callback({
+				session
+			})
+		} else {
+			nextProps = callback
+		}
+		if (nextProps) {
+			// 分组的
+			const { unreadMsgCount, stickyOnTop, mute, lastMsgTime, ...nextUpdateProps } = nextProps
+			Object.keys(nextProps).forEach(k => {
+				if (session[k] !== nextProps[k]) {
+					changeProps[k] = {
+						before: session[k],
+						after: nextProps[k]
+					}
+				}
+			})
+			Object.keys(nextUpdateProps).forEach(k => {
+				Vue.set(session, k, nextUpdateProps[k])
+			})
+			// 处理会话时间
+			if (typeof lastMsgTime !== 'undefined' && session.lastMsgTime !== nextProps.lastMsgTime) {
+				const oldSortFields = this.getSortField(session.lastMsgTime)
+				// 把老的清空
+				// 重置一下数据
+				const groupIds = [ALL_WECHAT_ACCOUNT_ID, session.wechatAccountId]
+				groupIds.forEach(groupId => {
+					const topFields = [0, 1]
+					topFields.forEach(topField => {
+						if (
+							this.data.sessionGroupData[groupId] && 
+							this.data.sessionGroupData[groupId][topField] && 
+							this.data.sessionGroupData[groupId][topField][oldSortFields.day] && 
+							this.data.sessionGroupData[groupId][topField][oldSortFields.day][oldSortFields.milliseconds]
+						) {
+							let index = -1
+							this.data.sessionGroupData[groupId][topField][oldSortFields.day][oldSortFields.milliseconds].some((v, i) => {
+								if (v.conversationId === session.conversationId) {
+									index = i
+									return true
+								}
+							})
+							this.data.sessionGroupData[groupId][topField][oldSortFields.day][oldSortFields.milliseconds].splice(index, 1)
+						}
+					})
+				})
+				// 按照新的时间来分组排序
+				Vue.set(session, 'lastMsgTime', lastMsgTime)
+				const topField = session.stickyOnTop ? 0 : 1 // 0置顶
+				const sortFields = this.getSortField(session.lastMsgTime)
+				groupIds.forEach(groupId => {
+					// 分组的
+					if (!this.data.sessionGroupData[groupId]) {
+						Vue.set(this.data.sessionGroupData, groupId, {})
+					}
+					if (!this.data.sessionGroupData[groupId][topField]) {
+						Vue.set(this.data.sessionGroupData[groupId], topField, {})
+					}
+					if (!this.data.sessionGroupData[groupId][topField][sortFields.day]) {
+						Vue.set(this.data.sessionGroupData[groupId][topField], sortFields.day, {})
+					}
+					if (!this.data.sessionGroupData[groupId][topField][sortFields.day][sortFields.milliseconds]) {
+						Vue.set(this.data.sessionGroupData[groupId][topField][sortFields.day], sortFields.milliseconds, [])
+					}
+					this.data.sessionGroupData[groupId][topField][sortFields.day][sortFields.milliseconds].push(session)
+				})
+			}
+			// 处理未读数量逻辑
+			if (typeof unreadMsgCount !== 'undefined' && session.unreadMsgCount !== nextProps.unreadMsgCount) {
+				// const origUnreadMsgCount = session.unreadMsgCount || 0
+				Vue.set(session, 'unreadMsgCount', unreadMsgCount)
+				// let nowUnreadMsgCount = session.unreadMsgCount || 0
+				// let diffUnreadMsgCount = nowUnreadMsgCount - origUnreadMsgCount
+				// if (diffUnreadMsgCount) {
+				// 	this.data.sessionUnreadCountMap[groupField] += diffUnreadMsgCount
+				// }
+			}
+			// 处理置顶会话逻辑
+			if (typeof stickyOnTop !== 'undefined' && session.stickyOnTop !== nextProps.stickyOnTop) {
+				Vue.set(session, 'stickyOnTop', stickyOnTop)
+				const topField = nextProps.stickyOnTop ? 0 : 1 // 0置顶
+				// 把已经存在的剔除，先删后插
+				// 所有的
+				const groupIds = [ALL_WECHAT_ACCOUNT_ID, session.wechatAccountId]
+				const sortFields = this.getSortField(session.lastMsgTime)
+				groupIds.forEach(groupId => {
+					// 重置一下数据
+					const topFields = [0, 1]
+					topFields.forEach(topField => {
+						if (
+							this.data.sessionGroupData[groupId] && 
+							this.data.sessionGroupData[groupId][topField] && 
+							this.data.sessionGroupData[groupId][topField][sortFields.day] && 
+							this.data.sessionGroupData[groupId][topField][sortFields.day][sortFields.milliseconds]
+						) {
+							let index = -1
+							this.data.sessionGroupData[groupId][topField][sortFields.day][sortFields.milliseconds].some((v, i) => {
+								if (v.conversationId === session.conversationId) {
+									index = i
+									return true
+								}
+							})
+							this.data.sessionGroupData[groupId][topField][sortFields.day][sortFields.milliseconds].splice(index, 1)
+						}
+					})
+				})
+				groupIds.forEach(groupId => {
+					// 分组的
+					if (!this.data.sessionGroupData[groupId]) {
+						Vue.set(this.data.sessionGroupData, groupId, {})
+					}
+					if (!this.data.sessionGroupData[groupId][topField]) {
+						Vue.set(this.data.sessionGroupData[groupId], topField, {})
+					}
+					if (!this.data.sessionGroupData[groupId][topField][sortFields.day]) {
+						Vue.set(this.data.sessionGroupData[groupId][topField], sortFields.day, {})
+					}
+					if (!this.data.sessionGroupData[groupId][topField][sortFields.day][sortFields.milliseconds]) {
+						Vue.set(this.data.sessionGroupData[groupId][topField][sortFields.day], sortFields.milliseconds, [])
+					}
+					this.data.sessionGroupData[groupId][topField][sortFields.day][sortFields.milliseconds].push(session)
+				}) 
+			}
+			// 处理免打扰
+			if (typeof mute !== 'undefined' && session.mute !== nextProps.mute) {
+				Vue.set(session, 'mute', mute)
+				if (mute) {
+					if (!this.data.sessionMuteMap[session.wechatAccountId]) {
+						Vue.set(this.data.sessionMuteMap, session.wechatAccountId, {})
+					}
+					if (!this.data.sessionMuteMap[session.wechatAccountId][session.conversationId]) {
+						Vue.set(this.data.sessionMuteMap[session.wechatAccountId], session.conversationId, session)
+					}
+				} else {
+					if (this.data.sessionMuteMap[session.wechatAccountId]) {
+						Vue.delete(this.data.sessionMuteMap[session.wechatAccountId], session.conversationId)
+					}
+				}
+			}
+		}
+		if (changeProps && Object.keys(changeProps).length) {
+			this.onUpdateSession && this.onUpdateSession({
+				session,
+				changeProps,
+				updateProps: nextProps
+			})
+		}
+	}
+	
+	/**
+	 * 设置会话已读
+	*/
+	setSessionRead (sessionId) {
+		let session = this.sessionMap[sessionId]
+		if (!session) {
+			session =  this.data.virtualSessionData.find(v => v.conversationId === sessionId)
+		}
+		if (!session) {
+			return
+		}
+		return this.updateSessionRead({
+			conversationId: sessionId
+		}).then(() => {
+			this.markSessionRead(sessionId)
+		})
+	}
+	
+	/**
+	 * 标记会话已读，不经过服务器请求
+	*/
+	markSessionRead (sessionId) {
+		let session = this.sessionMap[sessionId]
+		if (!session) {
+			session =  this.data.virtualSessionData.find(v => v.conversationId === sessionId)
+		}
+		if (!session) {
+			return
+		}
+		const oldUnreadMsgCount = session.unreadMsgCount || 0
+		this.updateSession(sessionId, ({ session }) => {
+			return {
+				unreadMsgCount: 0
+			}
+		})
+		this.onSessionReadChange && this.onSessionReadChange({
+			session,
+			oldUnreadMsgCount
+		})
+	}
+	
+	/**
+	 * 设置账号下的会话已读
+	*/
+	setAccountSessionRead (accountId) {
+		const sessions = this.sessionGroupData[accountId]
+		if (!sessions) {
+			return
+		}
+		// 置顶的
+		for (let i in sessions) {
+			// 大时间范围
+			for (let j in sessions[i]) {
+				// 小时间范围
+				for (let k in sessions[i][j]) {
+					if (sessions[i][j][k] && sessions[i][j][k].length) {
+						sessions[i][j][k].forEach(item => {
+							this.markSessionRead(item.conversationId)
+						})
+					}
+				}
+			}
+		}
+	}
+	
+	/**
+	 * 清空账号下的所有会话数据
+	*/
+	clearAccountSession (wechatAccountId) {
+		const sessions = this.sessionGroupData[wechatAccountId]
+		if (!sessions) {
+			return
+		}
+		// 置顶的
+		for (let i in sessions) {
+			// 大时间范围
+			for (let j in sessions[i]) {
+				// 小时间范围
+				for (let k in sessions[i][j]) {
+					if (sessions[i][j][k] && sessions[i][j][k].length) {
+						sessions[i][j][k].forEach(item => {
+							this.removeSession(item.conversationId)
+						})
+					}
+				}
+			}
+		}
+	}
+	
+	/**
+	 * 加载分配好友/群任务产生的会话数据
+	*/
+	loadAssignTaskSessionData (params) {
+		params = Object.assign({
+			taskId: null, // 分配的taskId
+			total: 0 , // 已获取总数
+			size: 50 // 每次获取数量
+		}, params)
+		this.data.loadAssignTaskSessioning = true
+		return loopLoadAssignSessionData((nextParams) => {
+			return this.loadAssignTaskSessionDataMethod(nextParams)
+		}, params).then(rs => {
+			if (rs && rs.length) {
+				this.setSessionData(rs, null, false)
+			}
+			return rs
+		}).finally(() => {
+			this.data.loadAssignTaskSessioning = false
+		})
+	}
+
+	/**
+	 * 置顶会话
+	*/
+	stickyTopSession (sessionId, isTop) {
+		if (!this.stickyTopSessionMethod) {
+			throw new Error('未配置stickyTopSessionMethod')
+		}
+		return this.stickyTopSessionMethod(Object.assign({
+			conversationId: sessionId,
+			enable: isTop
+		})).then(() => {
+			return this.updateSession(sessionId, {
+				stickyOnTop: isTop
+			})
+		})
+	}
+
+	/**
+	 * 会话免打扰
+	*/
+	muteNotificationSession (sessionId, isMute) {
+		if (!this.muteNotificationSessionMethod) {
+			throw new Error('未配置muteNotificationSessionMethod')
+		}
+		return this.muteNotificationSessionMethod(Object.assign({
+			conversationId: sessionId,
+			enable: isMute
+		})).then(() => {
+			return this.updateSession(sessionId, {
+				mute: isMute
+			})
+		})
+	}
+
+	/**
+	 * 删除会话
+	*/
+	deleteSession (sessionId) {
+		if (!this.deleteSessionMethod) {
+			throw new Error('未配置deleteSessionMethod')
+		}
+		const session = this.sessionMap[sessionId]
+		return this.deleteSessionMethod({
+			conversationId: sessionId
+		}).then(() => {
+			this.removeSession(sessionId)
+			this.onDeleteSession && this.onDeleteSession({
+				session
+			})
+		})
+	}
+
+	starSession (sessionId, sync) {
+		if (!this.starSessionMethod) {
+			throw new Error('starSessionMethod未定义')
+		}
+		if (sync !== false) {
+			return this.starSessionMethod(sessionId).then(() => {
+				this.updateSession(sessionId, {
+					starMark: true
+				})
+			})
+		} else {
+			this.updateSession(sessionId, {
+				starMark: true
+			})
+		}
+	}
+
+	unstarSession (sessionId, sync) {
+		if (!this.unstarSessionMethod) {
+			throw new Error('starSessionMethod未定义')
+		}
+		if (sync !== false) {
+			return this.unstarSessionMethod(sessionId).then(() => {
+				this.updateSession(sessionId, {
+					starMark: false
+				})
+			})
+		} else {
+			this.updateSession(sessionId, {
+				starMark: false
+			})
+		}
+	}
+
+	reload (params) {
+		params = Object.assign({
+			wechatAccountId: null, // 微账号id
+			size: 20 // 本次要获取的会话条数
+		}, params, {
+			lastUpdateTime: null // 最后更新时间
+		})
+		this.data.loading = true
+		const ps1 = this.loadSessionData(params, {
+			lastSession: null,
+			lastUpdateSession: null,
+			topSessionData: null
+		})
+		ps1.then((rs) => {
+			this.setSessionData(rs.data, params.wechatAccountId || ALL_WECHAT_ACCOUNT_ID)
+		})
+		if (this.cancelLoadDataRequest) {
+			this.cancelLoadDataRequest()
+		}
+		this.cancelLoadDataRequest = () => {
+			ps1 && ps1.abort && ps1.abort()
+		}
+		return Promise.all([ps1]).then((rs) => {
+			this.data.loading = false
+			return rs[0]
+		}, err => {
+			this.data.loading = false
+			return Promise.reject(err)
+		})
+	}
+	
+	loadData (params) {
+		params = Object.assign({
+			wechatAccountId: null, // 微账号id
+			lastUpdateTime: null, // 最后更新时间
+			size: 20 // 本次要获取的会话条数
+		}, params)
+		this.data.loading = true
+		let lastSession = this._getLastSessionBySessionGroup(params.wechatAccountId || ALL_WECHAT_ACCOUNT_ID)
+		const ps1 = this.loadSessionData(params, {
+			lastSession,
+			topSessionData: this._getStickyOnTopSessionData(params.wechatAccountId || ALL_WECHAT_ACCOUNT_ID)
+		}).then(rs => {
+			// 这里地方还是需要用后端返回的数据设置，因为要将wechatAccountId记录到分组里面，addSession会做去重的
+			this.setSessionData(rs.data, params.wechatAccountId || ALL_WECHAT_ACCOUNT_ID, false)
+			return rs
+		})
+		if (this.cancelLoadDataRequest) {
+			this.cancelLoadDataRequest()
+		} 
+		this.cancelLoadDataRequest = () => {
+			ps1 && ps1.abort && ps1.abort()
+		}
+		return Promise.all([ps1]).then((rs) => {
+			this.data.loading = false
+			return rs[0]
+		}, err => {
+			this.data.loading = false
+			return Promise.reject(err)
+		})
+	}
+
+	/**
+	 * 新增虚拟会话
+	 * 虚拟会话不会在会话列表展示，主要是给选中通讯录好友或群聊的时候产生一个统一的占位数据，后面加入来了新消息，那么会用新消息产生的会话替代这个虚拟会话
+	*/
+	addVirtualSession (sessionData) {
+		if (!sessionData || typeof sessionData !== 'object') {
+			throw new Error('[ClientChatSession]虚拟会话必须是object')
+		}
+		if (!sessionData.conversationId) {
+			throw new Error('[ClientChatSession]虚拟会话缺少必须的conversationId属性')
+		}
+		if (this.data.virtualSessionData.some(v => v.conversationId === sessionData.conversationId)) {
+			console.warn('[ClientChatSession]虚拟会话' + sessionData.conversationId + '已存在')
+			return
+		}
+		this.data.virtualSessionData.push(sessionData)
+		return sessionData
+	}
+
+	/**
+	 * 获取虚拟会话
+	*/
+	getVirtualSession (sessionId) {
+		return this.data.virtualSessionData.find(v => v.conversationId === sessionId)
+	}
+
+	/**
+	 * 清除虚拟会话
+	*/
+	clearVirtualSession () {
+		const virtualSessionData = this.data.virtualSessionData
+		this.data.virtualSessionData = []
+		this.onClearVirtualSession && this.onClearVirtualSession({
+			virtualSessionData
+		})
+	}
+	
+	reset () {
+		this.data.sessionGroupData = {}
+		this.data.sessionMuteMap = {}
+		this.lastSessionInfo = {}
+		// this.data.sessionUnreadCountMap = {}
+		this.sessionMap = {}
+		if (this.cancelLoadDataRequest) {
+			this.cancelLoadDataRequest()
+			this.cancelLoadDataRequest = null
+		}
+		if (this.cancelRefreshRequest) {
+			this.cancelRefreshRequest()
+			this.cancelRefreshRequest = null
+		}
+		if (this.pollRequestMap) {
+			Object.keys(this.pollRequestMap).forEach(key => {
+				this.pollRequestMap[key].stop()
+			})
+			this.pollRequestMap = {}
+		}
+	}
+}