koishi-plugin-group-verification 1.0.10 → 1.0.11

package/lib/index.js

@@ -373,89 +373,149 @@ ${debugInfo}`];
       return `已为群 ${targetGroupId} 创建验证配置`;
     }
   });
-  groupVerify.subcommand(".approve <userId>", "同意用户加群申请").alias("accept", "同意", "appr", "通过").action(async ({ session }, userId) => {
-    if (!await checkPermission(session)) {
-      return "权限不足";
+  groupVerify.subcommand(".approve [userId]", "同意加群申请").alias("accept", "同意", "通过", "gva").action(async ({ session }, userId) => {
+    const [hasPermission, errorMsg] = await checkPermission(session);
+    if (!hasPermission) {
+      return errorMsg || "权限不足";
     }
-    if (!session.guildId) {
+    const groupId = session.guildId;
+    if (!groupId) {
       return "请在群聊中使用此命令";
     }
-    if (!userId) {
-      return "请提供用户ID";
+    if (!userId || userId.toLowerCase() === "all") {
+      if (userId?.toLowerCase() === "all") {
+        const pendingRequests2 = await ctx.database.get("group_verification_pending", { groupId });
+        if (pendingRequests2.length === 0) {
+          return "当前无待审核的加群申请";
+        }
+        let approvedCount = 0;
+        for (const request2 of pendingRequests2) {
+          try {
+            await ctx.database.remove("group_verification_pending", { id: request2.id });
+            await updateStats(groupId, "manuallyApproved");
+            approvedCount++;
+          } catch (error) {
+            logger.warn(`处理申请 ${request2.id} 时出错:`, error);
+          }
+        }
+        return `已处理 ${approvedCount} 个加群申请`;
+      } else {
+        const recentRequest = await ctx.database.get("group_verification_pending", { groupId }, ["id", "userId", "userName"]);
+        if (recentRequest.length === 0) {
+          return "当前无待审核的加群申请";
+        }
+        const request2 = recentRequest[0];
+        try {
+          await session.bot.handleGuildMemberRequest(request2.userId, true);
+          await ctx.database.remove("group_verification_pending", { id: request2.id });
+          await updateStats(groupId, "manuallyApproved");
+          return `已同意用户 ${request2.userName}(${request2.userId}) 的加群申请`;
+        } catch (error) {
+          return `处理申请时出错: ${error.message}`;
+        }
+      }
     }
-    const pendingApplications = await ctx.database.get("group_verification_pending", {
-      groupId: session.guildId,
+    const pendingRequests = await ctx.database.get("group_verification_pending", {
+      groupId,
       userId
     });
-    if (pendingApplications.length === 0) {
+    if (pendingRequests.length === 0) {
       return `未找到用户 ${userId} 的待审核申请`;
     }
-    const application = pendingApplications[0];
-    await ctx.database.remove("group_verification_pending", { id: application.id });
-    await updateStats(session.guildId, "manuallyApproved");
-    return `已同意用户 ${application.userName}(${userId}) 的加群申请`;
+    const request = pendingRequests[0];
+    try {
+      await session.bot.handleGuildMemberRequest(request.userId, true);
+      await ctx.database.remove("group_verification_pending", { id: request.id });
+      await updateStats(groupId, "manuallyApproved");
+      return `已同意用户 ${request.userName}(${userId}) 的加群申请`;
+    } catch (error) {
+      return `处理申请时出错: ${error.message}`;
+    }
   });
-  groupVerify.subcommand(".reject <userId>", "拒绝用户加群申请").alias("拒绝", "rej", "拒绝").action(async ({ session }, userId) => {
-    if (!await checkPermission(session)) {
-      return "权限不足";
+  groupVerify.subcommand(".reject [userId]", "拒绝加群申请").alias("拒绝", "rej", "gvr").action(async ({ session }, userId) => {
+    const [hasPermission, errorMsg] = await checkPermission(session);
+    if (!hasPermission) {
+      return errorMsg || "权限不足";
     }
-    if (!session.guildId) {
+    const groupId = session.guildId;
+    if (!groupId) {
       return "请在群聊中使用此命令";
     }
-    if (!userId) {
-      return "请提供用户ID";
+    if (!userId || userId.toLowerCase() === "all") {
+      if (userId?.toLowerCase() === "all") {
+        const pendingRequests2 = await ctx.database.get("group_verification_pending", { groupId });
+        if (pendingRequests2.length === 0) {
+          return "当前无待审核的加群申请";
+        }
+        let rejectedCount = 0;
+        for (const request2 of pendingRequests2) {
+          try {
+            await ctx.database.remove("group_verification_pending", { id: request2.id });
+            await updateStats(groupId, "rejected");
+            rejectedCount++;
+          } catch (error) {
+            logger.warn(`处理申请 ${request2.id} 时出错:`, error);
+          }
+        }
+        return `已拒绝 ${rejectedCount} 个加群申请`;
+      } else {
+        const recentRequest = await ctx.database.get("group_verification_pending", { groupId }, ["id", "userId", "userName"]);
+        if (recentRequest.length === 0) {
+          return "当前无待审核的加群申请";
+        }
+        const request2 = recentRequest[0];
+        try {
+          await ctx.database.remove("group_verification_pending", { id: request2.id });
+          await updateStats(groupId, "rejected");
+          return `已拒绝用户 ${request2.userName}(${request2.userId}) 的加群申请`;
+        } catch (error) {
+          return `处理申请时出错: ${error.message}`;
+        }
+      }
     }
-    const pendingApplications = await ctx.database.get("group_verification_pending", {
-      groupId: session.guildId,
+    const pendingRequests = await ctx.database.get("group_verification_pending", {
+      groupId,
       userId
     });
-    if (pendingApplications.length === 0) {
+    if (pendingRequests.length === 0) {
       return `未找到用户 ${userId} 的待审核申请`;
     }
-    const application = pendingApplications[0];
-    await ctx.database.remove("group_verification_pending", { id: application.id });
-    await updateStats(session.guildId, "rejected");
-    return `已拒绝用户 ${application.userName}(${userId}) 的加群申请`;
+    const request = pendingRequests[0];
+    try {
+      await ctx.database.remove("group_verification_pending", { id: request.id });
+      await updateStats(groupId, "rejected");
+      return `已拒绝用户 ${request.userName}(${userId}) 的加群申请`;
+    } catch (error) {
+      return `处理申请时出错: ${error.message}`;
+    }
   });
-  groupVerify.subcommand(".stats [groupId]", "查看群组验证统计信息").alias("统计", "stat", "statistics").option("total", "-t 显示总计统计").action(async ({ session, options }, groupId) => {
-    const targetGroupId = groupId || session.guildId;
-    if (!targetGroupId && !options.total) {
-      return "请在群聊中使用此命令或指定群号，或使用 -t 参数查看总计统计";
-    }
-    let statsList = [];
-    if (options.total) {
-      const totalStats = await ctx.database.get("group_verification_stats", { groupId: "TOTAL" });
-      if (totalStats.length > 0) {
-        statsList.push(totalStats[0]);
-      }
-      if (targetGroupId && targetGroupId !== "TOTAL") {
-        const groupStats = await ctx.database.get("group_verification_stats", { groupId: targetGroupId });
-        statsList = statsList.concat(groupStats);
+  groupVerify.subcommand(".stats [target]", "查看群组验证统计信息").alias("统计", "stat", "statistics").action(async ({ session }, target) => {
+    const validTargets = ["all", "total"];
+    const isGroupId = target && /^\d+$/.test(target);
+    const isSpecialTarget = target && validTargets.includes(target.toLowerCase());
+    if (target && !isGroupId && !isSpecialTarget) {
+      return "参数错误：只能指定群号、all、total或留空";
+    }
+    if (target?.toLowerCase() === "total" || target?.toLowerCase() === "all") {
+      const koishiAuthority = session.author?.authority || session.user?.authority;
+      if (!(koishiAuthority && koishiAuthority >= 3)) {
+        return "查看总计统计需要koishi 3级以上权限";
       }
-    } else {
-      const groupStats = await ctx.database.get("group_verification_stats", { groupId: targetGroupId });
-      statsList = groupStats;
     }
-    if (statsList.length === 0) {
-      if (options.total) {
-        return "暂无统计信息";
-      } else {
-        return `群 ${targetGroupId} 暂无验证统计信息`;
+    const groupId = session.guildId;
+    if (!target) {
+      if (!groupId) {
+        return "请在群聊中使用此命令或指定群号";
       }
+      return await getGroupStats(groupId);
     }
-    let result = "";
-    for (const stats of statsList) {
-      const groupName = stats.groupId === "TOTAL" ? "总计" : `群 ${stats.groupId}`;
-      const lastUpdated = new Date(stats.lastUpdated).toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" });
-      result += `${groupName} 验证统计：
-自动批准: ${stats.autoApproved}
-手动批准: ${stats.manuallyApproved}
-拒绝: ${stats.rejected}
-最后更新: ${lastUpdated}
-
-`;
+    if (target.toLowerCase() === "all" || target.toLowerCase() === "total") {
+      return await getTotalStats();
+    }
+    if (isGroupId) {
+      return await getGroupStats(target);
     }
-    return result.trim();
+    return "参数错误";
   });
   groupVerify.subcommand(".pending", "查看待审核加群申请").alias("list", "待审", "pend", "待处理").action(async ({ session }) => {
     if (!session.guildId) {
@@ -532,6 +592,34 @@ ${debugInfo}`];
     }
     await syncTotalStats(ctx);
   });
