MQTTvue/mqtt-vue-dashboard/server/dist/controllers/deviceBindingController.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DeviceBindingController = void 0;
const deviceBinding_1 = require("../models/deviceBinding");
const device_1 = require("../models/device");
const helpers_1 = require("../utils/helpers");
class DeviceBindingController {
    static async getAllBindings(req, res) {
        try {
            const bindings = await deviceBinding_1.DeviceBindingModel.getAll();
            res.json({
                success: true,
                data: bindings,
                message: '获取设备绑定关系成功'
            });
        }
        catch (error) {
            console.error('获取设备绑定关系失败:', error);
            res.status(500).json({
                success: false,
                message: '获取设备绑定关系失败',
                error: error.message
            });
        }
    }
    static async getDevicesByRoom(req, res) {
        try {
            const { roomId } = req.params;
            const roomIdStr = (0, helpers_1.toString)(roomId);
            if (!roomIdStr || isNaN(parseInt(roomIdStr))) {
                res.status(400).json({
                    success: false,
                    message: '房间ID无效'
                });
                return;
            }
            const devices = await deviceBinding_1.DeviceBindingModel.getByRoomId(parseInt(roomIdStr));
            res.json({
                success: true,
                data: devices,
                message: '获取房间设备成功'
            });
        }
        catch (error) {
            console.error('获取房间设备失败:', error);
            res.status(500).json({
                success: false,
                message: '获取房间设备失败',
                error: error.message
            });
        }
    }
    static async getAvailableDevices(req, res) {
        try {
            const devices = await deviceBinding_1.DeviceBindingModel.getAvailableDevices();
            res.json({
                success: true,
                data: devices,
                message: '获取可绑定设备成功'
            });
        }
        catch (error) {
            console.error('获取可绑定设备失败:', error);
            res.status(500).json({
                success: false,
                message: '获取可绑定设备失败',
                error: error.message
            });
        }
    }
    static async getAllDevicesWithBindingStatus(req, res) {
        try {
            const page = parseInt((0, helpers_1.toString)(req.query.page)) || 1;
            const pageSize = parseInt((0, helpers_1.toString)(req.query.pageSize)) || 10;
            const status = (0, helpers_1.toString)(req.query.status);
            const room_id = req.query.room_id ? parseInt((0, helpers_1.toString)(req.query.room_id)) : undefined;
            const search = (0, helpers_1.toString)(req.query.search);
            const filters = {
                ...(status && { status }),
                ...(room_id && { room_id }),
                ...(search && { search })
            };
            const { devices, total } = await deviceBinding_1.DeviceBindingModel.getAllDevicesWithBindingStatus(page, pageSize, filters);
            res.json({
                success: true,
                data: {
                    devices,
                    pagination: {
                        current: page,
                        pageSize,
                        total
                    }
                },
                message: '获取设备绑定状态成功'
            });
        }
        catch (error) {
            console.error('获取设备绑定状态失败:', error);
            res.status(500).json({
                success: false,
                message: '获取设备绑定状态失败',
                error: error.message
            });
        }
    }
    static async bindDevice(req, res) {
        try {
            const { device_clientid, room_id, device_name, device_type, properties } = req.body;
            if (!device_clientid || !room_id) {
                res.status(400).json({
                    success: false,
                    message: '设备客户端ID和房间ID为必填项'
                });
                return;
            }
            const device = await device_1.DeviceModel.getByClientId(device_clientid);
            if (!device) {
                res.status(404).json({
                    success: false,
                    message: '设备不存在'
                });
                return;
            }
            const binding = await deviceBinding_1.DeviceBindingModel.bindDevice(device_clientid, room_id);
            res.status(201).json({
                success: true,
                data: binding,
                message: '设备绑定成功'
            });
        }
        catch (error) {
            console.error('设备绑定失败:', error);
            res.status(500).json({
                success: false,
                message: '设备绑定失败',
                error: error.message
            });
        }
    }
    static async unbindDevice(req, res) {
        try {
            const { deviceClientId } = req.params;
            const deviceClientIdStr = (0, helpers_1.toString)(deviceClientId);
            if (!deviceClientIdStr) {
                res.status(400).json({
                    success: false,
                    message: '设备客户端ID为必填项'
                });
                return;
            }
            const success = await deviceBinding_1.DeviceBindingModel.unbindDevice(deviceClientIdStr);
            if (!success) {
                res.status(404).json({
                    success: false,
                    message: '设备绑定关系不存在'
                });
                return;
            }
            res.json({
                success: true,
                message: '设备解绑成功'
            });
        }
        catch (error) {
            console.error('设备解绑失败:', error);
            res.status(500).json({
                success: false,
                message: '设备解绑失败',
                error: error.message
            });
        }
    }
    static async updateBinding(req, res) {
        try {
            const { id } = req.params;
            const { room_id, device_name, device_type, properties } = req.body;
            const idStr = (0, helpers_1.toString)(id);
            if (!idStr || isNaN(parseInt(idStr))) {
                res.status(400).json({
                    success: false,
                    message: '绑定ID无效'
                });
                return;
            }
            const binding = await deviceBinding_1.DeviceBindingModel.updateBinding(parseInt(idStr), {
                room_id,
                device_name,
                device_type,
                properties
            });
            res.json({
                success: true,
                data: binding,
                message: '设备绑定更新成功'
            });
        }
        catch (error) {
            console.error('更新设备绑定失败:', error);
            res.status(500).json({
                success: false,
                message: '更新设备绑定失败',
                error: error.message
            });
        }
    }
    static async getRoomDevicesWithDetails(req, res) {
        try {
            const { roomId } = req.params;
            const roomIdStr = (0, helpers_1.toString)(roomId);
            if (!roomIdStr || isNaN(parseInt(roomIdStr))) {
                res.status(400).json({
                    success: false,
                    message: '房间ID无效'
                });
                return;
            }
            const devices = await deviceBinding_1.DeviceBindingModel.getRoomDevicesWithDetails(parseInt(roomIdStr));
            res.json({
                success: true,
                data: devices,
                message: '获取房间设备详情成功'
            });
        }
        catch (error) {
            console.error('获取房间设备详情失败:', error);
            res.status(500).json({
                success: false,
                message: '获取房间设备详情失败',
                error: error.message
            });
        }
    }
}
exports.DeviceBindingController = DeviceBindingController;
//# sourceMappingURL=deviceBindingController.js.map