初始化IDC设备管理系统项目

backend/db.js

@@ -0,0 +1,9 @@
+const { Sequelize } = require('sequelize');
+
+// 创建并导出sequelize实例
+const sequelize = new Sequelize({
+  dialect: 'sqlite',
+  storage: './idc_management.db' // SQLite数据库文件路径
+});
+
+module.exports = { sequelize };

backend/initDeviceFields.js

@@ -0,0 +1,171 @@
+const DeviceField = require('./models/DeviceField');
+const { sequelize } = require('./db');
+
+// 默认设备字段配置
+const defaultDeviceFields = [
+  {
+    fieldName: 'deviceId',
+    displayName: '设备ID',
+    fieldType: 'string',
+    required: true,
+    order: 1,
+    visible: true
+  },
+  {
+    fieldName: 'name',
+    displayName: '设备名称',
+    fieldType: 'string',
+    required: true,
+    order: 2,
+    visible: true
+  },
+  {
+    fieldName: 'type',
+    displayName: '设备类型',
+    fieldType: 'select',
+    required: true,
+    order: 3,
+    visible: true,
+    options: [
+      { value: 'server', label: '服务器' },
+      { value: 'switch', label: '交换机' },
+      { value: 'router', label: '路由器' },
+      { value: 'storage', label: '存储设备' },
+      { value: 'other', label: '其他设备' }
+    ]
+  },
+  {
+    fieldName: 'model',
+    displayName: '型号',
+    fieldType: 'string',
+    required: true,
+    order: 4,
+    visible: true
+  },
+  {
+    fieldName: 'serialNumber',
+    displayName: '序列号',
+    fieldType: 'string',
+    required: true,
+    order: 5,
+    visible: true
+  },
+  {
+    fieldName: 'rackId',
+    displayName: '所在机柜',
+    fieldType: 'select',
+    required: true,
+    order: 6,
+    visible: true
+  },
+  {
+    fieldName: 'position',
+    displayName: '位置(U)',
+    fieldType: 'number',
+    required: true,
+    order: 7,
+    visible: true
+  },
+  {
+    fieldName: 'height',
+    displayName: '高度(U)',
+    fieldType: 'number',
+    required: true,
+    order: 8,
+    visible: true
+  },
+  {
+    fieldName: 'powerConsumption',
+    displayName: '功率(W)',
+    fieldType: 'number',
+    required: true,
+    order: 9,
+    visible: true
+  },
+  {
+    fieldName: 'status',
+    displayName: '状态',
+    fieldType: 'select',
+    required: true,
+    order: 10,
+    visible: true,
+    options: [
+      { value: 'running', label: '运行中' },
+      { value: 'maintenance', label: '维护中' },
+      { value: 'offline', label: '离线' },
+      { value: 'fault', label: '故障' }
+    ]
+  },
+  {
+    fieldName: 'purchaseDate',
+    displayName: '购买日期',
+    fieldType: 'date',
+    required: true,
+    order: 11,
+    visible: true
+  },
+  {
+    fieldName: 'warrantyExpiry',
+    displayName: '保修到期',
+    fieldType: 'date',
+    required: true,
+    order: 12,
+    visible: true
+  },
+  {
+    fieldName: 'ipAddress',
+    displayName: 'IP地址',
+    fieldType: 'string',
+    required: false,
+    order: 13,
+    visible: true
+  },
+  {
+    fieldName: 'description',
+    displayName: '描述',
+    fieldType: 'textarea',
+    required: false,
+    order: 14,
+    visible: true
+  }
+];
+
+// 初始化设备字段
+async function initDeviceFields() {
+  try {
+    console.log('开始初始化设备字段配置...');
+    
+    // 连接数据库
+    await sequelize.authenticate();
+    console.log('数据库连接成功');
+    
+    // 同步表结构
+    await sequelize.sync();
+    console.log('数据库表结构同步完成');
+    
+    // 批量创建默认字段
+    for (const field of defaultDeviceFields) {
+      // 检查字段是否已存在
+      const existingField = await DeviceField.findOne({
+        where: { fieldName: field.fieldName }
+      });
+      
+      if (existingField) {
+        // 更新已有字段
+        await existingField.update(field);
+        console.log(`更新字段: ${field.displayName}`);
+      } else {
+        // 创建新字段
+        await DeviceField.create(field);
+        console.log(`创建字段: ${field.displayName}`);
+      }
+    }
+    
+    console.log('设备字段配置初始化完成');
+  } catch (error) {
+    console.error('设备字段配置初始化失败:', error);
+  }
+}
+
+// 导出初始化函数
+module.exports = initDeviceFields;

