koishi-plugin-bilibili-notify 2.0.0-alpha.14 → 2.0.0-alpha.16

package/lib/blive.d.ts

@@ -0,0 +1,9 @@
+import { Context, Logger } from "koishi";
+declare class BLive {
+    static inject: string[];
+    ctx: Context;
+    logger: Logger;
+    constructor(ctx: Context);
+    connectToLiveBroadcastRoom(roomId: string): void;
+}
+export default BLive;

package/lib/blive.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BLive {
+    // 必须服务
+    static inject = [''];
+    // 定义类属性
+    ctx;
+    logger;
+    // 构造函数
+    constructor(ctx) {
+        // 将Context赋值给类属性
+        this.ctx = ctx;
+        // 将logger赋值给类属性
+        this.logger = ctx.logger('bl');
+    }
+    // 定义方法
+    connectToLiveBroadcastRoom(roomId) {
+        console.log(roomId);
+    }
+}
+exports.default = BLive;

package/lib/comRegister.d.ts

@@ -3,6 +3,8 @@ import { Notifier } from "@koishijs/plugin-notifier";
 import { LoginBili } from "./database";
 type ChannelIdArr = Array<{
     channelId: string;
+    dynamic: boolean;
+    live: boolean;
     atAll: boolean;
 }>;
 type TargetItem = {
@@ -36,6 +38,7 @@ declare class ComRegister {
     dynamicDispose: Function;
     sendMsgFunc: (bot: Bot<Context, any>, channelId: string, content: any) => Promise<void>;
     constructor(ctx: Context, config: ComRegister.Config);
+    init(ctx: Context, config: ComRegister.Config): Promise<void>;
     splitMultiPlatformStr(str: string): Target;
     getBot(ctx: Context, pf: string): Bot<Context, any>;
     sendPrivateMsg(content: string): Promise<void>;
@@ -53,7 +56,10 @@ declare class ComRegister {
         flag: boolean;
         msg: string;
     }>;
-    getSubFromDatabase(ctx: Context): Promise<void>;
+    loadSubFromConfig(ctx: Context, subs: ComRegister.Config["sub"]): Promise<void>;
+    loadSubFromDatabase(ctx: Context): Promise<void>;
+    checkIfDynamicDetectIsNeeded(ctx: Context): void;
+    enableDynamicDetect(ctx: Context): void;
     unsubSingle(ctx: Context, id: string, type: number): string;
     checkIfUserIsTheLastOneWhoSubDyn(): void;
     unsubAll(ctx: Context, uid: string): void;
@@ -61,6 +67,20 @@ declare class ComRegister {
 }
 declare namespace ComRegister {
     interface Config {
+        sub: Array<{
+            uid: string;
+            dynamic: boolean;
+            live: boolean;
+            target: Array<{
+                channelIdArr: Array<{
+                    channelId: string;
+                    dynamic: boolean;
+                    live: boolean;
+                    atAll: boolean;
+                }>;
+                platform: string;
+            }>;
+        }>;
         master: {
             enable: boolean;
             platform: string;

package/lib/comRegister.js

@@ -37,56 +37,9 @@ class ComRegister {
     sendMsgFunc;
     // 构造函数
     constructor(ctx, config) {
-        this.logger = ctx.logger('cr');
-        this.config = config;
-        // 拿到私人机器人实例
-        this.privateBot = ctx.bots.find(bot => bot.platform === config.master.platform);
-        if (!this.privateBot) {
-            ctx.notifier.create({
-                content: '您未配置私人机器人，将无法向您推送机器人状态！'
-            });
-            this.logger.error('您未配置私人机器人，将无法向您推送机器人状态！');
-        }
-        // 检查登录数据库是否有数据
-        ctx.database.get('loginBili', 1, ['dynamic_group_id']).then(data => this.loginDBData = data[0]);
-        // 从数据库获取订阅
-        this.getSubFromDatabase(ctx);
-        // 判断消息发送方式
-        if (config.automaticResend) {
-            this.sendMsgFunc = async (bot, channelId, content) => {
-                // 多次尝试发送消息
-                const attempts = 3;
-                for (let i = 0; i < attempts; i++) {
-                    try {
-                        // 发送消息
-                        await bot.sendMessage(channelId, content);
-                        // 防止消息发送速度过快被忽略
-                        await ctx.sleep(500);
-                        // 成功发送消息，跳出循环
-                        break;
-                    }
-                    catch (e) {
-                        if (i === attempts - 1) { // 已尝试三次
-                            this.logger.error(`发送群组ID:${channelId}消息失败！原因: ` + e.message);
-                            console.log(e);
-                            this.sendPrivateMsg(`发送群组ID:${channelId}消息失败，请查看日志`);
-                        }
-                    }
-                }
-            };
-        }
-        else {
-            this.sendMsgFunc = async (bot, guild, content) => {
-                try {
-                    // 发送消息
-                    await bot.sendMessage(guild, content);
-                }
-                catch (e) {
-                    this.logger.error(`发送群组ID:${guild}消息失败！原因: ` + e.message);
-                    await this.sendPrivateMsg(`发送群组ID:${guild}消息失败，请查看日志`);
-                }
-            };
-        }
+        // 初始化
+        this.init(ctx, config);
+        // 注册指令
         const statusCom = ctx.command('status', '插件状态相关指令', { permissions: ['authority:5'] });
         statusCom.subcommand('.dyn', '查看动态监测运行状态')
             .usage('查看动态监测运行状态')
@@ -198,7 +151,7 @@ class ComRegister {
                         // 销毁定时器
                         this.loginTimer();
                         // 订阅之前的订阅
-                        await this.getSubFromDatabase(ctx);
+                        await this.loadSubFromDatabase(ctx);
                         // 清除控制台通知
                         ctx.ba.disposeNotifier();
                         // 发送成功登录推送
@@ -265,12 +218,7 @@ class ComRegister {
                     // id--
                     this.num--;
                     // 判断是否还有动态订阅
-                    if (this.dynamicDispose && !this.subManager.find((sub) => sub.dynamic === true)) { // 没有动态订阅
-                        // 将动态检测关闭
-                        this.dynamicDispose();
-                        // 将动态监测置为空
-                        this.dynamicDispose = null;
-                    }
+                    this.checkIfUserIsTheLastOneWhoSubDyn();
                     // 发送成功通知
                     await session.send('已取消订阅该用户');
                     // 更新控制台提示
@@ -328,6 +276,8 @@ class ComRegister {
                 groupId.forEach(group => {
                     channelIdArr.push({
                         channelId: group,
+                        dynamic: true,
+                        live: true,
                         atAll: options.atAll
                     });
                 });
@@ -387,7 +337,7 @@ class ComRegister {
                                 // 判断targetArr是否为空
                                 if (target.length === 0) {
                                     // 为空则默认为当前环境
-                                    target = [{ channelIdArr: [{ channelId: session.event.channel.id, atAll: options.atAll }], platform: session.event.platform }];
+                                    target = [{ channelIdArr: [{ channelId: session.event.channel.id, dynamic: true, live: true, atAll: options.atAll }], platform: session.event.platform }];
                                     // 没有满足条件的群组或频道
                                     await session.send('没有满足条件的群组或频道，默认订阅到当前聊天环境');
                                 }
@@ -398,7 +348,7 @@ class ComRegister {
                         }
                         else {
                             // 未填写群号或频道号，默认为当前环境
-                            target = [{ channelIdArr: [{ channelId: session.event.channel.id, atAll: options.atAll }], platform: session.event.platform }];
+                            target = [{ channelIdArr: [{ channelId: session.event.channel.id, dynamic: true, live: true, atAll: options.atAll }], platform: session.event.platform }];
                             // 发送提示消息
                             await session.send('没有填写群号或频道号，默认订阅到当前聊天环境');
                         }
@@ -406,7 +356,7 @@ class ComRegister {
                 }
                 else {
                     // 用户直接订阅，将当前环境赋值给target
-                    target = [{ channelIdArr: [{ channelId: session.event.channel.id, atAll: options.atAll }], platform: session.event.platform }];
+                    target = [{ channelIdArr: [{ channelId: session.event.channel.id, dynamic: true, live: true, atAll: options.atAll }], platform: session.event.platform }];
                 }
             }
             // 定义外围变量                
@@ -489,13 +439,7 @@ class ComRegister {
             if (dynamicMsg) {
                 // 判断是否开启动态监测
                 if (!this.dynamicDispose) {
-                    // 开启动态监测
-                    if (this.config.dynamicDebugMode) {
-                        this.dynamicDispose = ctx.setInterval(this.debug_dynamicDetect(ctx), config.dynamicLoopTime * 1000);
-                    }
-                    else {
-                        this.dynamicDispose = ctx.setInterval(this.dynamicDetect(ctx), config.dynamicLoopTime * 1000);
-                    }
+                    this.enableDynamicDetect(ctx);
                 }
                 // 发送订阅消息通知
                 await session.send(`订阅${userData.info.uname}动态通知`);
@@ -580,12 +524,72 @@ class ComRegister {
             await session.send('已发送消息，如未收到则说明您的机器人不支持发送私聊消息或您的信息填写有误');
         });
     }
+    async init(ctx, config) {
+        // 设置logger
+        this.logger = ctx.logger('cr');
+        // 将config设置给类属性
+        this.config = config;
+        // 拿到私人机器人实例
+        this.privateBot = ctx.bots.find(bot => bot.platform === config.master.platform);
+        if (!this.privateBot) {
+            ctx.notifier.create({
+                content: '您未配置私人机器人，将无法向您推送机器人状态！'
+            });
+            this.logger.error('您未配置私人机器人，将无法向您推送机器人状态！');
+        }
+        // 检查登录数据库是否有数据
+        this.loginDBData = (await ctx.database.get('loginBili', 1, ['dynamic_group_id']))[0];
+        // 从配置获取订阅
+        config.sub && await this.loadSubFromConfig(ctx, config.sub);
+        // 从数据库获取订阅
+        await this.loadSubFromDatabase(ctx);
+        // 判断消息发送方式
+        if (config.automaticResend) {
+            this.sendMsgFunc = async (bot, channelId, content) => {
+                // 多次尝试发送消息
+                const attempts = 3;
+                for (let i = 0; i < attempts; i++) {
+                    try {
+                        // 发送消息
+                        await bot.sendMessage(channelId, content);
+                        // 防止消息发送速度过快被忽略
+                        await ctx.sleep(500);
+                        // 成功发送消息，跳出循环
+                        break;
+                    }
+                    catch (e) {
+                        if (i === attempts - 1) { // 已尝试三次
+                            this.logger.error(`发送群组ID:${channelId}消息失败！原因: ` + e.message);
+                            console.log(e);
+                            this.sendPrivateMsg(`发送群组ID:${channelId}消息失败，请查看日志`);
+                        }
+                    }
+                }
+            };
+        }
+        else {
+            this.sendMsgFunc = async (bot, guild, content) => {
+                try {
+                    // 发送消息
+                    await bot.sendMessage(guild, content);
+                }
+                catch (e) {
+                    this.logger.error(`发送群组ID:${guild}消息失败！原因: ` + e.message);
+                    await this.sendPrivateMsg(`发送群组ID:${guild}消息失败，请查看日志`);
+                }
+            };
+        }
+        // 检查是否需要动态监测
+        this.checkIfDynamicDetectIsNeeded(ctx);
+        // 在控制台中显示订阅对象
+        this.updateSubNotifier(ctx);
+    }
     splitMultiPlatformStr(str) {
         return str.split(';').map(cv => cv.split('.')).map(([idStr, platform]) => {
             const channelIdArr = idStr.split(',').map(id => {
                 const atAll = /@$/.test(id); // 使用正则表达式检查 id 是否以 @ 结尾
                 const channelId = atAll ? id.slice(0, -1) : id; // 去除末尾的 @
-                return { channelId, atAll };
+                return { channelId, dynamic: true, live: true, atAll };
             });
             return { channelIdArr, platform };
         });
@@ -656,22 +660,33 @@ class ComRegister {
             if (target.channelIdArr[0].channelId === 'all') {
                 // 获取所有guild
                 for (const guild of (await bot.getGuildList()).data) {
-                    sendArr.push({ channelId: guild.id, atAll: target.channelIdArr[0].atAll });
+                    sendArr.push({
+                        channelId: guild.id,
+                        dynamic: target.channelIdArr[0].dynamic,
+                        live: target.channelIdArr[0].live,
+                        atAll: target.channelIdArr[0].atAll
+                    });
                 }
             }
             else {
                 sendArr = target.channelIdArr;
             }
-            // 循环给每个群组发送
+            // 判断是否是直播推送，如果是则需要进一步判断是否需要艾特群体成员
             if (live) {
-                // 直播推送，需要判断是否为
+                // 直播开播推送，判断是否需要艾特全体成员
                 for (const channel of sendArr) {
-                    await this.sendMsgFunc(bot, channel.channelId, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [content, channel.atAll && (0, jsx_runtime_1.jsx)("at", { type: "all" })] }));
+                    // 判断是否需要推送直播消息
+                    if (channel.live) {
+                        await this.sendMsgFunc(bot, channel.channelId, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [content, channel.atAll && (0, jsx_runtime_1.jsx)("at", { type: "all" })] }));
+                    }
                 }
             }
             else {
                 for (const channel of sendArr) {
-                    await this.sendMsgFunc(bot, channel.channelId, content);
+                    // 判断是否需要推送动态消息和直播消息
+                    if (channel.dynamic || channel.live) {
+                        await this.sendMsgFunc(bot, channel.channelId, content);
+                    }
                 }
             }
         }
@@ -1401,7 +1416,69 @@ class ComRegister {
         // 订阅成功
         return { flag: true, msg: '用户订阅成功' };
     }
-    async getSubFromDatabase(ctx) {
+    async loadSubFromConfig(ctx, subs) {
+        for (const sub of subs) {
+            // 定义Data
+            let data;
+            // 定义直播销毁函数
+            let liveDispose;
+            // 判断是否需要订阅直播
+            if (sub.live) {
+                // 获取用户信息
+                let content;
+                // 设置重试次数
+                const attempts = 3;
+                for (let i = 0; i < attempts; i++) {
+                    try {
+                        // 获取用户信息
+                        content = await ctx.ba.getUserInfo(sub.uid);
+                        // 成功则跳出循环
+                        break;
+                    }
+                    catch (e) {
+                        this.logger.error('getSubFromDatabase() getUserInfo() 发生了错误，错误为：' + e.message);
+                        if (i === attempts - 1) { // 已尝试三次
+                            // 发送私聊消息并重启服务
+                            return await this.sendPrivateMsgAndStopService(ctx);
+                        }
+                    }
+                }
+                // 获取data
+                data = content.data;
+                // 检查roomid是否存在
+                if (!data.live_room) {
+                    // 用户没有开通直播间，无法订阅直播
+                    sub.live = false;
+                    // 发送提示
+                    this.logger.warn(`UID:${sub.uid} 用户没有开通直播间，无法订阅直播！`);
+                }
+                // 判断是否订阅直播
+                if (sub.live) {
+                    // 订阅直播
+                    liveDispose = ctx.setInterval(() => {
+                        this.liveDetect(ctx, data.live_room.room_id, sub.target);
+                    }, this.config.liveLoopTime * 1000);
+                }
+            }
+            // 在B站中订阅该对象
+            const subInfo = await this.subUserInBili(ctx, sub.uid);
+            // 判断订阅是否成功
+            if (!subInfo.flag)
+                this.logger.warn(subInfo.msg);
+            // 将该订阅添加到sm中
+            this.subManager.push({
+                id: +sub.uid,
+                uid: sub.uid,
+                roomId: sub.live ? data.live_room.roomid : '',
+                target: sub.target,
+                platform: '',
+                live: sub.live,
+                dynamic: sub.dynamic,
+                liveDispose
+            });
+        }
+    }
+    async loadSubFromDatabase(ctx) {
         // 判断登录信息是否已加载完毕
         await this.checkIfLoginInfoIsLoaded(ctx);
         // 如果未登录，则直接返回
@@ -1499,6 +1576,7 @@ class ComRegister {
                 this.logger.info(`UID:${sub.uid} 房间号被篡改，自动取消订阅`);
                 // Send msg
                 await this.sendPrivateMsg(`UID:${sub.uid} 房间号被篡改，自动取消订阅`);
+                // 直接返回
                 return;
             }
             // 构建订阅对象
@@ -1516,11 +1594,12 @@ class ComRegister {
             if (sub.live) {
                 // 判断订阅直播数是否超过限制
                 if (!this.config.unlockSubLimits && liveSubNum >= 3) {
+                    // 将live改为false
                     subManagerItem.live = false;
                     // log
                     this.logger.warn(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
                     // 发送错误消息
-                    this.sendPrivateMsg(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
+                    await this.sendPrivateMsg(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
                 }
                 else {
                     // 直播订阅数+1
@@ -1534,18 +1613,20 @@ class ComRegister {
             // 保存新订阅对象
             this.subManager.push(subManagerItem);
         }
+    }
+    checkIfDynamicDetectIsNeeded(ctx) {
         // 检查是否有订阅对象需要动态监测
-        if (this.subManager.some(sub => sub.dynamic)) {
-            // 开始动态监测
-            if (this.config.dynamicDebugMode) {
-                this.dynamicDispose = ctx.setInterval(this.debug_dynamicDetect(ctx), 10000);
-            }
-            else {
-                this.dynamicDispose = ctx.setInterval(this.dynamicDetect(ctx), 10000 /* this.config.dynamicLoopTime * 1000 */);
-            }
+        if (this.subManager.some(sub => sub.dynamic))
+            this.enableDynamicDetect(ctx);
+    }
+    enableDynamicDetect(ctx) {
+        // 开始动态监测
+        if (this.config.dynamicDebugMode) {
+            this.dynamicDispose = ctx.setInterval(this.debug_dynamicDetect(ctx), this.config.dynamicLoopTime * 1000);
+        }
+        else {
+            this.dynamicDispose = ctx.setInterval(this.dynamicDetect(ctx), this.config.dynamicLoopTime * 1000);
         }
-        // 在控制台中显示订阅对象
-        this.updateSubNotifier(ctx);
     }
     unsubSingle(ctx, id /* UID或RoomId */, type /* 0取消Live订阅，1取消Dynamic订阅 */) {
         // 定义返回消息
@@ -1628,7 +1709,7 @@ class ComRegister {
         }
     }
     checkIfUserIsTheLastOneWhoSubDyn() {
-        if (this.subManager.some(sub => sub.dynamic)) {
+        if (this.dynamicDispose && !this.subManager.some(sub => sub.dynamic)) {
             // 停止动态监测
             this.dynamicDispose();
             this.dynamicDispose = null;
@@ -1665,6 +1746,20 @@ class ComRegister {
 }
 (function (ComRegister) {
     ComRegister.Config = koishi_1.Schema.object({
+        sub: koishi_1.Schema.array(koishi_1.Schema.object({
+            uid: koishi_1.Schema.string().description('订阅用户UID'),
+            dynamic: koishi_1.Schema.boolean().description('是否订阅用户动态'),
+            live: koishi_1.Schema.boolean().description('是否订阅用户直播'),
+            target: koishi_1.Schema.array(koishi_1.Schema.object({
+                channelIdArr: koishi_1.Schema.array(koishi_1.Schema.object({
+                    channelId: koishi_1.Schema.string().description('频道/群组号'),
+                    dynamic: koishi_1.Schema.boolean().description('该频道/群组是否推送动态信息'),
+                    live: koishi_1.Schema.boolean().description('该频道/群组是否推送直播通知'),
+                    atAll: koishi_1.Schema.boolean().description('推送开播通知时是否艾特全体成员')
+                })).description('频道/群组信息'),
+                platform: koishi_1.Schema.string().description('推送平台')
+            })).description('订阅用户需要发送的频道/群组信息')
+        })).role('table').description('手动输入订阅信息，方便自定义订阅内容，这里的订阅内容不会存入数据库。uid: 订阅用户UID，dynamic: 是否需要订阅动态，live: 是否需要订阅直播'),
         master: koishi_1.Schema.object({
             enable: koishi_1.Schema.boolean(),
             platform: koishi_1.Schema.string(),

package/lib/index.d.ts

@@ -15,6 +15,21 @@ export interface Config {
     automaticResend: boolean;
     renderType: 'render' | 'page';
     userAgent: string;
+    subTitle: {};
+    sub: Array<{
+        uid: string;
+        dynamic: boolean;
+        live: boolean;
+        target: Array<{
+            channelIdArr: Array<{
+                channelId: string;
+                dynamic: boolean;
+                live: boolean;
+                atAll: boolean;
+            }>;
+            platform: string;
+        }>;
+    }>;
     dynamic: {};
     dynamicUrl: boolean;
     dynamicCheckNumber: number;

package/lib/index.js

@@ -93,6 +93,21 @@ exports.Config = koishi_1.Schema.object({
     userAgent: koishi_1.Schema.string()
         .required()
         .description('设置请求头User-Agen，请求出现-352时可以尝试修改，UA获取方法可参考：https://blog.csdn.net/qq_44503987/article/details/104929111'),
+    subTitle: koishi_1.Schema.object({}).description('手动订阅'),
+    sub: koishi_1.Schema.array(koishi_1.Schema.object({
+        uid: koishi_1.Schema.string().description('订阅用户UID'),
+        dynamic: koishi_1.Schema.boolean().description('是否订阅用户动态'),
+        live: koishi_1.Schema.boolean().description('是否订阅用户直播'),
+        target: koishi_1.Schema.array(koishi_1.Schema.object({
+            channelIdArr: koishi_1.Schema.array(koishi_1.Schema.object({
+                channelId: koishi_1.Schema.string().description('频道/群组号'),
+                dynamic: koishi_1.Schema.boolean().description('该频道/群组是否推送动态信息'),
+                live: koishi_1.Schema.boolean().description('该频道/群组是否推送直播通知'),
+                atAll: koishi_1.Schema.boolean().description('推送开播通知时是否艾特全体成员')
+            })).description('频道/群组信息'),
+            platform: koishi_1.Schema.string().description('推送平台')
+        })).description('订阅用户需要发送的频道/群组信息')
+    })).role('table').description('手动输入订阅信息，方便自定义订阅内容，这里的订阅内容不会存入数据库。uid: 订阅用户UID，dynamic: 是否需要订阅动态，live: 是否需要订阅直播'),
     dynamic: koishi_1.Schema.object({}).description('动态推送设置'),
     dynamicUrl: koishi_1.Schema.boolean()
         .default(false)
@@ -290,6 +305,7 @@ class ServerManager extends koishi_1.Service {
             });
             // CR = ComRegister
             const cr = this.ctx.plugin(comRegister_1.default, {
+                sub: globalConfig.sub,
                 master: globalConfig.master,
                 unlockSubLimits: globalConfig.unlockSubLimits,
                 automaticResend: globalConfig.automaticResend,

package/package.json

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

package/readme.md

@@ -201,6 +201,8 @@
 - ver 2.0.0-alpha.12 更改：开启艾特全体成员后，只有在开播时才艾特全体成员
 - ver 2.0.0-alpha.13 修复：无法对TG群组的特殊频道号进行订阅处理；提示 `您未配置对应平台的机器人，不能在该平台进行订阅操作` 仍进行订阅操作
 - ver 2.0.0-alpha.14 修复：订阅TG群组时提示输入无效
+- ver 2.0.0-alpha.15 新增：手动订阅功能  修复：一些潜在的bug
+- ver 2.0.0-alpha.16 优化：手动订阅功能
 
 ## 交流群