koishi-plugin-bilibili-notify 3.1.1-alpha.0 → 3.1.3-alpha.0

package/lib/comRegister.d.ts

@@ -1,7 +1,7 @@
 import { type Bot, type Context, type FlatPick, type Logger, Schema } from "koishi";
 import type { Notifier } from "@koishijs/plugin-notifier";
 import type { LoginBili } from "./database";
-import { LiveType, type MasterInfo, PushType, type SubItem, type SubManager, type Target } from "./type";
+import { LiveType, type MasterInfo, PushType, type Result, type SubItem, type SubManager, type Target } from "./type";
 declare class ComRegister {
     static inject: string[];
     qqRelatedBotList: Array<string>;
@@ -19,11 +19,11 @@ declare class ComRegister {
     constructor(ctx: Context, config: ComRegister.Config);
     init(config: ComRegister.Config): Promise<void>;
     getBot(pf: string): Bot<Context, any>;
-    test_wordCloud(): Promise<void>;
     sendPrivateMsg(content: string): Promise<void>;
     sendPrivateMsgAndRebootService(): Promise<void>;
     sendPrivateMsgAndStopService(): Promise<void>;
     sendMessageWithRetry(bot: Bot<Context>, channelId: string, content: any): Promise<void>;
+    getGroupsThatMeetCriteria(targets: Target, type: PushType): string[];
     broadcastToTargets(targets: Target, content: any, type: PushType): Promise<void>;
     dynamicDetect(): (...args: any[]) => void;
     debug_dynamicDetect(): (...args: any[]) => void;
@@ -33,11 +33,8 @@ declare class ComRegister {
     subShow(): string;
     updateSubNotifier(): void;
     checkIfLoginInfoIsLoaded(): Promise<unknown>;
-    subUserInBili(mid: string): Promise<{
-        code: number;
-        msg: string;
-    }>;
-    loadSubFromConfig(subs: ComRegister.Config["sub"]): Promise<void>;
+    subUserInBili(mid: string): Promise<Result>;
+    loadSubFromConfig(subs: ComRegister.Config["sub"]): Promise<Result>;
     checkIfDynamicDetectIsNeeded(): void;
     enableDynamicDetect(): void;
     checkIfIsLogin(): Promise<boolean>;

package/lib/comRegister.js

@@ -176,7 +176,10 @@ class ComRegister {
                         // 销毁定时器
                         this.loginTimer();
                         // 订阅手动订阅中的订阅
-                        await this.loadSubFromConfig(config.sub);
+                        const { code, msg } = await this.loadSubFromConfig(config.sub);
+                        // 判断是否加载成功
+                        if (code !== 0)
+                            this.logger.error(msg);
                         // 清除控制台通知
                         ctx.ba.disposeNotifier();
                         // 发送成功登录推送
@@ -295,7 +298,17 @@ class ComRegister {
             return;
         }
         // 从配置获取订阅
-        config.sub && (await this.loadSubFromConfig(config.sub));
+        if (config.sub) {
+            const { code, msg } = await this.loadSubFromConfig(config.sub);
+            // 判断是否加载成功
+            if (code !== 0) {
+                this.logger.error(msg);
+                this.logger.error("订阅对象加载失败，插件初始化失败！");
+                // 发送私聊消息
+                await this.sendPrivateMsg("订阅对象加载失败，插件初始化失败！");
+                return;
+            }
+        }
         // 检查是否需要动态监测
         this.checkIfDynamicDetectIsNeeded();
         // 在控制台中显示订阅对象
@@ -316,42 +329,6 @@ class ComRegister {
     getBot(pf) {
         return this.ctx.bots.find((bot) => bot.platform === pf);
     }
-    // TODO:WordCloud
-    async test_wordCloud() {
-        /* const currentLiveDanmakuArr = []
-        // 定义获取弹幕权重Record函数
-        const getDanmakuWeightRecord = (): Record<string, number> => {
-            // 创建segmentit
-            const segmentit = useDefault(new Segment());
-            // 创建Record
-            const danmakuWeightRecord: Record<string, number> = {};
-            // 循环遍历currentLiveDanmakuArr
-            for (const danmaku of currentLiveDanmakuArr) {
-                // 遍历结果
-                segmentit.doSegment(danmaku).map((word: { w: string; p: number }) => {
-                    // 定义权重
-                    danmakuWeightRecord[word.w] = (danmakuWeightRecord[word.w] || 0) + 1;
-                });
-            }
-            // 返回Record
-            return danmakuWeightRecord;
-        }; */
-        // Test
-        const testTarget = [
-            {
-                channelArr: [
-                    {
-                        channelId: "635762054",
-                        dynamic: true,
-                        live: false,
-                        liveGuardBuy: false,
-                        atAll: false,
-                    },
-                ],
-                platform: "qqguild",
-            },
-        ];
-    }
     async sendPrivateMsg(content) {
         if (this.config.master.enable) {
             if (this.config.master.masterAccountGuildId) {
@@ -422,82 +399,93 @@ class ComRegister {
             await this.sendPrivateMsg(`发送群组ID:${channelId}消息失败，请查看日志`);
         });
     }
-    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-    async broadcastToTargets(targets, content, type) {
-        for (const target of targets) {
-            // 获取机器人实例
-            const bot = this.getBot(target.platform);
-            // 定义需要发送的数组
-            let channelArr = [];
-            // 判断是否需要推送所有机器人加入的群
-            if (target.channelArr[0].channelId === "all") {
-                // 获取所有guild
-                for (const guild of (await bot.getGuildList()).data) {
-                    channelArr.push({
-                        channelId: guild.id,
-                        dynamic: target.channelArr[0].dynamic,
-                        live: target.channelArr[0].live,
-                        liveGuardBuy: target.channelArr[0].liveGuardBuy,
-                        atAll: target.channelArr[0].atAll,
-                    });
+    getGroupsThatMeetCriteria(targets, type) {
+        // 定义数组
+        const pushArr = [];
+        // 判断类型
+        if (type === type_1.PushType.Live || type === type_1.PushType.StartBroadcasting) {
+            for (const target of targets) {
+                for (const channel of target.channelArr) {
+                    if (channel.live) {
+                        pushArr.push(`${target.platform}:${channel.channelId}`);
+                    }
                 }
             }
-            else {
-                channelArr = target.channelArr;
-            }
-            // 模式匹配
-            const pushTypePatternMatching = {
-                [type_1.PushType.Live]: async () => {
-                    for (const channel of channelArr) {
-                        // 判断是否需要推送动态消息
-                        if (channel.live) {
-                            await this.sendMessageWithRetry(bot, channel.channelId, content);
-                        }
-                        // 延迟发送
-                        await this.ctx.sleep(500);
-                    }
-                },
-                [type_1.PushType.Dynamic]: async () => {
-                    for (const channel of channelArr) {
-                        // 判断是否需要推送动态消息
-                        if (channel.live) {
-                            await this.sendMessageWithRetry(bot, channel.channelId, content);
-                        }
-                        // 延迟发送
-                        await this.ctx.sleep(500);
-                    }
-                },
-                [type_1.PushType.StartBroadcasting]: async () => {
-                    // 直播开播推送，判断是否需要艾特全体成员
-                    for (const channel of channelArr) {
-                        // 判断是否需要推送直播消息
-                        if (channel.live) {
-                            await this.sendMessageWithRetry(bot, channel.channelId, content);
-                        }
-                        // 判断是否需要艾特全体成员
-                        if (channel.atAll) {
-                            await this.sendMessageWithRetry(bot, channel.channelId, (0, jsx_runtime_1.jsx)("at", { type: "all" }));
-                        }
-                        // 延迟发送
-                        await this.ctx.sleep(500);
+            return pushArr;
+        }
+        if (type === type_1.PushType.Dynamic) {
+            for (const target of targets) {
+                for (const channel of target.channelArr) {
+                    if (channel.dynamic) {
+                        pushArr.push(`${target.platform}:${channel.channelId}`);
                     }
-                },
-                [type_1.PushType.LiveGuardBuy]: async () => {
-                    // 直播守护购买推送，判断是否需要艾特全体成员
-                    for (const channel of channelArr) {
-                        // 判断是否需要推送直播消息
-                        if (channel.liveGuardBuy) {
-                            await this.sendMessageWithRetry(bot, channel.channelId, content);
-                        }
-                        // 延迟发送
-                        await this.ctx.sleep(500);
+                }
+            }
+            return pushArr;
+        }
+        if (type === type_1.PushType.LiveGuardBuy) {
+            for (const target of targets) {
+                for (const channel of target.channelArr) {
+                    if (channel.liveGuardBuy) {
+                        pushArr.push(`${target.platform}:${channel.channelId}`);
                     }
-                },
-            };
-            // 推送
-            await pushTypePatternMatching[type]();
+                }
+            }
+            return pushArr;
         }
     }
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+    async broadcastToTargets(targets, content, type) {
+        // 不止一个目标平台或一个目标频道
+        if (targets.length !== 1 || targets[0].channelArr.length !== 1) {
+            // 直接使用broadcast
+            const pushArr = this.getGroupsThatMeetCriteria(targets, type);
+            // logger
+            this.logger.info(`推送消息到 ${pushArr.length} 个目标频道，目标频道为：${pushArr.join(", ")}`);
+            // 推送消息
+            await (0, utils_1.withRetry)(async () => {
+                await this.ctx.broadcast(pushArr, content);
+            }, 1);
+            // 结束
+            return;
+        }
+        // 获取目标
+        const targetChannel = targets[0].channelArr[0];
+        // 获取机器人实例
+        const bot = this.getBot(targets[0].platform);
+        // 模式匹配
+        const pushTypePatternMatching = {
+            [type_1.PushType.Live]: async () => {
+                if (targetChannel.live) {
+                    // 直接推送
+                    await this.sendMessageWithRetry(bot, targetChannel.channelId, content);
+                }
+            },
+            [type_1.PushType.Dynamic]: async () => {
+                if (targetChannel.dynamic) {
+                    await this.sendMessageWithRetry(bot, targetChannel.channelId, content);
+                }
+            },
+            [type_1.PushType.StartBroadcasting]: async () => {
+                // 判断是否需要推送直播消息
+                if (targetChannel.live) {
+                    await this.sendMessageWithRetry(bot, targetChannel.channelId, content);
+                }
+                // 判断是否需要艾特全体成员
+                if (targetChannel.atAll) {
+                    await this.sendMessageWithRetry(bot, targetChannel.channelId, (0, jsx_runtime_1.jsx)("at", { type: "all" }));
+                }
+            },
+            [type_1.PushType.LiveGuardBuy]: async () => {
+                // 判断是否需要推送直播消息
+                if (targetChannel.liveGuardBuy) {
+                    await this.sendMessageWithRetry(bot, targetChannel.channelId, content);
+                }
+            },
+        };
+        // 推送
+        await pushTypePatternMatching[type]();
+    }
     dynamicDetect() {
         // 检测初始化变量
         let detectSetup = true;
@@ -637,6 +625,12 @@ class ComRegister {
                                 }
                                 return;
                             }
+                            if (e.message === "已屏蔽专栏动态") {
+                                if (this.config.filter.notify) {
+                                    await this.broadcastToTargets(sub.target, `${upName}投稿了一条专栏，已屏蔽`, type_1.PushType.Dynamic);
+                                }
+                                return;
+                            }
                             // 未知错误
                             this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
                             // 发送私聊消息并重启服务
@@ -840,10 +834,14 @@ class ComRegister {
                 const upName = item.modules.module_author.name;
                 // logger
                 this.logger.info(`当前动态UP主UID:${upUID}，UP主名称:${upName}`);
+                // 定义是否是订阅的UP主flag
+                let isSubscribed = false;
                 // 寻找关注的UP主的动态
                 for (const sub of this.subManager) {
                     // 判断是否是订阅的UP主
                     if (sub.dynamic && sub.uid === upUID) {
+                        // 将flag设置为true
+                        isSubscribed = true;
                         // logger：订阅该UP主，推送该动态
                         this.logger.info("订阅该UP主，开始推送该动态...");
                         // logger
@@ -912,6 +910,8 @@ class ComRegister {
                         // logger
                         this.logger.info("动态推送完毕！");
                     }
+                }
+                if (!isSubscribed) {
                     // logger
                     this.logger.info("不是关注的UP主，跳过该动态");
                 }
@@ -1305,10 +1305,8 @@ class ComRegister {
         // 判断分组是否准备好
         const resp = await checkGroupIsReady();
         // 判断是否创建成功
-        if (resp.code !== 0) {
-            // 创建分组失败
+        if (resp.code !== 0)
             return resp;
-        }
         // 获取分组详情
         const getGroupDetailData = async () => {
             // 获取分组明细
@@ -1321,10 +1319,8 @@ class ComRegister {
                     // 分组不存在
                     const resp = await checkGroupIsReady();
                     // 判断是否创建成功
-                    if (resp.code !== 0) {
-                        // 创建分组失败
-                        return { ...resp, data: undefined };
-                    }
+                    if (resp.code !== 0)
+                        return resp;
                     // 再次获取分组明细
                     return getGroupDetailData();
                 }
@@ -1437,85 +1433,67 @@ class ComRegister {
         return await func();
     }
     async loadSubFromConfig(subs) {
-        // 定义一个AbortController
-        const controller = new AbortController();
-        const { signal } = controller;
-        // 设置超时
-        signal.addEventListener("abort", () => {
-            this.logger.info(`${signal.reason}，订阅未完全加载！`);
-        });
-        await Promise.all(subs.map(async (sub) => {
-            let timer;
-            // 创建一个定时器
-            const timeoutPromise = new Promise((_, reject) => {
-                timer = this.ctx.setTimeout(() => {
-                    // 取消订阅加载
-                    if (signal.aborted)
-                        return;
-                    // 终止
-                    controller.abort(`加载订阅UID:${sub.uid}超时`);
-                }, this.config.subLoadTimeout * 1000);
+        for (const sub of subs) {
+            // logger
+            this.logger.info(`加载订阅UID:${sub.uid}中...`);
+            // 定义Data
+            const { code: userInfoCode, msg: userInfoMsg, data: userInfoData, } = await (0, utils_1.withRetry)(async () => {
+                // 获取用户信息
+                const data = await this.ctx.ba.getUserInfo(sub.uid);
+                // 返回用户信息
+                return { code: 0, data };
+            })
+                .then((content) => content.data)
+                .catch((e) => {
+                this.logger.error(`loadSubFromConfig() getUserInfo() 发生了错误，错误为：${e.message}`);
+                // 返回失败
+                return { code: -1, message: `加载订阅UID:${sub.uid}失败！` };
             });
-            await Promise.race([
-                (async () => {
-                    // logger
-                    this.logger.info(`加载订阅UID:${sub.uid}中...`);
-                    // 定义Data
-                    const data = await (0, utils_1.withRetry)(async () => await this.ctx.ba.getUserInfo(sub.uid))
-                        .then((content) => content.data)
-                        .catch((e) => {
-                        this.logger.error(`loadSubFromConfig() getUserInfo() 发生了错误，错误为：${e.message}`);
-                        // logger
-                        this.logger.info(`加载订阅UID:${sub.uid}失败！`);
-                    });
-                    // 判断是否需要订阅直播
-                    if (sub.live) {
-                        // 检查roomid是否存在
-                        if (!data.live_room) {
-                            // 用户没有开通直播间，无法订阅直播
-                            sub.live = false;
-                            // 发送提示
-                            this.logger.warn(`UID:${sub.uid} 用户没有开通直播间，无法订阅直播！`);
-                        }
-                        // 判断是否订阅直播
-                        if (sub.live) {
-                            // 启动直播监测
-                            await this.liveDetectWithListener(data.live_room.roomid, sub.target, sub.card);
-                        }
-                    }
-                    // 在B站中订阅该对象
-                    const subInfo = await this.subUserInBili(sub.uid);
-                    // 判断订阅是否成功
-                    if (subInfo.code !== 0) {
-                        // 订阅失败，直接返回
-                        this.logger.error(`UID:${sub.uid} 订阅失败，错误信息：${subInfo.msg}`);
-                        return;
-                    }
-                    // 判断是否超时
-                    if (signal.aborted) {
-                        // 订阅加载超时，取消订阅加载
-                        return;
-                    }
-                    // 清除定时器
-                    timer();
-                    // 将该订阅添加到sm中
-                    this.subManager.push({
-                        id: +sub.uid,
-                        uid: sub.uid,
-                        uname: data.name,
-                        roomId: sub.live ? data.live_room.roomid : "",
-                        target: sub.target,
-                        platform: "",
-                        live: sub.live,
-                        dynamic: sub.dynamic,
-                        card: sub.card,
-                    });
-                    // logger
-                    this.logger.info(`UID:${sub.uid}订阅加载完毕！`);
-                })(),
-                timeoutPromise,
-            ]);
-        }));
+            // 判断是否获取成功
+            if (userInfoCode !== 0)
+                return { code: userInfoCode, msg: userInfoMsg };
+            // 判断是否需要订阅直播
+            if (sub.live) {
+                // 检查roomid是否存在
+                if (!userInfoData.live_room) {
+                    // 用户没有开通直播间，无法订阅直播
+                    sub.live = false;
+                    // 发送提示
+                    this.logger.warn(`UID:${sub.uid} 用户没有开通直播间，无法订阅直播！`);
+                }
+                // 判断是否订阅直播
+                if (sub.live) {
+                    // 启动直播监测
+                    await this.liveDetectWithListener(userInfoData.live_room.roomid, sub.target, sub.card);
+                }
+            }
+            // 在B站中订阅该对象
+            const subInfo = await this.subUserInBili(sub.uid);
+            // 判断订阅是否成功
+            if (subInfo.code !== 0)
+                return subInfo;
+            // 将该订阅添加到sm中
+            this.subManager.push({
+                id: +sub.uid,
+                uid: sub.uid,
+                uname: userInfoData.name,
+                roomId: sub.live ? userInfoData.live_room.roomid : "",
+                target: sub.target,
+                platform: "",
+                live: sub.live,
+                dynamic: sub.dynamic,
+                card: sub.card,
+            });
+            // logger
+            this.logger.info(`UID:${sub.uid}订阅加载完毕！`);
+            // 1-3秒随机延迟
+            const randomDelay = Math.floor(Math.random() * 3) + 1;
+            // logger
+            this.logger.info(`随机延迟:${randomDelay}秒`);
+            // delay
+            await this.ctx.sleep(randomDelay * 1000);
+        }
+        return { code: 0, msg: "订阅加载完毕！" };
     }
     checkIfDynamicDetectIsNeeded() {
         // 检查是否有订阅对象需要动态监测

package/lib/generateImg.d.ts

@@ -33,6 +33,7 @@ declare namespace GenerateImg {
             regex: string;
             keywords: Array<string>;
             forward: boolean;
+            article: boolean;
         };
         removeBorder: boolean;
         cardColorStart: string;

package/lib/generateImg.js

@@ -534,8 +534,13 @@ class GenerateImg extends koishi_1.Service {
                         `${upName}发布了剧集（番剧、电影、纪录片），我暂时无法渲染，请自行查看`,
                         link,
                     ];
-                case DYNAMIC_TYPE_ARTICLE:
+                case DYNAMIC_TYPE_ARTICLE: {
+                    //转发动态屏蔽
+                    if (this.giConfig.filter.enable && this.giConfig.filter.article) {
+                        throw new Error("已屏蔽专栏动态");
+                    }
                     return [`${upName}投稿了新专栏，我暂时无法渲染，请自行查看`, link];
+                }
                 case DYNAMIC_TYPE_MUSIC:
                     return [`${upName}发行了新歌，我暂时无法渲染，请自行查看`, link];
                 case DYNAMIC_TYPE_COMMON_SQUARE:
@@ -1473,6 +1478,7 @@ class GenerateImg extends koishi_1.Service {
             regex: koishi_1.Schema.string(),
             keywords: koishi_1.Schema.array(String),
             forward: koishi_1.Schema.boolean(),
+            article: koishi_1.Schema.boolean(),
         }),
         removeBorder: koishi_1.Schema.boolean(),
         cardColorStart: koishi_1.Schema.string(),

package/lib/index.js

@@ -387,6 +387,7 @@ exports.Config = koishi_1.Schema.object({
                 forward: koishi_1.Schema.boolean()
                     .default(false)
                     .description("是否屏蔽转发动态"),
+                article: koishi_1.Schema.boolean().default(false).description("是否屏蔽专栏"),
             }),
             koishi_1.Schema.object({}),
         ]),

package/lib/type/index.d.ts

@@ -5,13 +5,14 @@ export declare enum LiveType {
     StopBroadcast = 3,
     FirstLiveBroadcast = 4
 }
-export type ChannelArr = Array<{
+export type Channel = {
     channelId: string;
     dynamic: boolean;
     live: boolean;
     liveGuardBuy: boolean;
     atAll: boolean;
-}>;
+};
+export type ChannelArr = Array<Channel>;
 export type TargetItem = {
     channelArr: ChannelArr;
     platform: string;
@@ -95,3 +96,8 @@ export declare enum PushType {
     StartBroadcasting = 2,
     LiveGuardBuy = 3
 }
+export type Result = {
+    code: number;
+    msg?: string;
+    data?: any;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-bilibili-notify",
   "description": "Koishi bilibili notify plugin",
-  "version": "3.1.1-alpha.0",
+  "version": "3.1.3-alpha.0",
   "contributors": [
     "Akokko <admin@akokko.com>"
   ],

package/readme.md

@@ -234,6 +234,8 @@ uid为必填参数，为要推送的UP主的UID，index为可选参数，为要
 - ver 3.1.0-alpha.1 修复：无法发送 `@全体成员` 消息，将消息发送模式改回
 - ver 3.1.0 修复：订阅某位UP主直播和动态后，某些群聊只开启推送直播也会推送动态
 - ver 3.1.1-alpha.0 修复：稿件重投后，会将之前日期的动态一起推送； 优化：加强动态debug输出； 移除：不必要选项 `live.liveDetectMode`
+- ver 3.1.2-alpha.0 重构：对消息发送模块进行小型重构，多群多平台推送将不再支持艾特全体成员，仅单平台单群聊支持； 移除：群聊 `all` 选项
+- ver 3.1.3-alpha.0 移除：订阅超时； 新增：屏蔽专栏动态功能； 优化：改进了加载插件的错误提示；
 
 ## 交流群