ECS5 / ECS5.0Web · Files

/* Layout */
import Layout from "@/layout";


/**
 * 自定义路由信息配置 permissionCode 字段是匹配后台的接口权限数据的permissionCode 
 * 需要自己在wpf页面权限处查看或者数据库 需要保证正确
 */
export const defaultRoutesConfig = [
  //用户目录 
  {
    path: "/systemPermission",
    permissionCode: "ecswinpermission",
    component: Layout,
    redirect: "/systemPermission/index",
    name: "用户权限管理",
    meta: {
      title: "用户权限管理",
      icon: "quanxian",
    },
    children: [
      {
        path: "user",
        permissionCode: "user",
        component: () => import("@/views/systemPermission/permission/user"),
        name: "user",
        meta: { title: "用户管理", icon: "yonghu" },
      }, {
        path: "role",
        permissionCode: "permission",
        component: () => import("@/views/systemPermission/permission/role"), // Parent router-view
        name: "role",
        meta: { title: "权限管理", icon: "juese" },
      },
    ],
  },

  //系统管理
  {
    path: "/systemManage",
    permissionCode: "ecswinsys",
    component: Layout,
    redirect: "/systemManage/dict",
    name: "系统管理",
    meta: { title: "系统管理", icon: "xitongshezhi" },
    children: [
      {
        path: "config",
        permissionCode: "config",
        name: "系统配置",
        component: () => import("@/views/systemManage/config"),
        meta: { title: "系统配置", icon: "xitongpeizhi" },
      },
      {
        path: "dict",
        permissionCode: "dict",
        name: "字典管理",
        component: () => import("@/views/systemManage/dict"),
        meta: { title: "字典管理", icon: "zidianguanli" },
      },
      {
        path: "timer",
        permissionCode: "job",
        name: "定时器",
        component: () => import("@/views/systemManage/timer"),
        meta: { title: "定时器", icon: "dingshiqi" },
      },
    ],
  },

  //基础数据
  {
    path: "/basicData",
    permissionCode: "ecsbase",
    component: Layout,
    redirect: "/basicData/warehouse",
    name: "基础数据",
    meta: { title: "基础数据", icon: "jichushuju" },
    children: [
      {
        path: "warehouse",
        permissionCode: "warehouse",
        name: "仓库管理",
        component: () => import("@/views/basicData/warehouse"),
        meta: { title: "仓库管理", icon: "cangkuguanli" },
      },
      {
        path: "location",
        permissionCode: "location",
        name: "库位管理",
        component: () => import("@/views/basicData/location"),
        meta: { title: "库位管理", icon: "kuwei" },
      },
      {
        path: "container",
        permissionCode: "ecswincontainer",
        name: "容器管理",
        component: () => import("@/views/basicData/container"),
        meta: { title: "容器管理", icon: "rongqi" },
      },
    ],
  },

  //设备管理
  {
    path: "/device",
    permissionCode: "ecswinequipment",
    component: Layout,
    redirect: "/deviceManage/deviceManage",
    name: "设备管理",
    meta: { title: "设备管理", icon: "task" },
    children: [
      {
        path: "deviceManage",
        permissionCode: "equipmentmanager",
        name: "设备管理列表",
        component: () => import("@/views/deviceManage/deviceManage"),
        meta: { title: "设备管理", icon: "main-task" },
      },
      {
        path: "deviceTepeManage",
        permissionCode: "equipmenttypemanager",
        name: "设备类型管理",
        component: () => import("@/views/deviceManage/deviceTepeManage"),
        meta: { title: "设备类型管理", icon: "ddj-task" },
      },
      {
        path: 'deviceErrManage',
        permissionCode: "PageEquipmentAlarmRecord",
        name: '设备报警管理',
        component: () => import('@/views/deviceManage/deviceErrManage'),
        meta: { title: '设备报警管理', icon: 'crgv-task' }
      },
      {
        path: 'deviceStateManage',
        permissionCode: "PageEquipmentStatusRecord",
        name: '设备状态管理',
        component: () => import('@/views/deviceManage/deviceStateManage'),
        meta: { title: '设备状态管理', icon: 'rgv-task' }
      }
    ],
  },

  //任务管理
  {
    path: "/example",
    permissionCode: "ecswintask",
    component: Layout,
    redirect: "/example/taskManage",
    name: "任务管理",
    meta: { title: "任务管理", icon: "task" },
    children: [
      {
        path: "taskModel_host",
        permissionCode: "maintask",
        name: "主任务",
        component: () => import("@/views/taskManage/taskModel_host"),
        meta: { title: "主任务", icon: "main-task" },
      },
      {
        path: "taskModel_stacker",
        permissionCode: "srmtask",
        name: "堆垛机任务",
        component: () => import("@/views/taskManage/taskModel_stacker"),
        meta: { title: "堆垛机任务", icon: "ddj-task" },
      }, {
        path: 'CRGV任务',
        permissionCode: "crgvtask",
        name: 'CRGV任务',
        component: () => import('@/views/taskManage/taskModel_CRGV'),
        meta: { title: 'CRGV任务', icon: 'crgv-task' }
      },
      {
        path: 'RGV任务',
        permissionCode: "rgvtask",
        name: 'RGV任务',
        component: () => import('@/views/taskManage/taskModel_RGV'),
        meta: { title: 'RGV任务', icon: 'rgv-task' }
      }
    ],
  },
  //日志管理
  {
    path: "/logManage",
    permissionCode: "ecswinlog",
    component: Layout,
    name: "日志管理",
    children: [
      {
        path: "index",
        permissionCode: "Log",
        name: "日志管理列表",
        component: () => import("@/views/logManage/index"),
        meta: { title: "日志", icon: "form" },
      },
    ],
  },
]

