yunrui_asset/backend/routes/cables.js

const logger = require('../utils/logger').module('CablesRoute');
const express = require('express');
const router = express.Router();
const { Op } = require('sequelize');
const Cable = require('../models/Cable');
const Device = require('../models/Device');
const DevicePort = require('../models/DevicePort');

const PORT_COMPATIBILITY = {
  RJ45: {
    compatibleWith: ['RJ45'],
    cableTypes: ['ethernet', 'copper'],
    description: '电口',
  },
  SFP: {
    compatibleWith: ['SFP', 'SFP+', 'SFP28', 'QSFP', 'QSFP28'],
    cableTypes: ['fiber'],
    description: '光口',
  },
  'SFP+': {
    compatibleWith: ['SFP', 'SFP+', 'SFP28', 'QSFP28'],
    cableTypes: ['fiber'],
    description: '万兆光口',
  },
  SFP28: {
    compatibleWith: ['SFP28', 'SFP+', 'QSFP28'],
    cableTypes: ['fiber'],
    description: '25G光口',
  },
  QSFP: {
    compatibleWith: ['QSFP', 'QSFP28'],
    cableTypes: ['fiber'],
    description: '40G光口',
  },
  QSFP28: {
    compatibleWith: ['QSFP28', 'QSFP'],
    cableTypes: ['fiber'],
    description: '100G光口',
  },
};

const SPEED_COMPATIBILITY = {
  '100M': { compatibleSpeeds: ['100M', '1G'], warningThreshold: null },
  '1G': { compatibleSpeeds: ['100M', '1G', '10G'], warningThreshold: '10G' },
  '10G': { compatibleSpeeds: ['1G', '10G', '25G'], warningThreshold: '25G' },
  '25G': { compatibleSpeeds: ['10G', '25G', '40G'], warningThreshold: '40G' },
  '40G': { compatibleSpeeds: ['25G', '40G', '100G'], warningThreshold: '100G' },
  '100G': { compatibleSpeeds: ['40G', '100G'], warningThreshold: null },
};

function checkPortCompatibility(sourcePort, targetPort) {
  const incompatibilityReasons = [];

  const sourcePortType = sourcePort.portType;
  const targetPortType = targetPort.portType;

  const sourceCompat = PORT_COMPATIBILITY[sourcePortType];
  const targetCompat = PORT_COMPATIBILITY[targetPortType];

  if (!sourceCompat || !targetCompat) {
    incompatibilityReasons.push({
      type: 'unknown',
      message: `未知端口类型: 源端口=${sourcePortType}, 目标端口=${targetPortType}`,
      severity: 'error',
    });
    return { compatible: false, reasons: incompatibilityReasons };
  }

  const sourceCanConnect = sourceCompat.compatibleWith.includes(targetPortType);
  const targetCanConnect = targetCompat.compatibleWith.includes(sourcePortType);

  if (!sourceCanConnect || !targetCanConnect) {
    incompatibilityReasons.push({
      type: 'portType',
      message: `端口类型不兼容: 源端口(${sourcePortType}-${sourceCompat.description})无法连接到目标端口(${targetPortType}-${targetCompat.description})`,
      severity: 'error',
      details: {
        sourcePortType,
        targetPortType,
        sourceDescription: sourceCompat.description,
        targetDescription: targetCompat.description,
      },
    });
  }

  const sourceSpeedCompat = SPEED_COMPATIBILITY[sourcePort.portSpeed];
  const targetSpeedCompat = SPEED_COMPATIBILITY[targetPort.portSpeed];

  if (sourceSpeedCompat && targetSpeedCompat) {
    const sourceCanSupportTarget = sourceSpeedCompat.compatibleSpeeds.includes(targetPort.portSpeed);
    const targetCanSupportSource = targetSpeedCompat.compatibleSpeeds.includes(sourcePort.portSpeed);

    if (!sourceCanSupportTarget || !targetCanSupportSource) {
      if (sourcePort.portSpeed !== targetPort.portSpeed) {
        incompatibilityReasons.push({
          type: 'speed',
          message: `端口速率不匹配: 源端口(${sourcePort.portSpeed})与目标端口(${targetPort.portSpeed})速率不一致，可能影响连接质量`,
          severity: 'warning',
          details: {
            sourceSpeed: sourcePort.portSpeed,
            targetSpeed: targetPort.portSpeed,
            sourceWarning: sourceSpeedCompat.warningThreshold,
            targetWarning: targetSpeedCompat.warningThreshold,
          },
        });
      }
    }
  }

  return {
    compatible: incompatibilityReasons.filter(r => r.severity === 'error').length === 0,
    reasons: incompatibilityReasons,
  };
}

