koishi-plugin-bilibili-notify 3.0.1-alpha.0 → 3.0.1-alpha.2

package/lib/comRegister.d.ts

@@ -35,7 +35,7 @@ declare class ComRegister {
     updateSubNotifier(): void;
     checkIfLoginInfoIsLoaded(): Promise<unknown>;
     subUserInBili(mid: string): Promise<{
-        flag: boolean;
+        code: number;
         msg: string;
     }>;
     loadSubFromConfig(subs: ComRegister.Config["sub"]): Promise<void>;

package/lib/comRegister.js

@@ -950,6 +950,7 @@ class ComRegister {
                     .replace("-name", masterInfo.username)
                     .replace("-time", await this.ctx.gi.getTimeDifference(liveTime))
                     .replace("-watched", watched)
+                    .replace("\\n", "\n")
                     .replace("-link", `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`)
                 : null;
             // 发送直播通知卡片
@@ -1028,6 +1029,7 @@ class ComRegister {
                         .replace("-name", masterInfo.username)
                         .replace("-time", await this.ctx.gi.getTimeDifference(liveTime))
                         .replace("-follower", follower)
+                        .replace("\\n", "\n")
                         .replace("-link", `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`)
                     : null;
                 // 推送开播通知
@@ -1070,6 +1072,7 @@ class ComRegister {
                         .replace("-name", masterInfo.username)
                         .replace("-time", await this.ctx.gi.getTimeDifference(liveTime))
                         .replace("-follower_change", followerChange)
+                        .replace("\\n", "\n")
                     : null;
                 // 推送通知卡片
                 await sendLiveNotifyCard(type_1.LiveType.StopBroadcast, followerChange, liveEndMsg);
@@ -1098,6 +1101,7 @@ class ComRegister {
                     .replace("-name", masterInfo.username)
                     .replace("-time", await this.ctx.gi.getTimeDifference(liveTime))
                     .replace("-watched", watched)
+                    .replace("\\n", "\n")
                     .replace("-link", `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`)
                 : null;
             // 发送直播通知卡片
@@ -1181,136 +1185,232 @@ class ComRegister {
                     }
                 }
                 else if (createGroupData.code !== 0) {
-                    console.log(createGroupData);
                     // 创建分组失败
-                    return false;
+                    return { code: createGroupData.code, msg: createGroupData.message };
                 }
                 // 创建成功，保存到数据库
                 this.ctx.database.set("loginBili", 1, {
                     dynamic_group_id: this.loginDBData.dynamic_group_id,
                 });
                 // 创建成功
-                return true;
+                return { code: createGroupData.code, msg: createGroupData.message };
             }
-            return true;
+            return { code: 0, msg: "分组已存在" };
         };
         // 判断分组是否准备好
-        const flag = await checkGroupIsReady();
+        const resp = await checkGroupIsReady();
         // 判断是否创建成功
-        if (!flag) {
+        if (resp.code !== 0) {
             // 创建分组失败
-            return { flag: false, msg: "创建分组失败，请尝试重启插件" };
+            return resp;
         }
-        // 获取分组明细
-        const relationGroupDetailData = await this.ctx.ba.getRelationGroupDetail(this.loginDBData.dynamic_group_id);
-        // 判断分组信息是否获取成功
-        if (relationGroupDetailData.code !== 0) {
-            if (relationGroupDetailData.code === 22104) {
-                // 将原先的分组id置空
-                this.loginDBData.dynamic_group_id = null;
-                // 分组不存在
-                const flag = await checkGroupIsReady();
-                // 判断是否创建成功
-                if (!flag) {
-                    // 创建分组失败
-                    return { flag: false, msg: "创建分组失败，请尝试重启插件" };
+        // 获取分组详情
+        const getGroupDetailData = async () => {
+            // 获取分组明细
+            const relationGroupDetailData = await this.ctx.ba.getRelationGroupDetail(this.loginDBData.dynamic_group_id);
+            // 判断分组信息是否获取成功
+            if (relationGroupDetailData.code !== 0) {
+                if (relationGroupDetailData.code === 22104) {
+                    // 将原先的分组id置空
+                    this.loginDBData.dynamic_group_id = null;
+                    // 分组不存在
+                    const resp = await checkGroupIsReady();
+                    // 判断是否创建成功
+                    if (resp.code !== 0) {
+                        // 创建分组失败
+                        return { ...resp, data: undefined };
+                    }
+                    // 再次获取分组明细
+                    return getGroupDetailData();
                 }
-                return { flag: true, msg: "分组不存在，已重新创建分组" };
+                // 获取分组明细失败
+                return {
+                    code: relationGroupDetailData.code,
+                    msg: relationGroupDetailData.message,
+                    data: undefined,
+                };
             }
-            // 获取分组明细失败
-            return { flag: false, msg: "获取分组明细失败" };
+            return {
+                code: 0,
+                msg: "获取分组明细成功",
+                data: relationGroupDetailData.data,
+            };
+        };
+        // 获取分组明细
+        const { code, msg, data } = await getGroupDetailData();
+        // 判断获取分组明细是否成功
+        if (code !== 0) {
+            return { code, msg };
         }
-        for (const user of relationGroupDetailData.data) {
+        // 判断是否已经订阅该对象
+        for (const user of data) {
             if (user.mid === mid) {
                 // 已关注订阅对象
-                return { flag: true, msg: "订阅对象已存在于分组中" };
+                return { code: 0, msg: "订阅对象已存在于分组中" };
             }
         }
         // 订阅对象
-        const subUserData = await this.ctx.ba.follow(mid);
-        // 判断是否订阅成功
-        switch (subUserData.code) {
-            case -101:
+        const subUserData = (await this.ctx.ba.follow(mid));
+        // 模式匹配
+        const subUserMatchPattern = {
+            [-101]: () => {
                 return {
-                    flag: false,
+                    code: subUserData.code,
                     msg: "账号未登录，请使用指令bili login登录后再进行订阅操作",
                 };
-            case -102:
-                return { flag: false, msg: "账号被封停，无法进行订阅操作" };
-            case 22002:
-                return { flag: false, msg: "因对方隐私设置，无法进行订阅操作" };
-            case 22003:
-                return { flag: false, msg: "你已将对方拉黑，无法进行订阅操作" };
-            case 22013:
-                return { flag: false, msg: "账号已注销，无法进行订阅操作" };
-            case 40061:
+            },
+            [-102]: () => {
+                return {
+                    code: subUserData.code,
+                    msg: "账号被封停，无法进行订阅操作",
+                };
+            },
+            [22002]: () => {
+                return {
+                    code: subUserData.code,
+                    msg: "因对方隐私设置，无法进行订阅操作",
+                };
+            },
+            [22003]: () => {
+                return {
+                    code: subUserData.code,
+                    msg: "你已将对方拉黑，无法进行订阅操作",
+                };
+            },
+            [22013]: () => {
+                return {
+                    code: subUserData.code,
+                    msg: "账号已注销，无法进行订阅操作",
+                };
+            },
+            [40061]: () => {
                 return {
-                    flag: false,
+                    code: subUserData.code,
                     msg: "账号不存在，请检查uid输入是否正确或用户是否存在",
                 };
-            case 22001:
-                break; // 订阅对象为自己 无需添加到分组
-            case 22014: // 已关注订阅对象 无需再次关注
-            case 0: {
-                // 执行订阅成功
+            },
+            [22001]: () => {
+                return {
+                    code: 0,
+                    msg: "订阅对象为自己，无需添加到分组",
+                };
+            },
+            // 已订阅该对象
+            [22014]: async () => {
                 // 把订阅对象添加到分组中
                 const copyUserToGroupData = await this.ctx.ba.copyUserToGroup(mid, this.loginDBData.dynamic_group_id);
                 // 判断是否添加成功
                 if (copyUserToGroupData.code !== 0) {
                     // 添加失败
-                    return { flag: false, msg: "添加订阅对象到分组失败，请稍后重试" };
+                    return {
+                        code: copyUserToGroupData.code,
+                        msg: "添加订阅对象到分组失败，请稍后重试",
+                    };
                 }
-            }
-        }
-        // 订阅成功
-        return { flag: true, msg: "用户订阅成功" };
+                // 添加成功
+                return { code: 0, msg: "订阅对象添加成功" };
+            },
+            // 订阅成功
+            [0]: async () => {
+                // 把订阅对象添加到分组中
+                const copyUserToGroupData = await this.ctx.ba.copyUserToGroup(mid, this.loginDBData.dynamic_group_id);
+                // 判断是否添加成功
+                if (copyUserToGroupData.code !== 0) {
+                    // 添加失败
+                    return {
+                        code: copyUserToGroupData.code,
+                        msg: "添加订阅对象到分组失败，请稍后重试",
+                    };
+                }
+                // 添加成功
+                return { code: 0, msg: "订阅对象添加成功" };
+            },
+        };
+        // 获取函数
+        const func = subUserMatchPattern[subUserData.code];
+        // 执行函数并返回
+        return await func();
     }
     async loadSubFromConfig(subs) {
-        for (const sub of subs) {
-            // 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.flag)
-                this.logger.warn(subInfo.msg);
-            // 将该订阅添加到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,
+        // 定义一个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}超时`);
+                }, 10 * 1000);
             });
-            this.logger.info(`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;
+                    }
+                    // 将该订阅添加到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,
+                    });
+                    // 清除定时器
+                    timer();
+                    // logger
+                    this.logger.info(`UID:${sub.uid}订阅加载完毕！`);
+                })(),
+                timeoutPromise,
+            ]);
+        }));
     }
     checkIfDynamicDetectIsNeeded() {
         // 检查是否有订阅对象需要动态监测
@@ -1320,7 +1420,7 @@ class ComRegister {
     enableDynamicDetect() {
         // 开始动态监测
         if (this.config.dynamicDebugMode) {
-            this.dynamicDispose = this.ctx.setInterval(this.debug_dynamicDetect(), 5 * 1000);
+            this.dynamicDispose = this.ctx.setInterval(this.debug_dynamicDetect(), this.config.dynamicLoopTime * 1000);
         }
         else {
             this.dynamicDispose = this.ctx.setInterval(this.dynamicDetect(), this.config.dynamicLoopTime * 1000);

package/lib/index.d.ts

@@ -33,6 +33,7 @@ export interface Config {
     userAgent: string;
     subTitle: {};
     sub: Array<{
+        name: string;
         uid: string;
         dynamic: boolean;
         live: boolean;

package/lib/index.js

@@ -277,6 +277,7 @@ exports.Config = koishi_1.Schema.object({
         .description("设置请求头User-Agen，请求出现-352时可以尝试修改，UA获取方法可参考：https://blog.csdn.net/qq_44503987/article/details/104929111"),
     subTitle: koishi_1.Schema.object({}).description("订阅配置"),
     sub: koishi_1.Schema.array(koishi_1.Schema.object({
+        name: koishi_1.Schema.string().description("订阅用户昵称，只是给你自己看的(相当于备注)，可填可不填"),
         uid: koishi_1.Schema.string().required().description("订阅用户UID"),
         dynamic: koishi_1.Schema.boolean().default(false).description("是否订阅用户动态"),
         live: koishi_1.Schema.boolean().default(false).description("是否订阅用户直播"),
@@ -370,14 +371,14 @@ exports.Config = koishi_1.Schema.object({
         .default(1)
         .description("设定间隔多长时间推送一次直播状态，单位为小时，默认为一小时"),
     customLiveStart: koishi_1.Schema.string()
-        .default("-name开播啦，当前粉丝数：-follower -link")
-        .description("自定义开播提示语，-name代表UP昵称，-follower代表当前粉丝数，-link代表直播间链接（如果使用的是QQ官方机器人，请不要使用）。例如-name开播啦，会发送为xxxUP开播啦"),
+        .default("-name开播啦，当前粉丝数：-follower\\n-link")
+        .description("自定义开播提示语，-name代表UP昵称，-follower代表当前粉丝数，-link代表直播间链接（如果使用的是QQ官方机器人，请不要使用），\\n为换行。例如-name开播啦，会发送为xxxUP开播啦"),
     customLive: koishi_1.Schema.string()
-        .default("-name正在直播，目前已播-time，累计看过人数：-watched -link")
-        .description("自定义直播中提示语，-name代表UP昵称，-time代表开播时长，-watched代表累计看过人数，-link代表直播间链接（如果使用的是QQ官方机器人，请不要使用）。例如-name正在直播，会发送为xxxUP正在直播xxx"),
+        .default("-name正在直播，目前已播-time，累计看过人数：-watched\\n-link")
+        .description("自定义直播中提示语，-name代表UP昵称，-time代表开播时长，-watched代表累计看过人数，-link代表直播间链接（如果使用的是QQ官方机器人，请不要使用），\\n为换行。例如-name正在直播，会发送为xxxUP正在直播xxx"),
     customLiveEnd: koishi_1.Schema.string()
         .default("-name下播啦，本次直播了-time，粉丝数变化-follower_change")
-        .description("自定义下播提示语，-name代表UP昵称，-follower_change代表本场直播粉丝数变，-time代表开播时长。例如-name下播啦，本次直播了-time，会发送为xxxUP下播啦，直播时长为xx小时xx分钟xx秒"),
+        .description("自定义下播提示语，-name代表UP昵称，-follower_change代表本场直播粉丝数变，-time代表开播时长，\\n为换行。例如-name下播啦，本次直播了-time，会发送为xxxUP下播啦，直播时长为xx小时xx分钟xx秒"),
     followerDisplay: koishi_1.Schema.boolean()
         .default(true)
         .description("粉丝数变化和看过本场直播的人数是否显示在推送卡片中"),

package/package.json

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

package/readme.md

@@ -214,6 +214,8 @@
 - ver 3.0.0-beta.2 新增：配置项 `sub.card`，能更改每个订阅的推送卡片样式，未更改的样式与全局样式保持一致
 - ver 3.0.0 优化：配置项 `sub.card` 添加实验性标识
 - ver 3.0.1-alpha.0 优化：动态推送逻辑
+- ver 3.0.1-alpha.1 新增：直播提示语换行符，配置项 `sub.name` 为可选项； 修复：debug模式下动态监测5S一次； 优化：加载订阅
+- ver 3.0.1-alpha.2 优化：改进错误提示，改进订阅加载方式
 
 ## 交流群