yz-yuki-plugin 2.0.6-9 → 2.0.7-1

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

@@ -2,7 +2,7 @@ import QRCode from 'qrcode';
 import { Redis, Segment, Bot } from 'yunzaijs';
 import Config from '../../utils/config.js';
 import { renderPage } from '../../utils/image.js';
-import { WeiboGetWebData } from './weibo.main.get.web.data.js';
+import { WeiboWebDataFetcher } from './weibo.main.get.web.data.js';
 import { WeiboQuery } from './weibo.main.query.js';
 
 class WeiboTask {
@@ -15,16 +15,22 @@ class WeiboTask {
         this.groupKey = 'Yz:yuki:weibo:upPush:group:';
         this.privateKey = 'Yz:yuki:weibo:upPush:private:';
     }
+    /**
+     * 执行动态推送任务
+     */
     async runTask() {
         let weiboConfigData = await Config.getUserConfig('weibo', 'config');
         let weiboPushData = await Config.getUserConfig('weibo', 'push');
-        let interval = weiboConfigData.interval || 7200; // 推送间隔时间，单位为秒，默认2小时
+        let interval = weiboConfigData.interval || 7200; // 筛选何时发布的动态，单位为秒，默认2小时内发布的动态
         logger.debug(`当前微博功能配置：${JSON.stringify(weiboConfigData)}`);
         const uidMap = new Map(); // 存放group 和 private 对应所属 uid 与推送信息的映射
         const dynamicList = {}; // 存放获取的所有动态，键为 uid，值为动态数组
         await this.processWeiboData(weiboPushData, uidMap, dynamicList);
         let now = Date.now() / 1000; // 当前时间戳（秒）
-        await this.pushDynamicMessages(uidMap, dynamicList, now, interval, weiboConfigData);
+        // 定义待推送动态消息映射
+        const messageMap = new Map();
+        await this.makeUidDynamicDataMap(uidMap, dynamicList, now, interval, weiboConfigData, messageMap);
+        await this.sendDynamicMessage(messageMap, weiboConfigData);
     }
     /**
      * 处理微博数据，获取动态列表并构建 uid 映射
@@ -53,7 +59,7 @@ class WeiboTask {
                         dynamicList[subInfoOfup.uid] = dynamicData;
                     }
                     else {
-                        resp = await await new WeiboGetWebData().getBloggerDynamicList(subInfoOfup.uid); // 获取指定 uid 的动态列表
+                        resp = await new WeiboWebDataFetcher().getBloggerDynamicList(subInfoOfup.uid); // 获取指定 uid 的动态列表
                         if (resp) {
                             requestedDataOfUids.set(subInfoOfup.uid, resp); // 将响应数据存储到映射中
                             const dynamicData = resp || [];
@@ -71,14 +77,14 @@ class WeiboTask {
         requestedDataOfUids.clear(); // 清空已请求的映射
     }
     /**
-     * 推送动态消息
+     * 构建uid对应动态数据映射
      * @param uidMap uid 映射
      * @param dynamicList 动态列表
      * @param now 当前时间戳
-     * @param interval 推送间隔时间
+     * @param dynamicTimeRange 筛选何时发布的动态
      * @param weiboConfigData 微博配置数据
      */
-    async pushDynamicMessages(uidMap, dynamicList, now, interval, weiboConfigData) {
+    async makeUidDynamicDataMap(uidMap, dynamicList, now, dynamicTimeRange, weiboConfigData, messageMap) {
         for (let [chatType, chatTypeMap] of uidMap) {
             for (let [key, value] of chatTypeMap) {
                 const tempDynamicList = dynamicList[key] || [];
@@ -93,7 +99,7 @@ class WeiboTask {
                     }
                     if (!raw_post?.mblog?.created_at)
                         continue;
-                    if (Number(now - WeiboQuery.getDynamicCreatetDate(raw_post) / 1000) > interval) {
+                    if (Number(now - WeiboQuery.getDynamicCreatetDate(raw_post) / 1000) > dynamicTimeRange) {
                         logger.debug(`超过间隔，跳过   [ ${user?.screen_name} : ${user?.id} ] ${raw_post?.mblog?.created_at} 的动态`);
                         continue;
                     } // 如果超过推送时间间隔，跳过当前循环
@@ -110,7 +116,7 @@ class WeiboTask {
                         for (let chatId of chatIds) {
                             if (type && type.length && !type.includes(pushDynamicData.type))
                                 continue; // 如果禁用了某类型的动态推送，跳过当前循环
-                            await this.sendDynamic(chatId, bot_id, upName, pushDynamicData, weiboConfigData, chatType); // 发送动态消息
+                            await this.makeDynamicMessageMap(chatId, bot_id, upName, pushDynamicData, weiboConfigData, chatType, messageMap); // 发送动态消息
                             await this.randomDelay(1000, 2000); // 随机延时1-2秒
                         }
                     }
@@ -119,15 +125,16 @@ class WeiboTask {
         }
     }
     /**
-     * 发送动态消息
+     * 渲染构建待发送的动态消息数据的映射数组
      * @param chatId 聊天 ID
      * @param bot_id 机器人 ID
-     * @param upName 用户名
+     * @param upName 博主用户名
      * @param pushDynamicData 推送动态数据
      * @param weiboConfigData 微博配置数据
      * @param chatType 聊天类型
+     * @param messageMap 待发送的动态消息映射
      */
-    async sendDynamic(chatId, bot_id, upName, pushDynamicData, weiboConfigData, chatType) {
+    async makeDynamicMessageMap(chatId, bot_id, upName, pushDynamicData, weiboConfigData, chatType, messageMap) {
         const id_str = WeiboQuery.getDynamicId(pushDynamicData); // 获取动态 ID
         let sended = null, markKey = '';
         if (chatType === 'group') {
@@ -142,10 +149,16 @@ class WeiboTask {
             return; // 如果已经发送过，则直接返回
         if (!!weiboConfigData.pushMsgMode) {
             const { data, uid } = await WeiboQuery.formatDynamicData(pushDynamicData); // 处理动态数据
-            const eval2 = eval;
-            let banWords = eval2(`/${weiboConfigData.banWords.join('|')}/g`); // 构建屏蔽关键字正则表达式
-            if (new RegExp(banWords).test(`${data?.title}${data?.content}`)) {
-                return 'return'; // 如果动态包含屏蔽关键字，则直接返回
+            const getBanWords = weiboConfigData?.banWords;
+            if (getBanWords && Array.isArray(getBanWords) && getBanWords.length > 0) {
+                // 构建屏蔽关键字正则表达式，转义特殊字符
+                const banWords = new RegExp(getBanWords.map(word => word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), 'g');
+                if (banWords.test(`${data?.title}${data?.content}`)) {
+                    return 'return'; // 如果动态消息包含屏蔽关键字，则直接返回
+                }
+            }
+            else if (getBanWords && !Array.isArray(getBanWords)) {
+                logger.error(`微博动态：Yaml配置文件中，banWords 字段格式不是数组格式，请检查！`);
             }
             let boxGrid = !!weiboConfigData.boxGrid === false ? false : true; // 是否启用九宫格样式，默认为 true
             let isSplit = !!weiboConfigData.isSplit === false ? false : true; // 是否启用分片截图，默认为 true
@@ -168,44 +181,35 @@ class WeiboTask {
             };
             let imgs = await this.renderDynamicCard(uid, renderData, ScreenshotOptionsData);
             if (!imgs)
-                return;
-            Redis.set(`${markKey}${chatId}:${id_str}`, '1', { EX: 3600 * 72 }); // 设置已发送标记
-            global?.logger?.mark('优纪插件：微博动态执行推送');
-            for (let i = 0; i < imgs.length; i++) {
-                const image = imgs[i];
-                await this.sendMessage(chatId, bot_id, chatType, Segment.image(image));
-                await this.randomDelay(1000, 2000); // 随机延时1-2秒
-            }
-            await new Promise(resolve => setTimeout(resolve, 1000));
+                return; // 如果渲染失败，则直接返回
+            await this.addMessageToMap(messageMap, chatType, bot_id, chatId, 'SINGLE', id_str, extentData?.type, imgs.map(img => Segment.image(img)));
         }
         else {
             const dynamicMsg = await WeiboQuery.formatTextDynamicData(upName, pushDynamicData, false, weiboConfigData); //构建文字动态消息
-            Redis.set(`${markKey}${chatId}:${id_str}`, '1', { EX: 3600 * 72 }); // 设置已发送标记
             if (dynamicMsg === undefined || dynamicMsg === 'continue') {
                 return 'return'; // 如果动态消息构建失败或内部资源获取失败，则直接返回
             }
             const getBanWords = weiboConfigData?.banWords;
             if (getBanWords && Array.isArray(getBanWords) && getBanWords.length > 0) {
-                const banWords = new RegExp(getBanWords.join('|'), 'g'); // 构建屏蔽关键字正则表达式
+                // 构建屏蔽关键字正则表达式，转义特殊字符
+                const banWords = new RegExp(getBanWords.map(word => word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), 'g');
                 if (banWords.test(dynamicMsg.msg.join(''))) {
                     return 'return'; // 如果动态消息包含屏蔽关键字，则直接返回
                 }
             }
+            else if (getBanWords && !Array.isArray(getBanWords)) {
+                logger.error(`微博动态：Yaml配置文件中，banWords 字段格式不是数组格式，请检查！`);
+            }
             let mergeTextPic = !!weiboConfigData.mergeTextPic === false ? false : true; // 是否合并文字和图片，默认为 true
-            if (mergeTextPic) {
+            //开启了合并文本和图片
+            if (mergeTextPic === true) {
                 const mergeMsg = [...dynamicMsg.msg, ...dynamicMsg.pics];
-                await this.sendMessage(chatId, bot_id, chatType, mergeMsg);
+                await this.addMessageToMap(messageMap, chatType, bot_id, chatId, 'MERGE', id_str, dynamicMsg.dynamicType, mergeMsg);
             }
             else {
-                await this.sendMessage(chatId, bot_id, chatType, dynamicMsg.msg);
-                const pics = dynamicMsg.pics;
-                if (pics && pics.length > 0) {
-                    for (let i = 0; i < pics.length; i++) {
-                        await this.sendMessage(chatId, bot_id, chatType, pics[i]);
-                        await this.randomDelay(1000, 2000); // 随机延时1-2秒
-                    }
-                }
-                await new Promise(resolve => setTimeout(resolve, 1000));
+                //不合并文本和图片
+                await this.addMessageToMap(messageMap, chatType, bot_id, chatId, 'MERGE', id_str, dynamicMsg.dynamicType, dynamicMsg.msg);
+                await this.addMessageToMap(messageMap, chatType, bot_id, chatId, 'SINGLE', id_str, dynamicMsg.dynamicType, dynamicMsg.pics);
             }
         }
     }
@@ -286,13 +290,86 @@ class WeiboTask {
         }
     }
     /**
-     * 发送消息
+     * 收集消息映射
+     * @param messageMap 消息映射
+     * @param chatType 聊天类型
+     * @param bot_id 机器人 ID
+     * @param chatId 聊天 ID
+     * @param sendMode 发送模式: SINGLE 逐条发送，MERGE 合并发送
+     * @param dynamicUUid_str 动态 UUID
+     * @param dynamicType 动态类型
+     * @param message 消息内容
+     */
+    async addMessageToMap(messageMap, chatType, bot_id, chatId, sendMode, dynamicUUid_str, dynamicType, messages) {
+        if (!messageMap.has(chatType)) {
+            messageMap.set(chatType, new Map());
+        }
+        const botMap = messageMap.get(chatType);
+        if (!botMap?.has(bot_id)) {
+            botMap?.set(bot_id, new Map());
+        }
+        const chatMap = botMap?.get(bot_id);
+        if (!chatMap?.has(chatId)) {
+            chatMap?.set(chatId, []);
+        }
+        chatMap?.get(chatId)?.push({ sendMode, dynamicUUid_str, dynamicType, messages });
+    }
+    /**
+     * 推送动态消息
+     * @param messageMap 消息映射
+     * @param biliConfigData 微博配置数据
+     */
+    async sendDynamicMessage(messageMap, weiboConfigData) {
+        const LogMark = new Set(); // 日志mark
+        for (const [chatType, botMap] of messageMap) {
+            for (const [bot_id, chatMap] of botMap) {
+                for (const [chatId, messageCombinationList] of chatMap) {
+                    // 遍历组合消息
+                    for (const messageCombination of messageCombinationList) {
+                        const { sendMode, dynamicUUid_str, dynamicType, messages } = messageCombination;
+                        let sended = null;
+                        let markKey = '';
+                        if (chatType === 'group') {
+                            markKey = this.groupKey;
+                            sended = await Redis.get(`${markKey}${chatId}:${dynamicUUid_str}`);
+                        }
+                        else if (chatType === 'private') {
+                            markKey = this.privateKey;
+                            sended = await Redis.get(`${markKey}${chatId}:${dynamicUUid_str}`);
+                        }
+                        const sendMarkKey = `${markKey}${chatId}:${dynamicUUid_str}`;
+                        if (sended) {
+                            continue; // 如果已经发送过，则直接跳过
+                        }
+                        if (!LogMark.has('1')) {
+                            global?.logger?.mark('优纪插件: B站动态执行推送');
+                            LogMark.add('1');
+                        }
+                        if (sendMode === 'SINGLE') {
+                            for (let i = 0; i < messages.length; i++) {
+                                await this.sendMessageApi(chatId, bot_id, chatType, messages[i]);
+                            }
+                            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 }); // 发送成功后设置标记
+                        }
+                    }
+                }
+            }
+        }
+        LogMark.clear(); // 清空日志mark
+    }
+    /**
+     * 发送消息api
      * @param chatId 聊天 ID
      * @param bot_id 机器人 ID
      * @param chatType 聊天类型
      * @param message 消息内容
      */
-    async sendMessage(chatId, bot_id, chatType, message) {
+    async sendMessageApi(chatId, bot_id, chatType, message) {
         if (chatType === 'group') {
             await (Bot[bot_id] ?? Bot)
                 ?.pickGroup(String(chatId))

package/lib/utils/image.js

@@ -15,11 +15,11 @@ class Image extends Picture {
         // 继承父类实例
         super();
         // 父类已经实例化组件渲染对象
-        //this.Com;
+        //this.component;
         // 父类已经实例化启动 Puppeteer
-        //this.Pup.start();
+        //this.puppeteer.start();
         // 初始化 YukiPuppeteerRender 实例
-        this.yukiPuppeteerRender = new YukiPuppeteerRender(this.Pup);
+        this.yukiPuppeteerRender = new YukiPuppeteerRender(this.puppeteer);
     }
     /**
      * 实例方法，用于执行实际的渲染和截图操作
@@ -34,7 +34,7 @@ class Image extends Picture {
         // 根据组件名称获取对应的 React 组件
         const Page = index[page];
         // 调用 yukiPuppeteerRender 进行截图操作
-        return this.yukiPuppeteerRender.yukiScreenshot(this.Com.compile({
+        return this.yukiPuppeteerRender.yukiScreenshot(this.component.compile({
             path: page,
             name: `${uid}.html`,
             component: React.createElement(Page, { ...props }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yz-yuki-plugin",
-  "version": "2.0.6-9",
+  "version": "2.0.7-1",
   "description": "优纪插件，yunzaijs 关于 微博推送、B站推送 等功能的拓展插件",
   "author": "snowtafir",
   "type": "module",
@@ -31,12 +31,12 @@
     "debug": "^4.3.6",
     "jsdom": "^25.0.1",
     "json5": "^2.2.3",
-    "jsxp": "^1.0.8",
+    "jsxp": "^1.1.2",
     "lodash": "^4.17.21",
     "md5": "^2.3.0",
     "moment": "^2.30.1",
     "node-fetch": "^3.3.2",
-    "puppeteer": "^24.1.0",
+    "puppeteer": "^24.4.0",
     "qrcode": "^1.5.4",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
@@ -63,14 +63,14 @@
     "icqq": "^0.6.10",
     "jsdom": "^24.1.1",
     "json5": "^2.2.3",
-    "jsxp": "^1.0.8",
+    "jsxp": "^1.1.2",
     "lodash": "^4.17.21",
     "lvyjs": "^0.2.14",
     "md5": "^2.3.0",
     "node-fetch": "^3.3.2",
     "postcss": "^8.4.47",
     "prettier": "^3.4.2",
-    "puppeteer": "^24.1.0",
+    "puppeteer": "^24.4.0",
     "qrcode": "^1.5.4",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",