koishi-plugin-bilibili-notify 2.0.0-alpha.1 → 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

@@ -10,12 +10,12 @@ const jsx_runtime_1 = require("@satorijs/element/jsx-runtime");
 const koishi_1 = require("koishi");
 // 导入qrcode
 const qrcode_1 = __importDefault(require("qrcode"));
-const jimp_1 = require("jimp");
 var LiveType;
 (function (LiveType) {
     LiveType[LiveType["NotLiveBroadcast"] = 0] = "NotLiveBroadcast";
     LiveType[LiveType["StartBroadcasting"] = 1] = "StartBroadcasting";
     LiveType[LiveType["LiveBroadcast"] = 2] = "LiveBroadcast";
+    LiveType[LiveType["StopBroadcast"] = 3] = "StopBroadcast";
 })(LiveType || (LiveType = {}));
 class ComRegister {
     static inject = ['ba', 'gi', 'database', 'sm'];
@@ -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--
@@ -283,7 +291,8 @@ class ComRegister {
                 case 'satori':
                 case 'chronocat':
                 case 'qq':
-                case 'qqguild': break;
+                case 'qqguild':
+                case 'discord': break;
                 default: return '暂不支持该平台';
             }
             // 检查是否登录
@@ -294,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 {
@@ -509,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(' ')}`);
@@ -1217,22 +1176,10 @@ class ComRegister {
                             const liveEndMsg = this.config.customLiveEnd
                                 .replace('-name', username)
                                 .replace('-time', await ctx.gi.getTimeDifference(liveTime));
-                            // 获取头像并缩放
-                            let resizedImage;
-                            // Jimp无法处理Webp格式，直接跳过
-                            try {
-                                resizedImage = await jimp_1.Jimp.read(userface).then(async (image) => {
-                                    return await image.resize({ w: 100, h: 100 }).getBuffer(jimp_1.JimpMime.png);
-                                });
-                            }
-                            catch (e) {
-                                if (e.message === 'Unsupported MIME type: image/webp')
-                                    console.log('主播使用的是webp格式头像，无法进行渲染');
-                                else
-                                    console.log(e);
-                            }
-                            // 发送下播通知
-                            await this.sendMsg(guildId, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [resizedImage && koishi_1.h.image(resizedImage, 'image/png'), " ", liveEndMsg] }));
+                            // 更改直播时长
+                            data.live_time = liveTime;
+                            // 发送@全体成员通知
+                            await sendLiveNotifyCard(data, LiveType.StopBroadcast, liveEndMsg);
                         }
                         // 未进循环，还未开播，继续循环
                         break;
@@ -1370,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);
@@ -1397,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(' ');
             /* 判断数据库是否被篡改 */
@@ -1448,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/lib/generateImg.js

@@ -44,14 +44,7 @@ class GenerateImg extends koishi_1.Service {
         super(ctx, 'gi');
         this.giConfig = config;
     }
-    /* protected start(): void | Promise<void> {
-        this.logger.info('工作中');
-    }
-
-    protected stop(): void | Promise<void> {
-        this.logger.info('已停止工作')
-    } */
-    async generateLiveImg(data, username, userface, liveStatus /*0未开播 1刚开播 2已开播 */) {
+    async generateLiveImg(data, username, userface, liveStatus /*0未开播 1刚开播 2已开播 3停止直播*/) {
         const [titleStatus, liveTime, cover] = await this.getLiveStatus(data.live_time, liveStatus);
         // 加载字体
         const fontURL = (0, url_1.pathToFileURL)((0, path_1.resolve)(__dirname, 'font/HYZhengYuan-75W.ttf'));
@@ -1437,6 +1430,12 @@ class GenerateImg extends koishi_1.Service {
                 cover = false;
                 break;
             }
+            case 3: {
+                titleStatus = '下播啦';
+                liveTime = `直播时长：${await this.getTimeDifference(time)}`;
+                cover = true;
+                break;
+            }
         }
         return [titleStatus, liveTime, cover];
     }

package/lib/index.d.ts

@@ -9,7 +9,7 @@ declare module 'koishi' {
 export interface Config {
     require: {};
     key: string;
-    platform: 'qq' | 'qqguild' | 'onebot' | 'red' | 'telegram' | 'satori' | 'chronocat' | 'lark';
+    platform: 'qq' | 'qqguild' | 'onebot' | 'discord' | 'red' | 'telegram' | 'satori' | 'chronocat' | 'lark';
     master: {};
     basicSettings: {};
     unlockSubLimits: boolean;

package/lib/index.js

@@ -57,10 +57,10 @@ exports.Config = koishi_1.Schema.object({
         .role('secret')
         .required()
         .description('请输入一个32位小写字母的十六进制密钥（例如：9b8db7ae562b9864efefe06289cc5530），使用此密钥将你的B站登录信息存储在数据库中，请一定保存好此密钥。如果你忘记了此密钥，必须重新登录。你可以自行生成，或到这个网站生成：https://www.sexauth.com/'),
-    platform: koishi_1.Schema.union(['qq', 'qqguild', 'onebot', 'red', 'telegram', 'satori', 'chronocat', 'lark'])
+    platform: koishi_1.Schema.union(['qq', 'qqguild', 'onebot', 'discord', 'red', 'telegram', 'satori', 'chronocat', 'lark'])
         .role('')
         .required()
-        .description('请选择你的机器人平台，目前支持QQ、QQ群、OneBot、RedBot、Telegram、Satori、ChronoCat、Lark。从2.0版本开始，只能在一个平台下使用本插件'),
+        .description('请选择你的机器人平台，目前支持QQ、QQ群、OneBot、Discord、RedBot、Telegram、Satori、ChronoCat、Lark。从2.0版本开始，只能在一个平台下使用本插件'),
     master: koishi_1.Schema.intersect([
         koishi_1.Schema.object({
             enable: koishi_1.Schema.boolean()

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-bilibili-notify",
   "description": "Koishi bilibili notify plugin",
-  "version": "2.0.0-alpha.1",
+  "version": "2.0.0-alpha.3",
   "contributors": [
     "Akokko <admin@akokko.com>"
   ],
@@ -29,7 +29,6 @@
   "dependencies": {
     "axios": "^1.7.9",
     "axios-cookiejar-support": "^5.0.5",
-    "jimp": "^1.6.0",
     "jsdom": "^24.1.3",
     "luxon": "^3.5.0",
     "md5": "^2.3.0",

package/readme.md

@@ -178,7 +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
 
 ## 交流群