Upload 5 files

services/AISummary.js

@@ -0,0 +1,452 @@
+// AISummary.js - AI总结模块
+const cron = require('node-cron');
+const {config} = require("dotenv");
+
+class AISummary {
+    /**
+     * 获取用户时区的执行时间点列表（格式化字符串）
+     * @returns {string[]} 例如: ['4:00', '8:00', '12:00', '16:00', '20:00']
+     */
+    getScheduleStrings() {
+        try {
+            const scheduleHours = this.generateScheduleHours();
+            return scheduleHours.map(hour => {
+                const h = hour.toString().padStart(2, '0');
+                return `${h}:00`;
+            });
+        } catch (error) {
+            console.error('[AISummary] 获取schedules失败:', error.message);
+            return [];
+        }
+    }
+
+    constructor(statsRecorder, statsQuery, config = {}) {
+        this.recorder = statsRecorder;
+        this.query = statsQuery;
+
+        // AI配置
+        this.aiConfig = {
+            apiUrl: config.aiApiUrl || process.env.AI_API_URL || 'https://api.openai.com/v1/chat/completions',
+            apiKey: config.aiApiKey || process.env.AI_API_KEY || '',
+            model: config.aiModel || process.env.AI_MODEL || 'gpt-4',
+            maxTokens: config.aiMaxTokens || 1000,
+            timezoneOffset: config.timezoneOffset || parseInt(process.env.DEFAULT_TIMEZONE_OFFSET) || 8,
+            aiPrompt: config.aiPrompt || '无',
+        };
+
+        // 发布配置
+        this.publishConfig = {
+            publishEnabled: config.publishEnabled || process.env.PUBLISH_ENABLED || false,
+            apiUrl: config.publishApiUrl || process.env.PUBLISH_API_URL || '',
+            apiKey: config.publishApiKey || process.env.PUBLISH_API_KEY || '',
+        };
+
+        // 定时任务配置
+        this.scheduleConfig = {
+            // 时间间隔（小时），默认4小时
+            intervalHours: config.intervalHours || parseInt(process.env.SCHEDULE_INTERVAL_HOURS) || 4,
+
+            // 起始时间（小时），默认0点（但不触发）
+            startHour: config.startHour !== undefined ? config.startHour : 0,
+
+            // 结束时间（小时），默认24点
+            endHour: config.endHour !== undefined ? config.endHour : 24,
+
+            // 是否跳过起始时间的触发，默认true
+            skipStartHour: config.skipStartHour !== false
+        };
+
+        // 定时任务实例
+        this.cronJobs = [];
+
+        // 是否启用定时任务
+        this.enabled = config.enabled !== false;
+
+        // 存储最近的总结结果（内存缓存）
+        this.recentSummaries = new Map();
+    }
+
+    // 生成执行时间点
+    generateScheduleHours() {
+        const { intervalHours, startHour, endHour, skipStartHour } = this.scheduleConfig;
+
+        // 参数验证
+        if (intervalHours <= 0 || intervalHours > 24) {
+            throw new Error('intervalHours must be between 1 and 24');
+        }
+
+        if (startHour < 0 || startHour >= 24) {
+            throw new Error('startHour must be between 0 and 23');
+        }
+
+        if (endHour <= startHour || endHour > 24) {
+            throw new Error('endHour must be greater than startHour and not exceed 24');
+        }
+
+        const scheduleHours = [];
+        let currentHour = startHour + intervalHours; // 从起始时间后的第一个间隔开始
+
+        // 如果不跳过起始时间，则添加起始时间
+        if (!skipStartHour) {
+            scheduleHours.push(startHour);
+        }
+
+        // 生成后续时间点
+        while (currentHour < endHour) {
+            scheduleHours.push(currentHour);
+            currentHour += intervalHours;
+        }
+
+        return scheduleHours;
+    }
+
+    // 启动定时任务
+    start() {
+        if (!this.enabled) {
+            console.log('[AISummary] 定时任务未启用');
+            return;
+        }
+
+        if (!this.aiConfig.apiKey) {
+            console.error('[AISummary] AI API Key未配置，无法启动');
+            return;
+        }
+
+        try {
+            const scheduleHours = this.generateScheduleHours();
+            const offset = this.aiConfig.timezoneOffset;
+
+            console.log('[AISummary] 定时任务配置:');
+            console.log(`  - 用户时区: UTC${offset >= 0 ? '+' : ''}${offset}`);
+            console.log(`  - 时间间隔: 每${this.scheduleConfig.intervalHours}小时`);
+            console.log(`  - 起始时间: ${this.scheduleConfig.startHour}:00 (${this.scheduleConfig.skipStartHour ? '不触发' : '触发'})`);
+            console.log(`  - 结束时间: ${this.scheduleConfig.endHour}:00`);
+            console.log(`  - 执行时间点: ${scheduleHours.map(h => `${h}:00`).join('、')}`);
+
+            // 为每个时间点创建定时任务
+            scheduleHours.forEach(userHour => {
+                // 将用户时区时间转换为UTC时间
+                const utcHour = (userHour - offset + 24) % 24;
+                const cronTime = `0 ${utcHour} * * *`;
+                const triggerType = `cron-${userHour}`;
+
+                const job = cron.schedule(cronTime, async () => {
+                    console.log(`[AISummary] 定时任务触发 (用户时区 ${userHour}:00 = UTC ${utcHour}:00)`);
+                    await this.runDailySummaryForAllDevices(triggerType);
+                });
+
+                this.cronJobs.push(job);
+                console.log(`  ✓ 已创建定时任务: 用户时区 ${userHour}:00 (UTC ${utcHour}:00) - cron: ${cronTime}`);
+            });
+
+            console.log(`[AISummary] 定时任务已启动，共 ${this.cronJobs.length} 个任务`);
+
+        } catch (error) {
+            console.error('[AISummary] 定时任务启动失败:', error.message);
+            throw error;
+        }
+    }
+
+// 停止定时任务
+    stop() {
+        this.cronJobs.forEach(job => job.stop());
+        this.cronJobs = [];
+        console.log('[AISummary] 定时任务已停止');
+    }
+
+    // 为所有设备运行每日总结
+    async runDailySummaryForAllDevices(trigger = 'cron') {
+        try {
+            const devices = await this.query.getDevices();
+            console.log(`[AISummary] 开始为 ${devices.length} 个设备生成总结`);
+
+            for (const device of devices) {
+                try {
+                    await this.generateDailySummary(device.device, null, null, trigger);
+                } catch (error) {
+                    console.error(`[AISummary] 设备 ${device.device} 总结失败:`, error.message);
+                }
+            }
+
+            console.log('[AISummary] 所有设备总结完成');
+        } catch (error) {
+            console.error('[AISummary] 运行总结任务失败:', error);
+        }
+    }
+
+    // 生成每日总结 (对外接口)
+    async generateDailySummary(deviceId, date = null, timezoneOffset = null, trigger = 'manual') {
+        const tz = timezoneOffset !== null ? timezoneOffset : this.aiConfig.timezoneOffset;
+
+        // 如果没有指定日期，使用当天的数据（考虑时区）
+        let targetDate;
+        if (date) {
+            targetDate = new Date(date);
+        } else {
+            // 获取用户时区的当前时间
+            const now = new Date();
+            const userNow = new Date(now.getTime() + tz * 60 * 60 * 1000);
+            targetDate = new Date(userNow);
+        }
+        // 归零到当天0点
+        targetDate.setHours(0, 0, 0, 0);
+
+        console.log(`[AISummary] 开始为设备 ${deviceId} 生成 ${targetDate.toISOString().split('T')[0]} 的总结 (触发方式: ${trigger})`);
+
+        // 1. 获取统计数据
+        const statsData = await this.collectDailyData(deviceId, targetDate, tz);
+
+        if (statsData.totalUsage === 0) {
+            console.log(`[AISummary] 设备 ${deviceId} 在 ${targetDate.toISOString().split('T')[0]} 无使用数据`);
+            return {
+                success: false,
+                message: 'No usage data for this day'
+            };
+        }
+
+        // 2. 调用AI生成总结
+        const aiSummary = await this.callAI(statsData, deviceId);
+
+        // 3. 发布总结
+        const publishResult = await this.publishSummary(deviceId, targetDate, aiSummary, statsData);
+
+        // 4. 保存到内存缓存
+        const summaryRecord = {
+            summary: aiSummary,
+            date: targetDate.toISOString().split('T')[0],
+            timestamp: new Date().toISOString(),
+            trigger: trigger, // 'manual', 'cron-x'
+            publishResult
+        };
+
+        this.recentSummaries.set(deviceId, summaryRecord);
+
+        console.log(`[AISummary] 设备 ${deviceId} 总结完成并已保存`);
+
+        return {
+            success: true,
+            deviceId,
+            ...summaryRecord
+        };
+    }
+
+    // 收集每日数据
+    async collectDailyData(deviceId, date, timezoneOffset) {
+        // 获取当天统计
+        const dailyStats = await this.query.getDailyStats(deviceId, date, timezoneOffset);
+
+        // 获取最近200条切换记录
+        let recentSwitches = [];
+        if (this.recorder.recentAppSwitches.has(deviceId)) {
+            const switches = this.recorder.recentAppSwitches.get(deviceId);
+            recentSwitches = switches
+                .filter(entry => {
+                    const entryDate = new Date(entry.timestamp);
+                    const entryDateOnly = new Date(entryDate);
+                    entryDateOnly.setHours(0, 0, 0, 0);
+                    return entryDateOnly.getTime() === date.getTime();
+                })
+                .slice(0, 200)
+                .map(entry => {
+                    // 将UTC时间转换为用户本地时间
+                    const userTime = new Date(entry.timestamp);
+                    userTime.setMinutes(userTime.getMinutes() + timezoneOffset * 60);
+
+                    return {
+                        appName: entry.appName,
+                        timestamp: userTime.toISOString(), // 保持ISO格式
+                        localTime: userTime.toLocaleTimeString('zh-CN', { hour12: false }), // 添加本地时间字符串
+                        running: entry.running !== false
+                    };
+                });
+        }
+
+        return {
+            deviceId,
+            date: date.toISOString().split('T')[0],
+            totalUsage: dailyStats.totalUsage,
+            appStats: dailyStats.appStats,
+            hourlyStats: dailyStats.hourlyStats,
+            recentSwitches,
+            timezoneOffset
+        };
+    }
+
+
+    // 调用AI API
+    async callAI(statsData, deviceId) {
+        const prompt = this.buildPrompt(statsData, deviceId);
+
+        try {
+            const response = await fetch(this.aiConfig.apiUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.aiConfig.apiKey}`
+                },
+                body: JSON.stringify({
+                    model: this.aiConfig.model,
+                    messages: [
+                        {
+                            role: 'system',
+                            content: '你是一个时间分析师'
+                        },
+                        {
+                            role: 'user',
+                            content: prompt
+                        }
+                    ],
+                    max_tokens: this.aiConfig.maxTokens,
+                    temperature: 0.7
+                })
+            });
+
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`AI API 请求失败: ${response.status} ${errorText}`);
+            }
+
+            const result = await response.json();
+            return result.choices[0].message.content;
+
+        } catch (error) {
+            console.error('[AISummary] AI调用失败:', error);
+            throw error;
+        }
+    }
+
+    // 构建AI提示词
+    buildPrompt(statsData, deviceId) {
+        const { date, totalUsage, appStats, hourlyStats, recentSwitches } = statsData;
+
+        // 计算应用使用占比
+        const appUsageList = Object.entries(appStats)
+            .map(([app, minutes]) => ({
+                app,
+                minutes,
+                percentage: ((minutes / totalUsage) * 100).toFixed(1)
+            }))
+            .sort((a, b) => b.minutes - a.minutes);
+
+        // 构建提示词
+        let prompt = `总结以下设备的应用使用情况，控制在300字以内\n\n`;
+
+        prompt += `- 设备ID: ${deviceId}\n`;
+        prompt += `- 统计日期: ${date}\n\n`;
+
+        prompt += `## 总体使用情况\n`;
+        prompt += `- 总使用时长: ${Math.floor(totalUsage / 60)}小时${totalUsage % 60}分钟\n`;
+        prompt += `- 使用应用数量: ${Object.keys(appStats).length}个\n\n`;
+
+        prompt += `## 应用使用占比(TOP 20)\n`;
+        appUsageList.slice(0, 20).forEach(({ app, minutes, percentage }) => {
+            prompt += `- ${app}: ${Math.floor(minutes / 60)}小时${minutes % 60}分钟 (${percentage}%)\n`;
+        });
+
+
+        prompt += `\n## 最近应用切换记录 (最新${Math.min(recentSwitches.length, 100)}条)\n`;
+        recentSwitches.slice(0, 10).forEach(({ appName, timestamp, running }) => {
+            const time = new Date(timestamp).toLocaleTimeString('zh-CN', { hour12: false });
+            const status = running ? '打开' : '关闭';
+            prompt += `- ${time} ${status} ${appName}\n`;
+        });
+        prompt += this.aiConfig.aiPrompt;
+        prompt += `注意：控制在300字以内，不要返回md格式，只能换行`;
+
+        return prompt;
+    }
+
+    // 发布总结到指定API
+    async publishSummary(deviceId, date, summary, statsData) {
+        if (!this.publishConfig.apiUrl || this.publishConfig.publishEnabled){
+            console.log('[AISummary] 未配置发布功能，跳过发布');
+            return { published: false, reason: 'No publish API configured' };
+        }
+
+        try {
+            const payload = {
+                deviceId,
+                date: date.toISOString().split('T')[0],
+                timestamp: new Date().toISOString(),
+                summary
+            };
+
+            const headers = {
+                'Content-Type': 'application/json'
+            };
+
+            if (this.publishConfig.apiKey) {
+                headers['Authorization'] = `Bearer ${this.publishConfig.apiKey}`;
+            }
+
+            const response = await fetch(this.publishConfig.apiUrl, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(payload)
+            });
+
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`发布API请求失败: ${response.status} ${errorText}`);
+            }
+
+            const result = await response.json();
+            console.log('[AISummary] 总结已成功发布');
+
+            return {
+                published: true,
+                response: result
+            };
+
+        } catch (error) {
+            console.error('[AISummary] 发布失败:', error);
+            return {
+                published: false,
+                error: error.message
+            };
+        }
+    }
+
+    // 手动触发总结 (用于测试或按需生成)
+    async triggerSummary(deviceId, options = {}) {
+        const {
+            date = null,
+            timezoneOffset = null
+        } = options;
+
+        return await this.generateDailySummary(deviceId, date, timezoneOffset, 'manual');
+    }
+
+    // 获取最近一次总结
+    getRecentSummary(deviceId) {
+        if (!this.recentSummaries.has(deviceId)) {
+            return null;
+        }
+        return this.recentSummaries.get(deviceId);
+    }
+
+    // 获取所有设备的最近总结
+    getAllRecentSummaries() {
+        const summaries = {};
+        this.recentSummaries.forEach((summary, deviceId) => {
+            summaries[deviceId] = summary;
+        });
+        return summaries;
+    }
+
+    // 预留：周总结功能
+    async generateWeeklySummary(deviceId, weekOffset = 0, timezoneOffset = null) {
+        // TODO: 实现周总结
+        console.log('[AISummary] 周总结功能待实现');
+        throw new Error('Weekly summary not implemented yet');
+    }
+
+    // 预留：月总结功能
+    async generateMonthlySummary(deviceId, monthOffset = 0, timezoneOffset = null) {
+        // TODO: 实现月总结
+        console.log('[AISummary] 月总结功能待实现');
+        throw new Error('Monthly summary not implemented yet');
+    }
+}
+
+module.exports = AISummary;