async function validatePortCompatibility(sourceDeviceId, sourcePortName, targetDeviceId, targetPortName) {
  try {
    const [sourcePorts, targetPorts] = await Promise.all([
      DevicePort.findAll({ where: { deviceId: sourceDeviceId, portName: sourcePortName } }),
      DevicePort.findAll({ where: { deviceId: targetDeviceId, portName: targetPortName } }),
    ]);

    const sourcePort = sourcePorts[0];
    const targetPort = targetPorts[0];

    if (!sourcePort) {
      return {
        compatible: false,
        reasons: [{
          type: 'notFound',
          message: `源设备 ${sourceDeviceId} 的端口 ${sourcePortName} 不存在`,
          severity: 'error',
        }],
      };
    }

    if (!targetPort) {
      return {
        compatible: false,
        reasons: [{
          type: 'notFound',
          message: `目标设备 ${targetDeviceId} 的端口 ${targetPortName} 不存在`,
          severity: 'error',
        }],
      };
    }

    return checkPortCompatibility(sourcePort, targetPort);
  } catch (error) {
    logger.error('验证端口兼容性时出错', { error: error.message, stack: error.stack });
    return {
      compatible: false,
      reasons: [{
        type: 'error',
        message: `验证端口兼容性时出错: ${error.message}`,
        severity: 'error',
      }],
    };
  }
}

// 辅助函数：更新端口状态
async function updatePortStatus(deviceId, portName, status) {
  try {
    await DevicePort.update({ status }, { where: { deviceId, portName } });
  } catch (error) {
    logger.error('更新端口状态失败: ${deviceId}:${portName} -> ${status}', { error: error.message, stack: error.stack });
  }
}

// 辅助函数：将端口状态设为occupied
async function occupyPort(deviceId, portName) {
  await updatePortStatus(deviceId, portName, 'occupied');
}

// 辅助函数：将端口状态恢复为free
async function freePort(deviceId, portName) {
  await updatePortStatus(deviceId, portName, 'free');
}

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) {
    logger.error('获取接线列表失败', { error: error.message, stack: error.stack });
    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) {
    logger.error('获取设备接线失败', { error: error.message, stack: error.stack });
    res.status(500).json({ error: error.message });
  }
});

// 获取指定机柜内所有设备的接线
router.get('/rack/:rackId', async (req, res) => {
  try {
    const { rackId } = req.params;

    // 1. 找出该机柜下的所有设备ID
    const devices = await Device.findAll({
      where: { rackId: rackId },
      attributes: ['deviceId'],
    });

    const deviceIds = devices.map(d => d.deviceId);

    if (deviceIds.length === 0) {
      return res.json([]);
    }

    // 2. 查找这些设备参与的所有接线
    const cables = await Cable.findAll({
      where: {
        [Op.or]: [
          { sourceDeviceId: { [Op.in]: deviceIds } },
          { targetDeviceId: { [Op.in]: deviceIds } },
        ],
      },
      include: [
        {
          model: Device,
          as: 'sourceDevice',
          attributes: ['deviceId', 'name', 'type', 'rackId'],
        },
        {
          model: Device,
          as: 'targetDevice',
          attributes: ['deviceId', 'name', 'type', 'rackId'],
        },
      ],
    });

    res.json(cables);
  } catch (error) {
    logger.error('获取机柜接线失败', { error: error.message, stack: error.stack });
    res.status(500).json({ error: error.message });
  }
});

