koishi-plugin-bilibili-notify 0.1.0 → 0.1.2

package/lib/comRegister.d.ts

@@ -1,30 +1,26 @@
-import { Context, Logger, Schema, Session } from "koishi";
+import { Bot, Context, Logger, Schema, Session } from "koishi";
 declare class ComRegister {
     static inject: string[];
     logger: Logger;
     config: ComRegister.Config;
-    id: number;
-    sub: {
-        id: number;
-        uid: string;
-        room_id: string;
-        dynamic: number;
-        video: 1;
-        live: number;
-        time: Date;
-    };
+    num: number;
     subManager: {
+        id: number;
         uid: string;
         roomId: string;
+        targetId: string;
         live: boolean;
         dynamic: boolean;
         liveDispose: Function;
         dynamicDispose: Function;
     }[];
+    qqBot: Bot<Context>;
+    qqguildBot: Bot<Context>;
     constructor(ctx: Context, config: ComRegister.Config);
-    dynamicDetect(ctx: Context, session: Session, uid: string): () => Promise<"账号未登录" | "未知错误">;
-    liveDetect(ctx: Context, session: Session, roomId: string): () => Promise<void>;
+    dynamicDetect(ctx: Context, bot: Bot<Context>, groupId: string, uid: string): () => Promise<"账号未登录" | "未知错误">;
+    liveDetect(ctx: Context, bot: Bot<Context>, groupId: string, roomId: string): () => Promise<void>;
     checkIfNeedSub(comNeed: boolean, subType: string, session: Session, data?: any): Promise<boolean>;
+    getSubFromDatabase(ctx: Context): Promise<void>;
 }
 declare namespace ComRegister {
     interface Config {

package/lib/comRegister.js

@@ -16,12 +16,20 @@ class ComRegister {
     static inject = ['biliAPI', 'gimg', 'wbi', 'database'];
     logger;
     config;
-    id = 1;
-    sub;
+    num = 0;
     subManager = [];
+    // QQ群机器人
+    qqBot;
+    // QQ频道机器人
+    qqguildBot;
     constructor(ctx, config) {
         this.logger = ctx.logger('commandRegister');
         this.config = config;
+        // 拿到QQ群机器人
+        this.qqBot = ctx.bots[ctx.bots.findIndex(bot => bot.platform === 'qq')];
+        // 拿到QQ频道机器人
+        this.qqguildBot = ctx.bots[ctx.bots.findIndex(bot => bot.platform === 'qqguild')];
+        this.getSubFromDatabase(ctx);
         ctx.command('test')
             .subcommand('.cookies')
             .usage('测试指令，用于测试从数据库读取cookies')
@@ -77,6 +85,20 @@ class ComRegister {
             .action(() => {
             console.log(this.subManager);
         });
+        ctx.command('test')
+            .subcommand('.group')
+            .usage('查看session groupId')
+            .example('test group')
+            .action(({ session }) => {
+            console.log(session.event.channel);
+        });
+        ctx.command('test')
+            .subcommand('.session')
+            .usage('查看seesion')
+            .example('test session')
+            .action(({ session }) => {
+            console.log(session);
+        });
         ctx.command('bili', 'bili-notify插件相关指令')
             .subcommand('.login', '登录B站之后才可以进行之后的操作')
             .usage('使用二维码登录，登录B站之后才可以进行之后的操作')
@@ -132,23 +154,66 @@ class ComRegister {
             }, 1000);
         });
         ctx.command('bili')
-            .subcommand('.sub <mid:string> [groupid:string]')
+            .subcommand('.unsub <uid:string>')
+            .usage('取消订阅')
+            .example('bili unsub 用户UID')
+            .action(async ({ session }, uid) => {
+            this.logger.info('调用bili.unsub指令');
+            // 若用户UID为空则直接返回
+            if (!uid)
+                return '用户UID不能为空';
+            // 定义是否存在
+            let exist;
+            await Promise.all(this.subManager.map(async (sub, i) => {
+                if (sub.uid === uid) {
+                    // 执行dispose方法，销毁定时器
+                    this.subManager[i].dynamicDispose();
+                    this.subManager[i].liveDispose();
+                    // 从数据库中删除订阅
+                    await ctx.database.remove('bilibili', { uid: this.subManager[i].uid });
+                    // 将该订阅对象从订阅管理对象中移除
+                    this.subManager = this.subManager.splice(i, i);
+                    // id--
+                    this.num--;
+                    // 发送成功通知
+                    session.send('已取消订阅该用户');
+                    // 将存在flag设置为true
+                    exist = true;
+                }
+            }));
+            // 未订阅该用户，无需取消订阅
+            !exist && session.send('未订阅该用户，无需取消订阅');
+        });
+        ctx.command('bili')
+            .subcommand('.show')
+            .usage('展示订阅对象')
+            .example('bili show')
+            .action(async ({ session }) => {
+            let table = ``;
+            this.subManager.forEach(sub => {
+                table += 'UID:' + sub.uid + '  RoomID:' + sub.roomId + '\n';
+            });
+            !table && session.send('没有订阅任何UP');
+            table && session.send(table);
+        });
+        ctx.command('bili')
+            .subcommand('.sub <mid:string> [guildId:string]')
             .option('live', '-l')
             .option('dynamic', '-d')
             .usage('订阅用户动态和直播通知，若需要订阅直播请加上-l，需要订阅动态则加上-d。若没有加任何参数，之后会向你单独询问，<>中为必选参数，[]中为可选参数，目标群号若不填，则默认为当前群聊')
             .example('bili sub 用户uid 目标QQ群号(暂不支持) -l -d')
-            .action(async ({ session, options }, mid, groupid) => {
+            .action(async ({ session, options }, mid, guildId) => {
             this.logger.info('调用bili.sub指令');
+            // 如果订阅人数超过三个则直接返回
+            if (this.num >= 3)
+                return '目前最多只能订阅三个人';
             // 检查必选参数是否有值
-            if (mid === undefined) {
+            if (!mid)
                 return '请输入用户uid';
-            }
             // 判断要订阅的用户是否已经存在于订阅管理对象中
-            this.subManager && this.subManager.forEach((sub) => {
-                // 已订阅该用户
-                if (sub.uid === mid)
-                    return session.send('已订阅该用户，请勿重复订阅');
-            });
+            if (this.subManager && this.subManager.some(sub => sub.uid === mid)) {
+                return '已订阅该用户，请勿重复订阅';
+            }
             // 定义是否需要直播通知，动态订阅，视频推送
             let liveMsg, dynamicMsg;
             // 获取用户信息
@@ -179,99 +244,142 @@ class ComRegister {
             liveMsg = await this.checkIfNeedSub(options.live, '直播', session, data);
             // 判断是否需要订阅动态
             dynamicMsg = await this.checkIfNeedSub(options.dynamic, '动态', session);
-            // 构造订阅对象
-            this.sub = {
-                id: this.id,
+            // 判断是哪个平台
+            let platform;
+            if (!guildId) { // 没有输入群号，默认当前聊天环境
+                switch (session.event.platform) {
+                    case 'qqguild':
+                        guildId = session.event.channel.id;
+                        break;
+                    case 'qq':
+                        guildId = session.event.guild.id;
+                        break;
+                    default: return '暂不支持该平台';
+                }
+            }
+            // 定义Bot
+            let bot;
+            // 判断是哪个聊天平台
+            switch (session.event.platform) {
+                case 'qqguild': {
+                    bot = this.qqguildBot;
+                    platform = 'qqguild';
+                    break;
+                }
+                case 'qq': {
+                    bot = this.qqBot;
+                    platform = 'qq';
+                    break;
+                }
+                default: return '暂不支持该平台';
+            }
+            // 保存到数据库中
+            const sub = await ctx.database.create('bilibili', {
                 uid: mid,
                 room_id: data.live_room.roomid.toString(),
                 dynamic: dynamicMsg ? 1 : 0,
                 video: 1,
                 live: liveMsg ? 1 : 0,
+                targetId: guildId,
+                platform,
                 time: new Date()
-            };
-            // 保存到数据库中
-            await ctx.database.upsert('bilibili', [this.sub]);
-            // 让id自增
-            this.id++;
+            });
+            // 订阅数+1
+            this.num++;
             // 开始订阅
             // 保存新订阅对象
             this.subManager.push({
+                id: sub.id,
                 uid: mid,
+                targetId: guildId,
                 roomId: data.live_room.roomid.toString(),
                 live: liveMsg,
                 dynamic: dynamicMsg,
                 liveDispose: null,
                 dynamicDispose: null
             });
+            // 获取用户信息
+            const { data: userData } = await ctx.biliAPI.getMasterInfo(sub.uid);
             // 需要订阅直播
-            if (liveMsg)
-                await session.execute(`bili live ${data.live_room.roomid}`);
+            if (liveMsg) {
+                await session.execute(`bili live ${data.live_room.roomid} ${guildId} -b ${platform}`);
+                // 发送订阅消息通知
+                await bot.sendMessage(sub.targetId, `订阅${userData.info.uname}直播通知`);
+            }
             // 需要订阅动态
-            if (dynamicMsg)
-                await session.execute(`bili dynamic ${mid}`);
-            // 发送订阅成功通知
+            if (dynamicMsg) {
+                await session.execute(`bili dynamic ${mid} ${guildId} -b ${platform}`);
+                // 发送订阅消息通知
+                await bot.sendMessage(sub.targetId, `订阅${userData.info.uname}动态通知`);
+            }
         });
         ctx.command('bili')
             .subcommand('.dynamic <uid:string>')
+            .option('bot', '-b <type:string>')
             .usage('订阅用户动态推送')
             .example('bili dynamic 1')
-            .action(async ({ session }, uid) => {
+            .action(async ({ session, options }, uid, guildId) => {
             this.logger.info('调用bili.dynamic指令');
             // 如果uid为空则返回
-            if (!uid) {
-                await session.send('用户uid不能为空');
-                return;
-            }
-            // 定义订阅对象索引
-            let index;
-            // 定义要订阅的对象是否存在于订阅管理对象中
-            let exist;
+            if (!uid)
+                return '用户uid不能为空';
+            if (!options.bot)
+                return '非法调用';
             // 保存到订阅管理对象
-            this.subManager.forEach((sub, i) => {
-                if (sub.uid === uid) {
-                    exist = true;
-                    index = i;
-                }
-            });
+            const index = this.subManager.findIndex(sub => sub.uid === uid);
             // 不存在则直接返回
-            if (!exist) {
+            if (index === -1) {
                 session.send('请勿直接调用该指令');
                 return;
             }
+            // 获取对应Bot
+            let bot;
+            switch (options.bot) {
+                case 'qq':
+                    bot = this.qqBot;
+                    break;
+                case 'qqguild':
+                    bot = this.qqguildBot;
+                    break;
+                default: return '非法调用';
+            }
             // 开始循环检测
-            const dispose = ctx.setInterval(this.dynamicDetect(ctx, session, uid), 60000);
+            const dispose = ctx.setInterval(this.dynamicDetect(ctx, bot, guildId, uid), 60000);
             // 将销毁函数保存到订阅管理对象
             this.subManager[index].dynamicDispose = dispose;
         });
         ctx.command('bili')
-            .subcommand('.live <roomId:string>')
+            .subcommand('.live <roomId:string> <guildId:string>')
+            .option('bot', '-b <type:string>')
             .usage('订阅主播开播通知')
             .example('bili live 732')
-            .action(async ({ session }, roomId) => {
+            .action(async ({ session, options }, roomId, guildId) => {
             this.logger.info('调用bili.live指令');
             // 如果room_id为空则返回
-            if (!roomId) {
-                await session.send('订阅主播房间号不能为空');
-                return;
-            }
-            // 定义订阅对象索引
-            let index;
-            // 定义要订阅的对象是否存在于订阅管理对象中
-            let exist;
+            if (!roomId)
+                return '订阅主播房间号不能为空';
+            if (!guildId)
+                return '目标群组或频道不能为空';
+            if (!options.bot)
+                return '非法调用';
             // 保存到订阅管理对象
-            this.subManager.forEach((sub, i) => {
-                if (sub.roomId === roomId) {
-                    exist = true;
-                    index = i;
-                }
-            });
+            const index = this.subManager.findIndex(sub => sub.roomId === roomId);
             // 要订阅的对象不在订阅管理对象中，直接返回
-            if (!exist) {
-                await session.send('请勿直接调用该指令');
-                return;
+            if (index === -1)
+                return '请勿直接调用该指令';
+            // 获取对应Bot
+            let bot;
+            switch (options.bot) {
+                case 'qq':
+                    bot = this.qqBot;
+                    break;
+                case 'qqguild':
+                    bot = this.qqguildBot;
+                    break;
+                default: return '非法调用';
             }
             // 开始循环检测
-            const dispose = ctx.setInterval(this.liveDetect(ctx, session, roomId), 5000);
+            const dispose = ctx.setInterval(this.liveDetect(ctx, bot, guildId, roomId), 5000);
             // 保存销毁函数
             this.subManager[index].liveDispose = dispose;
         });
@@ -303,16 +411,12 @@ class ComRegister {
             session.send(string);
         });
     }
-    dynamicDetect(ctx, session, uid) {
+    dynamicDetect(ctx, bot, groupId, uid) {
         let firstSubscription = true;
         let timePoint;
         return async () => {
-            // 第一次的判断
+            // 第一次订阅判断
             if (firstSubscription) {
-                // 获取用户信息
-                const { data: userData } = await ctx.biliAPI.getMasterInfo(uid);
-                // 发送订阅消息通知
-                session.send(`订阅${userData.info.uname}动态通知!`);
                 // 设置第一次的时间点
                 timePoint = Date.now();
                 // 设置第一次为false
@@ -354,33 +458,28 @@ class ComRegister {
                     }
                     // 推送该条动态
                     const [pic] = await ctx.gimg.generateDynamicImg(items[num]);
-                    session.send(pic);
+                    await bot.sendMessage(groupId, pic);
                 }
             }
         };
     }
-    liveDetect(ctx, session, roomId) {
+    liveDetect(ctx, bot, groupId, roomId) {
         let firstSubscription = true;
         let timer = 0;
         let open = false;
         let liveTime;
         let uData;
         return async () => {
-            // Test code
-            /* console.log('===========================>');
-            console.log(timer);
-            console.log(open);
-            console.log('===========================>'); */
             // 发送请求检测直播状态
             const content = await ctx.biliAPI.getLiveRoomInfo(roomId);
             const { data } = content;
             // B站出问题了
             if (content.code !== 0) {
                 if (content.msg === '未找到该房间') {
-                    session.send('未找到该房间！');
+                    await bot.sendMessage(groupId, '未找到该房间！');
                 }
                 else {
-                    session.send('未知错误，请呼叫管理员检查问题！');
+                    await bot.sendMessage(groupId, '未知错误，请呼叫管理员检查问题！');
                 }
                 // dispose
                 return;
@@ -391,15 +490,14 @@ class ComRegister {
                 const { data: userData } = await ctx.biliAPI.getMasterInfo(data.uid);
                 // 主播信息不会变，请求一次即可
                 uData = userData;
-                // 发送订阅消息通知
-                session.send(`订阅${userData.info.uname}直播通知`);
+                // 判断直播状态
                 if (data.live_status === 1) { // 当前正在直播
-                    // 改变开播状态
-                    open = true;
                     // 推送直播信息
-                    await session.send(await ctx
+                    await bot.sendMessage(groupId, await ctx
                         .gimg
                         .generateLiveImg(data, uData, LiveType.LiveBroadcast));
+                    // 改变开播状态
+                    open = true;
                 } // 未开播，直接返回
                 return;
             }
@@ -413,7 +511,7 @@ class ComRegister {
                         // 下播了将定时器清零
                         timer = 0;
                         // 发送下播通知
-                        session.send(`${uData.info.uname}下播啦，本次直播了${ctx.gimg.getTimeDifference(liveTime)}`);
+                        bot.sendMessage(groupId, `${uData.info.uname}下播啦，本次直播了${ctx.gimg.getTimeDifference(liveTime)}`);
                     }
                     // 未进循环，还未开播，继续循环
                     break;
@@ -429,7 +527,7 @@ class ComRegister {
                         // 主播信息不会变，开播时刷新一次即可
                         uData = userData;
                         // 发送直播通知
-                        await session.send(await ctx.gimg.generateLiveImg(data, uData, LiveType.StartBroadcasting));
+                        await bot.sendMessage(groupId, await ctx.gimg.generateLiveImg(data, uData, LiveType.StartBroadcasting));
                     }
                     else { // 还在直播
                         if (this.config.pushTime > 0) {
@@ -439,7 +537,7 @@ class ComRegister {
                                 // 到时间重新计时
                                 timer = 0;
                                 // 发送状态信息
-                                session.send(await ctx
+                                bot.sendMessage(groupId, await ctx
                                     .gimg
                                     .generateLiveImg(data, uData, LiveType.LiveBroadcast));
                             }
@@ -484,6 +582,54 @@ class ComRegister {
             }
         }
     }
+    async getSubFromDatabase(ctx) {
+        // 从数据库中获取数据
+        const subData = await ctx.database.get('bilibili', { id: { $gt: 0 } });
+        // 设定订阅数量
+        this.num = subData.length;
+        // 如果订阅数量超过三个则被非法修改数据库
+        // 向管理员发送重新订阅通知
+        if (this.num > 3)
+            return;
+        // 定义Bot
+        let bot;
+        // 循环遍历
+        subData.forEach(sub => {
+            // 拿到对应bot
+            switch (sub.platform) {
+                case 'qq': bot = this.qqBot;
+                case 'qqguild': bot = this.qqguildBot;
+            }
+            // 构建订阅对象
+            let subManagerItem = {
+                id: sub.id,
+                uid: sub.uid,
+                roomId: sub.room_id,
+                targetId: sub.targetId,
+                live: +sub.live === 1 ? true : false,
+                dynamic: +sub.dynamic === 1 ? true : false,
+                liveDispose: null,
+                dynamicDispose: null
+            };
+            // 判断需要订阅的服务
+            if (sub.dynamic) { // 需要订阅动态
+                // 开始循环检测
+                const dispose = ctx.setInterval(this.dynamicDetect(ctx, bot, sub.targetId, sub.uid), 60000);
+                // 保存销毁函数
+                subManagerItem.dynamicDispose = dispose;
+            }
+            if (sub.live) { // 需要订阅动态
+                // 开始循环检测
+                const dispose = ctx.setInterval(this.liveDetect(ctx, bot, sub.targetId, sub.room_id), 5000);
+                // 保存销毁函数
+                subManagerItem.liveDispose = dispose;
+            }
+            // 保存新订阅对象
+            this.subManager.push(subManagerItem);
+            // 发送订阅成功通知
+            bot.sendMessage(sub.targetId, '重新加载测试发送');
+        });
+    }
 }
 (function (ComRegister) {
     ComRegister.Config = koishi_1.Schema.object({

package/lib/database.d.ts

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

package/lib/database.js

@@ -17,7 +17,9 @@ function apply(ctx) {
         dynamic: 'unsigned',
         video: 'unsigned',
         live: 'unsigned',
+        targetId: 'string',
+        platform: 'string',
         time: 'timestamp'
-    });
+    }, { autoInc: true });
 }
 exports.apply = apply;

package/lib/generateImg.js

@@ -206,22 +206,26 @@ class GenerateImg extends koishi_1.Service {
             // 最基本的图文处理
             function basicDynamic() {
                 const module_dynamic = dynamicMajorData.modules.module_dynamic;
-                const richText = module_dynamic.desc.rich_text_nodes.reduce((accumulator, currentValue) => {
-                    if (currentValue.emoji) {
-                        return accumulator + `<img style="width:22px; height:22px;" src="${currentValue.emoji.icon_url}"/>`;
-                    }
-                    else {
-                        return accumulator + currentValue.text;
+                if (module_dynamic.desc) {
+                    const richText = module_dynamic.desc.rich_text_nodes.reduce((accumulator, currentValue) => {
+                        if (currentValue.emoji) {
+                            return accumulator + `<img style="width:22px; height:22px;" src="${currentValue.emoji.icon_url}"/>`;
+                        }
+                        else {
+                            return accumulator + currentValue.text;
+                        }
+                    }, '');
+                    // 查找\n
+                    const text = richText.replace(/\n/g, '<br>');
+                    // 拼接字符串
+                    if (text) {
+                        main += `
+                            <div class="card-details">
+                                ${text}
+                            </div>
+                        `;
                     }
-                }, '');
-                // 查找\n
-                const text = richText.replace(/\n/g, '<br>');
-                // 拼接字符串
-                text && (main += `
-                    <div class="card-details">
-                        ${text}
-                    </div>
-                `);
+                }
                 // 图片
                 let major = '';
                 if (module_dynamic.major && module_dynamic.major.draw) {

package/package.json

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