878 lines
24 KiB
JavaScript
878 lines
24 KiB
JavaScript
const logger = require('../utils/logger').module('IdleDevicesRoute');
|
|
const express = require('express');
|
|
const router = express.Router();
|
|
const { Op } = require('sequelize');
|
|
const Device = require('../models/Device');
|
|
const Rack = require('../models/Rack');
|
|
const Room = require('../models/Room');
|
|
const {
|
|
logDeviceOperation,
|
|
generateDeviceDescription,
|
|
buildDeviceMetadata,
|
|
} = require('../utils/operationLogger');
|
|
|
|
async function generateIdleDeviceId() {
|
|
const devices = await Device.findAll({
|
|
where: {
|
|
deviceId: {
|
|
[Op.like]: 'DEV%',
|
|
},
|
|
},
|
|
});
|
|
|
|
let maxNumber = 0;
|
|
devices.forEach(device => {
|
|
const match = device.deviceId.match(/^DEV(\d+)$/);
|
|
if (match) {
|
|
const num = parseInt(match[1], 10);
|
|
if (num > maxNumber) {
|
|
maxNumber = num;
|
|
}
|
|
}
|
|
});
|
|
|
|
const newNumber = maxNumber + 1;
|
|
return `DEV${String(newNumber).padStart(4, '0')}`;
|
|
}
|
|
|
|
router.get('/', async (req, res) => {
|
|
try {
|
|
const { keyword, sourceType, idleReason, page = 1, pageSize = 10 } = req.query;
|
|
const offset = (page - 1) * pageSize;
|
|
|
|
const where = { isIdle: true };
|
|
|
|
if (keyword) {
|
|
where[Op.or] = [
|
|
{ deviceId: { [Op.like]: `%${keyword}%` } },
|
|
{ name: { [Op.like]: `%${keyword}%` } },
|
|
{ serialNumber: { [Op.like]: `%${keyword}%` } },
|
|
];
|
|
}
|
|
|
|
if (sourceType && sourceType !== 'all') {
|
|
where.sourceType = sourceType;
|
|
}
|
|
|
|
if (idleReason) {
|
|
where.idleReason = { [Op.like]: `%${idleReason}%` };
|
|
}
|
|
|
|
const { count, rows } = await Device.findAndCountAll({
|
|
where,
|
|
include: [
|
|
{
|
|
model: Rack,
|
|
attributes: ['rackId', 'name', 'roomId'],
|
|
include: [
|
|
{
|
|
model: Room,
|
|
attributes: ['roomId', 'name'],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
offset: parseInt(offset),
|
|
limit: parseInt(pageSize),
|
|
order: [['idleDate', 'DESC']],
|
|
});
|
|
|
|
res.json({
|
|
total: count,
|
|
idleDevices: rows,
|
|
page: parseInt(page),
|
|
pageSize: parseInt(pageSize),
|
|
});
|
|
} catch (error) {
|
|
logger.error('获取空闲设备列表失败', { error: error.message, stack: error.stack });
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
router.get('/:deviceId', async (req, res) => {
|
|
try {
|
|
const device = await Device.findOne({
|
|
where: { deviceId: req.params.deviceId, isIdle: true },
|
|
include: [
|
|
{
|
|
model: Rack,
|
|
attributes: ['rackId', 'name', 'roomId'],
|
|
include: [
|
|
{
|
|
model: Room,
|
|
attributes: ['roomId', 'name'],
|
|
},
|
|
],
|
|
},
|
|
],
|
|
});
|
|
|
|
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 {
|
|
name,
|
|
type,
|
|
model,
|
|
serialNumber,
|
|
powerConsumption,
|
|
idleReason,
|
|
warehouseId,
|
|
description,
|
|
rackId,
|
|
position,
|
|
} = req.body;
|
|
|
|
let { deviceId } = req.body;
|
|
|
|
if (!deviceId || deviceId.trim() === '') {
|
|
deviceId = await generateIdleDeviceId();
|
|
}
|
|
|
|
const existingDevice = await Device.findByPk(deviceId);
|
|
if (existingDevice) {
|
|
return res.status(400).json({ error: '设备ID已存在' });
|
|
}
|
|
|
|
if (rackId) {
|
|
const rack = await Rack.findByPk(rackId);
|
|
if (!rack) {
|
|
return res.status(404).json({ error: '机柜不存在' });
|
|
}
|
|
}
|
|
|
|
const device = await Device.create({
|
|
deviceId,
|
|
name: name || '',
|
|
type: type || 'other',
|
|
model: model || '',
|
|
serialNumber: serialNumber || '',
|
|
powerConsumption: powerConsumption || 0,
|
|
status: 'offline',
|
|
isIdle: true,
|
|
idleDate: new Date(),
|
|
idleReason: idleReason || '',
|
|
warehouseId: warehouseId || null,
|
|
rackId: rackId || null,
|
|
position: position || null,
|
|
sourceType: warehouseId ? 'warehouse' : rackId ? 'rack' : 'rack',
|
|
description: description || '',
|
|
});
|
|
|
|
await logDeviceOperation(
|
|
'create',
|
|
generateDeviceDescription(
|
|
'新增空闲设备',
|
|
{
|
|
deviceId: device.deviceId,
|
|
name: device.name || deviceId,
|
|
type: device.type,
|
|
model: device.model,
|
|
serialNumber: device.serialNumber,
|
|
ipAddress: device.ipAddress,
|
|
},
|
|
{ includeRack: false }
|
|
),
|
|
{
|
|
targetId: device.deviceId,
|
|
targetName: device.name || deviceId,
|
|
afterState: device.toJSON(),
|
|
req,
|
|
metadata: buildDeviceMetadata(device.toJSON(), {
|
|
sourceType: device.sourceType,
|
|
type: 'idle_device_create',
|
|
}),
|
|
}
|
|
);
|
|
|
|
res.status(201).json(device);
|
|
} catch (error) {
|
|
res.status(400).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
router.post('/from-device/:deviceId', async (req, res) => {
|
|
const t = await require('../db').sequelize.transaction();
|
|
try {
|
|
const { idleReason } = req.body;
|
|
const { deviceId } = req.params;
|
|
|
|
const device = await Device.findByPk(deviceId, { transaction: t });
|
|
if (!device) {
|
|
await t.rollback();
|
|
return res.status(404).json({ error: '设备不存在' });
|
|
}
|
|
|
|
if (device.isIdle) {
|
|
await t.rollback();
|
|
return res.status(400).json({ error: '设备已经标记为空闲设备' });
|
|
}
|
|
|
|
await device.update(
|
|
{
|
|
isIdle: true,
|
|
status: 'idle',
|
|
idleDate: new Date(),
|
|
idleReason: idleReason || `从设备管理转入`,
|
|
sourceType: 'rack',
|
|
},
|
|
{ transaction: t }
|
|
);
|
|
|
|
await t.commit();
|
|
|
|
const deviceData = device.toJSON();
|
|
await logDeviceOperation('to_idle', generateDeviceDescription('设备转入空闲设备', deviceData), {
|
|
targetId: device.deviceId,
|
|
targetName: device.name,
|
|
beforeState: { ...deviceData, isIdle: false },
|
|
afterState: { ...deviceData, isIdle: true },
|
|
req,
|
|
metadata: buildDeviceMetadata(deviceData, { idleReason, type: 'device_to_idle' }),
|
|
});
|
|
|
|
res.json({
|
|
message: '设备已转入空闲设备',
|
|
device: device.toJSON(),
|
|
});
|
|
} catch (error) {
|
|
await t.rollback();
|
|
logger.error('设备转入空闲设备失败', { error: error.message, stack: error.stack });
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
router.post('/batch-from-devices', async (req, res) => {
|
|
const t = await require('../db').sequelize.transaction();
|
|
try {
|
|
const { deviceIds, idleReason } = req.body;
|
|
|
|
if (!deviceIds || !Array.isArray(deviceIds) || deviceIds.length === 0) {
|
|
await t.rollback();
|
|
return res.status(400).json({ error: '请提供有效的设备ID列表' });
|
|
}
|
|
|
|
const devices = await Device.findAll({
|
|
where: { deviceId: { [Op.in]: deviceIds } },
|
|
transaction: t,
|
|
});
|
|
|
|
const notIdleDevices = devices.filter(d => !d.isIdle);
|
|
const alreadyIdleDevices = devices.filter(d => d.isIdle);
|
|
|
|
if (notIdleDevices.length > 0) {
|
|
await Device.update(
|
|
{
|
|
isIdle: true,
|
|
status: 'idle',
|
|
idleDate: new Date(),
|
|
idleReason: idleReason || `批量转入`,
|
|
},
|
|
{
|
|
where: { deviceId: { [Op.in]: notIdleDevices.map(d => d.deviceId) } },
|
|
transaction: t,
|
|
}
|
|
);
|
|
}
|
|
|
|
await t.commit();
|
|
|
|
const deviceDetails = notIdleDevices.map(d => d.toJSON());
|
|
const deviceSummary = deviceDetails
|
|
.map(
|
|
d =>
|
|
`${d.name}(编号:${d.deviceId}${d.type ? `,类型:${d.type}` : ''}${d.serialNumber ? `,序列号:${d.serialNumber}` : ''})`
|
|
)
|
|
.join('、');
|
|
|
|
await logDeviceOperation(
|
|
'batch_to_idle',
|
|
`批量将 ${notIdleDevices.length} 台设备转入空闲设备：${deviceSummary}`,
|
|
{
|
|
targetId: deviceIds.join(','),
|
|
targetName: `${notIdleDevices.length}台设备`,
|
|
req,
|
|
metadata: { idleReason, type: 'batch_device_to_idle', devices: deviceDetails },
|
|
}
|
|
);
|
|
|
|
res.json({
|
|
message: `成功将 ${notIdleDevices.length} 台设备转入空闲设备`,
|
|
total: devices.length,
|
|
updated: notIdleDevices.length,
|
|
skipped: alreadyIdleDevices.length,
|
|
});
|
|
} catch (error) {
|
|
await t.rollback();
|
|
logger.error('批量转入空闲设备失败', { error: error.message, stack: error.stack });
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
router.put('/batch-restore', async (req, res) => {
|
|
const t = await require('../db').sequelize.transaction();
|
|
try {
|
|
const { devices } = req.body;
|
|
|
|
logger.info('========== batch-restore 开始 ==========');
|
|
logger.info('原始请求 body', { data: JSON.stringify(req.body) });
|
|
logger.info('devices 参数', { data: devices });
|
|
|
|
if (!devices || !Array.isArray(devices) || devices.length === 0) {
|
|
await t.rollback();
|
|
logger.info('错误: devices 参数无效');
|
|
return res.status(400).json({ error: '请提供有效的设备列表' });
|
|
}
|
|
|
|
const deviceIds = devices.map(d => d.deviceId).filter(Boolean);
|
|
logger.info('提取的 deviceIds', { data: deviceIds });
|
|
|
|
if (deviceIds.length === 0) {
|
|
await t.rollback();
|
|
logger.info('错误: deviceIds 为空');
|
|
return res.status(400).json({ error: '设备ID不能为空' });
|
|
}
|
|
|
|
logger.info('开始查询设备，条件', { data: { deviceId: { [Op.in]: deviceIds }, isIdle: true } });
|
|
|
|
const idleDevices = await Device.findAll({
|
|
where: { deviceId: { [Op.in]: deviceIds }, isIdle: true },
|
|
transaction: t,
|
|
});
|
|
|
|
logger.info('查询到的空闲设备数量', { data: idleDevices.length });
|
|
if (idleDevices.length > 0) {
|
|
logger.info('查询到的设备ID', { data: idleDevices.map(d => d.deviceId) });
|
|
}
|
|
|
|
if (idleDevices.length === 0) {
|
|
logger.info('没有找到空闲设备，检查设备是否存在:');
|
|
const allDevices = await Device.findAll({
|
|
where: { deviceId: { [Op.in]: deviceIds } },
|
|
transaction: t,
|
|
});
|
|
logger.info('设备表中存在的设备数量', { data: allDevices.length });
|
|
if (allDevices.length > 0) {
|
|
logger.info('存在的设备及其 isIdle 状态', { data: allDevices.map(d => ({ deviceId: d.deviceId, isIdle: d.isIdle })) });
|
|
}
|
|
|
|
await t.rollback();
|
|
return res.status(404).json({ error: '没有找到空闲设备' });
|
|
}
|
|
|
|
let restoredCount = 0;
|
|
const results = [];
|
|
|
|
for (const device of idleDevices) {
|
|
const deviceConfig = devices.find(d => d.deviceId === device.deviceId);
|
|
if (!deviceConfig) {
|
|
continue;
|
|
}
|
|
|
|
const targetRackId = deviceConfig.targetRackId;
|
|
const targetPosition = deviceConfig.targetPosition;
|
|
|
|
if (!targetRackId) {
|
|
results.push({
|
|
deviceId: device.deviceId,
|
|
name: device.name,
|
|
status: 'skipped',
|
|
reason: '未指定目标机柜',
|
|
});
|
|
continue;
|
|
}
|
|
|
|
const targetRack = await Rack.findByPk(targetRackId, { transaction: t });
|
|
if (!targetRack) {
|
|
results.push({
|
|
deviceId: device.deviceId,
|
|
name: device.name,
|
|
status: 'failed',
|
|
reason: '目标机柜不存在',
|
|
});
|
|
continue;
|
|
}
|
|
|
|
const height = device.height || 1;
|
|
const position = targetPosition || 1;
|
|
|
|
const checkResult = await checkPositionAvailable(targetRackId, position, height, null, t);
|
|
if (!checkResult.available) {
|
|
results.push({
|
|
deviceId: device.deviceId,
|
|
name: device.name,
|
|
status: 'failed',
|
|
reason: `U位${position}已被占用`,
|
|
});
|
|
continue;
|
|
}
|
|
|
|
await device.update(
|
|
{
|
|
isIdle: false,
|
|
idleDate: null,
|
|
idleReason: null,
|
|
rackId: targetRackId,
|
|
position: position,
|
|
warehouseId: null,
|
|
sourceType: 'rack',
|
|
status: 'offline',
|
|
},
|
|
{ transaction: t }
|
|
);
|
|
|
|
await targetRack.update(
|
|
{
|
|
currentPower: targetRack.currentPower + (device.powerConsumption || 0),
|
|
},
|
|
{ transaction: t }
|
|
);
|
|
|
|
restoredCount++;
|
|
results.push({
|
|
deviceId: device.deviceId,
|
|
name: device.name,
|
|
status: 'success',
|
|
targetRack: targetRack.name,
|
|
targetPosition: position,
|
|
});
|
|
}
|
|
|
|
await t.commit();
|
|
|
|
const successCount = results.filter(r => r.status === 'success').length;
|
|
const failedCount = results.filter(r => r.status === 'failed').length;
|
|
const skippedCount = results.filter(r => r.status === 'skipped').length;
|
|
|
|
const successDevices = idleDevices.filter(d =>
|
|
results.some(r => r.deviceId === d.deviceId && r.status === 'success')
|
|
);
|
|
const deviceSummary = successDevices
|
|
.map(
|
|
d =>
|
|
`${d.name}(编号:${d.deviceId}${d.type ? `,类型:${d.type}` : ''}${d.ipAddress ? `,IP:${d.ipAddress}` : ''})`
|
|
)
|
|
.join('、');
|
|
|
|
await logDeviceOperation(
|
|
'batch_restore',
|
|
`批量上架 ${successCount} 台空闲设备：${deviceSummary}`,
|
|
{
|
|
targetId: deviceIds.join(','),
|
|
targetName: `${successCount}台设备`,
|
|
req,
|
|
metadata: {
|
|
results,
|
|
type: 'batch_idle_device_restore',
|
|
devices: successDevices.map(d => d.toJSON()),
|
|
},
|
|
}
|
|
);
|
|
|
|
res.json({
|
|
message: `成功上架 ${successCount} 台设备`,
|
|
total: idleDevices.length,
|
|
restored: successCount,
|
|
failed: failedCount,
|
|
skipped: skippedCount,
|
|
details: results,
|
|
});
|
|
} catch (error) {
|
|
await t.rollback();
|
|
logger.error('批量上架设备失败', { error: error.message, stack: error.stack });
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
router.put('/:deviceId/shelve', async (req, res) => {
|
|
const t = await require('../db').sequelize.transaction();
|
|
try {
|
|
const { deviceId } = req.params;
|
|
const {
|
|
name,
|
|
type,
|
|
model,
|
|
serialNumber,
|
|
height,
|
|
powerConsumption,
|
|
rackId,
|
|
position,
|
|
description,
|
|
} = req.body;
|
|
|
|
const device = await Device.findOne({
|
|
where: { deviceId, isIdle: true },
|
|
transaction: t,
|
|
});
|
|
|
|
if (!device) {
|
|
await t.rollback();
|
|
return res.status(404).json({ error: '空闲设备不存在' });
|
|
}
|
|
|
|
if (!rackId) {
|
|
await t.rollback();
|
|
return res.status(400).json({ error: '请选择目标机柜' });
|
|
}
|
|
|
|
const targetRack = await Rack.findByPk(rackId, { transaction: t });
|
|
if (!targetRack) {
|
|
await t.rollback();
|
|
return res.status(404).json({ error: '目标机柜不存在' });
|
|
}
|
|
|
|
const deviceHeight = height || device.height || 1;
|
|
logger.info('上架设备 - 位置检查参数', { data: { rackId, position, deviceHeight, deviceId, existingDeviceId: device.deviceId } });
|
|
const positionCheck = await checkPositionAvailable(rackId, position, deviceHeight, deviceId, t);
|
|
logger.info('上架设备 - 位置检查结果', { data: positionCheck });
|
|
if (!positionCheck.available) {
|
|
await t.rollback();
|
|
return res.status(400).json({ error: positionCheck.reason });
|
|
}
|
|
|
|
const beforeState = device.toJSON();
|
|
|
|
await device.update(
|
|
{
|
|
name: name || device.name,
|
|
type: type || device.type,
|
|
model: model || device.model,
|
|
serialNumber: serialNumber || device.serialNumber,
|
|
height: deviceHeight,
|
|
powerConsumption: powerConsumption || device.powerConsumption || 0,
|
|
rackId: rackId,
|
|
position: position,
|
|
description: description || device.description,
|
|
isIdle: false,
|
|
idleDate: null,
|
|
idleReason: null,
|
|
warehouseId: null,
|
|
sourceType: 'rack',
|
|
status: 'running',
|
|
},
|
|
{ transaction: t }
|
|
);
|
|
|
|
await targetRack.update(
|
|
{
|
|
currentPower: targetRack.currentPower + (powerConsumption || device.powerConsumption || 0),
|
|
},
|
|
{ transaction: t }
|
|
);
|
|
|
|
await t.commit();
|
|
|
|
const updatedDevice = await Device.findByPk(deviceId, {
|
|
include: [{ model: Rack, include: [Room] }],
|
|
});
|
|
|
|
const deviceData = {
|
|
...updatedDevice.toJSON(),
|
|
rackName: targetRack.name,
|
|
roomName: updatedDevice.Rack?.Room?.name,
|
|
};
|
|
|
|
await logDeviceOperation(
|
|
'shelve',
|
|
generateDeviceDescription('空闲设备上架', deviceData, { includePosition: false }) +
|
|
`到机柜【${targetRack.name}】U${position}`,
|
|
{
|
|
targetId: device.deviceId,
|
|
targetName: device.name,
|
|
beforeState: { ...beforeState, isIdle: true },
|
|
afterState: deviceData,
|
|
req,
|
|
metadata: buildDeviceMetadata(deviceData, { rackId, position, type: 'idle_device_shelve' }),
|
|
}
|
|
);
|
|
|
|
res.json({
|
|
message: '设备上架成功',
|
|
device: updatedDevice,
|
|
});
|
|
} catch (error) {
|
|
await t.rollback();
|
|
logger.error('设备上架失败', { error: error.message, stack: error.stack });
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
router.put('/:deviceId', async (req, res) => {
|
|
try {
|
|
const device = await Device.findOne({
|
|
where: { deviceId: req.params.deviceId, isIdle: true },
|
|
});
|
|
|
|
if (!device) {
|
|
return res.status(404).json({ error: '空闲设备不存在' });
|
|
}
|
|
|
|
const beforeState = device.toJSON();
|
|
const allowedFields = [
|
|
'name',
|
|
'type',
|
|
'model',
|
|
'idleReason',
|
|
'description',
|
|
'powerConsumption',
|
|
];
|
|
|
|
allowedFields.forEach(field => {
|
|
if (req.body[field] !== undefined) {
|
|
device[field] = req.body[field];
|
|
}
|
|
});
|
|
|
|
if (req.body.warehouseId !== undefined) {
|
|
device.warehouseId = req.body.warehouseId || null;
|
|
device.sourceType = req.body.warehouseId ? 'warehouse' : 'rack';
|
|
}
|
|
|
|
if (req.body.rackId !== undefined) {
|
|
if (req.body.rackId) {
|
|
const rack = await Rack.findByPk(req.body.rackId);
|
|
if (!rack) {
|
|
return res.status(404).json({ error: '机柜不存在' });
|
|
}
|
|
}
|
|
device.rackId = req.body.rackId || null;
|
|
if (!req.body.warehouseId) {
|
|
device.sourceType = 'rack';
|
|
}
|
|
}
|
|
|
|
if (req.body.position !== undefined) {
|
|
device.position = req.body.position || null;
|
|
}
|
|
|
|
await device.save();
|
|
|
|
await logDeviceOperation(
|
|
'update',
|
|
generateDeviceDescription('更新空闲设备', device.toJSON(), { includeRack: false }),
|
|
{
|
|
targetId: device.deviceId,
|
|
targetName: device.name,
|
|
beforeState,
|
|
afterState: device.toJSON(),
|
|
req,
|
|
metadata: buildDeviceMetadata(device.toJSON(), { type: 'idle_device_update' }),
|
|
}
|
|
);
|
|
|
|
res.json(device);
|
|
} catch (error) {
|
|
res.status(400).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
router.put('/:deviceId/restore', async (req, res) => {
|
|
const t = await require('../db').sequelize.transaction();
|
|
try {
|
|
const { targetRackId, targetPosition } = req.body;
|
|
const { deviceId } = req.params;
|
|
|
|
const device = await Device.findOne({
|
|
where: { deviceId, isIdle: true },
|
|
transaction: t,
|
|
});
|
|
|
|
if (!device) {
|
|
await t.rollback();
|
|
return res.status(404).json({ error: '空闲设备不存在' });
|
|
}
|
|
|
|
if (!targetRackId || !targetPosition) {
|
|
await t.rollback();
|
|
return res.status(400).json({ error: '恢复设备需要指定目标机柜和位置' });
|
|
}
|
|
|
|
const targetRack = await Rack.findByPk(targetRackId, { transaction: t });
|
|
if (!targetRack) {
|
|
await t.rollback();
|
|
return res.status(404).json({ error: '目标机柜不存在' });
|
|
}
|
|
|
|
const positionCheck = await checkPositionAvailable(
|
|
targetRackId,
|
|
targetPosition,
|
|
device.height || 1,
|
|
deviceId,
|
|
t
|
|
);
|
|
if (!positionCheck.available) {
|
|
await t.rollback();
|
|
return res.status(400).json({ error: positionCheck.reason });
|
|
}
|
|
|
|
await device.update(
|
|
{
|
|
isIdle: false,
|
|
idleDate: null,
|
|
idleReason: null,
|
|
rackId: targetRackId,
|
|
position: targetPosition,
|
|
warehouseId: null,
|
|
sourceType: 'rack',
|
|
status: 'offline',
|
|
},
|
|
{ transaction: t }
|
|
);
|
|
|
|
await targetRack.update(
|
|
{
|
|
currentPower: targetRack.currentPower + (device.powerConsumption || 0),
|
|
},
|
|
{ transaction: t }
|
|
);
|
|
|
|
await t.commit();
|
|
|
|
const updatedDevice = await Device.findByPk(deviceId, {
|
|
include: [{ model: Rack, include: [Room] }],
|
|
});
|
|
|
|
const deviceData = {
|
|
...updatedDevice.toJSON(),
|
|
rackName: targetRack.name,
|
|
roomName: updatedDevice.Rack?.Room?.name,
|
|
};
|
|
|
|
await logDeviceOperation(
|
|
'restore',
|
|
generateDeviceDescription('空闲设备恢复', deviceData, { includePosition: false }) +
|
|
`到机柜【${targetRack.name}】U${targetPosition}`,
|
|
{
|
|
targetId: device.deviceId,
|
|
targetName: device.name,
|
|
beforeState: { ...device.toJSON(), isIdle: true },
|
|
afterState: deviceData,
|
|
req,
|
|
metadata: buildDeviceMetadata(deviceData, {
|
|
targetRackId,
|
|
targetPosition,
|
|
type: 'idle_device_restore',
|
|
}),
|
|
}
|
|
);
|
|
|
|
res.json({
|
|
message: '设备已恢复到设备管理',
|
|
device: updatedDevice,
|
|
});
|
|
} catch (error) {
|
|
await t.rollback();
|
|
logger.error('恢复设备失败', { error: error.message, stack: error.stack });
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
router.delete('/:deviceId', async (req, res) => {
|
|
const t = await require('../db').sequelize.transaction();
|
|
try {
|
|
const device = await Device.findOne({
|
|
where: { deviceId: req.params.deviceId, isIdle: true },
|
|
transaction: t,
|
|
});
|
|
|
|
if (!device) {
|
|
await t.rollback();
|
|
return res.status(404).json({ error: '空闲设备不存在' });
|
|
}
|
|
|
|
const beforeState = device.toJSON();
|
|
|
|
await device.destroy({ transaction: t });
|
|
|
|
await t.commit();
|
|
|
|
await logDeviceOperation(
|
|
'delete',
|
|
generateDeviceDescription(
|
|
'删除空闲设备',
|
|
{
|
|
...device.toJSON(),
|
|
name: device.name || device.deviceId,
|
|
},
|
|
{ includeRack: false }
|
|
),
|
|
{
|
|
targetId: device.deviceId,
|
|
targetName: device.name,
|
|
beforeState,
|
|
req,
|
|
metadata: buildDeviceMetadata(device.toJSON(), { type: 'idle_device_delete' }),
|
|
}
|
|
);
|
|
|
|
res.json({ message: '空闲设备删除成功' });
|
|
} catch (error) {
|
|
await t.rollback();
|
|
logger.error('删除空闲设备失败', { error: error.message, stack: error.stack });
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
async function checkPositionAvailable(
|
|
rackId,
|
|
position,
|
|
height,
|
|
excludeDeviceId = null,
|
|
transaction = null
|
|
) {
|
|
const pos = parseInt(position, 10);
|
|
if (!pos || pos <= 0) {
|
|
return { available: true, reason: null };
|
|
}
|
|
|
|
const deviceHeight = parseInt(height, 10) || 1;
|
|
const startU = pos;
|
|
const endU = pos + deviceHeight - 1;
|
|
|
|
const queryOptions = {
|
|
where: {
|
|
rackId: rackId,
|
|
position: { [Op.ne]: null },
|
|
isIdle: false,
|
|
},
|
|
attributes: ['deviceId', 'position', 'height'],
|
|
};
|
|
|
|
if (transaction) {
|
|
queryOptions.transaction = transaction;
|
|
// 使用悲观锁防止竞态条件
|
|
queryOptions.lock = transaction.LOCK ? transaction.LOCK.UPDATE : 'UPDATE';
|
|
}
|
|
|
|
const existingDevices = await Device.findAll(queryOptions);
|
|
|
|
for (const d of existingDevices) {
|
|
if (excludeDeviceId && d.deviceId === excludeDeviceId) {
|
|
continue;
|
|
}
|
|
|
|
const existStart = d.position;
|
|
const existEnd = d.position + (d.height || 1) - 1;
|
|
|
|
if (!(endU < existStart || startU > existEnd)) {
|
|
return {
|
|
available: false,
|
|
reason: `U位冲突：机柜中已有设备 ${d.deviceId} 占用 U${existStart}${existEnd !== existStart ? '-' + existEnd : ''}`,
|
|
};
|
|
}
|
|
}
|
|
|
|
return { available: true, reason: null };
|
|
}
|
|
|
|
module.exports = router;
|