koishi-plugin-bilibili-notify 1.0.3 → 1.0.4-alpha.1

package/lib/biliAPI.d.ts

@@ -14,6 +14,7 @@ declare class BiliAPI extends Service {
     loginNotifier: Notifier;
     constructor(ctx: Context);
     protected start(): void | Promise<void>;
+    getServerUTCTime(): Promise<number>;
     getTimeNow(): Promise<any>;
     getUserSpaceDynamic(mid: string): Promise<any>;
     getCookieInfo(refreshToken: string): Promise<any>;
@@ -23,7 +24,6 @@ declare class BiliAPI extends Service {
     getLoginStatus(qrcodeKey: string): Promise<any>;
     getLiveRoomInfo(roomId: string): Promise<any>;
     getMasterInfo(mid: string): Promise<any>;
-    getUTCPlus8Time(): number;
     disposeNotifier(): void;
     createNewClient(): void;
     getCookies(): string;

package/lib/biliAPI.js

@@ -18,6 +18,7 @@ const GET_LOGIN_STATUS = 'https://passport.bilibili.com/x/passport-login/web/qrc
 const GET_LIVE_ROOM_INFO = 'https://api.live.bilibili.com/room/v1/Room/get_info';
 const GET_MASTER_INFO = 'https://api.live.bilibili.com/live_user/v1/Master/info';
 const GET_TIME_NOW = 'https://api.bilibili.com/x/report/click/now';
+const GET_SERVER_UTC_TIME = 'https://interface.bilibili.com/serverdate.js';
 class BiliAPI extends koishi_1.Service {
     static inject = ['database', 'wbi', 'notifier'];
     jar;
@@ -35,6 +36,23 @@ class BiliAPI extends koishi_1.Service {
         this.loadCookiesFromDatabase();
         this.logger.info('BiliAPI已被注册到Context中');
     }
+    async getServerUTCTime() {
+        try {
+            const { data } = await this.client.get(GET_SERVER_UTC_TIME);
+            const regex = /Date\.UTC\((.*?)\)/;
+            const match = data.match(regex);
+            if (match) {
+                const timestamp = new Function(`return Date.UTC(${match[1]})`)();
+                return timestamp / 1000;
+            }
+            else {
+                throw new Error('Failed to parse server time');
+            }
+        }
+        catch (e) {
+            throw new Error('网络异常，本次请求失败！');
+        }
+    }
     async getTimeNow() {
         try {
             const { data } = await this.client.get(GET_TIME_NOW);
@@ -118,12 +136,6 @@ class BiliAPI extends koishi_1.Service {
             throw new Error('网络异常，本次请求失败！');
         }
     }
-    getUTCPlus8Time() {
-        // 获取当前时间的UTC+8时间对象
-        const currentTimeInUtc8 = new Date().toLocaleString('en-US', { timeZone: 'Asia/Shanghai' });
-        // 将时间转换为Unix时间戳（单位：秒）
-        return Math.floor(new Date(currentTimeInUtc8).getTime() / 1000);
-    }
     disposeNotifier() { this.loginNotifier && this.loginNotifier.dispose(); }
     createNewClient() {
         this.jar = new tough_cookie_1.CookieJar();

package/lib/comRegister.d.ts

@@ -17,7 +17,7 @@ declare class ComRegister {
     qqBot: Bot<Context>;
     qqguildBot: Bot<Context>;
     constructor(ctx: Context, config: ComRegister.Config);
-    dynamicDetect(ctx: Context, bot: Bot<Context>, guildId: string, uid: string): () => Promise<void>;
+    dynamicDetect(ctx: Context, bot: Bot<Context>, guildId: string, uid: string): () => Promise<void | string[]>;
     liveDetect(ctx: Context, bot: Bot<Context>, guildId: string, roomId: string): () => Promise<void>;
     checkIfNeedSub(comNeed: boolean, subType: string, session: Session, data?: any): Promise<boolean>;
     getSubFromDatabase(ctx: Context): Promise<void>;

package/lib/comRegister.js

@@ -31,91 +31,80 @@ class ComRegister {
         this.qqguildBot = ctx.bots[ctx.bots.findIndex(bot => bot.platform === 'qqguild')];
         // 从数据库获取订阅
         this.getSubFromDatabase(ctx);
-        /* ctx.command('test', { hidden: true, permissions: ['authority:5'] })
+        ctx.command('test', { hidden: true, /* permissions: ['authority:5'] */ })
             .subcommand('.cookies')
             .usage('测试指令，用于测试从数据库读取cookies')
             .action(async () => {
-                await ctx.biliAPI.loadCookiesFromDatabase()
-            })
-
+            await ctx.biliAPI.loadCookiesFromDatabase();
+        });
         ctx.command('test')
             .subcommand('.my')
             .usage('测试指令，用于测试获取自己信息')
             .example('test.my')
             .action(async () => {
-                const content = await ctx.biliAPI.getMyselfInfo()
-                console.log(content);
-            })
-
+            const content = await ctx.biliAPI.getMyselfInfo();
+            console.log(content);
+        });
         ctx.command('test')
             .subcommand('.user <mid:string>')
             .usage('测试指令，用于测试获取用户信息')
             .example('test.user 用户UID')
             .action(async (_, mid) => {
-                const content = await ctx.biliAPI.getUserInfo(mid)
-                console.log(content);
-            })
-
+            const content = await ctx.biliAPI.getUserInfo(mid);
+            console.log(content);
+        });
         ctx.command('test')
             .subcommand('.time')
             .usage('测试时间接口')
             .example('test.time')
             .action(async () => {
-                const content = await ctx.biliAPI.getTimeNow()
-                console.log(content);
-            })
-
+            const content = await ctx.biliAPI.getTimeNow();
+            return content;
+        });
         ctx.command('test')
             .subcommand('.exist')
             .usage('测试写法')
             .example('test.exist')
             .action(async () => {
-                let num = 1;
-                console.log(num && `Hello World`);
-            })
-
+            let num = 1;
+            console.log(num && `Hello World`);
+        });
         ctx.command('test')
             .subcommand('.gimg <uid:string> <index:number>')
             .usage('测试图片生成')
             .example('test.gimg')
