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

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

@@ -237,13 +237,17 @@ class ComRegister {
                     }
                 }
                 // 判断是否未开播
-                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;
         });
@@ -290,11 +294,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 +306,7 @@ class ComRegister {
                     // 打印错误信息
                     this.logger.error(`发送群组ID:${channelId}消息失败！原因: ${e.message}`);
                     await this.sendPrivateMsg(`发送群组ID:${channelId}消息失败，请查看日志`);
-                }
+                });
             };
         }
         // 检查登录数据库是否有数据
@@ -475,190 +475,180 @@ 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;
+                            // 存储该动态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 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}发布了一条含有屏蔽关键字的动态`);
                                     }
-                                    // 未知错误
-                                    if (i === attempts - 1) {
-                                        this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
-                                        // 发送私聊消息并重启服务
-                                        return await this.sendPrivateMsgAndStopService();
+                                    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();
                                 }
                             }
-                            // 判断是否需要发送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}发布了一条动态，但是推送失败`);
-                            }
+                        }
+                        // 判断是否需要发送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 +657,195 @@ 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;
+                            // 存储该动态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 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}发布了一条含有屏蔽关键字的动态`);
                                     }
-                                    // 未知错误
-                                    if (i === attempts - 1) {
-                                        this.logger.error(`dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：${e.message}`);
-                                        // 发送私聊消息并重启服务
-                                        return await this.sendPrivateMsgAndStopService();
+                                    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();
                                 }
                             }
-                            // 判断是否需要发送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}发布了一条动态，但是推送失败`);
-                            }
+                        }
+                        // 判断是否需要发送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) {

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 {
@@ -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.24",
   "contributors": [
     "Akokko <admin@akokko.com>"
   ],

package/readme.md

@@ -207,6 +207,7 @@
 - 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`，分别设置卡片底板颜色和底板边框宽度； 优化：部分代码结构
 
 ## 交流群