ECS5 / ECS5.0Web · Files

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

/**
 * 自定义路由信息配置 permissionCode 字段是匹配后台的接口权限数据的permissionCode
 * 需要自己在wpf页面权限处查看或者数据库 需要保证正确
 * 后续新增 都写在 此处 serverRoutesConfig
 */
export const serverRoutesConfig = [
  //用户目录
  {
    path: "/systemPermission",
    permissionCode: "ecswinpermission",
    component: Layout,
    redirect: "/systemPermission/user",
    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: "/device/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/taskModel_host",
    name: "system.taskManagement",
    meta: { title: "system.taskManagement", icon: "task" },
    children: [
      {
        path: "taskModel_host",
        permissionCode: "maintask",
        name: "taskManage.mainTask",
        component: () => import("@/views/taskManage/taskModel_host"),
        meta: { title: "taskManage.mainTask", icon: "main-task" },
      },
      {
        path: "taskModel_stacker",
        permissionCode: "srmtask",
        name: "taskManage.stackerTask",
        component: () => import("@/views/taskManage/taskModel_stacker"),
        meta: { title: "taskManage.stackerTask", 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 sys_routes404Config = {
  path: "/404",
  component: () => import("@/views/404"),
  hidden: true,
};

//默认地图
export const sys_outesMapConfig = {
  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);
}