koishi-plugin-bilibili-notify 2.0.0-alpha.5 → 2.0.0-alpha.7

package/README.md

@@ -48,23 +48,22 @@
 
 订阅UP主：订阅你想要推送的UP主
 
-- 使用指令 `bili sub <uid> [Q群号]` 订阅需要订阅的UP主
+- 使用指令 `bili sub <uid>` 订阅需要订阅的UP主
 - 参数说明：
   - `uid` 为必填参数，为 `up主` 的  `uid` 
-  - `Q群号` 为可选参数，可以添加多个，如果Q群号为 `all` 则会向机器人加入的所有群聊推送
-- 选项说明：`bili sub <uid>` 有两个选项：-l 和 -d
+- 选项说明：`bili sub <uid>` 有三个选项：-l -d -m
   - `-l` 为订阅UP主直播间，包括直播开播通知，定时推送直播内容，下播通知
   - `-d` 为订阅UP主动态推送，目前实现推送的动态类型有：普通图文动态，转发动态，直播预约动态
+  - `-m` 为多平台动态推送，格式为：群号/频道号,群号/频道号,群号/频道号.平台名;群号/频道号,群号/频道号.平台号
+  例如：
+  `-m 3247293,324389,89874324.qq;EDBWIUBIU.qqguild;79324792,3247892.onebot`
+  所有分隔符均为英文符号
 
 - 例如：
-  - `bili sub 1194210119 ` 订阅UID为1194210119的UP主
+  - `bili sub 1194210119 ` 订阅UID为1194210119的UP主动态推送和直播间
   - `bili sub 1194210119 -d` 订阅UID为1194210119的UP主动态推送
-  - `bili sub 1194210119 -ld` 订阅UID为1194210119的UP主动态推送和直播间
-  - `bili sub 1194210119 1234567 2345678` 订阅UID为1194210119的UP主，向Q群号为1234567和2345678两个群进行推送
-  - `bili sub 1194210119 all` 订阅UID为1194210119的UP主，向机器人加入的所有群聊进行推送
-- Tips:
-  - 除非使用指令 `bili sub 1194210119 -ld` ，没有加选项或只加了一个选项的指令都会再次询问是否需要订阅另一项。例如：使用指令 `bili sub 1194210119 -d` 机器人会询问是否需要订阅直播间
-  - `[Q群号]` 这个可选参数仅支持Q群
+  - `bili sub 1194210119 -l` 订阅UID为1194210119的UP主直播间
+  - `bili sub 1194210119 -m 3247293,324389,89874324.qq;all.onebot;EHUIWDBUAWD.qqguild` 订阅UID为1194210119的UP主，向群号为3247293，324389，89874324的QQ群，所有onebot平台下的群聊，频道号为EHUIWDBUAWD的QQ频道平台进行推送
 
 取消订阅UP主：取消订阅不需要推送的UP主
 
@@ -183,6 +182,8 @@
 - ver 2.0.0-alpha.3 修复：订阅和取消订阅的bug，下播通知的bug
 - ver 2.0.0-alpha.4 修复：初次订阅后不推送动态的bug 优化：下播不再发送链接
 - ver 2.0.0-alpha.5 移除：选项pushUrl，选项platform 新增：选项customLive，主人账号中platform选项。支持多平台，且可同时推送不同平台，单个UP主只能推送一个平台
+- ver 2.0.0-alpha.6 修复：直播推送发送失败的bug
+- ver 2.0.0-alpha.7 重构：现已支持同一UP多平台推送
 
 ## 交流群
 

package/lib/comRegister.d.ts

@@ -1,11 +1,16 @@
 import { Bot, Context, FlatPick, Logger, Schema, Session } from "koishi";
 import { Notifier } from "@koishijs/plugin-notifier";
 import { LoginBili } from "./database";
