koishi-plugin-bilibili-notify 1.2.12-alpha.3 → 1.2.13

package/lib/biliAPI.d.ts

@@ -17,7 +17,6 @@ declare class BiliAPI extends Service {
     loginInfoIsLoaded: boolean;
     constructor(ctx: Context, config: BiliAPI.Config);
     protected start(): void | Promise<void>;
-    protected stop(): void | Promise<void>;
     getServerUTCTime(): Promise<number>;
     getTimeNow(): Promise<any>;
     getUserSpaceDynamic(mid: string): Promise<any>;

package/lib/biliAPI.js

@@ -41,11 +41,11 @@ class BiliAPI extends koishi_1.Service {
         // 从数据库加载cookies
         this.loadCookiesFromDatabase();
         // 输出日志
-        this.logger.info('工作中');
-    }
-    stop() {
-        this.logger.info('已停止工作');
+        // this.logger.info('工作中')
     }
+    /* protected stop(): void | Promise<void> {
+        this.logger.info('已停止工作')
+    } */
     async getServerUTCTime() {
         try {
             const { data } = await this.client.get(GET_SERVER_UTC_TIME);

package/lib/comRegister.d.ts

@@ -31,6 +31,7 @@ declare class ComRegister {
     sendPrivateMsgAndRebootService(ctx: Context, bot: Bot<Context>, content: string): Promise<void>;
     sendMsg(ctx: Context, targets: Array<string>, bot: Bot<Context>, content: any): Promise<void>;
     dynamicDetect(ctx: Context, bot: Bot<Context>, uid: string, guildId: Array<string>): () => Promise<void>;
+    debug_dynamicDetect(ctx: Context, bot: Bot<Context>, uid: string, guildId: Array<string>): () => Promise<void>;
     liveDetect(ctx: Context, bot: Bot<Context>, roomId: string, guildId: Array<string>): () => Promise<void>;
     subShow(): string;
     checkIfNeedSub(comNeed: boolean, subType: string, session: Session, data?: any): Promise<boolean>;
@@ -63,6 +64,7 @@ declare namespace ComRegister {
             regex: string;
             keywords: Array<string>;
         };
+        dynamicDebugMode: boolean;
     }
     const Config: Schema<Config>;
 }

package/lib/comRegister.js

@@ -38,12 +38,12 @@ class ComRegister {
     chronocatBot;
     constructor(ctx, config) {
         this.logger = ctx.logger('cr');
-        ctx.on('ready', () => {
+        /* ctx.on('ready', () => {
             this.logger.info('工作中');
-        });
+        })
         ctx.on('dispose', () => {
             this.logger.info('已停止工作');
-        });
+        }) */
         this.config = config;
         // 拿到各类机器人
         ctx.bots.forEach(bot => {
@@ -553,7 +553,13 @@ class ComRegister {
             // 获得对应bot
             const bot = this.getTheCorrespondingBotBasedOnTheSession(session);
             // 开始循环检测
-            const dispose = ctx.setInterval(this.dynamicDetect(ctx, bot, uid, guildId), config.dynamicLoopTime * 1000);
+            let dispose;
+            if (this.config.dynamicDebugMode) {
+                dispose = ctx.setInterval(this.debug_dynamicDetect(ctx, bot, uid, guildId), config.dynamicLoopTime * 1000);
+            }
+            else {
+                dispose = ctx.setInterval(this.dynamicDetect(ctx, bot, uid, guildId), config.dynamicLoopTime * 1000);
+            }
             // 将销毁函数保存到订阅管理对象
             this.subManager[index].dynamicDispose = dispose;
         });
@@ -822,6 +828,162 @@ class ComRegister {
                         // 结束循环
                         break;
                     }
+                    case 4101128: { // 获取动态信息错误
+                        // 输出日志
+                        this.logger.error('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message);
+                        // 发送私聊消息
+                        await this.sendPrivateMsg(bot, '获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
+                        // 结束循环
+                        break;
+                    }
+                    default: { // 未知错误
+                        // 发送私聊消息
+                        await this.sendPrivateMsg(bot, '获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
+                        // 取消订阅
+                        this.unsubAll(ctx, bot, uid);
+                        // 结束循环
+                        break;
+                    }
+                }
+            }
+            // 获取数据内容
+            const items = content.data.items;
+            // 定义方法：更新时间点为最新发布动态的发布时间
+            const updatePoint = (num) => {
+                switch (num) {
+                    case 1: {
+                        if (items[0].modules.module_tag) { // 存在置顶动态
+                            timePoint = items[num].modules.module_author.pub_ts;
+                        }
+                        break;
+                    }
+                    case 0: timePoint = items[num].modules.module_author.pub_ts;
+                }
+            };
+            // 发送请求 默认只查看配置文件规定数量的数据
+            for (let num = this.config.dynamicCheckNumber - 1; num >= 0; num--) {
+                // 没有动态内容则直接跳过
+                if (!items[num])
+                    continue;
+                // 寻找发布时间比时间点更晚的动态
+                if (items[num].modules.module_author.pub_ts > timePoint) {
+                    // 定义变量
+                    let pic;
+                    let buffer;
+                    // 从动态数据中取出UP主名称和动态ID
+                    const upName = content.data.items[num].modules.module_author.name;
+                    const dynamicId = content.data.items[num].id_str;
+                    // 推送该条动态
+                    let attempts = 3;
+                    for (let i = 0; i < attempts; i++) {
+                        // 获取动态推送图片
+                        try {
+                            // 渲染图片
+                            const { pic: gimgPic, buffer: gimgBuffer } = await ctx.gi.generateDynamicImg(items[num]);
+                            // 赋值
+                            pic = gimgPic;
+                            buffer = gimgBuffer;
+                            // 成功则跳出循环
+                            break;
+                        }
+                        catch (e) {
+                            // 直播开播动态，不做处理
+                            if (e.message === '直播开播动态，不做处理')
+                                return updatePoint(num);
+                            if (e.message === '出现关键词，屏蔽该动态') {
+                                // 如果需要发送才发送
+                                this.config.filter.notify && await this.sendMsg(ctx, guildId, bot, `${upName}发布了一条含有屏蔽关键字的动态`);
+                                return updatePoint(num);
+                            }
+                            if (e.message === '已屏蔽转发动态') {
+                                this.config.filter.notify && await this.sendMsg(ctx, guildId, bot, `${upName}发布了一条转发动态，已屏蔽`);
+                                return updatePoint(num);
+                            }
+                            // 未知错误
+                            if (i === attempts - 1) {
+                                this.logger.error('dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：' + e.message);
+                                // 发送私聊消息并重启服务
+                                return await this.sendPrivateMsgAndRebootService(ctx, bot, '插件可能出现某些未知错误，请尝试重启插件，如果仍然发生该错误，请带着日志向作者反馈');
+                            }
+                        }
+                    }
+                    // 判断是否需要发送URL
+                    const dUrl = this.config.dynamicUrl ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}` : '';
+                    // 如果pic存在，则直接返回pic
+                    if (pic) {
+                        this.logger.info('推送动态中，使用render模式');
+                        // pic存在，使用的是render模式
+                        await this.sendMsg(ctx, guildId, bot, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
+                    }
+                    else if (buffer) {
+                        this.logger.info('推送动态中，使用page模式');
+                        // pic不存在，说明使用的是page模式
+                        await this.sendMsg(ctx, guildId, bot, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), dUrl] }));
+                    }
+                    else {
+                        this.logger.info(items[num].modules.module_author.name + '发布了一条动态，但是推送失败');
+                    }
+                    // 更新时间点
+                    updatePoint(num);
+                }
+            }
+        };
+    }
+    debug_dynamicDetect(ctx, bot, uid, guildId) {
+        let firstSubscription = true;
+        let timePoint;
+        return async () => {
+            this.logger.info('动态监测开始');
+            // 第一次订阅判断
+            if (firstSubscription) {
+                this.logger.info('第一次订阅');
+                // 设置第一次的时间点
+                timePoint = ctx.ba.getTimeOfUTC8();
+                // 设置第一次为false
+                firstSubscription = false;
+                return;
+            }
+            this.logger.info('获取动态信息中');
+            // 获取用户空间动态数据
+            let content;
+            try {
+                content = await ctx.ba.getUserSpaceDynamic(uid);
+            }
+            catch (e) {
+                return this.logger.error('dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：' + e.message);
+            }
+            this.logger.info('判断动态信息是否正确');
+            // 判断是否出现其他问题
+            if (content.code !== 0) {
+                switch (content.code) {
+                    case -101: { // 账号未登录
+                        // 输出日志
+                        this.logger.error('账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
+                        // 发送私聊消息
+                        await this.sendPrivateMsg(bot, '账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
+                        // 停止服务
+                        await ctx.sm.disposePlugin();
+                        // 结束循环
+                        break;
+                    }
+                    case -352: { // 风控
+                        // 输出日志
+                        this.logger.error('账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
+                        // 发送私聊消息
+                        await this.sendPrivateMsg(bot, '账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
+                        // 停止服务
+                        await ctx.sm.disposePlugin();
+                        // 结束循环
+                        break;
+                    }
+                    case 4101128: { // 获取动态信息错误
+                        // 输出日志
+                        this.logger.error('获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message);
+                        // 发送私聊消息
+                        await this.sendPrivateMsg(bot, '获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
+                        // 结束循环
+                        break;
+                    }
                     default: { // 未知错误
                         // 发送私聊消息
                         await this.sendPrivateMsg(bot, '获取动态信息错误，错误码为：' + content.code + '，错误为：' + content.message); // 未知错误
@@ -834,6 +996,10 @@ class ComRegister {
             }
             // 获取数据内容
             const items = content.data.items;
+            this.logger.info('获取到的动态信息：');
+            items.forEach(element => {
+                this.logger.info(element.basic.rid_str);
+            });
             // 定义方法：更新时间点为最新发布动态的发布时间
             const updatePoint = (num) => {
                 switch (num) {
@@ -853,6 +1019,7 @@ class ComRegister {
                     continue;
                 // 寻找发布时间比时间点更晚的动态
                 if (items[num].modules.module_author.pub_ts > timePoint) {
+                    this.logger.info('即将推送的动态信息：' + items[num].basic.rid_str);
                     // 定义变量
                     let pic;
                     let buffer;
@@ -861,6 +1028,7 @@ class ComRegister {
                     const dynamicId = content.data.items[num].id_str;
                     // 推送该条动态
                     let attempts = 3;
+                    this.logger.info('尝试渲染推送图片');
                     for (let i = 0; i < attempts; i++) {
                         // 获取动态推送图片
                         try {
@@ -893,6 +1061,7 @@ class ComRegister {
                             }
                         }
                     }
+                    this.logger.info('尝试推送动态卡片');
                     // 判断是否需要发送URL
                     const dUrl = this.config.dynamicUrl ? `${upName}发布了一条动态：https://t.bilibili.com/${dynamicId}` : '';
                     // 如果pic存在，则直接返回pic
@@ -911,6 +1080,7 @@ class ComRegister {
                     }
                     // 更新时间点
                     updatePoint(num);
+                    this.logger.info('推送动态完成');
                 }
             }
         };
@@ -1330,8 +1500,14 @@ class ComRegister {
             };
             // 判断需要订阅的服务
             if (sub.dynamic) { // 需要订阅动态
+                let dispose;
                 // 开始循环检测
-                const dispose = ctx.setInterval(this.dynamicDetect(ctx, bot, sub.uid, targetArr), this.config.dynamicLoopTime * 1000);
+                if (this.config.dynamicDebugMode) {
+                    dispose = ctx.setInterval(this.debug_dynamicDetect(ctx, bot, sub.uid, targetArr), this.config.dynamicLoopTime * 1000);
+                }
+                else {
+                    dispose = ctx.setInterval(this.dynamicDetect(ctx, bot, sub.uid, targetArr), this.config.dynamicLoopTime * 1000);
+                }
                 // 保存销毁函数
                 subManagerItem.dynamicDispose = dispose;
             }
@@ -1461,6 +1637,7 @@ class ComRegister {
             regex: koishi_1.Schema.string(),
             keywords: koishi_1.Schema.array(String),
         }),
+        dynamicDebugMode: koishi_1.Schema.boolean().required()
     });
 })(ComRegister || (ComRegister = {}));
 exports.default = ComRegister;

package/lib/generateImg.d.ts

@@ -8,8 +8,6 @@ declare class GenerateImg extends Service {
     static inject: string[];
     giConfig: GenerateImg.Config;
     constructor(ctx: Context, config: GenerateImg.Config);
-    protected start(): void | Promise<void>;
-    protected stop(): void | Promise<void>;
     generateLiveImg(data: any, userData: any, liveStatus: number): Promise<{
         buffer: Buffer;
         pic?: undefined;

package/lib/generateImg.js

@@ -43,12 +43,13 @@ class GenerateImg extends koishi_1.Service {
         super(ctx, 'gi');
         this.giConfig = config;
     }
-    start() {
+    /* protected start(): void | Promise<void> {
         this.logger.info('工作中');
     }
-    stop() {
-        this.logger.info('已停止工作');
-    }
+
+    protected stop(): void | Promise<void> {
+        this.logger.info('已停止工作')
+    } */
     async generateLiveImg(data, userData, liveStatus /*0未开播 1刚开播 2已开播 */) {
         const [titleStatus, liveTime, cover] = await this.getLiveStatus(data.live_time, liveStatus);
         // 加载字体

package/lib/index.d.ts

@@ -30,6 +30,8 @@ export interface Config {
     enableLargeFont: boolean;
     font: string;
     filter: {};
+    debug: {};
+    dynamicDebugMode: boolean;
 }
 export declare const Config: Schema<Config>;
 declare class ServerManager extends Service {

package/lib/index.js

@@ -150,6 +150,11 @@ exports.Config = koishi_1.Schema.object({
             koishi_1.Schema.object({})
         ])
     ]),
+    debug: koishi_1.Schema.object({}).description('调试设置'),
+    dynamicDebugMode: koishi_1.Schema.boolean()
+        .default(false)
+        .description('动态调试模式，开启后会在控制台输出动态推送的详细信息，用于调试')
+        .experimental()
 });
 class ServerManager extends koishi_1.Service {
     // 服务
@@ -256,7 +261,8 @@ class ServerManager extends koishi_1.Service {
                 dynamicCheckNumber: globalConfig.dynamicCheckNumber,
                 dynamicLoopTime: this.dynamicLoopTime,
                 dynamicUrl: globalConfig.dynamicUrl,
-                filter: globalConfig.filter
+                filter: globalConfig.filter,
+                dynamicDebugMode: globalConfig.dynamicDebugMode
             });
             // 添加服务
             this.servers.push(ba);

package/lib/wbi.d.ts

@@ -8,8 +8,6 @@ declare class Wbi extends Service {
     wbiConfig: Wbi.Config;
     mixinKeyEncTab: number[];
     constructor(ctx: Context, config: Wbi.Config);
-    protected start(): void | Promise<void>;
-    protected stop(): void | Promise<void>;
     getMixinKey: (orig: any) => string;
     encWbi(params: any, img_key: any, sub_key: any): string;
     getWbiKeys(): Promise<{

package/lib/wbi.js

@@ -18,12 +18,13 @@ class Wbi extends koishi_1.Service {
         super(ctx, 'wbi');
         this.wbiConfig = config;
     }
-    start() {
-        this.logger.info('工作中');
-    }
-    stop() {
-        this.logger.info('已停止工作');
+    /* protected start(): void | Promise<void> {
+        this.logger.info('工作中')
     }
+
+    protected stop(): void | Promise<void> {
+        this.logger.info('已停止工作')
+    } */
     // 对 imgKey 和 subKey 进行字符顺序打乱编码
     getMixinKey = (orig) => this.mixinKeyEncTab.map(n => orig[n]).join('').slice(0, 32);
     // 为请求参数进行 wbi 签名

package/package.json

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

package/readme.md

@@ -155,6 +155,8 @@
 - ver 1.2.12-alpha.1 删除直播推送时的多余空格
 - ver 1.2.12-alpha.2 尝试修复版本 `1.2.12-alpha.0 账号出现某些问题后，不会再清除订阅信息` 仍然会清除订阅信息的bug
 - ver 1.2.12-alpha.3 尝试修复订阅时使用 `all` 报错的bug
+- ver 1.2.12 新增动态错误处理
+- ver 1.2.13 现已支持调试模式，目前支持对动态的调试。需要调试模式可在控制台中开启
 
 ## 交流群