11

api/middleware/schedule/handlers/activeHandler.js

@@ -0,0 +1,88 @@
+const BaseHandler = require('./baseHandler');
+const ConfigManager = require('../services/configManager');
+const command = require('../command');
+const config = require('../config');
+
+/**
+ * 自动活跃处理器
+ * 负责保持账户活跃度
+ */
+class ActiveHandler extends BaseHandler {
+    /**
+     * 处理自动活跃任务
+     * @param {object} task - 任务对象
+     * @returns {Promise<object>} 执行结果
+     */
+    async handle(task) {
+        return await this.execute(task, async () => {
+            return await this.doActive(task);
+        }, {
+            checkAuth: true,
+            checkOnline: true,
+            recordDeviceMetrics: true
+        });
+    }
+
+    /**
+     * 执行活跃逻辑
+     */
+    async doActive(task) {
+        const { sn_code, taskParams } = task;
+        const { platform = 'boss' } = taskParams;
+
+        console.log(`[自动活跃] 开始 - 设备: ${sn_code}`);
+
+        // 1. 获取账户配置
+        const accountConfig = await this.getAccountConfig(sn_code, ['platform_type', 'active_strategy']);
+
+        if (!accountConfig) {
+            return {
+                activeCount: 0,
+                message: '未找到账户配置'
+            };
+        }
+
+        // 2. 解析活跃策略配置
+        const activeStrategy = ConfigManager.parseActiveStrategy(accountConfig.active_strategy);
+
+        // 3. 检查活跃时间范围
+        const timeRange = ConfigManager.getTimeRange(activeStrategy);
+        if (timeRange) {
+            const timeRangeValidator = require('../services/timeRangeValidator');
+            const timeCheck = timeRangeValidator.checkTimeRange(timeRange);
+
+            if (!timeCheck.allowed) {
+                return {
+                    activeCount: 0,
+                    message: timeCheck.reason
+                };
+            }
+        }
+
+        // 4. 创建活跃指令
+        const actions = activeStrategy.actions || ['view_jobs'];
+        const activeCommands = actions.map(action => ({
+            command_type: `active_${action}`,
+            command_name: `自动活跃 - ${action}`,
+            command_params: JSON.stringify({
+                sn_code,
+                platform: platform || accountConfig.platform_type || 'boss',
+                action
+            }),
+            priority: config.getTaskPriority('auto_active') || 5
+        }));
+
+        // 5. 执行活跃指令
+        const result = await command.executeCommands(task.id, activeCommands, this.mqttClient);
+
+        console.log(`[自动活跃] 完成 - 设备: ${sn_code}, 执行动作: ${actions.join(', ')}`);
+
+        return {
+            activeCount: actions.length,
+            actions,
+            message: '活跃完成'
+        };
+    }
+}
+
+module.exports = ActiveHandler;

api/middleware/schedule/handlers/baseHandler.js

