com.huawei.idme.miniapp
├── config          # 配置类
│   ├── XdmfConfig.java       # xDM-F SDK配置（补充Token传递与iDME权限适配，P0）
│   ├── WebSocketConfig.java  # 实时通信配置（P2）
│   └── SecurityConfig.java   # 权限控制配置（集成iDME鉴权，P1）
├── controller      # 控制层
│   ├── EquipmentController.java（P0，适配iDME设备实体API）
│   ├── PartController.java（P0，适配iDME物料与分类API）
│   ├── ProcedureController.java（P0，适配iDME工序实例API）
│   ├── WorkingPlanController.java（P0，核心工艺API与iDME生命周期绑定）
│   └── AuthController.java    # 权限管理接口（集成iDME批量鉴权，P1）
├── dto              # 数据传输对象
│   ├── request               # 请求DTO
│   │   ├── EquipmentCreateReq.java（P0，字段与xDM-F Equipment实体对齐）
│   │   ├── SaveProcessDesignReq.java (核心，P0，适配iDME关系实体创建规范)
│   │   ├── SubmitPlanReq.java（P0，关联iDME生命周期状态更新）
│   │   ├── PartSearchReq.java（P0，适配xDM-F find接口查询参数）
│   │   ├── PartCategoryReq.java（P0，适配xDM-F树形结构创建参数）
│   │   ├── RoleAssignReq.java  # 角色分配请求（P1，关联iDME用户角色API）
│   │   └── ProcessTemplateReq.java  # 工艺模板请求（P1，基于xDM-F实例创建规范）
│   └── response              # 响应VO
│       ├── BaseResponse.java  (含code, msg, requestId，P0，适配iDME响应格式)
│       ├── EquipmentVO.java（P0，与xDM-F Equipment实体属性映射）
│       ├── PartVO.java（P0，与xDM-F Part实体属性映射）
│       ├── PartCategoryVO.java（P0，与xDM-F树形分类实体映射）
│       ├── ProcessRouteVO.java（P0，与xDM-F ProcessRoute实体映射）
│       ├── RoleVO.java（P1，适配iDME角色权限返回格式）
│       └── ProcessTemplateVO.java（P1，基于xDM-F实例响应规范）
├── service          # 业务逻辑层
│   ├── XdmfApiClient.java    # xDM-F SDK封装工具类（P0+P1，封装iDME全量数据服务API）
│   ├── EquipmentService.java（P0，调用xDM-F设备CRUD与关系查询接口）
│   ├── PartService.java（P0，调用xDM-F物料版本与库存接口，补充P1库存校验）
│   ├── PartCategoryService.java（P0，调用xDM-F树形分类创建与查询接口）
│   ├── WorkingPlanService.java (核心，P0，调用xDM-F工艺与关系实体接口)
│   ├── AuthService.java      # 权限管理服务（P1，集成iDME batchHasAccess接口）
│   ├── ProcessTemplateService.java  # 工艺模板服务（P1，基于xDM-F实例保存规范）
│   └── WebSocketService.java # 实时通信服务（P2，监听iDME事件通知）
├── entity           # 数据实体扩展
│   ├── PartCategory.java（P0，与xDM-F树形分类实体属性对齐）
│   ├── ProcessRoute.java（P0，与xDM-F工艺路线实体属性对齐）
│   ├── Role.java             # 角色实体（P1，适配iDME用户角色模型）
│   ├── UserRoleRel.java      # 用户-角色关联实体（P1，适配iDME权限关联规范）
│   └── ProcessTemplate.java  # 工艺模板实体（P1，基于xDM-F实例扩展）
└── exception        # 异常处理
    ├── BusinessException.java（P0，映射iDME错误码格式）
    └── GlobalExceptionHandler.java (P0，捕获iDME API调用异常并转换为统一错误码)

src/
├── api              # API 封装（均适配iDME接口规范）
│   ├── equipment.js（P0，调用iDME设备实体API）
│   ├── workingPlan.js（P0，调用iDME工艺与生命周期API）
│   ├── part.js（P0，调用iDME物料与版本API）
│   ├── partCategory.js（P0，调用iDME树形分类API）
│   ├── auth.js               # 权限相关API（P1，调用iDME鉴权与角色API）
│   └── processTemplate.js    # 工艺模板API（P1，基于iDME实例API封装）
├── components       # 公共组件
│   ├── ExtAttrsForm.vue      # 扩展属性动态表单（P0，适配xDM-F扩展属性格式）
│   ├── PermissionGuard.vue   # 权限守卫组件（P1，集成iDME权限校验结果）
│   └── ProcessTemplateForm.vue  # 工艺模板表单（P1，遵循iDME实例创建参数规范）
├── views            # 页面
│   ├── equipment
│   │   └── EquipmentList.vue（P0，展示iDME设备实体查询结果）
│   ├── part
│   │   ├── PartList.vue（P0，展示iDME物料查询结果）
│   │   └── PartCategory.vue（P0，适配iDME树形分类展示）
│   ├── workingPlan
│   │   ├── DesignCanvas.vue # 工艺设计画布 (核心交互，P0，调用iDME关系实体创建API)
│   │   ├── RouteList.vue（P0，展示iDME工艺路线实例）
│   │   └── TemplateList.vue # 工艺模板列表（P1，基于iDME实例查询结果展示）
│   └── system
│       ├── RoleManagement.vue # 角色管理页面（P1，适配iDME角色管理API）
│       └── UserRoleAssign.vue # 用户角色分配页面（P1，调用iDME权限关联API）
└── store            # Pinia 状态管理
    ├── useEquipmentStore.js（P0，同步iDME设备实体数据）
    ├── usePlanStore.js（P0，同步iDME工艺与生命周期状态）
    ├── usePartStore.js（P0，同步iDME物料与分类数据）
    └── useAuthStore.js       # 权限状态管理（P1，缓存iDME鉴权结果）

public void updateStatus(String equipmentId, String newStatus, String operator) {
    // 1. 权限校验：调用iDME批量鉴权接口
    authService.checkPermission(operator, "EQUIPMENT_STATUS_UPDATE");
    
    // 2. 校验状态合法性（与iDME生命周期状态对齐）
    if (!Arrays.asList("RUNNING", "STOPPED", "MAINTENANCE", "SCRAPPED").contains(newStatus)) {
        throw new BusinessException("E001", "设备状态不合法（iDME生命周期状态约束）");
    }
    
    // 3. 校验是否被工艺引用（调用iDME关系实体查询接口）
    if ("STOPPED".equals(newStatus) || "SCRAPPED".equals(newStatus)) {
        boolean isUsed = xdmfApiClient.checkRelationExists("Rel_Procedure_Resource", "targetId", equipmentId);
        if (isUsed) {
            throw new BusinessException("E002", "设备被工艺引用，禁止停机/报废（iDME关系实体约束）");
        }
    }
    
    // 4. 调用iDME设备实体更新接口
    Map<String, Object> updateParams = new HashMap<>();
    updateParams.put("status", newStatus);
    updateParams.put("lastModifiedBy", operator);
    xdmfApiClient.updateEntity("Equipment", equipmentId, updateParams);
    
    // 5. 同步iDME生命周期状态
    xdmfApiClient.updateLifecycleState("Equipment", equipmentId, mapStatusToLifecycle(newStatus));
    
    // 6. 实时通知相关模块
    EquipmentVO updatedEq = xdmfApiClient.getEntityById("Equipment", equipmentId, EquipmentVO.class);
    webSocketService.broadcastEquipmentStatus(updatedEq);
}

// 库存校验逻辑（工艺提交前触发）
public void validateStock(String partId, BigDecimal requiredQuantity) {
    // 1. 调用iDME物料实例查询接口获取最新数据
    PartVO part = xdmfApiClient.getEntityById("Part", partId, PartVO.class);
    if (part == null) {
        throw new BusinessException("P008", "物料不存在（iDME实例查询无结果）");
    }
    
    // 2. 校验物料状态（遵循iDME生命周期约束）
    if ("DISABLED".equals(part.getStatus()) || "OBSOLETE".equals(part.getLifecycleState())) {
        throw new BusinessException("P005", "物料【" + part.getName() + "】已禁用或过期，不可使用");
    }
    
    // 3. 校验库存数量
    if (part.getStockQuantity().compareTo(requiredQuantity) < 0) {
        throw new BusinessException("P006", "物料【" + part.getName() + "】库存不足，当前库存：" + part.getStockQuantity() + "，所需数量：" + requiredQuantity);
    }
}

// 物料版本升版逻辑（基于iDME saveAs接口）
public PartVO saveAsVersion(String partId) {
    // 1. 查询原物料信息（调用iDME实例查询接口）
    PartVO oldPart = xdmfApiClient.getEntityById("Part", partId, PartVO.class);
    
    // 2. 生成新版本号（遵循iDME版本命名规范）
    String newVersion = generateNewVersion(oldPart.getVersion());
    
    // 3. 调用iDME另存版本接口创建新版本
    Map<String, Object> saveAsParams = new HashMap<>();
    saveAsParams.put("sourceInstanceId", partId);
    saveAsParams.put("version", newVersion);
    saveAsParams.put("modifier", SecurityContextHolder.getContext().getAuthentication().getName());
    
    String newPartId = xdmfApiClient.saveAsEntity("Part", saveAsParams);
    return xdmfApiClient.getEntityById("Part", newPartId, PartVO.class);
}

@Data
public class SubmitPlanReq {
    private String planId;
    private String operator;
    private List<ProcessMaterialReq> materials; // 工艺所需物料清单
    private String lifecycleState; // 目标iDME生命周期状态（如Submitted）
}

@Data
public class ProcessMaterialReq {
    private String partId;
    private BigDecimal quantity;
    private String partVersion; // 关联iDME物料版本
}

@Transactional(rollbackFor = Exception.class)
public void submitPlan(SubmitPlanReq req) {
    String planId = req.getPlanId();
    // 1. 校验工艺状态（调用iDME生命周期查询接口）
    WorkingPlanVO plan = xdmfApiClient.getEntityById("WorkingPlan", planId, WorkingPlanVO.class);
    if (!"Draft".equals(plan.getLifecycleState())) {
        throw new BusinessException("P002", "非草稿状态不可提交（iDME生命周期约束）");
    }
    
    // 2. 权限校验：调用iDME批量鉴权接口
    authService.checkPermission(req.getOperator(), "PROCESS_SUBMIT");
    
    // 3. 物料库存与状态校验（调用iDME物料查询接口）
    for (ProcessMaterialReq material : req.getMaterials()) {
        partService.validateStock(material.getPartId(), material.getQuantity());
    }
    
    // 4. 设备状态校验（调用iDME设备查询接口）
    List<ProcedureItem> procedures = plan.getProcedures();
    for (ProcedureItem item : procedures) {
        for (ResourceItem res : item.getResources()) {
            if ("DEVICE".equals(res.getTargetType())) {
                EquipmentVO eq = xdmfApiClient.getEntityById("Equipment", res.getTargetId(), EquipmentVO.class);
                if (!"RUNNING".equals(eq.getStatus()) || !"ACTIVE".equals(eq.getLifecycleState())) {
                    throw new BusinessException("E004", "设备【" + eq.getName() + "】非运行状态，工艺不可提交");
                }
            }
        }
    }
    
    // 5. 更新工艺状态与iDME生命周期
    Map<String, Object> updateParams = new HashMap<>();
    updateParams.put("status", "Submitted");
    updateParams.put("lifecycleState", req.getLifecycleState());
    updateParams.put("submitter", req.getOperator());
    xdmfApiClient.updateEntity("WorkingPlan", planId, updateParams);
    
    // 6. 实时通知工艺状态变更
    webSocketService.broadcastPlanStatus(planId, "Submitted");
}

@Service
public class AuthService {
    // 权限校验（集成iDME batchHasAccess接口）
    public void checkPermission(String userId, String permissionCode) {
        // 1. 调用iDME批量鉴权接口
        Map<String, Object> authParams = new HashMap<>();
        authParams.put("userId", userId);
        authParams.put("rdmExtensionType", "SystemPermission");
        authParams.put("operations", Collections.singletonList(permissionCode));
        authParams.put("ids", Collections.singletonList(permissionCode));
        
        Map<String, Boolean> authResult = xdmfApiClient.batchHasAccess(authParams);
        Boolean hasPermission = authResult.get(permissionCode);
        if (hasPermission == null || !hasPermission) {
            throw new BusinessException("A002", "用户无【" + permissionCode + "】权限，操作被拒绝（iDME鉴权结果）");
        }
    }
    
    // 分配角色（调用iDME用户角色关联接口）
    public void assignRole(RoleAssignReq req, String operator) {
        // 1. 校验操作员权限
        this.checkPermission(operator, "ROLE_ASSIGN");
        
        // 2. 调用iDME接口删除原有关联
        xdmfApiClient.deleteRelation("UserRoleRel", "userId", req.getUserId());
        
        // 3. 调用iDME接口创建新关联
        Map<String, Object> relParams = new HashMap<>();
        relParams.put("userId", req.getUserId());
        relParams.put("roleId", req.getRoleId());
        xdmfApiClient.createRelation("UserRoleRel", relParams);
    }
}

@Service
public class WebSocketService {
    @Autowired
    private SimpMessagingTemplate messagingTemplate;
    
    // 推送设备状态变更（监听iDME设备实例更新事件）
    public void broadcastEquipmentStatus(EquipmentVO equipment) {
        messagingTemplate.convertAndSend("/topic/equipment/status/" + equipment.getId(), equipment);
    }
    
    // 推送工艺状态变更（监听iDME工艺生命周期变更事件）
    public void broadcastPlanStatus(String planId, String status) {
        WorkingPlanVO plan = xdmfApiClient.getEntityById("WorkingPlan", planId, WorkingPlanVO.class);
        Map<String, Object> msg = new HashMap<>();
        msg.put("planId", planId);
        msg.put("planName", plan.getPlanName());
        msg.put("status", status);
        msg.put("lifecycleState", plan.getLifecycleState());
        msg.put("timestamp", LocalDateTime.now());
        messagingTemplate.convertAndSend("/topic/plan/status/" + planId, msg);
    }
}

import { defineStore } from 'pinia';
export const useAuthStore = defineStore('auth', {
  state: () => ({
    currentUser: null,
    userRoles: [],
    userPermissions: []
  }),
  actions: {
    // 加载用户权限（调用iDME鉴权接口）
    async loadUserAuth() {
      const res = await api.getUserPermissions();
      if (res.code === '0000') {
        this.currentUser = res.data.user;
        this.userRoles = res.data.roles;
        this.userPermissions = res.data.permissions;
      }
    },
    // 检查是否有权限（基于iDME鉴权结果）
    hasPermission(permissionCode) {
      return this.userPermissions.includes(permissionCode);
    }
  }
});

spring:
  application:
    name: industrial-miniapp
  websocket:
    broker:
      enable: true
      prefix: /topic
xdmf:
  endpoint: http://127.0.0.1:8080/rdm_IndustrialMiniAPP_app/services/dynamic/api
  public-endpoint: http://127.0.0.1:8080/rdm_IndustrialMiniAPP_app/publicservices/api
  app-id: IndustrialMiniAPP # iDME应用ID
  token: ${XDM_AUTH_TOKEN:your_default_token} # iDME认证Token
  cache:
    equipmentPoolExpire: 600 # 设备池缓存过期时间（与iDME数据更新频率匹配）
    partCategoryExpire: 600 # 物料分类缓存过期时间
    rolePermissionExpire: 1800 # 角色权限缓存过期时间（与iDME权限更新频率匹配）
security:
  idme:
    auth-endpoint: http://127.0.0.1:8080/rdm_IndustrialMiniAPP_app/services/rdm/basic/api/AccessService/batchHasAccess