export const constantRoutes404Config = {
  path: "/404",
  component: () => import("@/views/404"),
  hidden: true,
}

export const constantRoutesMapConfig = {
  path: '/map',
  component: Layout,
  redirect: '/mapSystem',
  orderNum: 100000,
  children: [{
    path: 'mapSystem',
    name: 'mapSystem',
    component: () => import('@/views/map/mapSystem'),
    meta: { title: '图形管理', icon: 'el-icon-house', affix: true }
  }]
}


/**
* 将后台权限数据转换为前端路由结构
* @param {Object} result - 后台返回的权限数据（包含data字段）
* @param {Array} constantRoutes - 前端定义的路由配置模板
* @returns {Array} 符合前端要求的路由结构
*/
export function generatePermissionRoutes(result, constantRoutes) {
  // 1. 构建权限码映射表，提取关键路由配置
  const permissionCodeMap = {};
  const buildPermissionMap = (routes) => {
    routes.forEach(route => {
      if (route.permissionCode) {
        permissionCodeMap[route.permissionCode] = {
          path: route.path,
          component: route.component,  // 保留前端定义的组件（目录用Layout，菜单用页面组件）
          name: route.name,
          meta: route.meta,
          redirect: route.redirect
        };
      }
      if (route.children) buildPermissionMap(route.children);
    });
  };
  buildPermissionMap(constantRoutes);

  // 2. 过滤并处理后台节点数据
  const validNodes = result.data
    .filter(item => [1, 5].includes(item.permissionType))  // 仅保留目录和菜单
    .map(item => ({
      id: item.id,
      parentId: item.parentId,
      permissionCode: item.permissionCode,
      permissionType: item.permissionType,
      orderNum: item.orderNum || 0, // 确保有默认值
      children: []
    }));

  // 3. 构建树形结构
  const nodeMap = new Map(validNodes.map(node => [node.id, node]));
  validNodes.forEach(node => {
    if (node.parentId && nodeMap.has(node.parentId)) {
      const parent = nodeMap.get(node.parentId);
      if (parent.permissionType === 1) {  // 仅允许目录节点包含子节点
        parent.children.push(node);
      }
    }
  });

  // 4. 定位根节点（父节点为模块或空）
  const rootNodes = validNodes.filter(node => {
    const parent = nodeMap.get(node.parentId);
    return !parent || parent.permissionType === 10;
  }).sort((a, b) => a.orderNum - b.orderNum);


  // 5. 递归转换节点为路由对象
  const convertToRoute = (node) => {
    const routeConfig = permissionCodeMap[node.permissionCode];
    if (!routeConfig) return null;  // 无匹配配置则忽略

    // 核心：目录强制使用Layout，菜单使用配置的组件
    const route = {
      path: routeConfig.path,
      permissionCode: node.permissionCode,
      component: node.permissionType === 1 ? Layout : routeConfig.component,  // 目录层硬编码Layout
      name: routeConfig.name,
      meta: { ...routeConfig.meta }
    };

    // 处理目录的重定向逻辑
    if (node.permissionType === 1) {
      route.redirect = routeConfig.redirect;
      route.children = node.children
        .map(child => convertToRoute(child))
        .filter(Boolean)
        .sort((a, b) => a.orderNum - b.orderNum) // 子节点按orderNum排序
    }

    return route;
  };

  // 6. 生成最终路由配置
  return rootNodes
    .map(node => convertToRoute(node))
    .filter(Boolean)
}