@@ -0,0 +1,250 @@
+const deviceManager = require('../core/deviceManager');
+const accountValidator = require('../services/accountValidator');
+const db = require('../../dbProxy');
+
+/**
+ * 任务处理器基类
+ * 提供通用的授权检查、计时、错误处理、设备记录等功能
+ */
+class BaseHandler {
+    constructor(mqttClient) {
+        this.mqttClient = mqttClient;
+    }
+
+    /**
+     * 执行任务（带授权检查和错误处理）
+     * @param {object} task - 任务对象
+     * @param {Function} businessLogic - 业务逻辑函数
+     * @param {object} options - 选项
+     * @returns {Promise<object>} 执行结果
+     */
+    async execute(task, businessLogic, options = {}) {
+        const {
+            checkAuth = true,           // 是否检查授权
+            checkOnline = true,         // 是否检查在线状态
+            recordDeviceMetrics = true  // 是否记录设备指标
+        } = options;
+
+        const { sn_code, taskName } = task;
+        const startTime = Date.now();
+
+        try {
+            // 1. 验证账户（启用 + 授权 + 在线）
+            if (checkAuth || checkOnline) {
+                const validation = await accountValidator.validate(sn_code, {
+                    checkEnabled: true,
+                    checkAuth,
+                    checkOnline,
+                    offlineThreshold: 3 * 60 * 1000 // 3分钟
+                });
+
+                if (!validation.valid) {
+                    throw new Error(`设备 ${sn_code} 验证失败: ${validation.reason}`);
+                }
+            }
+
+            // 2. 记录任务开始
+            if (recordDeviceMetrics) {
+                deviceManager.recordTaskStart(sn_code, task);
+            }
+
+            // 3. 执行业务逻辑
+            const result = await businessLogic();
+
+            // 4. 记录任务成功
+            const duration = Date.now() - startTime;
+            if (recordDeviceMetrics) {
+                deviceManager.recordTaskComplete(sn_code, task, true, duration);
+            }
+
+            return {
+                success: true,
+                duration,
+                ...result
+            };
+
+        } catch (error) {
+            // 5. 记录任务失败
+            const duration = Date.now() - startTime;
+            if (recordDeviceMetrics) {
+                deviceManager.recordTaskComplete(sn_code, task, false, duration);
+            }
+
+            console.error(`[${taskName}] 执行失败 (设备: ${sn_code}):`, error.message);
+
+            return {
+                success: false,
+                error: error.message,
+                duration
+            };
+        }
+    }
+
+    /**
+     * 检查每日操作限制
+     * @param {string} sn_code - 设备序列号
+     * @param {string} operation - 操作类型 (search, deliver, chat)
+     * @param {string} platform - 平台类型
+     * @returns {Promise<{allowed: boolean, count?: number, limit?: number, reason?: string}>}
+     */
+    async checkDailyLimit(sn_code, operation, platform = 'boss') {
+        try {
+            const today = new Date().toISOString().split('T')[0];
+            const task_status = db.getModel('task_status');
+
+            // 查询今日该操作的完成次数
+            const count = await task_status.count({
+                where: {
+                    sn_code,
+                    taskType: `auto_${operation}`,
+                    status: 'completed',
+                    endTime: {
+                        [db.models.op.gte]: new Date(today)
+                    }
+                }
+            });
+
+            // 获取每日限制（从 deviceManager 或配置）
+            const limit = deviceManager.canExecuteOperation(sn_code, operation);
+
+            if (!limit.allowed) {
+                return {
+                    allowed: false,
+                    count,
+                    reason: limit.reason
+                };
+            }
+
+            return {
+                allowed: true,
+                count,
+                limit: limit.max || 999
+            };
+
+        } catch (error) {
+            console.error(`[每日限制检查] 失败 (${sn_code}, ${operation}):`, error);
+            return { allowed: true }; // 检查失败时默认允许
+        }
+    }
+
+    /**
+     * 检查执行间隔时间
+     * @param {string} sn_code - 设备序列号
+     * @param {string} taskType - 任务类型
+     * @param {number} intervalMinutes - 间隔时间（分钟）
+     * @returns {Promise<{allowed: boolean, elapsed?: number, remaining?: number, reason?: string}>}
+     */
+    async checkInterval(sn_code, taskType, intervalMinutes) {
+        try {
+            const task_status = db.getModel('task_status');
+
+            // 查询最近一次成功完成的任务
+            const lastTask = await task_status.findOne({
+                where: {
+                    sn_code,
+                    taskType,
+                    status: 'completed'
+                },
+                order: [['endTime', 'DESC']],
+                attributes: ['endTime']
+            });
+
+            if (!lastTask || !lastTask.endTime) {
+                return { allowed: true, elapsed: null };
+            }
+
+            const now = Date.now();
+            const lastTime = new Date(lastTask.endTime).getTime();
+            const elapsed = now - lastTime;
+            const intervalMs = intervalMinutes * 60 * 1000;
+
+            if (elapsed < intervalMs) {
+                const remainingMinutes = Math.ceil((intervalMs - elapsed) / (60 * 1000));
+                const elapsedMinutes = Math.floor(elapsed / (60 * 1000));
+
+                return {
+                    allowed: false,
+                    elapsed: elapsedMinutes,
+                    remaining: remainingMinutes,
+                    reason: `距离上次执行仅 ${elapsedMinutes} 分钟，还需等待 ${remainingMinutes} 分钟`
+                };
+            }
+
+            return {
+                allowed: true,
+                elapsed: Math.floor(elapsed / (60 * 1000))
+            };
+
+        } catch (error) {
+            console.error(`[间隔检查] 失败 (${sn_code}, ${taskType}):`, error);
+            return { allowed: true }; // 检查失败时默认允许
+        }
+    }
+
+    /**
+     * 获取账户配置
+     * @param {string} sn_code - 设备序列号
+     * @param {string[]} fields - 需要的字段
+     * @returns {Promise<object|null>}
+     */
+    async getAccountConfig(sn_code, fields = ['*']) {
+        try {
+            const pla_account = db.getModel('pla_account');
+            const account = await pla_account.findOne({
+                where: { sn_code, is_delete: 0 },
+                attributes: fields
+            });
+
+            return account ? account.toJSON() : null;
+        } catch (error) {
+            console.error(`[获取账户配置] 失败 (${sn_code}):`, error);
+            return null;
+        }
+    }
+
+    /**
+     * 推送设备工作状态（可选的通知）
+     * @param {string} sn_code - 设备序列号
+     * @param {object} status - 状态信息
+     */
+    async notifyDeviceStatus(sn_code, status) {
+        try {
+            const deviceWorkStatusNotifier = require('../notifiers/deviceWorkStatusNotifier');
+            await deviceWorkStatusNotifier.sendDeviceWorkStatus(sn_code, status);
+        } catch (error) {
+            console.warn(`[状态推送] 失败 (${sn_code}):`, error.message);
+        }
+    }
+
+    /**
+     * 标准化错误响应
+     * @param {Error} error - 错误对象
+     * @param {string} sn_code - 设备序列号
+     * @returns {object} 标准化的错误响应
+     */
+    formatError(error, sn_code) {
+        return {
+            success: false,
+            error: error.message || '未知错误',
+            sn_code,
+            timestamp: new Date().toISOString()
+        };
+    }
+
+    /**
+     * 标准化成功响应
+     * @param {object} data - 响应数据
+     * @param {string} sn_code - 设备序列号
+     * @returns {object} 标准化的成功响应
+     */
+    formatSuccess(data, sn_code) {
+        return {
+            success: true,
+            sn_code,
+            timestamp: new Date().toISOString(),
+            ...data
+        };
+    }
+}
+
+module.exports = BaseHandler;

