koishi-plugin-bind-bot 2.0.4 → 2.1.0

package/lib/services/database.service.js

@@ -0,0 +1,451 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseService = void 0;
+const helpers_1 = require("../utils/helpers");
+/**
+ * 数据库服务层
+ * 统一管理数据库操作，包括 MC 绑定和 BUID 绑定的 CRUD
+ */
+class DatabaseService {
+    ctx;
+    logger;
+    mcidbindRepo;
+    normalizeQQId;
+    getUsernameByUuid;
+    constructor(ctx, logger, mcidbindRepo, normalizeQQId, getUsernameByUuid) {
+        this.ctx = ctx;
+        this.logger = logger;
+        this.mcidbindRepo = mcidbindRepo;
+        this.normalizeQQId = normalizeQQId;
+        this.getUsernameByUuid = getUsernameByUuid;
+    }
+    // =========== MC 绑定相关 ===========
+    /**
+     * 根据 QQ 号查询 MC 绑定信息
+     */
+    async getMcBindByQQId(qqId) {
+        try {
+            // 处理空值
+            if (!qqId) {
+                this.logger.warn('MCIDBIND', `尝试查询空QQ号`);
+                return null;
+            }
+            const normalizedQQId = this.normalizeQQId(qqId);
+            // 查询MCIDBIND表中对应QQ号的绑定记录
+            return await this.mcidbindRepo.findByQQId(normalizedQQId);
+        }
+        catch (error) {
+            this.logger.error('MCIDBIND', `根据QQ号查询绑定信息失败: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * 根据 MC 用户名查询绑定信息
+     */
+    async getMcBindByUsername(mcUsername) {
+        // 处理空值
+        if (!mcUsername) {
+            this.logger.warn('MCIDBIND', `尝试查询空MC用户名`);
+            return null;
+        }
+        // 使用 Repository 查询
+        return await this.mcidbindRepo.findByMCUsername(mcUsername);
+    }
+    /**
+     * 创建或更新 MC 绑定
+     */
+    async createOrUpdateMcBind(userId, mcUsername, mcUuid, isAdmin) {
+        try {
+            // 验证输入参数
+            if (!userId) {
+                this.logger.error('MCIDBIND', `创建/更新绑定失败: 无效的用户ID`);
+                return false;
+            }
+            if (!mcUsername) {
+                this.logger.error('MCIDBIND', `创建/更新绑定失败: 无效的MC用户名`);
+                return false;
+            }
+            const normalizedQQId = this.normalizeQQId(userId);
+            if (!normalizedQQId) {
+                this.logger.error('MCIDBIND', `创建/更新绑定失败: 无法提取有效的QQ号`);
+                return false;
+            }
+            // 查询是否已存在绑定记录
+            let bind = await this.getMcBindByQQId(normalizedQQId);
+            if (bind) {
+                // 更新现有记录，但保留管理员状态
+                const updateData = {
+                    mcUsername,
+                    mcUuid,
+                    lastModified: new Date()
+                };
+                // 仅当指定了isAdmin参数时更新管理员状态
+                if (typeof isAdmin !== 'undefined') {
+                    updateData.isAdmin = isAdmin;
+                }
+                await this.mcidbindRepo.update(normalizedQQId, updateData);
+                this.logger.info('MCIDBIND', `更新绑定: QQ=${normalizedQQId}, MC用户名=${mcUsername}, UUID=${mcUuid}`, true);
+                return true;
+            }
+            else {
+                // 创建新记录
+                try {
+                    await this.mcidbindRepo.create({
+                        qqId: normalizedQQId,
+                        mcUsername,
+                        mcUuid,
+                        lastModified: new Date(),
+                        isAdmin: isAdmin || false
+                    });
+                    this.logger.info('MCIDBIND', `创建绑定: QQ=${normalizedQQId}, MC用户名=${mcUsername}, UUID=${mcUuid}`, true);
+                    return true;
+                }
+                catch (createError) {
+                    this.logger.error('MCIDBIND', `创建绑定失败: MC用户名=${mcUsername}, 错误=${createError.message}`);
+                    return false;
+                }
+            }
+        }
+        catch (error) {
+            this.logger.error('MCIDBIND', `创建/更新绑定失败: MC用户名=${mcUsername}, 错误=${error.message}`);
+            return false;
+        }
+    }
+    /**
+     * 删除 MC 绑定（同时解绑 MC 和 B 站账号）
+     */
+    async deleteMcBind(userId) {
+        try {
+            // 验证输入参数
+            if (!userId) {
+                this.logger.error('MCIDBIND', `删除绑定失败: 无效的用户ID`);
+                return false;
+            }
+            const normalizedQQId = this.normalizeQQId(userId);
+            if (!normalizedQQId) {
+                this.logger.error('MCIDBIND', `删除绑定失败: 无法提取有效的QQ号`);
+                return false;
+            }
+            // 查询是否存在绑定记录
+            const bind = await this.getMcBindByQQId(normalizedQQId);
+            if (bind) {
+                // 删除整个绑定记录，包括MC和B站账号
+                const removedCount = await this.mcidbindRepo.delete(normalizedQQId);
+                // 检查是否真正删除成功
+                if (removedCount > 0) {
+                    let logMessage = `删除绑定: QQ=${normalizedQQId}`;
+                    if (bind.mcUsername)
+                        logMessage += `, MC用户名=${bind.mcUsername}`;
+                    if (bind.buidUid)
+                        logMessage += `, B站UID=${bind.buidUid}(${bind.buidUsername})`;
+                    this.logger.info('MCIDBIND', logMessage, true);
+                    return true;
+                }
+                else {
+                    this.logger.warn('MCIDBIND', `删除绑定异常: QQ=${normalizedQQId}, 可能未实际删除`);
+                    return false;
+                }
+            }
+            this.logger.warn('MCIDBIND', `删除绑定失败: QQ=${normalizedQQId}不存在绑定记录`);
+            return false;
+        }
+        catch (error) {
+            this.logger.error('MCIDBIND', `删除绑定失败: 错误=${error.message}`);
+            return false;
+        }
+    }
+    /**
+     * 检查 MC 用户名是否已被其他 QQ 号绑定（支持不区分大小写和 UUID 检查）
+     */
+    async checkUsernameExists(username, currentUserId, uuid) {
+        try {
+            // 验证输入参数
+            if (!username) {
+                this.logger.warn('绑定检查', `尝试检查空MC用户名`);
+                return false;
+            }
+            // 跳过临时用户名的检查
+            if (username.startsWith('_temp_')) {
+                return false;
+            }
+            // 使用不区分大小写的查询
+            const bind = await this.mcidbindRepo.findByUsernameIgnoreCase(username);
+            // 如果没有绑定，返回false
+            if (!bind)
+                return false;
+            // 如果绑定的用户名是临时用户名，视为未绑定
+            if (bind.mcUsername && bind.mcUsername.startsWith('_temp_')) {
+                return false;
+            }
+            // 如果提供了 UUID，检查是否为同一个 MC 账号（用户改名场景）
+            if (uuid && bind.mcUuid) {
+                const cleanUuid = uuid.replace(/-/g, '');
+                const bindCleanUuid = bind.mcUuid.replace(/-/g, '');
+                if (cleanUuid === bindCleanUuid) {
+                    // 同一个 UUID，说明是用户改名，允许绑定
+                    this.logger.info('绑定检查', `检测到MC账号改名: UUID=${uuid}, 旧用户名=${bind.mcUsername}, 新用户名=${username}`, true);
+                    return false;
+                }
+            }
+            // 如果提供了当前用户ID，需要排除当前用户
+            if (currentUserId) {
+                const normalizedCurrentId = this.normalizeQQId(currentUserId);
+                // 如果绑定的用户就是当前用户，返回false，表示没有被其他用户绑定
+                return normalizedCurrentId ? bind.qqId !== normalizedCurrentId : true;
+            }
+            return true;
+        }
+        catch (error) {
+            this.logger.error('绑定检查', `检查用户名"${username}"是否已被绑定失败: ${error.message}`);
+            return false;
+        }
+    }
+    // =========== BUID 绑定相关 ===========
+    /**
+     * 根据 B 站 UID 查询绑定信息
+     */
+    async getBuidBindByBuid(buid) {
+        try {
+            if (!buid) {
+                this.logger.warn('B站账号绑定', `尝试查询空B站UID`);
+                return null;
+            }
+            const bind = await this.mcidbindRepo.findByBuidUid(buid);
+            return bind;
+        }
+        catch (error) {
+            this.logger.error('B站账号绑定', `根据B站UID(${buid})查询绑定信息失败: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * 检查 B 站 UID 是否已被绑定
+     */
+    async checkBuidExists(buid, currentUserId) {
+        try {
+            const bind = await this.getBuidBindByBuid(buid);
+            if (!bind)
+                return false;
+            // 如果指定了当前用户ID，则排除当前用户的绑定
+            if (currentUserId) {
+                const normalizedCurrentId = this.normalizeQQId(currentUserId);
+                return bind.qqId !== normalizedCurrentId;
+            }
+            return true;
+        }
+        catch (error) {
+            this.logger.error('B站账号绑定', `检查B站UID(${buid})是否存在时出错: ${error.message}`);
+            return false;
+        }
+    }
+    /**
+     * 创建或更新 B 站账号绑定
+     */
+    async createOrUpdateBuidBind(userId, buidUser) {
+        try {
+            const normalizedQQId = this.normalizeQQId(userId);
+            if (!normalizedQQId) {
+                this.logger.error('B站账号绑定', `创建/更新绑定失败: 无法提取有效的QQ号`);
+                return false;
+            }
+            // 检查该UID是否已被其他用户绑定（安全检查）
+            const existingBuidBind = await this.getBuidBindByBuid(buidUser.uid);
+            if (existingBuidBind && existingBuidBind.qqId !== normalizedQQId) {
+                this.logger.error('B站账号绑定', `安全检查失败: B站UID ${buidUser.uid} 已被QQ(${existingBuidBind.qqId})绑定，无法为QQ(${normalizedQQId})绑定`);
+                return false;
+            }
+            // 查询是否已存在绑定记录
+            let bind = await this.getMcBindByQQId(normalizedQQId);
+            const updateData = {
+                buidUid: buidUser.uid.toString(), // 转换为字符串存储
+                buidUsername: buidUser.username,
+                guardLevel: buidUser.guard_level || 0,
+                guardLevelText: buidUser.guard_level_text || '',
+                maxGuardLevel: buidUser.max_guard_level || 0,
+                maxGuardLevelText: buidUser.max_guard_level_text || '',
+                medalName: buidUser.medal?.name || '',
+                medalLevel: buidUser.medal?.level || 0,
+                wealthMedalLevel: buidUser.wealthMedalLevel || 0,
+                lastActiveTime: buidUser.last_active_time ? new Date(buidUser.last_active_time) : new Date(),
+                lastModified: new Date()
+            };
+            if (bind) {
+                await this.mcidbindRepo.update(normalizedQQId, updateData);
+                this.logger.info('B站账号绑定', `更新绑定: QQ=${normalizedQQId}, B站UID=${buidUser.uid}, 用户名=${buidUser.username}`, true);
+            }
+            else {
+                // 为跳过MC绑定的用户生成唯一的临时用户名，避免UNIQUE constraint冲突
+                const tempMcUsername = `_temp_skip_${normalizedQQId}_${Date.now()}`;
+                const newBind = {
+                    qqId: normalizedQQId,
+                    mcUsername: tempMcUsername,
+                    mcUuid: '',
+                    isAdmin: false,
+                    whitelist: [],
+                    tags: [],
+                    ...updateData
+                };
+                await this.mcidbindRepo.create(newBind);
+                this.logger.info('B站账号绑定', `创建绑定(跳过MC): QQ=${normalizedQQId}, B站UID=${buidUser.uid}, 用户名=${buidUser.username}, 临时MC用户名=${tempMcUsername}`, true);
+            }
+            return true;
+        }
+        catch (error) {
+            this.logger.error('B站账号绑定', `创建/更新B站账号绑定失败: ${error.message}`);
+            return false;
+        }
+    }
+    /**
+     * 仅更新 B 站信息，不更新绑定时间（用于查询时刷新数据）
+     */
+    async updateBuidInfoOnly(userId, buidUser) {
+        try {
+            const normalizedQQId = this.normalizeQQId(userId);
+            if (!normalizedQQId) {
+                this.logger.error('B站账号信息更新', `更新失败: 无法提取有效的QQ号`);
+                return false;
+            }
+            // 查询是否已存在绑定记录
+            const bind = await this.getMcBindByQQId(normalizedQQId);
+            if (!bind) {
+                this.logger.warn('B站账号信息更新', `QQ(${normalizedQQId})没有绑定记录，无法更新B站信息`);
+                return false;
+            }
+            // 仅更新B站相关字段，不更新lastModified
+            const updateData = {
+                buidUsername: buidUser.username,
+                guardLevel: buidUser.guard_level || 0,
+                guardLevelText: buidUser.guard_level_text || '',
+                maxGuardLevel: buidUser.max_guard_level || 0,
+                maxGuardLevelText: buidUser.max_guard_level_text || '',
+                medalName: buidUser.medal?.name || '',
+                medalLevel: buidUser.medal?.level || 0,
+                wealthMedalLevel: buidUser.wealthMedalLevel || 0,
+                lastActiveTime: buidUser.last_active_time ? new Date(buidUser.last_active_time) : new Date()
+            };
+            await this.mcidbindRepo.update(normalizedQQId, updateData);
+            this.logger.info('B站账号信息更新', `刷新信息: QQ=${normalizedQQId}, B站UID=${bind.buidUid}, 用户名=${buidUser.username}`, true);
+            return true;
+        }
+        catch (error) {
+            this.logger.error('B站账号信息更新', `更新B站账号信息失败: ${error.message}`);
+            return false;
+        }
+    }
+    // =========== 用户名更新检查 ===========
+    /**
+     * 检查并更新用户名（如果与当前数据库中的不同）
+     */
+    async checkAndUpdateUsername(bind) {
+        try {
+            if (!bind || !bind.mcUuid) {
+                this.logger.warn('用户名更新', `无法检查用户名更新: 空绑定或空UUID`);
+                return bind;
+            }
+            // 通过UUID查询最新用户名
+            const latestUsername = await this.getUsernameByUuid(bind.mcUuid);
+            if (!latestUsername) {
+                this.logger.warn('用户名更新', `无法获取UUID "${bind.mcUuid}" 的最新用户名`);
+                return bind;
+            }
+            // 如果用户名与数据库中的不同，更新数据库（使用规范化比较，不区分大小写）
+            const normalizedLatest = (0, helpers_1.normalizeUsername)(latestUsername);
+            const normalizedCurrent = (0, helpers_1.normalizeUsername)(bind.mcUsername);
+            if (normalizedLatest !== normalizedCurrent) {
+                this.logger.info('用户名更新', `用户 QQ(${bind.qqId}) 的Minecraft用户名已变更: ${bind.mcUsername} -> ${latestUsername}`, true);
+                // 更新数据库中的用户名
+                await this.mcidbindRepo.update(bind.qqId, {
+                    mcUsername: latestUsername
+                });
+                // 更新返回的绑定对象
+                bind.mcUsername = latestUsername;
+            }
+            return bind;
+        }
+        catch (error) {
+            this.logger.error('用户名更新', `检查和更新用户名失败: ${error.message}`);
+            return bind;
+        }
+    }
+    /**
+     * 智能缓存版本的改名检测函数
+     * 特性：
+     * - 24小时冷却期（失败>=3次时延长到72小时）
+     * - 失败计数追踪
+     * - 成功时重置失败计数
+     */
+    async checkAndUpdateUsernameWithCache(bind) {
+        try {
+            if (!bind || !bind.mcUuid) {
+                this.logger.warn('改名检测缓存', `无法检查用户名更新: 空绑定或空UUID`);
+                return bind;
+            }
+            const now = new Date();
+            const failCount = bind.usernameCheckFailCount || 0;
+            // 根据失败次数决定冷却期：普通24小时，失败>=3次则72小时
+            const cooldownHours = failCount >= 3 ? 72 : 24;
+            // 检查是否在冷却期内
+            if (bind.usernameLastChecked) {
+                const lastCheck = new Date(bind.usernameLastChecked);
+                const hoursSinceCheck = (now.getTime() - lastCheck.getTime()) / (1000 * 60 * 60);
+                if (hoursSinceCheck < cooldownHours) {
+                    this.logger.debug('改名检测缓存', `QQ(${bind.qqId}) 在冷却期内(${hoursSinceCheck.toFixed(1)}h/${cooldownHours}h)，跳过检查`);
+                    return bind;
+                }
+            }
+            this.logger.debug('改名检测缓存', `QQ(${bind.qqId}) 开始检查用户名变更（失败计数: ${failCount}）`);
+            // 执行实际的改名检测
+            const oldUsername = bind.mcUsername;
+            const updatedBind = await this.checkAndUpdateUsername(bind);
+            // 判断检测是否成功
+            const detectionSuccess = updatedBind.mcUsername !== null && updatedBind.mcUsername !== undefined;
+            if (detectionSuccess) {
+                // 检测成功
+                const usernameChanged = (0, helpers_1.normalizeUsername)(updatedBind.mcUsername) !== (0, helpers_1.normalizeUsername)(oldUsername);
+                // 更新检查时间和重置失败计数
+                await this.mcidbindRepo.update(bind.qqId, {
+                    usernameLastChecked: now,
+                    usernameCheckFailCount: 0
+                });
+                if (usernameChanged) {
+                    this.logger.info('改名检测缓存', `QQ(${bind.qqId}) 用户名已变更: ${oldUsername} -> ${updatedBind.mcUsername}`, true);
+                }
+                else {
+                    this.logger.debug('改名检测缓存', `QQ(${bind.qqId}) 用户名无变更: ${updatedBind.mcUsername}`);
+                }
+                // 更新返回对象的缓存字段
+                updatedBind.usernameLastChecked = now;
+                updatedBind.usernameCheckFailCount = 0;
+            }
+            else {
+                // 检测失败（API失败或返回null）
+                const newFailCount = failCount + 1;
+                await this.mcidbindRepo.update(bind.qqId, {
+                    usernameLastChecked: now,
+                    usernameCheckFailCount: newFailCount
+                });
+                this.logger.warn('改名检测缓存', `QQ(${bind.qqId}) 检测失败，失败计数: ${newFailCount}`);
+                // 更新返回对象的缓存字段
+                updatedBind.usernameLastChecked = now;
+                updatedBind.usernameCheckFailCount = newFailCount;
+            }
+            return updatedBind;
+        }
+        catch (error) {
+            this.logger.error('改名检测缓存', `检查和更新用户名失败: ${error.message}`);
+            // 失败时也更新检查时间和递增失败计数
+            try {
+                const failCount = bind.usernameCheckFailCount || 0;
+                await this.mcidbindRepo.update(bind.qqId, {
+                    usernameLastChecked: new Date(),
+                    usernameCheckFailCount: failCount + 1
+                });
+            }
+            catch (updateError) {
+                this.logger.error('改名检测缓存', `更新失败计数时出错: ${updateError.message}`);
+            }
+            return bind;
+        }
+    }
+}
+exports.DatabaseService = DatabaseService;

package/lib/services/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 服务层统一导出
+ */
+export * from './api.service';
+export * from './database.service';
+export * from './nickname.service';

package/lib/services/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 服务层统一导出
+ */
+__exportStar(require("./api.service"), exports);
+__exportStar(require("./database.service"), exports);
+__exportStar(require("./nickname.service"), exports);

package/lib/services/nickname.service.d.ts

@@ -0,0 +1,42 @@
+import { Session } from 'koishi';
+import { LoggerService } from '../utils/logger';
+import type { ZminfoUser } from '../types';
+/**
+ * 群昵称管理服务
+ * 负责自动设置和验证群昵称
+ */
+export declare class NicknameService {
+    private logger;
+    private config;
+    private normalizeQQId;
+    private validateBUID;
+    private getBilibiliOfficialUserInfo;
+    private updateBuidInfoOnly;
+    constructor(logger: LoggerService, config: {
+        autoNicknameGroupId: string;
+    }, normalizeQQId: (userId: string) => string, validateBUID: (buid: string) => Promise<ZminfoUser | null>, getBilibiliOfficialUserInfo: (uid: string) => Promise<{
+        name: string;
+        mid: number;
+    } | null>, updateBuidInfoOnly: (userId: string, buidUser: ZminfoUser) => Promise<boolean>);
+    /**
+     * 检查群昵称格式是否正确
+     */
+    checkNicknameFormat(nickname: string, buidUsername: string, mcUsername: string | null): boolean;
+    /**
+     * 使用四层判断逻辑获取最准确的B站用户名
+     * 优先级：官方API > ZMINFO > 数据库
+     */
+    private getLatestBuidUsername;
+    /**
+     * 同步数据库中的B站用户信息
+     */
+    private syncDatabaseIfNeeded;
+    /**
+     * 设置群昵称并验证
+     */
+    private setAndVerifyNickname;
+    /**
+     * 自动群昵称设置功能（重构版）
+     */
+    autoSetGroupNickname(session: Session, mcUsername: string | null, buidUsername: string, buidUid?: string, targetUserId?: string, specifiedGroupId?: string): Promise<void>;
+}