koishi-plugin-wordpress-notifier 2.5.4 → 2.5.5

package/lib/index.d.ts

@@ -5,7 +5,6 @@ declare module 'koishi' {
     interface Tables {
         wordpress_post_updates: WordPressPostUpdateRecord;
         wordpress_user_registrations: WordPressUserRegistrationRecord;
-        wordpress_group_pushes: WordPressGroupPushRecord;
     }
 }
 export interface Config {
@@ -61,13 +60,6 @@ export interface WordPressUserRegistrationRecord {
     userId: number;
     pushedAt: Date;
 }
-export interface WordPressGroupPushRecord {
-    id: number;
-    groupId: string;
-    postId: number;
-    pushedAt: Date;
-    isUpdate: boolean;
-}
 export interface WordPressNotification {
     type: 'post' | 'update' | 'user';
     data: any;

package/lib/index.js

@@ -15,7 +15,7 @@ exports.Config = koishi_1.Schema.object({
     mentionAll: koishi_1.Schema.boolean().default(false).description('是否 @全体成员'),
     maxArticles: koishi_1.Schema.number().default(5).description('每次最多推送的文章数量'),
     username: koishi_1.Schema.string().default('').description('WordPress 用户名（用于 Basic 认证，与应用程序密码配合使用）'),
-    applicationPassword: koishi_1.Schema.string().default('').description('WordPress 应用程序密码（用于 Basic 认证，例如：hGR2sPFuYnclxHc4AvJqcUtB）'),
+    applicationPassword: koishi_1.Schema.string().default('').description('WordPress 应用程序密码（用于 Basic 认证，例如：hGR2sPFuYnclxHc4AvJq cUtB）'),
     superAdmins: koishi_1.Schema.array(koishi_1.Schema.string()).default([]).description('超级管理员 QQ 号列表')
 });
 function apply(ctx, config) {
@@ -42,19 +42,6 @@ function apply(ctx, config) {
         autoInc: true,
         unique: ['userId']
     });
-    ctx.model.extend('wordpress_group_pushes', {
-        id: 'integer',
-        groupId: 'string',
-        postId: 'integer',
-        pushedAt: 'timestamp',
-        isUpdate: 'boolean'
-    }, {
-        primary: 'id',
-        autoInc: true,
-        unique: ['groupId', 'postId']
-    });
-    // 确保所有插入操作都不手动指定 id 字段，让数据库自动生成
-    // Koishi 框架的 autoInc: true 配置会自动处理自增主键
     ctx.logger.info('数据库表配置完成，autoInc: true 已启用，确保插入操作不手动指定 id 字段');
     // 为所有数据库操作添加详细日志，便于诊断自增主键问题
     ctx.on('ready', async () => {
@@ -62,61 +49,18 @@ function apply(ctx, config) {
         ctx.logger.info('数据库表配置：');
         ctx.logger.info('wordpress_post_updates: id 字段设置为 autoInc: true');
         ctx.logger.info('wordpress_user_registrations: id 字段设置为 autoInc: true');
-        ctx.logger.info('wordpress_group_pushes: id 字段设置为 autoInc: true，唯一键为 groupId+postId');
-        ctx.logger.info('插件将确保所有插入操作不手动指定 id 字段，让数据库自动生成');
+        ctx.logger.info('所有群聊共用一个文章标记，不再区分群聊');
         // 检查并修复数据库表结构问题
         await checkAndFixTableStructure();
+        // 执行初始推送
+        await pushNewPosts();
     });
-    // 检查并修复数据库表结构的函数
+    // 检查数据库表结构的函数
     async function checkAndFixTableStructure() {
         try {
             ctx.logger.info('开始检查数据库表结构...');
-            // 获取表中的所有记录，检查是否存在相同 groupId 不同 postId 的记录
-            const allRecords = await ctx.database.get('wordpress_group_pushes', {});
-            ctx.logger.info(`当前 wordpress_group_pushes 表共有 ${allRecords.length} 条记录`);
-            // 检查是否存在相同 groupId 不同 postId 的记录
-            const groupPostMap = new Map();
-            let hasDuplicateGroupId = false;
-            for (const record of allRecords) {
-                const groupId = record.groupId;
-                const postId = record.postId;
-                if (!groupPostMap.has(groupId)) {
-                    groupPostMap.set(groupId, new Set());
-                }
-                const postIds = groupPostMap.get(groupId);
-                if (postIds.has(postId)) {
-                    ctx.logger.warn(`发现重复记录：groupId=${groupId}, postId=${postId}`);
-                }
-                else {
-                    postIds.add(postId);
-                }
-                // 如果一个群有多个不同的 postId，说明表结构正确
-                if (postIds.size > 1) {
-                    hasDuplicateGroupId = true;
-                }
-            }
-            if (hasDuplicateGroupId) {
-                ctx.logger.info('检测到同一群有多个不同文章记录，表结构正确');
-            }
-            else {
-                ctx.logger.warn('检测到每个群只有一个文章记录，可能存在表结构问题');
-                ctx.logger.warn('建议检查 wordpress_group_pushes 表的唯一键设置，应设置为 groupId+postId 的联合唯一键');
-                ctx.logger.warn('当前表结构可能导致一个群只能推送一篇文章');
-            }
-            // 尝试通过重新创建表来修复结构（使用 Koishi 内置的表重建机制）
-            ctx.logger.info('尝试通过 Koishi 模型扩展机制修复表结构...');
-            // 重新扩展模型，确保唯一键设置正确
-            ctx.model.extend('wordpress_group_pushes', {
-                id: 'integer',
-                groupId: 'string',
-                postId: 'integer',
-                pushedAt: 'timestamp',
-                isUpdate: 'boolean'
-            }, {
-                primary: 'id',
-                autoInc: true,
-                unique: ['groupId', 'postId']
-            });
+            ctx.logger.info('所有群聊现在共用一个文章标记，不再区分群聊');
+            ctx.logger.info('wordpress_group_pushes 表已不再使用，已移除相关功能');
             ctx.logger.info('表结构检查和修复完成');
         }
         catch (error) {
@@ -241,28 +185,6 @@ function apply(ctx, config) {
             return null;
         }
     }
-    async function isGroupPushed(groupId, postId) {
-        try {
-            // 明确查询 groupId + postId 组合是否存在
-            const query = { groupId, postId };
-            ctx.logger.info(`检查群 ${groupId} 是否已推送文章 ${postId}，查询条件：${JSON.stringify(query)}`);
-            const records = await ctx.database.get('wordpress_group_pushes', query);
-            const result = records.length > 0;
-            ctx.logger.info(`检查群 ${groupId} 是否已推送文章 ${postId}：${result ? '是' : '否'}`);
-            // 添加调试日志，显示所有相关记录
-            if (records.length > 0) {
-                ctx.logger.debug(`找到 ${records.length} 条匹配记录：${JSON.stringify(records)}`);
-            }
-            return result;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            ctx.logger.error(`检查推送记录失败：${errorMessage}`);
-            ctx.logger.error(`错误栈：${error instanceof Error ? error.stack : '无'}`);
-            // 发生错误时，默认返回 false，避免阻塞推送流程
-            return false;
-        }
-    }
     async function markUserAsPushed(userId) {
         try {
             ctx.logger.info(`开始标记用户已推送，用户 ID: ${userId}`);
@@ -317,69 +239,6 @@ function apply(ctx, config) {
             throw error;
         }
     }
-    async function markGroupAsPushed(groupId, postId, isUpdate) {
-        try {
-            ctx.logger.info(`开始标记群 ${groupId} 已推送文章 ${postId}`);
-            // 1. 获取当前表中的所有记录，检查是否有相同 groupId 的不同 postId 记录
-            const allGroupRecords = await ctx.database.get('wordpress_group_pushes', { groupId });
-            ctx.logger.info(`群 ${groupId} 已有 ${allGroupRecords.length} 条推送记录`);
-            if (allGroupRecords.length > 0) {
-                ctx.logger.info(`已有记录示例：${JSON.stringify(allGroupRecords.slice(0, 2))}`);
-            }
-            // 2. 检查是否已存在该 groupId + postId 的组合
-            const existingRecords = await ctx.database.get('wordpress_group_pushes', { groupId, postId });
-            ctx.logger.info(`检查结果：群 ${groupId} 已推送文章 ${postId}：${existingRecords.length > 0 ? '是' : '否'}`);
-            // 3. 创建新记录，不删除旧记录（除非是同篇文章的更新）
-            const newRecord = {
-                groupId,
-                postId,
-                pushedAt: new Date(),
-                isUpdate
-            };
-            ctx.logger.info(`准备创建新记录：${JSON.stringify(newRecord)}`);
-            await ctx.database.create('wordpress_group_pushes', newRecord);
-            ctx.logger.info(`已创建新记录，群 ${groupId}，文章 ${postId}`);
-            // 4. 写入后验证，确保记录真正存入数据库
-            const verification = await ctx.database.get('wordpress_group_pushes', { groupId, postId });
-            if (verification.length > 0) {
-                ctx.logger.info(`记录写入验证成功，群 ${groupId}，文章 ${postId}`);
-                // 验证后再次检查该群的所有记录
-                const updatedAllGroupRecords = await ctx.database.get('wordpress_group_pushes', { groupId });
-                ctx.logger.info(`群 ${groupId} 现在共有 ${updatedAllGroupRecords.length} 条推送记录`);
-            }
-            else {
-                ctx.logger.error(`记录写入验证失败，群 ${groupId}，文章 ${postId}`);
-            }
-        }
-        catch (error) {
-            // 处理唯一约束冲突错误
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            ctx.logger.error(`标记推送记录失败：${errorMessage}`);
-            ctx.logger.error(`错误栈：${error instanceof Error ? error.stack : '无'}`);
-            ctx.logger.error(`插入参数：groupId=${groupId}, postId=${postId}, isUpdate=${isUpdate}`);
-            // 详细记录错误信息，便于诊断
-            if (errorMessage.includes('UNIQUE constraint failed')) {
-                ctx.logger.error(`唯一约束冲突，可能的原因：`);
-                ctx.logger.error(`1. 数据库表的 unique 约束设置错误，可能只针对 groupId 而不是 groupId+postId 组合`);
-                ctx.logger.error(`2. 同一篇文章被多次推送`);
-                ctx.logger.error(`3. 数据库表结构与模型定义不符`);
-                // 尝试获取表结构信息（如果可能）
-                try {
-                    const allRecords = await ctx.database.get('wordpress_group_pushes', {});
-                    ctx.logger.error(`当前表中共有 ${allRecords.length} 条记录`);
-                    if (allRecords.length > 0) {
-                        ctx.logger.error(`前 3 条记录：${JSON.stringify(allRecords.slice(0, 3))}`);
-                    }
-                }
-                catch (e) {
-                    ctx.logger.error(`获取表记录失败：${e}`);
-                }
-            }
-            else {
-                ctx.logger.error(`非约束冲突错误，插件将继续运行`);
-            }
-        }
-    }
     function formatPostMessage(post, mention = false, isUpdate = false) {
         // 彻底过滤 HTML 标签和非法字符，只保留安全文本
         const sanitizeText = (text) => {
@@ -399,7 +258,7 @@ function apply(ctx, config) {
         }
         // 合并为单段文本，提升适配器兼容性
         const messageType = isUpdate ? '📝 文章更新' : '📝 新文章';
-        const messageDate = isUpdate ? `📅 发布: ${date}\n� 更新: ${modifiedDate}` : `� ${date}`;
+        const messageDate = isUpdate ? `📅 发布: ${date}\n🔄 更新: ${modifiedDate}` : `📅 ${date}`;
         const message = `${messageType}\n${messageDate}\n📄 ${excerpt}...\n🔗 ${post.link}`;
         segments.push(koishi_1.h.text(message));
         return segments;
@@ -508,31 +367,33 @@ function apply(ctx, config) {
                 for (const post of posts) {
                     ctx.logger.info(`正在处理文章: ${post.id} - ${post.title.rendered}`);
                     ctx.logger.info(`文章 ID: ${post.id}, 发布时间: ${post.date}, 修改时间: ${post.modified}`);
-                    for (const target of config.targets) {
-                        try {
-                            ctx.logger.info(`正在处理目标: ${target}`);
-                            // 直接使用原始目标字符串，不进行数字转换，避免丢失平台前缀等信息
-                            const stringTarget = target;
-                            // 检查该群是否已推送过此文章
-                            const hasPushed = await isGroupPushed(stringTarget, post.id);
-                            ctx.logger.info(`检查结果: 群 ${stringTarget} 已推送文章 ${post.id}：${hasPushed ? '是' : '否'}`);
-                            if (!hasPushed) {
+                    // 检查文章是否已推送过（所有群聊共用一个标记）
+                    const postRecord = await getPostUpdateRecord(post.id);
+                    const hasPushed = !!postRecord;
+                    ctx.logger.info(`检查结果: 文章 ${post.id} 是否已推送：${hasPushed ? '是' : '否'}`);
+                    if (!hasPushed) {
+                        // 推送到所有目标群聊
+                        for (const target of config.targets) {
+                            try {
+                                ctx.logger.info(`正在处理目标: ${target}`);
+                                // 直接使用原始目标字符串，不进行数字转换，避免丢失平台前缀等信息
+                                const stringTarget = target;
                                 const segments = formatPostMessage(post, true, false);
                                 ctx.logger.info(`准备推送新文章到目标: ${stringTarget}`);
                                 await bot.sendMessage(stringTarget, segments);
                                 ctx.logger.info(`已推送新文章到 ${stringTarget}: ${post.title.rendered}`);
-                                // 标记该群已推送此文章
-                                await markGroupAsPushed(stringTarget, post.id, false);
-                                ctx.logger.info(`已标记群 ${stringTarget} 已推送文章 ${post.id}`);
                             }
-                            else {
-                                ctx.logger.info(`跳过推送: 群 ${stringTarget} 已推送过文章 ${post.id}`);
+                            catch (error) {
+                                ctx.logger.error(`推送新文章到 ${target} 失败: ${error}`);
+                                ctx.logger.error(`错误详情: ${JSON.stringify(error)}`);
                             }
                         }
-                        catch (error) {
-                            ctx.logger.error(`推送新文章到 ${target} 失败: ${error}`);
-                            ctx.logger.error(`错误详情: ${JSON.stringify(error)}`);
-                        }
+                        // 标记文章已推送（所有群聊共用一个标记）
+                        await updatePostUpdateRecord(post.id, new Date(post.modified));
+                        ctx.logger.info(`已标记文章 ${post.id} 为已推送，所有群聊将不再推送此文章`);
+                    }
+                    else {
+                        ctx.logger.info(`跳过推送: 文章 ${post.id} 已推送过，所有群聊将不再推送`);
                     }
                 }
             }
@@ -545,29 +406,26 @@ function apply(ctx, config) {
                     const updateRecord = await getPostUpdateRecord(post.id);
                     const postModifiedDate = new Date(post.modified);
                     // 检查文章是否有更新
-                    if (!updateRecord || postModifiedDate > new Date(updateRecord.lastModified)) {
+                    if (updateRecord && postModifiedDate > new Date(updateRecord.lastModified)) {
+                        ctx.logger.info(`文章 ${post.id} 有更新，准备推送更新通知`);
+                        // 推送到所有目标群聊
                         for (const target of config.targets) {
                             try {
                                 ctx.logger.info(`正在处理目标: ${target}`);
-                                // 直接使用原始目标字符串，与新文章推送逻辑保持一致
                                 const stringTarget = target;
-                                // 检查该群是否已推送过此文章
-                                if (await isGroupPushed(stringTarget, post.id)) {
-                                    const segments = formatPostMessage(post, true, true);
-                                    ctx.logger.info(`准备推送文章更新到目标: ${stringTarget}`);
-                                    await bot.sendMessage(stringTarget, segments);
-                                    ctx.logger.info(`已推送文章更新到 ${stringTarget}: ${post.title.rendered}`);
-                                    // 更新该群推送记录
-                                    await markGroupAsPushed(stringTarget, post.id, true);
-                                }
+                                const segments = formatPostMessage(post, true, true);
+                                ctx.logger.info(`准备推送文章更新到目标: ${stringTarget}`);
+                                await bot.sendMessage(stringTarget, segments);
+                                ctx.logger.info(`已推送文章更新到 ${stringTarget}: ${post.title.rendered}`);
                             }
                             catch (error) {
                                 ctx.logger.error(`推送文章更新到 ${target} 失败: ${error}`);
                                 ctx.logger.error(`错误详情: ${JSON.stringify(error)}`);
                             }
                         }
-                        // 更新文章更新记录
+                        // 更新文章更新记录（所有群聊共用一个标记）
                         await updatePostUpdateRecord(post.id, postModifiedDate);
+                        ctx.logger.info(`已更新文章 ${post.id} 的推送记录，所有群聊将使用此更新时间作为新的推送基准`);
                     }
                 }
             }
@@ -749,8 +607,8 @@ ${targetText}
     ctx.command('wordpress.pushed', '查看已推送的文章列表')
         .action(async () => {
         ctx.logger.info('命令 wordpress.pushed 被调用');
-        // 获取已推送的文章记录，使用 wordpress_group_pushes 表
-        const records = await ctx.database.get('wordpress_group_pushes', {}, {
+        // 获取已推送的文章记录，使用 wordpress_post_updates 表
+        const records = await ctx.database.get('wordpress_post_updates', {}, {
             sort: {
                 pushedAt: 'desc'
             }
@@ -760,7 +618,7 @@ ${targetText}
         }
         let message = '📋 已推送文章列表（按时间倒序）：\n\n';
         for (const record of records) {
-            message += `${record.id}. 文章 ID: ${record.postId}（群：${record.groupId}，${record.isUpdate ? '更新' : '新文章'}）\n`;
+            message += `${record.id}. 文章 ID: ${record.postId}\n`;
             message += `📅 推送时间: ${new Date(record.pushedAt).toLocaleString('zh-CN')}\n\n`;
         }
         return message;
@@ -791,7 +649,6 @@ ${targetText}
         // 获取所有记录
         const allUpdateRecords = await ctx.database.get('wordpress_post_updates', {});
         const allUserRecords = await ctx.database.get('wordpress_user_registrations', {});
-        const allGroupRecords = await ctx.database.get('wordpress_group_pushes', {});
         // 筛选需要删除的记录
         const updateRecordsToRemove = allUpdateRecords.filter(record => {
             return new Date(record.pushedAt) < cutoffDate;
@@ -799,9 +656,6 @@ ${targetText}
         const userRecordsToRemove = allUserRecords.filter(record => {
             return new Date(record.pushedAt) < cutoffDate;
         });
-        const groupRecordsToRemove = allGroupRecords.filter(record => {
-            return new Date(record.pushedAt) < cutoffDate;
-        });
         // 删除旧记录
         let result = 0;
         for (const record of updateRecordsToRemove) {
@@ -812,10 +666,6 @@ ${targetText}
             await ctx.database.remove('wordpress_user_registrations', { id: record.id });
             result++;
         }
-        for (const record of groupRecordsToRemove) {
-            await ctx.database.remove('wordpress_group_pushes', { id: record.id });
-            result++;
-        }
         ctx.logger.info(`已清理 ${result} 条 ${daysToKeep} 天前的推送记录`);
         return `已清理 ${result} 条 ${daysToKeep} 天前的推送记录`;
     });
@@ -838,10 +688,6 @@ ${targetText}
 
 💡 提示：所有命令都需要加 / 前缀`;
     });
-    ctx.on('ready', async () => {
-        ctx.logger.info('WordPress 推送插件已就绪');
-        await pushNewPosts();
-    });
     ctx.setInterval(() => {
         pushNewPosts();
     }, config.interval);

package/package.json

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