backend/models/Device.js

@@ -0,0 +1,82 @@
+const { DataTypes } = require('sequelize');
+const { sequelize } = require('../db');
+const Rack = require('./Rack');
+
+const Device = sequelize.define('Device', {
+  deviceId: {
+    type: DataTypes.STRING,
+    primaryKey: true,
+    allowNull: false,
+    unique: true
+  },
+  name: {
+    type: DataTypes.STRING,
+    allowNull: false
+  },
+  type: {
+    type: DataTypes.STRING,
+    allowNull: false
+  },
+  model: {
+    type: DataTypes.STRING,
+    allowNull: false
+  },
+  serialNumber: {
+    type: DataTypes.STRING,
+    allowNull: false,
+    unique: true
+  },
+  rackId: {
+    type: DataTypes.STRING,
+    allowNull: false,
+    references: {
+      model: Rack,
+      key: 'rackId'
+    }
+  },
+  position: {
+    type: DataTypes.INTEGER,
+    allowNull: false // 设备在机柜中的位置（U数）
+  },
+  height: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+    defaultValue: 1 // 设备高度（U数）
+  },
+  powerConsumption: {
+    type: DataTypes.FLOAT,
+    allowNull: false
+  },
+  status: {
+    type: DataTypes.STRING,
+    defaultValue: 'running'
+  },
+  purchaseDate: {
+    type: DataTypes.DATE,
+    allowNull: false
+  },
+  warrantyExpiry: {
+    type: DataTypes.DATE,
+    allowNull: false
+  },
+  ipAddress: {
+    type: DataTypes.STRING
+  },
+  description: {
+    type: DataTypes.TEXT
+  },
+  customFields: {
+    type: DataTypes.JSON,
+    defaultValue: {},
+    allowNull: false
+  }
+}, {
+  tableName: 'devices',
+  timestamps: true
+});
+
+// 关联关系
+Device.belongsTo(Rack, { foreignKey: 'rackId' });
+Rack.hasMany(Device, { foreignKey: 'rackId' });
+
+module.exports = Device;

backend/models/DeviceField.js

@@ -0,0 +1,49 @@
+const { DataTypes } = require('sequelize');
+const { sequelize } = require('../db');
+
+const DeviceField = sequelize.define('DeviceField', {
+  fieldId: {
+    type: DataTypes.INTEGER,
+    primaryKey: true,
+    autoIncrement: true,
+    allowNull: false
+  },
+  fieldName: {
+    type: DataTypes.STRING,
+    allowNull: false,
+    unique: true
+  },
+  displayName: {
+    type: DataTypes.STRING,
+    allowNull: false
+  },
+  fieldType: {
+    type: DataTypes.STRING,
+    allowNull: false,
+    defaultValue: 'string'
+  },
+  required: {
+    type: DataTypes.BOOLEAN,
+    allowNull: false,
+    defaultValue: false
+  },
+  options: {
+    type: DataTypes.JSON,
+    allowNull: true
+  },
+  order: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+    defaultValue: 0
+  },
+  visible: {
+    type: DataTypes.BOOLEAN,
+    allowNull: false,
+    defaultValue: true
+  }
+}, {
+  tableName: 'deviceFields',
+  timestamps: true
+});
+
+module.exports = DeviceField;

backend/models/Rack.js

