koishi-plugin-bilibili-notify 1.3.7 → 2.0.0-alpha.1

package/lib/comRegister.js

@@ -26,67 +26,36 @@ class ComRegister {
     rebootCount = 0;
     subNotifier;
     subManager = [];
-    // QQ群机器人
-    qqBot;
-    // QQ频道机器人
-    qqguildBot;
-    // OneBot机器人
-    oneBot;
-    // Red机器人
-    redBot;
-    // Telegram机器人
-    telegramBot;
-    // Satori机器人
-    satoriBot;
-    // Chronocat机器人
-    chronocatBot;
-    // Lark机器人
-    larkBot;
+    // 机器人实例
+    bot;
+    // 动态销毁函数
+    dynamicDispose;
     // 发送消息方式
     sendMsgFunc;
+    // 构造函数
     constructor(ctx, config) {
         this.logger = ctx.logger('cr');
         this.config = config;
-        // 拿到各类机器人
-        ctx.bots.forEach(bot => {
-            switch (bot.platform) {
-                case 'qq':
-                    this.qqBot = bot;
-                    break;
-                case 'qqguild':
-                    this.qqguildBot = bot;
-                    break;
-                case 'onebot':
-                    this.oneBot = bot;
-                    break;
-                case 'red':
-                    this.redBot = bot;
-                    break;
-                case 'telegram':
-                    this.telegramBot = bot;
-                    break;
-                case 'satori':
-                    this.satoriBot = bot;
-                    break;
-                case 'chronocat':
-                    this.chronocatBot = bot;
-                    break;
-                case 'lark':
-                    this.larkBot = bot;
-                    break;
-            }
-        });
+        // 拿到机器人实例
+        this.bot = ctx.bots.find(bot => bot.platform === config.platform);
+        if (!this.bot) {
+            ctx.notifier.create({
+                type: 'danger',
+                content: '未找到对应机器人实例，请检查配置是否正确或重新配置适配器！'
+            });
+            this.logger.error('未找到对应机器人实例，请检查配置是否正确或重新配置适配器！');
+        }
         // 从数据库获取订阅
         this.getSubFromDatabase(ctx);
         // 判断消息发送方式
         if (config.automaticResend) {
-            this.sendMsgFunc = async (guild, bot, content) => {
+            this.sendMsgFunc = async (guild, content) => {
                 // 多次尝试发送消息
                 const attempts = 3;
                 for (let i = 0; i < attempts; i++) {
                     try {
                         // 发送消息
-                        await bot.sendMessage(guild, content);
+                        await this.bot.sendMessage(guild, content);
                         // 防止消息发送速度过快被忽略
                         await ctx.sleep(500);
                         // 成功发送消息，跳出循环
@@ -95,134 +64,44 @@ class ComRegister {
                     catch (e) {
                         if (i === attempts - 1) { // 已尝试三次
                             this.logger.error(`发送群组ID:${guild}消息失败！原因: ` + e.message);
-                            this.sendPrivateMsg(bot, `发送群组ID:${guild}消息失败，请查看日志`);
+                            console.log(e);
+                            this.sendPrivateMsg(`发送群组ID:${guild}消息失败，请查看日志`);
                         }
                     }
                 }
             };
         }
         else {
-            this.sendMsgFunc = async (guild, bot, content) => {
+            this.sendMsgFunc = async (guild, content) => {
                 try {
                     // 发送消息
-                    await bot.sendMessage(guild, content);
+                    await this.bot.sendMessage(guild, content);
                 }
                 catch (e) {
                     this.logger.error(`发送群组ID:${guild}消息失败！原因: ` + e.message);
-                    await this.sendPrivateMsg(bot, `发送群组ID:${guild}消息失败，请查看日志`);
+                    await this.sendPrivateMsg(`发送群组ID:${guild}消息失败，请查看日志`);
                 }
             };
         }
-        /* const testCom = ctx.command('test', { hidden: true, permissions: ['authority:5'] })
-
-        testCom.subcommand('.cookies')
-            .usage('测试指令，用于测试从数据库读取cookies')
-            .action(async () => {
-                this.logger.info('调用test cookies指令')
-                // await ctx.ba.loadCookiesFromDatabase()
-                console.log(JSON.parse(ctx.ba.getCookies()));
-            })
-
-        testCom
-            .subcommand('.my')
-            .usage('测试指令，用于测试获取自己信息')
-            .example('test.my')
+        const statusCom = ctx.command('status', '插件状态相关指令', { permissions: ['authority:5'] });
+        statusCom.subcommand('.dyn', '查看动态监测运行状态')
+            .usage('查看动态监测运行状态')
+            .example('status dyn')
+            .action(() => {
+            if (this.dynamicDispose) {
+                return '动态监测正在运行';
+            }
+            else {
+                return '动态监测未运行';
+            }
+        });
+        statusCom.subcommand('.sm', '查看订阅管理对象')
+            .usage('查看订阅管理对象')
+            .example('status sm')
             .action(async () => {
-                const content = await ctx.ba.getMyselfInfo()
-                console.log(content);
-            })
-
-        testCom
-            .subcommand('.user <mid:string>')
-            .usage('测试指令，用于测试获取用户信息')
-            .example('test.user 用户UID')
-            .action(async (_, mid) => {
-                const content = await ctx.ba.getUserInfo(mid)
-                console.log(content);
-            })
-
-        testCom
-            .subcommand('.time')
-            .usage('测试时间接口')
-            .example('test.time')
-            .action(async ({ session }) => {
-                session.send(await ctx.ba.getTimeNow())
-            })
-
-        testCom
-            .subcommand('.gimg <uid:string> <index:number>')
-            .usage('测试图片生成')
-            .example('test.gimg')
-            .action(async ({ session }, uid, index) => {
-                // logger
-                this.logger.info('调用test gimg指令')
-                // 获取用户空间动态数据
-                const { data } = await ctx.ba.getUserSpaceDynamic(uid)
-                // 获取动态推送图片
-                const { pic, buffer } = await ctx.gi.generateDynamicImg(data.items[index])
-                // 如果pic存在，则直接返回pic
-                if (pic) return pic
-                // pic不存在，说明使用的是page模式
-                await session.send(h.image(buffer, 'image/png'))
-            })
-
-        testCom
-            .subcommand('.group')
-            .usage('查看session groupId')
-            .example('test group')
-            .action(({ session }) => {
-                console.log(session.event.channel);
-            })
-
-        testCom
-            .subcommand('.session')
-            .usage('查看seesion')
-            .example('test session')
-            .action(({ session }) => {
-                console.log(session);
-            })
-
-        testCom
-            .subcommand('.utc')
-            .usage('获取当前UTC+8 Unix时间戳')
-            .example('test utc')
-            .action(async ({ session }) => {
-                session.send((await ctx.ba.getServerUTCTime()).toString())
-            })
-
-        testCom
-            .subcommand('.livestop', '发送下播提示语测试')
-            .usage('发送下播提示语测试')
-            .example('test livestop')
-            .action(async ({ session }) => {
-                // logger
-                this.logger.info('调用test gimg指令')
-                // 获取主播信息
-                const { data } = await ctx.ba.getMasterInfo('686127')
-                let resizedImage: Buffer
-                try {
-                    resizedImage = await Jimp.read(data.info.face).then(async image => {
-                        return await image.resize(100, 100).getBufferAsync(Jimp.MIME_PNG)
-                    })
-                } catch (e) {
-                    if (e.message === 'Unsupported MIME type: image/webp') console.log('主播使用的是webp格式头像，无法进行渲染');
-                    else console.log(e);
-                }
-                // 发送下播提示语
-                await session.send(
-                    <>{resizedImage && h.image(resizedImage, 'image/png')} 主播{data.info.uname}已下播</>
-                )
-            })
-
-        testCom
-            .subcommand('.sendmsg', '测试发送消息方法')
-            .usage('测试发送消息方法')
-            .example('test sendmsg')
-            .action(async ({ session }) => {
-                // 获得对应bot
-                const bot = this.getTheCorrespondingBotBasedOnTheSession(session)
-                // this.sendMsg(['all'], bot, 'Hello World')
-            }) */
+            console.log(this.subManager);
+            return '查看控制台';
+        });
         const biliCom = ctx.command('bili', 'bili-notify插件相关指令', { permissions: ['authority:3'] });
         biliCom.subcommand('.login', '登录B站之后才可以进行之后的操作')
             .usage('使用二维码登录，登录B站之后才可以进行之后的操作')
@@ -340,18 +219,31 @@ class ComRegister {
                         return;
                     }
                     // 取消全部订阅 执行dispose方法，销毁定时器
-                    if (sub.dynamic)
-                        this.subManager[i].dynamicDispose();
                     if (sub.live)
                         this.subManager[i].liveDispose();
                     // 从数据库中删除订阅
                     await ctx.database.remove('bilibili', { uid: this.subManager[i].uid });
                     // 将该订阅对象从订阅管理对象中移除
                     this.subManager.splice(i, 1);
+                    // 将订阅对象移出订阅关注组
+                    const removeUserFromGroupData = await ctx.ba.removeUserFromGroup(sub.uid);
+                    // 判断是否移出成功 22105关注对象为自己
+                    if (removeUserFromGroupData.code !== 0 || removeUserFromGroupData.data !== 22105) {
+                        // 移出失败
+                        await session.send('取消订阅对象失败，请稍后重试');
+                        return;
+                    }
                     // id--
                     this.num--;
+                    // 判断是否还有动态订阅
+                    if (this.dynamicDispose && !this.subManager.find((sub) => sub.dynamic === true)) { // 没有动态订阅
+                        // 将动态检测关闭
+                        this.dynamicDispose();
+                        // 将动态监测置为空
+                        this.dynamicDispose = null;
+                    }
                     // 发送成功通知
-                    session.send('已取消订阅该用户');
+                    await session.send('已取消订阅该用户');
                     // 更新控制台提示
                     this.updateSubNotifier(ctx);
                     // 将存在flag设置为true
@@ -360,7 +252,7 @@ class ComRegister {
             }));
             // 未订阅该用户，无需取消订阅
             if (!exist)
-                session.send('未订阅该用户，无需取消订阅');
+                await session.send('未订阅该用户，无需取消订阅');
         });
         biliCom
             .subcommand('.show', '展示订阅对象')
