koishi-plugin-bilibili-notify 0.1.2 → 1.0.0-alpha.0

package/lib/authority.d.ts

@@ -0,0 +1,5 @@
+import { Context } from "koishi";
+declare class Authority {
+    constructor(ctx: Context);
+}
+export default Authority;

package/lib/authority.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Authority {
+    constructor(ctx) {
+        // 授予权限
+        /* ctx.permissions.provide('telegram:admin', async (name, session) => {
+            console.log(session);
+            return session.telegram?.sender?.role === 'admin'
+        }) */
+    }
+}
+exports.default = Authority;

package/lib/biliAPI.d.ts

@@ -22,8 +22,8 @@ declare class BiliAPI extends Service {
     getLiveRoomInfo(roomId: string): Promise<any>;
     getMasterInfo(mid: string): Promise<any>;
     createNewClient(): void;
-    getCookies(): Promise<string>;
+    getCookies(): string;
     loadCookiesFromDatabase(): Promise<void>;
-    checkIfTokenNeedRefresh(refreshToken: string, csrf: string): Promise<void>;
+    checkIfTokenNeedRefresh(refreshToken: string, csrf: string, times?: number): Promise<void>;
 }
 export default BiliAPI;

package/lib/biliAPI.js

@@ -35,48 +35,93 @@ class BiliAPI extends koishi_1.Service {
         this.logger.info('BiliAPI已被注册到Context中');
     }
     async getTimeNow() {
-        const { data } = await this.client.get(GET_TIME_NOW);
-        return data;
+        try {
+            const { data } = await this.client.get(GET_TIME_NOW);
+            return data;
+        }
+        catch (e) {
+            throw new Error('网络异常，本次请求失败！');
+        }
     }
     async getUserSpaceDynamic(mid) {
-        const { data } = await this.client.get(`${GET_USER_SPACE_DYNAMIC_LIST}?host_mid=${mid}`);
-        return data;
+        try {
+            const { data } = await this.client.get(`${GET_USER_SPACE_DYNAMIC_LIST}?host_mid=${mid}`);
+            return data;
+        }
+        catch (e) {
+            throw new Error('网络异常，本次请求失败！');
+        }
     }
     // Check if Token need refresh
     async getCookieInfo(refreshToken) {
-        const { data } = await this.client.get(`${GET_COOKIES_INFO}?csrf=${refreshToken}`);
-        return data;
+        try {
+            const { data } = await this.client.get(`${GET_COOKIES_INFO}?csrf=${refreshToken}`);
+            return data;
+        }
+        catch (e) {
+            throw new Error('网络异常，本次请求失败！');
+        }
     }
     async getUserInfo(mid) {
-        const wbi = await this.ctx.wbi.getWbi({ mid });
-        const { data } = await this.client.get(`${GET_USER_INFO}?${wbi}`);
-        return data;
+        try {
+            const wbi = await this.ctx.wbi.getWbi({ mid });
+            const { data } = await this.client.get(`${GET_USER_INFO}?${wbi}`);
+            return data;
+        }
+        catch (e) {
+            throw new Error('网络异常，本次请求失败！');
+        }
     }
     async getMyselfInfo() {
-        const { data } = await this.client.get(GET_MYSELF_INFO);
-        return data;
+        try {
+            const { data } = await this.client.get(GET_MYSELF_INFO);
+            return data;
+        }
+        catch (e) {
+            throw new Error('网络异常，本次请求失败！');
+        }
     }
     async getLoginQRCode() {
-        const { data } = await this.client.get(GET_LOGIN_QRCODE);
-        return data;
+        try {
+            const { data } = await this.client.get(GET_LOGIN_QRCODE);
+            return data;
+        }
+        catch (e) {
+            throw new Error('网络异常，本次请求失败！');
+        }
     }
     async getLoginStatus(qrcodeKey) {
-        const { data } = await this.client.get(`${GET_LOGIN_STATUS}?qrcode_key=${qrcodeKey}`);
-        return data;
+        try {
+            const { data } = await this.client.get(`${GET_LOGIN_STATUS}?qrcode_key=${qrcodeKey}`);
+            return data;
+        }
+        catch (e) {
+            throw new Error('网络异常，本次请求失败！');
+        }
     }
     async getLiveRoomInfo(roomId) {
-        const { data } = await this.client.get(`${GET_LIVE_ROOM_INFO}?room_id=${roomId}`);
-        return data;
+        try {
+            const { data } = await this.client.get(`${GET_LIVE_ROOM_INFO}?room_id=${roomId}`);
+            return data;
+        }
+        catch (e) {
+            throw new Error('网络异常，本次请求失败！');
+        }
     }
     async getMasterInfo(mid) {
-        const { data } = await this.client.get(`${GET_MASTER_INFO}?uid=${mid}`);
-        return data;
+        try {
+            const { data } = await this.client.get(`${GET_MASTER_INFO}?uid=${mid}`);
+            return data;
+        }
+        catch (e) {
+            throw new Error('网络异常，本次请求失败！');
+        }
     }
     createNewClient() {
         this.jar = new tough_cookie_1.CookieJar();
         this.client = (0, axios_cookiejar_support_1.wrapper)(axios_1.default.create({ jar: this.jar, headers: { 'Content-Type': 'application/json' } }));
     }