// 检查接线冲突
router.post('/check-conflict', async (req, res) => {
  try {
    const { sourceDeviceId, sourcePort, targetDeviceId, targetPort, excludeCableId } = req.body;

    if (!sourceDeviceId || !sourcePort || !targetDeviceId || !targetPort) {
      return res.status(400).json({ error: '缺少必填字段' });
    }

    const conflicts = [];

    // 检查源端口冲突
    const sourceConflict = await Cable.findOne({
      where: {
        [Op.or]: [
          { sourceDeviceId, sourcePort },
          { targetDeviceId: sourceDeviceId, targetPort: sourcePort },
        ],
        ...(excludeCableId && { cableId: { [Op.ne]: excludeCableId } }),
      },
      include: [
        {
          model: Device,
          as: 'sourceDevice',
          attributes: ['deviceId', 'name', 'type'],
        },
        {
          model: Device,
          as: 'targetDevice',
          attributes: ['deviceId', 'name', 'type'],
        },
      ],
    });

    if (sourceConflict) {
      conflicts.push({
        type: 'source',
        port: sourcePort,
        deviceId: sourceDeviceId,
        existingCable: sourceConflict,
      });
    }

    // 检查目标端口冲突
    const targetConflict = await Cable.findOne({
      where: {
        [Op.or]: [
          { sourceDeviceId: targetDeviceId, sourcePort: targetPort },
          { targetDeviceId, targetPort },
        ],
        ...(excludeCableId && { cableId: { [Op.ne]: excludeCableId } }),
      },
      include: [
        {
          model: Device,
          as: 'sourceDevice',
          attributes: ['deviceId', 'name', 'type'],
        },
        {
          model: Device,
          as: 'targetDevice',
          attributes: ['deviceId', 'name', 'type'],
        },
      ],
    });

    if (targetConflict) {
      conflicts.push({
        type: 'target',
        port: targetPort,
        deviceId: targetDeviceId,
        existingCable: targetConflict,
      });
    }

    res.json({
      hasConflict: conflicts.length > 0,
      conflicts,
    });
  } catch (error) {
    logger.error('检查接线冲突失败', { error: error.message, stack: error.stack });
    res.status(500).json({ error: error.message });
  }
});

// 检查端口兼容性
router.post('/check-compatibility', async (req, res) => {
  try {
    const { sourceDeviceId, sourcePort, targetDeviceId, targetPort } = req.body;

    if (!sourceDeviceId || !sourcePort || !targetDeviceId || !targetPort) {
      return res.status(400).json({ error: '缺少必填字段' });
    }

    const compatibilityResult = await validatePortCompatibility(sourceDeviceId, sourcePort, targetDeviceId, targetPort);

    res.json({
      compatible: compatibilityResult.compatible,
      ...compatibilityResult,
    });
  } catch (error) {
    logger.error('检查端口兼容性失败', { error: error.message, stack: error.stack });
    res.status(500).json({ error: error.message });
  }
});

router.post('/', async (req, res) => {
  try {
    const {
      cableId,
      sourceDeviceId,
      sourcePort,
      targetDeviceId,
      targetPort,
      cableType,
      cableLength,
      status,
      description,
      cableLabel,
      cableColor,
      installedBy,
      installedAt,
      lastTestedAt,
      force,
    } = req.body;

    if (!sourceDeviceId || !sourcePort || !targetDeviceId || !targetPort) {
      return res.status(400).json({ error: '缺少必填字段' });
    }

    if (sourceDeviceId === targetDeviceId) {
      return res.status(400).json({ error: '源设备和目标设备不能相同' });
    }

    // 端口兼容性验证
    const compatibilityResult = await validatePortCompatibility(sourceDeviceId, sourcePort, targetDeviceId, targetPort);
    if (!compatibilityResult.compatible) {
      const errorReasons = compatibilityResult.reasons.filter(r => r.severity === 'error');
      return res.status(400).json({
        error: '端口不兼容',
        incompatibility: true,
        compatibilityResult,
        errors: errorReasons.map(r => r.message),
      });
    }

    // 如果不是强制模式，检查冲突（包括反向端口分配）
    if (!force) {
      const existingCable = await Cable.findOne({
        where: {
          [Op.or]: [
            { sourceDeviceId, sourcePort },
            { targetDeviceId, targetPort },
            { sourceDeviceId: targetDeviceId, sourcePort: targetPort },
            { targetDeviceId: sourceDeviceId, targetPort: sourcePort },
          ],
        },
      });

      if (existingCable) {
        return res.status(409).json({
          error: '端口已被占用',
          conflict: true,
          existingCable,
        });
      }
    }

    // 如果是强制模式，先断开原有连接
    if (force) {
      const existingCables = await Cable.findAll({
        where: {
          [Op.or]: [
            { sourceDeviceId, sourcePort },
            { targetDeviceId: sourceDeviceId, targetPort: sourcePort },
            { sourceDeviceId: targetDeviceId, sourcePort: targetPort },
            { targetDeviceId, targetPort },
          ],
        },
      });

      for (const cable of existingCables) {
        await cable.destroy();
        // 释放原有端口
        await freePort(cable.sourceDeviceId, cable.sourcePort);
        await freePort(cable.targetDeviceId, cable.targetPort);
      }
    }

    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,
      cableLabel: cableLabel || null,
      cableColor: cableColor || null,
      installedBy: installedBy || null,
      installedAt: installedAt || null,
      lastTestedAt: lastTestedAt || null,
    });

    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'],
        },
      ],
    });

    // 自动将源端口和目标端口状态设为occupied
    await occupyPort(sourceDeviceId, sourcePort);
    await occupyPort(targetDeviceId, targetPort);

    res.status(201).json(createdCable);
  } catch (error) {
    logger.error('创建接线失败', { error: error.message, stack: error.stack });
    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,
        });

        // 自动将源端口和目标端口状态设为occupied
        await occupyPort(cableData.sourceDeviceId, cableData.sourcePort);
        await occupyPort(cableData.targetDeviceId, cableData.targetPort);

        results.success++;
      } catch (error) {
        results.failed++;
        results.errors.push({
          index: i + 1,
          cableId: cableData.cableId,
          error: error.message,
        });
      }
    }

    res.json(results);
  } catch (error) {
    logger.error('批量创建接线失败', { error: error.message, stack: error.stack });
    res.status(500).json({ error: error.message });
  }
});