api/middleware/schedule/handlers/chatHandler.js

@@ -0,0 +1,87 @@
+const BaseHandler = require('./baseHandler');
+const ConfigManager = require('../services/configManager');
+const command = require('../command');
+const config = require('../config');
+
+/**
+ * 自动沟通处理器
+ * 负责自动回复HR消息
+ */
+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 = 'boss' } = taskParams;
+
+        console.log(`[自动沟通] 开始 - 设备: ${sn_code}`);
+
+        // 1. 获取账户配置
+        const accountConfig = await this.getAccountConfig(sn_code, ['platform_type', 'chat_strategy']);
+
+        if (!accountConfig) {
+            return {
+                chatCount: 0,
+                message: '未找到账户配置'
+            };
+        }
+
+        // 2. 解析沟通策略配置
+        const chatStrategy = ConfigManager.parseChatStrategy(accountConfig.chat_strategy);
+
+        // 3. 检查沟通时间范围
+        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
+                };
+            }
+        }
+
+        // 4. 创建沟通指令
+        const chatCommand = {
+            command_type: 'autoChat',
+            command_name: '自动沟通',
+            command_params: JSON.stringify({
+                sn_code,
+                platform: platform || accountConfig.platform_type || 'boss',
+                autoReply: chatStrategy.auto_reply || false,
+                replyTemplate: chatStrategy.reply_template || ''
+            }),
+            priority: config.getTaskPriority('auto_chat') || 6
+        };
+
+        // 5. 执行沟通指令
+        const result = await command.executeCommands(task.id, [chatCommand], this.mqttClient);
+
+        console.log(`[自动沟通] 完成 - 设备: ${sn_code}`);
+
+        return {
+            chatCount: result.chatCount || 0,
+            message: '沟通完成'
+        };
+    }
+}
+
+module.exports = ChatHandler;

api/middleware/schedule/handlers/deliverHandler.js