-            .action(async (_, uid, index) => {
-                // 获取用户空间动态数据
-                const { data } = await ctx.biliAPI.getUserSpaceDynamic(uid)
-                const [pic] = await ctx.gimg.generateDynamicImg(data.items[index])
-                return pic
-            })
-
+            .action(async ({ session }, uid, index) => {
+            // 获取用户空间动态数据
+            const { data } = await ctx.biliAPI.getUserSpaceDynamic(uid);
+            // 获取动态推送图片
+            const { pic, buffer } = await ctx.gimg.generateDynamicImg(data.items[index]);
+            // 如果pic存在，则直接返回pic
+            if (pic)
+                return pic;
+            // pic不存在，说明使用的是page模式
+            await session.send(koishi_1.h.image(buffer, 'image/png'));
+        });
         ctx.command('test')
             .subcommand('.group')
             .usage('查看session groupId')
             .example('test group')
             .action(({ session }) => {
-                console.log(session.event.channel);
-            })
-
+            console.log(session.event.channel);
+        });
         ctx.command('test')
             .subcommand('.session')
             .usage('查看seesion')
             .example('test session')
             .action(({ session }) => {
-                console.log(session);
-            })
-
-        // ctx.command('test')
-        //     .subcommand('.dynamic <uid:string>')
-        //     .usage('测试动态监测')
-        //     .example('test dynamic uid')
-        //     .action(({ session }, uid) => {
-        //         ctx.setInterval(this.test_dynamicDetect(ctx, session, uid), 30000)
-        //     })
-
+            console.log(session);
+        });
         ctx.command('test')
             .subcommand('.utc')
             .usage('获取当前UTC+8 Unix时间戳')
             .example('test utc')
-            .action(() => {
-                console.log(ctx.biliAPI.getUTCPlus8Time());
-            }) */
+            .action(async ({ session }) => {
+            session.send((await ctx.biliAPI.getServerUTCTime()).toString());
+        });
         ctx.command('bili', 'bili-notify插件相关指令', { permissions: ['authority:3'] })
             .subcommand('.login', '登录B站之后才可以进行之后的操作')
             .usage('使用二维码登录，登录B站之后才可以进行之后的操作')
