@aochuang/client-sdk 1.0.364 → 1.0.366

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aochuang/client-sdk",
-  "version": "1.0.364",
+  "version": "1.0.366",
   "description": "",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

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

@@ -131,6 +131,7 @@ export default class ClientChatSession {
 			stickyTopSessionMethod: null,
 			muteNotificationSessionMethod: null,
 			getSessionMethod: null,
+			onGetSessionLog: null,
 			updateSessionReadMethod: null,
 			starSessionMethod: null,
 			unstarSessionMethod: null,
@@ -166,6 +167,7 @@ export default class ClientChatSession {
 		this.loadSessionData = options.loadSessionDataMethod
 		this.updateSessionRead = options.updateSessionReadMethod
 		this.getSessionMethod = options.getSessionMethod
+		this.onGetSessionLog = options.onGetSessionLog
 		this.loadAssignTaskSessionDataMethod = options.loadAssignTaskSessionDataMethod
 		this.stickyTopSessionMethod = options.stickyTopSessionMethod
 		this.muteNotificationSessionMethod = options.muteNotificationSessionMethod
@@ -228,41 +230,139 @@ export default class ClientChatSession {
 		})
 	}
 
-	getSession (sessionId, serializeMethod) {
+	_addGetSessionLog (title, data) {
+		if (this.onGetSessionLog) {
+			this.onGetSessionLog({
+				group: 'client-chat-session:getSession',
+				content: {
+					title,
+					data
+				}
+			})
+		}
+	}
+
+	_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 = {}) {
 		if (this.sessionMap[sessionId]) {  
 			return Promise.resolve({
 				data: this.sessionMap[sessionId]
 			})
 		}
 		// 这里需要轮询从后端获取会话，后端会话更新和创建是异步的，所以要多轮训请求几次
-		if (!this.pollRequestMap[sessionId] || !this.pollRequestMap[sessionId].ps) {
-			const pollRequest = createPollRequest(({ done, fail }) => {
-				return this.getSessionMethod({
-					id: sessionId
-				}).then((rs) => {
-					if (rs.data) {
-						done(rs)
-					}
-				})
-			})
-			this.pollRequestMap[sessionId] = pollRequest
-			this.pollRequestMap[sessionId].ps = pollRequest.start().then(rs => {
-				if (serializeMethod) {
-					rs = serializeMethod(rs)
-				}
+		let pollRequest = this.pollRequestMap[sessionId]
+		if (pollRequest && pollRequest.ps) {
+			this._addGetSessionSerializeTask(pollRequest, serializeMethod, taskOptions)
+			return pollRequest.ps
+		}
+
+		pollRequest = createPollRequest(({ done }) => {
+			pollRequest.requestCount += 1
+			return this.getSessionMethod({
+				id: sessionId
+			}).then((rs) => {
 				if (rs.data) {
-					this.addSession(rs.data, null)
-					return rs
+					done(rs)
 				} else {
-					return Promise.reject('未找到会话' + sessionId)
+					pollRequest.emptyResponseCount += 1
 				}
-			}).finally(() => {
-				if (this.pollRequestMap[sessionId] === pollRequest) {
-					delete this.pollRequestMap[sessionId]
+			}, (error) => {
+				pollRequest.requestErrorCount += 1
+				pollRequest.lastRequestError = error && (error.message || error.errMsg || error.toString && error.toString()) || error
+				return Promise.reject(error)
+			})
+		})
+		pollRequest.serializeTasks = []
+		pollRequest.serializeTaskMap = {}
+		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
+		})
+		pollRequest.ps = pollRequest.start().then(rs => {
+			if (!rs.data) {
+				return Promise.reject('未找到会话' + sessionId)
+			}
+			const context = {
+				baseLastMsgTime: rs.data.lastMsgTime || 0,
+				processedMessageIds: [],
+				skippedMessageIds: [],
+				unreadMessageIds: []
+			}
+			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)
 				}
 			})
-		}
-		return this.pollRequestMap[sessionId].ps
+			this.addSession(rs.data, null)
+			const wechatAccountId = rs.data.wechatAccountId
+			this._addGetSessionLog('会话轮询合并完成', {
+				sessionId,
+				requestCount: pollRequest.requestCount,
+				emptyResponseCount: pollRequest.emptyResponseCount,
+				requestErrorCount: pollRequest.requestErrorCount,
+				duration: Date.now() - pollRequest.startedAt,
+				baseLastMsgTime: context.baseLastMsgTime,
+				lastMsgTime: rs.data.lastMsgTime,
+				lastMsgId: rs.data.lastMsgId,
+				unreadMsgCount: rs.data.unreadMsgCount,
+				processedMessageCount: context.processedMessageIds.length,
+				skippedMessageCount: context.skippedMessageIds.length,
+				unreadMessageCount: context.unreadMessageIds.length,
+				hasSessionMap: !!this.sessionMap[sessionId],
+				hasAllSessionGroup: !!this._getSessionBySessionGroup(sessionId, ALL_WECHAT_ACCOUNT_ID),
+				hasAccountSessionGroup: !!this._getSessionBySessionGroup(sessionId, wechatAccountId)
+			})
+			return rs
+		}).catch((error) => {
+			this._addGetSessionLog('会话轮询失败', {
+				sessionId,
+				requestCount: pollRequest.requestCount,
+				emptyResponseCount: pollRequest.emptyResponseCount,
+				requestErrorCount: pollRequest.requestErrorCount,
+				duration: Date.now() - pollRequest.startedAt,
+				error: error && (error.message || error.errMsg || error.toString && error.toString()) || error,
+				lastRequestError: pollRequest.lastRequestError
+			})
+			return Promise.reject(error)
+		}).finally(() => {
+			if (this.pollRequestMap[sessionId] === pollRequest) {
+				delete this.pollRequestMap[sessionId]
+			}
+		})
+		return pollRequest.ps
 	}
 	
 	findSession (findFn) {
@@ -741,7 +841,9 @@ export default class ClientChatSession {
 									return true
 								}
 							})