@@ -0,0 +1,410 @@
+const BaseHandler = require('./baseHandler');
+const ConfigManager = require('../services/configManager');
+const jobFilterEngine = require('../services/jobFilterEngine');
+const command = require('../command');
+const config = require('../config');
+const db = require('../../dbProxy');
+const jobFilterService = require('../../../services/job_filter_service');
+
+/**
+ * 自动投递处理器
+ * 负责职位搜索、过滤、评分和自动投递
+ */
+class DeliverHandler extends BaseHandler {
+    /**
+     * 处理自动投递任务
+     * @param {object} task - 任务对象
+     * @returns {Promise<object>} 执行结果
+     */
+    async handle(task) {
+        return await this.execute(task, async () => {
+            return await this.doDeliver(task);
+        }, {
+            checkAuth: true,
+            checkOnline: true,
+            recordDeviceMetrics: true
+        });
+    }
+
+    /**
+     * 执行投递逻辑
+     */
+    async doDeliver(task) {
+        const { sn_code, taskParams } = task;
+        const { keyword, platform = 'boss', pageCount = 3, maxCount = 10, filterRules = {} } = taskParams;
+
+        console.log(`[自动投递] 开始 - 设备: ${sn_code}, 关键词: ${keyword}`);
+
+        // 1. 检查每日投递限制
+        const dailyCheck = await this.checkDailyDeliverLimit(sn_code, platform);
+        if (!dailyCheck.allowed) {
+            return {
+                deliveredCount: 0,
+                message: dailyCheck.message
+            };
+        }
+
+        const actualMaxCount = dailyCheck.actualMaxCount;
+
+        // 2. 检查并获取简历
+        const resume = await this.getOrRefreshResume(sn_code, platform, task.id);
+        if (!resume) {
+            return {
+                deliveredCount: 0,
+                message: '未找到简历信息'
+            };
+        }
+
+        // 3. 获取账户配置
+        const accountConfig = await this.getAccountConfig(sn_code, [
+            'keyword', 'platform_type', 'deliver_config', 'job_type_id', 'is_salary_priority'
+        ]);
+
+        if (!accountConfig) {
+            return {
+                deliveredCount: 0,
+                message: '未找到账户配置'
+            };
+        }
+
+        // 4. 检查投递时间范围
+        const deliverConfig = ConfigManager.parseDeliverConfig(accountConfig.deliver_config);
+        const timeRange = ConfigManager.getTimeRange(deliverConfig);
+
+        if (timeRange) {
+            const timeRangeValidator = require('../services/timeRangeValidator');
+            const timeCheck = timeRangeValidator.checkTimeRange(timeRange);
+            if (!timeCheck.allowed) {
+                return {
+                    deliveredCount: 0,
+                    message: timeCheck.reason
+                };
+            }
+        }
+
+        // 5. 获取职位类型配置
+        const jobTypeConfig = await this.getJobTypeConfig(accountConfig.job_type_id);
+
+        // 6. 搜索职位列表
+        await this.searchJobs(sn_code, platform, keyword || accountConfig.keyword, pageCount, task.id);
+
+        // 7. 从数据库获取待投递职位
+        const pendingJobs = await this.getPendingJobs(sn_code, platform, actualMaxCount * 3);
+
+        if (!pendingJobs || pendingJobs.length === 0) {
+            return {
+                deliveredCount: 0,
+                message: '没有待投递的职位'
+            };
+        }
+
+        // 8. 合并过滤配置
+        const filterConfig = this.mergeFilterConfig(deliverConfig, filterRules, jobTypeConfig);
+
+        // 9. 过滤已投递的公司
+        const recentCompanies = await this.getRecentDeliveredCompanies(sn_code, 30);
+
+        // 10. 过滤、评分、排序职位
+        const filteredJobs = await this.filterAndScoreJobs(
+            pendingJobs,
+            resume,
+            accountConfig,
+            jobTypeConfig,
+            filterConfig,
+            recentCompanies
+        );
+
+        const jobsToDeliver = filteredJobs.slice(0, actualMaxCount);
+
+        console.log(`[自动投递] 职位筛选完成 - 原始: ${pendingJobs.length}, 符合条件: ${filteredJobs.length}, 将投递: ${jobsToDeliver.length}`);
+
+        if (jobsToDeliver.length === 0) {
+            return {
+                deliveredCount: 0,
+                message: '没有符合条件的职位'
+            };
+        }
+
+        // 11. 创建投递指令并执行
+        const deliverCommands = this.createDeliverCommands(jobsToDeliver, sn_code, platform);
+        const result = await command.executeCommands(task.id, deliverCommands, this.mqttClient);
+
+        console.log(`[自动投递] 完成 - 设备: ${sn_code}, 投递: ${deliverCommands.length} 个职位`);
+
+        return {
+            deliveredCount: deliverCommands.length,
+            ...result
+        };
+    }
+
+    /**
+     * 检查每日投递限制
+     */
+    async checkDailyDeliverLimit(sn_code, platform) {
+        const apply_records = db.getModel('apply_records');
+        const dailyLimit = config.getDailyLimit('apply', platform);
+
+        const today = new Date();
+        today.setHours(0, 0, 0, 0);
+
+        const todayApplyCount = await apply_records.count({
+            where: {
+                sn_code,
+                platform,
+                applyTime: {
+                    [db.models.op.gte]: today
+                }
+            }
+        });
+
+        console.log(`[自动投递] 今日已投递: ${todayApplyCount}/${dailyLimit}`);
+
+        if (todayApplyCount >= dailyLimit) {
+            return {
+                allowed: false,
+                message: `已达到每日投递上限（${dailyLimit}次）`
+            };
+        }
+
+        const remainingQuota = dailyLimit - todayApplyCount;
+
+        return {
+            allowed: true,
+            actualMaxCount: remainingQuota,
+            todayCount: todayApplyCount,
+            limit: dailyLimit
+        };
+    }
+
+    /**
+     * 获取或刷新简历
+     */
+    async getOrRefreshResume(sn_code, platform, taskId) {
+        const resume_info = db.getModel('resume_info');
+        const twoHoursAgo = new Date(Date.now() - 2 * 60 * 60 * 1000);
+
+        let resume = await resume_info.findOne({
+            where: {
+                sn_code,
+                platform,
+                isActive: true
+            },
+            order: [['last_modify_time', 'DESC']]
+        });
+
+        const needRefresh = !resume ||
+            !resume.last_modify_time ||
+            new Date(resume.last_modify_time) < twoHoursAgo;
+
+        if (needRefresh) {
+            console.log(`[自动投递] 简历超过2小时未更新，重新获取`);
+
+            try {
+                await command.executeCommands(taskId, [{
+                    command_type: 'getOnlineResume',
+                    command_name: '获取在线简历',
+                    command_params: JSON.stringify({ sn_code, platform }),
+                    priority: config.getTaskPriority('get_resume') || 5
+                }], this.mqttClient);
+
+                // 重新查询
+                resume = await resume_info.findOne({
+                    where: { sn_code, platform, isActive: true },
+                    order: [['last_modify_time', 'DESC']]
+                });
+            } catch (error) {
+                console.warn(`[自动投递] 获取在线简历失败:`, error.message);
+            }
+        }
+
+        return resume ? resume.toJSON() : null;
+    }
+
+    /**
+     * 获取职位类型配置
+     */
+    async getJobTypeConfig(jobTypeId) {
+        if (!jobTypeId) return null;
+
+        try {
+            const job_types = db.getModel('job_types');
+            const jobType = await job_types.findByPk(jobTypeId);
+            return jobType ? jobType.toJSON() : null;
+        } catch (error) {
+            console.error(`[自动投递] 获取职位类型配置失败:`, error);
+            return null;
+        }
+    }
+
+    /**
+     * 搜索职位列表
+     */
+    async searchJobs(sn_code, platform, keyword, pageCount, taskId) {
+        const getJobListCommand = {
+            command_type: 'getJobList',
+            command_name: '获取职位列表',
+            command_params: JSON.stringify({
+                sn_code,
+                keyword,
+                platform,
+                pageCount
+            }),
+            priority: config.getTaskPriority('search_jobs') || 5
+        };
+
+        await command.executeCommands(taskId, [getJobListCommand], this.mqttClient);
+    }
+
+    /**
+     * 获取待投递职位
+     */
+    async getPendingJobs(sn_code, platform, limit) {
+        const job_postings = db.getModel('job_postings');
+
+        const jobs = await job_postings.findAll({
+            where: {
+                sn_code,
+                platform,
+                applyStatus: 'pending'
+            },
+            order: [['create_time', 'DESC']],
+            limit
+        });
+
+        return jobs.map(job => job.toJSON ? job.toJSON() : job);
+    }
+
+    /**
+     * 合并过滤配置
+     */
+    mergeFilterConfig(deliverConfig, filterRules, jobTypeConfig) {
+        // 排除关键词
+        const jobTypeExclude = jobTypeConfig?.excludeKeywords
+            ? ConfigManager.parseConfig(jobTypeConfig.excludeKeywords, [])
+            : [];
+
+        const deliverExclude = ConfigManager.getExcludeKeywords(deliverConfig);
+        const filterExclude = filterRules.excludeKeywords || [];
+
+        // 过滤关键词
+        const deliverFilter = ConfigManager.getFilterKeywords(deliverConfig);
+        const filterKeywords = filterRules.keywords || [];
+
+        // 薪资范围
+        const salaryRange = filterRules.minSalary || filterRules.maxSalary
+            ? { min: filterRules.minSalary || 0, max: filterRules.maxSalary || 0 }
+            : ConfigManager.getSalaryRange(deliverConfig);
+
+        return {
+            exclude_keywords: [...jobTypeExclude, ...deliverExclude, ...filterExclude],
+            filter_keywords: filterKeywords.length > 0 ? filterKeywords : deliverFilter,
+            min_salary: salaryRange.min,
+            max_salary: salaryRange.max,
+            priority_weights: ConfigManager.getPriorityWeights(deliverConfig)
+        };
+    }
+
+    /**
+     * 获取近期已投递的公司
+     */
+    async getRecentDeliveredCompanies(sn_code, days = 30) {
+        const apply_records = db.getModel('apply_records');
+        const daysAgo = new Date();
+        daysAgo.setDate(daysAgo.getDate() - days);
+
+        const recentApplies = await apply_records.findAll({
+            where: {
+                sn_code,
+                applyTime: {
+                    [db.models.op.gte]: daysAgo
+                }
+            },
+            attributes: ['companyName'],
+            group: ['companyName']
+        });
+
+        return new Set(recentApplies.map(apply => apply.companyName).filter(Boolean));
+    }
+
+    /**
+     * 过滤和评分职位
+     */
+    async filterAndScoreJobs(jobs, resume, accountConfig, jobTypeConfig, filterConfig, recentCompanies) {
+        const scored = [];
+
+        for (const job of jobs) {
+            // 1. 过滤近期已投递的公司
+            if (job.companyName && recentCompanies.has(job.companyName)) {
+                console.log(`[自动投递] 跳过已投递公司: ${job.companyName}`);
+                continue;
+            }
+
+            // 2. 使用 jobFilterEngine 过滤和评分
+            const filtered = await jobFilterEngine.filterJobs([job], filterConfig, resume);
+            if (filtered.length === 0) {
+                continue; // 不符合过滤条件
+            }
+
+            // 3. 使用原有的评分系统（job_filter_service）计算详细分数
+            const scoreResult = jobFilterService.calculateJobScoreWithWeights(
+                job,
+                resume,
+                accountConfig,
+                jobTypeConfig,
+                accountConfig.is_salary_priority || []
+            );
+
+            // 4. 计算关键词奖励
+            const KeywordMatcher = require('../utils/keywordMatcher');
+            const keywordBonus = KeywordMatcher.calculateBonus(
+                `${job.jobTitle} ${job.companyName} ${job.jobDescription || ''}`,
+                filterConfig.filter_keywords,
+                { baseScore: 5, maxBonus: 20 }
+            );
+
+            const finalScore = scoreResult.totalScore + keywordBonus.score;
+
+            // 5. 只保留评分 >= 60 的职位
+            if (finalScore >= 60) {
+                scored.push({
+                    ...job,
+                    matchScore: finalScore,
+                    scoreDetails: {
+                        ...scoreResult.scores,
+                        keywordBonus: keywordBonus.score
+                    }
+                });
+            }
+        }
+
+        // 按评分降序排序
+        scored.sort((a, b) => b.matchScore - a.matchScore);
+
+        return scored;
+    }
+
+    /**
+     * 创建投递指令
+     */
+    createDeliverCommands(jobs, sn_code, platform) {
+        return jobs.map(job => ({
+            command_type: 'deliver_resume',
+            command_name: `投递简历 - ${job.jobTitle} @ ${job.companyName} (评分:${job.matchScore})`,
+            command_params: JSON.stringify({
+                sn_code,
+                platform,
+                jobId: job.jobId,
+                encryptBossId: job.encryptBossId || '',
+                securityId: job.securityId || '',
+                brandName: job.companyName,
+                jobTitle: job.jobTitle,
+                companyName: job.companyName,
+                matchScore: job.matchScore,
+                scoreDetails: job.scoreDetails
+            }),
+            priority: config.getTaskPriority('apply') || 6
+        }));
+    }
+}
+
+module.exports = DeliverHandler;

