wechaty-web-panel 1.6.112 → 1.6.113

package/dist/mcp/src/models/ChatMessage.js

@@ -0,0 +1,151 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../config/database.js';
+const ChatMessage = sequelize.define('ChatMessage', {
+    id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true
+    },
+    robotId: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: '当前登录机器人的id'
+    },
+    robotName: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '当前登录机器人的昵称'
+    },
+    conversationId: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: '会话id, 如果是私聊就是好友wxid，如果是群聊就是群wxid'
+    },
+    conversationName: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '会话名，如果是私聊就是好友昵称，如果是群聊就是群名'
+    },
+    conversationAvatar: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: '会话头像，如果是私聊就是好友头像，如果是群聊就是群头像'
+    },
+    isRobotAnswer: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: false,
+        comment: '是否机器人回复，用于检查是否机器人自己回复'
+    },
+    realUser: {
+        type: DataTypes.INTEGER,
+        defaultValue: 0,
+        comment: '是否真人回复'
+    },
+    msgId: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '消息ID'
+    },
+    contentType: {
+        type: DataTypes.STRING,
+        defaultValue: '文字',
+        comment: '对话内容类型：文字，图片，文件，h5连接，小程序，名片等'
+    },
+    recordType: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: 'contact 私聊 room 群聊'
+    },
+    chatUserName: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '聊天用户昵称'
+    },
+    chatUserAlias: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '聊天用户备注'
+    },
+    chatUserId: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '聊天用户id'
+    },
+    chatUserAvatar: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: '聊天用户头像'
+    },
+    roomName: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '群聊名称'
+    },
+    roomId: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '群聊id'
+    },
+    content: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: '聊天内容'
+    },
+    url: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: 'h5链接'
+    },
+    fileName: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '文件名称'
+    },
+    isImage: {
+        type: DataTypes.BOOLEAN,
+        defaultValue: false,
+        comment: '是否图片'
+    },
+    description: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: 'h5描述'
+    },
+    imageUrl: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: 'h5图片链接'
+    },
+    title: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: 'h5标题'
+    },
+    timestamp: {
+        type: DataTypes.BIGINT,
+        allowNull: false,
+        comment: '聊天时间戳'
+    }
+}, {
+    tableName: 'chat_messages',
+    timestamps: true,
+    indexes: [
+        {
+            fields: ['robotId', 'conversationId']
+        },
+        {
+            fields: ['robotId']
+        },
+        {
+            fields: ['timestamp']
+        },
+        {
+            fields: ['recordType']
+        },
+        {
+            fields: ['msgId']
+        }
+    ]
+});
+export default ChatMessage;
+//# sourceMappingURL=ChatMessage.js.map

package/dist/mcp/src/models/Friend.js

@@ -0,0 +1,64 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../config/database.js';
+const Friend = sequelize.define('Friend', {
+    id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true
+    },
+    robotId: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: '机器人账号id'
+    },
+    wxid: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: '好友wxid'
+    },
+    wxNumber: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '好友微信号'
+    },
+    name: {
+        type: DataTypes.STRING,
+        defaultValue: null,
+        comment: '昵称'
+    },
+    avatar: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        defaultValue: null,
+        comment: '头像'
+    },
+    alias: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '别名'
+    },
+    remark: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '备注'
+    },
+    tags: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '标签'
+    }
+}, {
+    tableName: 'friends',
+    timestamps: true,
+    indexes: [
+        {
+            fields: ['robotId', 'wxid'],
+            unique: true
+        },
+        {
+            fields: ['robotId']
+        }
+    ]
+});
+export default Friend;
+//# sourceMappingURL=Friend.js.map

package/dist/mcp/src/models/Group.js

@@ -0,0 +1,55 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../config/database.js';
+const Group = sequelize.define('Group', {
+    id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true
+    },
+    robotId: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: '机器人账号id'
+    },
+    wxid: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true, // 添加唯一约束，支持外键引用
+        comment: '群wxid'
+    },
+    adminId: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '群管理员wxid'
+    },
+    name: {
+        type: DataTypes.STRING,
+        defaultValue: null,
+        comment: '群名'
+    },
+    avatar: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        defaultValue: null,
+        comment: '群头像'
+    },
+    memberCount: {
+        type: DataTypes.INTEGER,
+        allowNull: true,
+        comment: '群成员数'
+    }
+}, {
+    tableName: 'groups',
+    timestamps: true,
+    indexes: [
+        {
+            fields: ['robotId', 'wxid'],
+            unique: true
+        },
+        {
+            fields: ['robotId']
+        }
+    ]
+});
+export default Group;
+//# sourceMappingURL=Group.js.map

