yz-yuki-plugin 2.0.7-1 → 2.0.7-11

package/CHANGELOG.md

@@ -1,4 +1,6 @@
 # 2.0.7
+* 修复同一up订阅多个群聊订阅，推送类型合并的问题
+* 添加白名单关键词过滤功能
 * 新增B站视频解析
 
 # 2.0.6

package/README.md

@@ -2,7 +2,7 @@
 
 # YUKI-PLUGIN
 
-- 一个适用于 `Yunzai 系列机器人框架` 的B站动态和微博动态订阅推送的插件
+- 一个适用于 `Yunzai 系列机器人框架` 的B站动态、B站视频链接解析和微博动态订阅推送的插件
 
 - 支持 群聊/私聊 订阅B站动态和微博动态，支持定时推送，支持手动触发推送，支持简单查询B站/微博用户信息。
 
@@ -160,6 +160,7 @@ https://m.weibo.cn/u/7643376782 # 7643376782 为崩坏星穹铁道博主uid
 请使用 `#优纪帮助`或 `/yuki帮助` 获取完整帮助
 
 - [x] B站动态
+- [x] B站视频链接解析
 - [x] 微博动态
 
 
@@ -190,6 +191,7 @@ https://m.weibo.cn/u/7643376782 # 7643376782 为崩坏星穹铁道博主uid
 | 删除B站ck | 删除手动获取的B站cookie，权限：Master | `#删除B站本地ck` |
 | 查看B站ck | 查看当前启用的B站ck,仅限私聊 | `#我的B站ck` |
 | 刷新B站临时ck | 重新获取并刷新redis缓存的未绑定自己的B站ck而自动获取的 临时B站cookie | `#刷新B站临时ck` |
+| B站视频链接解析 | 解析B站视频链接，支持av号、BV号、app分享链接，官方短链 | `链接xxxx` |
 ||||
 | **微博功能** | ------------------------- | ---------- |
 | 添加微博推送 | 检测博主的微博动态进行推送，权限：Master。可选分类：视频、图文、文章、转发，不加分类则默认全部 | `#订阅微博推送uid` `#订阅微博推送 图文 uid` |

package/defaultConfig/bilibili/config.yaml

@@ -43,6 +43,15 @@ pushContentLineLimit: 5
 # 是否展示定时任务的日志，0 不显示 1 显示
 pushTaskLog: 1
 
+# 白名单关键词，命中即推送，不在白名单则不推送。
+# 白名单与黑名单共同起作用，即命中白名单但不命中黑名单即推送，不在白名单或命中黑名单则不推送。
+# 白名单为空则不启用白名单功能。
+# 配置示例：
+# whiteWordslist:
+#   - 白名单关键词1
+#   - 白名单关键词2
+whiteWordslist:
+
 # 包含关键词不推送
 banWords:
   - 关键词1

package/defaultConfig/weibo/config.yaml

@@ -38,6 +38,15 @@ pushContentLineLimit: 5
 # 是否展示定时任务的日志，0 不显示 1 显示
 pushTaskLog: 1
 
+# 白名单关键词，命中即推送，不在白名单则不推送。
+# 白名单与黑名单共同起作用，即命中白名单但不命中黑名单即推送，不在白名单或命中黑名单则不推送。
+# 白名单为空则不启用白名单功能。
+# 配置示例：
+# whiteWordslist:
+#   - 白名单关键词1
+#   - 白名单关键词2
+whiteWordslist:
+
 # 包含关键词不推送
 banWords:
   - 关键词1

package/lib/apps/bilibili.js