api/middleware/schedule/handlers/index.js

@@ -0,0 +1,18 @@
+/**
+ * 处理器模块导出
+ * 统一导出所有任务处理器
+ */
+
+const BaseHandler = require('./baseHandler');
+const SearchHandler = require('./searchHandler');
+const DeliverHandler = require('./deliverHandler');
+const ChatHandler = require('./chatHandler');
+const ActiveHandler = require('./activeHandler');
+
+module.exports = {
+    BaseHandler,
+    SearchHandler,
+    DeliverHandler,
+    ChatHandler,
+    ActiveHandler
+};

api/middleware/schedule/handlers/searchHandler.js

@@ -0,0 +1,87 @@
+const BaseHandler = require('./baseHandler');
+const ConfigManager = require('../services/configManager');
+const command = require('../command');
+const config = require('../config');
+
+/**
+ * 自动搜索处理器
+ * 负责搜索职位列表
+ */
+class SearchHandler extends BaseHandler {
+    /**
+     * 处理自动搜索任务
+     * @param {object} task - 任务对象
+     * @returns {Promise<object>} 执行结果
+     */
+    async handle(task) {
+        return await this.execute(task, async () => {
+            return await this.doSearch(task);
+        }, {
+            checkAuth: true,
+            checkOnline: true,
+            recordDeviceMetrics: true
+        });
+    }
+
+    /**
+     * 执行搜索逻辑
+     */
+    async doSearch(task) {
+        const { sn_code, taskParams } = task;
+        const { keyword, platform = 'boss', pageCount = 3 } = taskParams;
+
+        console.log(`[自动搜索] 开始 - 设备: ${sn_code}, 关键词: ${keyword}`);
+
+        // 1. 获取账户配置
+        const accountConfig = await this.getAccountConfig(sn_code, ['keyword', 'platform_type', 'search_config']);
+
+        if (!accountConfig) {
+            return {
+                jobsFound: 0,
+                message: '未找到账户配置'
+            };
+        }
+
+        // 2. 解析搜索配置
+        const searchConfig = ConfigManager.parseSearchConfig(accountConfig.search_config);
+
+        // 3. 检查搜索时间范围
+        const timeRange = ConfigManager.getTimeRange(searchConfig);
+        if (timeRange) {
+            const timeRangeValidator = require('../services/timeRangeValidator');
+            const timeCheck = timeRangeValidator.checkTimeRange(timeRange);
+
+            if (!timeCheck.allowed) {
+                return {
+                    jobsFound: 0,
+                    message: timeCheck.reason
+                };
+            }
+        }
+
+        // 4. 创建搜索指令
+        const searchCommand = {
+            command_type: 'getJobList',
+            command_name: `自动搜索职位 - ${keyword || accountConfig.keyword}`,
+            command_params: JSON.stringify({
+                sn_code,
+                keyword: keyword || accountConfig.keyword || '',
+                platform: platform || accountConfig.platform_type || 'boss',
+                pageCount: pageCount || searchConfig.page_count || 3
+            }),
+            priority: config.getTaskPriority('search_jobs') || 8
+        };
+
+        // 5. 执行搜索指令
+        const result = await command.executeCommands(task.id, [searchCommand], this.mqttClient);
+
+        console.log(`[自动搜索] 完成 - 设备: ${sn_code}, 结果: ${JSON.stringify(result)}`);
+
+        return {
+            jobsFound: result.jobCount || 0,
+            message: '搜索完成'
+        };
+    }
+}
+
+module.exports = SearchHandler;