koishi-plugin-bilibili-notify 2.0.0-alpha.2 → 2.0.0-alpha.3

package/lib/biliAPI.d.ts

@@ -36,6 +36,7 @@ declare class BiliAPI extends Service {
     getAllDynamic(updateBaseline?: string): Promise<any>;
     hasNewDynamic(updateBaseline: string): Promise<any>;
     follow(fid: string): Promise<any>;
+    getRelationGroupDetail(tagid: string): Promise<any>;
     getCookieInfo(refreshToken: string): Promise<any>;
     getUserInfo(mid: string): Promise<any>;
     getWbiKeys(): Promise<{

package/lib/biliAPI.js

@@ -40,6 +40,7 @@ const CREATE_GROUP = 'https://api.bilibili.com/x/relation/tag/create';
 const MODIFY_GROUP_MEMBER = 'https://api.bilibili.com/x/relation/tags/addUsers';
 const GET_ALL_GROUP = 'https://api.bilibili.com/x/relation/tags';
 const COPY_USER_TO_GROUP = 'https://api.bilibili.com/x/relation/tags/copyUsers';
+const GET_RELATION_GROUP_DETAIL = 'https://api.bilibili.com/x/relation/tag';
 class BiliAPI extends koishi_1.Service {
     static inject = ['database', 'notifier'];
     jar;
@@ -240,6 +241,15 @@ class BiliAPI extends koishi_1.Service {
             throw new Error('网络异常，本次请求失败！');
         }
     }
+    async getRelationGroupDetail(tagid) {
+        try {
+            const { data } = await this.client.get(`${GET_RELATION_GROUP_DETAIL}?tagid=${tagid}`);
+            return data;
+        }
+        catch (e) {
+            throw new Error('网络异常，本次请求失败！');
+        }
+    }
     // Check if Token need refresh
     async getCookieInfo(refreshToken) {
         try {

package/lib/comRegister.d.ts

@@ -1,5 +1,6 @@
-import { Bot, Context, Logger, Schema, Session } from "koishi";
+import { Bot, Context, FlatPick, Logger, Schema, Session } from "koishi";
 import { Notifier } from "@koishijs/plugin-notifier";
+import { LoginBili } from "./database";
 type SubItem = {
     id: number;
     uid: string;
@@ -20,6 +21,7 @@ declare class ComRegister {
     rebootCount: number;
     subNotifier: Notifier;
     subManager: SubManager;
+    loginDBData: FlatPick<LoginBili, "dynamic_group_id">;
     bot: Bot<Context>;
     dynamicDispose: Function;
     sendMsgFunc: (guild: string, content: any) => Promise<void>;
@@ -35,6 +37,10 @@ declare class ComRegister {
     checkIfNeedSub(liveSub: boolean, dynamicSub: boolean, session: Session, data?: any): Promise<Array<boolean>>;
     updateSubNotifier(ctx: Context): void;
     checkIfLoginInfoIsLoaded(ctx: Context): Promise<unknown>;
+    subUserInBili(ctx: Context, mid: string): Promise<{
+        flag: boolean;
+        msg: string;
+    }>;
     getSubFromDatabase(ctx: Context): Promise<void>;
     unsubSingle(ctx: Context, id: string, type: number): string;
     checkIfUserThatIsSubDynAndUnsub(): void;

package/lib/comRegister.js

@@ -26,6 +26,8 @@ class ComRegister {
     rebootCount = 0;
     subNotifier;
     subManager = [];
+    // 检查登录数据库是否有数据
+    loginDBData;
     // 机器人实例
     bot;
     // 动态销毁函数
@@ -45,6 +47,8 @@ class ComRegister {
             });
             this.logger.error('未找到对应机器人实例，请检查配置是否正确或重新配置适配器！');
         }
+        // 检查登录数据库是否有数据
+        ctx.database.get('loginBili', 1, ['dynamic_group_id']).then(data => this.loginDBData = data[0]);
         // 从数据库获取订阅
         this.getSubFromDatabase(ctx);
         // 判断消息发送方式
@@ -216,6 +220,7 @@ class ComRegister {
                             await session.send(this.unsubSingle(ctx, sub.uid, 1)); /* 1为取消订阅Dynamic */
                         // 将存在flag设置为true
                         exist = true;
+                        // 结束循环
                         return;
                     }
                     // 取消全部订阅 执行dispose方法，销毁定时器
@@ -228,9 +233,12 @@ class ComRegister {
                     // 将订阅对象移出订阅关注组
                     const removeUserFromGroupData = await ctx.ba.removeUserFromGroup(sub.uid);
                     // 判断是否移出成功 22105关注对象为自己
-                    if (removeUserFromGroupData.code !== 0 || removeUserFromGroupData.data !== 22105) {
+                    if (removeUserFromGroupData.code !== 0 && removeUserFromGroupData.code !== 22105) {
                         // 移出失败
                         await session.send('取消订阅对象失败，请稍后重试');
+                        // 将存在flag设置为true
+                        exist = true;
+                        // 结束循环
                         return;
                     }
                     // id--
@@ -295,56 +303,7 @@ class ComRegister {
             // 检查必选参数是否已填
             if (!mid)
                 return '请输入用户uid';
-            // 检查数据库是否有数据
-            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 '添加订阅对象到分组失败，请稍后重试';
-                    }
-                }
-            }
+            // 订阅对象 TODO
             // 定义外围变量                
             let content;
             try {
@@ -510,7 +469,6 @@ 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(' ')}`);
@@ -1218,8 +1176,10 @@ class ComRegister {
                             const liveEndMsg = this.config.customLiveEnd
                                 .replace('-name', username)
                                 .replace('-time', await ctx.gi.getTimeDifference(liveTime));
+                            // 更改直播时长
+                            data.live_time = liveTime;
                             // 发送@全体成员通知
-                            await sendLiveNotifyCard(data, LiveType.StartBroadcasting, liveEndMsg);
+                            await sendLiveNotifyCard(data, LiveType.StopBroadcast, liveEndMsg);
                         }
                         // 未进循环，还未开播，继续循环
                         break;
@@ -1357,6 +1317,97 @@ class ComRegister {
             check();
         });
     }
+    async subUserInBili(ctx, mid) {
+        // 获取关注分组信息
+        const checkGroupIsReady = async () => {
+            // 判断是否有数据
+            if (this.loginDBData.dynamic_group_id === '' || this.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
+                            this.loginDBData.dynamic_group_id = group.tagid;
+                            // 结束循环
+                            break;
+                        }
+                    }
+                }
+                else if (createGroupData.code !== 0) {
+                    console.log(createGroupData);
+                    // 创建分组失败
+                    return false;
+                }
+                // 创建成功，保存到数据库
+                ctx.database.set('loginBili', 1, { dynamic_group_id: this.loginDBData.dynamic_group_id });
+                // 创建成功
+                return true;
+            }
+            return true;
+        };
+        // 判断分组是否准备好
+        const flag = await checkGroupIsReady();
+        // 判断是否创建成功
+        if (!flag) {
+            // 创建分组失败
+            return { flag: false, msg: '创建分组失败，请尝试重启插件' };
+        }
+        // 获取分组明细
+        const relationGroupDetailData = await ctx.ba.getRelationGroupDetail(this.loginDBData.dynamic_group_id);
+        // 判断分组信息是否获取成功
+        if (relationGroupDetailData.code !== 0) {
+            if (relationGroupDetailData.code === 22104) {
+                // 将原先的分组id置空
+                this.loginDBData.dynamic_group_id = null;
+                // 分组不存在
+                const flag = await checkGroupIsReady();
+                // 判断是否创建成功
+                if (!flag) {
+                    // 创建分组失败
+                    return { flag: false, msg: '创建分组失败，请尝试重启插件' };
+                }
+                return { flag: true, msg: '分组不存在，已重新创建分组' };
+            }
+            // 获取分组明细失败
+            return { flag: false, msg: '获取分组明细失败' };
+        }
+        relationGroupDetailData.data.forEach(user => {
+            if (user.mid === mid) {
+                // 已关注订阅对象
+                return { flag: true, msg: '订阅对象已存在于分组中' };
+            }
+        });
+        // 订阅对象
+        const subUserData = await ctx.ba.follow(mid);
+        // 判断是否订阅成功
+        switch (subUserData.code) {
+            case -101: return { flag: false, msg: '账号未登录，请使用指令bili login登录后再进行订阅操作' };
+            case -102: return { flag: false, msg: '账号被封停，无法进行订阅操作' };
+            case 22002: return { flag: false, msg: '因对方隐私设置，无法进行订阅操作' };
+            case 22003: return { flag: false, msg: '你已将对方拉黑，无法进行订阅操作' };
+            case 22013: return { flag: false, msg: '账号已注销，无法进行订阅操作' };
+            case 40061: return { flag: false, msg: '账号不存在，请检查uid输入是否正确或用户是否存在' };
+            case 22001: break; // 订阅对象为自己 无需添加到分组
+            case 22014: // 已关注订阅对象 无需再次关注
+            case 0: { // 执行订阅成功
+                // 把订阅对象添加到分组中
+                const copyUserToGroupData = await ctx.ba.copyUserToGroup(mid, this.loginDBData.dynamic_group_id);
+                // 判断是否添加成功
+                if (copyUserToGroupData.code !== 0) {
+                    // 添加失败
+                    return { flag: false, msg: '添加订阅对象到分组失败，请稍后重试' };
+                }
+            }
+        }
+        // 订阅成功
+        return { flag: true, msg: '用户订阅成功' };
+    }
     async getSubFromDatabase(ctx) {
         // 判断登录信息是否已加载完毕
         await this.checkIfLoginInfoIsLoaded(ctx);
@@ -1384,6 +1435,19 @@ class ComRegister {
                 // 跳过下面的步骤
                 continue;
             }
+            // 判断用户是否在B站中订阅了
+            const subUserData = await this.subUserInBili(ctx, sub.uid);
+            // 判断是否订阅
+            if (!subUserData.flag) {
+                // log
+                this.logger.warn(`UID:${sub.uid} ${subUserData.msg}，自动取消订阅`);
+                // 发送私聊消息
+                await this.sendPrivateMsg(`UID:${sub.uid} ${subUserData.msg}，自动取消订阅`);
+                // 删除该条数据
+                await ctx.database.remove('bilibili', { id: sub.id });
+                // 跳过下面的步骤
+                continue;
+            }
             // 获取推送目标数组
             const targetIdArr = sub.targetId.split(' ');
             /* 判断数据库是否被篡改 */
@@ -1435,7 +1499,7 @@ class ComRegister {
                 }
             }
             // 检测房间号是否被篡改
-            if (sub.live && (!data.live_room || data.live_room.roomid.toString() !== sub.room_id)) {
+            if (sub.live && (!data.live_room || data.live_room.roomid != sub.room_id)) {
                 // 房间号被篡改，删除该订阅
                 await deleteSub();
                 // log

package/package.json

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

package/{README.md → readme.md}

@@ -178,8 +178,9 @@
 - ver 1.3.7 新增设置项：插件重启后是否进行直播推送。优化直播人气显示
 
 - ver 2.0.0-alpha.0 重构：对动态订阅进行了重构，优化了订阅流程
-- ver 2.0.0-alpha.1 修复bug：无法成功取消订阅自己、用户没有直播间订阅直播出错。对直播订阅进行了限制，继承自以前的unlockSubLimits配置项。优化了一些配置项
+- ver 2.0.0-alpha.1 修复：无法成功取消订阅自己、用户没有直播间订阅直播出错。对直播订阅进行了限制，继承自以前的unlockSubLimits配置项。优化了一些配置项
 - ver 2.0.0-alpha.2 新增：支持Discord平台。优化了下播通知
+- ver 2.0.0-alpha.3 修复：订阅和取消订阅的bug，下播通知的bug
 
 ## 交流群