services/EyeTimeQuery.js

@@ -0,0 +1,111 @@
+// EyeTimeQuery.js - 仅统计用眼分钟数(日/周/月), 支持时区
+const { mongoose } = require('../index');
+const DateRangeHelper = require('../utils/DateRange');
+const TimezoneUtils = require('../utils/timezone');
+
+const DailyEyeTime = mongoose.model('DailyEyeTime');
+
+class EyeTimeQuery {
+    constructor(timezoneOffset = 8) {
+        // 初始化时区工具与日期范围助手
+        this.timezoneOffset = timezoneOffset;
+        this.timezoneUtils = new TimezoneUtils(timezoneOffset);
+        this.dateHelper = new DateRangeHelper(timezoneOffset);
+    }
+
+    /**
+     * 获取某日的用眼分钟数
+     * @param {Date} date - 查询目标日期（UTC 或本地时间均可）
+     * @param {number} timezoneOffset - 时区偏移（小时）
+     */
+    async getDailyMinutes(date, timezoneOffset = this.timezoneOffset) {
+        const tzUtils = new TimezoneUtils(timezoneOffset);
+
+        // 解析输入日期为本地日期
+        const localDate = tzUtils.parseDate(date);
+
+        // 构建数据库查询的日期（本地零点对应的 UTC 时间）
+        const localDayStart = new Date(Date.UTC(
+            localDate.getUTCFullYear(),
+            localDate.getUTCMonth(),
+            localDate.getUTCDate(),
+            0, 0, 0, 0
+        ));
+        const dbDate = tzUtils.localToUtc(localDayStart);
+
+        // 查询记录
+        const dayRecords = await DailyEyeTime.find({
+            date: dbDate
+        }).lean();
+
+        // 初始化小时分布
+        const hourlyStats = Array(24).fill(0);
+
+        for (const rec of dayRecords) {
+            if (rec.hourlyUsage && Array.isArray(rec.hourlyUsage)) {
+                for (let i = 0; i < 24; i++) {
+                    hourlyStats[i] += rec.hourlyUsage[i] || 0;
+                }
+            }
+        }
+
+        // 总分钟数直接用小时分布求和
+        const totalUsage = Math.round(hourlyStats.reduce((a, b) => a + b, 0) * 100) / 100;
+
+        return {
+            date: localDate.toISOString().split('T')[0],
+            totalUsage,
+            hourlyStats: hourlyStats.map(v => Math.round(v * 100) / 100),
+            timezoneOffset
+        };
+    }
+
+
+    /**
+     * 获取周统计结果
+     */
+    async getWeeklyMinutes(weekOffset = 0, timezoneOffset = this.timezoneOffset) {
+        const { startDate, endDate } = this.dateHelper.getWeekRange(weekOffset);
+        const result = {};
+
+        for (let d = new Date(startDate); d <= endDate; d.setDate(d.getDate() + 1)) {
+            const stats = await this.getDailyMinutes(new Date(d), timezoneOffset);
+            result[stats.date] = stats.totalUsage;
+        }
+
+        return {
+            weekOffset,
+            weekRange: {
+                start: startDate.toISOString().split('T')[0],
+                end: endDate.toISOString().split('T')[0]
+            },
+            dailyTotals: result,
+            timezoneOffset
+        };
+    }
+
+    /**
+     * 获取月统计结果
+     */
+    async getMonthlyMinutes(monthOffset = 0, timezoneOffset = this.timezoneOffset) {
+        const { startDate, endDate } = this.dateHelper.getMonthRange(monthOffset, timezoneOffset);
+        const result = {};
+
+        for (let d = new Date(startDate); d <= endDate; d.setDate(d.getDate() + 1)) {
+            const stats = await this.getDailyMinutes(new Date(d), timezoneOffset);
+            result[stats.date] = stats.totalUsage;
+        }
+
+        return {
+            monthOffset,
+            monthRange: {
+                start: startDate.toISOString().split('T')[0],
+                end: endDate.toISOString().split('T')[0]
+            },
+            dailyTotals: result,
+            timezoneOffset
+        };
+    }
+}
+
+module.exports = EyeTimeQuery;

services/EyeTimeRecorder.js

@@ -0,0 +1,182 @@
+// EyeTimeRecorder.js
+const { mongoose } = require('../index');
+const TimezoneUtils = require('../utils/timezone');
+
+const DailyEyeTime = mongoose.model('DailyEyeTime', {
+    date: Date,           // 本地时区日期零点对应的 UTC 时间戳
+    hourlyUsage: [Number] // 24小时数组,每项代表分钟数
+});
+
+class EyeTimeRecorder {
+    constructor(timezoneConfig) {
+        // 初始化时区工具
+        this.timezoneUtils = new TimezoneUtils(timezoneConfig.timezoneOffset || 'Asia/Shanghai');
+
+        // 存储所有设备的状态
+        this.deviceStates = new Map(); // { deviceId: { isActive: boolean, lastUpdateTime: timestamp } }
+
+        // 全局状态追踪
+        this.globalActive = false;
+        this.lastRecordTime = null;
+    }
+
+    /**
+     * 记录设备活动状态
+     * @param {string} deviceId - 设备ID
+     * @param {boolean} isActive - 是否活跃（用眼中）
+     */
+    async recordActivity(deviceId, isActive = true) {
+        const now = Date.now();
+        const wasGlobalActive = this.globalActive;
+
+        // 更新设备状态
+        this.deviceStates.set(deviceId, {
+            isActive: isActive,
+            lastUpdateTime: now
+        });
+
+        // 重新计算全局状态（只要有一个设备活跃，全局就活跃）
+        this.globalActive = false;
+        for (const [, state] of this.deviceStates) {
+            if (state.isActive) {
+                this.globalActive = true;
+                break;
+            }
+        }
+
+        // 如果全局状态从活跃变为非活跃，需要记录最后一段时间
+        if (wasGlobalActive && !this.globalActive && this.lastRecordTime) {
+            await this._saveUsageTime(this.lastRecordTime, now);
+            this.lastRecordTime = null;
+        }
+
+        // 如果全局状态从非活跃变为活跃，开始新的记录
+        if (!wasGlobalActive && this.globalActive) {
+            this.lastRecordTime = now;
+        }
+
+        // 如果全局状态持续活跃，记录这段时间并更新起始时间
+        if (wasGlobalActive && this.globalActive && this.lastRecordTime) {
+            await this._saveUsageTime(this.lastRecordTime, now);
+            this.lastRecordTime = now;
+        }
+    }
+
+    /**
+     * 保存使用时间到数据库
+     * @private
+     */
+    async _saveUsageTime(startTime, endTime) {
+        const durationMs = endTime - startTime;
+        if (durationMs <= 0) return;
+
+        // 将时间段按本地时区的小时和日期拆分
+        const segments = this._splitTimeSegments(startTime, endTime);
+
+        // 为每个时间段更新数据库
+        for (const segment of segments) {
+            await this._updateDailyRecord(segment.date, segment.hour, segment.minutes);
+        }
+    }
+
+    /**
+     * 将时间段按本地时区的日期和小时拆分
+     * @private
+     */
+    _splitTimeSegments(startTime, endTime) {
+        const segments = [];
+        let currentTime = startTime;
+
+        while (currentTime < endTime) {
+            // 转换为本地时间
+            const localDate = this.timezoneUtils.utcToLocal(new Date(currentTime));
+            const currentHour = localDate.getHours();
+
+            // 计算当前小时结束时间（本地时间）
+            const hourEndLocal = new Date(localDate);
+            hourEndLocal.setHours(currentHour, 59, 59, 999);
+
+            // 转换回UTC
+            const hourEndUtc = this.timezoneUtils.localToUtc(hourEndLocal).getTime();
+
+            // 确定这个时间段的结束时间
+            const segmentEnd = Math.min(endTime, hourEndUtc + 1); // +1ms 进入下一小时
+
+            // 计算分钟数
+            const segmentDurationMs = segmentEnd - currentTime;
+            const minutes = segmentDurationMs / (60 * 1000);
+
+            // 获取本地时区零点的正确 UTC 时间
+            // 例如：北京时间 2025-11-24 -> UTC 2025-11-23T16:00Z
+            const localDayStartUtc = this.timezoneUtils.getLocalDayStart(new Date(currentTime));
+
+            segments.push({
+                date: localDayStartUtc,  // 存储为本地时区零点对应的 UTC 时间
+                hour: currentHour,
+                minutes: minutes
+            });
+
+            currentTime = segmentEnd;
+        }
+
+        return segments;
+    }
+
+    /**
+     * 更新数据库中的每日记录
+     * @private
+     */
+    async _updateDailyRecord(date, hour, minutes) {
+        try {
+            // 查找或创建当天的记录
+            let record = await DailyEyeTime.findOne({ date: date });
+
+            if (!record) {
+                // 创建新记录，初始化24小时数组为0
+                record = new DailyEyeTime({
+                    date: date,  // 存储为本地时区零点的 UTC 时间
+                    hourlyUsage: Array(24).fill(0)
+                });
+            }
+
+            // 累加该小时的使用时间
+            record.hourlyUsage[hour] += minutes;
+
+            // 保存到数据库
+            await record.save();
+
+        } catch (error) {
+            console.error('保存用眼时间记录失败:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * 获取设备当前状态（可选方法，用于调试）
+     */
+    getDeviceStatus(deviceId) {
+        return this.deviceStates.get(deviceId) || null;
+    }
+
+    /**
+     * 获取全局活跃状态（可选方法，用于调试）
+     */
+    isGlobalActive() {
+        return this.globalActive;
+    }
+
+    /**
+     * 获取所有活跃设备列表（可选方法，用于调试）
+     */
+    getActiveDevices() {
+        const activeDevices = [];
+        for (const [deviceId, state] of this.deviceStates) {
+            if (state.isActive) {
+                activeDevices.push(deviceId);
+            }
+        }
+        return activeDevices;
+    }
+}
+
+module.exports = EyeTimeRecorder;

services/StatsQuery.js

@@ -0,0 +1,253 @@
+// StatsQuery.js - 简化版（适配新的存储逻辑）
+const { mongoose } = require('../index');
+const DateRangeHelper = require('../utils/DateRange');
+const TimezoneUtils = require('../utils/timezone');
+
+const DailyStat = mongoose.model('DailyStat');
+
+class StatsQuery {
+    constructor(recorder, config = {}) {
+        this.recorder = recorder;
+        this.timezoneOffset = config.timezoneOffset || 8;
+        this.dateRangeHelper = new DateRangeHelper(this.timezoneOffset);
+        this.tzUtils = new TimezoneUtils(this.timezoneOffset);
+    }
+
+    // 查询统计数据（直接查询本地日期）
+    async _queryStats(query, startDate, endDate) {
+        // 构建查询日期数组（本地时区日期）
+        const queryDates = [];
+        const current = new Date(startDate);
+
+        while (current <= endDate) {
+            // 转换为数据库存储格式（本地零点对应的 UTC 时间）
+            const localDayStart = new Date(Date.UTC(
+                current.getUTCFullYear(),
+                current.getUTCMonth(),
+                current.getUTCDate(),
+                0, 0, 0, 0
+            ));
+            const dbDate = this.tzUtils.localToUtc(localDayStart);
+            queryDates.push(dbDate);
+
+            // 移动到下一天
+            current.setUTCDate(current.getUTCDate() + 1);
+        }
+
+        query.date = { $in: queryDates };
+        return DailyStat.find(query);
+    }
+
+    // 处理统计数据
+    _processStats(allStats, startDate, endDate, isSingleDay = false) {
+        const dailyStats = {};
+        const appDailyStats = {};
+        const hourlyStats = Array(24).fill(0);
+        const appHourlyStats = {};
+        let totalUsage = 0;
+
+        allStats.forEach(stat => {
+            const appName = stat.appName;
+
+            // 将数据库的 date 转换回本地日期
+            const dbDate = new Date(stat.date);
+            const localDayStart = this.tzUtils.utcToLocal(dbDate);
+            const localDateOnly = new Date(Date.UTC(
+                localDayStart.getUTCFullYear(),
+                localDayStart.getUTCMonth(),
+                localDayStart.getUTCDate()
+            ));
+
+            const dateKey = localDateOnly.toISOString().split('T')[0];
+
+            // 初始化
+            if (!dailyStats[dateKey]) dailyStats[dateKey] = 0;
+            if (!appDailyStats[appName]) appDailyStats[appName] = {};
+            if (!appDailyStats[appName][dateKey]) appDailyStats[appName][dateKey] = 0;
+            if (!appHourlyStats[appName]) {
+                appHourlyStats[appName] = Array(24).fill(0);
+            }
+
+            // 累加每小时数据
+            stat.hourlyUsage.forEach((minutes, hour) => {
+                if (minutes > 0) {
+                    dailyStats[dateKey] += minutes;
+                    appDailyStats[appName][dateKey] += minutes;
+                    hourlyStats[hour] += minutes;
+                    appHourlyStats[appName][hour] += minutes;
+                    totalUsage += minutes;
+                }
+            });
+        });
+
+        return { dailyStats, appDailyStats, hourlyStats, appHourlyStats, totalUsage };
+    }
+
+    // ============ 对外接口 ============
+
+    // 获取某天的统计数据
+    async getDailyStats(deviceId, date) {
+        const localDate = this.tzUtils.parseDate(date);
+
+        const allStats = await this._queryStats(
+            { deviceId },
+            localDate,
+            localDate
+        );
+
+        const { hourlyStats, appHourlyStats, totalUsage } = this._processStats(
+            allStats,
+            localDate,
+            localDate,
+            true
+        );
+
+        // 只保留有数据的应用
+        const appStats = {};
+        Object.keys(appHourlyStats).forEach(appName => {
+            const total = appHourlyStats[appName].reduce((sum, val) => sum + val, 0);
+            if (total > 0) appStats[appName] = total;
+        });
+
+        return {
+            totalUsage,
+            appStats,
+            hourlyStats,
+            appHourlyStats: Object.keys(appStats).length > 0 ? appHourlyStats : {}
+        };
+    }
+
+    // 获取周统计
+    async getWeeklyAppStats(deviceId, appName = null, weekOffset = 0) {
+        const { startDate, endDate } = this.dateRangeHelper.getWeekRange(weekOffset);
+
+        const query = { deviceId };
+        if (appName) query.appName = appName;
+
+        const allStats = await this._queryStats(query, startDate, endDate);
+        const { dailyStats, appDailyStats } = this._processStats(allStats, startDate, endDate);
+
+        return {
+            weekOffset,
+            weekRange: {
+                start: startDate.toISOString().split('T')[0],
+                end: endDate.toISOString().split('T')[0]
+            },
+            dailyTotals: dailyStats,
+            appDailyStats: appName ? { [appName]: appDailyStats[appName] || {} } : appDailyStats
+        };
+    }
+
+    // 获取月统计
+    async getMonthlyAppStats(deviceId, appName = null, monthOffset = 0) {
+        const { startDate, endDate } = this.dateRangeHelper.getMonthRange(monthOffset);
+
+        const query = { deviceId };
+        if (appName) query.appName = appName;
+
+        const allStats = await this._queryStats(query, startDate, endDate);
+        const { dailyStats, appDailyStats } = this._processStats(allStats, startDate, endDate);
+
+        return {
+            monthOffset,
+            monthRange: {
+                start: startDate.toISOString().split('T')[0],
+                end: endDate.toISOString().split('T')[0]
+            },
+            dailyTotals: dailyStats,
+            appDailyStats: appName ? { [appName]: appDailyStats[appName] || {} } : appDailyStats
+        };
+    }
+
+    // 获取某天所有设备统计
+    async getDailyStatsForAllDevices(date) {
+        const localDate = this.tzUtils.parseDate(date);
+
+        const allStats = await this._queryStats({}, localDate, localDate);
+        const { hourlyStats, appHourlyStats, totalUsage } = this._processStats(
+            allStats,
+            localDate,
+            localDate,
+            true
+        );
+
+        const appStats = {};
+        Object.keys(appHourlyStats).forEach(appName => {
+            const total = appHourlyStats[appName].reduce((sum, val) => sum + val, 0);
+            if (total > 0) appStats[appName] = total;
+        });
+
+        return { totalUsage, appStats, hourlyStats, appHourlyStats };
+    }
+
+    // 获取周统计所有设备
+    async getWeeklyAppStatsForAllDevices(appName = null, weekOffset = 0) {
+        const { startDate, endDate } = this.dateRangeHelper.getWeekRange(weekOffset);
+
+        const query = {};
+        if (appName) query.appName = appName;
+
+        const allStats = await this._queryStats(query, startDate, endDate);
+        const { dailyStats, appDailyStats } = this._processStats(allStats, startDate, endDate);
+
+        return {
+            weekOffset,
+            weekRange: {
+                start: startDate.toISOString().split('T')[0],
+                end: endDate.toISOString().split('T')[0]
+            },
+            dailyTotals: dailyStats,
+            appDailyStats: appName ? { [appName]: appDailyStats[appName] || {} } : appDailyStats
+        };
+    }
+
+    // 获取月统计所有设备
+    async getMonthlyAppStatsForAllDevices(appName = null, monthOffset = 0) {
+        const { startDate, endDate } = this.dateRangeHelper.getMonthRange(monthOffset);
+
+        const query = {};
+        if (appName) query.appName = appName;
+
+        const allStats = await this._queryStats(query, startDate, endDate);
+        const { dailyStats, appDailyStats } = this._processStats(allStats, startDate, endDate);
+
+        return {
+            monthOffset,
+            monthRange: {
+                start: startDate.toISOString().split('T')[0],
+                end: endDate.toISOString().split('T')[0]
+            },
+            dailyTotals: dailyStats,
+            appDailyStats: appName ? { [appName]: appDailyStats[appName] || {} } : appDailyStats
+        };
+    }
+
+    // 获取设备列表
+    async getDevices() {
+        return Array.from(this.recorder.recentAppSwitches.keys()).map(deviceId => {
+            let currentApp = "Unknown";
+            let runningSince = new Date();
+            let isRunning = true;
+            const batteryInfo = this.recorder.getLatestBatteryInfo(deviceId);
+
+            if (this.recorder.recentAppSwitches.has(deviceId) && this.recorder.recentAppSwitches.get(deviceId).length > 0) {
+                const lastSwitch = this.recorder.recentAppSwitches.get(deviceId)[0];
+                currentApp = lastSwitch.appName;
+                runningSince = lastSwitch.timestamp;
+                isRunning = lastSwitch.running !== false;
+            }
+
+            return {
+                device: deviceId,
+                currentApp,
+                running: isRunning,
+                runningSince,
+                batteryLevel: batteryInfo.level,
+                isCharging: batteryInfo.isCharging,
+                batteryTimestamp: batteryInfo.timestamp
+            };
+        });
+    }
+}
+
+module.exports = StatsQuery;

services/StatsRecorder.js

@@ -0,0 +1,236 @@
+// StatsRecorder.js - 记录信息模块
+const { mongoose } = require('../index');
+const EyeTimeRecorder = require('./EyeTimeRecorder');
+const TimezoneUtils = require('../utils/timezone'); // 引入时区工具
+
+let eyeTimeRecorder;
+let timezoneUtils;
+
+// 定义新的数据模型 - 按天/小时/应用存储
+const DailyStat = mongoose.model('DailyStat', {
+    deviceId: String,
+    date: Date,       // 本地时区日期零点 (存储为该时区零点的 UTC 时间戳)
+    appName: String,
+    hourlyUsage: [Number] // 24小时数组,每项代表分钟数
+});
+
+class StatsRecorder {
+    constructor(timezoneConfig = 8) {
+        // 初始化时区工具（接收时区偏移或时区名称）
+        timezoneUtils = new TimezoneUtils(timezoneConfig);
+        eyeTimeRecorder = new EyeTimeRecorder({timezoneOffset: timezoneConfig});
+        // 设备应用切换记录
+        this.recentAppSwitches = new Map(); // {deviceId: [{appName, timestamp}]}
+        // 电池信息存储
+        this.batteryInfo = new Map(); // {deviceId: {level, isCharging, timestamp}}
+    }
+
+    // 记录电池信息和充电状态
+    recordBattery(deviceId, level, isCharging = false) {
+        const now = new Date();
+
+        this.batteryInfo.set(deviceId, {
+            level: level,
+            isCharging: isCharging,
+            timestamp: now
+        });
+    }
+
+    // 获取最新电池信息
+    getLatestBatteryInfo(deviceId) {
+        const info = this.batteryInfo.get(deviceId);
+        if (!info) {
+            return {
+                level: 0,
+                isCharging: false,
+                timestamp: null
+            };
+        }
+        return info;
+    }
+
+    // 记录应用使用时间
+    async recordUsage(deviceId, appName, running) {
+        const now = new Date();
+
+        await eyeTimeRecorder.recordActivity(deviceId, running) // 记录公共使用时间（用眼时长）
+
+        if (!this.recentAppSwitches.has(deviceId)) {
+            this.recentAppSwitches.set(deviceId, []);
+        }
+
+        const deviceSwitches = this.recentAppSwitches.get(deviceId);
+
+        // 处理停止运行的情况
+        if (running === false) {
+            if (deviceSwitches.length > 0) {
+                const lastSwitch = deviceSwitches[0];
+                if (lastSwitch.running !== false) {
+                    const minutesSinceLastSwitch = this.calculatePreciseMinutes(lastSwitch.timestamp, now);
+                    // 更新应用分时段时间统计,传递完整的开始时间戳
+                    await this.updateDailyStat(deviceId, lastSwitch.appName, lastSwitch.timestamp, minutesSinceLastSwitch);
+                }
+                deviceSwitches[0].running = false;
+                deviceSwitches.unshift({
+                    appName: "设备待机",
+                    timestamp: now,
+                    running: false
+                });
+            }
+            return;
+        }
+
+        // 使用时间计算
+        let minutesSinceLastSwitch = 0;
+        if (deviceSwitches.length > 0) {
+            const lastSwitch = deviceSwitches[0];
+            if (lastSwitch.running !== false) {
+                minutesSinceLastSwitch = this.calculatePreciseMinutes(lastSwitch.timestamp, now);
+                // 关键修改:传递完整的开始时间戳
+                await this.updateDailyStat(deviceId, lastSwitch.appName, lastSwitch.timestamp, minutesSinceLastSwitch);
+            }
+        }
+
+        // 添加新记录
+        deviceSwitches.unshift({
+            appName: appName,
+            timestamp: now,
+            running: true
+        });
+
+        if (deviceSwitches.length > 20) {
+            deviceSwitches.pop();
+        }
+    }
+
+    // 精确计算时间差,返回小数分钟(精确到2位)
+    calculatePreciseMinutes(startTime, endTime) {
+        const milliseconds = endTime - startTime;
+        const minutes = milliseconds / (60 * 1000);
+        // 保留2位小数
+        return Math.round(minutes * 100) / 100;
+    }
+
+    // 获取本地时区的日期零点（返回该零点对应的 UTC Date 对象）
+    getLocalDayStart(timestamp) {
+        // 将 UTC 时间转换为本地时间
+        const localTime = timezoneUtils.utcToLocal(new Date(timestamp));
+
+        // 获取本地时间的日期部分
+        const year = localTime.getUTCFullYear();
+        const month = localTime.getUTCMonth();
+        const day = localTime.getUTCDate();
+
+        // 创建本地零点时间
+        const localDayStart = new Date(Date.UTC(year, month, day, 0, 0, 0, 0));
+
+        // 转换回 UTC（这样存储的就是本地零点对应的 UTC 时间）
+        return timezoneUtils.localToUtc(localDayStart);
+    }
+
+    // 更新每日统计
+    async updateDailyStat(deviceId, appName, startTimestamp, durationMinutes) {
+        // 使用本地时区的日期零点
+        const dayStart = this.getLocalDayStart(startTimestamp);
+
+        let stat = await DailyStat.findOne({
+            deviceId,
+            date: dayStart,
+            appName
+        });
+
+        if (!stat) {
+            stat = new DailyStat({
+                deviceId,
+                date: dayStart,
+                appName,
+                hourlyUsage: Array(24).fill(0)
+            });
+        }
+
+        await this.distributePreciseMinutes(stat, startTimestamp, durationMinutes);
+        await stat.save();
+    }
+
+    async distributePreciseMinutes(stat, startTimestamp, totalMinutes) {
+        let remainingMinutes = totalMinutes;
+        let currentTimestamp = new Date(startTimestamp);
+
+        while (remainingMinutes > 0) {
+            // 获取当前时间戳对应的本地日期零点
+            const currentDayStart = this.getLocalDayStart(currentTimestamp);
+
+            // 获取本地时区的小时、分钟、秒
+            const localTime = timezoneUtils.utcToLocal(currentTimestamp);
+            const currentHour = localTime.getUTCHours();
+            const currentMinute = localTime.getUTCMinutes();
+            const currentSecond = localTime.getUTCSeconds();
+
+            // 如果跨日期了,需要获取新的统计记录
+            let currentStat = stat;
+            if (currentDayStart.getTime() !== stat.date.getTime()) {
+                currentStat = await DailyStat.findOne({
+                    deviceId: stat.deviceId,
+                    date: currentDayStart,
+                    appName: stat.appName
+                });
+
+                if (!currentStat) {
+                    currentStat = new DailyStat({
+                        deviceId: stat.deviceId,
+                        date: currentDayStart,
+                        appName: stat.appName,
+                        hourlyUsage: Array(24).fill(0)
+                    });
+                }
+            }
+
+            // 计算当前小时内已使用的分钟数
+            const usedInCurrentHour = currentStat.hourlyUsage[currentHour];
+
+            // 计算当前时间点到下一个小时开始还有多少分钟
+            const minutesToNextHour = 60 - currentMinute - (currentSecond > 0 ? (currentSecond / 60) : 0);
+
+            // 当前小时的剩余容量
+            const availableSpace = Math.max(0, 60 - usedInCurrentHour);
+
+            // 实际能在当前小时分配的时间
+            const minutesToAdd = Math.min(remainingMinutes, minutesToNextHour, availableSpace);
+
+            if (minutesToAdd > 0) {
+                const preciseMinutesToAdd = Math.round(minutesToAdd * 100) / 100;
+                currentStat.hourlyUsage[currentHour] = Math.round((currentStat.hourlyUsage[currentHour] + preciseMinutesToAdd) * 100) / 100;
+
+                // 如果是跨日期的新统计记录,需要保存
+                if (currentStat !== stat) {
+                    await currentStat.save();
+                }
+
+                remainingMinutes = Math.round((remainingMinutes - preciseMinutesToAdd) * 100) / 100;
+            }
+
+            // 移动到下一个时间点
+            if (minutesToAdd >= minutesToNextHour) {
+                // 移动到下一个小时的开始
+                currentTimestamp = new Date(currentTimestamp.getTime() + minutesToNextHour * 60 * 1000);
+            } else {
+                // 在当前小时内完成了分配
+                break;
+            }
+
+            // 避免浮点数精度问题
+            if (remainingMinutes < 0.01) {
+                remainingMinutes = 0;
+            }
+
+            // 防止无限循环(最多处理30天)
+            const daysDifference = Math.floor((currentTimestamp - startTimestamp) / (24 * 60 * 60 * 1000));
+            if (daysDifference > 30) {
+                console.warn(`超过30天限制,剩余 ${remainingMinutes} 分钟无法分配,设备: ${stat.deviceId}, 应用: ${stat.appName}`);
+                break;
+            }
+        }
+    }
+}
+
+module.exports = StatsRecorder;