autoAiWorkSys/api/middleware/schedule/handlers/chatHandler.js

const BaseHandler = require('./baseHandler');
const ConfigManager = require('../services/configManager');
const command = require('../core/command');
const config = require('../infrastructure/config');
const chatManager = require('../../job/managers/chatManager');
const db = require('../../dbProxy');

/**
 * 自动沟通处理器
 * 负责自动回复 HR 消息。auto_chat 是任务，其下按指令执行：获取列表 → 获取详情 →（若需回复）发送消息
 */
class ChatHandler extends BaseHandler {
    /**
     * 处理自动沟通任务
     * @param {object} task - 任务对象
     * @returns {Promise<object>} 执行结果
     */
    async handle(task) {
        return await this.execute(task, async () => {
            return await this.doChat(task);
        }, {
            checkAuth: true,
            checkOnline: true,
            recordDeviceMetrics: true
        });
    }

    /**
     * 执行沟通逻辑：先下发「获取列表」指令，再对每个会话下发「获取详情」→（若需回复）「发送消息」指令
     */
    async doChat(task) {
        const { sn_code, taskParams } = task;
        const platform = taskParams.platform || 'boss';

        console.log(`[自动沟通] 开始 - 设备: ${sn_code}`);

        const accountConfig = await this.getAccountConfig(sn_code, ['platform_type', 'chat_strategy']);
        if (!accountConfig) {
            return { chatCount: 0, message: '未找到账户配置' };
        }

        const chatStrategy = ConfigManager.parseChatStrategy(accountConfig.chat_strategy);
        const timeRange = ConfigManager.getTimeRange(chatStrategy);
        if (timeRange) {
            const timeRangeValidator = require('../services/timeRangeValidator');
            const timeCheck = timeRangeValidator.checkTimeRange(timeRange);
            if (!timeCheck.allowed) {
                return { chatCount: 0, message: timeCheck.reason };
            }
        }

        const platform_type = platform || accountConfig.platform_type || 'boss';
        const page_count = chatStrategy.page_count || 3;

        // 1. 下发「获取列表」指令
        const list_command = {
            command_type: 'get_chat_list',
            command_name: '获取聊天列表',
            command_params: { platform: platform_type, pageCount: page_count },
            priority: config.getTaskPriority('auto_chat') || 6
        };
        const list_exec = await command.executeCommands(task.id, [list_command], this.mqttClient);
        const list_result = list_exec?.results?.[0]?.result;
        const friend_list = Array.isArray(list_result?.friendList) ? list_result.friendList : [];

        if (friend_list.length === 0) {
            console.log(`[自动沟通] 完成 - 设备: ${sn_code}，无会话`);
            return { chatCount: 0, message: '没有可沟通的会话', detail: { total_contacts: 0 } };
        }

        let replied_count = 0;
        const details = [];

        // 2. 将会话列表同步到聊天记录表（按会话维度做一条摘要记录）
        try {
            const chatRecordsModel = db.getModel('chat_records');
            for (const friend of friend_list) {
                const friend_id = friend.friendId;
                if (!friend_id) continue;

                const encryptId = friend.encryptFriendId || '';

                const existing = await chatRecordsModel.findOne({
                    where: {
                        sn_code,
                        platform: platform_type,
                        encryptBossId: encryptId,
                        direction: 'received',
                        chatType: 'session'
                    }
                });

                const baseData = {
                    sn_code,
                    platform: platform_type,
                    encryptBossId: encryptId,
                    jobTitle: friend.jobName || '',
                    companyName: friend.brandName || '',
                    hrName: friend.name || '',
                    hrTitle: friend.bossTitle || '',
                    hrId: String(friend_id),
                    chatType: 'session',
                    direction: 'received',
                    content: '',
                    contentType: 'text',
                    receiveTime: friend.updateTime ? new Date(friend.updateTime) : new Date()
                };

                if (existing) {
                    await existing.update(baseData);
                } else {
                    await chatRecordsModel.create(baseData);
                }
            }
        } catch (e) {
            console.warn('[自动沟通] 同步聊天会话列表到 chat_records 失败:', e.message);
        }

        // 3. 对每个会话：下发「获取详情」→ 若需回复则下发「发送消息」
        for (const friend of friend_list) {
            const friend_id = friend.friendId;
            if (!friend_id) continue;

            try {
                const detail_command = {
                    command_type: 'get_chat_detail',
                    command_name: '获取聊天详情',
                    command_params: { platform: platform_type, friendId: friend_id },
                    priority: config.getTaskPriority('auto_chat') || 6
                };
                const detail_exec = await command.executeCommands(task.id, [detail_command], this.mqttClient);
                const detail = detail_exec?.results?.[0]?.result;

                const decision = await chatManager.getReplyContentFromDetail(detail || {});

                if (decision.replied && decision.reply_content) {
                    const send_command = {
                        command_type: 'send_chat_message',
                        command_name: '发送聊天消息',
                        command_params: {
                            platform: platform_type,
                            friendId: friend_id,
                            messages: [{ type: 'text', content: decision.reply_content }],
                            chatType: 'reply'
                        },
                        priority: config.getTaskPriority('auto_chat') || 6
                    };
                    await command.executeCommands(task.id, [send_command], this.mqttClient);
                    replied_count++;
                }

                details.push({
                    friendId: friend_id,
                    replied: !!decision.replied,
                    reason: decision.reason || null
                });
            } catch (err) {
                details.push({
                    friendId: friend_id,
                    replied: false,
                    reason: err.message || '处理失败'
                });
            }
        }

        console.log(`[自动沟通] 完成 - 设备: ${sn_code}，会话 ${friend_list.length}，回复 ${replied_count}`);

        return {
            chatCount: replied_count,
            message: '自动沟通完成',
            detail: {
                total_contacts: friend_list.length,
                replied_count,
                details
            }
        };
    }
}

module.exports = ChatHandler;