-							this.data.sessionGroupData[groupId][topField][oldSortFields.day][oldSortFields.milliseconds].splice(index, 1)
+							if (index >= 0) {
+								this.data.sessionGroupData[groupId][topField][oldSortFields.day][oldSortFields.milliseconds].splice(index, 1)
+							}
 						}
 					})
 				})

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

@@ -295,9 +295,10 @@ class ClientChat {
 			sortField: 'lastMsgTime',
 			name: 'session',
 			loadAssignTaskSessionDataMethod: options.loadAssignTaskSessionDataMethod,
-			loadSessionDataMethod: options.loadSessionDataMethod, 
+			loadSessionDataMethod: options.loadSessionDataMethod,
 			updateSessionReadMethod: options.updateSessionReadMethod,
 			getSessionMethod: options.getSessionMethod,
+			onGetSessionLog: data => this.socket && this.socket.addLog(data),
 			stickyTopSessionMethod: options.stickyTopSessionMethod,
 			muteNotificationSessionMethod: options.muteNotificationSessionMethod,
 			getNextUnreadSessionMethod: options.getNextUnreadSessionMethod,
@@ -417,66 +418,49 @@ class ClientChat {
 				}
 				const localSession = this.session.findSession(({ session }) => session.conversationId === sessionId)
 				if (!localSession) {
-					this.socket.addLog({
-						group: 'client-chat-message:onAddMessageSuccess',
-						content: {
-							title: '未获取到会话，开始从服务端获取',
-							data: {
-								sessionId,
-								accountId,
-								wechatFriendId: data.wechatFriendId
-							}
-						}
-					})
-					return this.session.getSession(sessionId, rs => {
-						// https://vs.rpa.cn/zentao/bug-view-2411.html
-						// 如果后端返回的未读数量是0，那么前端先自己兼容一下，因为后端更新会话是异步过程，有可能这里获取到的会话信息还是老的，并不是这个消息更新之后的信息，得看后端会不会异步改成同步
-						if (rs && rs.data && !rs.data.unreadMsgCount) {
-							rs.data.unreadMsgCount = data.isSend ? 0 : 1
-							rs.data.lastMsgContent = data.content
-							rs.data.lastMsgType = data.msgType
-							rs.data.lastMsgTime = data.wechatTime
-							rs.data.lastMsgId = data.id
-							rs.data.lastUpdateTime = data.updateDate
-						}
-						return rs
-					}).then((rs => {
-						// 前面更新未读消息数量只是处理会话的时候，因为getSession是异步的，会导致addMessage多次执行到这里，不会倒下面更新会话的逻辑
-						// 比如连续发了3条消息，然后getSession后端返回可能只会返回2条未读数，所以这里还需要补偿一下
-						const session = rs.data || {}
-						const isNewerMessage = data.wechatTime > (session.lastMsgTime || 0)
-						if (!data.isSend && isNewerMessage) {
-							if (!(this.sessionManage.currentSession && this.sessionManage.currentSession.conversationId === sessionId && this.shouldMarkCurrentSessionRead(sessionId, data))) {
-								// 更新账号未读消息数量
-								this.account.updateAccountUnreadMessageNum(session.wechatAccountId, ({ unreadMesasgeNum, unreadMessageMuteNum }) => {
-									if (session.mute) {
-										return {
-											num: (unreadMesasgeNum || 0) + 1,
-											muteNum: (unreadMessageMuteNum || 0) + 1
-										}
-									} else {
-										return {
-											num: (unreadMesasgeNum || 0) + 1,
-											muteNum: unreadMessageMuteNum
-										}
-									}
-								})
-							}
-						}
-					}), (error) => {
+					if (!this.session.pollRequestMap[sessionId]) {
 						this.socket.addLog({
 							group: 'client-chat-message:onAddMessageSuccess',
 							content: {
-								title: '未获取到会话，从服务端获取失败',
+								title: '未获取到会话，开始从服务端获取',
 								data: {
-									error: error && (error.message || error.errMsg || error.toString && error.toString()) || error,
 									sessionId,
 									accountId,
-									wechatFriendId: data.wechatFriendId
+									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
+							const isNewerMessage = data.wechatTime > (rs.data.lastMsgTime || 0)
+							if (isNewerMessage) {
+								rs.data.lastMsgContent = data.content
+								rs.data.lastMsgType = data.msgType
+								rs.data.lastMsgTime = data.wechatTime
+								rs.data.lastMsgId = data.id
+								rs.data.lastUpdateTime = data.updateDate
+							}
+							if (!data.isSend && isAfterServerMessage) {
+								if (this.sessionManage.currentSession && this.sessionManage.currentSession.conversationId === sessionId && this.shouldMarkCurrentSessionRead(sessionId, data)) {
+									rs.data.unreadMsgCount = 0
+								} else {
+									rs.data.unreadMsgCount = (rs.data.unreadMsgCount || 0) + 1
+									context.unreadMessageIds.push(data.id)
+								}
+							} else {
+								context.skippedMessageIds.push(data.id)
+							}
+						}
+						return rs
+					}, {
+						messageId: data.id,
+						wechatTime: data.wechatTime
+					}).catch(() => {})
 					} else {
 						this.session.updateSession(sessionId, ({ session }) => {
 							// listChange/getSession may already include this message in unreadMsgCount.
@@ -570,69 +554,52 @@ class ClientChat {
 				// 更新会话未读消息数量
 				const localSession = this.session.findSession(({ session }) => session.conversationId === sessionId)
 				if (!localSession) {
-					this.socket.addLog({
-						group: 'client-chat-message:onAddMessageSuccess',
-						content: {
-							title: '未获取到会话，开始从服务端获取',
-							data: {
-								sessionId,
-								accountId,
-								wechatChatroomId: data.wechatChatroomId
-							}
-						}
-					})
-					this.session.getSession(sessionId, (rs) => {
-						// https://vs.rpa.cn/zentao/bug-view-2411.html
-						// 如果后端返回的未读数量是0，那么前端先自己兼容一下，因为后端更新会话是异步过程，有可能这里获取到的会话信息还是老的，并不是这个消息更新之后的信息，得看后端会不会异步改成同步
-						if (rs && rs.data && !rs.data.unreadMsgCount) {
-							rs.data.unreadMsgCount = data.isSend ? 0 : 1
-							rs.data.lastMsgContent = data.content
-							rs.data.lastMsgType = data.msgType
-							rs.data.lastMsgTime = data.wechatTime
-							rs.data.lastMsgId = data.id
-							rs.data.lastUpdateTime = data.updateDate
-						}
-						if (rs && rs.data && atMessage && !(this.sessionManage.currentSession && this.sessionManage.currentSession.conversationId === sessionId)) {
-							rs.data.lastAtMsgContent = appendLastAtMsgContent(rs.data.lastAtMsgContent, atMessage)
-						}
-						return rs
-					}).then(rs => {
-						// 前面更新未读消息数量只是处理会话的时候，因为getSession是异步的，会导致addMessage多次执行到这里，不会倒下面更新会话的逻辑
-						// 比如连续发了3条消息，然后getSession后端返回可能只会返回2条未读数，所以这里还需要补偿一下
-						const session = rs.data || {}
-						const isNewerMessage = data.wechatTime > (session.lastMsgTime || 0)
-						if (!data.isSend && isNewerMessage) {
-							if (!(this.sessionManage.currentSession && this.sessionManage.currentSession.conversationId === sessionId && this.shouldMarkCurrentSessionRead(sessionId, data))) {
-								// 更新账号未读消息数量
-								this.account.updateAccountUnreadMessageNum(session.wechatAccountId, ({ unreadMesasgeNum, unreadMessageMuteNum }) => {
-									if (session.mute) {
-										return {
-											num: (unreadMesasgeNum || 0) + 1,
-											muteNum: (unreadMessageMuteNum || 0) + 1
-										}
-									} else {
-										return {
-											num: (unreadMesasgeNum || 0) + 1,
-											muteNum: unreadMessageMuteNum
-										}
-									}
-								})
-							}
-						}
-					}, (error) => {
+					if (!this.session.pollRequestMap[sessionId]) {
 						this.socket.addLog({
 							group: 'client-chat-message:onAddMessageSuccess',
 							content: {
-								title: '未获取到会话，从服务端获取失败',
+								title: '未获取到会话，开始从服务端获取',
 								data: {
-									error: error && (error.message || error.errMsg || error.toString && error.toString()) || error,
 									sessionId,
 									accountId,
-									wechatChatroomId: data.wechatChatroomId
+									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
+							const isNewerMessage = data.wechatTime > (rs.data.lastMsgTime || 0)
+							if (isNewerMessage) {
+								rs.data.lastMsgContent = data.content
+								rs.data.lastMsgType = data.msgType
+								rs.data.lastMsgTime = data.wechatTime
+								rs.data.lastMsgId = data.id
+								rs.data.lastUpdateTime = data.updateDate
+							}
+							if (!data.isSend && isAfterServerMessage) {
+								if (this.sessionManage.currentSession && this.sessionManage.currentSession.conversationId === sessionId && this.shouldMarkCurrentSessionRead(sessionId, data)) {
+									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)
+							}
+						}
+						return rs
+					}, {
+						messageId: data.id,
+						wechatTime: data.wechatTime
+					}).catch(() => {})
 					} else {
 						this.session.updateSession(sessionId, ({ session }) => {
 							// listChange/getSession may already include this message in unreadMsgCount.