koishi-plugin-bilibili-notify 3.1.2-alpha.0 → 3.1.4-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,7 +19,6 @@ 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>;
@@ -34,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) {
@@ -514,8 +491,10 @@ class ComRegister {
         let detectSetup = true;
         // 时间线
         let timeline;
-        // 第一条动态的动态ID
-        let dynamicIdStr1st;
+        // 当前推送动态时间线
+        let currentTimeline;
+        // 动态ID
+        let dynId;
         // 定义handler
         const handler = async () => {
             // 动态监测启动初始化
@@ -537,7 +516,7 @@ class ComRegister {
                 if (content.code !== 0)
                     return;
                 // 设置第一条动态的动态ID
-                dynamicIdStr1st = content.data?.items[0]?.id_str || "0";
+                dynId = content.data?.items[0]?.id_str || "0";
                 // 设置时间线
                 timeline =
                     content.data?.items[0]?.modules.module_author.pub_ts ||
@@ -613,7 +592,7 @@ class ComRegister {
                 // 获取动态ID
                 const dynamicId = item.id_str;
                 // 动态ID如果一致则结束循环
-                if (dynamicId === dynamicIdStr1st)
+                if (dynamicId === dynId)
                     break;
                 // 获取动态发布时间
                 const postTime = item.modules.module_author.pub_ts;
@@ -648,6 +627,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}`);
                             // 发送私聊消息并重启服务
@@ -660,8 +645,13 @@ class ComRegister {
                         let dUrl = "";
                         // 判断是否需要发送URL
                         if (this.config.dynamicUrl) {
-                            // 生成动态链接
-                            dUrl = `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`;
+                            if (item.type === "DYNAMIC_TYPE_AV") {
+                                dUrl = `${upName}发布了新视频：${item.modules.module_dynamic.major.archive.jump_url}`;
+                            }
+                            else {
+                                // 生成动态链接
+                                dUrl = `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`;
+                            }
                         }
                         // logger
                         this.logger.info("推送动态中...");
@@ -678,16 +668,22 @@ class ComRegister {
                                 }
                             }
                         }
+                        // 设置timeline
+                        currentTimeline = postTime;
                         // logger
                         this.logger.info("动态推送完毕！");
                     }
                 }
             }
-            // 更新本次请求第一条动态的动态ID
-            dynamicIdStr1st = items[0].id_str;
             // 更新时间线
-            timeline =
-                items[0].modules.module_author.pub_ts || luxon_1.DateTime.now().toSeconds();
+            if (currentTimeline) {
+                timeline = currentTimeline;
+                currentTimeline = null;
+            }
+            // 设置动态ID
+            if (items[0].id_str && items[0].id_str !== dynId) {
+                dynId = items[0].id_str;
+            }
         };
         // 返回一个闭包函数
         return (0, utils_1.withLock)(handler);
@@ -697,8 +693,10 @@ class ComRegister {
         let detectSetup = true;
         // 时间线
         let timeline;
-        // 第一条动态的动态ID
-        let dynamicIdStr1st;
+        // 当前推送动态时间线
+        let currentTimeline;
+        // 动态ID
+        let dynId;
         // 定义handler
         const handler = async () => {
             // 动态监测启动初始化
@@ -728,9 +726,9 @@ class ComRegister {
                     return;
                 }
                 // 设置第一条动态的动态ID
-                dynamicIdStr1st = content.data?.items[0]?.id_str || "0";
+                dynId = content.data?.items[0]?.id_str || "0";
                 // logger
-                this.logger.info(`获取到第一条动态ID:${dynamicIdStr1st}`);
+                this.logger.info(`获取到第一条动态ID:${dynId}`);
                 // 设置时间线
                 timeline =
                     content.data?.items[0]?.modules.module_author.pub_ts ||
@@ -820,11 +818,12 @@ class ComRegister {
                 const dynamicId = item.id_str;
                 // logger
                 this.logger.info(`当前动态ID:${dynamicId}`);
-                this.logger.info(`上一次获取到第一条动态ID:${dynamicId}`);
+                this.logger.info(`上次第一条推送的动态ID:${dynId}`);
                 // 动态ID如果一致则结束循环
-                if (dynamicId === dynamicIdStr1st) {
+                if (dynamicId === dynId) {
                     // logger
-                    this.logger.info("动态ID与上一次获取第一条一致，结束循环");
+                    this.logger.info("动态ID与上次第一条推送动态一致，结束循环");
+                    // 结束循环
                     break;
                 }
                 // 获取动态发布时间
@@ -845,16 +844,20 @@ class ComRegister {
                     break;
                 }
                 // logger
-                this.logger.info("动态时间线大于上一次获取到第一条动态时间线，开始判断是否是订阅的UP主...");
+                this.logger.info("动态时间线大于最后推送动态时间线，开始判断是否是订阅的UP主...");
                 // 从动态数据中取出UP主名称、UID
                 const upUID = item.modules.module_author.mid.toString();
                 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
@@ -898,8 +901,13 @@ class ComRegister {
                         if (this.config.dynamicUrl) {
                             // logger
                             this.logger.info("生成动态链接中...");
-                            // 生成动态链接
-                            dUrl = `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`;
+                            if (item.type === "DYNAMIC_TYPE_AV") {
+                                dUrl = `${upName}发布了新视频：${item.modules.module_dynamic.major.archive.jump_url}`;
+                            }
+                            else {
+                                // 生成动态链接
+                                dUrl = `${upName}发布了一条动态：https://t.bilibili.com/${item.id_str}`;
+                            }
                         }
                         // logger
                         this.logger.info("推送动态中...");
@@ -920,22 +928,33 @@ class ComRegister {
                             // logger
                             this.logger.info("图片推送完毕！");
                         }
+                        // 设置timeline
+                        currentTimeline = postTime;
                         // logger
                         this.logger.info("动态推送完毕！");
                     }
+                }
+                if (!isSubscribed) {
                     // logger
                     this.logger.info("不是关注的UP主，跳过该动态");
                 }
             }