router.put('/:cableId', async (req, res) => {
  try {
    // 获取更新前的接线信息
    const oldCable = await Cable.findByPk(req.params.cableId);

    if (!oldCable) {
      return res.status(404).json({ error: '接线不存在' });
    }

    const {
      sourceDeviceId: oldSourceDeviceId,
      sourcePort: oldSourcePort,
      targetDeviceId: oldTargetDeviceId,
      targetPort: oldTargetPort,
    } = oldCable;

    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'],
          },
        ],
      });

      const { sourceDeviceId, sourcePort, targetDeviceId, targetPort } = cable;

      // 同步更新端口状态
      // 源端口变更：释放旧端口，占用新端口
      if (oldSourceDeviceId !== sourceDeviceId || oldSourcePort !== sourcePort) {
        await freePort(oldSourceDeviceId, oldSourcePort);
        await occupyPort(sourceDeviceId, sourcePort);
      }

      // 目标端口变更：释放旧端口，占用新端口
      if (oldTargetDeviceId !== targetDeviceId || oldTargetPort !== targetPort) {
        await freePort(oldTargetDeviceId, oldTargetPort);
        await occupyPort(targetDeviceId, targetPort);
      }

      res.json(cable);
    } else {
      res.status(404).json({ error: '接线不存在' });
    }
  } catch (error) {
    logger.error('更新接线失败', { error: error.message, stack: error.stack });
    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 cables = await Cable.findAll({
      where: { cableId: { [Op.in]: cableIds } },
    });

    const deletedCount = await Cable.destroy({
      where: { cableId: { [Op.in]: cableIds } },
    });

    // 自动将所有相关端口状态恢复为free
    for (const cable of cables) {
      await freePort(cable.sourceDeviceId, cable.sourcePort);
      await freePort(cable.targetDeviceId, cable.targetPort);
    }

    res.json({
      message: `批量删除成功，已删除 ${deletedCount} 条接线`,
      deletedCount,
    });
  } catch (error) {
    logger.error('批量删除接线失败', { error: error.message, stack: error.stack });
    res.status(500).json({ error: error.message });
  }
});

// 删除单个接线
router.delete('/:cableId', async (req, res) => {
  try {
    // 先获取接线信息，用于后续恢复端口状态
    const cable = await Cable.findByPk(req.params.cableId);

    if (!cable) {
      return res.status(404).json({ error: '接线不存在' });
    }

    const { sourceDeviceId, sourcePort, targetDeviceId, targetPort } = cable;

    const deleted = await Cable.destroy({
      where: { cableId: req.params.cableId },
    });

    if (deleted) {
      // 自动将源端口和目标端口状态恢复为free
      await freePort(sourceDeviceId, sourcePort);
      await freePort(targetDeviceId, targetPort);

      res.status(204).json();
    } else {
      res.status(404).json({ error: '接线不存在' });
    }
  } catch (error) {
    logger.error('删除接线失败', { error: error.message, stack: error.stack });
    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) {
    logger.error('获取接线详情失败', { error: error.message, stack: error.stack });
    res.status(500).json({ error: error.message });
  }
});

module.exports = router;