@@ -494,28 +483,31 @@ class ComRegister {
                 }
                 return;
             }
-            let liveTime = (new Date(data.live_time).getTime()) / 1000;
-            const string = await ctx.gimg.generateLiveImg(data, userData, data.live_status !== 1 ?
+            const { pic, buffer } = await ctx.gimg.generateLiveImg(data, userData, data.live_status !== 1 ?
                 LiveType.NotLiveBroadcast :
                 LiveType.LiveBroadcast);
-            session.send(string);
+            // pic 存在，使用的是render模式
+            if (pic)
+                return pic;
+            // pic不存在，说明使用的是page模式
+            await session.send(koishi_1.h.image(buffer, 'image/png'));
         });
     }
     dynamicDetect(ctx, bot, guildId, uid) {
         let firstSubscription = true;
         let timePoint;
         // Test code
-        // let timer = 0
+        let timer = 0;
         return async () => {
             // Test code
-            /* console.log('timer:' + timer++);
+            console.log('timer:' + timer++);
             console.log('firstSubscription:' + firstSubscription);
             console.log(`timePoint: ${timePoint}`);
-            console.log(`timePoint: ${ctx.gimg.unixTimestampToString(timePoint)}`); */
+            console.log(`timePoint: ${ctx.gimg.unixTimestampToString(timePoint)}`);
             // 第一次订阅判断
             if (firstSubscription) {
                 // 设置第一次的时间点
-                timePoint = ctx.biliAPI.getUTCPlus8Time();
+                timePoint = await ctx.biliAPI.getServerUTCTime();
                 // 设置第一次为false
                 firstSubscription = false;
                 return;
@@ -544,13 +536,14 @@ class ComRegister {
             }
             // 获取数据内容
             const items = content.data.items;
-            // 发送请求 默认只查看前五条数据
+            // 发送请求 默认只查看配置文件规定的数据
             for (let num = this.config.dynamicCheckNumber - 1; num >= 0; num--) {
                 // 没有动态内容则直接跳过
                 if (!items[num])
                     continue;
                 // Test code
-                // console.log(`items[${num}].modules.module_author.pub_ts: ${ctx.gimg.unixTimestampToString(items[num].modules.module_author.pub_ts)}`);
+                console.log(`items[${num}].modules.module_author.pub_ts: ${items[num].modules.module_author.pub_ts}`);
+                console.log(`items[${num}].modules.module_author.pub_ts: ${ctx.gimg.unixTimestampToString(items[num].modules.module_author.pub_ts)}`);
                 // 寻找发布时间比时间点时间更晚的动态
                 if (items[num].modules.module_author.pub_ts > timePoint) {
                     // 如果这是遍历的最后一条，将时间点设置为这条动态的发布时间
@@ -572,9 +565,15 @@ class ComRegister {
                     let attempts = 3;
                     for (let i = 0; i < attempts; i++) {
                         try {
-                            const [pic] = await ctx.gimg.generateDynamicImg(items[num]);
-                            await bot.sendMessage(guildId, pic);
-                            break; // 如果成功，那么跳出循环
+                            // 获取动态推送图片
+                            const { pic, buffer } = await ctx.gimg.generateDynamicImg(items[num]);
+                            // 如果pic存在，则直接返回pic
+                            if (pic)
+                                return await bot.sendMessage(guildId, pic);
+                            // pic不存在，说明使用的是page模式
+                            await bot.sendMessage(guildId, koishi_1.h.image(buffer, 'image/png'));
+                            // 如果成功，那么跳出循环
+                            break;
                         }
                         catch (e) {
                             if (i === attempts - 1) { // 如果已经尝试了三次，那么抛出错误
@@ -594,6 +593,16 @@ class ComRegister {
         let uData;
         // 相当于锁的作用，防止上一个循环没处理完
         let flag = true;
+        async function sendLiveNotifyCard(data, uData, liveType) {
+            // 获取直播通知卡片
+            const { pic, buffer } = await ctx.gimg.generateLiveImg(data, uData, liveType);
+            // 推送直播信息
+            // pic 存在，使用的是render模式
+            if (pic)
+                return bot.sendMessage(guildId, pic);
+            // pic不存在，说明使用的是page模式
+            await bot.sendMessage(guildId, koishi_1.h.image(buffer, 'image/png'));
+        }
         return async () => {
             try {
                 // console.log('start before' + ' ' + flag);
@@ -640,10 +649,8 @@ class ComRegister {
                     if (data.live_status === 1) { // 当前正在直播
                         // 设置开播时间
                         liveTime = data.live_time;
-                        // 推送直播信息
-                        await bot.sendMessage(guildId, await ctx
-                            .gimg
-                            .generateLiveImg(data, uData, LiveType.LiveBroadcast));
+                        // 发送直播通知卡片
+                        sendLiveNotifyCard(data, uData, LiveType.LiveBroadcast);
                         // 改变开播状态
                         open = true;
                     } // 未开播，直接返回
@@ -659,7 +666,7 @@ class ComRegister {
                             // 下播了将定时器清零
                             timer = 0;
                             // 发送下播通知
-                            bot.sendMessage(guildId, `${uData.info.uname}下播啦，本次直播了${ctx.gimg.getTimeDifference(liveTime)}`);
+                            bot.sendMessage(guildId, `${uData.info.uname}下播啦，本次直播了${await ctx.gimg.getTimeDifference(liveTime)}`);
                         }
                         // 未进循环，还未开播，继续循环
                         break;
@@ -681,8 +688,8 @@ class ComRegister {
                             }
                             // 主播信息不会变，开播时刷新一次即可
                             uData = userData;
-                            // 发送直播通知
-                            await bot.sendMessage(guildId, await ctx.gimg.generateLiveImg(data, uData, LiveType.StartBroadcasting));
+                            // 发送直播通知卡片
+                            sendLiveNotifyCard(data, uData, LiveType.StartBroadcasting);
                         }
                         else { // 还在直播
                             if (this.config.pushTime > 0) {
@@ -691,10 +698,8 @@ class ComRegister {
                                 if (timer >= (6 * 60 * this.config.pushTime)) { // 到时间推送直播消息
                                     // 到时间重新计时
                                     timer = 0;
-                                    // 发送状态信息
-                                    bot.sendMessage(guildId, await ctx
-                                        .gimg
-                                        .generateLiveImg(data, uData, LiveType.LiveBroadcast));
+                                    // 发送直播通知卡片
+                                    sendLiveNotifyCard(data, uData, LiveType.LiveBroadcast);
                                 }
                             }
                             // 否则继续循环

package/lib/generateImg.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { Context, Schema, Service } from "koishi";
 declare module 'koishi' {
     interface Context {
@@ -9,14 +10,29 @@ declare class GenerateImg extends Service {
     config: GenerateImg.Config;
     constructor(ctx: Context, config: GenerateImg.Config);
     protected start(): void | Promise<void>;
-    generateLiveImg(data: any, userData: any, liveStatus: number): Promise<string>;
-    generateDynamicImg(data: any): Promise<string[]>;
-    getLiveStatus(time: string, liveStatus: number): [string, string, boolean];
-    getTimeDifference(dateString: string): string;
+    generateLiveImg(data: any, userData: any, liveStatus: number): Promise<{
+        buffer: Buffer;
+        pic?: undefined;
+    } | {
+        pic: string;
+        buffer?: undefined;
+    }>;
+    generateDynamicImg(data: any): Promise<{
+        buffer: Buffer;
+        link: string;
+        pic?: undefined;
+    } | {
+        pic: string;
+        link: string;
+        buffer?: undefined;
+    }>;
+    getLiveStatus(time: string, liveStatus: number): Promise<[string, string, boolean]>;
+    getTimeDifference(dateString: string): Promise<string>;
     unixTimestampToString(timestamp: number): string;
 }
 declare namespace GenerateImg {
     interface Config {
+        renderType: number;
         cardColorStart: string;
         cardColorEnd: string;
         font: string;