koishi-plugin-bind-bot 2.0.0

package/lib/repositories/mcidbind.repository.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCIDBINDRepository = void 0;
+/**
+ * MCIDBIND 数据仓储类
+ * 封装所有 MCIDBIND 表的数据库操作
+ */
+class MCIDBINDRepository {
+    ctx;
+    logger;
+    constructor(ctx, logger) {
+        this.ctx = ctx;
+        this.logger = logger;
+    }
+    /**
+     * 根据 QQ 号查询绑定信息
+     * @param qqId QQ号（已规范化）
+     * @returns 绑定信息或 null
+     */
+    async findByQQId(qqId) {
+        try {
+            this.logger.debug('数据库', `查询QQ(${qqId})的绑定信息`);
+            const binds = await this.ctx.database.get('mcidbind', { qqId });
+            return binds.length > 0 ? binds[0] : null;
+        }
+        catch (error) {
+            this.logger.error('数据库', `查询QQ(${qqId})绑定信息失败: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * 根据 MC 用户名查询绑定信息
+     * @param mcUsername MC用户名
+     * @returns 绑定信息或 null
+     */
+    async findByMCUsername(mcUsername) {
+        try {
+            this.logger.debug('数据库', `查询MC用户名(${mcUsername})的绑定信息`);
+            const binds = await this.ctx.database.get('mcidbind', { mcUsername });
+            return binds.length > 0 ? binds[0] : null;
+        }
+        catch (error) {
+            this.logger.error('数据库', `查询MC用户名(${mcUsername})绑定信息失败: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * 根据 B站 UID 查询绑定信息
+     * @param buidUid B站UID
+     * @returns 绑定信息或 null
+     */
+    async findByBuidUid(buidUid) {
+        try {
+            this.logger.debug('数据库', `查询B站UID(${buidUid})的绑定信息`);
+            const binds = await this.ctx.database.get('mcidbind', { buidUid });
+            return binds.length > 0 ? binds[0] : null;
+        }
+        catch (error) {
+            this.logger.error('数据库', `查询B站UID(${buidUid})绑定信息失败: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * 获取所有绑定记录
+     * @param options 查询选项
+     * @returns 绑定记录列表
+     */
+    async findAll(options) {
+        try {
+            this.logger.debug('数据库', `获取所有绑定记录${options?.limit ? ` (limit: ${options.limit})` : ''}`);
+            const records = await this.ctx.database.get('mcidbind', {}, options);
+            return records;
+        }
+        catch (error) {
+            this.logger.error('数据库', `获取所有绑定记录失败: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * 根据标签查询绑定记录
+     * @param tag 标签名称
+     * @returns 包含该标签的绑定记录列表
+     */
+    async findByTag(tag) {
+        try {
+            this.logger.debug('数据库', `查询包含标签"${tag}"的绑定记录`);
+            const allRecords = await this.ctx.database.get('mcidbind', {});
+            return allRecords.filter(record => record.tags && record.tags.includes(tag));
+        }
+        catch (error) {
+            this.logger.error('数据库', `查询标签"${tag}"的绑定记录失败: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * 创建新的绑定记录
+     * @param data 绑定数据
+     * @returns 创建的记录
+     */
+    async create(data) {
+        try {
+            this.logger.debug('数据库', `创建QQ(${data.qqId})的绑定记录`);
+            const created = await this.ctx.database.create('mcidbind', data);
+            this.logger.info('数据库', `成功创建QQ(${data.qqId})的绑定记录`, true);
+            return created;
+        }
+        catch (error) {
+            this.logger.error('数据库', `创建QQ(${data.qqId})绑定记录失败: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * 更新绑定记录（部分字段）
+     * @param qqId QQ号
+     * @param data 要更新的字段
+     */
+    async update(qqId, data) {
+        try {
+            this.logger.debug('数据库', `更新QQ(${qqId})的绑定记录`);
+            await this.ctx.database.set('mcidbind', { qqId }, data);
+            this.logger.info('数据库', `成功更新QQ(${qqId})的绑定记录`, true);
+        }
+        catch (error) {
+            this.logger.error('数据库', `更新QQ(${qqId})绑定记录失败: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * 删除绑定记录
+     * @param qqId QQ号
+     * @returns 删除的记录数
+     */
+    async delete(qqId) {
+        try {
+            this.logger.debug('数据库', `删除QQ(${qqId})的绑定记录`);
+            const result = await this.ctx.database.remove('mcidbind', { qqId });
+            this.logger.info('数据库', `成功删除QQ(${qqId})的绑定记录（删除${result.removed}条）`, true);
+            return result.removed;
+        }
+        catch (error) {
+            this.logger.error('数据库', `删除QQ(${qqId})绑定记录失败: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * 删除所有绑定记录
+     * @returns 删除的记录数
+     */
+    async deleteAll() {
+        try {
+            this.logger.debug('数据库', `删除所有绑定记录`);
+            const result = await this.ctx.database.remove('mcidbind', {});
+            this.logger.info('数据库', `成功删除所有绑定记录（删除${result.removed}条）`, true);
+            return result.removed;
+        }
+        catch (error) {
+            this.logger.error('数据库', `删除所有绑定记录失败: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * 批量创建绑定记录
+     * @param records 绑定记录列表
+     */
+    async batchCreate(records) {
+        try {
+            this.logger.debug('数据库', `批量创建${records.length}条绑定记录`);
+            for (const record of records) {
+                await this.ctx.database.create('mcidbind', record);
+            }
+            this.logger.info('数据库', `成功批量创建${records.length}条绑定记录`, true);
+        }
+        catch (error) {
+            this.logger.error('数据库', `批量创建绑定记录失败: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * 为用户添加标签
+     * @param qqId QQ号
+     * @param tag 标签名称
+     */
+    async addTag(qqId, tag) {
+        try {
+            const bind = await this.findByQQId(qqId);
+            if (!bind) {
+                throw new Error(`QQ(${qqId})的绑定记录不存在`);
+            }
+            const tags = bind.tags || [];
+            if (!tags.includes(tag)) {
+                tags.push(tag);
+                await this.update(qqId, { tags });
+                this.logger.info('数据库', `成功为QQ(${qqId})添加标签"${tag}"`, true);
+            }
+        }
+        catch (error) {
+            this.logger.error('数据库', `为QQ(${qqId})添加标签"${tag}"失败: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * 为用户移除标签
+     * @param qqId QQ号
+     * @param tag 标签名称
+     */
+    async removeTag(qqId, tag) {
+        try {
+            const bind = await this.findByQQId(qqId);
+            if (!bind) {
+                throw new Error(`QQ(${qqId})的绑定记录不存在`);
+            }
+            const tags = bind.tags || [];
+            const index = tags.indexOf(tag);
+            if (index > -1) {
+                tags.splice(index, 1);
+                await this.update(qqId, { tags });
+                this.logger.info('数据库', `成功为QQ(${qqId})移除标签"${tag}"`, true);
+            }
+        }
+        catch (error) {
+            this.logger.error('数据库', `为QQ(${qqId})移除标签"${tag}"失败: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * 为用户添加白名单服务器
+     * @param qqId QQ号
+     * @param serverId 服务器ID
+     */
+    async addWhitelist(qqId, serverId) {
+        try {
+            const bind = await this.findByQQId(qqId);
+            if (!bind) {
+                throw new Error(`QQ(${qqId})的绑定记录不存在`);
+            }
+            const whitelist = bind.whitelist || [];
+            if (!whitelist.includes(serverId)) {
+                whitelist.push(serverId);
+                await this.update(qqId, { whitelist });
+                this.logger.info('数据库', `成功为QQ(${qqId})添加白名单服务器"${serverId}"`, true);
+            }
+        }
+        catch (error) {
+            this.logger.error('数据库', `为QQ(${qqId})添加白名单服务器"${serverId}"失败: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * 为用户移除白名单服务器
+     * @param qqId QQ号
+     * @param serverId 服务器ID
+     */
+    async removeWhitelist(qqId, serverId) {
+        try {
+            const bind = await this.findByQQId(qqId);
+            if (!bind) {
+                throw new Error(`QQ(${qqId})的绑定记录不存在`);
+            }
+            const whitelist = bind.whitelist || [];
+            const index = whitelist.indexOf(serverId);
+            if (index > -1) {
+                whitelist.splice(index, 1);
+                await this.update(qqId, { whitelist });
+                this.logger.info('数据库', `成功为QQ(${qqId})移除白名单服务器"${serverId}"`, true);
+            }
+        }
+        catch (error) {
+            this.logger.error('数据库', `为QQ(${qqId})移除白名单服务器"${serverId}"失败: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * 获取所有管理员
+     * @returns 管理员列表
+     */
+    async findAllAdmins() {
+        try {
+            this.logger.debug('数据库', `获取所有管理员`);
+            const allRecords = await this.ctx.database.get('mcidbind', {});
+            return allRecords.filter(record => record.isAdmin);
+        }
+        catch (error) {
+            this.logger.error('数据库', `获取所有管理员失败: ${error.message}`);
+            return [];
+        }
+    }
+}
+exports.MCIDBINDRepository = MCIDBINDRepository;

package/lib/repositories/schedule-mute.repository.d.ts

@@ -0,0 +1,68 @@
+import { Context } from 'koishi';
+import { LoggerService } from '../utils/logger';
+import type { SCHEDULE_MUTE_TASKS } from '../types';
+/**
+ * 定时禁言任务数据仓储类
+ * 封装所有 SCHEDULE_MUTE_TASKS 表的数据库操作
+ */
+export declare class ScheduleMuteRepository {
+    private ctx;
+    private logger;
+    constructor(ctx: Context, logger: LoggerService);
+    /**
+     * 根据 ID 查询定时禁言任务
+     * @param id 任务ID
+     * @returns 任务信息或 null
+     */
+    findById(id: number): Promise<SCHEDULE_MUTE_TASKS | null>;
+    /**
+     * 根据群组 ID 查询定时禁言任务
+     * @param groupId 群组ID
+     * @returns 任务列表
+     */
+    findByGroupId(groupId: string): Promise<SCHEDULE_MUTE_TASKS[]>;
+    /**
+     * 获取所有定时禁言任务
+     * @returns 任务列表
+     */
+    findAll(): Promise<SCHEDULE_MUTE_TASKS[]>;
+    /**
+     * 获取所有已启用的定时禁言任务
+     * @returns 任务列表
+     */
+    findAllEnabled(): Promise<SCHEDULE_MUTE_TASKS[]>;
+    /**
+     * 创建定时禁言任务
+     * @param data 任务数据
+     * @returns 创建的任务
+     */
+    create(data: Omit<SCHEDULE_MUTE_TASKS, 'id'>): Promise<SCHEDULE_MUTE_TASKS>;
+    /**
+     * 更新定时禁言任务
+     * @param id 任务ID
+     * @param data 要更新的字段
+     */
+    update(id: number, data: Partial<Omit<SCHEDULE_MUTE_TASKS, 'id'>>): Promise<void>;
+    /**
+     * 删除定时禁言任务
+     * @param id 任务ID
+     * @returns 删除的记录数
+     */
+    delete(id: number): Promise<number>;
+    /**
+     * 启用定时禁言任务
+     * @param id 任务ID
+     */
+    enable(id: number): Promise<void>;
+    /**
+     * 禁用定时禁言任务
+     * @param id 任务ID
+     */
+    disable(id: number): Promise<void>;
+    /**
+     * 删除群组的所有定时禁言任务
+     * @param groupId 群组ID
+     * @returns 删除的记录数
+     */
+    deleteByGroupId(groupId: string): Promise<number>;
+}

package/lib/repositories/schedule-mute.repository.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScheduleMuteRepository = void 0;
+/**
+ * 定时禁言任务数据仓储类
+ * 封装所有 SCHEDULE_MUTE_TASKS 表的数据库操作
+ */
+class ScheduleMuteRepository {
+    ctx;
+    logger;
+    constructor(ctx, logger) {
+        this.ctx = ctx;
+        this.logger = logger;
+    }
+    /**
+     * 根据 ID 查询定时禁言任务
+     * @param id 任务ID
+     * @returns 任务信息或 null
+     */
+    async findById(id) {
+        try {
+            this.logger.debug('数据库', `查询定时禁言任务ID(${id})`);
+            const tasks = await this.ctx.database.get('schedule_mute_tasks', { id });
+            return tasks.length > 0 ? tasks[0] : null;
+        }
+        catch (error) {
+            this.logger.error('数据库', `查询定时禁言任务ID(${id})失败: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * 根据群组 ID 查询定时禁言任务
+     * @param groupId 群组ID
+     * @returns 任务列表
+     */
+    async findByGroupId(groupId) {
+        try {
+            this.logger.debug('数据库', `查询群${groupId}的定时禁言任务`);
+            const tasks = await this.ctx.database.get('schedule_mute_tasks', { groupId });
+            return tasks;
+        }
+        catch (error) {
+            this.logger.error('数据库', `查询群${groupId}的定时禁言任务失败: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * 获取所有定时禁言任务
+     * @returns 任务列表
+     */
+    async findAll() {
+        try {
+            this.logger.debug('数据库', `获取所有定时禁言任务`);
+            const tasks = await this.ctx.database.get('schedule_mute_tasks', {});
+            return tasks;
+        }
+        catch (error) {
+            this.logger.error('数据库', `获取所有定时禁言任务失败: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * 获取所有已启用的定时禁言任务
+     * @returns 任务列表
+     */
+    async findAllEnabled() {
+        try {
+            this.logger.debug('数据库', `获取所有已启用的定时禁言任务`);
+            const tasks = await this.ctx.database.get('schedule_mute_tasks', { enabled: true });
+            return tasks;
+        }
+        catch (error) {
+            this.logger.error('数据库', `获取所有已启用的定时禁言任务失败: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * 创建定时禁言任务
+     * @param data 任务数据
+     * @returns 创建的任务
+     */
+    async create(data) {
+        try {
+            this.logger.debug('数据库', `创建群${data.groupId}的定时禁言任务`);
+            const created = await this.ctx.database.create('schedule_mute_tasks', data);
+            this.logger.info('数据库', `成功创建群${data.groupId}的定时禁言任务（ID:${created.id}）`, true);
+            return created;
+        }
+        catch (error) {
+            this.logger.error('数据库', `创建群${data.groupId}的定时禁言任务失败: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * 更新定时禁言任务
+     * @param id 任务ID
+     * @param data 要更新的字段
+     */
+    async update(id, data) {
+        try {
+            this.logger.debug('数据库', `更新定时禁言任务ID(${id})`);
+            await this.ctx.database.set('schedule_mute_tasks', { id }, data);
+            this.logger.info('数据库', `成功更新定时禁言任务ID(${id})`, true);
+        }
+        catch (error) {
+            this.logger.error('数据库', `更新定时禁言任务ID(${id})失败: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * 删除定时禁言任务
+     * @param id 任务ID
+     * @returns 删除的记录数
+     */
+    async delete(id) {
+        try {
+            this.logger.debug('数据库', `删除定时禁言任务ID(${id})`);
+            const result = await this.ctx.database.remove('schedule_mute_tasks', { id });
+            this.logger.info('数据库', `成功删除定时禁言任务ID(${id})（删除${result.removed}条）`, true);
+            return result.removed;
+        }
+        catch (error) {
+            this.logger.error('数据库', `删除定时禁言任务ID(${id})失败: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * 启用定时禁言任务
+     * @param id 任务ID
+     */
+    async enable(id) {
+        try {
+            this.logger.debug('数据库', `启用定时禁言任务ID(${id})`);
+            await this.ctx.database.set('schedule_mute_tasks', { id }, { enabled: true });
+            this.logger.info('数据库', `成功启用定时禁言任务ID(${id})`, true);
+        }
+        catch (error) {
+            this.logger.error('数据库', `启用定时禁言任务ID(${id})失败: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * 禁用定时禁言任务
+     * @param id 任务ID
+     */
+    async disable(id) {
+        try {
+            this.logger.debug('数据库', `禁用定时禁言任务ID(${id})`);
+            await this.ctx.database.set('schedule_mute_tasks', { id }, { enabled: false });
+            this.logger.info('数据库', `成功禁用定时禁言任务ID(${id})`, true);
+        }
+        catch (error) {
+            this.logger.error('数据库', `禁用定时禁言任务ID(${id})失败: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * 删除群组的所有定时禁言任务
+     * @param groupId 群组ID
+     * @returns 删除的记录数
+     */
+    async deleteByGroupId(groupId) {
+        try {
+            this.logger.debug('数据库', `删除群${groupId}的所有定时禁言任务`);
+            const result = await this.ctx.database.remove('schedule_mute_tasks', { groupId });
+            this.logger.info('数据库', `成功删除群${groupId}的所有定时禁言任务（删除${result.removed}条）`, true);
+            return result.removed;
+        }
+        catch (error) {
+            this.logger.error('数据库', `删除群${groupId}的所有定时禁言任务失败: ${error.message}`);
+            throw error;
+        }
+    }
+}
+exports.ScheduleMuteRepository = ScheduleMuteRepository;

package/lib/types/api.d.ts

@@ -0,0 +1,135 @@
+/**
+ * 外部API响应接口类型定义
+ * 包含 Mojang API、ZMINFO API 和 Bilibili API
+ */
+/**
+ * Mojang API 响应接口
+ * 用于获取MC用户UUID和用户名
+ */
+export interface MojangProfile {
+    id: string;
+    name: string;
+}
+/**
+ * ZMINFO API - 用户信息接口
+ */
+export interface ZminfoUser {
+    uid: string;
+    username: string;
+    avatar_url: string;
+    guard_level: number;
+    guard_level_text: string;
+    max_guard_level: number;
+    max_guard_level_text: string;
+    medal: {
+        name: string;
+        level: number;
+        uid: string;
+        room: number;
+    } | null;
+    wealthMedalLevel: number;
+    last_active_time: string;
+}
+/**
+ * ZMINFO API 响应接口
+ */
+export interface ZminfoApiResponse {
+    success: boolean;
+    message: string;
+    data?: {
+        user?: ZminfoUser;
+    };
+}
+/**
+ * Bilibili Live API - 粉丝勋章信息接口
+ */
+export interface MedalInfo {
+    target_id: number;
+    level: number;
+    medal_name: string;
+    medal_color_start: number;
+    medal_color_end: number;
+    medal_color_border: number;
+    guard_level: number;
+    wearing_status: number;
+    medal_id: number;
+    intimacy: number;
+    next_intimacy: number;
+    today_feed: number;
+    day_limit: number;
+    guard_icon: string;
+    honor_icon: string;
+}
+/**
+ * Bilibili Live API - 用户勋章信息接口
+ */
+export interface UinfoMedal {
+    name: string;
+    level: number;
+    color_start: number;
+    color_end: number;
+    color_border: number;
+    color: number;
+    id: number;
+    typ: number;
+    is_light: number;
+    ruid: number;
+    guard_level: number;
+    score: number;
+    guard_icon: string;
+    honor_icon: string;
+    v2_medal_color_start: string;
+    v2_medal_color_end: string;
+    v2_medal_color_border: string;
+    v2_medal_color_text: string;
+    v2_medal_color_level: string;
+    user_receive_count: number;
+}
+/**
+ * Bilibili Live API - 勋章列表项接口
+ */
+export interface MedalListItem {
+    medal_info: MedalInfo;
+    target_name: string;
+    target_icon: string;
+    link: string;
+    live_status: number;
+    official: number;
+    uinfo_medal: UinfoMedal;
+    data?: {
+        icon?: string;
+        uid?: number;
+        name?: string;
+    };
+}
+/**
+ * Bilibili Live API - 响应接口
+ */
+export interface BilibiliMedalAPIResponse {
+    code: number;
+    message: string;
+    ttl: number;
+    data?: {
+        list: MedalListItem[];
+        count: number;
+        close_space_medal: number;
+        only_show_wearing: number;
+        name: string;
+        icon: string;
+        uid: number;
+        level: number;
+    };
+}
+/**
+ * 扩展的ZMINFO用户信息接口
+ * 包含目标粉丝牌数据（用于强制绑定）
+ */
+export interface EnhancedZminfoUser extends ZminfoUser {
+    targetMedal?: {
+        found: boolean;
+        name?: string;
+        level?: number;
+        guard_level?: number;
+        wearing_status?: number;
+    };
+}

package/lib/types/api.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * 外部API响应接口类型定义
+ * 包含 Mojang API、ZMINFO API 和 Bilibili API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });