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: "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' }
            //   }
        ],
    },
]

export const constantRoutes404Config = {
    path: "/404",
    component: () => import("@/views/404"),
    hidden: true,
}
export const constantRouteslogManage = {
    path: "/logManage",
    permissionCode: "ecswinlog",
    component: Layout,
    name: "日志管理",
    children: [
        {
            path: "index",
            permissionCode: "Log",
            name: "日志管理列表",
            component: () => import("@/views/logManage/index"),
            meta: { title: "日志", icon: "form" },
        },
    ],
}

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)
}