+  async function getGroupStats(groupId) {
+    const stats = await ctx.database.get("group_verification_stats", { groupId });
+    if (stats.length === 0) {
+      return `群 ${groupId} 暂无验证统计信息`;
+    }
+    const stat = stats[0];
+    const lastUpdated = new Date(stat.lastUpdated).toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" });
+    return `群 ${groupId} 验证统计：
+自动批准: ${stat.autoApproved}
+手动批准: ${stat.manuallyApproved}
+拒绝: ${stat.rejected}
+最后更新: ${lastUpdated}`;
+  }
+  __name(getGroupStats, "getGroupStats");
+  async function getTotalStats() {
+    const stats = await ctx.database.get("group_verification_stats", { groupId: "TOTAL" });
+    if (stats.length === 0) {
+      return "暂无统计信息";
+    }
+    const stat = stats[0];
+    const lastUpdated = new Date(stat.lastUpdated).toLocaleString("zh-CN", { timeZone: "Asia/Shanghai" });
+    return `总计验证统计：
+自动批准: ${stat.autoApproved}
+手动批准: ${stat.manuallyApproved}
+拒绝: ${stat.rejected}
+最后更新: ${lastUpdated}`;
+  }
+  __name(getTotalStats, "getTotalStats");
   async function syncTotalStats(ctx2) {
     try {
       const allStats = await ctx2.database.get("group_verification_stats", {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-group-verification",
   "description": "Koishi 群组加群验证插件，支持多关键词匹配审核、多种审核方式和详细统计功能",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/src/index.ts

@@ -536,132 +536,211 @@ export function apply(ctx: Context, config: Config) {
 
   // Subcommand: approve join request
   groupVerify
-    .subcommand('.approve <userId>', '同意用户加群申请')
-    .alias('accept', '同意', 'appr', '通过')
+    .subcommand('.approve [userId]', '同意加群申请')
+    .alias('accept', '同意', '通过', 'gva')
     .action(async ({ session }, userId) => {
       // 权限检查
-      if (!(await checkPermission(session))) {
-        return '权限不足'
+      const [hasPermission, errorMsg] = await checkPermission(session)
+      if (!hasPermission) {
+        return errorMsg || '权限不足'
       }
 
-      if (!session.guildId) {
+      const groupId = session.guildId
+      if (!groupId) {
         return '请在群聊中使用此命令'
       }
-      
-      if (!userId) {
-        return '请提供用户ID'
+
+      // 处理默认情况和all情况
+      if (!userId || userId.toLowerCase() === 'all') {
+        if (userId?.toLowerCase() === 'all') {
+          // 处理所有待审核申请
+          const pendingRequests = await ctx.database.get('group_verification_pending', { groupId })
+          if (pendingRequests.length === 0) {
+            return '当前无待审核的加群申请'
+          }
+          
+          let approvedCount = 0
+          for (const request of pendingRequests) {
+            try {
+              // TODO: 需要获取实际的requestId来进行审批
+              // await session.bot.handleGuildMemberRequest(request.requestId, true)
+              await ctx.database.remove('group_verification_pending', { id: request.id })
+              await updateStats(groupId, 'manuallyApproved')
+              approvedCount++
+            } catch (error) {
+              logger.warn(`处理申请 ${request.id} 时出错:`, error)
+            }
+          }
+          
+          return `已处理 ${approvedCount} 个加群申请`
+        } else {
+          // 处理最近的一个申请
+          const recentRequest = await ctx.database.get('group_verification_pending', { groupId }, ['id', 'userId', 'userName'])
+          if (recentRequest.length === 0) {
+            return '当前无待审核的加群申请'
+          }
+          
+          const request = recentRequest[0]
+          try {
+            // 这里需要获取实际的requestId，暂时用userId作为示例
+            await session.bot.handleGuildMemberRequest(request.userId, true)
+            await ctx.database.remove('group_verification_pending', { id: request.id })
+            await updateStats(groupId, 'manuallyApproved')
+            return `已同意用户 ${request.userName}(${request.userId}) 的加群申请`
+          } catch (error) {
+            return `处理申请时出错: ${error.message}`
+          }
+        }
       }
-      
-      // Find pending applications
-      const pendingApplications = await ctx.database.get('group_verification_pending', {
-        groupId: session.guildId,
-        userId: userId
+
+      // 处理指定用户ID的情况
+      const pendingRequests = await ctx.database.get('group_verification_pending', { 
+        groupId, 
+        userId: userId 
       })
-      
-      if (pendingApplications.length === 0) {
+
+      if (pendingRequests.length === 0) {
         return `未找到用户 ${userId} 的待审核申请`
       }
-      
-      const application = pendingApplications[0]
-      
-      // Remove pending record
-      await ctx.database.remove('group_verification_pending', { id: application.id })
-      await updateStats(session.guildId, 'manuallyApproved')
-      
-      return `已同意用户 ${application.userName}(${userId}) 的加群申请`
+
+      const request = pendingRequests[0]
+      try {
+        // 这里需要获取实际的requestId来进行审批
+        await session.bot.handleGuildMemberRequest(request.userId, true)
+        await ctx.database.remove('group_verification_pending', { id: request.id })
+        await updateStats(groupId, 'manuallyApproved')
+        return `已同意用户 ${request.userName}(${userId}) 的加群申请`
+      } catch (error) {
+        return `处理申请时出错: ${error.message}`
+      }
     })
 
   // Subcommand: reject join request
   groupVerify
-    .subcommand('.reject <userId>', '拒绝用户加群申请')
-    .alias('拒绝', 'rej', '拒绝')
+    .subcommand('.reject [userId]', '拒绝加群申请')
+    .alias('拒绝', 'rej', 'gvr')
     .action(async ({ session }, userId) => {
       // 权限检查
-      if (!(await checkPermission(session))) {
-        return '权限不足'
+      const [hasPermission, errorMsg] = await checkPermission(session)
+      if (!hasPermission) {
+        return errorMsg || '权限不足'
       }
 
-      if (!session.guildId) {
+      const groupId = session.guildId
+      if (!groupId) {
         return '请在群聊中使用此命令'
       }
-      
-      if (!userId) {
-        return '请提供用户ID'
+
+      // 处理默认情况和all情况
+      if (!userId || userId.toLowerCase() === 'all') {
+        if (userId?.toLowerCase() === 'all') {
+          // 拒绝所有待审核申请
+          const pendingRequests = await ctx.database.get('group_verification_pending', { groupId })
+          if (pendingRequests.length === 0) {
+            return '当前无待审核的加群申请'
+          }
+          
+          let rejectedCount = 0
+          for (const request of pendingRequests) {
+            try {
+              // TODO: 需要获取实际的requestId来进行拒绝
+              // await session.bot.handleGuildMemberRequest(request.requestId, false)
+              await ctx.database.remove('group_verification_pending', { id: request.id })
+              await updateStats(groupId, 'rejected')
+              rejectedCount++
+            } catch (error) {
+              logger.warn(`处理申请 ${request.id} 时出错:`, error)
+            }
+          }
+          
+          return `已拒绝 ${rejectedCount} 个加群申请`
+        } else {
+          // 拒绝最近的一个申请
+          const recentRequest = await ctx.database.get('group_verification_pending', { groupId }, ['id', 'userId', 'userName'])
+          if (recentRequest.length === 0) {
+            return '当前无待审核的加群申请'
+          }
+          
+          const request = recentRequest[0]
+          try {
+            // TODO: 需要获取实际的requestId来进行拒绝
+            // await session.bot.handleGuildMemberRequest(request.requestId, false)
+            await ctx.database.remove('group_verification_pending', { id: request.id })
+            await updateStats(groupId, 'rejected')
+            return `已拒绝用户 ${request.userName}(${request.userId}) 的加群申请`
+          } catch (error) {
+            return `处理申请时出错: ${error.message}`
+          }
+        }
       }
-      
-      // Find pending applications
-      const pendingApplications = await ctx.database.get('group_verification_pending', {
-        groupId: session.guildId,
-        userId: userId
+
+      // 处理指定用户ID的情况
+      const pendingRequests = await ctx.database.get('group_verification_pending', { 
+        groupId, 
+        userId: userId 
       })
-      
-      if (pendingApplications.length === 0) {
+
+      if (pendingRequests.length === 0) {
         return `未找到用户 ${userId} 的待审核申请`
       }
-      
-      const application = pendingApplications[0]
-      
-      // Remove pending record
-      await ctx.database.remove('group_verification_pending', { id: application.id })
-      await updateStats(session.guildId, 'rejected')
-      
-      return `已拒绝用户 ${application.userName}(${userId}) 的加群申请`
+
+      const request = pendingRequests[0]
+      try {
+        // TODO: 需要获取实际的requestId来进行拒绝
+        // await session.bot.handleGuildMemberRequest(request.requestId, false)
+        await ctx.database.remove('group_verification_pending', { id: request.id })
+        await updateStats(groupId, 'rejected')
+        return `已拒绝用户 ${request.userName}(${userId}) 的加群申请`
+      } catch (error) {
+        return `处理申请时出错: ${error.message}`
+      }
     })
 
   // Subcommand: view statistics
   groupVerify
-    .subcommand('.stats [groupId]', '查看群组验证统计信息')
+    .subcommand('.stats [target]', '查看群组验证统计信息')
     .alias('统计', 'stat', 'statistics')
-    .option('total', '-t 显示总计统计')
-    .action(async ({ session, options }, groupId) => {
-      // 权限检查（统计命令相对宽松，任意用户可查看）
-      const targetGroupId = groupId || session.guildId
+    .action(async ({ session }, target) => {
+      // 参数验证：只能是群号、all、total或空
+      const validTargets = ['all', 'total']
+      const isGroupId = target && /^\d+$/.test(target)
+      const isSpecialTarget = target && validTargets.includes(target.toLowerCase())
+      
+      if (target && !isGroupId && !isSpecialTarget) {
+        return '参数错误：只能指定群号、all、total或留空'
+      }
       
-      if (!targetGroupId && !options.total) {
-        return '请在群聊中使用此命令或指定群号，或使用 -t 参数查看总计统计'
+      // 权限检查：总计统计需要3级以上权限
+      if (target?.toLowerCase() === 'total' || target?.toLowerCase() === 'all') {
+        // 检查是否为koishi 3级以上权限
+        const koishiAuthority = (session as any).author?.authority || (session as any).user?.authority
+        if (!(koishiAuthority && koishiAuthority >= 3)) {
+          return '查看总计统计需要koishi 3级以上权限'
+        }
       }
       
-      let statsList: GroupVerificationStats[] = []
+      const groupId = session.guildId
       
-      if (options.total) {
-        // 显示总计统计
-        const totalStats = await ctx.database.get('group_verification_stats', { groupId: 'TOTAL' })
-        if (totalStats.length > 0) {
-          statsList.push(totalStats[0])
-        }
-        
-        // 如果同时指定了具体群号，也显示该群统计
-        if (targetGroupId && targetGroupId !== 'TOTAL') {
-          const groupStats = await ctx.database.get('group_verification_stats', { groupId: targetGroupId })
-          statsList = statsList.concat(groupStats)
+      // 处理不同参数情况
+      if (!target) {
+        // 无参数：显示当前群统计
+        if (!groupId) {
+          return '请在群聊中使用此命令或指定群号'
         }
-      } else {
-        // 显示指定群统计
-        const groupStats = await ctx.database.get('group_verification_stats', { groupId: targetGroupId })
-        statsList = groupStats
+        return await getGroupStats(groupId)
       }
       
-      if (statsList.length === 0) {
-        if (options.total) {
-          return '暂无统计信息'
-        } else {
-          return `群 ${targetGroupId} 暂无验证统计信息`
-        }
+      if (target.toLowerCase() === 'all' || target.toLowerCase() === 'total') {
+        // 显示总计统计
+        return await getTotalStats()
       }
       
-      let result = ''
-      for (const stats of statsList) {
-        const groupName = stats.groupId === 'TOTAL' ? '总计' : `群 ${stats.groupId}`
-        const lastUpdated = new Date(stats.lastUpdated).toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' })
-        
-        result += `${groupName} 验证统计：
-自动批准: ${stats.autoApproved}
-手动批准: ${stats.manuallyApproved}
-拒绝: ${stats.rejected}
-最后更新: ${lastUpdated}\n\n`
+      if (isGroupId) {
+        // 显示指定群统计
+        return await getGroupStats(target)
       }
       
-      return result.trim()
+      return '参数错误'
     })
 
   // Subcommand: view pending requests
@@ -760,6 +839,42 @@ export function apply(ctx: Context, config: Config) {
     await syncTotalStats(ctx)
   })
   
+  // 辅助函数：获取群组统计
+  async function getGroupStats(groupId: string): Promise<string> {
+    const stats = await ctx.database.get('group_verification_stats', { groupId })
+    
+    if (stats.length === 0) {
+      return `群 ${groupId} 暂无验证统计信息`
+    }
+    
+    const stat = stats[0]
+    const lastUpdated = new Date(stat.lastUpdated).toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' })
+    
+    return `群 ${groupId} 验证统计：
+自动批准: ${stat.autoApproved}
+手动批准: ${stat.manuallyApproved}
+拒绝: ${stat.rejected}
+最后更新: ${lastUpdated}`
+  }
+  
+  // 辅助函数：获取总计统计
+  async function getTotalStats(): Promise<string> {
+    const stats = await ctx.database.get('group_verification_stats', { groupId: 'TOTAL' })
+    
+    if (stats.length === 0) {
+      return '暂无统计信息'
+    }
+    
+    const stat = stats[0]
+    const lastUpdated = new Date(stat.lastUpdated).toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' })
+    
+    return `总计验证统计：
+自动批准: ${stat.autoApproved}
+手动批准: ${stat.manuallyApproved}
+拒绝: ${stat.rejected}
+最后更新: ${lastUpdated}`
+  }
+  
   // 同步统计数据到总计行的函数
   async function syncTotalStats(ctx: Context) {
     try {