@@ -499,9 +499,10 @@ message.use(async (e) => {
 }, [/^(#|\/)(yuki|优纪)?搜索(b站|B站|bili|bilibili|哔哩|哔哩哔哩)(up|UP)主.*$/]);
 /** 根据名称搜索up的uid*/
 message.use(async (e) => {
-    if (biliConfigData?.parseVideoLink && !!biliConfigData.parseVideoLink === false) {
+    let parseVideoLink = !!biliConfigData?.parseVideoLink === false ? false : true;
+    if (parseVideoLink === false) {
         logger?.info(`优纪B站视频链接解析配置文件已设置关闭，解析终止。`);
-        return;
+        return false;
     }
     const videoIDMatch = e.msg.match(/(b23\.tv\/([a-zA-Z0-9]+))|(www\.bilibili\.com\/video\/)?(av\d+|BV[a-zA-Z0-9]+)/);
     let videoID;

package/lib/models/bilibili/bilibili.main.get.web.data.js

@@ -4,7 +4,6 @@ import BiliApi from './bilibili.main.api.js';
 import { readSyncCookie, cookieWithBiliTicket, readSavedCookieItems, readSavedCookieOtherItems } from './bilibili.main.models.js';
 import { getWbiSign } from './bilibili.risk.wbi.js';
 import { getDmImg } from './bilibili.risk.dm.img.js';
-import { getWebId } from './bilibili.risk.w_webid.js';
 
 class BilibiliWebDataFetcher {
     e;
@@ -52,20 +51,17 @@ class BilibiliWebDataFetcher {
         let { cookie } = await readSyncCookie();
         cookie = await cookieWithBiliTicket(cookie);
         const dmImg = await getDmImg();
-        const w_webid = await getWebId(uid);
         const data = {
             mid: uid,
             token: '',
             platform: 'web',
             web_location: 1550101,
-            ...dmImg,
-            w_webid: w_webid
+            ...dmImg
         };
         let signCookie = (await readSavedCookieItems(cookie, ['SESSDATA'], false)) || (await readSavedCookieOtherItems(cookie, ['SESSDATA']));
         const { w_rid, time_stamp } = await getWbiSign(data, BiliApi.BILIBILI_HEADERS, signCookie);
         const params = {
             ...data,
-            w_webid: w_webid,
             w_rid: w_rid,
             wts: time_stamp
         };

package/lib/models/bilibili/bilibili.main.query.js

@@ -227,7 +227,7 @@ class BiliQuery {
                     case 'RICH_TEXT_NODE_TYPE_EMOJI':
                         // 处理表情类型，使用 img 标签显示表情
                         const emoji = node.emoji;
-                        return `<img src="${emoji?.icon_url}" alt="${emoji?.text}" title="${emoji?.text}" style="vertical-align: middle; width: ${emoji?.size ? Number(emoji?.size) * 2 : 2}em; height: ${emoji?.size ? Number(emoji?.size) * 2 : 2}em;">`;
+                        return `<img src="${emoji?.icon_url}" alt="${emoji?.text}" title="${emoji?.text}" style="vertical-align: middle; width: ${emoji?.size ? Number(emoji?.size) * 1.5 : 1.5}em; height: ${emoji?.size ? Number(emoji?.size) * 1.5 : 1.5}em;">`;
                     case 'RICH_TEXT_NODE_TYPE_GOODS':
                         // 处理商品推广类型，使用官方的HTML标签写法
                         const goods_url = node?.jump_url;
@@ -346,7 +346,7 @@ class BiliQuery {
                                         case 'RICH_TEXT_NODE_TYPE_EMOJI':
                                             // 处理表情类型，使用 img 标签显示表情
                                             const emoji = node?.rich?.emoji;
-                                            return `<img src="${emoji?.icon_url}" alt="${emoji?.text}" title="${emoji?.text}" style="vertical-align: middle; width: ${emoji?.size ? Number(emoji?.size) * 2 : 2}em; height: ${emoji?.size ? Number(emoji?.size) * 2 : 2}em;">`;
+                                            return `<img src="${emoji?.icon_url}" alt="${emoji?.text}" title="${emoji?.text}" style="vertical-align: middle; width: ${emoji?.size ? Number(emoji?.size) * 1.5 : 1.5}em; height: ${emoji?.size ? Number(emoji?.size) * 1.5 : 1.5}em;">`;
                                         case 'RICH_TEXT_NODE_TYPE_GOODS':
                                             // 处理商品推广类型，使用官方的HTML标签写法
                                             const goods_url = node?.rich?.jump_url;

package/lib/models/bilibili/bilibili.main.task.js

@@ -71,39 +71,40 @@ class BiliTask {
             for (let chatId in biliPushData[chatType]) {
                 const subUpsOfChat = Array.prototype.slice.call(biliPushData[chatType][chatId] || []);
                 for (let subInfoOfup of subUpsOfChat) {
+                    const { uid, bot_id, name, type } = subInfoOfup;
                     let resp;
                     // 检查是否已经请求过该 uid
-                    if (requestedDataOfUids.has(subInfoOfup.uid)) {
-                        resp = requestedDataOfUids.get(subInfoOfup.uid); // 从已请求的映射中获取响应数据
-                        const dynamicData = resp.data?.items || [];
-                        dynamicList[subInfoOfup.uid] = dynamicData;
-                    }
-                    else {
-                        resp = await this.hendleEventDynamicData(subInfoOfup.uid);
+                    if (!requestedDataOfUids.has(uid)) {
+                        resp = await this.hendleEventDynamicData(uid);
                         if (resp) {
                             if (resp.code === 0) {
-                                requestedDataOfUids.set(subInfoOfup.uid, resp); // 将响应数据存储到映射中
+                                requestedDataOfUids.set(uid, resp); // 将响应数据存储到映射中
                                 const dynamicData = resp.data?.items || [];
-                                dynamicList[subInfoOfup.uid] = dynamicData;
+                                dynamicList[uid] = dynamicData;
                             }
                             else if (resp.code === -352) {
-                                logger.error(`获取 ${subInfoOfup.uid} 动态失败，resCode：-352，请待下次任务自动重试`);
+                                logger.error(`获取 ${uid} 动态失败，resCode：-352，请待下次任务自动重试`);
                                 return;
                             }
                             else if (resp.code !== 0) {
-                                logger.error(`获取 ${subInfoOfup.uid} 动态失败，resCode：${resp.code}，请待下次任务自动重试`);
+                                logger.error(`获取 ${uid} 动态失败，resCode：${resp.code}，请待下次任务自动重试`);
                                 return;
                             }
                         }
                         else {
-                            logger.error(`获取 ${subInfoOfup.uid} 动态失败，无响应数据，请待下次任务自动重试`);
+                            logger.error(`获取 ${uid} 动态失败，无响应数据，请待下次任务自动重试`);
                             return;
                         }
                     }
-                    const chatIds = Array.from(new Set([...Object((chatTypeMap.get(subInfoOfup.uid) && chatTypeMap.get(subInfoOfup.uid).chatIds) || []), chatId]));
-                    const bot_id = subInfoOfup.bot_id || [];
-                    const { name, type } = subInfoOfup;
-                    chatTypeMap.set(subInfoOfup.uid, { chatIds, bot_id, upName: name, type });
+                    if (!chatTypeMap.has(uid)) {
+                        chatTypeMap.set(uid, new Map());
+                    }
+                    const botChatMap = chatTypeMap.get(uid);
+                    if (!botChatMap?.has(bot_id)) {
+                        botChatMap?.set(bot_id, new Map());
+                    }
+                    const chatMap = botChatMap?.get(bot_id);
+                    chatMap?.set(chatId, { upName: name, types: type });
                     await this.randomDelay(2000, getDataRandomDelay); // 随机延时
                 }
             }
@@ -119,11 +120,11 @@ class BiliTask {
      * @param biliConfigData Bilibili配置数据
      */
     async makeUidDynamicDataMap(uidMap, dynamicList, now, dynamicTimeRange, biliConfigData, messageMap) {
+        const printedList = new Set(); // 已打印的动态列表
         for (let [chatType, chatTypeMap] of uidMap) {
-            for (let [key, value] of chatTypeMap) {
-                const tempDynamicList = dynamicList[key] || [];
+            for (let [upUid, bot_idMap] of chatTypeMap) {
+                const tempDynamicList = dynamicList[upUid] || [];
                 const willPushDynamicList = [];
-                const printedList = new Set(); // 已打印的动态列表
                 for (let dynamicItem of tempDynamicList) {
                     let author = dynamicItem?.modules?.module_author || {};
                     if (!printedList.has(author?.mid)) {
@@ -136,19 +137,19 @@ class BiliTask {
                         logger.debug(`超过间隔，跳过  [ ${author?.name} : ${author?.mid} ] ${author?.pub_time} 的动态`);
                         continue;
                     } // 如果超过推送时间间隔，跳过当前循环
-                    if (dynamicItem.type === 'DYNAMIC_TYPE_FORWARD' && !biliConfigData.pushTransmit)
-                        continue; // 如果关闭了转发动态的推送，跳过当前循环
+                    if (dynamicItem?.type === 'DYNAMIC_TYPE_FORWARD' && !biliConfigData.pushTransmit) {
+                        continue;
+                    } // 如果关闭了转发动态的推送，跳过当前循环
                     willPushDynamicList.push(dynamicItem);
                 }
-                printedList.clear();
-                const pushMapInfo = value || {}; // 获取当前 uid 对应的推送信息
-                const { chatIds, bot_id, upName, type } = pushMapInfo;
                 // 遍历待推送的动态数组，发送动态消息
-                for (let pushDynamicData of willPushDynamicList) {
-                    if (chatIds && chatIds.length) {
-                        for (let chatId of chatIds) {
-                            if (type && type.length && !type.includes(pushDynamicData.type))
-                                continue; // 如果禁用了某类型的动态推送，跳过当前循环
+                for (let [bot_id, chatIdMap] of bot_idMap) {
+                    for (let [chatId, subUpInfo] of chatIdMap) {
+                        const { upName, types } = subUpInfo;
+                        for (let pushDynamicData of willPushDynamicList) {
+                            if (types && types.length > 0 && !types.includes(pushDynamicData.type)) {
+                                continue;
+                            } // 如果禁用了某类型的动态推送，跳过当前循环
                             await this.makeDynamicMessageMap(chatId, bot_id, upName, pushDynamicData, biliConfigData, chatType, messageMap); // 发送动态消息
                             await this.randomDelay(1000, 2000); // 随机延时1-2秒
                         }
@@ -156,6 +157,7 @@ class BiliTask {
                 }
             }
         }
+        printedList.clear(); // 清空已打印的动态列表
     }
     /**
      * 渲染构建待发送的动态消息数据的映射数组
@@ -184,12 +186,23 @@ class BiliTask {
         if (pushMsgMode === 'PIC') {
             const { data, uid } = await BiliQuery.formatDynamicData(pushDynamicData); // 处理动态数据
             const extentData = { ...data };
+            const getWhiteWords = biliConfigData?.whiteWordslist;
             const getBanWords = biliConfigData?.banWords;
+            if (getWhiteWords && Array.isArray(getWhiteWords) && getWhiteWords.length > 0) {
+                // 构建白名单关键字正则表达式，转义特殊字符
+                const whiteWords = new RegExp(getWhiteWords.map(word => word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), 'g');
+                if (!whiteWords.test(`${extentData?.title}${extentData?.content}`)) {
+                    return; // 如果动态消息不在白名单中，则直接返回
+                }
+            }
+            else if (getWhiteWords && !Array.isArray(getWhiteWords)) {
+                logger.error(`B站动态：Yaml配置文件中，whiteWordslist 字段格式不是数组格式，请检查！`);
+            }
             if (getBanWords && Array.isArray(getBanWords) && getBanWords.length > 0) {
                 // 构建屏蔽关键字正则表达式，转义特殊字符
                 const banWords = new RegExp(getBanWords.map(word => word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), 'g');
                 if (banWords.test(`${extentData?.title}${extentData?.content}`)) {
-                    return 'return'; // 如果动态消息包含屏蔽关键字，则直接返回
+                    return; // 如果动态消息包含屏蔽关键字，则直接返回
                 }
             }
             else if (getBanWords && !Array.isArray(getBanWords)) {
@@ -223,7 +236,18 @@ class BiliTask {
             if (dynamicMsg === undefined || dynamicMsg === 'continue') {
                 return 'return'; // 如果动态消息构建失败，则直接返回
             }
+            const getWhiteWords = biliConfigData?.whiteWordslist;
             const getBanWords = biliConfigData?.banWords;
+            if (getWhiteWords && Array.isArray(getWhiteWords) && getWhiteWords.length > 0) {
+                // 构建白名单关键字正则表达式，转义特殊字符
+                const whiteWords = new RegExp(getWhiteWords.map(word => word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), 'g');
+                if (!whiteWords.test(dynamicMsg.msg.join(''))) {
+                    return; // 如果动态消息不在白名单中，则直接返回
+                }
+            }
+            else if (getWhiteWords && !Array.isArray(getWhiteWords)) {
+                logger.error(`B站动态：Yaml配置文件中，whiteWordslist 字段格式不是数组格式，请检查！`);
+            }
             if (getBanWords && Array.isArray(getBanWords) && getBanWords.length > 0) {
                 // 构建屏蔽关键字正则表达式，转义特殊字符
                 const banWords = new RegExp(getBanWords.map(word => word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), 'g');
@@ -399,15 +423,22 @@ class BiliTask {
                             }
                         }
                         if (sendMode === 'SINGLE') {
+                            let allSent = true;
                             for (let i = 0; i < messages.length; i++) {
-                                await this.sendMessageApi(chatId, bot_id, chatType, messages[i]);
+                                if (!(await this.sendMessageApi(chatId, bot_id, chatType, messages[i]))) {
+                                    allSent = false;
+                                    break; // 如果有任何一条消息发送失败，停止发送后续消息
+                                }
+                            }
+                            if (allSent) {
+                                await Redis.set(sendMarkKey, '1', { EX: 3600 * 72 }); // 发送成功后设置标记
+                                await this.randomDelay(1000, 2000); // 随机延时1-2秒
                             }
-                            await Redis.set(sendMarkKey, '1', { EX: 3600 * 72 }); // 发送成功后设置标记
-                            await this.randomDelay(1000, 2000); // 随机延时1-2秒
                         }
                         else if (sendMode === 'MERGE') {
-                            await this.sendMessageApi(chatId, bot_id, chatType, messages);
-                            await Redis.set(sendMarkKey, '1', { EX: 3600 * 72 }); // 发送成功后设置标记
+                            if (await this.sendMessageApi(chatId, bot_id, chatType, messages)) {
+                                await Redis.set(sendMarkKey, '1', { EX: 3600 * 72 }); // 发送成功后设置标记
+                            }
                         }
                     }
                 }
@@ -423,21 +454,18 @@ class BiliTask {
      * @param message 消息内容
      */
     async sendMessageApi(chatId, bot_id, chatType, message) {
-        if (chatType === 'group') {
-            await (Bot[bot_id] ?? Bot)
-                ?.pickGroup(String(chatId))
-                .sendMsg(message) // 发送群聊
-                .catch((error) => {
-                global?.logger?.error(`群组[${chatId}]推送失败：${JSON.stringify(error)}`);
-            });
+        try {
+            if (chatType === 'group') {
+                await (Bot[bot_id] ?? Bot)?.pickGroup(String(chatId)).sendMsg(message); // 发送群聊
+            }
+            else if (chatType === 'private') {
+                await (Bot[bot_id] ?? Bot)?.pickFriend(String(chatId)).sendMsg(message); // 发送好友私聊
+            }
+            return true; // 发送成功
         }
-        else if (chatType === 'private') {
-            await (Bot[bot_id] ?? Bot)
-                ?.pickFriend(String(chatId))
-                .sendMsg(message)
-                .catch((error) => {
-                global?.logger?.error(`用户[${chatId}]推送失败：${JSON.stringify(error)}`);
-            }); // 发送好友私聊
+        catch (error) {
+            global?.logger?.error(`${chatType === 'group' ? '群聊' : '私聊'} ${chatId} 消息发送失败：${JSON.stringify(error)}`);
+            return false; // 发送失败
         }
     }
     /**

package/lib/models/bilibili/bilibili.risk.dm.img.js

@@ -1,16 +1,16 @@
 /**获取dm参数 */
 async function getDmImg() {
-    const dm_img_list = [];
+    const dm_img_list = `[]`;
     //Buffer.from("WebGL 1", 'utf-8').toString("base64") //webgl version的值 WebGL 1 的base64 编码
     const dm_img_str = 'V2ViR0wgMS';
     //webgl unmasked renderer的值拼接webgl unmasked vendor的值的base64编码
     const dm_cover_img_str = 'QU5HTEUgKEludGVsLCBJbnRlbChSKSBIRCBHcmFwaGljcyBEaXJlY3QzRDExIHZzXzVfMCBwc181XzApLCBvciBzaW1pbGFyR29vZ2xlIEluYy4gKEludGVsKQ';
-    const dm_img_inter = { ds: [], wh: [0, 0, 0], of: [0, 0, 0] };
+    const dm_img_inter = `{ds:[],wh:[0,0,0],of:[0,0,0]}`;
     return {
-        dm_img_list: String(dm_img_list).replace(/\s+/g, ''),
+        dm_img_list: dm_img_list,
         dm_img_str: dm_img_str,
         dm_cover_img_str: dm_cover_img_str,
-        dm_img_inter: String(dm_img_inter).replace(/\s+/g, '')
+        dm_img_inter: dm_img_inter
     };
 }
 

package/lib/models/weibo/weibo.main.task.js

@@ -51,25 +51,26 @@ class WeiboTask {
             for (let chatId in weiboPushData[chatType]) {
                 const subUpsOfChat = Array.prototype.slice.call(weiboPushData[chatType][chatId] || []);
                 for (let subInfoOfup of subUpsOfChat) {
+                    const { uid, bot_id, name, type } = subInfoOfup;
                     let resp;
                     // 检查是否已经请求过该 uid
-                    if (requestedDataOfUids.has(subInfoOfup.uid)) {
-                        resp = requestedDataOfUids.get(subInfoOfup.uid); // 从已请求的映射中获取响应数据
-                        const dynamicData = resp || [];
-                        dynamicList[subInfoOfup.uid] = dynamicData;
-                    }
-                    else {
-                        resp = await new WeiboWebDataFetcher().getBloggerDynamicList(subInfoOfup.uid); // 获取指定 uid 的动态列表
+                    if (!requestedDataOfUids.has(uid)) {
+                        resp = await new WeiboWebDataFetcher().getBloggerDynamicList(uid); // 获取指定 uid 的动态列表
                         if (resp) {
-                            requestedDataOfUids.set(subInfoOfup.uid, resp); // 将响应数据存储到映射中
+                            requestedDataOfUids.set(uid, resp); // 将响应数据存储到映射中
                             const dynamicData = resp || [];
                             dynamicList[subInfoOfup.uid] = dynamicData;
                         }
                     }
-                    const chatIds = Array.from(new Set([...Object((chatTypeMap.get(subInfoOfup.uid) && chatTypeMap.get(subInfoOfup.uid).chatIds) || []), chatId]));
-                    const bot_id = subInfoOfup.bot_id || [];
-                    const { name, type } = subInfoOfup;
-                    chatTypeMap.set(subInfoOfup.uid, { chatIds, bot_id, upName: name, type });
+                    if (!chatTypeMap.has(uid)) {
+                        chatTypeMap.set(uid, new Map());
+                    }
+                    const botChatMap = chatTypeMap.get(uid);
+                    if (!botChatMap?.has(bot_id)) {
+                        botChatMap?.set(bot_id, new Map());
+                    }
+                    const chatMap = botChatMap?.get(bot_id);
+                    chatMap?.set(chatId, { upName: name, types: type });
                     await this.randomDelay(1000, 4000); // 随机延时1-4秒
                 }
             }
@@ -85,11 +86,11 @@ class WeiboTask {
      * @param weiboConfigData 微博配置数据
      */
     async makeUidDynamicDataMap(uidMap, dynamicList, now, dynamicTimeRange, weiboConfigData, messageMap) {
+        const printedList = new Set(); // 已打印的动态列表
         for (let [chatType, chatTypeMap] of uidMap) {
-            for (let [key, value] of chatTypeMap) {
-                const tempDynamicList = dynamicList[key] || [];
+            for (let [upUid, bot_idMap] of chatTypeMap) {
+                const tempDynamicList = dynamicList[upUid] || [];
                 const willPushDynamicList = [];
-                const printedList = new Set(); // 已打印的动态列表
                 for (let dynamicItem of tempDynamicList) {
                     let raw_post = dynamicItem || {};
                     let user = raw_post?.mblog?.user || {};
@@ -103,19 +104,19 @@ class WeiboTask {
                         logger.debug(`超过间隔，跳过   [ ${user?.screen_name} : ${user?.id} ] ${raw_post?.mblog?.created_at} 的动态`);
                         continue;
                     } // 如果超过推送时间间隔，跳过当前循环
-                    if (dynamicItem.type === 'DYNAMIC_TYPE_FORWARD' && !weiboConfigData.pushTransmit)
-                        continue; // 如果关闭了转发动态的推送，跳过当前循环
+                    if (dynamicItem?.type === 'DYNAMIC_TYPE_FORWARD' && !weiboConfigData.pushTransmit) {
+                        continue;
+                    } // 如果关闭了转发动态的推送，跳过当前循环
                     willPushDynamicList.push(dynamicItem);
                 }
-                printedList.clear();
-                const pushMapInfo = value || {}; // 获取当前 uid 对应的推送信息
-                const { chatIds, bot_id, upName, type } = pushMapInfo;
                 // 遍历待推送的动态数组，发送动态消息
-                for (let pushDynamicData of willPushDynamicList) {
-                    if (chatIds && chatIds.length) {
-                        for (let chatId of chatIds) {
-                            if (type && type.length && !type.includes(pushDynamicData.type))
-                                continue; // 如果禁用了某类型的动态推送，跳过当前循环
+                for (let [bot_id, chatIdMap] of bot_idMap) {
+                    for (let [chatId, subUpInfo] of chatIdMap) {
+                        const { upName, types } = subUpInfo;
+                        for (let pushDynamicData of willPushDynamicList) {
+                            if (types && types.length > 0 && !types.includes(pushDynamicData.type)) {
+                                continue;
+                            } // 如果禁用了某类型的动态推送，跳过当前循环
                             await this.makeDynamicMessageMap(chatId, bot_id, upName, pushDynamicData, weiboConfigData, chatType, messageMap); // 发送动态消息
                             await this.randomDelay(1000, 2000); // 随机延时1-2秒
                         }
@@ -123,6 +124,7 @@ class WeiboTask {
                 }
             }
         }
+        printedList.clear(); // 清空已打印的动态列表
     }
     /**
      * 渲染构建待发送的动态消息数据的映射数组
@@ -149,7 +151,18 @@ class WeiboTask {
             return; // 如果已经发送过，则直接返回
         if (!!weiboConfigData.pushMsgMode) {
             const { data, uid } = await WeiboQuery.formatDynamicData(pushDynamicData); // 处理动态数据
+            const getWhiteWords = weiboConfigData?.whiteWordslist;
             const getBanWords = weiboConfigData?.banWords;
+            if (getWhiteWords && Array.isArray(getWhiteWords) && getWhiteWords.length > 0) {
+                // 构建白名单关键字正则表达式，转义特殊字符
+                const whiteWords = new RegExp(getWhiteWords.map(word => word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), 'g');
+                if (!whiteWords.test(`${data?.title}${data?.content}`)) {
+                    return; // 如果动态消息不在白名单中，则直接返回
+                }
+            }
+            else if (getWhiteWords && !Array.isArray(getWhiteWords)) {
+                logger.error(`微博动态：Yaml配置文件中，whiteWordslist 字段格式不是数组格式，请检查！`);
+            }
             if (getBanWords && Array.isArray(getBanWords) && getBanWords.length > 0) {
                 // 构建屏蔽关键字正则表达式，转义特殊字符
                 const banWords = new RegExp(getBanWords.map(word => word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), 'g');
@@ -189,7 +202,18 @@ class WeiboTask {
             if (dynamicMsg === undefined || dynamicMsg === 'continue') {
                 return 'return'; // 如果动态消息构建失败或内部资源获取失败，则直接返回
             }
+            const getWhiteWords = weiboConfigData?.whiteWordslist;
             const getBanWords = weiboConfigData?.banWords;
+            if (getWhiteWords && Array.isArray(getWhiteWords) && getWhiteWords.length > 0) {
+                // 构建白名单关键字正则表达式，转义特殊字符
+                const whiteWords = new RegExp(getWhiteWords.map(word => word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), 'g');
+                if (!whiteWords.test(dynamicMsg.msg.join(''))) {
+                    return; // 如果动态消息不在白名单中，则直接返回
+                }
+            }
+            else if (getWhiteWords && !Array.isArray(getWhiteWords)) {
+                logger.error(`微博动态：Yaml配置文件中，whiteWordslist 字段格式不是数组格式，请检查！`);
+            }
             if (getBanWords && Array.isArray(getBanWords) && getBanWords.length > 0) {
                 // 构建屏蔽关键字正则表达式，转义特殊字符
                 const banWords = new RegExp(getBanWords.map(word => word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), 'g');
@@ -346,15 +370,22 @@ class WeiboTask {
                             LogMark.add('1');
                         }
                         if (sendMode === 'SINGLE') {
+                            let allSent = true;
                             for (let i = 0; i < messages.length; i++) {
-                                await this.sendMessageApi(chatId, bot_id, chatType, messages[i]);
+                                if (!(await this.sendMessageApi(chatId, bot_id, chatType, messages[i]))) {
+                                    allSent = false;
+                                    break; // 如果有任何一条消息发送失败，停止发送后续消息
+                                }
+                            }
+                            if (allSent) {
+                                await Redis.set(sendMarkKey, '1', { EX: 3600 * 72 }); // 发送成功后设置标记
+                                await this.randomDelay(1000, 2000); // 随机延时1-2秒
                             }
-                            await Redis.set(sendMarkKey, '1', { EX: 3600 * 72 }); // 发送成功后设置标记
-                            await this.randomDelay(1000, 2000); // 随机延时1-2秒
                         }
                         else if (sendMode === 'MERGE') {
-                            await this.sendMessageApi(chatId, bot_id, chatType, messages);
-                            await Redis.set(sendMarkKey, '1', { EX: 3600 * 72 }); // 发送成功后设置标记
+                            if (await this.sendMessageApi(chatId, bot_id, chatType, messages)) {
+                                await Redis.set(sendMarkKey, '1', { EX: 3600 * 72 }); // 发送成功后设置标记
+                            }
                         }
                     }
                 }
@@ -370,21 +401,18 @@ class WeiboTask {
      * @param message 消息内容
      */
     async sendMessageApi(chatId, bot_id, chatType, message) {
-        if (chatType === 'group') {
-            await (Bot[bot_id] ?? Bot)
-                ?.pickGroup(String(chatId))
-                .sendMsg(message) // 发送群聊
-                .catch(error => {
-                global?.logger?.error(`群组[${chatId}]推送失败：${JSON.stringify(error)}`);
-            });
+        try {
+            if (chatType === 'group') {
+                await (Bot[bot_id] ?? Bot)?.pickGroup(String(chatId)).sendMsg(message); // 发送群聊
+            }
+            else if (chatType === 'private') {
+                await (Bot[bot_id] ?? Bot)?.pickFriend(String(chatId)).sendMsg(message); // 发送好友私聊
+            }
+            return true; // 发送成功
         }
-        else if (chatType === 'private') {
-            await (Bot[bot_id] ?? Bot)
-                ?.pickFriend(String(chatId))
-                .sendMsg(message)
-                .catch(error => {
-                global?.logger?.error(`用户[${chatId}]推送失败：${JSON.stringify(error)}`);
-            }); // 发送好友私聊
+        catch (error) {
+            global?.logger?.error(`${chatType === 'group' ? '群聊' : '私聊'} ${chatId} 消息发送失败：${JSON.stringify(error)}`);
+            return false; // 发送失败
         }
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yz-yuki-plugin",
-  "version": "2.0.7-1",
+  "version": "2.0.7-11",
   "description": "优纪插件，yunzaijs 关于 微博推送、B站推送 等功能的拓展插件",
   "author": "snowtafir",
   "type": "module",

package/resources/css/dynamic/MainPage.css

@@ -25,8 +25,10 @@ body::-webkit-scrollbar {
   font-style: normal;
 }
 
+@import url('https://s1.hdslb.com/bfs/static/jinkela/long/font/regular.css');
+
 body {
-  font-family: 'OPSans', Arial, sans-serif;
+  font-family: 'OPSans', 'HarmonyOS_Regular', 'PingFang SC', 'Microsoft YaHei', Arial, sans-serif;
   background-color: #f9f9f9;
   margin: 0;
   padding: 0;

package/lib/models/bilibili/bilibili.risk.w_webid.js

@@ -1,46 +0,0 @@
-import axios from 'axios';
-import lodash from 'lodash';
-import { Redis } from 'yunzaijs';
-import BiliApi from './bilibili.main.api.js';
-import { readSyncCookie, cookieWithBiliTicket } from './bilibili.main.models.js';
-
-async function getWebId(uid) {
-    const w_webid_key = 'Yz:yuki:bili:w_webid';
-    const w_webid = await Redis.get(w_webid_key);
-    const keyTTL = await Redis.ttl(w_webid_key);
-    if (w_webid && keyTTL < 259200) {
-        return String(w_webid);
-    }
-    else {
-        const url = `https://space.bilibili.com/${uid ? uid : 401742377}/dynamic`;
-        let { cookie } = await readSyncCookie();
-        cookie = await cookieWithBiliTicket(cookie);
-        const res = await axios.get(url, {
-            timeout: 8000,
-            headers: lodash.merge(BiliApi.BILIBILI_DYNAMIC_SPACE_HEADERS, {
-                Cookie: `${cookie}`,
-                Host: `space.bilibili.com`
-            })
-        });
-        const htmlContent = await res.data;
-        const htmlContentRegex = /="__RENDER_DATA__"\s*type="application\/json">(.*?)<\/script>/;
-        const __RENDER_DATA__ = htmlContent.match(htmlContentRegex);
-        if (__RENDER_DATA__ && __RENDER_DATA__[1]) {
-            const decoded__RENDER_DATA__JsonString = decodeURIComponent(__RENDER_DATA__[1]);
-            const accessIdRegex = /"access_id":"(.*?)"/;
-            const access_id = decoded__RENDER_DATA__JsonString.match(accessIdRegex);
-            const ExpirationTimeRegex = /document.getElementById\("__RENDER_DATA__"\).*?setTimeout\(function\(\)\s*{window.location.reload\(true\);},\s*(\d+)\s*\*\s*(\d+)\);<\/script>/;
-            const ExpirationTime = htmlContent.match(ExpirationTimeRegex);
-            if (access_id && access_id[1] && ExpirationTime && ExpirationTime[1]) {
-                await Redis.set(w_webid_key, access_id[1], { EX: Number(ExpirationTime[1]) });
-                return String(access_id[1]);
-            }
-            else {
-                console.error('Failed to get access_id from __RENDER_DATA__');
-                return null;
-            }
-        }
-    }
-}
-
-export { getWebId };