@@ -0,0 +1,50 @@
+const { DataTypes } = require('sequelize');
+const { sequelize } = require('../db');
+const Room = require('./Room');
+
+const Rack = sequelize.define('Rack', {
+  rackId: {
+    type: DataTypes.STRING,
+    primaryKey: true,
+    allowNull: false,
+    unique: true
+  },
+  name: {
+    type: DataTypes.STRING,
+    allowNull: false
+  },
+  height: {
+    type: DataTypes.INTEGER,
+    allowNull: false,
+    defaultValue: 42 // 标准机柜高度（U数）
+  },
+  maxPower: {
+    type: DataTypes.FLOAT,
+    allowNull: false
+  },
+  currentPower: {
+    type: DataTypes.FLOAT,
+    defaultValue: 0
+  },
+  status: {
+    type: DataTypes.STRING,
+    defaultValue: 'active'
+  },
+  roomId: {
+    type: DataTypes.STRING,
+    allowNull: false,
+    references: {
+      model: Room,
+      key: 'roomId'
+    }
+  }
+}, {
+  tableName: 'racks',
+  timestamps: true
+});
+
+// 关联关系
+Rack.belongsTo(Room, { foreignKey: 'roomId' });
+Room.hasMany(Rack, { foreignKey: 'roomId' });
+
+module.exports = Rack;

backend/models/Room.js

@@ -0,0 +1,39 @@
+const { DataTypes } = require('sequelize');
+const { sequelize } = require('../db');
+
+const Room = sequelize.define('Room', {
+  roomId: {
+    type: DataTypes.STRING,
+    primaryKey: true,
+    allowNull: false,
+    unique: true
+  },
+  name: {
+    type: DataTypes.STRING,
+    allowNull: false
+  },
+  location: {
+    type: DataTypes.STRING,
+    allowNull: false
+  },
+  area: {
+    type: DataTypes.FLOAT,
+    allowNull: false
+  },
+  capacity: {
+    type: DataTypes.INTEGER,
+    allowNull: false
+  },
+  status: {
+    type: DataTypes.STRING,
+    defaultValue: 'active'
+  },
+  description: {
+    type: DataTypes.TEXT
+  }
+}, {
+  tableName: 'rooms',
+  timestamps: true
+});
+
+module.exports = Room;

backend/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "idc-backend",
+  "version": "1.0.0",
+  "description": "IDC设备管理系统后端",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "nodemon server.js"
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "sequelize": "^6.32.1",
+    "sqlite3": "^5.1.6",
+    "cors": "^2.8.5"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.1"
+  }
+}

backend/routes/deviceFields.js

