@aochuang/client-sdk 1.0.377 → 1.0.378

package/components/chat-editor/chat-editor-suggestions/chat-editor-suggestions.vue

@@ -19,11 +19,12 @@
                 <span 
                     class="sdk-chat-editor-suggestions__close" 
                     title="关闭"
-                    @click="handleCloseClick"
+                    @mousedown.prevent.stop
+                    @click.stop="handleCloseClick"
                 ></span>
             </div>
         </div>
-        <div class="sdk-chat-editor-suggestions__body" ref="body">
+        <div class="sdk-chat-editor-suggestions__body" ref="body" @scroll="handleBodyScroll">
             <template v-if="data && data.length">
                 <div class="sdk-chat-editor-suggestions__list">
                     <div 
@@ -39,6 +40,9 @@
                     </div>
                 </div>
             </template>
+            <div v-if="loadingMore" class="sdk-chat-editor-suggestions__load-more">
+                <ui-loading size="mini" text="加载中..."></ui-loading>
+            </div>
         </div>
         <div class="sdk-chat-editor-suggestions__foot">
             <ui-icon name="information-line"></ui-icon> 提示：
@@ -68,8 +72,20 @@ export default {
             type: Boolean,
             default: false
         },
+        loadingMore: {
+            type: Boolean,
+            default: false
+        },
         confirmMethod: {
             type: Function
+        },
+        loadMoreEnabled: {
+            type: Boolean,
+            default: false
+        },
+        hasMore: {
+            type: Boolean,
+            default: false
         }
     },
     data () {
@@ -106,7 +122,16 @@ export default {
     },
     methods: {
         handleCloseClick () {
-            this.closed = true
+            this.$emit('close')
+        },
+        handleBodyScroll (evt) {
+            if (!this.loadMoreEnabled || this.loading || this.loadingMore || !this.hasMore) {
+                return
+            }
+            const target = evt.target
+            if (target.scrollHeight - target.scrollTop - target.clientHeight <= 20) {
+                this.$emit('load-more')
+            }
         },
         handleItemMouseEnter (item) {
             this.focusId = item.id
@@ -180,7 +205,10 @@ export default {
         checkAutoFocus () {
             if (!this.data || !this.data.length) {
                 this.focusId = null
-            } else {
+                return
+            }
+            const hasFocusedItem = this.data.some(item => item.id === this.focusId)
+            if (!hasFocusedItem) {
                 this.focusId = this.data[0].id
             }
         },
@@ -297,6 +325,14 @@ export default {
     overflow: auto;
     position: relative;
 }
+.sdk-chat-editor-suggestions__load-more {
+    height: 28px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: #999;
+    font-size: 12px;
+}
 .sdk-chat-editor-suggestions__foot{
     color: #999;
     line-height: 24px;

package/components/chat-editor/chat-editor.vue

@@ -46,8 +46,13 @@
                 ref="suggestions"
                 :keyword="suggestionsKeyword"
                 :loading="suggestioning"
+                :loading-more="suggestionsLoadingMore"
                 :data="suggestionsData"
                 :confirm-method="handleSuggestionsConfirmMethod"
+                :load-more-enabled="suggestionsLoadMore"
+                :has-more="suggestionsHasMore"
+                @load-more="handleSuggestionsLoadMore"
+                @close="handleSuggestionsClose"
                 @closed="handleSuggestionsClosed"
             >
                 <template slot="item" slot-scope="scope">
@@ -83,6 +88,14 @@ export default {
         fetchSuggestionsMethod: {
             type: Function
         },
+        suggestionsLoadMore: {
+            type: Boolean,
+            default: false
+        },
+        suggestionsPageSize: {
+            type: Number,
+            default: 20
+        },
         confirmSuggestionsMethod: {
             type: Function
         },
@@ -99,6 +112,8 @@ export default {
             sending: false,
             popoverActive: false,
             suggestioning: false,
+            suggestionsLoadingMore: false,
+            suggestionsHasMore: false,
             suggestionsData: [],
             suggestionsKeyword: null,
             inputValue: this.value || ''
@@ -127,6 +142,30 @@ export default {
         },
         handleSuggestionsClosed () {
             this.suggestionsData = []
+            this.suggestionsLoadingMore = false
+            this.suggestionsHasMore = false
+        },
+        handleSuggestionsClose () {
+            const range = this.cacheInputRange ? Object.assign({}, this.cacheInputRange) : null
+            this.closeSuggestions()
+            this.$nextTick(() => {
+                this.focus()
+                if (range) {
+                    this.setSelectionByTextRange(range.start, range.end)
+                }
+            })
+        },
+        handleSuggestionsLoadMore () {
+            if (!this.suggestionsLoadMore || this.suggestioning || this.suggestionsLoadingMore || !this.suggestionsHasMore) {
+                return
+            }
+            const lastItem = this.suggestionsData.length
+                ? this.suggestionsData[this.suggestionsData.length - 1]
+                : null
+            return this.loadSuggestions(this.suggestionsKeyword, this.suggestionsNearsetInfo, {
+                isLoadMore: true,
+                lastItem
+            })
         },
         handleSuggestionsConfirmMethod ({ item }) {
             const next = () => {
@@ -255,29 +294,58 @@ export default {
                 this.loadSuggestions(nearest, nearsetInfo)
             }, 200)
         },
-        loadSuggestions (keyword, nearestInfo) {
+        loadSuggestions (keyword, nearestInfo, options = {}) {
             if (!this.fetchSuggestionsMethod) {
                 return
             }
+            const isLoadMore = !!options.isLoadMore
             keyword = this.normalizeSuggestionsKeyword(nearestInfo, keyword)
+            if (!isLoadMore) {
+                this.suggestionsHasMore = false
+            }
             const requestId = (this._suggestionsRequestId || 0) + 1
             this._suggestionsRequestId = requestId
-            this.suggestioning = true
+            if (isLoadMore) {
+                this.suggestionsLoadingMore = true
+            } else {
+                this.suggestioning = true
+            }
             this.suggestionsKeyword = keyword
             this.popoverActive = true
             clearTimeout(this._loadSuggestionsTimer)
             return this.fetchSuggestionsMethod({
                 keyword,
                 nearestInfo,
-                isAtContext: !!(nearestInfo && nearestInfo.isAtContext)
+                isAtContext: !!(nearestInfo && nearestInfo.isAtContext),
+                isLoadMore,
+                lastItem: options.lastItem || null
             }).then(rs => {
                 if (requestId !== this._suggestionsRequestId) {
                     return
                 }
-                this.suggestionsData = rs || []
+                const nextData = rs || []
+                if (isLoadMore) {
+                    const ids = new Set(this.suggestionsData.map(item => item.id))
+                    this.suggestionsData = this.suggestionsData.concat(nextData.filter(item => {
+                        if (ids.has(item.id)) {
+                            return false
+                        }
+                        ids.add(item.id)
+                        return true
+                    }))
+                } else {
+                    this.suggestionsData = nextData
+                }
+                this.suggestionsHasMore = this.suggestionsLoadMore &&
+                    this.suggestionsPageSize > 0 &&
+                    nextData.length >= this.suggestionsPageSize
             }).finally(() => {
                 if (requestId === this._suggestionsRequestId) {
-                    this.suggestioning = false
+                    if (isLoadMore) {
+                        this.suggestionsLoadingMore = false
+                    } else {
+                        this.suggestioning = false
+                    }
                 }
             })
         },
@@ -294,6 +362,8 @@ export default {
             this._suggestionsRequestId = (this._suggestionsRequestId || 0) + 1
             this.$refs.suggestions && this.$refs.suggestions.close()
             this.suggestioning = false
+            this.suggestionsLoadingMore = false
+            this.suggestionsHasMore = false
             this.popoverActive = false
         },
         hasCurrentSuggestionsContext () {

package/package.json

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

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 行附近）：