+type TargetItem = {
+    idArr: Array<string>;
+    platform: string;
+};
+type Target = Array<TargetItem>;
 type SubItem = {
     id: number;
     uid: string;
     roomId: string;
-    targetIdArr: Array<string>;
+    target: Target;
     platform: string;
     live: boolean;
     dynamic: boolean;
@@ -14,6 +19,7 @@ type SubItem = {
 type SubManager = Array<SubItem>;
 declare class ComRegister {
     static inject: string[];
+    qqRelatedBotList: Array<string>;
     logger: Logger;
     config: ComRegister.Config;
     loginTimer: Function;
@@ -26,16 +32,20 @@ declare class ComRegister {
     dynamicDispose: Function;
     sendMsgFunc: (bot: Bot<Context, any>, guild: string, content: any) => Promise<void>;
     constructor(ctx: Context, config: ComRegister.Config);
+    splitMultiPlatformStr(str: string): Array<{
+        idArr: Array<string>;
+        platform: string;
+    }>;
     getBot(ctx: Context, pf: string): Bot<Context, any>;
     sendPrivateMsg(content: string): Promise<void>;
     sendPrivateMsgAndRebootService(ctx: Context): Promise<void>;
     sendPrivateMsgAndStopService(ctx: Context): Promise<void>;
-    sendMsg(ctx: Context, targets: Array<string>, content: any, platform: string): Promise<void>;
+    sendMsg(ctx: Context, targets: Target, content: any): Promise<void>;
     dynamicDetect(ctx: Context): () => Promise<void>;
     debug_dynamicDetect(ctx: Context): () => Promise<void>;
-    liveDetect(ctx: Context, roomId: string, guildId: Array<string>, platform: string): () => Promise<void>;
+    liveDetect(ctx: Context, roomId: string, target: Target): () => Promise<void>;
     subShow(): string;
-    checkIfNeedSub(liveSub: boolean, dynamicSub: boolean, session: Session, data?: any): Promise<Array<boolean>>;
+    checkIfNeedSub(liveSub: boolean, dynamicSub: boolean, session: Session, liveRoomData: any): Promise<Array<boolean>>;
     updateSubNotifier(ctx: Context): void;
     checkIfLoginInfoIsLoaded(ctx: Context): Promise<unknown>;
     subUserInBili(ctx: Context, mid: string): Promise<{
@@ -44,7 +54,7 @@ declare class ComRegister {
     }>;
     getSubFromDatabase(ctx: Context): Promise<void>;
     unsubSingle(ctx: Context, id: string, type: number): string;
-    checkIfUserThatIsSubDynAndUnsub(): void;
+    checkIfUserIsTheLastOneWhoSubDyn(): void;
     unsubAll(ctx: Context, uid: string): void;
     checkIfIsLogin(ctx: Context): Promise<boolean>;
 }

package/lib/comRegister.js

@@ -19,6 +19,7 @@ var LiveType;
 })(LiveType || (LiveType = {}));
 class ComRegister {
     static inject = ['ba', 'gi', 'database', 'sm'];
+    qqRelatedBotList = ['qq', 'onebot', 'red', 'satori', 'chronocat'];
     logger;
     config;
     loginTimer;
@@ -105,6 +106,27 @@ class ComRegister {
             this.logger.info(this.subManager);
             return '查看控制台';
         });
+        statusCom
+            .subcommand('.bot', '查询当前拥有的机器人信息', { hidden: true })
+            .usage('查询当前拥有的机器人信息')
+            .example('status bot 查询当前拥有的机器人信息')
+            .action(() => {
+            this.logger.info('开始输出BOT信息');
+            ctx.bots.forEach(bot => {
+                this.logger.info('--------------------------------');
+                this.logger.info('平台：' + bot.platform);
+                this.logger.info('名称：' + bot.user.name);
+                this.logger.info('--------------------------------');
+            });
+        });
+        statusCom
+            .subcommand('.env', '查询当前环境的信息', { hidden: true })
+            .usage('查询当前环境的信息')
+            .example('status env 查询当前环境的信息')
+            .action(async ({ session }) => {
+            await session.send(`Guild ID:${session.event.guild.id}`);
+            await session.send(`Channel ID: ${session.event.channel.id}`);
+        });
         const biliCom = ctx.command('bili', 'bili-notify插件相关指令', { permissions: ['authority:3'] });
         biliCom.subcommand('.login', '登录B站之后才可以进行之后的操作')
             .usage('使用二维码登录，登录B站之后才可以进行之后的操作')
@@ -270,12 +292,13 @@ class ComRegister {
             return subTable;
         });
         biliCom
-            .subcommand('.sub <mid:string> [...guildId:string]', '订阅用户动态和直播通知')
+            .subcommand('.sub <mid:string>', '订阅用户动态和直播通知')
+            .option('multiplatform', '-m <value:string>', { type: /^[A-Za-z0-9]+(?:,[A-Za-z0-9]+)*\.[A-Za-z0-9]+(?:,[A-Za-z0-9]+)*(?:;[A-Za-z0-9]+(?:,[A-Za-z0-9]+)*\.[A-Za-z0-9]+(?:,[A-Za-z0-9]+)*)*$/ })
             .option('live', '-l')
             .option('dynamic', '-d')
             .usage('订阅用户动态和直播通知，若需要订阅直播请加上-l，需要订阅动态则加上-d。若没有加任何参数，之后会向你单独询问，尖括号中为必选参数，中括号为可选参数，目标群号若不填，则默认为当前群聊')
             .example('bili sub 1194210119 目标QQ群号(实验性) -l -d 订阅UID为1194210119的UP主的动态和直播')
-            .action(async ({ session, options }, mid, ...guildId) => {
+            .action(async ({ session, options }, mid) => {
             this.logger.info('调用bili.sub指令');
             // 先判断是否订阅直播，再判断是否解锁订阅限制，最后判断直播订阅是否已超三个
             if (options.live && !this.config.unlockSubLimits && (this.subManager.reduce((acc, cur) => acc + (cur.live ? 1 : 0), 0) >= 3)) {
@@ -294,6 +317,68 @@ class ComRegister {
             // 判断是否订阅对象存在
             if (!subUserData.flag)
                 return '订阅对象失败，请稍后重试！';
+            let target;
+            // 判断是否使用多平台功能
+            if (options.multiplatform) {
+                // 分割字符串，赋值给target
+                target = this.splitMultiPlatformStr(options.multiplatform);
+            }
+            if (target) {
+                target.forEach(async ({ idArr, platform }, index) => {
+                    if (idArr.length > 0) { // 输入了推送群号或频道号
+                        // 拿到对应的bot
+                        const bot = this.getBot(ctx, platform);
+                        // 判断是否配置了对应平台的机器人
+                        if (!ctx.bots.some(bot => bot.platform === platform)) {
+                            await session.send('您未配置对应平台的机器人，不能在该平台进行订阅操作');
+                        }
+                        // 判断是否需要加入的群全部推送
+                        if (idArr[0] !== 'all') {
+                            // 定义满足条件的群组数组
+                            const targetArr = [];
+                            // 获取机器人加入的群组
+                            const guildList = await bot.getGuildList();
+                            // 遍历群组
+                            for (const guild of guildList.data) {
+                                // 获取频道
+                                const channelList = await bot.getChannelList(guild.id);
+                                // 判断群号是否符合条件
+                                for (const id of idArr) {
+                                    // 判断是否机器人加入了该群
+                                    if (channelList.data.some(channel => channel.id === id)) { // 机器人加入了该群
+                                        // 保存到数组
+                                        targetArr.push(id);
+                                        // 继续下一个循环
+                                        continue;
+                                    }
+                                    // 不满足条件发送错误提示
+                                    await session.send(`您的机器未加入${id}，无法对该群或频道进行推送`);
+                                }
+                            }
+                            // 判断targetArr是否为空
+                            if (targetArr.length === 0) {
+                                // 为空则默认为当前环境
+                                target = [{ idArr: [session.event.channel.id], platform: session.event.platform }];
+                                // 没有满足条件的群组或频道
+                                await session.send('没有满足条件的群组或频道，默认订阅到当前聊天环境');
+                            }
+                            // 将符合条件的群组添加到target中
+                            target[index].idArr = targetArr;
+                        }
+                        // 如果为all则全部推送，不需要进行修改
+                    }
+                    else {
+                        // 未填写群号或频道号，默认为当前环境
+                        target = [{ idArr: [session.event.channel.id], platform: session.event.platform }];
+                        // 发送提示消息
+                        await session.send('没有填写群号或频道号，默认订阅到当前聊天环境');
+                    }
+                });
+            }
+            else {
+                // 用户直接订阅，将当前环境赋值给target
+                target = [{ idArr: [session.event.channel.id], platform: session.event.platform }];
+            }
             // 定义外围变量                
             let content;
             try {
@@ -329,90 +414,14 @@ class ComRegister {
                 // 返回错误信息
                 return msg;
             }
-            // 定义目标群组id
-            let targetId;
-            // 定义目标群组id数组
-            let targetIdArr;
-            // 判断是否输入了QQ群号
-            if (guildId.length > 0) { // 输入了QQ群号
-                // 定义方法
-                const checkIfGuildHasJoined = async (bot) => {
-                    // 获取机器人加入的群组
-                    const guildList = await bot.getGuildList();
-                    // 定义满足条件的群组数组
-                    const targetArr = [];
-                    // 判断群号是否符合条件
-                    for (const guild of guildId) {
-                        // 判断是否机器人加入了该群
-                        if (guildList.data.some(cv => cv.id === guild)) { // 机器人加入了该群
-                            // 保存到数组
-                            targetArr.push(guild);
-                            // 继续下一个循环
-                            continue;
-                        }
-                        // 不满足条件发送错误提示
-                        session.send(`您的机器未加入${guild}，无法对该群进行推送`);
-                    }
-                    // 返回数组
-                    return targetArr;
-                };
-                // 定义可用的群组数组
-                let okGuild = [];
-                // 判断是否需要加入的群全部推送
-                if (guildId[0] === 'all') {
-                    // 判断是否有群机器人相关Bot
-                    if (['qq', 'onebot', 'red', 'satori', 'chronocat'].includes(session.event.platform)) {
-                        // 推送所有群组
-                        okGuild.push('all');
-                    }
-                    else {
-                        // 发送错误提示并返回
-                        session.send('您尚未配置任何QQ群相关机器人，不能对QQ群进行操作');
-                        // 直接返回
-                        return;
-                    }
-                }
-                else {
-                    // 判断是否有群机器人相关Bot
-                    switch (session.event.platform) {
-                        case 'qq':
-                        case 'onebot':
-                        case 'red':
-                        case 'satori':
-                        case 'chronocat': {
-                            // 获取该会话机器人
-                            const bot = this.getBot(ctx, session.event.platform);
-                            // 检查机器人是否加入该群
-                            okGuild = await checkIfGuildHasJoined(bot);
-                            break;
-                        }
-                        default: {
-                            // 发送错误提示并返回
-                            session.send('您尚未配置任何QQ群相关机器人，不能对QQ群进行操作');
-                            // 直接返回
-                            return;
-                        }
-                    }
-                }
-                // 将可用的目标赋值给数组
-                targetIdArr = okGuild;
-                // 将群号用空格进行分割
-                targetId = okGuild.join(' ');
-            }
-            else { // 没有输入QQ群号
-                // 为当前群聊环境进行推送
-                targetId = session.event.channel.id;
-                // 将目标id转换为数组进行赋值
-                targetIdArr = [session.event.channel.id];
-            }
             // 获取data
             const { data } = content;
             // 判断是否需要订阅直播和动态
-            const [liveMsg, dynamicMsg] = await this.checkIfNeedSub(options.live, options.dynamic, session, data);
+            const [liveMsg, dynamicMsg] = await this.checkIfNeedSub(options.live, options.dynamic, session, data.live_room);
             // 判断是否未订阅任何消息
-            if (!liveMsg && !dynamicMsg) {
+            if (!liveMsg && !dynamicMsg)
                 return '您未订阅该UP的任何消息';
-            }
+            // 获取到对应的订阅对象
             const subUser = this.subManager.find(sub => sub.uid === mid);
             // 判断要订阅的用户是否已经存在于订阅管理对象中
             if (subUser) {
@@ -427,43 +436,22 @@ class ComRegister {
             }
             // 获取直播房间号
             const roomId = data.live_room?.roomid.toString();
-            // 保存到数据库中
-            const sub = await ctx.database.create('bilibili', {
-                uid: mid,
-                room_id: roomId,
-                dynamic: dynamicMsg ? 1 : 0,
-                video: 1,
-                live: liveMsg ? 1 : 0,
-                targetId,
-                platform: session.event.platform,
-                time: new Date()
-            });
-            // 订阅数+1
-            this.num++;
-            // 保存新订阅对象
-            this.subManager.push({
-                id: sub.id,
-                uid: mid,
-                targetIdArr,
-                roomId,
-                platform: session.event.platform,
-                live: liveMsg,
-                dynamic: dynamicMsg,
-                liveDispose: null
-            });
             // 获取用户信息
             let userData;
             try {
-                const { data } = await ctx.ba.getMasterInfo(sub.uid);
+                const { data } = await ctx.ba.getMasterInfo(mid);
                 userData = data;
             }
             catch (e) {
                 this.logger.error('bili sub指令 getMasterInfo() 发生了错误，错误为：' + e.message);
                 return '订阅出错啦，请重试';
             }
+            // 定义live销毁函数
+            let liveDispose;
             // 订阅直播
             if (liveMsg) {
-                await session.execute(`bili live ${roomId} ${targetId.split(',').join(' ')}`);
+                // 开始循环检测
+                liveDispose = ctx.setInterval(this.liveDetect(ctx, roomId, target), config.liveLoopTime * 1000);
                 // 发送订阅消息通知
                 await session.send(`订阅${userData.info.uname}直播通知`);
             }
@@ -482,29 +470,50 @@ class ComRegister {
                 // 发送订阅消息通知
                 await session.send(`订阅${userData.info.uname}动态通知`);
             }
+            // 保存到数据库中
+            const sub = await ctx.database.create('bilibili', {
+                uid: mid,
+                room_id: roomId,
+                dynamic: dynamicMsg ? 1 : 0,
+                video: 1,
+                live: liveMsg ? 1 : 0,
+                target: JSON.stringify(target),
+                platform: session.event.platform,
+                time: new Date()
+            });
+            // 订阅数+1
+            this.num++;
+            // 保存新订阅对象
+            this.subManager.push({
+                id: sub.id,
+                uid: mid,
+                roomId,
+                target,
+                platform: session.event.platform,
+                live: liveMsg,
+                dynamic: dynamicMsg,
+                liveDispose
+            });
             // 新增订阅展示到控制台
             this.updateSubNotifier(ctx);
         });
-        biliCom
+        /* biliCom
             .subcommand('.live <roomId:string> <...guildId:string>', '订阅主播开播通知', { hidden: true })
             .usage('订阅主播开播通知')
             .example('bili live 26316137 订阅房间号为26316137的直播间')
             .action(async (_, roomId, ...guildId) => {
-            this.logger.info('调用bili.live指令');
-            // 如果room_id为空则返回
-            if (!roomId)
-                return `${roomId}非法调用 dynamic 指令`; // 订阅主播房间号不能为空
-            if (!guildId)
-                return `${roomId}非法调用 dynamic 指令`; // 目标群组或频道不能为空
-            // 要订阅的对象不在订阅管理对象中，直接返回
-            const index = this.subManager.findIndex(sub => sub.roomId === roomId);
-            if (index === -1)
-                return '请勿直接调用该指令';
-            // 开始循环检测
-            const dispose = ctx.setInterval(this.liveDetect(ctx, roomId, guildId, this.subManager[index].platform), config.liveLoopTime * 1000);
-            // 保存销毁函数
-            this.subManager[index].liveDispose = dispose;
-        });
+                this.logger.info('调用bili.live指令')
+                // 如果room_id为空则返回
+                if (!roomId) return `${roomId}非法调用 dynamic 指令` // 订阅主播房间号不能为空
+                if (!guildId) return `${roomId}非法调用 dynamic 指令` // 目标群组或频道不能为空
+                // 要订阅的对象不在订阅管理对象中，直接返回
+                const index = this.subManager.findIndex(sub => sub.roomId === roomId)
+                if (index === -1) return '请勿直接调用该指令'
+                // 开始循环检测
+                const dispose = ctx.setInterval(this.liveDetect(ctx, roomId, guildId, this.subManager[index].platform), config.liveLoopTime * 1000)
+                // 保存销毁函数
+                this.subManager[index].liveDispose = dispose
+            }) */
         biliCom
             .subcommand('.status <roomId:string>', '查询主播当前直播状态', { hidden: true })
             .usage('查询主播当前直播状态')
@@ -548,19 +557,6 @@ class ComRegister {
             // pic不存在，说明使用的是page模式
             await session.send(koishi_1.h.image(buffer, 'image/png'));
         });
-        biliCom
-            .subcommand('.bot', '查询当前拥有的机器人信息', { hidden: true })
-            .usage('查询当前拥有的机器人信息')
-            .example('bili bot 查询当前拥有的机器人信息')
-            .action(() => {
-            this.logger.info('开始输出BOT信息');
-            ctx.bots.forEach(bot => {
-                this.logger.info('--------------------------------');
-                this.logger.info('平台：' + bot.platform);
-                this.logger.info('名称：' + bot.user.name);
-                this.logger.info('--------------------------------');
-            });
-        });
         biliCom
             .subcommand('.private', '向主人账号发送一条测试消息', { hidden: true })
             .usage('向主人账号发送一条测试消息')
@@ -572,6 +568,12 @@ class ComRegister {
             await session.send('已发送消息，如未收到则说明您的机器人不支持发送私聊消息或您的信息填写有误');
         });
     }
+    splitMultiPlatformStr(str) {
+        return str.split(';').map(cv => cv.split('.')).map(([idStr, platform]) => {
+            const idArr = idStr.split(',');
+            return { idArr, platform };
+        });
+    }
     getBot(ctx, pf) {
         return ctx.bots.find(bot => bot.platform === pf);
     }
@@ -628,24 +630,26 @@ class ComRegister {
         // 结束
         return;
     }
-    async sendMsg(ctx, targets, content, platform) {
-        // 获取机器人实例
-        const bot = this.getBot(ctx, platform);
-        // 定义需要发送的数组
-        let sendArr = [];
-        // 判断是否需要推送所有机器人加入的群
-        if (targets[0] === 'all') {
-            // 获取所有guild
-            for (const guild of (await bot.getGuildList()).data) {
-                sendArr.push(guild.id);
+    async sendMsg(ctx, targets, content) {
+        for (const target of targets) {
+            // 获取机器人实例
+            const bot = this.getBot(ctx, target.platform);
+            // 定义需要发送的数组
+            let sendArr = [];
+            // 判断是否需要推送所有机器人加入的群
+            if (target.idArr[0] === 'all') {
+                // 获取所有guild
+                for (const guild of (await bot.getGuildList()).data) {
+                    sendArr.push(guild.id);
+                }
+            }
+            else {
+                sendArr = target.idArr;
+            }
+            // 循环给每个群组发送
+            for (const guild of sendArr) {
+                await this.sendMsgFunc(bot, guild, content);
             }
-        }
-        else {
-            sendArr = targets;
-        }
-        // 循环给每个群组发送
-        for (const guild of sendArr) {
-            await this.sendMsgFunc(bot, guild, content);
         }
     }
     dynamicDetect(ctx) {
@@ -775,13 +779,13 @@ class ComRegister {
                                     if (e.message === '出现关键词，屏蔽该动态') {
                                         // 如果需要发送才发送
                                         if (this.config.filter.notify) {
-                                            await this.sendMsg(ctx, sub.targetIdArr, `${upName}发布了一条含有屏蔽关键字的动态`, sub.platform);
+                                            await this.sendMsg(ctx, sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
                                         }
                                         return;
                                     }
                                     if (e.message === '已屏蔽转发动态') {
                                         if (this.config.filter.notify) {
-                                            await this.sendMsg(ctx, sub.targetIdArr, `${upName}发布了一条转发动态，已屏蔽`, sub.platform);
+                                            await this.sendMsg(ctx, sub.target, `${upName}发布了一条转发动态，已屏蔽`);
                                         }
                                         return;
                                     }
@@ -799,12 +803,12 @@ class ComRegister {
                             if (pic) {
                                 this.logger.info('推送动态中，使用render模式');
                                 // pic存在，使用的是render模式
-                                await this.sendMsg(ctx, sub.targetIdArr, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }), sub.platform);
+                                await this.sendMsg(ctx, sub.target, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
                             }
                             else if (buffer) {
                                 this.logger.info('推送动态中，使用page模式');
                                 // pic不存在，说明使用的是page模式
-                                await this.sendMsg(ctx, sub.targetIdArr, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), dUrl] }), sub.platform);
+                                await this.sendMsg(ctx, 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 + '发布了一条动态，但是推送失败');
@@ -959,13 +963,13 @@ class ComRegister {
                                     if (e.message === '出现关键词，屏蔽该动态') {
                                         // 如果需要发送才发送
                                         if (this.config.filter.notify) {
-                                            await this.sendMsg(ctx, sub.targetIdArr, `${upName}发布了一条含有屏蔽关键字的动态`, sub.platform);
+                                            await this.sendMsg(ctx, sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
                                         }
                                         return;
                                     }
                                     if (e.message === '已屏蔽转发动态') {
                                         if (this.config.filter.notify) {
-                                            await this.sendMsg(ctx, sub.targetIdArr, `${upName}发布了一条转发动态，已屏蔽`, sub.platform);
+                                            await this.sendMsg(ctx, sub.target, `${upName}发布了一条转发动态，已屏蔽`);
                                         }
                                         return;
                                     }
@@ -983,12 +987,12 @@ class ComRegister {
                             if (pic) {
                                 this.logger.info('推送动态中，使用render模式');
                                 // pic存在，使用的是render模式
-                                await this.sendMsg(ctx, sub.targetIdArr, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }), sub.platform);
+                                await this.sendMsg(ctx, sub.target, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
                             }
                             else if (buffer) {
                                 this.logger.info('推送动态中，使用page模式');
                                 // pic不存在，说明使用的是page模式
-                                await this.sendMsg(ctx, sub.targetIdArr, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), dUrl] }), sub.platform);
+                                await this.sendMsg(ctx, 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 + '发布了一条动态，但是推送失败');
@@ -1002,7 +1006,7 @@ class ComRegister {
             }
         };
     }
-    liveDetect(ctx, roomId, guildId, platform) {
+    liveDetect(ctx, roomId, target) {
         let firstSubscription = true;
         let timer = 0;
         let open = false;
@@ -1012,7 +1016,7 @@ class ComRegister {
         // 相当于锁的作用，防止上一个循环没处理完
         let flag = true;
         // 定义发送直播通知卡片方法
-        const sendLiveNotifyCard = async (data, liveType, liveStartMsg, atAll) => {
+        const sendLiveNotifyCard = async (data, liveType, liveNotifyMsg, atAll) => {
             // 定义变量
             let pic;
             let buffer;
@@ -1039,12 +1043,12 @@ 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(ctx, guildId, pic + msg, platform);
+                const msg = (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [atAll && (0, jsx_runtime_1.jsx)("at", { type: "all" }), liveNotifyMsg && liveNotifyMsg] });
+                return await this.sendMsg(ctx, target, 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(ctx, guildId, msg, platform);
+            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" }), liveNotifyMsg && liveNotifyMsg] });
+            await this.sendMsg(ctx, target, pic + msg);
         };
         // 定义获取主播信息方法
         let useMasterInfo;
@@ -1188,10 +1192,10 @@ class ComRegister {
                                     // 到时间重新计时
                                     timer = 0;
                                     // 定义直播中通知消息
-                                    const liveMsg = this.config.customLive
+                                    const liveMsg = this.config.customLive ? this.config.customLive
                                         .replace('-name', username)
                                         .replace('-time', await ctx.gi.getTimeDifference(liveTime))
-                                        .replace('-link', `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`);
+                                        .replace('-link', `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`) : '';
                                     // 发送直播通知卡片
                                     sendLiveNotifyCard(data, LiveType.LiveBroadcast, liveMsg);
                                 }
@@ -1215,10 +1219,10 @@ class ComRegister {
         });
         return table ? table : '没有订阅任何UP';
     }
-    async checkIfNeedSub(liveSub, dynamicSub, session, data) {
+    async checkIfNeedSub(liveSub, dynamicSub, session, liveRoomData) {
         // 定义方法：用户直播间是否存在
         const liveRoom = async () => {
-            if (!data.live_room) {
+            if (!liveRoomData) {
                 // 未开通直播间
                 await session.send('该用户未开通直播间，无法订阅直播');
                 // 返回false
@@ -1411,7 +1415,7 @@ class ComRegister {
                 continue;
             }
             // 获取推送目标数组
-            const targetIdArr = sub.targetId.split(' ');
+            const target = JSON.parse(sub.target);
             /* 判断数据库是否被篡改 */
             // 获取用户信息
             let content;
@@ -1475,7 +1479,7 @@ class ComRegister {
                 id: sub.id,
                 uid: sub.uid,
                 roomId: sub.room_id,
-                targetIdArr,
+                target,
                 platform: sub.platform,
                 live: +sub.live === 1 ? true : false,
                 dynamic: +sub.dynamic === 1 ? true : false,
@@ -1495,7 +1499,7 @@ class ComRegister {
                     // 直播订阅数+1
                     liveSubNum++;
                     // 订阅直播，开始循环检测
-                    const dispose = ctx.setInterval(this.liveDetect(ctx, sub.room_id, targetIdArr, sub.platform), this.config.liveLoopTime * 1000);
+                    const dispose = ctx.setInterval(this.liveDetect(ctx, sub.room_id, target), this.config.liveLoopTime * 1000);
                     // 保存销毁函数
                     subManagerItem.liveDispose = dispose;
                 }
@@ -1530,7 +1534,7 @@ class ComRegister {
             // num--
             this.num--;
             // 判断是否还存在订阅了动态的对象，不存在则停止动态监测
-            this.checkIfUserThatIsSubDynAndUnsub();
+            this.checkIfUserIsTheLastOneWhoSubDyn();
         };
         try {
             switch (type) {
@@ -1575,7 +1579,7 @@ class ComRegister {
                     // 取消订阅
                     this.subManager[index].dynamic = false;
                     // 判断是否还存在订阅了动态的对象，不存在则停止动态监测
-                    this.checkIfUserThatIsSubDynAndUnsub();
+                    this.checkIfUserIsTheLastOneWhoSubDyn();
                     // 如果没有对这个UP的任何订阅，则移除
                     if (checkIfNoSubExist(sub)) {
                         // 从管理对象中移除
@@ -1596,7 +1600,7 @@ class ComRegister {
             this.updateSubNotifier(ctx);
         }
     }
-    checkIfUserThatIsSubDynAndUnsub() {
+    checkIfUserIsTheLastOneWhoSubDyn() {
         if (this.subManager.some(sub => sub.dynamic)) {
             // 停止动态监测
             this.dynamicDispose();
@@ -1609,7 +1613,7 @@ class ComRegister {
             if (sub.live)
                 await this.subManager[i].liveDispose();
             // 判断是否还存在订阅了动态的对象，不存在则停止动态监测
-            this.checkIfUserThatIsSubDynAndUnsub();
+            this.checkIfUserIsTheLastOneWhoSubDyn();
             // 从数据库中删除订阅
             await ctx.database.remove('bilibili', { uid: this.subManager[i].uid });
             // 将该订阅对象从订阅管理对象中移除

package/lib/database.d.ts

@@ -12,7 +12,7 @@ export interface Bilibili {
     dynamic: number;
     video: number;
     live: number;
-    targetId: string;
+    target: string;
     platform: string;
     time: Date;
 }

package/lib/database.js

@@ -12,7 +12,7 @@ function apply(ctx) {
         dynamic: 'unsigned',
         video: 'unsigned',
         live: 'unsigned',
-        targetId: 'string',
+        target: 'string',
         platform: 'string',
         time: 'timestamp'
     }, { autoInc: true });

package/package.json

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