feat: 新增网卡、端口和接线管理功能

- 添加网卡(NetworkCard)模型及相关路由
- 实现端口(DevicePort)管理功能
- 新增接线(Cable)管理功能
- 添加前端网卡和端口管理界面
- 更新机柜可视化页面显示接线
- 添加设备详情抽屉展示端口和接线信息
- 更新部署文档包含数据库迁移指南
- 添加批量创建端口功能
- 设备删除时自动清理相关接线
This commit is contained in:
zhang1106
2026-01-23 08:55:16 +08:00
parent e965be50c8
commit 8099edc5e5
21 changed files with 5080 additions and 15 deletions
+323
View File
@@ -0,0 +1,323 @@
const express = require('express');
const router = express.Router();
const { Op } = require('sequelize');
const Cable = require('../models/Cable');
const Device = require('../models/Device');
router.get('/', async (req, res) => {
try {
const { sourceDeviceId, targetDeviceId, status, cableType, page = 1, pageSize = 10 } = req.query;
const offset = (page - 1) * pageSize;
const where = {};
if (sourceDeviceId) {
where.sourceDeviceId = sourceDeviceId;
}
if (targetDeviceId) {
where.targetDeviceId = targetDeviceId;
}
if (status && status !== 'all') {
where.status = status;
}
if (cableType && cableType !== 'all') {
where.cableType = cableType;
}
const { count, rows } = await Cable.findAndCountAll({
where,
include: [
{
model: Device,
as: 'sourceDevice',
attributes: ['deviceId', 'name', 'type', 'rackId']
},
{
model: Device,
as: 'targetDevice',
attributes: ['deviceId', 'name', 'type', 'rackId']
}
],
offset,
limit: parseInt(pageSize),
order: [['createdAt', 'DESC']]
});
res.json({
total: count,
cables: rows,
page: parseInt(page),
pageSize: parseInt(pageSize)
});
} catch (error) {
console.error('获取接线列表失败:', error);
res.status(500).json({ error: error.message });
}
});
router.get('/device/:deviceId', async (req, res) => {
try {
const { deviceId } = req.params;
const cables = await Cable.findAll({
where: {
[Op.or]: [
{ sourceDeviceId: deviceId },
{ targetDeviceId: deviceId }
]
},
include: [
{
model: Device,
as: 'sourceDevice',
attributes: ['deviceId', 'name', 'type', 'rackId']
},
{
model: Device,
as: 'targetDevice',
attributes: ['deviceId', 'name', 'type', 'rackId']
}
]
});
res.json(cables);
} catch (error) {
console.error('获取设备接线失败:', error);
res.status(500).json({ error: error.message });
}
});
router.post('/', async (req, res) => {
try {
const { cableId, sourceDeviceId, sourcePort, targetDeviceId, targetPort, cableType, cableLength, status, description } = req.body;
if (!sourceDeviceId || !sourcePort || !targetDeviceId || !targetPort) {
return res.status(400).json({ error: '缺少必填字段' });
}
if (sourceDeviceId === targetDeviceId) {
return res.status(400).json({ error: '源设备和目标设备不能相同' });
}
const existingCable = await Cable.findOne({
where: {
[Op.or]: [
{ sourceDeviceId, sourcePort },
{ targetDeviceId, targetPort }
]
}
});
if (existingCable) {
return res.status(400).json({ error: '端口已被占用' });
}
const autoCableId = cableId || `CABLE-${Date.now()}-${Math.floor(Math.random() * 10000)}`;
const cable = await Cable.create({
cableId: autoCableId,
sourceDeviceId,
sourcePort,
targetDeviceId,
targetPort,
cableType: cableType || 'ethernet',
cableLength,
status: status || 'normal',
description
});
const createdCable = await Cable.findByPk(cable.cableId, {
include: [
{
model: Device,
as: 'sourceDevice',
attributes: ['deviceId', 'name', 'type', 'rackId']
},
{
model: Device,
as: 'targetDevice',
attributes: ['deviceId', 'name', 'type', 'rackId']
}
]
});
res.status(201).json(createdCable);
} catch (error) {
console.error('创建接线失败:', error);
res.status(500).json({ error: error.message });
}
});
router.post('/batch', async (req, res) => {
try {
const { cables } = req.body;
if (!cables || !Array.isArray(cables) || cables.length === 0) {
return res.status(400).json({ error: '请提供有效的接线数据' });
}
const results = {
total: cables.length,
success: 0,
failed: 0,
errors: []
};
for (let i = 0; i < cables.length; i++) {
const cableData = cables[i];
try {
if (!cableData.cableId || !cableData.sourceDeviceId || !cableData.sourcePort ||
!cableData.targetDeviceId || !cableData.targetPort) {
throw new Error('缺少必填字段');
}
if (cableData.sourceDeviceId === cableData.targetDeviceId) {
throw new Error('源设备和目标设备不能相同');
}
const existingCable = await Cable.findOne({
where: {
[Op.or]: [
{ sourceDeviceId: cableData.sourceDeviceId, sourcePort: cableData.sourcePort },
{ targetDeviceId: cableData.targetDeviceId, targetPort: cableData.targetPort }
]
}
});
if (existingCable) {
throw new Error('端口已被占用');
}
await Cable.create({
cableId: cableData.cableId,
sourceDeviceId: cableData.sourceDeviceId,
sourcePort: cableData.sourcePort,
targetDeviceId: cableData.targetDeviceId,
targetPort: cableData.targetPort,
cableType: cableData.cableType || 'ethernet',
cableLength: cableData.cableLength,
status: cableData.status || 'normal',
description: cableData.description
});
results.success++;
} catch (error) {
results.failed++;
results.errors.push({
index: i + 1,
cableId: cableData.cableId,
error: error.message
});
}
}
res.json(results);
} catch (error) {
console.error('批量创建接线失败:', error);
res.status(500).json({ error: error.message });
}
});
router.put('/:cableId', async (req, res) => {
try {
const [updated] = await Cable.update(req.body, {
where: { cableId: req.params.cableId }
});
if (updated) {
const cable = await Cable.findByPk(req.params.cableId, {
include: [
{
model: Device,
as: 'sourceDevice',
attributes: ['deviceId', 'name', 'type', 'rackId']
},
{
model: Device,
as: 'targetDevice',
attributes: ['deviceId', 'name', 'type', 'rackId']
}
]
});
res.json(cable);
} else {
res.status(404).json({ error: '接线不存在' });
}
} catch (error) {
console.error('更新接线失败:', error);
res.status(500).json({ error: error.message });
}
});
router.delete('/:cableId', async (req, res) => {
try {
const deleted = await Cable.destroy({
where: { cableId: req.params.cableId }
});
if (deleted) {
res.status(204).json();
} else {
res.status(404).json({ error: '接线不存在' });
}
} catch (error) {
console.error('删除接线失败:', error);
res.status(500).json({ error: error.message });
}
});
router.delete('/batch', async (req, res) => {
try {
const { cableIds } = req.body;
if (!cableIds || !Array.isArray(cableIds) || cableIds.length === 0) {
return res.status(400).json({ error: '请提供有效的接线ID列表' });
}
const deletedCount = await Cable.destroy({
where: { cableId: { [Op.in]: cableIds } }
});
res.json({
message: `批量删除成功,已删除 ${deletedCount} 条接线`,
deletedCount
});
} catch (error) {
console.error('批量删除接线失败:', error);
res.status(500).json({ error: error.message });
}
});
router.get('/:cableId', async (req, res) => {
try {
const cable = await Cable.findByPk(req.params.cableId, {
include: [
{
model: Device,
as: 'sourceDevice',
attributes: ['deviceId', 'name', 'type', 'rackId']
},
{
model: Device,
as: 'targetDevice',
attributes: ['deviceId', 'name', 'type', 'rackId']
}
]
});
if (!cable) {
return res.status(404).json({ error: '接线不存在' });
}
res.json(cable);
} catch (error) {
console.error('获取接线详情失败:', error);
res.status(500).json({ error: error.message });
}
});
module.exports = router;
+273
View File
@@ -0,0 +1,273 @@
const express = require('express');
const router = express.Router();
const { Op } = require('sequelize');
const DevicePort = require('../models/DevicePort');
const Device = require('../models/Device');
router.get('/', async (req, res) => {
try {
const { deviceId, status, portType, portSpeed, page = 1, pageSize = 10 } = req.query;
const offset = (page - 1) * pageSize;
const where = {};
if (deviceId) {
where.deviceId = deviceId;
}
if (status && status !== 'all') {
where.status = status;
}
if (portType && portType !== 'all') {
where.portType = portType;
}
if (portSpeed && portSpeed !== 'all') {
where.portSpeed = portSpeed;
}
const { count, rows } = await DevicePort.findAndCountAll({
where,
include: [
{
model: Device,
as: 'device',
attributes: ['deviceId', 'name', 'type', 'rackId']
}
],
offset,
limit: parseInt(pageSize),
order: [['createdAt', 'DESC']]
});
res.json({
total: count,
ports: rows,
page: parseInt(page),
pageSize: parseInt(pageSize)
});
} catch (error) {
console.error('获取端口列表失败:', error);
res.status(500).json({ error: error.message });
}
});
router.get('/device/:deviceId', async (req, res) => {
try {
const { deviceId } = req.params;
const ports = await DevicePort.findAll({
where: { deviceId },
include: [
{
model: Device,
as: 'device',
attributes: ['deviceId', 'name', 'type', 'rackId']
}
],
order: [['portName', 'ASC']]
});
res.json(ports);
} catch (error) {
console.error('获取设备端口失败:', error);
res.status(500).json({ error: error.message });
}
});
router.post('/', async (req, res) => {
try {
const { portId, deviceId, portName, portType, portSpeed, status, vlanId, description } = req.body;
if (!deviceId || !portName) {
return res.status(400).json({ error: '缺少必填字段' });
}
const existingPort = await DevicePort.findOne({
where: { deviceId, portName }
});
if (existingPort) {
return res.status(400).json({ error: '该设备的端口名称已存在' });
}
const autoPortId = portId || `PORT-${Date.now()}-${Math.floor(Math.random() * 10000)}`;
const port = await DevicePort.create({
portId: autoPortId,
deviceId,
portName,
portType: portType || 'RJ45',
portSpeed: portSpeed || '1G',
status: status || 'free',
vlanId,
description
});
const createdPort = await DevicePort.findByPk(port.portId, {
include: [
{
model: Device,
as: 'device',
attributes: ['deviceId', 'name', 'type', 'rackId']
}
]
});
res.status(201).json(createdPort);
} catch (error) {
console.error('创建端口失败:', error);
res.status(500).json({ error: error.message });
}
});
router.post('/batch', async (req, res) => {
try {
const { ports } = req.body;
if (!ports || !Array.isArray(ports) || ports.length === 0) {
return res.status(400).json({ error: '请提供有效的端口数据' });
}
const results = {
total: ports.length,
success: 0,
failed: 0,
errors: []
};
for (let i = 0; i < ports.length; i++) {
const portData = ports[i];
try {
if (!portData.portId || !portData.deviceId || !portData.portName) {
throw new Error('缺少必填字段');
}
const existingPort = await DevicePort.findOne({
where: { deviceId: portData.deviceId, portName: portData.portName }
});
if (existingPort) {
throw new Error('该设备的端口名称已存在');
}
await DevicePort.create({
portId: portData.portId,
deviceId: portData.deviceId,
portName: portData.portName,
portType: portData.portType || 'RJ45',
portSpeed: portData.portSpeed || '1G',
status: portData.status || 'free',
vlanId: portData.vlanId,
description: portData.description
});
results.success++;
} catch (error) {
results.failed++;
results.errors.push({
index: i + 1,
portId: portData.portId,
error: error.message
});
}
}
res.json(results);
} catch (error) {
console.error('批量创建端口失败:', error);
res.status(500).json({ error: error.message });
}
});
router.put('/:portId', async (req, res) => {
try {
const [updated] = await DevicePort.update(req.body, {
where: { portId: req.params.portId }
});
if (updated) {
const port = await DevicePort.findByPk(req.params.portId, {
include: [
{
model: Device,
as: 'device',
attributes: ['deviceId', 'name', 'type', 'rackId']
}
]
});
res.json(port);
} else {
res.status(404).json({ error: '端口不存在' });
}
} catch (error) {
console.error('更新端口失败:', error);
res.status(500).json({ error: error.message });
}
});
router.delete('/:portId', async (req, res) => {
try {
const deleted = await DevicePort.destroy({
where: { portId: req.params.portId }
});
if (deleted) {
res.status(204).json();
} else {
res.status(404).json({ error: '端口不存在' });
}
} catch (error) {
console.error('删除端口失败:', error);
res.status(500).json({ error: error.message });
}
});
router.delete('/batch', async (req, res) => {
try {
const { portIds } = req.body;
if (!portIds || !Array.isArray(portIds) || portIds.length === 0) {
return res.status(400).json({ error: '请提供有效的端口ID列表' });
}
const deletedCount = await DevicePort.destroy({
where: { portId: { [Op.in]: portIds } }
});
res.json({
message: `批量删除成功,已删除 ${deletedCount} 个端口`,
deletedCount
});
} catch (error) {
console.error('批量删除端口失败:', error);
res.status(500).json({ error: error.message });
}
});
router.get('/:portId', async (req, res) => {
try {
const port = await DevicePort.findByPk(req.params.portId, {
include: [
{
model: Device,
as: 'device',
attributes: ['deviceId', 'name', 'type', 'rackId']
}
]
});
if (!port) {
return res.status(404).json({ error: '端口不存在' });
}
res.json(port);
} catch (error) {
console.error('获取端口详情失败:', error);
res.status(500).json({ error: error.message });
}
});
module.exports = router;
+27 -7
View File
@@ -893,15 +893,35 @@ router.delete('/:deviceId', async (req, res) => {
});
if (deleted) {
// 更新机柜当前功率
const rack = await Rack.findByPk(device.rackId);
if (rack) {
await rack.update({
currentPower: Math.max(0, rack.currentPower - device.powerConsumption)
});
const Cable = require('../models/Cable');
const deletedCables = await Cable.destroy({
where: {
[Op.or]: [
{ sourceDeviceId: req.params.deviceId },
{ targetDeviceId: req.params.deviceId }
]
}
});
if (deletedCables > 0) {
console.log(`已删除 ${deletedCables} 条相关接线`);
}
res.status(204).json();
if (device.rackId) {
const rack = await Rack.findByPk(device.rackId);
if (rack) {
await rack.update({
currentPower: Math.max(0, rack.currentPower - device.powerConsumption)
});
}
}
res.status(200).json({
message: '删除成功',
deviceId: req.params.deviceId,
deletedCablesCount: deletedCables
});
} else {
res.status(404).json({ error: '设备不存在' });
}
+259
View File
@@ -0,0 +1,259 @@
const express = require('express');
const router = express.Router();
const { Op } = require('sequelize');
const NetworkCard = require('../models/NetworkCard');
const Device = require('../models/Device');
const DevicePort = require('../models/DevicePort');
router.get('/', async (req, res) => {
try {
const { deviceId } = req.query;
const where = {};
if (deviceId) {
where.deviceId = deviceId;
}
const networkCards = await NetworkCard.findAll({
where,
include: [
{
model: Device,
as: 'device',
attributes: ['deviceId', 'name', 'type']
}
],
order: [['slotNumber', 'ASC'], ['name', 'ASC']]
});
res.json(networkCards);
} catch (error) {
console.error('获取网卡列表失败:', error);
res.status(500).json({ error: error.message });
}
});
router.get('/device/:deviceId', async (req, res) => {
try {
const { deviceId } = req.params;
const networkCards = await NetworkCard.findAll({
where: { deviceId },
include: [
{
model: Device,
as: 'device',
attributes: ['deviceId', 'name', 'type']
}
],
order: [['slotNumber', 'ASC'], ['name', 'ASC']]
});
res.json(networkCards);
} catch (error) {
console.error('获取设备网卡失败:', error);
res.status(500).json({ error: error.message });
}
});
router.get('/:nicId', async (req, res) => {
try {
const networkCard = await NetworkCard.findByPk(req.params.nicId, {
include: [
{
model: Device,
as: 'device',
attributes: ['deviceId', 'name', 'type']
}
]
});
if (!networkCard) {
return res.status(404).json({ error: '网卡不存在' });
}
res.json(networkCard);
} catch (error) {
console.error('获取网卡详情失败:', error);
res.status(500).json({ error: error.message });
}
});
router.get('/:nicId/ports', async (req, res) => {
try {
const { nicId } = req.params;
const ports = await DevicePort.findAll({
where: { nicId },
order: [['portName', 'ASC']]
});
res.json(ports);
} catch (error) {
console.error('获取网卡端口失败:', error);
res.status(500).json({ error: error.message });
}
});
router.post('/', async (req, res) => {
try {
const { nicId, deviceId, name, description, slotNumber, model, manufacturer, status } = req.body;
if (!deviceId || !name) {
return res.status(400).json({ error: '缺少必填字段' });
}
const existingCard = await NetworkCard.findOne({
where: { deviceId, name }
});
if (existingCard) {
return res.status(400).json({ error: '该设备已存在同名网卡' });
}
const autoNicId = nicId || `NIC-${Date.now()}-${Math.floor(Math.random() * 10000)}`;
const networkCard = await NetworkCard.create({
nicId: autoNicId,
deviceId,
name,
description,
slotNumber,
model,
manufacturer,
status: status || 'normal',
portCount: 0
});
const createdCard = await NetworkCard.findByPk(networkCard.nicId, {
include: [
{
model: Device,
as: 'device',
attributes: ['deviceId', 'name', 'type']
}
]
});
res.status(201).json(createdCard);
} catch (error) {
console.error('创建网卡失败:', error);
res.status(500).json({ error: error.message });
}
});
router.put('/:nicId', async (req, res) => {
try {
const [updated] = await NetworkCard.update(req.body, {
where: { nicId: req.params.nicId }
});
if (updated) {
const networkCard = await NetworkCard.findByPk(req.params.nicId, {
include: [
{
model: Device,
as: 'device',
attributes: ['deviceId', 'name', 'type']
}
]
});
res.json(networkCard);
} else {
res.status(404).json({ error: '网卡不存在' });
}
} catch (error) {
console.error('更新网卡失败:', error);
res.status(500).json({ error: error.message });
}
});
router.delete('/:nicId', async (req, res) => {
try {
const { nicId } = req.params;
const portCount = await DevicePort.count({ where: { nicId } });
if (portCount > 0) {
return res.status(400).json({
error: `该网卡下还有 ${portCount} 个端口,请先删除或转移端口后再删除网卡`
});
}
const deleted = await NetworkCard.destroy({
where: { nicId }
});
if (deleted) {
res.status(204).json();
} else {
res.status(404).json({ error: '网卡不存在' });
}
} catch (error) {
console.error('删除网卡失败:', error);
res.status(500).json({ error: error.message });
}
});
router.get('/device/:deviceId/with-ports', async (req, res) => {
try {
const { deviceId } = req.params;
const networkCards = await NetworkCard.findAll({
where: { deviceId },
order: [['slotNumber', 'ASC'], ['name', 'ASC']]
});
const cardsWithPorts = await Promise.all(
networkCards.map(async (card) => {
const ports = await DevicePort.findAll({
where: { nicId: card.nicId },
order: [['portName', 'ASC']]
});
const freeCount = ports.filter(p => p.status === 'free').length;
const occupiedCount = ports.filter(p => p.status === 'occupied').length;
const faultCount = ports.filter(p => p.status === 'fault').length;
return {
...card.toJSON(),
ports,
stats: {
total: ports.length,
free: freeCount,
occupied: occupiedCount,
fault: faultCount
}
};
})
);
const ungroupedPorts = await DevicePort.findAll({
where: { deviceId, nicId: null },
order: [['portName', 'ASC']]
});
if (ungroupedPorts.length > 0) {
cardsWithPorts.push({
nicId: '_ungrouped',
name: '未分组端口',
description: '未分配到网卡的端口',
portCount: ungroupedPorts.length,
isUngrouped: true,
ports: ungroupedPorts,
stats: {
total: ungroupedPorts.length,
free: ungroupedPorts.filter(p => p.status === 'free').length,
occupied: ungroupedPorts.filter(p => p.status === 'occupied').length,
fault: ungroupedPorts.filter(p => p.status === 'fault').length
}
});
}
res.json(cardsWithPorts);
} catch (error) {
console.error('获取网卡及端口失败:', error);
res.status(500).json({ error: error.message });
}
});
module.exports = router;