package/dist/mcp/src/models/GroupMember.js

@@ -0,0 +1,67 @@
+import { DataTypes } from 'sequelize';
+import sequelize from '../config/database.js';
+const GroupMember = sequelize.define('GroupMember', {
+    id: {
+        type: DataTypes.INTEGER,
+        primaryKey: true,
+        autoIncrement: true
+    },
+    robotId: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: '机器人账号id'
+    },
+    roomWxid: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: '群wxid, 和群数据的wxid进行关联'
+    },
+    wxid: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: '群成员wxid'
+    },
+    wxNumber: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '群成员微信号'
+    },
+    name: {
+        type: DataTypes.STRING,
+        defaultValue: null,
+        comment: '群成员昵称'
+    },
+    avatar: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        defaultValue: null,
+        comment: '群成员头像'
+    },
+    alias: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '群成员别名'
+    },
+    remark: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '群成员备注'
+    }
+}, {
+    tableName: 'group_members',
+    timestamps: true,
+    indexes: [
+        {
+            fields: ['robotId', 'roomWxid', 'wxid'],
+            unique: true
+        },
+        {
+            fields: ['robotId', 'roomWxid']
+        },
+        {
+            fields: ['robotId']
+        }
+    ]
+});
+export default GroupMember;
+//# sourceMappingURL=GroupMember.js.map

package/dist/mcp/src/models/index.js

@@ -0,0 +1,27 @@
+import Friend from './Friend.js';
+import Group from './Group.js';
+import GroupMember from './GroupMember.js';
+import ChatMessage from './ChatMessage.js';
+// 建立模型关联关系
+// 使用应用层关联，不在数据库级别创建外键约束
+Group.hasMany(GroupMember, {
+    foreignKey: 'roomWxid',
+    sourceKey: 'wxid',
+    as: 'members',
+    constraints: false // 禁用数据库级别的外键约束
+});
+GroupMember.belongsTo(Group, {
+    foreignKey: 'roomWxid',
+    targetKey: 'wxid',
+    as: 'group',
+    constraints: false // 禁用数据库级别的外键约束
+});
+// 导出所有模型
+export { Friend, Group, GroupMember, ChatMessage };
+export default {
+    Friend,
+    Group,
+    GroupMember,
+    ChatMessage
+};
+//# sourceMappingURL=index.js.map

package/dist/mcp/src/scripts/migrate.js

@@ -0,0 +1,21 @@
+import { testConnection, initDatabase } from '../config/database.js';
+/**
+ * 数据库迁移脚本
+ */
+async function migrate() {
+    try {
+        console.log('🔄 开始数据库迁移...');
+        // 测试连接
+        await testConnection();
+        // 同步数据库结构
+        await initDatabase();
+        console.log('✅ 数据库迁移完成！');
+        process.exit(0);
+    }
+    catch (error) {
+        console.error('❌ 数据库迁移失败:', error);
+        process.exit(1);
+    }
+}
+migrate();
+//# sourceMappingURL=migrate.js.map

package/dist/mcp/src/services/ChatDataService.js