-    async getCookies() {
+    getCookies() {
         let cookies;
         this.jar.store.getAllCookies((err, c) => {
             if (err)
@@ -120,8 +165,22 @@ class BiliAPI extends koishi_1.Service {
         // Check if token need refresh
         this.checkIfTokenNeedRefresh(decryptedRefreshToken, csrf);
     }
-    async checkIfTokenNeedRefresh(refreshToken, csrf) {
-        const { data } = await this.getCookieInfo(refreshToken);
+    async checkIfTokenNeedRefresh(refreshToken, csrf, times = 0) {
+        let data;
+        try {
+            const { data: cookieData } = await this.getCookieInfo(refreshToken);
+            data = cookieData;
+        }
+        catch (e) {
+            // 发送三次仍网络错误则给管理员发送错误信息
+            if (times > 3)
+                return;
+            // 等待3秒再次尝试
+            this.ctx.setTimeout(() => {
+                this.checkIfTokenNeedRefresh(refreshToken, csrf, times + 1);
+            }, 3000);
+            return;
+        }
         // 不需要刷新，直接返回
         if (!data.refresh)
             return;
@@ -135,7 +194,8 @@ class BiliAPI extends koishi_1.Service {
             const encrypted = new Uint8Array(await crypto.subtle.encrypt({ name: "RSA-OAEP" }, publicKey, data));
             return encrypted.reduce((str, c) => str + c.toString(16).padStart(2, "0"), "");
         }
-        const correspondPath = await getCorrespondPath(Date.now());
+        const correspondPath = await getCorrespondPath(data.timestamp);
+        // 获取refresh_csrf
         const { data: refreshCsrfHtml } = await this.client.get(`https://www.bilibili.com/correspond/1/${correspondPath}`);
         // 创建一个虚拟的DOM元素
         const { document } = new jsdom_1.JSDOM(refreshCsrfHtml).window;
@@ -153,8 +213,14 @@ class BiliAPI extends koishi_1.Service {
         switch (refreshData.code) {
             // 账号未登录
             case -101: return this.createNewClient();
-            case -111: throw new Error('csrf 校验失败');
-            case 86095: throw new Error('refresh_csrf 错误或 refresh_token 与 cookie 不匹配');
+            case -111: {
+                await this.ctx.database.remove('loginBili', [1]);
+                throw new Error('csrf 校验失败');
+            }
+            case 86095: {
+                await this.ctx.database.remove('loginBili', [1]);
+                throw new Error('refresh_csrf 错误或 refresh_token 与 cookie 不匹配');
+            }
         }
         // 更新refresh_token
         await this.ctx.database.upsert('loginBili', [{

package/lib/comRegister.d.ts

@@ -17,14 +17,18 @@ declare class ComRegister {
     qqBot: Bot<Context>;
     qqguildBot: Bot<Context>;
     constructor(ctx: Context, config: ComRegister.Config);
-    dynamicDetect(ctx: Context, bot: Bot<Context>, groupId: string, uid: string): () => Promise<"账号未登录" | "未知错误">;
-    liveDetect(ctx: Context, bot: Bot<Context>, groupId: string, roomId: string): () => Promise<void>;
+    dynamicDetect(ctx: Context, bot: Bot<Context>, guildId: string, uid: string): () => Promise<void>;
+    liveDetect(ctx: Context, bot: Bot<Context>, guildId: string, roomId: string): () => Promise<false | void>;
     checkIfNeedSub(comNeed: boolean, subType: string, session: Session, data?: any): Promise<boolean>;
     getSubFromDatabase(ctx: Context): Promise<void>;
+    unsubSingle(ctx: Context, id: string, type: number): string;
+    checkIfIsLogin(ctx: Context): Promise<boolean>;
 }
 declare namespace ComRegister {
     interface Config {
         pushTime: number;
+        liveLoopTime: number;
+        dynamicLoopTime: number;
     }
     const Config: Schema<Config>;
 }

package/lib/comRegister.js

@@ -30,7 +30,7 @@ class ComRegister {
         // 拿到QQ频道机器人
         this.qqguildBot = ctx.bots[ctx.bots.findIndex(bot => bot.platform === 'qqguild')];
         this.getSubFromDatabase(ctx);
-        ctx.command('test')
+        ctx.command('test', { hidden: true, permissions: ['authority:5'] })
             .subcommand('.cookies')
             .usage('测试指令，用于测试从数据库读取cookies')
             .action(async () => {
@@ -72,19 +72,12 @@ class ComRegister {
             .subcommand('.gimg <uid:string> <index:number>')
             .usage('测试图片生成')
             .example('test.gimg')
-            .action(async (_, uid, index) => {
+            .action(async ({ session }, uid, index) => {
             // 获取用户空间动态数据
             const { data } = await ctx.biliAPI.getUserSpaceDynamic(uid);
             const [pic] = await ctx.gimg.generateDynamicImg(data.items[index]);
             return pic;
         });
-        ctx.command('test')
-            .subcommand('.subm')
-            .usage('查看订阅对象状态')
-            .example('test subm')
-            .action(() => {
-            console.log(this.subManager);
-        });
         ctx.command('test')
             .subcommand('.group')
             .usage('查看session groupId')
@@ -99,14 +92,20 @@ class ComRegister {
             .action(({ session }) => {
             console.log(session);
         });
-        ctx.command('bili', 'bili-notify插件相关指令')
+        ctx.command('bili', 'bili-notify插件相关指令', { permissions: ['authority:3'] })
             .subcommand('.login', '登录B站之后才可以进行之后的操作')
             .usage('使用二维码登录，登录B站之后才可以进行之后的操作')
             .example('bili login')
             .action(async ({ session }) => {
             this.logger.info('调用bili login指令');
             // 获取二维码
-            const content = await ctx.biliAPI.getLoginQRCode();
+            let content;
+            try {
+                content = await ctx.biliAPI.getLoginQRCode();
+            }
+            catch (e) {
+                return 'bili login getLoginQRCode() 本次网络请求失败';
+            }
             // 判断是否出问题
             if (content.code !== 0)
                 return await session.send('出问题咯，请联系管理员解决！');
@@ -131,7 +130,14 @@ class ComRegister {
             let dispose;
             // 发起登录请求检查登录状态
             dispose = ctx.setInterval(async () => {
-                const loginContent = await ctx.biliAPI.getLoginStatus(content.data.qrcode_key);
+                let loginContent;
+                try {
+                    loginContent = await ctx.biliAPI.getLoginStatus(content.data.qrcode_key);
+                }
+                catch (e) {
+                    this.logger.error(e);
+                    return;
+                }
                 if (loginContent.code !== 0) {
                     dispose();
                     return await session.send('登录失败！请联系管理员解决！');
@@ -148,16 +154,25 @@ class ComRegister {
                             bili_cookies: encryptedCookies,
                             bili_refresh_token: encryptedRefreshToken
                         }]);
+                    // 销毁定时器
                     dispose();
-                    return await session.send('登录成功！');
+                    // 发送成功登录推送
+                    await session.send('登录成功！');
+                    // 订阅之前的订阅
+                    await this.getSubFromDatabase(ctx);
+                    // 调用bili show指令
+                    await session.execute('bili show');
+                    return;
                 }
             }, 1000);
         });
         ctx.command('bili')
-            .subcommand('.unsub <uid:string>')
-            .usage('取消订阅')
-            .example('bili unsub 用户UID')
-            .action(async ({ session }, uid) => {
+            .subcommand('.unsub <uid:string>', '取消订阅UP主动态、直播或全部')
+            .usage('取消订阅，加-l为取消直播订阅，加-d为取消动态订阅，什么都不加则为全部取消')
+            .option('live', '-l')
+            .option('dynamic', '-d')
+            .example('bili unsub 用户UID -ld')
+            .action(async ({ session, options }, uid) => {
             this.logger.info('调用bili.unsub指令');
             // 若用户UID为空则直接返回
             if (!uid)
@@ -166,9 +181,21 @@ class ComRegister {
             let exist;
             await Promise.all(this.subManager.map(async (sub, i) => {
                 if (sub.uid === uid) {
-                    // 执行dispose方法，销毁定时器
-                    this.subManager[i].dynamicDispose();
-                    this.subManager[i].liveDispose();
+                    // 取消单个订阅
+                    if (options.live || options.dynamic) {
+                        if (options.live)
+                            await session.send(this.unsubSingle(ctx, sub.roomId, 0)); /* 0为取消订阅Live */
+                        if (options.dynamic)
+                            await session.send(this.unsubSingle(ctx, sub.uid, 1)); /* 1为取消订阅Dynamic */
+                        // 将存在flag设置为true
+                        exist = true;
+                        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 });
                     // 将该订阅对象从订阅管理对象中移除
@@ -185,25 +212,30 @@ class ComRegister {
             !exist && session.send('未订阅该用户，无需取消订阅');
         });
         ctx.command('bili')
-            .subcommand('.show')
+            .subcommand('.show', '展示订阅对象')
             .usage('展示订阅对象')
             .example('bili show')
             .action(async ({ session }) => {
             let table = ``;
             this.subManager.forEach(sub => {
-                table += 'UID:' + sub.uid + '  RoomID:' + sub.roomId + '\n';
+                table += `UID:${sub.uid}  ${sub.dynamic ? '已订阅动态' : ''}  ${sub.live ? '已订阅直播' : ''}` + '\n';
             });
             !table && session.send('没有订阅任何UP');
             table && session.send(table);
         });
         ctx.command('bili')
-            .subcommand('.sub <mid:string> [guildId:string]')
+            .subcommand('.sub <mid:string> [guildId:string]', '订阅用户动态和直播通知')
             .option('live', '-l')
             .option('dynamic', '-d')
-            .usage('订阅用户动态和直播通知，若需要订阅直播请加上-l，需要订阅动态则加上-d。若没有加任何参数，之后会向你单独询问，<>中为必选参数，[]中为可选参数，目标群号若不填，则默认为当前群聊')
+            .usage('订阅用户动态和直播通知，若需要订阅直播请加上-l，需要订阅动态则加上-d。若没有加任何参数，之后会向你单独询问，尖括号中为必选参数，中括号为可选参数，目标群号若不填，则默认为当前群聊')
             .example('bili sub 用户uid 目标QQ群号(暂不支持) -l -d')
             .action(async ({ session, options }, mid, guildId) => {
             this.logger.info('调用bili.sub指令');
+            // 检查是否登录
+            if (!(await this.checkIfIsLogin(ctx))) {
+                // 未登录直接返回
+                return '请使用指令bili login登录后再进行订阅操作';
+            }
             // 如果订阅人数超过三个则直接返回
             if (this.num >= 3)
                 return '目前最多只能订阅三个人';
@@ -217,7 +249,13 @@ class ComRegister {
             // 定义是否需要直播通知，动态订阅，视频推送
             let liveMsg, dynamicMsg;
             // 获取用户信息
-            const content = await ctx.biliAPI.getUserInfo(mid);
+            let content;
+            try {
+                content = await ctx.biliAPI.getUserInfo(mid);
+            }
+            catch (e) {
+                return 'bili sub getUserInfo() 本次网络请求失败';
+            }
             // 判断是否有其他问题
             if (content.code !== 0) {
                 let msg;
@@ -299,7 +337,14 @@ class ComRegister {
                 dynamicDispose: null
             });
             // 获取用户信息
-            const { data: userData } = await ctx.biliAPI.getMasterInfo(sub.uid);
+            let userData;
+            try {
+                const { data } = await ctx.biliAPI.getMasterInfo(sub.uid);
+                userData = data;
+            }
+            catch (e) {
+                return 'bili sub指令 getMasterInfo() 网络请求失败';
+            }
             // 需要订阅直播
             if (liveMsg) {
                 await session.execute(`bili live ${data.live_room.roomid} ${guildId} -b ${platform}`);
@@ -314,7 +359,7 @@ class ComRegister {
             }
         });
         ctx.command('bili')
-            .subcommand('.dynamic <uid:string>')
+            .subcommand('.dynamic <uid:string> <guildId:string>', '订阅用户动态推送', { hidden: true })
             .option('bot', '-b <type:string>')
             .usage('订阅用户动态推送')
             .example('bili dynamic 1')
@@ -323,6 +368,8 @@ class ComRegister {
             // 如果uid为空则返回
             if (!uid)
                 return '用户uid不能为空';
+            if (!guildId)
+                return '目标群组或频道不能为空';
             if (!options.bot)
                 return '非法调用';
             // 保存到订阅管理对象
@@ -349,11 +396,11 @@ class ComRegister {
             this.subManager[index].dynamicDispose = dispose;
         });
         ctx.command('bili')
-            .subcommand('.live <roomId:string> <guildId:string>')
+            .subcommand('.live <roomId:string> <guildId:string>', '订阅主播开播通知', { hidden: true })
             .option('bot', '-b <type:string>')
             .usage('订阅主播开播通知')
             .example('bili live 732')
-            .action(async ({ session, options }, roomId, guildId) => {
+            .action(async ({ options }, roomId, guildId) => {
             this.logger.info('调用bili.live指令');
             // 如果room_id为空则返回
             if (!roomId)
@@ -384,16 +431,29 @@ class ComRegister {
             this.subManager[index].liveDispose = dispose;
         });
         ctx.command('bili')
-            .subcommand('.status <roomId:string>')
+            .subcommand('.status <roomId:string>', '查询主播当前直播状态', { hidden: true })
             .usage('查询主播当前直播状态')
             .example('bili status 732')
             .action(async ({ session }, roomId) => {
             this.logger.info('调用bili.status指令');
             if (!roomId)
                 return session.send('请输入房间号!');
-            const content = await ctx.biliAPI.getLiveRoomInfo(roomId);
+            let content;
+            try {
+                content = await ctx.biliAPI.getLiveRoomInfo(roomId);
+            }
+            catch (e) {
+                return 'bili status指令 getLiveRoomInfo() 本次网络请求失败';
+            }
             const { data } = content;
-            const { data: userData } = await ctx.biliAPI.getMasterInfo(data.uid);
+            let userData;
+            try {
+                const { data: userInfo } = await ctx.biliAPI.getMasterInfo(data.uid);
+                userData = userInfo;
+            }
+            catch (e) {
+                return 'bili status指令 getMasterInfo() 网络请求失败';
+            }
             // B站出问题了
             if (content.code !== 0) {
                 if (content.msg === '未找到该房间') {
@@ -411,7 +471,7 @@ class ComRegister {
             session.send(string);
         });
     }
-    dynamicDetect(ctx, bot, groupId, uid) {
+    dynamicDetect(ctx, bot, guildId, uid) {
         let firstSubscription = true;
         let timePoint;
         return async () => {
@@ -424,17 +484,26 @@ class ComRegister {
                 return;
             }
             // 获取用户空间动态数据
-            const content = await ctx.biliAPI.getUserSpaceDynamic(uid);
+            let content;
+            try {
+                content = await ctx.biliAPI.getUserSpaceDynamic(uid);
+            }
+            catch (e) {
+                return this.logger.error('dynamicDetect getUserSpaceDynamic() 网络请求失败');
+            }
             // 判断是否出现其他问题
             if (content.code !== 0) {
                 switch (content.code) {
                     case -101: { // 账号未登录
-                        return '账号未登录';
+                        bot.sendMessage(guildId, '账号未登录，请登录后重新订阅动态');
                     }
                     default: { // 未知错误
-                        return '未知错误';
+                        bot.sendMessage(guildId, '未知错误，请重新订阅动态');
                     }
                 }
+                // 取消订阅
+                this.unsubSingle(ctx, uid, 1); /* 1为取消动态订阅 */
+                return;
             }
             // 获取数据内容
             const items = content.data.items;
@@ -458,94 +527,126 @@ class ComRegister {
                     }
                     // 推送该条动态
                     const [pic] = await ctx.gimg.generateDynamicImg(items[num]);
-                    await bot.sendMessage(groupId, pic);
+                    await bot.sendMessage(guildId, pic);
                 }
             }
         };
     }
-    liveDetect(ctx, bot, groupId, roomId) {
+    liveDetect(ctx, bot, guildId, roomId) {
         let firstSubscription = true;
         let timer = 0;
         let open = false;
         let liveTime;
         let uData;
+        // 相当于锁的作用，防止上一个循环没处理完
+        let flag = true;
         return async () => {
-            // 发送请求检测直播状态
-            const content = await ctx.biliAPI.getLiveRoomInfo(roomId);
-            const { data } = content;
-            // B站出问题了
-            if (content.code !== 0) {
-                if (content.msg === '未找到该房间') {
-                    await bot.sendMessage(groupId, '未找到该房间！');
+            try {
+                // 如果flag为false则说明前面的代码还未执行完，则直接返回
+                if (!flag)
+                    return flag = false;
+                // 发送请求检测直播状态
+                let content;
+                try {
+                    content = await ctx.biliAPI.getLiveRoomInfo(roomId);
                 }
-                else {
-                    await bot.sendMessage(groupId, '未知错误，请呼叫管理员检查问题！');
+                catch (e) {
+                    return this.logger.error('liveDetect getLiveRoomInfo 网络请求失败');
                 }
-                // dispose
-                return;
-            }
-            if (firstSubscription) {
-                firstSubscription = false;
-                // 获取主播信息
-                const { data: userData } = await ctx.biliAPI.getMasterInfo(data.uid);
-                // 主播信息不会变，请求一次即可
-                uData = userData;
-                // 判断直播状态
-                if (data.live_status === 1) { // 当前正在直播
-                    // 推送直播信息
-                    await bot.sendMessage(groupId, await ctx
-                        .gimg
-                        .generateLiveImg(data, uData, LiveType.LiveBroadcast));
-                    // 改变开播状态
-                    open = true;
-                } // 未开播，直接返回
-                return;
-            }
-            // 检查直播状态
-            switch (data.live_status) {
-                case 0:
-                case 2: { // 状态 0 和 2 说明未开播
-                    if (open) { // 之前开播，现在下播了
-                        // 更改直播状态
-                        open = false;
-                        // 下播了将定时器清零
-                        timer = 0;
-                        // 发送下播通知
-                        bot.sendMessage(groupId, `${uData.info.uname}下播啦，本次直播了${ctx.gimg.getTimeDifference(liveTime)}`);
+                const { data } = content;
+                // B站出问题了
+                if (content.code !== 0) {
+                    if (content.msg === '未找到该房间') {
+                        await bot.sendMessage(guildId, '未找到该房间，请检查房间号后重新订阅');
                     }
-                    // 未进循环，还未开播，继续循环
-                    break;
+                    else {
+                        await bot.sendMessage(guildId, '未知错误，请呼叫管理员检查问题后重新订阅');
+                    }
+                    // dispose
+                    this.unsubSingle(ctx, roomId, 0); /* 0为取消Live订阅 */
+                    return;
                 }
-                case 1: {
-                    if (!open) { // 之前未开播，现在开播了
-                        // 更改直播状态
+                if (firstSubscription) {
+                    firstSubscription = false;
+                    // 获取主播信息
+                    let userData;
+                    try {
+                        const { data: userInfo } = await ctx.biliAPI.getMasterInfo(data.uid);
+                        userData = userInfo;
+                    }
+                    catch (e) {
+                        return this.logger.error('liveDetect first sub getMasterInfo() 网络请求错误');
+                    }
+                    // 主播信息不会变，请求一次即可
+                    uData = userData;
+                    // 判断直播状态
+                    if (data.live_status === 1) { // 当前正在直播
+                        // 推送直播信息
+                        await bot.sendMessage(guildId, await ctx
+                            .gimg
+                            .generateLiveImg(data, uData, LiveType.LiveBroadcast));
+                        // 改变开播状态
                         open = true;
-                        // 设置开播时间
-                        liveTime = data.live_time;
-                        // 获取主播信息
-                        const { data: userData } = await ctx.biliAPI.getMasterInfo(data.uid);
-                        // 主播信息不会变，开播时刷新一次即可
-                        uData = userData;
-                        // 发送直播通知
-                        await bot.sendMessage(groupId, await ctx.gimg.generateLiveImg(data, uData, LiveType.StartBroadcasting));
+                    } // 未开播，直接返回
+                    return;
+                }
+                // 检查直播状态
+                switch (data.live_status) {
+                    case 0:
+                    case 2: { // 状态 0 和 2 说明未开播
+                        if (open) { // 之前开播，现在下播了
+                            // 更改直播状态
+                            open = false;
+                            // 下播了将定时器清零
+                            timer = 0;
+                            // 发送下播通知
+                            bot.sendMessage(guildId, `${uData.info.uname}下播啦，本次直播了${ctx.gimg.getTimeDifference(liveTime)}`);
+                        }
+                        // 未进循环，还未开播，继续循环
+                        break;
                     }
-                    else { // 还在直播
-                        if (this.config.pushTime > 0) {
-                            timer++;
-                            // 开始记录时间
-                            if (timer >= (12 * 30 * this.config.pushTime)) { // 到时间推送直播消息
-                                // 到时间重新计时
-                                timer = 0;
-                                // 发送状态信息
-                                bot.sendMessage(groupId, await ctx
-                                    .gimg
-                                    .generateLiveImg(data, uData, LiveType.LiveBroadcast));
+                    case 1: {
+                        if (!open) { // 之前未开播，现在开播了
+                            // 更改直播状态
+                            open = true;
+                            // 设置开播时间
+                            liveTime = data.live_time;
+                            // 获取主播信息
+                            let userData;
+                            try {
+                                const { data: userInfo } = await ctx.biliAPI.getMasterInfo(data.uid);
+                                userData = userInfo;
+                            }
+                            catch (e) {
+                                return this.logger.error('liveDetect open getMasterInfo() 网络请求错误');
+                            }
+                            // 主播信息不会变，开播时刷新一次即可
+                            uData = userData;
+                            // 发送直播通知
+                            await bot.sendMessage(guildId, await ctx.gimg.generateLiveImg(data, uData, LiveType.StartBroadcasting));
+                        }
+                        else { // 还在直播
+                            if (this.config.pushTime > 0) {
+                                timer++;
+                                // 开始记录时间
+                                if (timer >= (12 * 30 * this.config.pushTime)) { // 到时间推送直播消息
+                                    // 到时间重新计时
+                                    timer = 0;
+                                    // 发送状态信息
+                                    bot.sendMessage(guildId, await ctx
+                                        .gimg
+                                        .generateLiveImg(data, uData, LiveType.LiveBroadcast));
+                                }
                             }
+                            // 否则继续循环
                         }
-                        // 否则继续循环
                     }
                 }
             }
+            finally {
+                // 执行完方法体不论如何都把flag设置为true
+                flag = true;
+            }
         };
     }
     async checkIfNeedSub(comNeed, subType, session, data) {
@@ -583,6 +684,9 @@ class ComRegister {
         }
     }
     async getSubFromDatabase(ctx) {
+        if (!(await this.checkIfIsLogin(ctx))) { // 如果未登录，则直接返回
+            return;
+        }
         // 从数据库中获取数据
         const subData = await ctx.database.get('bilibili', { id: { $gt: 0 } });
         // 设定订阅数量
@@ -614,26 +718,95 @@ class ComRegister {
             // 判断需要订阅的服务
             if (sub.dynamic) { // 需要订阅动态
                 // 开始循环检测
-                const dispose = ctx.setInterval(this.dynamicDetect(ctx, bot, sub.targetId, sub.uid), 60000);
+                const dispose = ctx.setInterval(this.dynamicDetect(ctx, bot, sub.targetId, sub.uid), this.config.dynamicLoopTime * 1000);
                 // 保存销毁函数
                 subManagerItem.dynamicDispose = dispose;
             }
             if (sub.live) { // 需要订阅动态
                 // 开始循环检测
-                const dispose = ctx.setInterval(this.liveDetect(ctx, bot, sub.targetId, sub.room_id), 5000);
+                const dispose = ctx.setInterval(this.liveDetect(ctx, bot, sub.targetId, sub.room_id), this.config.liveLoopTime * 1000);
                 // 保存销毁函数
                 subManagerItem.liveDispose = dispose;
             }
             // 保存新订阅对象
             this.subManager.push(subManagerItem);
             // 发送订阅成功通知
-            bot.sendMessage(sub.targetId, '重新加载测试发送');
         });
     }
+    unsubSingle(ctx, id /* UID或RoomId */, type /* 0取消Live订阅，1取消Dynamic订阅 */) {
+        let index;
+        switch (type) {
+            case 0: { // 取消Live订阅
+                index = this.subManager.findIndex(sub => sub.roomId === id);
+                if (index === -1)
+                    return '未订阅该用户，无需取消订阅';
+                // 取消订阅
+                this.subManager[index].live && this.subManager[index].liveDispose();
+                // 如果没有对这个UP的任何订阅，则移除
+                if (!this.subManager[index].dynamic) {
+                    // 获取要删除行的id
+                    const id = this.subManager[index].id;
+                    // 从管理对象中移除
+                    this.subManager = this.subManager.splice(index, index);
+                    // 从数据库中删除
+                    ctx.database.remove('bilibili', [id]);
+                    // num--
+                    this.num--;
+                    return '已取消订阅该用户';
+                }
+                this.subManager[index].liveDispose = null;
+                this.subManager[index].live = false;
+                // 更新数据库
+                ctx.database.upsert('bilibili', [{
+                        id: +`${this.subManager[index].id}`,
+                        live: 0
+                    }]);
+                return '已取消订阅Live';
+            }
+            case 1: { // 取消Dynamic订阅
+                index = this.subManager.findIndex(sub => sub.uid === id);
+                if (index === -1)
+                    return '未订阅该用户，无需取消订阅';
+                // 取消订阅
+                this.subManager[index].dynamic && this.subManager[index].dynamicDispose();
+                // 如果没有对这个UP的任何订阅，则移除
+                if (!this.subManager[index].live) {
+                    // 获取要删除行的id
+                    const id = this.subManager[index].id;
+                    // 从管理对象中移除
+                    this.subManager = this.subManager.splice(index, index);
+                    // 从数据库中删除
+                    ctx.database.remove('bilibili', [id]);
+                    // num--
+                    this.num--;
+                    return '已取消订阅该用户';
+                }
+                this.subManager[index].dynamicDispose = null;
+                this.subManager[index].dynamic = false;
+                // 更新数据库
+                ctx.database.upsert('bilibili', [{
+                        id: +`${this.subManager[index].id}`,
+                        dynamic: 0
+                    }]);
+                return '已取消订阅Dynamic';
+            }
+        }
+    }
+    async checkIfIsLogin(ctx) {
+        if ((await ctx.database.get('loginBili', 1)).length !== 0) { // 数据库中有数据
+            // 检查cookie中是否有值
+            if (ctx.biliAPI.getCookies() !== '[]') { // 有值说明已登录
+                return true;
+            }
+        }
+        return false;
+    }
 }
 (function (ComRegister) {
     ComRegister.Config = koishi_1.Schema.object({
-        pushTime: koishi_1.Schema.number().required()
+        pushTime: koishi_1.Schema.number().required(),
+        liveLoopTime: koishi_1.Schema.number().default(5),
+        dynamicLoopTime: koishi_1.Schema.number().default(60)
     });
 })(ComRegister || (ComRegister = {}));
 exports.default = ComRegister;

package/lib/index.js

@@ -31,6 +31,7 @@ const koishi_1 = require("koishi");
 // import crypto
 const crypto_1 = __importDefault(require("crypto"));
 // import plugins
+// import Authority from './authority'
 const comRegister_1 = __importDefault(require("./comRegister"));
 const Database = __importStar(require("./database"));
 // import Service
@@ -68,6 +69,7 @@ function apply(ctx, config) {
     ctx.plugin(generateImg_1.default, { cardColorStart: config.cardColorStart, cardColorEnd: config.cardColorEnd });
     ctx.plugin(biliAPI_1.default);
     // load plugin
+    // ctx.plugin(Authority)
     ctx.plugin(comRegister_1.default, { pushTime: config.pushTime });
     // 当用户输入“恶魔兔，启动！”时，执行 help 指令
     ctx.middleware((session, next) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-bilibili-notify",
   "description": "Koishi bilibili notify plugin",
-  "version": "0.1.2",
+  "version": "1.0.0-alpha.0",
   "contributors": [
     "Akokko <admin@akokko.com>"
   ],
@@ -12,6 +12,10 @@
     "dist"
   ],
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Akokk0/koishi-plugin-bilibili-notify"
+  },
   "scripts": {},
   "keywords": [
     "chatbot",