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: "system.log",
        children: [
            {
                path: "index",
                permissionCode: "Log",
                name: "system.log",
                component: () => import("@/views/logManage/index"),
                meta: { title: "system.log", 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);
}