@@ -0,0 +1,284 @@
+import { Friend, Group, GroupMember, ChatMessage } from '../models/index.js';
+import { sequelize } from '../config/database.js';
+/**
+ * 微信聊天数据存储服务
+ */
+class ChatDataService {
+    /**
+     * 批量写入好友信息
+     * @param {Array} friendsData - 好友信息数组
+     * @param {Object} options - 配置选项
+     * @returns {Promise<Array>} 创建的好友记录
+     */
+    async batchCreateFriends(friendsData, options = {}) {
+        const { updateOnDuplicate = true } = options;
+        if (!Array.isArray(friendsData) || friendsData.length === 0) {
+            throw new Error('好友数据不能为空');
+        }
+        try {
+            if (updateOnDuplicate) {
+                // 使用 bulkCreate 的 updateOnDuplicate 选项
+                const result = await Friend.bulkCreate(friendsData, {
+                    updateOnDuplicate: ['name', 'avatar', 'alias', 'remark', 'tags', 'wxNumber'],
+                    validate: true
+                });
+                console.log(`✅ 成功批量写入/更新 ${result.length} 条好友记录`);
+                return result;
+            }
+            else {
+                // 仅创建新记录，忽略重复的
+                const result = await Friend.bulkCreate(friendsData, {
+                    ignoreDuplicates: true,
+                    validate: true
+                });
+                console.log(`✅ 成功批量写入 ${result.length} 条好友记录`);
+                return result;
+            }
+        }
+        catch (error) {
+            console.error('❌ 批量写入好友信息失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 批量写入群信息
+     * @param {Array} groupsData - 群信息数组
+     * @param {Object} options - 配置选项
+     * @returns {Promise<Array>} 创建的群记录
+     */
+    async batchCreateGroups(groupsData, options = {}) {
+        const { updateOnDuplicate = true } = options;
+        if (!Array.isArray(groupsData) || groupsData.length === 0) {
+            throw new Error('群组数据不能为空');
+        }
+        try {
+            if (updateOnDuplicate) {
+                const result = await Group.bulkCreate(groupsData, {
+                    updateOnDuplicate: ['name', 'avatar', 'adminId', 'memberCount'],
+                    validate: true
+                });
+                console.log(`✅ 成功批量写入/更新 ${result.length} 条群组记录`);
+                return result;
+            }
+            else {
+                const result = await Group.bulkCreate(groupsData, {
+                    ignoreDuplicates: true,
+                    validate: true
+                });
+                console.log(`✅ 成功批量写入 ${result.length} 条群组记录`);
+                return result;
+            }
+        }
+        catch (error) {
+            console.error('❌ 批量写入群组信息失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 批量写入群成员信息
+     * @param {Array} membersData - 群成员信息数组
+     * @param {Object} options - 配置选项
+     * @returns {Promise<Array>} 创建的群成员记录
+     */
+    async batchCreateGroupMembers(membersData, options = {}) {
+        const { updateOnDuplicate = true } = options;
+        if (!Array.isArray(membersData) || membersData.length === 0) {
+            throw new Error('群成员数据不能为空');
+        }
+        try {
+            if (updateOnDuplicate) {
+                const result = await GroupMember.bulkCreate(membersData, {
+                    updateOnDuplicate: ['name', 'avatar', 'alias', 'remark', 'wxNumber'],
+                    validate: true
+                });
+                console.log(`✅ 成功批量写入/更新 ${result.length} 条群成员记录`);
+                return result;
+            }
+            else {
+                const result = await GroupMember.bulkCreate(membersData, {
+                    ignoreDuplicates: true,
+                    validate: true
+                });
+                console.log(`✅ 成功批量写入 ${result.length} 条群成员记录`);
+                return result;
+            }
+        }
+        catch (error) {
+            console.error('❌ 批量写入群成员信息失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 写入对话记录
+     * @param {Object|Array} messageData - 消息数据，可以是单条或数组
+     * @returns {Promise<Object|Array>} 创建的消息记录
+     */
+    async createChatMessage(messageData) {
+        if (Array.isArray(messageData)) {
+            return this.batchCreateChatMessages(messageData);
+        }
+        if (!messageData || typeof messageData !== 'object') {
+            throw new Error('消息数据不能为空');
+        }
+        try {
+            const result = await ChatMessage.create(messageData);
+            console.log(`✅ 成功写入聊天记录: ${result.id}`);
+            return result;
+        }
+        catch (error) {
+            console.error('❌ 写入聊天记录失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 批量写入对话记录
+     * @param {Array} messagesData - 消息数据数组
+     * @returns {Promise<Array>} 创建的消息记录
+     */
+    async batchCreateChatMessages(messagesData) {
+        if (!Array.isArray(messagesData) || messagesData.length === 0) {
+            throw new Error('消息数据不能为空');
+        }
+        try {
+            const result = await ChatMessage.bulkCreate(messagesData, {
+                validate: true
+            });
+            console.log(`✅ 成功批量写入 ${result.length} 条聊天记录`);
+            return result;
+        }
+        catch (error) {
+            console.error('❌ 批量写入聊天记录失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 使用事务批量写入所有数据
+     * @param {Object} data - 包含所有类型数据的对象
+     * @param {Array} data.friends - 好友数据
+     * @param {Array} data.groups - 群组数据
+     * @param {Array} data.groupMembers - 群成员数据
+     * @param {Array} data.messages - 消息数据
+     * @returns {Promise<Object>} 写入结果
+     */
+    async batchCreateAllData(data) {
+        const { friends = [], groups = [], groupMembers = [], messages = [] } = data;
+        const transaction = await sequelize.transaction();
+        try {
+            const results = {};
+            // 批量写入好友信息
+            if (friends.length > 0) {
+                results.friends = await Friend.bulkCreate(friends, {
+                    updateOnDuplicate: ['name', 'avatar', 'alias', 'remark', 'tags', 'wxNumber'],
+                    validate: true,
+                    transaction
+                });
+            }
+            // 批量写入群组信息
+            if (groups.length > 0) {
+                results.groups = await Group.bulkCreate(groups, {
+                    updateOnDuplicate: ['name', 'avatar', 'adminId', 'memberCount'],
+                    validate: true,
+                    transaction
+                });
+            }
+            // 批量写入群成员信息
+            if (groupMembers.length > 0) {
+                results.groupMembers = await GroupMember.bulkCreate(groupMembers, {
+                    updateOnDuplicate: ['name', 'avatar', 'alias', 'remark', 'wxNumber'],
+                    validate: true,
+                    transaction
+                });
+            }
+            // 批量写入消息记录
+            if (messages.length > 0) {
+                results.messages = await ChatMessage.bulkCreate(messages, {
+                    validate: true,
+                    transaction
+                });
+            }
+            await transaction.commit();
+            console.log(`✅ 事务成功提交，写入数据统计:`, {
+                friends: results.friends?.length || 0,
+                groups: results.groups?.length || 0,
+                groupMembers: results.groupMembers?.length || 0,
+                messages: results.messages?.length || 0
+            });
+            return results;
+        }
+        catch (error) {
+            await transaction.rollback();
+            console.error('❌ 事务回滚，批量写入失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 根据robotId查询好友列表
+     * @param {string} robotId - 机器人ID
+     * @returns {Promise<Array>} 好友列表
+     */
+    async getFriendsByRobotId(robotId) {
+        try {
+            const friends = await Friend.findAll({
+                where: { robotId },
+                order: [['createdAt', 'DESC']]
+            });
+            return friends;
+        }
+        catch (error) {
+            console.error('❌ 查询好友列表失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 根据robotId查询群组列表
+     * @param {string} robotId - 机器人ID
+     * @returns {Promise<Array>} 群组列表
+     */
+    async getGroupsByRobotId(robotId) {
+        try {
+            const groups = await Group.findAll({
+                where: { robotId },
+                include: [{
+                        model: GroupMember,
+                        as: 'members'
+                    }],
+                order: [['createdAt', 'DESC']]
+            });
+            return groups;
+        }
+        catch (error) {
+            console.error('❌ 查询群组列表失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 根据条件查询聊天记录
+     * @param {Object} query - 查询条件
+     * @returns {Promise<Array>} 聊天记录列表
+     */
+    async getChatMessages(query = {}) {
+        const { robotId, conversationId, recordType, limit = 100, offset = 0 } = query;
+        try {
+            const whereClause = {};
+            if (robotId)
+                whereClause.robotId = robotId;
+            if (conversationId)
+                whereClause.conversationId = conversationId;
+            if (recordType)
+                whereClause.recordType = recordType;
+            const messages = await ChatMessage.findAll({
+                where: whereClause,
+                limit,
+                offset,
+                order: [['timestamp', 'DESC']]
+            });
+            return messages;
+        }
+        catch (error) {
+            console.error('❌ 查询聊天记录失败:', error);
+            throw error;
+        }
+    }
+}
+export default ChatDataService;
+//# sourceMappingURL=ChatDataService.js.map