@@ -0,0 +1,73 @@
+const express = require('express');
+const router = express.Router();
+const DeviceField = require('../models/DeviceField');
+
+// 获取所有字段配置
+router.get('/', async (req, res) => {
+  try {
+    const fields = await DeviceField.findAll({
+      order: [['order', 'ASC']]
+    });
+    res.json(fields);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 获取单个字段配置
+router.get('/:fieldId', async (req, res) => {
+  try {
+    const field = await DeviceField.findByPk(req.params.fieldId);
+    if (!field) {
+      return res.status(404).json({ error: '字段不存在' });
+    }
+    res.json(field);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 创建字段配置
+router.post('/', async (req, res) => {
+  try {
+    const field = await DeviceField.create(req.body);
+    res.status(201).json(field);
+  } catch (error) {
+    res.status(400).json({ error: error.message });
+  }
+});
+
+// 更新字段配置
+router.put('/:fieldId', async (req, res) => {
+  try {
+    const [updated] = await DeviceField.update(req.body, {
+      where: { fieldId: req.params.fieldId }
+    });
+    if (updated) {
+      const updatedField = await DeviceField.findByPk(req.params.fieldId);
+      res.json(updatedField);
+    } else {
+      res.status(404).json({ error: '字段不存在' });
+    }
+  } catch (error) {
+    res.status(400).json({ error: error.message });
+  }
+});
+
+// 删除字段配置
+router.delete('/:fieldId', async (req, res) => {
+  try {
+    const deleted = await DeviceField.destroy({
+      where: { fieldId: req.params.fieldId }
+    });
+    if (deleted) {
+      res.status(204).json();
+    } else {
+      res.status(404).json({ error: '字段不存在' });
+    }
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+module.exports = router;

backend/routes/devices.js

@@ -0,0 +1,124 @@
+const express = require('express');
+const router = express.Router();
+const Device = require('../models/Device');
+const Rack = require('../models/Rack');
+
+// 获取所有设备
+router.get('/', async (req, res) => {
+  try {
+    const devices = await Device.findAll({
+      include: [
+        { model: Rack }
+      ]
+    });
+    res.json(devices);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 获取单个设备
+router.get('/:deviceId', async (req, res) => {
+  try {
+    const device = await Device.findByPk(req.params.deviceId, {
+      include: [
+        { model: Rack }
+      ]
+    });
+    if (!device) {
+      return res.status(404).json({ error: '设备不存在' });
+    }
+    res.json(device);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 创建设备
+router.post('/', async (req, res) => {
+  try {
+    const device = await Device.create(req.body);
+    
+    // 更新机柜当前功率
+    const rack = await Rack.findByPk(req.body.rackId);
+    if (rack) {
+      await rack.update({
+        currentPower: rack.currentPower + req.body.powerConsumption
+      });
+    }
+    
+    res.status(201).json(device);
+  } catch (error) {
+    res.status(400).json({ error: error.message });
+  }
+});
+
+// 更新设备
+router.put('/:deviceId', async (req, res) => {
+  try {
+    // 获取旧设备信息以更新功率
+    const oldDevice = await Device.findByPk(req.params.deviceId);
+    if (!oldDevice) {
+      return res.status(404).json({ error: '设备不存在' });
+    }
+    
+    const [updated] = await Device.update(req.body, {
+      where: { deviceId: req.params.deviceId }
+    });
+    
+    if (updated) {
+      // 更新机柜当前功率
+      const rack = await Rack.findByPk(oldDevice.rackId);
+      if (rack) {
+        const powerDiff = req.body.powerConsumption - oldDevice.powerConsumption;
+        await rack.update({
+          currentPower: rack.currentPower + powerDiff
+        });
+      }
+      
+      const updatedDevice = await Device.findByPk(req.params.deviceId, {
+        include: [
+          { model: Rack }
+        ]
+      });
+      res.json(updatedDevice);
+    } else {
+      res.status(404).json({ error: '设备不存在' });
+    }
+  } catch (error) {
+    res.status(400).json({ error: error.message });
+  }
+});
+
+// 删除设备
+router.delete('/:deviceId', async (req, res) => {
+  try {
+    // 获取设备信息以更新功率
+    const device = await Device.findByPk(req.params.deviceId);
+    if (!device) {
+      return res.status(404).json({ error: '设备不存在' });
+    }
+    
+    const deleted = await Device.destroy({
+      where: { deviceId: req.params.deviceId }
+    });
+    
+    if (deleted) {
+      // 更新机柜当前功率
+      const rack = await Rack.findByPk(device.rackId);
+      if (rack) {
+        await rack.update({
+          currentPower: Math.max(0, rack.currentPower - device.powerConsumption)
+        });
+      }
+      
+      res.status(204).json();
+    } else {
+      res.status(404).json({ error: '设备不存在' });
+    }
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+module.exports = router;

backend/routes/racks.js

@@ -0,0 +1,94 @@
+const express = require('express');
+const router = express.Router();
+const Rack = require('../models/Rack');
+const Device = require('../models/Device');
+const Room = require('../models/Room');
+
+// 获取所有机柜
+router.get('/', async (req, res) => {
+  try {
+    const racks = await Rack.findAll({
+      include: [
+        { model: Room },
+        { model: Device }
+      ]
+    });
+    res.json(racks);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 获取单个机柜
+router.get('/:rackId', async (req, res) => {
+  try {
+    const rack = await Rack.findByPk(req.params.rackId, {
+      include: [
+        { model: Room },
+        { model: Device }
+      ]
+    });
+    if (!rack) {
+      return res.status(404).json({ error: '机柜不存在' });
+    }
+    res.json(rack);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 创建机柜
+router.post('/', async (req, res) => {
+  try {
+    const rack = await Rack.create(req.body);
+    res.status(201).json(rack);
+  } catch (error) {
+    res.status(400).json({ error: error.message });
+  }
+});
+
+// 更新机柜
+router.put('/:rackId', async (req, res) => {
+  try {
+    const [updated] = await Rack.update(req.body, {
+      where: { rackId: req.params.rackId }
+    });
+    if (updated) {
+      const updatedRack = await Rack.findByPk(req.params.rackId, {
+        include: [
+          { model: Room },
+          { model: Device }
+        ]
+      });
+      res.json(updatedRack);
+    } else {
+      res.status(404).json({ error: '机柜不存在' });
+    }
+  } catch (error) {
+    res.status(400).json({ error: error.message });
+  }
+});
+
+// 删除机柜
+router.delete('/:rackId', async (req, res) => {
+  try {
+    // 检查是否有设备关联
+    const devices = await Device.findAll({ where: { rackId: req.params.rackId } });
+    if (devices.length > 0) {
+      return res.status(400).json({ error: '该机柜下有设备，无法删除' });
+    }
+    
+    const deleted = await Rack.destroy({
+      where: { rackId: req.params.rackId }
+    });
+    if (deleted) {
+      res.status(204).json();
+    } else {
+      res.status(404).json({ error: '机柜不存在' });
+    }
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+module.exports = router;

backend/routes/rooms.js

@@ -0,0 +1,82 @@
+const express = require('express');
+const router = express.Router();
+const Room = require('../models/Room');
+const Rack = require('../models/Rack');
+
+// 获取所有机房
+router.get('/', async (req, res) => {
+  try {
+    const rooms = await Room.findAll({
+      include: Rack
+    });
+    res.json(rooms);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 获取单个机房
+router.get('/:roomId', async (req, res) => {
+  try {
+    const room = await Room.findByPk(req.params.roomId, {
+      include: Rack
+    });
+    if (!room) {
+      return res.status(404).json({ error: '机房不存在' });
+    }
+    res.json(room);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 创建机房
+router.post('/', async (req, res) => {
+  try {
+    const room = await Room.create(req.body);
+    res.status(201).json(room);
+  } catch (error) {
+    res.status(400).json({ error: error.message });
+  }
+});
+
+// 更新机房
+router.put('/:roomId', async (req, res) => {
+  try {
+    const [updated] = await Room.update(req.body, {
+      where: { roomId: req.params.roomId }
+    });
+    if (updated) {
+      const updatedRoom = await Room.findByPk(req.params.roomId);
+      res.json(updatedRoom);
+    } else {
+      res.status(404).json({ error: '机房不存在' });
+    }
+  } catch (error) {
+    res.status(400).json({ error: error.message });
+  }
+});
+
+// 删除机房
+router.delete('/:roomId', async (req, res) => {
+  try {
+    // 检查是否有机柜关联
+    const racks = await Rack.findAll({ where: { roomId: req.params.roomId } });
+    if (racks.length > 0) {
+      return res.status(400).json({ error: '该机房下有机柜，无法删除' });
+    }
+    
+    const deleted = await Room.destroy({
+      where: { roomId: req.params.roomId }
+    });
+    if (deleted) {
+      res.status(204).json();
+    } else {
+      res.status(404).json({ error: '机房不存在' });
+    }
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+module.exports = router;

backend/server.js

@@ -0,0 +1,52 @@
+const express = require('express');
+const cors = require('cors');
+const { sequelize } = require('./db');
+
+// 创建Express应用
+const app = express();
+const PORT = process.env.PORT || 3001;
+
+// 中间件
+app.use(cors());
+app.use(express.json());
+
+// 数据库连接已从db.js导入
+
+// 测试数据库连接并同步表结构
+sequelize.authenticate()
+  .then(() => {
+    console.log('数据库连接成功');
+    // 自动同步表结构，不再强制删除表
+    return sequelize.sync({
+      force: false, // 改为false，避免每次启动都删除表结构
+      alter: false  // SQLite不支持复杂的表结构修改
+    });
+  })
+  .then(() => {
+    console.log('数据库表结构同步完成');
+    // 同步完成后初始化设备字段
+    return require('./initDeviceFields')();
+  })
+  .catch(err => console.error('数据库操作失败:', err));
+
+// 导入路由
+const deviceRoutes = require('./routes/devices');
+const rackRoutes = require('./routes/racks');
+const roomRoutes = require('./routes/rooms');
+const deviceFieldRoutes = require('./routes/deviceFields');
+
+// 使用路由
+app.use('/api/devices', deviceRoutes);
+app.use('/api/racks', rackRoutes);
+app.use('/api/rooms', roomRoutes);
+app.use('/api/deviceFields', deviceFieldRoutes);
+
+// 健康检查
+app.get('/health', (req, res) => {
+  res.json({ status: 'ok', message: 'IDC设备管理系统后端服务正常运行' });
+});
+
+// 启动服务器
+app.listen(PORT, () => {
+  console.log(`服务器运行在 http://localhost:${PORT}`);
+});