获取并行度

api-common/src/main/java/api/common/pojo/constants/DictConstants.java

@@ -110,8 +110,8 @@ public class DictConstants {
     public static final String TASK_ERROR_REASON_4 = "未知状态！";
     public static final String TASK_ERROR_REASON_5 = "打分出错！";
 
-    public static final String USE_TYPE_EXCLUSIVE = "1";//独占使用
-    public static final String USE_TYPE_PUBLIC = "2";//公共使用
+    public static final String USER_TYPE_EXCLUSIVE = "1";//独占使用
+    public static final String USER_TYPE_PUBLIC = "2";//公共使用
 
     // 场景上传任务状态
     public static final String SCENE_IMPORT_STATUS_0 = "0"; //未上传

simulation-resource-scheduler/src/main/java/com/css/simulation/resource/scheduler/util/ProjectUtil.java

@@ -73,9 +73,9 @@ public class ProjectUtil {
 
     @SneakyThrows
     public void deletePod(String podName) {
-        KubernetesUtil.deletePod(apiClient, kubernetesNamespace, podName);
-        // 删除 redis key
+        // 先删除 redis key
         stringRedisTemplate.delete("pod:" + podName + ":node");
+        KubernetesUtil.deletePod(apiClient, kubernetesNamespace, podName);
     }
 
     public String getNodeNameOfPod(String podName) {
@@ -241,7 +241,7 @@ public class ProjectUtil {
         } else if (DictConstants.ROLE_CODE_UESR.equals(roleCode)) { //3-2 普通账户，不管是独占还是共享，都在自己的集群里排队，根据自己的独占节点排队
             clusterId = clusterMapper.selectByUserId(userId).getId();
         } else if (DictConstants.ROLE_CODE_SUBUESR.equals(roleCode)) {
-            if (DictConstants.USE_TYPE_EXCLUSIVE.equals(useType)) {   //3-3 普通子账户，根据自己的独占节点排队
+            if (DictConstants.USER_TYPE_EXCLUSIVE.equals(useType)) {   //3-3 普通子账户，根据自己的独占节点排队
                 clusterId = clusterMapper.selectByUserId(userId).getId();
             } else {    //3-4 共享子账户，根据父账户的共享节点排队
                 String parentUserId = userPO.getCreateUserId();
@@ -282,7 +282,7 @@ public class ProjectUtil {
         } else if (DictConstants.ROLE_CODE_UESR.equals(roleCode)) { //3-2 普通账户，不管是独占还是共享，都在自己的集群里排队，根据自己的独占节点排队
             clusterId = clusterMapper.selectByUserId(userId).getId();
         } else if (DictConstants.ROLE_CODE_SUBUESR.equals(roleCode)) {
-            if (DictConstants.USE_TYPE_EXCLUSIVE.equals(useType)) {   //3-3 普通子账户，根据自己的独占节点排队
+            if (DictConstants.USER_TYPE_EXCLUSIVE.equals(useType)) {   //3-3 普通子账户，根据自己的独占节点排队
                 clusterId = clusterMapper.selectByUserId(userId).getId();
             } else {    //3-4 共享子账户，根据父账户的共享节点排队
                 String parentUserId = userPO.getCreateUserId();
@@ -364,7 +364,7 @@ public class ProjectUtil {
         } else if (DictConstants.ROLE_CODE_UESR.equals(roleCode)) { //3-2 普通账户，不管是独占还是共享，都在自己的集群里排队，根据自己的独占节点排队
             clusterId = clusterMapper.selectByUserId(userId).getId();
         } else if (DictConstants.ROLE_CODE_SUBUESR.equals(roleCode)) {
-            if (DictConstants.USE_TYPE_EXCLUSIVE.equals(useType)) {   //3-3 普通子账户，根据自己的独占节点排队
+            if (DictConstants.USER_TYPE_EXCLUSIVE.equals(useType)) {   //3-3 普通子账户，根据自己的独占节点排队
                 clusterId = clusterMapper.selectByUserId(userId).getId();
             } else {    //3-4 共享子账户，根据父账户的共享节点排队
                 String parentUserId = userPO.getCreateUserId();

simulation-resource-server/src/main/java/com/css/simulation/resource/project/ctrl/SimulationProjectCtrl.java

@@ -25,131 +25,138 @@ public class SimulationProjectCtrl {
 
     /**
      * 创建/修改工作
+     *
      * @param param
      * @return
      */
     @RequestMapping("addOrUpdateProject")
     @ResponseBody
-    public ResponseBodyVO addOrUpdateProject(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO addOrUpdateProject(@RequestBody SimulationManualProjectParam param) {
         return service.addOrUpdateProject(param);
     }
 
     /**
      * 查询项目列表
+     *
      * @param param
      * @return
      */
     @RequestMapping("selectProject")
     @ResponseBody
-    public ResponseBodyVO selectProject(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO selectProject(@RequestBody SimulationManualProjectParam param) {
         return service.selectProject(param);
     }
 
     /**
      * 根据id查询
+     *
      * @return
      */
     @RequestMapping("selectProjectById")
     @ResponseBody
-    public ResponseBodyVO selectProjectById(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO selectProjectById(@RequestBody SimulationManualProjectParam param) {
         return service.selectProjectById(param);
     }
 
     /**
      * 删除工作（支持批量删除）
+     *
      * @return
      */
     @RequestMapping("deleteProjectByids")
     @ResponseBody
-    public ResponseBodyVO deleteProjectByids(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO deleteProjectByids(@RequestBody SimulationManualProjectParam param) {
         return service.deleteProjectByids(param);
     }
 
     /**
      * 修改工作运行状态
+     *
      * @param param
      * @return
      */
     @RequestMapping("updateProjectNowRunState")
     @ResponseBody
-    public ResponseBodyVO updateProjectNowRunState(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO updateProjectNowRunState(@RequestBody SimulationManualProjectParam param) {
         return service.updateProjectNowRunState(param);
     }
 
     /**
      * 获取工作详情
+     *
      * @param param
      * @return
      */
     @RequestMapping("selectProjectDetailsById")
     @ResponseBody
-    public ResponseBodyVO selectProjectDetailsById(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO selectProjectDetailsById(@RequestBody SimulationManualProjectParam param) {
         return service.selectProjectDetailsById(param);
     }
 
     /**
      * 获取测试报告详情
+     *
      * @param param
      * @return
      */
     @RequestMapping("selectProjectReportById")
     @ResponseBody
-    public  ResponseBodyVO selectProjectReportById(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO selectProjectReportById(@RequestBody SimulationManualProjectParam param) {
         return service.selectProjectReportById(param);
     }
 
     /**
      * 获取任务详情信息
+     *
      * @param param
      * @return
      */
     @RequestMapping("selectProjectTaskById")
     @ResponseBody
-    public ResponseBodyVO selectProjectTaskById(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO selectProjectTaskById(@RequestBody SimulationManualProjectParam param) {
         return service.selectProjectTaskById(param);
     }
 
     /**
      * 获取添加工作时需要的下拉选项
+     *
      * @return
      */
     @RequestMapping("selectDropDownByType")
     @ResponseBody
-    public ResponseBodyVO selectDropDownByType(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO selectDropDownByType(@RequestBody SimulationManualProjectParam param) {
         return service.selectDropDownByType(param);
     }
 
 
     /**
-     * 获取人员可用最大并行度
-     * @return
+     * @return 人员可用最大并行度
      */
     @RequestMapping("selectMaxParallelism")
     @ResponseBody
-    public ResponseBodyVO selectMaxParallelism(){
-
+    public ResponseBodyVO<Integer> selectMaxParallelism() {
         Integer licenseNum = clusterService.getLicenseNum();
-
-        return new ResponseBodyVO(ResponseBodyVO.Response.SUCCESS,null,licenseNum);
-//        return service.selectMaxParallelism();
+        return new ResponseBodyVO<>(ResponseBodyVO.Response.SUCCESS, null, licenseNum);
     }
 
     /**
-     * 根据字典类型和code获取name（测试方法）
-     * @param param
-     * @return
+     * 根据字典类型和
+     *
+     * @param param 参数
+     * @return name
      */
     @RequestMapping("getDictName")
     @ResponseBody
-    public ResponseBodyVO getDictName(@RequestBody DictParam param) {
+    public ResponseBodyVO<String> getDictName(@RequestBody DictParam param) {
         String dictName = service.getDictName(param.getType(), param.getCode());
-        return new ResponseBodyVO(ResponseBodyVO.Response.SUCCESS,null,dictName);
+        return new ResponseBodyVO<>(ResponseBodyVO.Response.SUCCESS, null, dictName);
 
     }
 
 
     /**
      * 解析车辆坐标文件
+     *
      * @return
      */
     @RequestMapping("analysisVehicleCoord")
@@ -161,18 +168,20 @@ public class SimulationProjectCtrl {
 
     /**
      * 查询工作任务列表
+     *
      * @param param
      * @return
      */
     @RequestMapping("selectProjectTaskList")
     @ResponseBody
-    public ResponseBodyVO selectProjectTaskList(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO selectProjectTaskList(@RequestBody SimulationManualProjectParam param) {
         return service.selectProjectTaskList(param);
     }
 
 
     /**
      * 导出测试报告
+     *
      * @return
      */
     @RequestMapping("exportProjectReportById")
@@ -183,65 +192,71 @@ public class SimulationProjectCtrl {
 
     /**
      * 生成保存评测等级（任务结果返回时调用）
+     *
      * @return
      */
     @RequestMapping("saveEvaluationLevel")
     @ResponseBody
-    public ResponseBodyVO saveEvaluationLevel(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO saveEvaluationLevel(@RequestBody SimulationManualProjectParam param) {
         return service.saveEvaluationLevel(param);
     }
 
     /**
-     *保存仿真结果到数据库（任务结果返回时调用）
+     * 保存仿真结果到数据库（任务结果返回时调用）
+     *
      * @param param
      * @return
      */
     @RequestMapping("saveTaskResult")
     @ResponseBody
-    public ResponseBodyVO saveTaskResult(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO saveTaskResult(@RequestBody SimulationManualProjectParam param) {
         return service.saveTaskResult(param);
     }
 
     /**
      * 导出工作任务文件包
+     *
      * @return
      */
     @RequestMapping("exportProjectTaskFileById")
     @ResponseBody
-    public void exportProjectTaskFileById(@RequestBody SimulationManualProjectParam param){
+    public void exportProjectTaskFileById(@RequestBody SimulationManualProjectParam param) {
         service.exportProjectTaskFileById(param);
     }
 
     /**
      * 同时导出工作报告和任务包
+     *
      * @param param
      */
     @RequestMapping("exportProjectReportAndTaskFileById")
     @ResponseBody
-    public void exportProjectReportAndTaskFileById(@RequestBody SimulationManualProjectParam param){
+    public void exportProjectReportAndTaskFileById(@RequestBody SimulationManualProjectParam param) {
         service.exportProjectReportAndTaskFileById(param);
     }
 
 
     /**
      * 添加编辑自动项目
+     *
      * @param param
      * @return
      */
     @RequestMapping("addOrUpdateAutomaticProject")
     @ResponseBody
-    public ResponseBodyVO addOrUpdateAutomaticProject(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO addOrUpdateAutomaticProject(@RequestBody SimulationManualProjectParam param) {
         return service.addOrUpdateAutomaticProject(param);
     }
 
 
     /**
      * 删除自动运行工作（支持批量删除）
+     *
      * @return
      */
     @RequestMapping("deleteAutomaticProjectByids")
     @ResponseBody
-    public ResponseBodyVO deleteAutomaticProjectByids(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO deleteAutomaticProjectByids(@RequestBody SimulationManualProjectParam param) {
         return service.deleteAutomaticProjectByids(param);
     }
 
@@ -250,16 +265,18 @@ public class SimulationProjectCtrl {
      */
     @RequestMapping("updateAutomaticRunState")
     @ResponseBody
-    public  ResponseBodyVO updateAutomaticRunState(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO updateAutomaticRunState(@RequestBody SimulationManualProjectParam param) {
         return service.updateAutomaticRunState(param);
-    };
+    }
+
+    ;
 
     /**
      * 查询自动运行项目列表
      */
     @RequestMapping("selectAutomaticProject")
     @ResponseBody
-    public ResponseBodyVO selectAutomaticProject(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO selectAutomaticProject(@RequestBody SimulationManualProjectParam param) {
         return service.selectAutomaticProject(param);
     }
 
@@ -268,7 +285,7 @@ public class SimulationProjectCtrl {
      */
     @RequestMapping("createAutomaticSubProject")
     @ResponseBody
-    public ResponseBodyVO createAutomaticSubProject(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO createAutomaticSubProject(@RequestBody SimulationManualProjectParam param) {
         return service.createAutomaticSubProject(param);
     }
 
@@ -277,29 +294,31 @@ public class SimulationProjectCtrl {
      */
     @RequestMapping("deleteAutomaticSubProjectByIds")
     @ResponseBody
-    public ResponseBodyVO deleteAutomaticSubProjectByIds(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO deleteAutomaticSubProjectByIds(@RequestBody SimulationManualProjectParam param) {
 
         return service.deleteAutomaticSubProjectByIds(param);
     }
 
     /**
      * 查询自动运行子工作信息
+     *
      * @return
      */
     @RequestMapping("selectSubProjectInfo")
     @ResponseBody
-    public ResponseBodyVO selectSubProjectInfo(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO selectSubProjectInfo(@RequestBody SimulationManualProjectParam param) {
         return service.selectSubProjectInfo(param);
     }
 
 
     /**
      * 查询自动运行子工作列表
+     *
      * @return
      */
     @RequestMapping("selectSubProjectList")
     @ResponseBody
-    public ResponseBodyVO selectSubProjectList(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO selectSubProjectList(@RequestBody SimulationManualProjectParam param) {
         return service.selectSubProjectList(param);
     }
 
@@ -308,18 +327,19 @@ public class SimulationProjectCtrl {
      */
     @RequestMapping("selectAutomaticProjectById")
     @ResponseBody
-    public ResponseBodyVO selectAutomaticProjectById(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO selectAutomaticProjectById(@RequestBody SimulationManualProjectParam param) {
         return service.selectAutomaticProjectById(param);
     }
 
     /**
      * 修改自动运行子工作运行状态
+     *
      * @param param
      * @return
      */
     @RequestMapping("updateAutoProjectNowRunState")
     @ResponseBody
-    public ResponseBodyVO updateAutoProjectNowRunState(@RequestBody SimulationManualProjectParam param){
+    public ResponseBodyVO updateAutoProjectNowRunState(@RequestBody SimulationManualProjectParam param) {
         return service.updateAutoProjectNowRunState(param);
     }
 

simulation-resource-server/src/main/java/com/css/simulation/resource/system/service/ClusterService.java

@@ -13,6 +13,7 @@ import com.css.simulation.resource.common.utils.PoUtil;
 import com.css.simulation.resource.log.service.LogService;
 import com.css.simulation.resource.system.mapper.ClusterMapper;
 import com.github.pagehelper.PageInfo;
+import lombok.SneakyThrows;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
@@ -41,17 +42,17 @@ public class ClusterService {
         String useType = AuthUtil.getCurrentUseType();
         String userId = AuthUtil.getCurrentUserId();
         //当前账户为管理员账户，需要查询普通账户，设置roleCode为2
-        if(DictConstants.ROLE_CODE_ADMIN.equals(roleCode) || DictConstants.ROLE_CODE_SYSADMIN.equals(roleCode)){
+        if (DictConstants.ROLE_CODE_ADMIN.equals(roleCode) || DictConstants.ROLE_CODE_SYSADMIN.equals(roleCode)) {
             clusterParam.setRoleCode(DictConstants.ROLE_CODE_UESR);
-        }else if(DictConstants.ROLE_CODE_UESR.equals(roleCode) && DictConstants.USE_TYPE_EXCLUSIVE.equals(useType)){
+        } else if (DictConstants.ROLE_CODE_UESR.equals(roleCode) && DictConstants.USER_TYPE_EXCLUSIVE.equals(useType)) {
             // 当前账户为独占使用的普通账户，需要查询该账户创建的普通账户子账户，设置roleCode为3及当前创建用户id
             clusterParam.setRoleCode(DictConstants.ROLE_CODE_SUBUESR);
             clusterParam.setCreateUserId(userId);
-        }else{
+        } else {
             return new PageInfo<>(new ArrayList<>());
         }
         List<ClusterVO> list = clusterMapper.getClusterList(clusterParam);
-        for (ClusterVO vo:list){
+        for (ClusterVO vo : list) {
             Map<String, String> dictMapByType = dictService.getDictMapByType(DictConstants.USE_TYPE);
             vo.setUseType(dictMapByType.get(vo.getUseType()));
         }
@@ -61,7 +62,7 @@ public class ClusterService {
 
     public ClusterPO saveCluster(ClusterPO clusterPO) {
         String id = clusterPO.getId();
-        if(ObjectUtil.isNotNull(id)){
+        if (ObjectUtil.isNotNull(id)) {
             // 更新，将原纪录is_deleted置为1
             ClusterPO deleteClusterPo = new ClusterPO();
             deleteClusterPo.setId(id);
@@ -92,18 +93,18 @@ public class ClusterService {
         Integer totalSimulationAll;
         Integer totalDynamicAll;
         //当前账户为管理员账户，需要查询普通账户，设置roleCode为2
-        if(DictConstants.ROLE_CODE_ADMIN.equals(roleCode) || DictConstants.ROLE_CODE_SYSADMIN.equals(roleCode)){
+        if (DictConstants.ROLE_CODE_ADMIN.equals(roleCode) || DictConstants.ROLE_CODE_SYSADMIN.equals(roleCode)) {
             clusterParam.setRoleCode(DictConstants.ROLE_CODE_UESR);
             totalSimulationAll = -1;
             totalDynamicAll = -1;
-        }else if(DictConstants.ROLE_CODE_UESR.equals(roleCode) && DictConstants.USE_TYPE_EXCLUSIVE.equals(useType)){
+        } else if (DictConstants.ROLE_CODE_UESR.equals(roleCode) && DictConstants.USER_TYPE_EXCLUSIVE.equals(useType)) {
             // 当前账户为独占使用的普通账户，需要查询该账户创建的普通账户子账户，设置roleCode为3及当前创建用户id
             clusterParam.setRoleCode(DictConstants.ROLE_CODE_SUBUESR);
             clusterParam.setCreateUserId(userId);
             // 查询该普通账户所有的集群数量
             totalSimulationAll = clusterMapper.getSimulationLicenseNum(userId);
             totalDynamicAll = clusterMapper.getDynamicLicenseNum(userId);
-        }else{
+        } else {
             return null;
         }
 
@@ -114,42 +115,65 @@ public class ClusterService {
     }
 
 
-    public Integer getLicenseNum(){
+    @SneakyThrows
+    public int getLicenseNum() {
+        //1 获取当前用户信息
         String roleCode = AuthUtil.getCurrentUserRoleCode();
-        String useType = AuthUtil.getCurrentUseType();
+        String userType = AuthUtil.getCurrentUseType();
         String userId = AuthUtil.getCurrentUserId();
-        if(DictConstants.ROLE_CODE_ADMIN.equals(roleCode) || DictConstants.ROLE_CODE_SYSADMIN.equals(roleCode)){ //管理员账户
+
+        //2 获取当前用户使用的集群账户 id
+        if (DictConstants.ROLE_CODE_ADMIN.equals(roleCode) || DictConstants.ROLE_CODE_SYSADMIN.equals(roleCode)) { // 管理
             return -1;
-        }else if(DictConstants.ROLE_CODE_SUBUESR.equals(roleCode) && DictConstants.USE_TYPE_PUBLIC.equals(useType)){
-            //查询父账户
-            userId = AuthUtil.getCreateUserId();
-        }
-        Integer simulationLicenseNum = clusterMapper.getSimulationLicenseNum(userId);
-        if(simulationLicenseNum == null){
-            simulationLicenseNum = 0;
-        }
-        if(DictConstants.ROLE_CODE_UESR.equals(roleCode) && simulationLicenseNum != 0){//普通账户需要减去它分配给子账户的
+        } else if (DictConstants.ROLE_CODE_UESR.equals(roleCode)) { //普通
             ClusterParam clusterParam = new ClusterParam();
             clusterParam.setCreateUserId(userId);
-            Integer assignedSimulationLicenseNum =  clusterMapper.getAssignedSimLicenseNum(clusterParam);
-            simulationLicenseNum = simulationLicenseNum - assignedSimulationLicenseNum;
-        }
+            Integer licenseTotal = clusterMapper.getSimulationLicenseNum(userId);   // 拥有节点
+            if (DictConstants.USER_TYPE_EXCLUSIVE.equals(userType)) { // 普通独占
+                if (licenseTotal == null || licenseTotal == 0) {
+                    return 0;
+                } else {
+                    Integer licenseAssigned = clusterMapper.getAssignedSimLicenseNum(clusterParam);    // 已分配节点
+                    return licenseTotal - licenseAssigned;
+                }
+            } else if (DictConstants.USER_TYPE_PUBLIC.equals(userType)) {
+                return licenseTotal;
+            } else {
+                throw new RuntimeException("ClusterService--getLicenseNum 获取失败1！");
+            }
 
-        return simulationLicenseNum;
+        } else if (DictConstants.ROLE_CODE_SUBUESR.equals(roleCode)) {
+            int licenseTotal;
+            if (DictConstants.USER_TYPE_EXCLUSIVE.equals(userType)) {
+                ClusterParam clusterParam = new ClusterParam();
+                clusterParam.setCreateUserId(userId);
+                licenseTotal = clusterMapper.getSimulationLicenseNum(userId);   // 拥有节点
+            } else if (DictConstants.USER_TYPE_PUBLIC.equals(userType)) {
+                //查询父账户
+                userId = AuthUtil.getCreateUserId();
+                ClusterParam clusterParam = new ClusterParam();
+                clusterParam.setCreateUserId(userId);
+                licenseTotal = clusterMapper.getSimulationLicenseNum(userId);   // 拥有节点
+            } else {
+                throw new RuntimeException("ClusterService--getLicenseNum 获取失败2！");
+            }
+            return licenseTotal;
+        } else {
+            throw new RuntimeException("ClusterService--getLicenseNum 获取失败3！");
+        }
     }
 
     public ClusterVO getClusterByUserId() {
         String roleCode = AuthUtil.getCurrentUserRoleCode();
         String useType = AuthUtil.getCurrentUseType();
         String userId = AuthUtil.getCurrentUserId();
-        if(DictConstants.ROLE_CODE_ADMIN.equals(roleCode) || DictConstants.ROLE_CODE_SYSADMIN.equals(roleCode)){ //管理员账户
+        if (DictConstants.ROLE_CODE_ADMIN.equals(roleCode) || DictConstants.ROLE_CODE_SYSADMIN.equals(roleCode)) { //管理员账户
             return null;
-        }else if(DictConstants.ROLE_CODE_SUBUESR.equals(roleCode) && DictConstants.USE_TYPE_PUBLIC.equals(useType)){ //公共使用的普通子账户
+        } else if (DictConstants.ROLE_CODE_SUBUESR.equals(roleCode) && DictConstants.USER_TYPE_PUBLIC.equals(useType)) { //公共使用的普通子账户
             //查询父账户
             userId = AuthUtil.getCreateUserId();
         }
-        ClusterVO clusterVO = clusterMapper.getClusterByUserId(userId);
-        return clusterVO;
+        return clusterMapper.getClusterByUserId(userId);
     }
 
 
@@ -157,7 +181,7 @@ public class ClusterService {
         String roleCode = AuthUtil.getCurrentUserRoleCode();
         String useType = AuthUtil.getCurrentUseType();
         String currentUserId = AuthUtil.getCurrentUserId();
-        if(DictConstants.ROLE_CODE_UESR.equals(roleCode) && DictConstants.USE_TYPE_EXCLUSIVE.equals(useType)){
+        if (DictConstants.ROLE_CODE_UESR.equals(roleCode) && DictConstants.USER_TYPE_EXCLUSIVE.equals(useType)) {
             //当前账户为独占使用的普通账户，其集群配置信息
             ClusterVO clusterVO = clusterMapper.getClusterByUserId(currentUserId);
 
@@ -167,9 +191,9 @@ public class ClusterService {
             Integer assignedDynLicenseNum = clusterMapper.getAssignedDynLicenseNum(clusterParam);
 
             //当前普通账户的集群总数量减去已分配的数量
-            if(ObjectUtil.isNotNull(clusterVO) && clusterVO.getNumSimulationLicense() > assignedSimLicenseNum && clusterVO.getNumDynamicLicense() > assignedDynLicenseNum){
+            if (ObjectUtil.isNotNull(clusterVO) && clusterVO.getNumSimulationLicense() > assignedSimLicenseNum && clusterVO.getNumDynamicLicense() > assignedDynLicenseNum) {
                 int validSimLicenseNum = clusterVO.getNumSimulationLicense() - assignedSimLicenseNum;
-                int validDynLicenseNum =  clusterVO.getNumDynamicLicense()  - assignedDynLicenseNum;
+                int validDynLicenseNum = clusterVO.getNumDynamicLicense() - assignedDynLicenseNum;
 
                 clusterVO.setValidNumSimLicense(validSimLicenseNum);
                 clusterVO.setValidNumDynLicense(validDynLicenseNum);