@@ -378,6 +270,10 @@ class ComRegister {
             .example('bili sub 1194210119 目标QQ群号(实验性) -l -d 订阅UID为1194210119的UP主的动态和直播')
             .action(async ({ session, options }, mid, ...guildId) => {
             this.logger.info('调用bili.sub指令');
+            // 先判断是否订阅直播，再判断是否解锁订阅限制，最后判断直播订阅是否已超三个
+            if (options.live && !this.config.unlockSubLimits && (this.subManager.reduce((acc, cur) => acc + (cur.live ? 1 : 0), 0) >= 3)) {
+                return '直播订阅已达上限，请取消部分直播订阅后再进行订阅';
+            }
             // 检查是否是不支持的平台
             switch (session.event.platform) {
                 case 'lark':
@@ -395,27 +291,74 @@ class ComRegister {
                 // 未登录直接返回
                 return '请使用指令bili login登录后再进行订阅操作';
             }
-            // 如果订阅人数超过三个则直接返回
-            if (!config.unlockSubLimits && this.num >= 3)
-                return '目前最多只能订阅三个人';
-            // 检查必选参数是否有值
+            // 检查必选参数是否已填
             if (!mid)
                 return '请输入用户uid';
-            // 判断要订阅的用户是否已经存在于订阅管理对象中
-            if (this.subManager && this.subManager.some(sub => sub.uid === mid)) {
-                return '已订阅该用户，请勿重复订阅';
+            // 检查数据库是否有数据
+            const loginDBData = (await ctx.database.get('loginBili', 1, ['dynamic_group_id']))[0];
+            // 判断是否有数据
+            if (loginDBData.dynamic_group_id === '' || loginDBData.dynamic_group_id === null) {
+                // 没有数据，没有创建分组，尝试创建分组
+                const createGroupData = await ctx.ba.createGroup("订阅");
+                // 如果分组已创建，则获取分组id
+                if (createGroupData.code === 22106) {
+                    // 分组已存在，拿到之前的分组id
+                    const allGroupData = await ctx.ba.getAllGroup();
+                    // 遍历所有分组
+                    for (const group of allGroupData.data) {
+                        // 找到订阅分组
+                        if (group.name === '订阅') {
+                            // 拿到分组id
+                            loginDBData.dynamic_group_id = group.tagid;
+                            // 结束循环
+                            break;
+                        }
+                    }
+                }
+                else if (createGroupData.code !== 0) {
+                    // 创建分组失败
+                    return '创建关注分组出错';
+                }
+                // 创建成功，保存到数据库
+                ctx.database.set('loginBili', 1, { dynamic_group_id: loginDBData.dynamic_group_id });
             }
-            // 获取用户信息
+            // 订阅对象
+            const subUserData = await ctx.ba.follow(mid);
+            // 判断是否订阅成功
+            switch (subUserData.code) {
+                case -101: return '账号未登录，请使用指令bili login登录后再进行订阅操作';
+                case -102: return '账号被封停，无法进行订阅操作';
+                case 22002: return '因对方隐私设置，无法进行订阅操作';
+                case 22003: return '你已将对方拉黑，无法进行订阅操作';
+                case 22013: return '账号已注销，无法进行订阅操作';
+                case 40061: return '账号不存在，请检查uid输入是否正确或用户是否存在';
+                case 22001: break; // 订阅对象为自己 无需添加到分组
+                case 22014: // 已关注订阅对象 无需再次关注
+                case 0: { // 执行订阅成功
+                    // 把订阅对象添加到分组中
+                    const copyUserToGroupData = await ctx.ba.copyUserToGroup(mid, loginDBData.dynamic_group_id);
+                    // 判断是否添加成功
+                    if (copyUserToGroupData.code !== 0) {
+                        // 添加失败
+                        return '添加订阅对象到分组失败，请稍后重试';
+                    }
+                }
+            }
+            // 定义外围变量                
             let content;
             try {
+                // 获取用户信息
                 content = await ctx.ba.getUserInfo(mid);
             }
             catch (e) {
+                // 返回错误信息
                 return 'bili sub getUserInfo() 发生了错误，错误为：' + e.message;
             }
-            // 判断是否有其他问题
+            // 判断是否成功获取用户信息
             if (content.code !== 0) {
+                // 定义错误消息
                 let msg;
+                // 判断错误代码
                 switch (content.code) {
                     case -400:
                         msg = '请求错误';
@@ -433,10 +376,13 @@ class ComRegister {
                         msg = '未知错误，错误信息：' + content.message;
                         break;
                 }
+                // 返回错误信息
                 return msg;
             }
-            // 设置目标ID
+            // 定义目标群组id
             let targetId;
+            // 定义目标群组id数组
+            let targetIdArr;
             // 判断是否输入了QQ群号
             if (guildId.length > 0) { // 输入了QQ群号
                 // 定义方法
@@ -447,6 +393,7 @@ class ComRegister {
                     const targetArr = [];
                     // 判断群号是否符合条件
                     for (const guild of guildId) {
+                        // 判断是否机器人加入了该群
                         if (guildList.data.some(cv => cv.id === guild)) { // 机器人加入了该群
                             // 保存到数组
                             targetArr.push(guild);
@@ -465,6 +412,7 @@ class ComRegister {
                 if (guildId[0] === 'all') {
                     // 判断是否有群机器人相关Bot
                     if (['qq', 'onebot', 'red', 'satori', 'chronocat'].includes(session.event.platform)) {
+                        // 推送所有群组
                         okGuild.push('all');
                     }
                     else {
@@ -477,24 +425,13 @@ class ComRegister {
                 else {
                     // 判断是否有群机器人相关Bot
                     switch (session.event.platform) {
-                        case 'qq': {
-                            okGuild = await checkIfGuildHasJoined(this.qqBot);
-                            break;
-                        }
-                        case 'onebot': {
-                            okGuild = await checkIfGuildHasJoined(this.oneBot);
-                            break;
-                        }
-                        case 'red': {
-                            okGuild = await checkIfGuildHasJoined(this.redBot);
-                            break;
-                        }
-                        case 'satori': {
-                            okGuild = await checkIfGuildHasJoined(this.satoriBot);
-                            break;
-                        }
+                        case 'qq':
+                        case 'onebot':
+                        case 'red':
+                        case 'satori':
                         case 'chronocat': {
-                            okGuild = await checkIfGuildHasJoined(this.chronocatBot);
+                            // 检查机器人是否加入该群
+                            okGuild = await checkIfGuildHasJoined(this.bot);
                             break;
                         }
                         default: {
@@ -505,23 +442,37 @@ class ComRegister {
                         }
                     }
                 }
+                // 将可用的目标赋值给数组
+                targetIdArr = okGuild;
                 // 将群号用空格进行分割
                 targetId = okGuild.join(' ');
             }
             else { // 没有输入QQ群号
                 // 为当前群聊环境进行推送
                 targetId = session.event.channel.id;
+                // 将目标id转换为数组进行赋值
+                targetIdArr = [session.event.channel.id];
             }
             // 获取data
             const { data } = content;
-            // 判断是否需要订阅直播
-            const liveMsg = await this.checkIfNeedSub(options.live, '直播', session, data);
-            // 判断是否需要订阅动态
-            const dynamicMsg = await this.checkIfNeedSub(options.dynamic, '动态', session);
+            // 判断是否需要订阅直播和动态
+            const [liveMsg, dynamicMsg] = await this.checkIfNeedSub(options.live, options.dynamic, session, data);
             // 判断是否未订阅任何消息
             if (!liveMsg && !dynamicMsg) {
                 return '您未订阅该UP的任何消息';
             }
+            const subUser = this.subManager.find(sub => sub.uid === mid);
+            // 判断要订阅的用户是否已经存在于订阅管理对象中
+            if (subUser) {
+                // 已存在，判断是否重复订阅直播通知
+                if (liveMsg && subUser.live) {
+                    return '已订阅该用户直播通知，请勿重复订阅';
+                }
+                // 已存在，判断是否重复订阅动态通知
+                if (dynamicMsg && subUser.dynamic) {
+                    return '已订阅该用户动态通知，请勿重复订阅';
+                }
+            }
             // 获取直播房间号
             const roomId = data.live_room?.roomid.toString();
             // 保存到数据库中
@@ -537,18 +488,16 @@ class ComRegister {
             });
             // 订阅数+1
             this.num++;
-            // 开始订阅
             // 保存新订阅对象
             this.subManager.push({
                 id: sub.id,
                 uid: mid,
-                targetId,
+                targetIdArr,
                 roomId,
                 platform: session.event.platform,
                 live: liveMsg,
                 dynamic: dynamicMsg,
-                liveDispose: null,
-                dynamicDispose: null
+                liveDispose: null
             });
             // 获取用户信息
             let userData;
@@ -560,55 +509,36 @@ class ComRegister {
                 this.logger.error('bili sub指令 getMasterInfo() 发生了错误，错误为：' + e.message);
                 return '订阅出错啦，请重试';
             }
-            // 需要订阅直播
+            console.log(liveMsg, dynamicMsg);
+            // 订阅直播
             if (liveMsg) {
                 await session.execute(`bili live ${roomId} ${targetId.split(',').join(' ')}`);
                 // 发送订阅消息通知
                 await session.send(`订阅${userData.info.uname}直播通知`);
             }
-            // 需要订阅动态
+            // 订阅动态
             if (dynamicMsg) {
-                await session.execute(`bili dynamic ${mid} ${targetId.split(',').join(' ')}`);
+                // 判断是否开启动态监测
+                if (!this.dynamicDispose) {
+                    // 开启动态监测
+                    if (this.config.dynamicDebugMode) {
+                        this.dynamicDispose = ctx.setInterval(this.debug_dynamicDetect(ctx), config.dynamicLoopTime * 1000);
+                    }
+                    else {
+                        this.dynamicDispose = ctx.setInterval(this.dynamicDetect(ctx), config.dynamicLoopTime * 1000);
+                    }
+                }
                 // 发送订阅消息通知
                 await session.send(`订阅${userData.info.uname}动态通知`);
             }
             // 新增订阅展示到控制台
             this.updateSubNotifier(ctx);
         });
-        biliCom
-            .subcommand('.dynamic <uid:string> <...guildId:string>', '订阅用户动态推送', { hidden: true })
-            .usage('订阅用户动态推送')
-            .example('bili dynamic 1194210119 订阅UID为1194210119的动态')
-            .action(async ({ session }, uid, ...guildId) => {
-            this.logger.info('调用bili.dynamic指令');
-            // 如果uid为空则返回
-            if (!uid)
-                return `${uid}非法调用 dynamic 指令`; // 用户uid不能为空
-            if (!guildId)
-                return `${uid}非法调用 dynamic 指令`; // 目标群组或频道不能为空
-            // 寻找对应订阅管理对象
-            const index = this.subManager.findIndex(sub => sub.uid === uid);
-            // 不存在则直接返回
-            if (index === -1)
-                return '请勿直接调用该指令';
-            // 获得对应bot
-            const bot = this.getTheCorrespondingBotBasedOnTheSession(session);
-            // 开始循环检测
-            let dispose;
-            if (this.config.dynamicDebugMode) {
-                dispose = ctx.setInterval(this.debug_dynamicDetect(ctx, bot, uid, guildId), config.dynamicLoopTime * 1000);
-            }
-            else {
-                dispose = ctx.setInterval(this.dynamicDetect(ctx, bot, uid, guildId), config.dynamicLoopTime * 1000);
-            }
-            // 将销毁函数保存到订阅管理对象
-            this.subManager[index].dynamicDispose = dispose;
-        });
         biliCom
             .subcommand('.live <roomId:string> <...guildId:string>', '订阅主播开播通知', { hidden: true })
             .usage('订阅主播开播通知')
             .example('bili live 26316137 订阅房间号为26316137的直播间')
-            .action(async ({ session }, roomId, ...guildId) => {
+            .action(async (_, roomId, ...guildId) => {
             this.logger.info('调用bili.live指令');
             // 如果room_id为空则返回
             if (!roomId)
@@ -619,10 +549,8 @@ class ComRegister {
             const index = this.subManager.findIndex(sub => sub.roomId === roomId);
             if (index === -1)
                 return '请勿直接调用该指令';
-            // 获得对应bot
-            const bot = this.getTheCorrespondingBotBasedOnTheSession(session);
             // 开始循环检测
-            const dispose = ctx.setInterval(this.liveDetect(ctx, bot, roomId, guildId), config.liveLoopTime * 1000);
+            const dispose = ctx.setInterval(this.liveDetect(ctx, roomId, guildId), config.liveLoopTime * 1000);
             // 保存销毁函数
             this.subManager[index].liveDispose = dispose;
         });
@@ -687,103 +615,31 @@ class ComRegister {
             .usage('向主人账号发送一条测试消息')
             .example('bili private 向主人账号发送一条测试消息')
             .action(async ({ session }) => {
-            // 获得对应bot
-            const bot = this.getTheCorrespondingBotBasedOnTheSession(session);
             // 发送消息
-            await this.sendPrivateMsg(bot, 'Hello World');
+            await this.sendPrivateMsg('Hello World');
             // 发送提示
             await session.send('已发送消息，如未收到则说明您的机器人不支持发送私聊消息或您的信息填写有误');
         });
-        /* biliCom
-            .subcommand('.reboot', '测试插件自动重启功能', { hidden: true })
-            .usage('测试插件自动重启功能')
-            .example('bili reboot 测试插件自动重启功能')
-            .action(async ({ session }) => {
-                // 发送提示消息
-                await session.send('测试biliAPI等服务自动重启功能')
-                // 获得对应bot
-                const bot = this.getTheCorrespondingBotBasedOnTheSession(session)
-                // 发送提示消息，重启服务
-                await this.sendPrivateMsgAndStopService(ctx, bot, '测试biliAPI等服务自动重启功能')
-            }) */
-        /* biliCom
-            .subcommand('.sendall', '测试给机器人加入的所有群发送消息', { hidden: true })
-            .usage('测试给机器人加入的所有群发送消息')
-            .example('bili sendall 测试给机器人加入的所有群发送消息')
-            .action(async ({ session }) => {
-                // 获得对应bot
-                const bot = this.getTheCorrespondingBotBasedOnTheSession(session)
-                // 发送消息
-                await this.sendMsg(ctx, ['all'], bot, 'Hello World')
-                // 发送提示
-                await session.send('已向机器人加入的所有群发送了消息')
-            }) */
-        /* biliCom
-            .subcommand('.list', '获取机器人加入的所有群组', { hidden: true })
-            .usage('获取当前机器人加入的所有群聊')
-            .example('bili list 获取当前机器人加入的所有群聊')
-            .action(async ({ session }) => {
-                // 获取对应Bot
-                const bot = this.getTheCorrespondingBotBasedOnTheSession(session)
-                // 获取群列表
-                const guildList = (await bot.getGuildList()).data
-                // 遍历群列表
-                guildList.map(item => this.logger.info(`已加入${item.id}`))
-            }) */
-    }
-    getTheCorrespondingBotBasedOnTheSession(session) {
-        // 获取对应Bot
-        let bot;
-        switch (session.event.platform) {
-            case 'lark':
-                bot = this.larkBot;
-                break;
-            case 'qq':
-                bot = this.qqBot;
-                break;
-            case 'qqguild':
-                bot = this.qqguildBot;
-                break;
-            case 'onebot':
-                bot = this.oneBot;
-                break;
-            case 'red':
-                bot = this.redBot;
-                break;
-            case 'telegram':
-                bot = this.telegramBot;
-                break;
-            case 'satori':
-                bot = this.satoriBot;
-                break;
-            case 'chronocat':
-                bot = this.chronocatBot;
-                break;
-            default: {
-                session.send('暂不支持该平台！');
-            }
-        }
-        return bot;
     }
-    async sendPrivateMsg(bot, content) {
+    async sendPrivateMsg(content) {
         if (this.config.master.enable) {
             if (this.config.master.masterAccountGuildId) {
                 // 向机器人主人发送消息
-                await bot.sendPrivateMessage(this.config.master.masterAccount, content, this.config.master.masterAccountGuildId);
+                await this.bot.sendPrivateMessage(this.config.master.masterAccount, content, this.config.master.masterAccountGuildId);
             }
             else {
                 // 向机器人主人发送消息
-                await bot.sendPrivateMessage(this.config.master.masterAccount, content);
+                await this.bot.sendPrivateMessage(this.config.master.masterAccount, content);
             }
         }
     }
-    async sendPrivateMsgAndRebootService(ctx, bot) {
+    async sendPrivateMsgAndRebootService(ctx) {
         // 判断重启次数是否超过三次
         if (this.rebootCount >= 3) {
             // logger
             this.logger.error('已重启插件三次，请检查机器人状态后使用指令 sys start 启动插件');
             // 重启失败，发送消息
-            await this.sendPrivateMsg(bot, '已重启插件三次，请检查机器人状态后使用指令 sys start 启动插件');
+            await this.sendPrivateMsg('已重启插件三次，请检查机器人状态后使用指令 sys start 启动插件');
             // 关闭插件
             await ctx.sm.disposePlugin();
             // 结束
@@ -803,14 +659,14 @@ class ComRegister {
             // logger
             this.logger.error('重启插件失败，请检查机器人状态后使用指令 sys start 启动插件');
             // 重启失败，发送消息
-            await this.sendPrivateMsg(bot, '重启插件失败，请检查机器人状态后使用指令 sys start 启动插件');
+            await this.sendPrivateMsg('重启插件失败，请检查机器人状态后使用指令 sys start 启动插件');
             // 关闭插件
             await ctx.sm.disposePlugin();
         }
     }
-    async sendPrivateMsgAndStopService(ctx, bot) {
+    async sendPrivateMsgAndStopService(ctx) {
         // 发送消息
-        await this.sendPrivateMsg(bot, '插件发生未知错误，请检查机器人状态后使用指令 sys start 启动插件');
+        await this.sendPrivateMsg('插件发生未知错误，请检查机器人状态后使用指令 sys start 启动插件');
         // logger
         this.logger.error('插件发生未知错误，请检查机器人状态后使用指令 sys start 启动插件');
         // 关闭插件
@@ -818,13 +674,13 @@ class ComRegister {
         // 结束
         return;
     }
-    async sendMsg(targets, bot, content) {
+    async sendMsg(targets, content) {
         // 定义需要发送的数组
         let sendArr = [];
         // 判断是否需要推送所有机器人加入的群
         if (targets[0] === 'all') {
             // 获取所有guild
-            for (const guild of (await bot.getGuildList()).data) {
+            for (const guild of (await this.bot.getGuildList()).data) {
                 sendArr.push(guild.id);
             }
         }
@@ -833,14 +689,15 @@ class ComRegister {
         }
         // 循环给每个群组发送
         for (const guild of sendArr) {
-            await this.sendMsgFunc(guild, bot, content);
+            await this.sendMsgFunc(guild, content);
         }
     }
-    dynamicDetect(ctx, bot, uid, guildId) {
-        let firstSubscription = true;
-        let timePoint;
+    dynamicDetect(ctx) {
+        let detectSetup = true;
+        let updateBaseline;
         // 相当于锁的作用，防止上一个循环没处理完
         let flag = true;
+        // 返回一个闭包函数
         return async () => {
             // 判断上一个循环是否完成
             if (!flag)
@@ -848,30 +705,44 @@ class ComRegister {
             flag = false;
             // 无论是否执行成功都要释放锁
             try {
-                // 第一次订阅判断
-                if (firstSubscription) {
-                    // 设置第一次的时间点
-                    timePoint = ctx.ba.getTimeOfUTC8();
-                    // 设置第一次为false
-                    firstSubscription = false;
+                // 检测启动初始化
+                if (detectSetup) {
+                    // 获取动态信息
+                    const data = await ctx.ba.getAllDynamic();
+                    // 判断获取动态信息是否成功
+                    if (data.code !== 0)
+                        return;
+                    // 设置更新基线
+                    updateBaseline = data.data.update_baseline;
+                    // 设置初始化为false
+                    detectSetup = false;
+                    // 初始化完成
                     return;
                 }
-                // 获取用户空间动态数据
+                // 获取用户所有动态数据
+                let updateNum;
                 let content;
                 try {
-                    content = await ctx.ba.getUserSpaceDynamic(uid);
+                    // 查询是否有新动态
+                    const data = await ctx.ba.hasNewDynamic(updateBaseline);
+                    updateNum = data.data.update_num;
+                    // 没有新动态或获取动态信息失败直接返回
+                    if (updateNum <= 0 || data.code !== 0)
+                        return;
+                    // 获取动态内容
+                    content = await 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(bot, '账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
+                            await this.sendPrivateMsg('账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
                             // 停止服务
                             await ctx.sm.disposePlugin();
                             // 结束循环
@@ -881,7 +752,7 @@ class ComRegister {
                             // 输出日志
                             this.logger.error('账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
                             // 发送私聊消息
-                            await this.sendPrivateMsg(bot, '账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
+                            await this.sendPrivateMsg('账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
                             // 停止服务
                             await ctx.sm.disposePlugin();
                             // 结束循环
@@ -892,104 +763,98 @@ class ComRegister {
                             // 输出日志
                             this.logger.error('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message);
                             // 发送私聊消息
-                            await this.sendPrivateMsg(bot, '获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
+                            await this.sendPrivateMsg('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
                             // 结束循环
                             break;
                         }
                         default: { // 未知错误
                             // 发送私聊消息
-                            await this.sendPrivateMsg(bot, '获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
-                            // 取消订阅
-                            this.unsubAll(ctx, bot, uid);
+                            await this.sendPrivateMsg('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
                             // 结束循环
                             break;
                         }
                     }
                 }
                 // 获取数据内容
-                const items = content.data.items;
-                // 定义方法：更新时间点为最新发布动态的发布时间
-                const updatePoint = (num) => {
-                    switch (num) {
-                        case 1: {
-                            if (items[0].modules.module_tag) { // 存在置顶动态
-                                timePoint = items[num].modules.module_author.pub_ts;
-                            }
-                            break;
-                        }
-                        case 0: timePoint = items[num].modules.module_author.pub_ts;
-                    }
-                };
-                // 发送请求 默认只查看配置文件规定数量的数据
-                for (let num = this.config.dynamicCheckNumber - 1; num >= 0; num--) {
+                const data = content.data;
+                // 更新基线
+                updateBaseline = data.update_baseline;
+                // 有新动态内容
+                const items = data.items;
+                // 检查更新的动态
+                for (let num = updateNum - 1; num >= 0; num--) {
                     // 没有动态内容则直接跳过
                     if (!items[num])
                         continue;
-                    // 寻找发布时间比时间点更晚的动态
-                    if (items[num].modules.module_author.pub_ts > timePoint) {
-                        // 定义变量
-                        let pic;
-                        let buffer;
-                        // 从动态数据中取出UP主名称和动态ID
-                        const upName = content.data.items[num].modules.module_author.name;
-                        const dynamicId = content.data.items[num].id_str;
-                        // 推送该条动态
-                        const attempts = 3;
-                        for (let i = 0; i < attempts; i++) {
-                            // 获取动态推送图片
-                            try {
-                                // 渲染图片
-                                const { pic: gimgPic, buffer: gimgBuffer } = await ctx.gi.generateDynamicImg(items[num]);
-                                // 赋值
-                                pic = gimgPic;
-                                buffer = gimgBuffer;
-                                // 成功则跳出循环
-                                break;
-                            }
-                            catch (e) {
-                                // 直播开播动态，不做处理
-                                if (e.message === '直播开播动态，不做处理')
-                                    return updatePoint(num);
-                                if (e.message === '出现关键词，屏蔽该动态') {
-                                    // 如果需要发送才发送
-                                    if (this.config.filter.notify) {
-                                        await this.sendMsg(guildId, bot, `${upName}发布了一条含有屏蔽关键字的动态`);
-                                    }
-                                    return updatePoint(num);
+                    // 从动态数据中取出UP主名称、UID和动态ID
+                    const upUID = items[num].modules.module_author.mid;
+                    // 寻找关注的UP主的动态
+                    this.subManager.forEach(async (sub) => {
+                        // 判断是否是订阅的UP主
+                        if (sub.uid == upUID) {
+                            // 订阅该UP主，推送该动态
+                            // 定义变量
+                            let pic;
+                            let buffer;
+                            // 从动态数据中取出UP主名称和动态ID
+                            const upName = content.data.items[num].modules.module_author.name;
+                            const dynamicId = content.data.items[num].id_str;
+                            // 推送该条动态
+                            const attempts = 3;
+                            for (let i = 0; i < attempts; i++) {
+                                // 获取动态推送图片
+                                try {
+                                    // 渲染图片
+                                    const { pic: gimgPic, buffer: gimgBuffer } = await ctx.gi.generateDynamicImg(items[num]);
+                                    // 赋值
+                                    pic = gimgPic;
+                                    buffer = gimgBuffer;
+                                    // 成功则跳出循环
+                                    break;
                                 }
-                                if (e.message === '已屏蔽转发动态') {
-                                    if (this.config.filter.notify) {
-                                        await this.sendMsg(guildId, bot, `${upName}发布了一条转发动态，已屏蔽`);
+                                catch (e) {
+                                    // 直播开播动态，不做处理
+                                    if (e.message === '直播开播动态，不做处理')
+                                        return;
+                                    if (e.message === '出现关键词，屏蔽该动态') {
+                                        // 如果需要发送才发送
+                                        if (this.config.filter.notify) {
+                                            await this.sendMsg(sub.targetIdArr, `${upName}发布了一条含有屏蔽关键字的动态`);
+                                        }
+                                        return;
+                                    }
+                                    if (e.message === '已屏蔽转发动态') {
+                                        if (this.config.filter.notify) {
+                                            await this.sendMsg(sub.targetIdArr, `${upName}发布了一条转发动态，已屏蔽`);
+                                        }
+                                        return;
+                                    }
+                                    // 未知错误
+                                    if (i === attempts - 1) {
+                                        this.logger.error('dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：' + e.message);
+                                        // 发送私聊消息并重启服务
+                                        return await this.sendPrivateMsgAndStopService(ctx);
                                     }
-                                    return updatePoint(num);
-                                }
-                                // 未知错误
-                                if (i === attempts - 1) {
-                                    this.logger.error('dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：' + e.message);
-                                    // 发送私聊消息并重启服务
-                                    return await this.sendPrivateMsgAndStopService(ctx, bot);
                                 }
                             }
+                            // 判断是否需要发送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.targetIdArr, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
+                            }
+                            else if (buffer) {
+                                this.logger.info('推送动态中，使用page模式');
+                                // pic不存在，说明使用的是page模式
+                                await this.sendMsg(sub.targetIdArr, (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(guildId, bot, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
-                        }
-                        else if (buffer) {
-                            this.logger.info('推送动态中，使用page模式');
-                            // pic不存在，说明使用的是page模式
-                            await this.sendMsg(guildId, bot, (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 + '发布了一条动态，但是推送失败');
-                        }
-                        // 更新时间点
-                        updatePoint(num);
-                    }
+                    });
                 }
             }
             finally {
@@ -997,11 +862,12 @@ class ComRegister {
             }
         };
     }
-    debug_dynamicDetect(ctx, bot, uid, guildId) {
-        let firstSubscription = true;
-        let timePoint;
+    debug_dynamicDetect(ctx) {
+        let detectSetup = true;
+        let updateBaseline;
         // 相当于锁的作用，防止上一个循环没处理完
         let flag = true;
+        // 返回一个闭包函数
         return async () => {
             // 判断上一个循环是否完成
             if (!flag)
@@ -1009,33 +875,50 @@ class ComRegister {
             flag = false;
             // 无论是否执行成功都要释放锁
             try {
-                // 第一次订阅判断
-                if (firstSubscription) {
-                    this.logger.info(`UID：${uid}-动态监测开始`);
-                    // 设置第一次的时间点
-                    timePoint = ctx.ba.getTimeOfUTC8();
-                    // 设置第一次为false
-                    firstSubscription = false;
+                console.log(`初始化状态：${detectSetup}`);
+                // 检测启动初始化
+                if (detectSetup) {
+                    // 获取动态信息
+                    const data = await ctx.ba.getAllDynamic();
+                    // 判断获取动态信息是否成功
+                    if (data.code !== 0)
+                        return;
+                    console.log(`更新基线：${data.data.update_baseline}`);
+                    // 设置更新基线
+                    updateBaseline = data.data.update_baseline;
+                    // 设置初始化为false
+                    detectSetup = false;
+                    // 初始化完成
                     return;
                 }
-                this.logger.info(`UID：${uid}-获取动态信息中`);
-                // 获取用户空间动态数据
+                // 获取用户所有动态数据
+                let updateNum;
                 let content;
                 try {
-                    content = await ctx.ba.getUserSpaceDynamic(uid);
+                    // 查询是否有新动态
+                    const data = await ctx.ba.hasNewDynamic(updateBaseline);
+                    updateNum = data.data.update_num;
+                    console.log(`获取是否有新动态：`);
+                    console.log(data);
+                    // 没有新动态或获取动态信息失败直接返回
+                    if (updateNum <= 0 || data.code !== 0)
+                        return;
+                    // 获取动态内容
+                    content = await ctx.ba.getAllDynamic(updateBaseline);
+                    console.log('获取动态内容：');
+                    console.log(content.data.items[0]);
                 }
                 catch (e) {
-                    return this.logger.error(`UID：${uid}-dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：${e.message}`);
+                    return this.logger.error('dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：' + e.message);
                 }
-                this.logger.info(`UID：${uid}-判断动态信息是否正确`);
-                // 判断是否出现其他问题
+                // 判断获取动态内容是否成功
                 if (content.code !== 0) {
                     switch (content.code) {
                         case -101: { // 账号未登录
                             // 输出日志
                             this.logger.error('账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
                             // 发送私聊消息
-                            await this.sendPrivateMsg(bot, '账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
+                            await this.sendPrivateMsg('账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
                             // 停止服务
                             await ctx.sm.disposePlugin();
                             // 结束循环
@@ -1045,7 +928,7 @@ class ComRegister {
                             // 输出日志
                             this.logger.error('账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
                             // 发送私聊消息
-                            await this.sendPrivateMsg(bot, '账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
+                            await this.sendPrivateMsg('账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
                             // 停止服务
                             await ctx.sm.disposePlugin();
                             // 结束循环
@@ -1056,109 +939,106 @@ class ComRegister {
                             // 输出日志
                             this.logger.error('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message);
                             // 发送私聊消息
-                            await this.sendPrivateMsg(bot, '获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
+                            await this.sendPrivateMsg('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
                             // 结束循环
                             break;
                         }
                         default: { // 未知错误
                             // 发送私聊消息
-                            await this.sendPrivateMsg(bot, '获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
-                            // 取消订阅
-                            this.unsubAll(ctx, bot, uid);
+                            await this.sendPrivateMsg('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
                             // 结束循环
                             break;
                         }
                     }
                 }
                 // 获取数据内容
-                const items = content.data.items;
-                this.logger.info(`UID：${uid}-获取到的动态信息：${items.map(v => v.basic.rid_str).join('、')}`);
-                // 定义方法：更新时间点为最新发布动态的发布时间
-                const updatePoint = (num) => {
-                    switch (num) {
-                        case 1: {
-                            if (items[0].modules.module_tag) { // 存在置顶动态
-                                timePoint = items[num].modules.module_author.pub_ts;
-                            }
-                            break;
-                        }
-                        case 0: timePoint = items[num].modules.module_author.pub_ts;
-                    }
-                };
-                // 发送请求 默认只查看配置文件规定数量的数据
-                for (let num = this.config.dynamicCheckNumber - 1; num >= 0; num--) {
+                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;
-                    // 寻找发布时间比时间点更晚的动态
-                    if (items[num].modules.module_author.pub_ts > timePoint) {
-                        this.logger.info(`UID：${uid}-即将推送的动态：${items[num].basic.rid_str}`);
-                        // 定义变量
-                        let pic;
-                        let buffer;
-                        // 从动态数据中取出UP主名称和动态ID
-                        const upName = content.data.items[num].modules.module_author.name;
-                        const dynamicId = content.data.items[num].id_str;
-                        // 推送该条动态
-                        const attempts = 3;
-                        this.logger.info(`UID：${uid}-尝试渲染推送图片`);
-                        for (let i = 0; i < attempts; i++) {
-                            // 获取动态推送图片
-                            try {
-                                // 渲染图片
-                                const { pic: gimgPic, buffer: gimgBuffer } = await ctx.gi.generateDynamicImg(items[num]);
-                                // 赋值
-                                pic = gimgPic;
-                                buffer = gimgBuffer;
-                                // 成功则跳出循环
-                                break;
-                            }
-                            catch (e) {
-                                // 直播开播动态，不做处理
-                                if (e.message === '直播开播动态，不做处理')
-                                    return updatePoint(num);
-                                if (e.message === '出现关键词，屏蔽该动态') {
-                                    // 如果需要发送才发送
-                                    if (this.config.filter.notify) {
-                                        await this.sendMsg(guildId, bot, `${upName}发布了一条含有屏蔽关键字的动态`);
-                                    }
-                                    return updatePoint(num);
+                    // 从动态数据中取出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主的动态
+                    this.subManager.forEach(async (sub) => {
+                        console.log(`当前订阅UP主：${sub.uid}`);
+                        // 判断是否是订阅的UP主
+                        if (sub.uid == upUID) {
+                            // 订阅该UP主，推送该动态
+                            // 定义变量
+                            let pic;
+                            let buffer;
+                            // 从动态数据中取出UP主名称和动态ID
+                            const upName = content.data.items[num].modules.module_author.name;
+                            const dynamicId = content.data.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 ctx.gi.generateDynamicImg(items[num]);
+                                    // 赋值
+                                    pic = gimgPic;
+                                    buffer = gimgBuffer;
+                                    // 成功则跳出循环
+                                    break;
                                 }
-                                if (e.message === '已屏蔽转发动态') {
-                                    if (this.config.filter.notify) {
-                                        await this.sendMsg(guildId, bot, `${upName}发布了一条转发动态，已屏蔽`);
+                                catch (e) {
+                                    // 直播开播动态，不做处理
+                                    if (e.message === '直播开播动态，不做处理')
+                                        return;
+                                    if (e.message === '出现关键词，屏蔽该动态') {
+                                        // 如果需要发送才发送
+                                        if (this.config.filter.notify) {
+                                            await this.sendMsg(sub.targetIdArr, `${upName}发布了一条含有屏蔽关键字的动态`);
+                                        }
+                                        return;
+                                    }
+                                    if (e.message === '已屏蔽转发动态') {
+                                        if (this.config.filter.notify) {
+                                            await this.sendMsg(sub.targetIdArr, `${upName}发布了一条转发动态，已屏蔽`);
+                                        }
+                                        return;
+                                    }
+                                    // 未知错误
+                                    if (i === attempts - 1) {
+                                        this.logger.error('dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：' + e.message);
+                                        // 发送私聊消息并重启服务
+                                        return await this.sendPrivateMsgAndStopService(ctx);
                                     }
-                                    return updatePoint(num);
-                                }
-                                // 未知错误
-                                if (i === attempts - 1) {
-                                    this.logger.error('dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：' + e.message);
-                                    // 发送私聊消息并重启服务
-                                    return await this.sendPrivateMsgAndStopService(ctx, bot);
                                 }
                             }
+                            // 判断是否需要发送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.targetIdArr, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
+                            }
+                            else if (buffer) {
+                                this.logger.info('推送动态中，使用page模式');
+                                // pic不存在，说明使用的是page模式
+                                await this.sendMsg(sub.targetIdArr, (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 + '发布了一条动态，但是推送失败');
+                            }
                         }
-                        this.logger.info(`UID：${uid}-尝试推送动态卡片`);
-                        // 判断是否需要发送URL
-                        const dUrl = this.config.dynamicUrl ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}` : '';
-                        // 如果pic存在，则直接返回pic
-                        if (pic) {
-                            this.logger.info(`UID：${uid}-推送动态中，使用render模式`);
-                            // pic存在，使用的是render模式
-                            await this.sendMsg(guildId, bot, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
-                        }
-                        else if (buffer) {
-                            this.logger.info(`UID：${uid}-推送动态中，使用page模式`);
-                            // pic不存在，说明使用的是page模式
-                            await this.sendMsg(guildId, bot, (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 + '发布了一条动态，但是推送失败');
-                        }
-                        // 更新时间点
-                        updatePoint(num);
-                        this.logger.info(`UID：${uid}-推送动态完成`);
-                    }
+                    });
                 }
             }
             finally {
@@ -1166,7 +1046,7 @@ class ComRegister {
             }
         };
     }
-    liveDetect(ctx, bot, roomId, guildId) {
+    liveDetect(ctx, roomId, guildId) {
         let firstSubscription = true;
         let timer = 0;
         let open = false;
@@ -1199,7 +1079,7 @@ class ComRegister {
                         if (i === attempts - 1) { // 已尝试三次
                             this.logger.error('liveDetect generateLiveImg() 推送卡片生成失败，原因：' + e.message);
                             // 发送私聊消息并重启服务
-                            return await this.sendPrivateMsgAndStopService(ctx, bot);
+                            return await this.sendPrivateMsgAndStopService(ctx);
                         }
                     }
                 }
@@ -1207,11 +1087,11 @@ class ComRegister {
                 // pic 存在，使用的是render模式
                 if (pic) {
                     const msg = (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [atAll && (0, jsx_runtime_1.jsx)("at", { type: "all" }), liveStartMsg && liveStartMsg, liveType !== LiveType.StartBroadcasting ? `https://live.bilibili.com/${roomId}` : ''] });
-                    return await this.sendMsg(guildId, bot, pic + msg);
+                    return await this.sendMsg(guildId, pic + msg);
                 }
                 // pic不存在，说明使用的是page模式
                 const msg = (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), atAll && (0, jsx_runtime_1.jsx)("at", { type: "all" }), liveStartMsg && liveStartMsg, liveType !== LiveType.StartBroadcasting ? `https://live.bilibili.com/${roomId}` : ''] });
-                await this.sendMsg(guildId, bot, msg);
+                await this.sendMsg(guildId, msg);
             };
         }
         else {
@@ -1235,7 +1115,7 @@ class ComRegister {
                         if (i === attempts - 1) { // 已尝试三次
                             this.logger.error('liveDetect generateLiveImg() 推送卡片生成失败，原因：' + e.message);
                             // 发送私聊消息并重启服务
-                            return await this.sendPrivateMsgAndStopService(ctx, bot);
+                            return await this.sendPrivateMsgAndStopService(ctx);
                         }
                     }
                 }
@@ -1243,11 +1123,11 @@ class ComRegister {
                 // pic 存在，使用的是render模式
                 if (pic) {
                     const msg = (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [atAll && (0, jsx_runtime_1.jsx)("at", { type: "all" }), liveStartMsg && liveStartMsg] });
-                    return await this.sendMsg(guildId, bot, pic + msg);
+                    return await this.sendMsg(guildId, pic + msg);
                 }
                 // pic不存在，说明使用的是page模式
                 const msg = (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), atAll && (0, jsx_runtime_1.jsx)("at", { type: "all" }), liveStartMsg && liveStartMsg] });
-                await this.sendMsg(guildId, bot, msg);
+                await this.sendMsg(guildId, msg);
             };
         }
         // 定义获取主播信息方法
@@ -1287,7 +1167,7 @@ class ComRegister {
                         this.logger.error('liveDetect getLiveRoomInfo 发生了错误，错误为：' + e.message);
                         if (i === attempts - 1) { // 已尝试三次
                             // 发送私聊消息并重启服务
-                            return await this.sendPrivateMsgAndStopService(ctx, bot);
+                            return await this.sendPrivateMsgAndStopService(ctx);
                         }
                     }
                 }
@@ -1308,7 +1188,7 @@ class ComRegister {
                             this.logger.error('liveDetect getMasterInfo() 发生了错误，错误为：' + e.message);
                             if (i === attempts - 1) { // 已尝试三次
                                 // 发送私聊消息并重启服务
-                                return await this.sendPrivateMsgAndStopService(ctx, bot);
+                                return await this.sendPrivateMsgAndStopService(ctx);
                             }
                         }
                     }
@@ -1352,7 +1232,7 @@ class ComRegister {
                                     console.log(e);
                             }
                             // 发送下播通知
-                            await this.sendMsg(guildId, bot, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [resizedImage && koishi_1.h.image(resizedImage, 'image/png'), " ", liveEndMsg] }));
+                            await this.sendMsg(guildId, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [resizedImage && koishi_1.h.image(resizedImage, 'image/png'), " ", liveEndMsg] }));
                         }
                         // 未进循环，还未开播，继续循环
                         break;
@@ -1377,7 +1257,7 @@ class ComRegister {
                                     this.logger.error('liveDetect open getMasterInfo() 发生了错误，错误为：' + e.message);
                                     if (i === attempts - 1) { // 已尝试三次
                                         // 发送私聊消息并重启服务
-                                        return await this.sendPrivateMsgAndStopService(ctx, bot);
+                                        return await this.sendPrivateMsgAndStopService(ctx);
                                     }
                                 }
                             }
@@ -1426,40 +1306,35 @@ class ComRegister {
         });
         return table ? table : '没有订阅任何UP';
     }
-    async checkIfNeedSub(comNeed, subType, session, data) {
-        if (comNeed) {
-            if (subType === '直播' && !data.live_room) {
+    async checkIfNeedSub(liveSub, dynamicSub, session, data) {
+        // 定义方法：用户直播间是否存在
+        const liveRoom = async () => {
+            if (!data.live_room) {
+                // 未开通直播间
                 await session.send('该用户未开通直播间，无法订阅直播');
-                return false;
+                // 返回false
+                return true;
             }
-            return true;
+            return false;
+        };
+        // 如果两者都为true或者都为false则直接返回
+        if ((liveSub && dynamicSub) || (!liveSub && !dynamicSub)) {
+            // 判断是否存在直播间
+            if (await liveRoom())
+                return [false, true];
+            // 返回
+            return [true, true];
         }
-        let input; // 用户输入
-        // 询问用户是否需要订阅直播
-        while (true) {
-            session.send(`是否需要订阅${subType}？需要输入 y 不需要输入 n `);
-            input = await session.prompt();
-            if (!input) {
-                await session.send('输入超时请重新订阅');
-                continue;
-            }
-            switch (input) {
-                case 'y': { // 需要订阅直播
-                    // 如果用户没有开通直播间则无法订阅
-                    if (subType === '直播' && !data.live_room) {
-                        await session.send('该用户未开通直播间，无法订阅直播');
-                        return false;
-                    }
-                    // 开启直播订阅
-                    return true;
-                }
-                // 不需要
-                case 'n': return false;
-                default: { // 输入了其他的内容
-                    session.send('输入有误，请输入 y 或 n');
-                }
-            }
+        // 如果只订阅直播
+        if (liveSub) {
+            // 判断是否存在直播间
+            if (await liveRoom())
+                return [false, false];
+            // 返回
+            return [true, false];
         }
+        // 只订阅动态
+        return [false, true];
     }
     updateSubNotifier(ctx) {
         // 更新控制台提示
@@ -1509,21 +1384,10 @@ class ComRegister {
             return;
         // 从数据库中获取数据
         const subData = await ctx.database.get('bilibili', { id: { $gt: 0 } });
-        // 设定订阅数量
-        this.num = subData.length;
-        // 如果订阅数量超过三个则数据库被非法修改
-        if (!this.config.unlockSubLimits && this.num > 3) {
-            // 在控制台提示重新订阅
-            ctx.notifier.create({
-                type: 'danger',
-                content: '您未解锁订阅限制，且订阅数大于3人，请您手动删除bilibili表中多余的数据后重启本插件'
-            });
-            return;
-        }
+        // 定义变量：订阅直播数
+        let liveSubNum = 0;
         // 循环遍历
         for (const sub of subData) {
-            // 定义Bot
-            let bot;
             // 判断是否存在没有任何订阅的数据
             if (!sub.dynamic && !sub.live) { // 存在未订阅任何项目的数据
                 // 删除该条数据
@@ -1534,45 +1398,8 @@ class ComRegister {
                 continue;
             }
             // 获取推送目标数组
-            const targetArr = sub.targetId.split(' ');
-            // 拿到对应bot
-            switch (sub.platform) {
-                case 'lark':
-                    bot = this.larkBot;
-                    break;
-                case 'qq':
-                    bot = this.qqBot;
-                    break;
-                case 'qqguild':
-                    bot = this.qqguildBot;
-                    break;
-                case 'onebot':
-                    bot = this.oneBot;
-                    break;
-                case 'red':
-                    bot = this.redBot;
-                    break;
-                case 'telegram':
-                    bot = this.telegramBot;
-                    break;
-                case 'satori':
-                    bot = this.satoriBot;
-                    break;
-                case 'chronocat':
-                    bot = this.chronocatBot;
-                    break;
-                default: {
-                    // 本条数据被篡改，删除该条订阅
-                    ctx.database.remove('bilibili', { id: sub.id });
-                    // 不支持的协议
-                    this.logger.info(`UID:${sub.uid} 出现不支持的协议，该条数据被篡改，自动取消订阅`);
-                    // 发送消息
-                    await this.sendPrivateMsg(bot, `UID:${sub.uid} 出现不支持的协议，该条数据被篡改，自动取消订阅`);
-                    // 继续下个循环
-                    continue;
-                }
-            }
-            // 判断数据库是否被篡改
+            const targetIdArr = sub.targetId.split(' ');
+            /* 判断数据库是否被篡改 */
             // 获取用户信息
             let content;
             const attempts = 3;
@@ -1587,7 +1414,7 @@ class ComRegister {
                     this.logger.error('getSubFromDatabase() getUserInfo() 发生了错误，错误为：' + e.message);
                     if (i === attempts - 1) { // 已尝试三次
                         // 发送私聊消息并重启服务
-                        return await this.sendPrivateMsgAndStopService(ctx, bot);
+                        return await this.sendPrivateMsgAndStopService(ctx);
                     }
                 }
             }
@@ -1598,14 +1425,14 @@ class ComRegister {
                 // 从数据库删除该条数据
                 await ctx.database.remove('bilibili', { id: sub.id });
                 // 给用户发送提示
-                await this.sendPrivateMsg(bot, `UID:${sub.uid} 数据库内容被篡改，已取消对该UP主的订阅`);
+                await this.sendPrivateMsg(`UID:${sub.uid} 数据库内容被篡改，已取消对该UP主的订阅`);
             };
             // 判断是否有其他问题
             if (content.code !== 0) {
                 switch (content.code) {
                     case -352:
                     case -403: {
-                        await this.sendPrivateMsg(bot, '你的登录信息已过期，请重新登录Bilibili');
+                        await this.sendPrivateMsg('你的登录信息已过期，请重新登录Bilibili');
                         return;
                     }
                     case -400:
@@ -1613,7 +1440,7 @@ class ComRegister {
                     default: {
                         await deleteSub();
                         // PrivateMsg
-                        await this.sendPrivateMsg(bot, `UID:${sub.uid} 数据出现问题，自动取消订阅`);
+                        await this.sendPrivateMsg(`UID:${sub.uid} 数据出现问题，自动取消订阅`);
                         // log
                         this.logger.info(`UID:${sub.uid} 数据出现问题，自动取消订阅`);
                         return;
@@ -1627,7 +1454,7 @@ class ComRegister {
                 // log
                 this.logger.info(`UID:${sub.uid} 房间号被篡改，自动取消订阅`);
                 // Send msg
-                await this.sendPrivateMsg(bot, `UID:${sub.uid} 房间号被篡改，自动取消订阅`);
+                await this.sendPrivateMsg(`UID:${sub.uid} 房间号被篡改，自动取消订阅`);
                 return;
             }
             // 构建订阅对象
@@ -1635,92 +1462,116 @@ class ComRegister {
                 id: sub.id,
                 uid: sub.uid,
                 roomId: sub.room_id,
-                targetId: sub.targetId,
+                targetIdArr,
                 platform: sub.platform,
                 live: +sub.live === 1 ? true : false,
                 dynamic: +sub.dynamic === 1 ? true : false,
-                liveDispose: null,
-                dynamicDispose: null
+                liveDispose: null
             };
-            // 判断需要订阅的服务
-            if (sub.dynamic) { // 需要订阅动态
-                let dispose;
-                // 开始循环检测
-                if (this.config.dynamicDebugMode) {
-                    dispose = ctx.setInterval(this.debug_dynamicDetect(ctx, bot, sub.uid, targetArr), this.config.dynamicLoopTime * 1000);
+            // 判断是否订阅直播
+            if (sub.live) {
+                // 判断订阅直播数是否超过限制
+                if (!this.config.unlockSubLimits && liveSubNum >= 3) {
+                    subManagerItem.live = false;
+                    // log
+                    this.logger.warn(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
+                    // 发送错误消息
+                    this.sendPrivateMsg(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
                 }
                 else {
-                    dispose = ctx.setInterval(this.dynamicDetect(ctx, bot, sub.uid, targetArr), this.config.dynamicLoopTime * 1000);
+                    // 直播订阅数+1
+                    liveSubNum++;
+                    // 订阅直播，开始循环检测
+                    const dispose = ctx.setInterval(this.liveDetect(ctx, sub.room_id, targetIdArr), this.config.liveLoopTime * 1000);
+                    // 保存销毁函数
+                    subManagerItem.liveDispose = dispose;
                 }
-                // 保存销毁函数
-                subManagerItem.dynamicDispose = dispose;
-            }
-            if (sub.live) { // 需要订阅直播
-                // 开始循环检测
-                const dispose = ctx.setInterval(this.liveDetect(ctx, bot, sub.room_id, targetArr), this.config.liveLoopTime * 1000);
-                // 保存销毁函数
-                subManagerItem.liveDispose = dispose;
             }
             // 保存新订阅对象
             this.subManager.push(subManagerItem);
         }
+        // 检查是否有订阅对象需要动态监测
+        if (this.subManager.some(sub => sub.dynamic)) {
+            // 开始动态监测
+            if (this.config.dynamicDebugMode) {
+                this.dynamicDispose = ctx.setInterval(this.debug_dynamicDetect(ctx), 10000);
+            }
+            else {
+                this.dynamicDispose = ctx.setInterval(this.dynamicDetect(ctx), 10000 /* this.config.dynamicLoopTime * 1000 */);
+            }
+        }
         // 在控制台中显示订阅对象
         this.updateSubNotifier(ctx);
     }
     unsubSingle(ctx, id /* UID或RoomId */, type /* 0取消Live订阅，1取消Dynamic订阅 */) {
-        let index;
-        const checkIfNoSubExist = (index) => {
-            if (!this.subManager[index].dynamic && !this.subManager[index].live) {
-                // 获取要删除行的id
-                const id = this.subManager[index].id;
-                // 从管理对象中移除
-                this.subManager.splice(index, 1);
-                // 从数据库中删除
-                ctx.database.remove('bilibili', [id]);
-                // num--
-                this.num--;
-                return '已取消订阅该用户';
-            }
-            return null;
+        // 定义返回消息
+        let msg;
+        // 定义方法：检查是否没有任何订阅
+        const checkIfNoSubExist = (sub) => !sub.dynamic && !sub.live;
+        // 定义方法：将订阅对象从订阅管理对象中移除
+        const removeSub = (index) => {
+            // 从管理对象中移除
+            this.subManager.splice(index, 1);
+            // 从数据库中删除
+            ctx.database.remove('bilibili', [this.subManager[index].id]);
+            // num--
+            this.num--;
+            // 判断是否还存在订阅了动态的对象，不存在则停止动态监测
+            this.checkIfUserThatIsSubDynAndUnsub();
         };
         try {
             switch (type) {
                 case 0: { // 取消Live订阅
-                    index = this.subManager.findIndex(sub => sub.roomId === id);
-                    if (index === -1)
-                        return '未订阅该用户，无需取消订阅';
+                    // 获取订阅对象所在的索引
+                    const index = this.subManager.findIndex(sub => sub.roomId === id);
+                    // 获取订阅对象
+                    const sub = this.subManager.find(sub => sub.roomId === id);
+                    // 判断是否存在订阅对象
+                    if (!sub) {
+                        msg = '未订阅该用户，无需取消订阅';
+                        return msg;
+                    }
                     // 取消订阅
-                    if (this.subManager[index].live)
-                        this.subManager[index].liveDispose();
-                    this.subManager[index].liveDispose = null;
-                    this.subManager[index].live = false;
+                    if (sub.live)
+                        sub.liveDispose();
+                    sub.liveDispose = null;
+                    sub.live = false;
                     // 如果没有对这个UP的任何订阅，则移除
-                    const info = checkIfNoSubExist(index);
-                    if (info)
-                        return info;
+                    if (checkIfNoSubExist(sub)) {
+                        // 从管理对象中移除
+                        removeSub(index);
+                        return '已取消订阅该用户';
+                    }
                     // 更新数据库
                     ctx.database.upsert('bilibili', [{
-                            id: +`${this.subManager[index].id}`,
+                            id: +`${sub.id}`,
                             live: 0
                         }]);
                     return '已取消订阅Live';
                 }
                 case 1: { // 取消Dynamic订阅
-                    index = this.subManager.findIndex(sub => sub.uid === id);
-                    if (index === -1)
-                        return '未订阅该用户，无需取消订阅';
+                    // 获取订阅对象所在的索引
+                    const index = this.subManager.findIndex(sub => sub.uid === id);
+                    // 获取订阅对象
+                    const sub = this.subManager.find(sub => sub.uid === id);
+                    // 判断是否存在订阅对象
+                    if (!sub) {
+                        msg = '未订阅该用户，无需取消订阅';
+                        return msg;
+                    }
                     // 取消订阅
-                    if (this.subManager[index].dynamic)
-                        this.subManager[index].dynamicDispose();
-                    this.subManager[index].dynamicDispose = null;
                     this.subManager[index].dynamic = false;
+                    // 判断是否还存在订阅了动态的对象，不存在则停止动态监测
+                    this.checkIfUserThatIsSubDynAndUnsub();
                     // 如果没有对这个UP的任何订阅，则移除
-                    const info = checkIfNoSubExist(index);
-                    if (info)
-                        return info;
+                    if (checkIfNoSubExist(sub)) {
+                        // 从管理对象中移除
+                        removeSub(index);
+                        return '已取消订阅该用户';
+                    }
                     // 更新数据库
                     ctx.database.upsert('bilibili', [{
-                            id: +`${this.subManager[index].id}`,
+                            id: sub.id,
                             dynamic: 0
                         }]);
                     return '已取消订阅Dynamic';
@@ -1732,13 +1583,20 @@ class ComRegister {
             this.updateSubNotifier(ctx);
         }
     }
-    unsubAll(ctx, bot, uid) {
+    checkIfUserThatIsSubDynAndUnsub() {
+        if (this.subManager.some(sub => sub.dynamic)) {
+            // 停止动态监测
+            this.dynamicDispose();
+            this.dynamicDispose = null;
+        }
+    }
+    unsubAll(ctx, uid) {
         this.subManager.filter(sub => sub.uid === uid).map(async (sub, i) => {
             // 取消全部订阅 执行dispose方法，销毁定时器
-            if (sub.dynamic)
-                await this.subManager[i].dynamicDispose();
             if (sub.live)
                 await this.subManager[i].liveDispose();
+            // 判断是否还存在订阅了动态的对象，不存在则停止动态监测
+            this.checkIfUserThatIsSubDynAndUnsub();
             // 从数据库中删除订阅
             await ctx.database.remove('bilibili', { uid: this.subManager[i].uid });
             // 将该订阅对象从订阅管理对象中移除
@@ -1746,7 +1604,7 @@ class ComRegister {
             // id--
             this.num--;
             // 发送成功通知
-            this.sendPrivateMsg(bot, `UID:${uid}，已取消订阅该用户`);
+            this.sendPrivateMsg(`UID:${uid}，已取消订阅该用户`);
             // 更新控制台提示
             this.updateSubNotifier(ctx);
         });
@@ -1763,6 +1621,7 @@ class ComRegister {
 }
 (function (ComRegister) {
     ComRegister.Config = koishi_1.Schema.object({
+        platform: koishi_1.Schema.string(),
         master: koishi_1.Schema.object({
             enable: koishi_1.Schema.boolean(),
             masterAccount: koishi_1.Schema.string(),