-            // 更新本次请求第一条动态的动态ID
-            dynamicIdStr1st = items[0].id_str;
-            // logger
-            this.logger.info(`更新本次请求第一条动态的动态ID:${dynamicIdStr1st}`);
             // 更新时间线
-            timeline =
-                items[0].modules.module_author.pub_ts || luxon_1.DateTime.now().toSeconds();
-            // logger
-            this.logger.info(`更新时间线:${timeline}`);
+            if (currentTimeline) {
+                timeline = currentTimeline;
+                currentTimeline = null;
+                // logger
+                this.logger.info(`更新时间线:${timeline}`);
+            }
+            else {
+                this.logger.info("时间线无需更新！");
+            }
+            // 更新动态ID
+            if (items[0].id_str && items[0].id_str !== dynId) {
+                dynId = items[0].id_str;
+                // logger
+                this.logger.info(`更新动态ID:${dynId}`);
+            }
             // logger
             this.logger.info(`时间线格式化:${luxon_1.DateTime.fromSeconds(timeline).toFormat("yyyy-MM-dd HH:mm:ss")}`);
             // logger
@@ -1316,10 +1335,8 @@ class ComRegister {
         // 判断分组是否准备好
         const resp = await checkGroupIsReady();
         // 判断是否创建成功
-        if (resp.code !== 0) {
-            // 创建分组失败
+        if (resp.code !== 0)
             return resp;
-        }
         // 获取分组详情
         const getGroupDetailData = async () => {
             // 获取分组明细
@@ -1332,10 +1349,8 @@ class ComRegister {
                     // 分组不存在
                     const resp = await checkGroupIsReady();
                     // 判断是否创建成功
-                    if (resp.code !== 0) {
-                        // 创建分组失败
-                        return { ...resp, data: undefined };
-                    }
+                    if (resp.code !== 0)
+                        return resp;
                     // 再次获取分组明细
                     return getGroupDetailData();
                 }
@@ -1442,91 +1457,71 @@ class ComRegister {
                 return { code: 0, msg: "订阅对象添加成功" };
             },
         };
-        // 获取函数
-        const func = subUserMatchPattern[subUserData.code];
         // 执行函数并返回
-        return await func();
+        return await subUserMatchPattern[subUserData.code]();
     }
     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

@@ -75,12 +75,25 @@ export type AllDynamicInfo = {
                 };
                 module_dynamic: {
                     major: {
-                        draw: {
+                        draw?: {
                             items: Array<{
                                 src: string;
                                 alt: string;
                             }>;
                         };
+                        archive?: {
+                            aid: string;
+                            badge: Object;
+                            bvid: string;
+                            cover: string;
+                            desc: string;
+                            disable_preview: number;
+                            duration_text: string;
+                            jump_url: string;
+                            stat: string;
+                            title: string;
+                            type: number;
+                        };
                     };
                 };
             };
@@ -96,3 +109,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.2-alpha.0",
+  "version": "3.1.4-alpha.0",
   "contributors": [
     "Akokko <admin@akokko.com>"
   ],

package/readme.md

@@ -235,6 +235,8 @@ uid为必填参数，为要推送的UP主的UID，index为可选参数，为要
 - 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 移除：订阅超时； 新增：屏蔽专栏动态功能； 优化：改进了加载插件的错误提示；
+- ver 3.1.4-alpha.0 修复：动态只推送视频； 优化：动态视频链接将直接发送为视频链接；
 
 ## 交流群