Node.js Express 路由聚合：优化内部逻辑调用与代码复用

// services/alarmService.js
/**
 * 模拟获取报警1数据的服务函数
 * @param {string} siteId - 站点ID
 * @returns {Promise<Object>} 报警1数据
 */
async function getAlarm1Data(siteId) {
    // 模拟异步数据获取或复杂计算
    return new Promise(resolve => setTimeout(() => {
        console.log(`[Service] Fetching alarm1 data for site: ${siteId}`);
        resolve({ id: 'A1', type: 'Fire Alarm', status: 'Active', site: siteId, timestamp: new Date().toISOString() });
    }, 100));
}

/**
 * 模拟获取报警2数据的服务函数
 * @param {string} siteId - 站点ID
 * @returns {Promise<Object>} 报警2数据
 */
async function getAlarm2Data(siteId) {
    return new Promise(resolve => setTimeout(() => {
        console.log(`[Service] Fetching alarm2 data for site: ${siteId}`);
        resolve({ id: 'A2', type: 'Smoke Detector', status: 'Inactive', site: siteId, timestamp: new Date().toISOString() });
    }, 150));
}

/**
 * 模拟获取报警3数据的服务函数
 * @param {string} siteId - 站点ID
 * @returns {Promise<Object>} 报警3数据
 */
async function getAlarm3Data(siteId) {
    return new Promise(resolve => setTimeout(() => {
        console.log(`[Service] Fetching alarm3 data for site: ${siteId}`);
        resolve({ id: 'A3', type: 'Water Leak', status: 'Active', site: siteId, timestamp: new Date().toISOString() });
    }, 80));
}

/**
 * 模拟获取报警4数据的服务函数
 * @param {string} siteId - 站点ID
 * @returns {Promise<Object>} 报警4数据
 */
async function getAlarm4Data(siteId) {
    return new Promise(resolve => setTimeout(() => {
        console.log(`[Service] Fetching alarm4 data for site: ${siteId}`);
        resolve({ id: 'A4', type: 'Motion Sensor', status: 'Active', site: siteId, timestamp: new Date().toISOString() });
    }, 120));
}

module.exports = {
    getAlarm1Data,
    getAlarm2Data,
    getAlarm3Data,
    getAlarm4Data
};

// routes/alarmRoutes.js
const express = require('express');
const router = express.Router();
const alarmService = require('../services/alarmService'); // 引入业务逻辑模块

// 假设这是你的中间件文件，需要根据实际路径调整
// const { authenticateUser } = require('../middleware/auth/authenticateUser');
// const { getSiteIds } = require('../middleware/sites/getSiteIds');

// 模拟中间件，实际项目中应从单独文件导入
function authenticateUser(req, res, next) {
    const authHeader = req.headers.authorization;
    if (!authHeader || !authHeader.startsWith('Bearer ')) {
        return res.status(401).json({ message: 'Authentication required' });
    }
    // 实际中会验证token并设置req.user
    req.user = { id: 'testUser', roles: ['admin'] };
    console.log('[Middleware] User authenticated.');
    next();
}

function getSiteIds(req, res, next) {
    // 实际中会根据用户或请求参数获取站点ID
    req.siteId = 'SITE_XYZ';
    console.log(`[Middleware] Site ID for request: ${req.siteId}`);
    next();
}

// 应用全局中间件到此路由器
router.use(authenticateUser);
router.use(getSiteIds);

// 单个报警数据端点 - /api/alarms/alarm1
router.get('/alarm1', async (req, res) => {
    try {
        const siteId = req.siteId; // 从getSiteIds中间件获取
        const data = await alarmService.getAlarm1Data(siteId);
        res.json(data);
    } catch (error) {
        console.error('Error fetching alarm1 data:', error);
        res.status(500).json({ error: 'Failed to retrieve alarm1 data.' });
    }
});

// 单个报警数据端点 - /api/alarms/alarm2
router.get('/alarm2', async (req, res) => {
    try {
        const siteId = req.siteId;
        const data = await alarmService.getAlarm2Data(siteId);
        res.json(data);
    } catch (error) {
        console.error('Error fetching alarm2 data:', error);
        res.status(500).json({ error: 'Failed to retrieve alarm2 data.' });
    }
});

// ... 可以添加 alarm3 和 alarm4 的独立路由

// 聚合所有报警数据端点 - /api/alarms/all-alarms
router.get('/all-alarms', async (req, res) => {
    try {
        const siteId = req.siteId; // 从getSiteIds中间件获取

        // 使用 Promise.all 并行调用所有业务逻辑函数
        const [alarm1Data, alarm2Data, alarm3Data, alarm4Data] = await Promise.all([
            alarmService.getAlarm1Data(siteId),
            alarmService.getAlarm2Data(siteId),
            alarmService.getAlarm3Data(siteId),
            alarmService.getAlarm4Data(siteId)
        ]);

        // 组合结果
        const aggregatedData = {
            alarm1: alarm1Data,
            alarm2: alarm2Data,
            alarm3: alarm3Data,
            alarm4: alarm4Data
        };
        res.json(aggregatedData);
    } catch (error) {
        console.error('Error fetching all alarms data:', error);
        res.status(500).json({ error: 'Failed to retrieve all alarms data.' });
    }
});

module.exports = router;

// app.js
const express = require('express');
const app = express();
const alarmRoutes = require('./routes/alarmRoutes'); // 引入报警路由

// 可以添加其他全局中间件，例如 body-parser 等
app.use(express.json()); // 用于解析JSON格式的请求体

// 将报警路由挂载到 /api/alarms 路径下
app.use('/api/alarms', alarmRoutes);

// 定义一个根路由，可选
app.get('/', (req, res) => {
    res.send('Welcome to the Alarm API!');
});

// 启动服务器
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Server running on port ${PORT}`);
    console.log(`Access individual alarms at: http://localhost:${PORT}/api/alarms/alarm1`);
    console.log(`Access aggregated alarms at: http://localhost:${PORT}/api/alarms/all-alarms`);
});