koishi-plugin-wordpress-notifier 2.9.3 → 2.9.4

package/README.md

@@ -205,6 +205,13 @@ npm install koishi-plugin-wordpress-notifier
 
 ## 版本历史
 
+### v2.9.4
+- 🎉 **Bug 修复**：修复文章更新检测误判问题，仅使用修改时间判断，避免因哈希值变化导致所有文章被重复推送
+- 🚀 **性能优化**：将文章检查数量从 20 篇减少到 10 篇，减少不必要的检查
+- ✨ **功能完善**：完整实现新用户注册推送功能
+- 📊 **用户体验**：添加详细的更新检测日志，便于调试和追踪
+- 🔧 **代码优化**：改进更新检测逻辑，使用秒级时间戳比较，避免精度问题
+
 ### v2.9.3
 - 🎉 **并发控制**：使用 p-limit 替代手动队列，彻底解决线程安全问题
 - 🚀 **性能优化**：添加 10 秒缓存防抖，避免重复请求

package/lib/schedule.js

@@ -52,7 +52,10 @@ class ScheduleService {
             const interval = (this.config.checkInterval || 30) * 60 * 1000;
             this.intervalId = setInterval(async () => {
                 try {
+                    // 检查文章更新
                     await this.checkAndPushArticles();
+                    // 检查新用户注册
+                    await this.checkNewUsers();
                 }
                 catch (error) {
                     this.ctx.logger.error('Error in scheduled task:', error);
@@ -178,8 +181,8 @@ class ScheduleService {
             if (!this.isPushTimeAllowed()) {
                 return;
             }
-            // 获取最新文章
-            const articles = await this.wordpressService.getLatestPosts(20);
+            // 获取最新文章（只获取最新的 10 篇，减少不必要的检查）
+            const articles = await this.wordpressService.getLatestPosts(10);
             if (articles.length === 0) {
                 this.ctx.logger.info('暂无新文章');
                 return;
@@ -230,17 +233,24 @@ class ScheduleService {
                                     if (pushedArticle) {
                                         const currentModified = new Date(article.modified || article.date);
                                         const storedModified = new Date(pushedArticle.modified);
-                                        const currentHash = this.pushService.generateHash(JSON.stringify(article));
-                                        // 检查是否有更新
-                                        if (currentModified > storedModified || currentHash !== pushedArticle.hash) {
+                                        // 修复：仅比较修改时间，移除哈希值比较，避免因动态字段变化导致误判
+                                        // 使用时间戳比较，忽略毫秒级差异，避免因时间精度导致误判
+                                        const currentTime = Math.floor(currentModified.getTime() / 1000); // 秒级时间戳
+                                        const storedTime = Math.floor(storedModified.getTime() / 1000);
+                                        // 检查是否有更新（仅当修改时间真正发生变化时才推送）
+                                        if (currentTime > storedTime) {
+                                            this.ctx.logger.info(`检测到文章 ${article.id} 有更新，修改时间从 ${storedModified.toISOString()} 变更为 ${currentModified.toISOString()}`);
                                             // 推送更新通知
                                             const success = await this.pushService.pushArticleUpdate(article, groupId);
                                             if (success) {
                                                 // 更新存储的修改时间和哈希值
-                                                await this.storageService.updatePushedArticle(article.id, groupId, currentModified, currentHash);
+                                                await this.storageService.updatePushedArticle(article.id, groupId, currentModified, this.pushService.generateHash(JSON.stringify(article)));
                                                 this.ctx.logger.info(`已推送文章 ${article.id} 的更新到群聊 ${groupId}`);
                                             }
                                         }
+                                        else {
+                                            this.ctx.logger.debug(`文章 ${article.id} 无更新，跳过`);
+                                        }
                                     }
                                 }
                             }
@@ -289,13 +299,70 @@ class ScheduleService {
     }
     // 检查新用户注册
     async checkNewUsers() {
-        // 模拟实现
-        this.ctx.logger.info('检查新用户注册');
+        try {
+            // 检查是否启用用户注册推送
+            if (!this.config.enableUserRegisterPush) {
+                return;
+            }
+            // 获取最新注册的用户（最近10个）
+            const users = await this.wordpressService.getLatestUsers(10);
+            if (users.length === 0) {
+                this.ctx.logger.info('暂无新用户注册');
+                return;
+            }
+            // 获取所有启用推送的群聊
+            const groups = await this.storageService.getEnabledGroups();
+            if (groups.length === 0) {
+                this.ctx.logger.info('没有启用推送的群聊');
+                return;
+            }
+            this.ctx.logger.info(`检查 ${users.length} 个新用户，推送至 ${groups.length} 个群聊`);
+            // 收集所有推送任务
+            const pushTasks = [];
+            // 检查每个用户
+            for (const user of users) {
+                for (const groupId of groups) {
+                    pushTasks.push(async () => {
+                        try {
+                            // 记录用户并检查是否为新用户
+                            const isNewUser = await this.storageService.recordWpUser(user.id, user.name, new Date(user.registered_date));
+                            if (isNewUser) {
+                                // 获取未通知的用户
+                                const unnotifiedUsers = await this.storageService.getUnnotifiedWpUsers();
+                                // 为每个未通知的用户推送
+                                for (const unnotifiedUser of unnotifiedUsers) {
+                                    const success = await this.pushService.pushUserRegister(unnotifiedUser, groupId);
+                                    if (success) {
+                                        // 标记为已通知
+                                        await this.storageService.markWpUserNotified(unnotifiedUser.wpUserId);
+                                        this.ctx.logger.info(`已推送新用户 ${unnotifiedUser.username} 到群聊 ${groupId}`);
+                                    }
+                                    else {
+                                        this.ctx.logger.warn(`推送新用户 ${unnotifiedUser.username} 到群聊 ${groupId} 失败`);
+                                    }
+                                }
+                            }
+                        }
+                        catch (error) {
+                            this.ctx.logger.error(`处理用户 ${user.id} 注册推送失败:`, error);
+                        }
+                    });
+                }
+            }
+            // 执行推送任务
+            const result = await this.executeWithConcurrencyLimit(pushTasks);
+            // 记录推送统计
+            this.ctx.logger.info(`新用户注册推送完成：成功 ${result.success} 次，失败 ${result.failed} 次`);
+        }
+        catch (error) {
+            this.ctx.logger.error('检查新用户注册失败:', error);
+        }
     }
     // 手动触发检查
     async triggerCheck() {
         try {
             await this.checkAndPushArticles();
+            await this.checkNewUsers();
         }
         catch (error) {
             this.ctx.logger.error('Error triggering check:', error);

package/lib/wordpress.d.ts

@@ -91,6 +91,7 @@ export declare class WordPressService {
     private cleanupCache;
     getLatestPosts(perPage?: number, page?: number): Promise<WordPressPost[]>;
     getPostById(id: number): Promise<WordPressPost>;
+    getLatestUsers(perPage?: number, page?: number): Promise<any[]>;
     getStatus(): {
         wordpressUrl: string;
         apiEndpoint: string;

package/lib/wordpress.js

@@ -393,6 +393,40 @@ class WordPressService {
             throw error;
         }
     }
+    // 获取最新注册的用户
+    async getLatestUsers(perPage = 10, page = 1) {
+        this.stats.commandCount++;
+        const cacheKey = `latest-users-${perPage}-${page}`;
+        const cachedData = this.getCache(cacheKey);
+        if (cachedData) {
+            return cachedData;
+        }
+        try {
+            // 获取最新注册的用户
+            const requestParams = {
+                per_page: Math.min(perPage, 100),
+                page: Math.max(1, page),
+                orderby: 'registered_date',
+                order: 'desc'
+            };
+            const response = await this.executeWithConcurrencyControl(() => this.client.get(`${this.config.apiEndpoint || '/wp-json/wp/v2'}/users`, {
+                params: requestParams
+            }), { method: 'GET', params: requestParams });
+            const users = response.data.map((user) => ({
+                id: user.id,
+                name: user.name,
+                registered_date: user.registered_date,
+                email: user.email,
+                link: user.link
+            }));
+            this.setCache(cacheKey, users);
+            return users;
+        }
+        catch (error) {
+            this.logError('Failed to get latest users:', error);
+            throw error;
+        }
+    }
     // 获取服务状态
     getStatus() {
         const successRate = this.stats.totalRequests > 0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-wordpress-notifier",
-  "version": "2.9.3",
+  "version": "2.9.4",
   "description": "WordPress 文章自动推送插件",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",