koishi-plugin-bilibili-notify 3.0.0-alpha.23 → 3.0.0-alpha.25

package/lib/comRegister.d.ts

@@ -26,8 +26,8 @@ declare class ComRegister {
     sendPrivateMsgAndRebootService(): Promise<void>;
     sendPrivateMsgAndStopService(): Promise<void>;
     sendMsg(targets: Target, content: any, live?: boolean): Promise<void>;
-    dynamicDetect(): () => Promise<void>;
-    debug_dynamicDetect(): () => Promise<void>;
+    dynamicDetect(): (...args: any[]) => void;
+    debug_dynamicDetect(): (...args: any[]) => void;
     sendLiveNotifyCard(info: {
         username: string;
         userface: string;

package/lib/comRegister.js

@@ -226,24 +226,31 @@ class ComRegister {
             for (const sub of this.subManager) {
                 // 定义开播标志位
                 let onLive = false;
-                // 遍历liveUsers
-                for (const user of live_users.items) {
-                    // 判断是否是订阅直播的UP
-                    if (user.mid.toString() === sub.uid && sub.live) {
-                        // 设置标志位为true
-                        onLive = true;
-                        // break
-                        break;
+                // 判断items是否存在
+                if (live_users.items) {
+                    // 遍历liveUsers
+                    for (const user of live_users.items) {
+                        // 判断是否是订阅直播的UP
+                        if (user.mid.toString() === sub.uid && sub.live) {
+                            // 设置标志位为true
+                            onLive = true;
+                            // break
+                            break;
+                        }
                     }
                 }
                 // 判断是否未开播
-                subLiveUsers.push({ uid: Number.parseInt(sub.uid), uname: sub.uname, onLive });
+                subLiveUsers.push({
+                    uid: Number.parseInt(sub.uid),
+                    uname: sub.uname,
+                    onLive,
+                });
             }
             // 定义table字符串
             let table = "";
             // 遍历liveUsers
             for (const user of subLiveUsers) {
-                table += `[UID:${user.uid}] 「${user.uname}」 ${user.onLive ? '正在直播' : '未开播'}\n`;
+                table += `[UID:${user.uid}] 「${user.uname}」 ${user.onLive ? "正在直播" : "未开播"}\n`;
             }
             return table;
         });
@@ -252,7 +259,7 @@ class ComRegister {
         // 设置logger
         this.logger = this.ctx.logger("cr");
         // logger
-        this.logger.info("加载订阅中...");
+        this.logger.info("初始化插件中...");
         // 将config设置给类属性
         this.config = config;
         // 拿到私人机器人实例
@@ -290,11 +297,7 @@ class ComRegister {
             bot, channelId, 
             // biome-ignore lint/suspicious/noExplicitAny: <explanation>
             content) => {
-                try {
-                    // 发送消息
-                    await bot.sendMessage(channelId, content);
-                }
-                catch (e) {
+                (0, utils_1.withRetry)(async () => await bot.sendMessage(channelId, content), 0).catch(async (e) => {
                     if (e.message === "this._request is not a function") {
                         // 2S之后重新发送消息
                         this.ctx.setTimeout(async () => {
@@ -306,7 +309,7 @@ class ComRegister {
                     // 打印错误信息
                     this.logger.error(`发送群组ID:${channelId}消息失败！原因: ${e.message}`);
                     await this.sendPrivateMsg(`发送群组ID:${channelId}消息失败，请查看日志`);
-                }
+                });
             };
         }
         // 检查登录数据库是否有数据
@@ -326,7 +329,7 @@ class ComRegister {
         // 在控制台中显示订阅对象
         this.updateSubNotifier();
         // logger
-        this.logger.info("订阅加载完毕！");
+        this.logger.info("插件初始化完毕！");
     }
     // biome-ignore lint/suspicious/noExplicitAny: <explanation>
     getBot(pf) {
@@ -475,190 +478,174 @@ class ComRegister {
         let updateBaseline;
         // 第一条动态的动态ID
         let dynamicIdStr;
-        // 相当于锁的作用，防止上一个循环没处理完
-        let flag = true;
-        // 返回一个闭包函数
-        return async () => {
-            // 判断上一个循环是否完成
-            if (!flag)
+        // 定义handler
+        const handler = async () => {
+            // 检测启动初始化
+            if (detectSetup) {
+                // 获取动态信息
+                const data = (await this.ctx.ba.getAllDynamic());
+                // 判断获取动态信息是否成功
+                if (data.code !== 0)
+                    return;
+                // 设置更新基线
+                updateBaseline = data.data.update_baseline;
+                // 设置初始化为false
+                detectSetup = false;
+                // 初始化完成
                 return;
-            flag = false;
-            // 无论是否执行成功都要释放锁
+            }
+            // 获取用户所有动态数据
+            let updateNum;
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            let content;
             try {
-                // 检测启动初始化
-                if (detectSetup) {
-                    // 获取动态信息
-                    const data = (await this.ctx.ba.getAllDynamic());
-                    // 判断获取动态信息是否成功
-                    if (data.code !== 0)
-                        return;
-                    // 设置更新基线
-                    updateBaseline = data.data.update_baseline;
-                    // 设置初始化为false
-                    detectSetup = false;
-                    // 初始化完成
+                // 查询是否有新动态
+                const data = await this.ctx.ba.hasNewDynamic(updateBaseline);
+                updateNum = data.data.update_num;
+                // 没有新动态或获取动态信息失败直接返回
+                if (updateNum <= 0 || data.code !== 0)
                     return;
-                }
-                // 获取用户所有动态数据
-                let updateNum;
-                // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-                let content;
-                try {
-                    // 查询是否有新动态
-                    const data = await this.ctx.ba.hasNewDynamic(updateBaseline);
-                    updateNum = data.data.update_num;
-                    // 没有新动态或获取动态信息失败直接返回
-                    if (updateNum <= 0 || data.code !== 0)
-                        return;
-                    // 获取动态内容
-                    content = (await this.ctx.ba.getAllDynamic(updateBaseline));
-                }
-                catch (e) {
-                    return this.logger.error(`dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：${e.message}`);
-                }
-                // 判断获取动态内容是否成功
-                if (content.code !== 0) {
-                    switch (content.code) {
-                        case -101: {
-                            // 账号未登录
-                            // 输出日志
-                            this.logger.error("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
-                            // 发送私聊消息
-                            await this.sendPrivateMsg("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
-                            // 停止服务
-                            await this.ctx.sm.disposePlugin();
-                            // 结束循环
-                            break;
-                        }
-                        case -352: {
-                            // 风控
-                            // 输出日志
-                            this.logger.error("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
-                            // 发送私聊消息
-                            await this.sendPrivateMsg("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
-                            // 停止服务
-                            await this.ctx.sm.disposePlugin();
-                            // 结束循环
-                            break;
-                        }
-                        case 4101128:
-                        case 4101129: {
-                            // 获取动态信息错误
-                            // 输出日志
-                            this.logger.error(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`);
-                            // 发送私聊消息
-                            await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
-                            // 结束循环
-                            break;
-                        }
-                        default: {
-                            // 未知错误
-                            // 发送私聊消息
-                            await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
-                            // 结束循环
-                            break;
-                        }
+                // 获取动态内容
+                content = (await this.ctx.ba.getAllDynamic(updateBaseline));
+            }
+            catch (e) {
+                return this.logger.error(`dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：${e.message}`);
+            }
+            // 判断获取动态内容是否成功
+            if (content.code !== 0) {
+                switch (content.code) {
+                    case -101: {
+                        // 账号未登录
+                        // 输出日志
+                        this.logger.error("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
+                        // 发送私聊消息
+                        await this.sendPrivateMsg("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
+                        // 停止服务
+                        await this.ctx.sm.disposePlugin();
+                        // 结束循环
+                        break;
+                    }
+                    case -352: {
+                        // 风控
+                        // 输出日志
+                        this.logger.error("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
+                        // 发送私聊消息
+                        await this.sendPrivateMsg("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
+                        // 停止服务
+                        await this.ctx.sm.disposePlugin();
+                        // 结束循环
+                        break;
+                    }
+                    case 4101128:
+                    case 4101129: {
+                        // 获取动态信息错误
+                        // 输出日志
+                        this.logger.error(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`);
+                        // 发送私聊消息
+                        await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
+                        // 结束循环
+                        break;
+                    }
+                    default: {
+                        // 未知错误
+                        // 发送私聊消息
+                        await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
+                        // 结束循环
+                        break;
                     }
                 }
-                // 获取数据内容
-                const data = content.data;
-                // 更新基线
-                updateBaseline = data.update_baseline;
-                // 有新动态内容
-                const items = data.items;
-                // 检查更新的动态
-                for (let num = updateNum - 1; num >= 0; num--) {
-                    // 没有动态内容则直接跳过
-                    if (!items[num])
-                        continue;
-                    // 从动态数据中取出UP主名称、UID和动态ID
-                    const upUID = items[num].modules.module_author.mid;
-                    // 寻找关注的UP主的动态
-                    for (const sub of this.subManager) {
-                        // 判断是否是订阅的UP主
-                        // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
-                        if (sub.dynamic && sub.uid == upUID) {
-                            // 订阅该UP主，推送该动态
-                            // 判断更新动态是否为1条
-                            if (updateNum === 1) {
-                                // 判断dynamicIdStr是否有值，是否与当前动态ID一致
-                                if (dynamicIdStr && dynamicIdStr === items[num].id_str) {
-                                    // 重复动态，不再推送，直接返回
-                                    return;
-                                }
-                                // 存储该动态ID
-                                dynamicIdStr = items[num].id_str;
+            }
+            // 获取数据内容
+            const data = content.data;
+            // 更新基线
+            updateBaseline = data.update_baseline;
+            // 有新动态内容
+            const items = data.items;
+            // 检查更新的动态
+            for (let num = updateNum - 1; num >= 0; num--) {
+                // 没有动态内容则直接跳过
+                if (!items[num])
+                    continue;
+                // 从动态数据中取出UP主名称、UID和动态ID
+                const upUID = items[num].modules.module_author.mid;
+                // 寻找关注的UP主的动态
+                for (const sub of this.subManager) {
+                    // 判断是否是订阅的UP主
+                    // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
+                    if (sub.dynamic && sub.uid == upUID) {
+                        // 订阅该UP主，推送该动态
+                        // 判断更新动态是否为1条
+                        if (updateNum === 1) {
+                            // 判断dynamicIdStr是否有值，是否与当前动态ID一致
+                            if (dynamicIdStr && dynamicIdStr === items[num].id_str) {
+                                // 重复动态，不再推送，直接返回
+                                return;
                             }
-                            // 定义变量
-                            let pic;
-                            let buffer;
-                            // 从动态数据中取出UP主名称和动态ID
-                            const upName = items[num].modules.module_author.name;
-                            const dynamicId = items[num].id_str;
-                            // 推送该条动态
-                            const attempts = 3;
-                            for (let i = 0; i < attempts; i++) {
-                                // 获取动态推送图片
-                                try {
-                                    // 渲染图片
-                                    const { pic: gimgPic, buffer: gimgBuffer } = await this.ctx.gi.generateDynamicImg(items[num]);
-                                    // 赋值
-                                    pic = gimgPic;
-                                    buffer = gimgBuffer;
-                                    // 成功则跳出循环
-                                    break;
-                                }
-                                catch (e) {
-                                    // 直播开播动态，不做处理
-                                    if (e.message === "直播开播动态，不做处理")
-                                        return;
-                                    if (e.message === "出现关键词，屏蔽该动态") {
-                                        // 如果需要发送才发送
-                                        if (this.config.filter.notify) {
-                                            await this.sendMsg(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
-                                        }
-                                        return;
-                                    }
-                                    if (e.message === "已屏蔽转发动态") {
-                                        if (this.config.filter.notify) {
-                                            await this.sendMsg(sub.target, `${upName}发布了一条转发动态，已屏蔽`);
-                                        }
-                                        return;
-                                    }
-                                    // 未知错误
-                                    if (i === attempts - 1) {
-                                        this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
-                                        // 发送私聊消息并重启服务
-                                        return await this.sendPrivateMsgAndStopService();
-                                    }
+                            // 存储该动态ID
+                            dynamicIdStr = items[num].id_str;
+                        }
+                        // 定义变量
+                        let pic;
+                        let buffer;
+                        // 从动态数据中取出UP主名称和动态ID
+                        const upName = items[num].modules.module_author.name;
+                        const dynamicId = items[num].id_str;
+                        // 推送该条动态
+                        const flag = await (0, utils_1.withRetry)(async () => {
+                            // 渲染图片
+                            const { pic: gimgPic, buffer: gimgBuffer } = await this.ctx.gi.generateDynamicImg(items[num]);
+                            // 赋值
+                            pic = gimgPic;
+                            buffer = gimgBuffer;
+                        })
+                            .then(() => true)
+                            .catch(async (e) => {
+                            // 直播开播动态，不做处理
+                            if (e.message === "直播开播动态，不做处理")
+                                return;
+                            if (e.message === "出现关键词，屏蔽该动态") {
+                                // 如果需要发送才发送
+                                if (this.config.filter.notify) {
+                                    await this.sendMsg(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
                                 }
+                                return;
                             }
-                            // 判断是否需要发送URL
-                            const dUrl = this.config.dynamicUrl
-                                ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`
-                                : "";
-                            // 如果pic存在，则直接返回pic
-                            if (pic) {
-                                this.logger.info("推送动态中，使用render模式");
-                                // pic存在，使用的是render模式
-                                await this.sendMsg(sub.target, pic + dUrl);
-                            }
-                            else if (buffer) {
-                                this.logger.info("推送动态中，使用page模式");
-                                // pic不存在，说明使用的是page模式
-                                await this.sendMsg(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/png"), dUrl] }));
-                            }
-                            else {
-                                this.logger.info(`${items[num].modules.module_author.name}发布了一条动态，但是推送失败`);
+                            if (e.message === "已屏蔽转发动态") {
+                                if (this.config.filter.notify) {
+                                    await this.sendMsg(sub.target, `${upName}发布了一条转发动态，已屏蔽`);
+                                }
+                                return;
                             }
+                            // 未知错误
+                            this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
+                        });
+                        // 判断是否执行成功，未执行成功直接返回
+                        if (!flag)
+                            return;
+                        // 判断是否需要发送URL
+                        const dUrl = this.config.dynamicUrl
+                            ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`
+                            : "";
+                        // 如果pic存在，则直接返回pic
+                        if (pic) {
+                            this.logger.info("推送动态中，使用render模式");
+                            // pic存在，使用的是render模式
+                            await this.sendMsg(sub.target, pic + dUrl);
+                        }
+                        else if (buffer) {
+                            this.logger.info("推送动态中，使用page模式");
+                            // pic不存在，说明使用的是page模式
+                            await this.sendMsg(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/png"), dUrl] }));
+                        }
+                        else {
+                            this.logger.info(`${items[num].modules.module_author.name}发布了一条动态，但是推送失败`);
                         }
                     }
                 }
             }
-            finally {
-                flag = true;
-            }
         };
+        // 返回一个闭包函数
+        return (0, utils_1.withLock)(handler);
     }
     debug_dynamicDetect() {
         // 检测初始化变量
@@ -667,205 +654,189 @@ class ComRegister {
         let updateBaseline;
         // 第一条动态的动态ID
         let dynamicIdStr;
-        // 相当于锁的作用，防止上一个循环没处理完
-        let flag = true;
-        // 返回一个闭包函数
-        return async () => {
-            // 判断上一个循环是否完成
-            if (!flag)
+        // 定义处理逻辑
+        const handler = async () => {
+            console.log(`初始化状态：${detectSetup}`);
+            // 检测启动初始化
+            if (detectSetup) {
+                // 获取动态信息
+                const data = (await this.ctx.ba.getAllDynamic());
+                // 判断获取动态信息是否成功
+                if (data.code !== 0)
+                    return;
+                console.log(`更新基线：${data.data.update_baseline}`);
+                // 设置更新基线
+                updateBaseline = data.data.update_baseline;
+                // 设置初始化为false
+                detectSetup = false;
+                // 初始化完成
                 return;
-            flag = false;
-            // 无论是否执行成功都要释放锁
+            }
+            // 获取用户所有动态数据
+            let updateNum;
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+            let content;
             try {
-                console.log(`初始化状态：${detectSetup}`);
-                // 检测启动初始化
-                if (detectSetup) {
-                    // 获取动态信息
-                    const data = (await this.ctx.ba.getAllDynamic());
-                    // 判断获取动态信息是否成功
-                    if (data.code !== 0)
-                        return;
-                    console.log(`更新基线：${data.data.update_baseline}`);
-                    // 设置更新基线
-                    updateBaseline = data.data.update_baseline;
-                    // 设置初始化为false
-                    detectSetup = false;
-                    // 初始化完成
+                // 查询是否有新动态
+                const data = await this.ctx.ba.hasNewDynamic(updateBaseline);
+                updateNum = data.data.update_num;
+                // biome-ignore lint/style/noUnusedTemplateLiteral: <explanation>
+                console.log(`获取是否有新动态：`);
+                console.log(data);
+                // 没有新动态或获取动态信息失败直接返回
+                if (updateNum <= 0 || data.code !== 0)
                     return;
-                }
-                // 获取用户所有动态数据
-                let updateNum;
-                // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-                let content;
-                try {
-                    // 查询是否有新动态
-                    const data = await this.ctx.ba.hasNewDynamic(updateBaseline);
-                    updateNum = data.data.update_num;
-                    // biome-ignore lint/style/noUnusedTemplateLiteral: <explanation>
-                    console.log(`获取是否有新动态：`);
-                    console.log(data);
-                    // 没有新动态或获取动态信息失败直接返回
-                    if (updateNum <= 0 || data.code !== 0)
-                        return;
-                    // 获取动态内容
-                    content = (await this.ctx.ba.getAllDynamic(updateBaseline));
-                    console.log("获取动态内容：");
-                    console.log(content.data.items[0]);
-                }
-                catch (e) {
-                    return this.logger.error(`dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：${e.message}`);
-                }
-                // 判断获取动态内容是否成功
-                if (content.code !== 0) {
-                    switch (content.code) {
-                        case -101: {
-                            // 账号未登录
-                            // 输出日志
-                            this.logger.error("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
-                            // 发送私聊消息
-                            await this.sendPrivateMsg("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
-                            // 停止服务
-                            await this.ctx.sm.disposePlugin();
-                            // 结束循环
-                            break;
-                        }
-                        case -352: {
-                            // 风控
-                            // 输出日志
-                            this.logger.error("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
-                            // 发送私聊消息
-                            await this.sendPrivateMsg("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
-                            // 停止服务
-                            await this.ctx.sm.disposePlugin();
-                            // 结束循环
-                            break;
-                        }
-                        case 4101128:
-                        case 4101129: {
-                            // 获取动态信息错误
-                            // 输出日志
-                            this.logger.error(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`);
-                            // 发送私聊消息
-                            await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
-                            // 结束循环
-                            break;
-                        }
-                        default: {
-                            // 未知错误
-                            // 发送私聊消息
-                            await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
-                            // 结束循环
-                            break;
-                        }
+                // 获取动态内容
+                content = (await this.ctx.ba.getAllDynamic(updateBaseline));
+                console.log("获取动态内容：");
+                console.log(content.data.items[0]);
+            }
+            catch (e) {
+                return this.logger.error(`dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：${e.message}`);
+            }
+            // 判断获取动态内容是否成功
+            if (content.code !== 0) {
+                switch (content.code) {
+                    case -101: {
+                        // 账号未登录
+                        // 输出日志
+                        this.logger.error("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
+                        // 发送私聊消息
+                        await this.sendPrivateMsg("账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件");
+                        // 停止服务
+                        await this.ctx.sm.disposePlugin();
+                        // 结束循环
+                        break;
+                    }
+                    case -352: {
+                        // 风控
+                        // 输出日志
+                        this.logger.error("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
+                        // 发送私聊消息
+                        await this.sendPrivateMsg("账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件");
+                        // 停止服务
+                        await this.ctx.sm.disposePlugin();
+                        // 结束循环
+                        break;
+                    }
+                    case 4101128:
+                    case 4101129: {
+                        // 获取动态信息错误
+                        // 输出日志
+                        this.logger.error(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`);
+                        // 发送私聊消息
+                        await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
+                        // 结束循环
+                        break;
+                    }
+                    default: {
+                        // 未知错误
+                        // 发送私聊消息
+                        await this.sendPrivateMsg(`获取动态信息错误，错误码为：${content.code}，错误为：${content.message}`); // 未知错误
+                        // 结束循环
+                        break;
                     }
                 }
-                // 获取数据内容
-                const data = content.data;
-                // 更新基线
-                updateBaseline = data.update_baseline;
-                console.log(`更新基线：${updateBaseline}`);
-                // 有新动态内容
-                const items = data.items;
-                // 检查更新的动态
-                for (let num = updateNum - 1; num >= 0; num--) {
-                    // 有更新动态
-                    console.log("有更新动态");
-                    // 没有动态内容则直接跳过
-                    if (!items[num])
-                        continue;
-                    // 从动态数据中取出UP主名称、UID和动态ID
-                    const upName = content.data.items[num].modules.module_author.name;
-                    const upUID = items[num].modules.module_author.mid;
-                    const dynamicId = content.data.items[num].id_str;
-                    console.log(`寻找关注的UP主，当前动态UP主：${upName}，UID：${upUID}，动态ID：${dynamicId}`);
-                    // 寻找关注的UP主的动态
-                    for (const sub of this.subManager) {
-                        console.log(`当前订阅UP主：${sub.uid}`);
-                        // 判断是否是订阅的UP主
-                        // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
-                        if (sub.dynamic && sub.uid == upUID) {
-                            // 订阅该UP主，推送该动态
-                            // 判断更新动态是否为1条
-                            if (updateNum === 1) {
-                                // 判断dynamicIdStr是否有值，是否与当前动态ID一致
-                                if (dynamicIdStr && dynamicIdStr === items[num].id_str) {
-                                    // 重复动态，不再推送，直接返回
-                                    return;
-                                }
-                                // 存储该动态ID
-                                dynamicIdStr = items[num].id_str;
+            }
+            // 获取数据内容
+            const data = content.data;
+            // 更新基线
+            updateBaseline = data.update_baseline;
+            console.log(`更新基线：${updateBaseline}`);
+            // 有新动态内容
+            const items = data.items;
+            // 检查更新的动态
+            for (let num = updateNum - 1; num >= 0; num--) {
+                // 有更新动态
+                console.log("有更新动态");
+                // 没有动态内容则直接跳过
+                if (!items[num])
+                    continue;
+                // 从动态数据中取出UP主名称、UID和动态ID
+                const upName = content.data.items[num].modules.module_author.name;
+                const upUID = items[num].modules.module_author.mid;
+                const dynamicId = content.data.items[num].id_str;
+                console.log(`寻找关注的UP主，当前动态UP主：${upName}，UID：${upUID}，动态ID：${dynamicId}`);
+                // 寻找关注的UP主的动态
+                for (const sub of this.subManager) {
+                    console.log(`当前订阅UP主：${sub.uid}`);
+                    // 判断是否是订阅的UP主
+                    // biome-ignore lint/suspicious/noDoubleEquals: <explanation>
+                    if (sub.dynamic && sub.uid == upUID) {
+                        // 订阅该UP主，推送该动态
+                        // 判断更新动态是否为1条
+                        if (updateNum === 1) {
+                            // 判断dynamicIdStr是否有值，是否与当前动态ID一致
+                            if (dynamicIdStr && dynamicIdStr === items[num].id_str) {
+                                // 重复动态，不再推送，直接返回
+                                return;
                             }
-                            // 定义变量
-                            let pic;
-                            let buffer;
-                            // 从动态数据中取出UP主名称和动态ID
-                            const upName = items[num].modules.module_author.name;
-                            const dynamicId = items[num].id_str;
-                            console.log(`UP主名称：${upName}，动态ID：${dynamicId}`);
-                            // 推送该条动态
-                            const attempts = 3;
-                            for (let i = 0; i < attempts; i++) {
-                                // 获取动态推送图片
-                                try {
-                                    // 渲染图片
-                                    const { pic: gimgPic, buffer: gimgBuffer } = await this.ctx.gi.generateDynamicImg(items[num]);
-                                    // 赋值
-                                    pic = gimgPic;
-                                    buffer = gimgBuffer;
-                                    // 成功则跳出循环
-                                    break;
-                                }
-                                catch (e) {
-                                    // 直播开播动态，不做处理
-                                    if (e.message === "直播开播动态，不做处理")
-                                        return;
-                                    if (e.message === "出现关键词，屏蔽该动态") {
-                                        // 如果需要发送才发送
-                                        if (this.config.filter.notify) {
-                                            await this.sendMsg(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
-                                        }
-                                        return;
-                                    }
-                                    if (e.message === "已屏蔽转发动态") {
-                                        if (this.config.filter.notify) {
-                                            await this.sendMsg(sub.target, `${upName}发布了一条转发动态，已屏蔽`);
-                                        }
-                                        return;
-                                    }
-                                    // 未知错误
-                                    if (i === attempts - 1) {
-                                        this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
-                                        // 发送私聊消息并重启服务
-                                        return await this.sendPrivateMsgAndStopService();
-                                    }
+                            // 存储该动态ID
+                            dynamicIdStr = items[num].id_str;
+                        }
+                        // 定义变量
+                        let pic;
+                        let buffer;
+                        // 从动态数据中取出UP主名称和动态ID
+                        const upName = items[num].modules.module_author.name;
+                        const dynamicId = items[num].id_str;
+                        console.log(`UP主名称：${upName}，动态ID：${dynamicId}`);
+                        // 推送该条动态
+                        const flag = await (0, utils_1.withRetry)(async () => {
+                            // 渲染图片
+                            const { pic: gimgPic, buffer: gimgBuffer } = await this.ctx.gi.generateDynamicImg(items[num]);
+                            // 赋值
+                            pic = gimgPic;
+                            buffer = gimgBuffer;
+                        })
+                            .then(() => true)
+                            .catch(async (e) => {
+                            // 直播开播动态，不做处理
+                            if (e.message === "直播开播动态，不做处理")
+                                return;
+                            if (e.message === "出现关键词，屏蔽该动态") {
+                                // 如果需要发送才发送
+                                if (this.config.filter.notify) {
+                                    await this.sendMsg(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
                                 }
+                                return;
                             }
-                            // 判断是否需要发送URL
-                            const dUrl = this.config.dynamicUrl
-                                ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`
-                                : "";
-                            // 如果pic存在，则直接返回pic
-                            if (pic) {
-                                this.logger.info("推送动态中，使用render模式");
-                                // pic存在，使用的是render模式
-                                await this.sendMsg(sub.target, pic + dUrl);
-                            }
-                            else if (buffer) {
-                                this.logger.info("推送动态中，使用page模式");
-                                // pic不存在，说明使用的是page模式
-                                await this.sendMsg(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/png"), dUrl] }));
-                            }
-                            else {
-                                this.logger.info(`${items[num].modules.module_author.name}发布了一条动态，但是推送失败`);
+                            if (e.message === "已屏蔽转发动态") {
+                                if (this.config.filter.notify) {
+                                    await this.sendMsg(sub.target, `${upName}发布了一条转发动态，已屏蔽`);
+                                }
+                                return;
                             }
+                            // 未知错误
+                            this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
+                        });
+                        // 发送私聊消息并重启服务
+                        if (!flag)
+                            return await this.sendPrivateMsgAndStopService();
+                        // 判断是否需要发送URL
+                        const dUrl = this.config.dynamicUrl
+                            ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}`
+                            : "";
+                        // 如果pic存在，则直接返回pic
+                        if (pic) {
+                            this.logger.info("推送动态中，使用render模式");
+                            // pic存在，使用的是render模式
+                            await this.sendMsg(sub.target, pic + dUrl);
+                        }
+                        else if (buffer) {
+                            this.logger.info("推送动态中，使用page模式");
+                            // pic不存在，说明使用的是page模式
+                            await this.sendMsg(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, "image/png"), dUrl] }));
+                        }
+                        else {
+                            this.logger.info(`${items[num].modules.module_author.name}发布了一条动态，但是推送失败`);
                         }
                     }
                 }
             }
-            finally {
-                flag = true;
-            }
         };
+        // 加工handler并返回
+        return (0, utils_1.withLock)(handler);
     }
     // 定义发送直播通知卡片方法
     async sendLiveNotifyCard(info, liveType, followerDisplay, liveNotifyMsg) {
@@ -873,26 +844,21 @@ class ComRegister {
         let pic;
         let buffer;
         // 多次尝试生成图片
-        const attempts = 3;
-        for (let i = 0; i < attempts; i++) {
-            try {
-                // 获取直播通知卡片
-                const { pic: picv, buffer: bufferv } = await this.ctx.gi.generateLiveImg(info.data, info.username, info.userface, followerDisplay, liveType);
-                // 赋值
-                pic = picv;
-                buffer = bufferv;
-                // 成功则跳出循环
-                break;
-            }
-            catch (e) {
-                if (i === attempts - 1) {
-                    // 已尝试三次
-                    this.logger.error(`liveDetect generateLiveImg() 推送卡片生成失败，原因：${e.message}`);
-                    // 发送私聊消息并重启服务
-                    return await this.sendPrivateMsgAndStopService();
-                }
-            }
-        }
+        const flag = await (0, utils_1.withRetry)(async () => {
+            // 获取直播通知卡片
+            const { pic: picv, buffer: bufferv } = await this.ctx.gi.generateLiveImg(info.data, info.username, info.userface, followerDisplay, liveType);
+            // 赋值
+            pic = picv;
+            buffer = bufferv;
+        })
+            .then(() => true)
+            .catch((e) => {
+            this.logger.error(`liveDetect generateLiveImg() 推送卡片生成失败，原因：${e.message}`);
+            return false;
+        });
+        // 发送私聊消息并重启服务
+        if (!flag)
+            return await this.sendPrivateMsgAndStopService();
         // 推送直播信息
         // pic 存在，使用的是render模式
         if (pic) {
@@ -951,26 +917,18 @@ class ComRegister {
     }
     async useLiveRoomInfo(roomId) {
         // 发送请求获取直播间信息
-        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-        let content;
-        const attempts = 3;
-        for (let i = 0; i < attempts; i++) {
-            try {
-                // 发送请求获取room信息
-                content = await this.ctx.ba.getLiveRoomInfo(roomId);
-                // 成功则跳出循环
-                break;
-            }
-            catch (e) {
-                this.logger.error(`liveDetect getLiveRoomInfo 发生了错误，错误为：${e.message}`);
-                if (i === attempts - 1) {
-                    // 已尝试三次
-                    // 发送私聊消息并重启服务
-                    return await this.sendPrivateMsgAndStopService();
-                }
-            }
-        }
-        return content.data;
+        const data = await (0, utils_1.withRetry)(async () => await this.ctx.ba.getLiveRoomInfo(roomId))
+            .then((content) => content.data)
+            .catch((e) => {
+            this.logger.error(`liveDetect getLiveRoomInfo 发生了错误，错误为：${e.message}`);
+            // 返回错误
+            return false;
+        });
+        // 发送私聊消息并重启服务
+        if (!data)
+            return await this.sendPrivateMsgAndStopService();
+        // 返回
+        return data;
     }
     async liveDetectWithListener(roomId, target) {
         // 定义开播时间
@@ -1356,34 +1314,18 @@ class ComRegister {
     }
     async loadSubFromConfig(subs) {
         for (const sub of subs) {
+            // logger
+            this.logger.info(`加载订阅UID:${sub.uid}中...`);
             // 定义Data
-            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-            let 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) {
-                // 获取用户信息
-                // biome-ignore lint/suspicious/noExplicitAny: <explanation>
-                let content;
-                // 设置重试次数
-                const attempts = 3;
-                for (let i = 0; i < attempts; i++) {
-                    try {
-                        // 获取用户信息
-                        content = await this.ctx.ba.getUserInfo(sub.uid);
-                        // 成功则跳出循环
-                        break;
-                    }
-                    catch (e) {
-                        this.logger.error(`loadSubFromConfig() getUserInfo() 发生了错误，错误为：${e.message}`);
-                        if (i === attempts - 1) {
-                            // 已尝试三次
-                            // 发送私聊消息并重启服务
-                            return await this.sendPrivateMsgAndStopService();
-                        }
-                    }
-                }
-                // 获取data
-                data = content.data;
                 // 检查roomid是否存在
                 if (!data.live_room) {
                     // 用户没有开通直播间，无法订阅直播
@@ -1413,6 +1355,7 @@ class ComRegister {
                 live: sub.live,
                 dynamic: sub.dynamic,
             });
+            this.logger.info(`UID:${sub.uid}订阅加载完毕！`);
         }
     }
     checkIfDynamicDetectIsNeeded() {

package/lib/generateImg.d.ts

@@ -41,6 +41,8 @@ declare namespace GenerateImg {
         removeBorder: boolean;
         cardColorStart: string;
         cardColorEnd: string;
+        cardBasePlateColor: string;
+        cardBasePlateBorder: string;
         enableLargeFont: boolean;
         font: string;
         hideDesc: boolean;

package/lib/generateImg.js

@@ -70,9 +70,9 @@ class GenerateImg extends koishi_1.Service {
                         width: 100%;
                         height: auto;
                         box-shadow: 0 4px 8px 0 rgba(0, 0, 0, 0.2);
-                        padding: 15px;
+                        padding: ${this.giConfig.cardBasePlateBorder};
                         border-radius: 10px;
-                        background-color: #FFF5EE;
+                        background-color: ${this.giConfig.cardBasePlateColor};
                     }
         
                     .card {
@@ -160,7 +160,7 @@ class GenerateImg extends koishi_1.Service {
                                         <span class="broadcast-message">${username}${titleStatus}</span>
                                     </div>
                                 </div>
-                                ${this.giConfig.hideDesc ? "" : `<p class="card-text">${data.description ? data.description : "这个主播很懒，什么都简介都没写"}</p>`}
+                                ${this.giConfig.hideDesc ? "" : `<p class="card-text">${data.description ? data.description : "这个主播很懒，什么简介都没写"}</p>`}
                                 <p class="card-link">
                                     <span>人气：${data.online > 10000 ? `${(data.online / 10000).toFixed(1)}万` : data.online}</span>
                                     <span>分区名称：${data.area_name}</span>
@@ -575,7 +575,7 @@ class GenerateImg extends koishi_1.Service {
         // 判断是否开启大字体模式
         let style;
         if (this.giConfig.enableLargeFont) {
-            style = `
+            style = /* css */ `
             @font-face {
                 font-family: "Custom Font";
                 src: url(${fontURL});
@@ -605,9 +605,9 @@ class GenerateImg extends koishi_1.Service {
                 width: 100%;
                 height: auto;
                 box-shadow: 0 4px 8px 0 rgba(0, 0, 0, 0.2);
-                padding: 15px;
+                padding: ${this.giConfig.cardBasePlateBorder};
                 border-radius: 10px;
-                background-color: #FFF5EE;
+                background-color: ${this.giConfig.cardBasePlateColor};
             }
 
             .card {
@@ -940,7 +940,7 @@ class GenerateImg extends koishi_1.Service {
             `;
         }
         else {
-            style = `
+            style = /* css */ `
             @font-face {
                 font-family: "Custom Font";
                 src: url(${fontURL});
@@ -970,9 +970,9 @@ class GenerateImg extends koishi_1.Service {
                 width: 100%;
                 height: auto;
                 box-shadow: 0 4px 8px 0 rgba(0, 0, 0, 0.2);
-                padding: 15px;
+                padding: ${this.giConfig.cardBasePlateBorder};
                 border-radius: 10px;
-                background-color: #FFF5EE;
+                background-color: ${this.giConfig.cardBasePlateColor};
             }
     
             .card {
@@ -1521,6 +1521,8 @@ class GenerateImg extends koishi_1.Service {
         removeBorder: koishi_1.Schema.boolean(),
         cardColorStart: koishi_1.Schema.string(),
         cardColorEnd: koishi_1.Schema.string(),
+        cardBasePlateColor: koishi_1.Schema.string(),
+        cardBasePlateBorder: koishi_1.Schema.string(),
         enableLargeFont: koishi_1.Schema.boolean(),
         font: koishi_1.Schema.string(),
         hideDesc: koishi_1.Schema.boolean(),

package/lib/index.d.ts

@@ -10,6 +10,18 @@ declare class ServerManager extends Service {
     servers: ForkScope[];
     renderType: number;
     dynamicLoopTime: number;
+    renderTypePatternMatching: {
+        render: number;
+        page: number;
+    };
+    dynamicLoopTimePatternMatching: {
+        "1\u5206\u949F": number;
+        "2\u5206\u949F": number;
+        "3\u5206\u949F": number;
+        "5\u5206\u949F": number;
+        "10\u5206\u949F": number;
+        "20\u5206\u949F": number;
+    };
     constructor(ctx: Context);
     protected start(): void | Promise<void>;
     registerPlugin: () => boolean;
@@ -57,6 +69,8 @@ export interface Config {
     removeBorder: boolean;
     cardColorStart: string;
     cardColorEnd: string;
+    cardBasePlateColor: string;
+    cardBasePlateBorder: string;
     enableLargeFont: boolean;
     font: string;
     filter: {};

package/lib/index.js

@@ -56,6 +56,20 @@ class ServerManager extends koishi_1.Service {
     renderType;
     // 动态循环时间
     dynamicLoopTime;
+    // 定义渲染类型模式匹配
+    renderTypePatternMatching = {
+        render: 0,
+        page: 1,
+    };
+    // 定义具体时间模式匹配
+    dynamicLoopTimePatternMatching = {
+        "1分钟": 60,
+        "2分钟": 120,
+        "3分钟": 180,
+        "5分钟": 300,
+        "10分钟": 600,
+        "20分钟": 1200,
+    };
     constructor(ctx) {
         super(ctx, "sm");
         // 插件运行相关指令
@@ -99,35 +113,10 @@ class ServerManager extends koishi_1.Service {
     start() {
         // 加载配置
         // 根据用户设置的渲染模式设置
-        switch (globalConfig.renderType) {
-            case "render":
-                this.renderType = 0;
-                break;
-            case "page":
-                this.renderType = 1;
-                break;
-        }
+        this.renderType = this.renderTypePatternMatching[globalConfig.renderType];
         // 转换为具体时间
-        switch (globalConfig.dynamicLoopTime) {
-            case "1分钟":
-                this.dynamicLoopTime = 60;
-                break;
-            case "2分钟":
-                this.dynamicLoopTime = 120;
-                break;
-            case "3分钟":
-                this.dynamicLoopTime = 180;
-                break;
-            case "5分钟":
-                this.dynamicLoopTime = 300;
-                break;
-            case "10分钟":
-                this.dynamicLoopTime = 600;
-                break;
-            case "20分钟":
-                this.dynamicLoopTime = 1200;
-                break;
-        }
+        this.dynamicLoopTime =
+            this.dynamicLoopTimePatternMatching[globalConfig.dynamicLoopTime];
         // 注册插件
         if (!this.registerPlugin()) {
             this.logger.error("插件启动失败");
@@ -151,6 +140,8 @@ class ServerManager extends koishi_1.Service {
                 removeBorder: globalConfig.removeBorder,
                 cardColorStart: globalConfig.cardColorStart,
                 cardColorEnd: globalConfig.cardColorEnd,
+                cardBasePlateColor: globalConfig.cardBasePlateColor,
+                cardBasePlateBorder: globalConfig.cardBasePlateBorder,
                 hideDesc: globalConfig.hideDesc,
                 enableLargeFont: globalConfig.enableLargeFont,
                 font: globalConfig.font,
@@ -387,6 +378,14 @@ exports.Config = koishi_1.Schema.object({
         .pattern(/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/)
         .default("#F9CCDF")
         .description("推送卡片的结束渐变背景色，请填入16进制颜色代码，参考网站：https://colorate.azurewebsites.net/"),
+    cardBasePlateColor: koishi_1.Schema.string()
+        .pattern(/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/)
+        .default("#FFF5EE")
+        .description("推送卡片底板颜色，请填入16进制颜色代码"),
+    cardBasePlateBorder: koishi_1.Schema.string()
+        .pattern(/\d*\.?\d+(?:px|em|rem|%|vh|vw|vmin|vmax)/)
+        .default("15px")
+        .description("推送卡片底板边框宽度，请填入css单位，例如1px，12.5rem，100%"),
     enableLargeFont: koishi_1.Schema.boolean()
         .default(false)
         .description("是否开启动态推送卡片大字体模式，默认为小字体。小字体更漂亮，但阅读比较吃力，大字体更易阅读，但相对没这么好看"),

package/package.json

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

package/readme.md

@@ -207,6 +207,8 @@
 - ver 3.0.0-alpha.21 优化：部分代码； 新增：更新插件后，由于机器人还未启动，已开始发送消息报错 `this._request is not a function` ，新增报错后自动重新发送消息的功能
 - ver 3.0.0-alpha.22 优化：订阅配置展示优化
 - ver 3.0.0-alpha.23 新增：指令 `bili ll` 可以查看当前订阅直播的UP主们的开播情况
+- ver 3.0.0-alpha.24 新增：配置项，`cardBasePlateColor` 和 `cardBasePlateBorder`，分别设置卡片底板颜色和底板边框宽度； 优化：部分代码结构
+- ver 3.0.0-alpha.25 修复：输入指令 `bili ll` 时报错 `TypeError: Cannot read properties of null (reading 'items')`，当某个订阅只订阅动态时无法成功订阅且后续订阅都无法加载； 优化：部分代码结构
 
 ## 交流群