更新！

FullCardServer/src/main/java/com/zhongshu/card/server/core/controller/scene/ProjectSceneInfoController.java

@@ -6,6 +6,7 @@ import com.github.microservice.auth.security.type.AuthType;
 import com.github.microservice.net.ResultContent;
 import com.zhongshu.card.client.model.base.IDParam;
 import com.zhongshu.card.client.model.scene.ProjectBindSceneParam;
+import com.zhongshu.card.client.model.scene.ProjectSceneInfoDetailModel;
 import com.zhongshu.card.client.model.scene.ProjectSceneInfoModel;
 import com.zhongshu.card.client.model.scene.ProjectSceneInfoSearch;
 import com.zhongshu.card.client.type.DataState;
@@ -54,6 +55,14 @@ public class ProjectSceneInfoController {
         return projectSceneInfoService.page(param, pageable);
     }
 
+    @ResourceAuth(value = "user", type = AuthType.User)
+    @Operation(summary = "项目场景列表（包括组件信息）-分页查询", description = "项目场景列表（包括组件信息）-分页查询")
+    @RequestMapping(value = {"pageAboutComponent"}, method = {RequestMethod.POST})
+    public ResultContent<Page<ProjectSceneInfoDetailModel>> pageAboutComponent(@Parameter(hidden = true) @PageableDefault(page = 0, size = 10) Pageable pageable, @Parameter(required = false) ProjectSceneInfoSearch param) {
+        Assert.hasText(param.getProjectOid(), "projectOid不能为空");
+        return projectSceneInfoService.pageAboutComponent(param, pageable);
+    }
+
     @ResourceAuth(value = "user", type = AuthType.User)
     @Operation(summary = "绑定场景", description = "绑定场景")
     @RequestMapping(value = "bindScene", method = {RequestMethod.POST})

FullCardServer/src/main/java/com/zhongshu/card/server/core/controller/scene/RoleSceneInfoController.java

@@ -5,7 +5,10 @@ import com.github.microservice.auth.security.type.AuthType;
 import com.github.microservice.net.ResultContent;
 import com.zhongshu.card.client.model.base.IDParam;
 import com.zhongshu.card.client.model.base.SortParam;
-import com.zhongshu.card.client.model.scene.*;
+import com.zhongshu.card.client.model.scene.RoleBindsSceneParam;
+import com.zhongshu.card.client.model.scene.RoleSceneComTreeModel;
+import com.zhongshu.card.client.model.scene.RoleSceneInfoModel;
+import com.zhongshu.card.client.model.scene.SceneInfoAboutComModel;
 import com.zhongshu.card.server.core.service.scene.RoleSceneInfoService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -24,61 +27,64 @@ import java.util.List;
  */
 @RestController
 @RequestMapping("/roleSceneInfo")
-@Tag(name = "场景--角色场景管理")
+@Tag(name = "组件--角色组件管理")
 public class RoleSceneInfoController {
 
     @Autowired
     private RoleSceneInfoService roleSceneInfoService;
 
+
+    //----------------------------------配置 start---------------------------
+    @ResourceAuth(value = "user", type = AuthType.User)
+    @Operation(summary = "角色绑定组件(多个)", description = "角色绑定组件（多个）")
+    @RequestMapping(value = "bindScenes", method = {RequestMethod.POST})
+    public ResultContent bindScenes(@RequestBody @Valid RoleBindsSceneParam param) {
+        return this.roleSceneInfoService.bindScenes(param);
+    }
+
     @ResourceAuth(value = "user", type = AuthType.User)
-    @Operation(summary = "角色场景列表", description = "角色场景列表")
+    @Operation(summary = "角色删除组件", description = "角色删除组件")
+    @RequestMapping(value = "deleteById", method = {RequestMethod.POST})
+    public ResultContent deleteById(@RequestBody IDParam param) {
+        return this.roleSceneInfoService.deleteById(param.getId());
+    }
+
+    @ResourceAuth(value = "user", type = AuthType.User)
+    @Operation(summary = "角色组件列表（列表形式）", description = "角色组件列表（列表形式）")
     @RequestMapping(value = {"list"}, method = {RequestMethod.POST})
     public ResultContent<List<RoleSceneInfoModel>> list(@RequestBody IDParam param) {
         return roleSceneInfoService.list(param.getId());
     }
 
     @ResourceAuth(value = "user", type = AuthType.User)
-    @Operation(summary = "得到角色所有已启用的场景列表", description = "得到角色所有已启用的场景列表")
+    @Operation(summary = "角色组件所有（树形式）", description = "角色组件所有（树形式）")
+    @RequestMapping(value = {"tree"}, method = {RequestMethod.POST})
+    public ResultContent<List<RoleSceneComTreeModel>> tree(@RequestBody IDParam param) {
+        return roleSceneInfoService.tree(List.of(param.getId()));
+    }
+    //----------------------------------配置 end------------------------------
+
+    @ResourceAuth(value = "user", type = AuthType.User)
+    @Operation(summary = "得到角色所有已启用的组件列表", description = "得到角色所有已启用的组件列表")
     @RequestMapping(value = {"getRoleAllEnableScenes"}, method = {RequestMethod.POST})
     public ResultContent<List<SceneInfoAboutComModel>> getRoleAllEnableScenes(@RequestBody IDParam param) {
         return ResultContent.buildSuccess(roleSceneInfoService.getAllEnableScenes(param.getId()));
     }
 
     @ResourceAuth(value = "user", type = AuthType.User)
-    @Operation(summary = "得到用户所有场景", description = "得到用户所有场景")
+    @Operation(summary = "得到用户所有组件", description = "得到用户所有组件")
     @RequestMapping(value = {"getUserAllEnableScenes"}, method = {RequestMethod.GET})
     public ResultContent<List<SceneInfoAboutComModel>> getUserAllEnableScenes() {
         return ResultContent.buildSuccess(roleSceneInfoService.getUserAllEnableScenes());
     }
 
     @ResourceAuth(value = "user", type = AuthType.User)
-    @Operation(summary = "角色绑定场景", description = "角色绑定场景")
-    @RequestMapping(value = "bindScene", method = {RequestMethod.POST})
-    public ResultContent bindScene(@RequestBody @Valid RoleBindSceneParam param) {
-        return this.roleSceneInfoService.bindScene(param);
-    }
-
-    @ResourceAuth(value = "user", type = AuthType.User)
-    @Operation(summary = "一次绑定多个（以前的删除）", description = "一次绑定多个（以前的删除）")
-    @RequestMapping(value = "bindList", method = {RequestMethod.POST})
-    public ResultContent bindList(@RequestBody @Valid RoleBindAllParam param) {
-        return this.roleSceneInfoService.bindList(param);
-    }
-
-    @ResourceAuth(value = "user", type = AuthType.User)
-    @Operation(summary = "根据场景数据ID 场景详情", description = "根据场景数据ID 场景详情")
+    @Operation(summary = "根据组件数据ID 组件详情", description = "根据组件数据ID 组件详情")
     @RequestMapping(value = "getDetailById", method = {RequestMethod.POST})
     public ResultContent<RoleSceneInfoModel> getDetailById(@RequestBody IDParam param) {
         return this.roleSceneInfoService.getDetailById(param.getId());
     }
 
-    @ResourceAuth(value = "user", type = AuthType.User)
-    @Operation(summary = "角色删除场景", description = "角色删除场景")
-    @RequestMapping(value = "deleteById", method = {RequestMethod.POST})
-    public ResultContent deleteById(@RequestBody IDParam param) {
-        return this.roleSceneInfoService.deleteById(param.getId());
-    }
-
     @ResourceAuth(value = "user", type = AuthType.User)
     @Operation(summary = "排序", description = "排序")
     @RequestMapping(value = "sort", method = {RequestMethod.POST})

FullCardServer/src/main/java/com/zhongshu/card/server/core/dao/scene/RoleSceneInfoDao.java

@@ -2,7 +2,7 @@ package com.zhongshu.card.server.core.dao.scene;
 
 import com.github.microservice.components.data.mongo.mongo.dao.MongoDao;
 import com.zhongshu.card.server.core.domain.scene.RoleSceneInfo;
-import com.zhongshu.card.server.core.domain.scene.SceneInfo;
+import com.zhongshu.card.server.core.domain.scene.SceneComponent;
 
 import java.util.List;
 
@@ -10,6 +10,8 @@ public interface RoleSceneInfoDao extends MongoDao<RoleSceneInfo> {
 
     RoleSceneInfo findTopById(String id);
 
+    RoleSceneInfo findTopByRoleIdAndComponentId(String roleId, SceneComponent component);
+
     RoleSceneInfo findTopByProjectSceneInfoIdAndRoleId(String projectSceneInfoId, String roleId);
 
     long countByRoleId(String roleId);
@@ -24,4 +26,7 @@ public interface RoleSceneInfoDao extends MongoDao<RoleSceneInfo> {
 
     long deleteByRoleId(String roleId);
 
+    long deleteByComponentId(String componentId);
+
+    long deleteByComponentIdIn(List<String> componentIds);
 }

FullCardServer/src/main/java/com/zhongshu/card/server/core/dao/scene/SceneComponentDao.java

@@ -9,6 +9,8 @@ public interface SceneComponentDao extends MongoDao<SceneComponent> {
 
     SceneComponent findTopById(String id);
 
+
+
     List<SceneComponent> findBySceneInfoIdOrderBySortAsc(String sceneInfoId);
 
     long deleteByIdIn(List<String> ids);

FullCardServer/src/main/java/com/zhongshu/card/server/core/domain/scene/ProjectSceneInfo.java

@@ -12,7 +12,7 @@ import org.springframework.data.mongodb.core.mapping.DBRef;
 import org.springframework.data.mongodb.core.mapping.Document;
 
 /**
- * 项目引用场景
+ * 项目引用应用
  *
  * @author TRX
  * @date 2024/11/22
@@ -24,15 +24,15 @@ import org.springframework.data.mongodb.core.mapping.Document;
 @NoArgsConstructor
 public class ProjectSceneInfo extends SuperMain {
 
-    //-------------------场景信息 start -------------------
-    @Schema(description = "场景数据")
+    //-------------------应用信息 start -------------------
+    @Schema(description = "应用数据")
     @DBRef(lazy = true)
     private SceneInfo sceneInfo;
 
     @Schema(description = "关联的数据ID")
     private String sceneInfoId;
 
-    @Schema(description = "场景名称")
+    @Schema(description = "应用名称")
     private String name;
 
     @Schema(description = "类型")
@@ -40,7 +40,7 @@ public class ProjectSceneInfo extends SuperMain {
 
     @Schema(description = "外面的状态")
     private DataState sceneState;
-    //-------------------场景信息 end --------------------
+    //-------------------应用信息 end --------------------
 
     @Schema(description = "状态")
     private DataState state = DataState.Enable;

FullCardServer/src/main/java/com/zhongshu/card/server/core/domain/scene/RoleSceneInfo.java

@@ -1,7 +1,5 @@
 package com.zhongshu.card.server.core.domain.scene;
 
-import com.zhongshu.card.client.type.DataState;
-import com.zhongshu.card.client.type.scene.SceneType;
 import com.zhongshu.card.server.core.domain.base.SuperMain;
 import com.zhongshu.card.server.core.domain.org.Role;
 import io.swagger.v3.oas.annotations.media.Schema;
@@ -13,7 +11,7 @@ import org.springframework.data.mongodb.core.mapping.DBRef;
 import org.springframework.data.mongodb.core.mapping.Document;
 
 /**
- * 项目引用场景
+ * 项目引用应用
  *
  * @author TRX
  * @date 2024/11/22
@@ -25,21 +23,28 @@ import org.springframework.data.mongodb.core.mapping.Document;
 @NoArgsConstructor
 public class RoleSceneInfo extends SuperMain {
 
-    @Schema(description = "场景数据")
+    @Schema(description = "应用数据")
     @DBRef(lazy = true)
     private SceneInfo sceneInfo;
 
+    @Schema(description = "组件")
+    @DBRef(lazy = true)
+    private SceneComponent component;
+
+    @Schema(description = "组件ID")
+    private String componentId;
+
     @Schema(description = "关联的数据ID")
     private String sceneInfoId;
 
-    @Schema(description = "项目管理的数据")
+    @Schema(description = "项目关联的应用数据")
     @DBRef(lazy = true)
     private ProjectSceneInfo projectSceneInfo;
 
-    @Schema(description = "项目管理的场景ID")
+    @Schema(description = "项目管理的应用ID")
     private String projectSceneInfoId;
 
-    @Schema(description = "场景数据")
+    @Schema(description = "应用数据")
     @DBRef(lazy = true)
     private Role role;
 

FullCardServer/src/main/java/com/zhongshu/card/server/core/service/scene/ProjectSceneInfoService.java

@@ -4,6 +4,7 @@ import com.github.microservice.components.data.base.util.PageEntityUtil;
 import com.github.microservice.net.ResultContent;
 import com.github.microservice.net.ResultMessage;
 import com.zhongshu.card.client.model.scene.ProjectBindSceneParam;
+import com.zhongshu.card.client.model.scene.ProjectSceneInfoDetailModel;
 import com.zhongshu.card.client.model.scene.ProjectSceneInfoModel;
 import com.zhongshu.card.client.model.scene.ProjectSceneInfoSearch;
 import com.zhongshu.card.client.type.DataState;
@@ -117,11 +118,30 @@ public class ProjectSceneInfoService extends SuperService {
         return projectSceneInfo;
     }
 
+    /**
+     * 项目的应用列表
+     *
+     * @param param
+     * @param pageable
+     * @return
+     */
     public ResultContent<Page<ProjectSceneInfoModel>> page(ProjectSceneInfoSearch param, Pageable pageable) {
         Page<ProjectSceneInfo> page = projectSceneInfoDao.page(pageable, param);
         return ResultContent.buildSuccess(PageEntityUtil.concurrent2PageModel(page, this::toModel));
     }
 
+    /**
+     * 项目的应用列表
+     *
+     * @param param
+     * @param pageable
+     * @return
+     */
+    public ResultContent<Page<ProjectSceneInfoDetailModel>> pageAboutComponent(ProjectSceneInfoSearch param, Pageable pageable) {
+        Page<ProjectSceneInfo> page = projectSceneInfoDao.page(pageable, param);
+        return ResultContent.buildSuccess(PageEntityUtil.concurrent2PageModel(page, this::toDetailModel));
+    }
+
     public ResultContent<ProjectSceneInfoModel> getDetailById(String id) {
         ProjectSceneInfo entity = projectSceneInfoDao.findTopById(id);
         if (ObjectUtils.isEmpty(entity)) {
@@ -215,4 +235,15 @@ public class ProjectSceneInfoService extends SuperService {
         return model;
     }
 
+    public ProjectSceneInfoDetailModel toDetailModel(ProjectSceneInfo entity) {
+        ProjectSceneInfoDetailModel model = new ProjectSceneInfoDetailModel();
+        if (ObjectUtils.isNotEmpty(entity)) {
+            BeanUtils.copyProperties(entity, model);
+            model.setSceneInfo(sceneInfoService.toModel(entity.getSceneInfo()));
+            model.setChildren(sceneInfoService.getSceneAllComponents(entity.getSceneInfoId()));
+        }
+        return model;
+    }
+
+
 }

FullCardServer/src/main/java/com/zhongshu/card/server/core/service/scene/RoleSceneInfoService.java

@@ -5,18 +5,17 @@ import com.github.microservice.net.ResultMessage;
 import com.google.common.collect.Lists;
 import com.zhongshu.card.client.model.base.SortParam;
 import com.zhongshu.card.client.model.org.role.RoleSimpleModel;
-import com.zhongshu.card.client.model.scene.RoleBindAllParam;
-import com.zhongshu.card.client.model.scene.RoleBindSceneParam;
-import com.zhongshu.card.client.model.scene.RoleSceneInfoModel;
-import com.zhongshu.card.client.model.scene.SceneInfoAboutComModel;
+import com.zhongshu.card.client.model.scene.*;
 import com.zhongshu.card.client.type.DataState;
 import com.zhongshu.card.server.core.dao.org.RoleDao;
 import com.zhongshu.card.server.core.dao.scene.ProjectSceneInfoDao;
 import com.zhongshu.card.server.core.dao.scene.RoleSceneInfoDao;
+import com.zhongshu.card.server.core.dao.scene.SceneComponentDao;
 import com.zhongshu.card.server.core.dao.scene.SceneInfoDao;
 import com.zhongshu.card.server.core.domain.org.Role;
 import com.zhongshu.card.server.core.domain.scene.ProjectSceneInfo;
 import com.zhongshu.card.server.core.domain.scene.RoleSceneInfo;
+import com.zhongshu.card.server.core.domain.scene.SceneComponent;
 import com.zhongshu.card.server.core.domain.scene.SceneInfo;
 import com.zhongshu.card.server.core.service.base.SuperService;
 import com.zhongshu.card.server.core.service.user.RoleServiceImpl;
@@ -26,11 +25,11 @@ import org.apache.commons.lang3.ObjectUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
 
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 /**
@@ -59,69 +58,83 @@ public class RoleSceneInfoService extends SuperService {
     @Autowired
     private RoleServiceImpl roleServiceImpl;
 
-    public ResultContent bindScene(RoleBindSceneParam param) {
-        ProjectSceneInfo entity = projectSceneInfoDao.findTopById(param.getId());
-        if (ObjectUtils.isEmpty(entity)) {
-            return ResultContent.buildFail(String.format(ResultMessage.DATA_NOT_EXIST, param.getId()));
-        }
-        Role role = roleDao.findTopById(param.getRoleId());
-        if (ObjectUtils.isEmpty(role)) {
-            return ResultContent.buildFail("角色不存在");
+    @Autowired
+    private SceneComponentDao sceneComponentDao;
+
+    /**
+     * 绑定组件
+     *
+     * @param param
+     * @return
+     */
+    public ResultContent bindScenes(RoleBindsSceneParam param) {
+        List<String> ids = param.getIds();
+        if (ObjectUtils.isEmpty(ids)) {
+            return ResultContent.buildFail("");
         }
-//        RoleSceneInfo roleSceneInfo = roleSceneInfoDao.findTopByProjectSceneInfoIdAndRoleId(entity.getId(), role.getId());
-//        if (ObjectUtils.isNotEmpty(roleSceneInfo)) {
-//            return ResultContent.buildFail(String.format("角色已存在场景：%s", entity.getName()));
-//        }
-        RoleSceneInfo roleSceneInfo = buildProjectSceneInfo(entity, role);
-        long index = roleSceneInfoDao.countByRoleId(role.getId());
-        roleSceneInfo.setSort(index + 1);
-        roleSceneInfoDao.save(roleSceneInfo);
-        return ResultContent.buildSuccess();
-    }
 
-    @Transactional
-    public ResultContent bindList(RoleBindAllParam param) {
         Role role = roleDao.findTopById(param.getRoleId());
         if (ObjectUtils.isEmpty(role)) {
             return ResultContent.buildFail("角色不存在");
         }
+        String projectOid = param.getProjectOid();
+        if (StringUtils.isEmpty(projectOid)) {
+            return ResultContent.buildFail("projectOid不能为空");
+        }
+
+        long i = 1;
         List<RoleSceneInfo> list = new ArrayList<>();
-        List<String> projectSceneInfoIds = param.getProjectSceneInfoIds();
-        if (ObjectUtils.isNotEmpty(projectSceneInfoIds)) {
-            long i = 1;
-            for (String projectSceneInfoId : projectSceneInfoIds) {
-                // 项目的场景
-                ProjectSceneInfo projectSceneInfo = projectSceneInfoDao.findTopById(projectSceneInfoId);
-                if (ObjectUtils.isNotEmpty(projectSceneInfo)) {
-                    RoleSceneInfo roleSceneInfo = buildProjectSceneInfo(projectSceneInfo, role);
-                    roleSceneInfo.setSort(i);
-                    i++;
-                    list.add(roleSceneInfo);
-                }
+        for (String id : ids) {
+            SceneComponent sceneComponent = sceneComponentDao.findTopById(id);
+            if (ObjectUtils.isEmpty(sceneComponent)) {
+                continue;
             }
+            SceneInfo sceneInfo = sceneComponent.getSceneInfo();
+            ProjectSceneInfo projectSceneInfo = projectSceneInfoDao.findTopBySceneInfoAndProjectOid(sceneInfo, projectOid);
+            if (ObjectUtils.isEmpty(projectSceneInfo)) {
+                continue;
+            }
+
+            RoleSceneInfo roleSceneInfo = roleSceneInfoDao.findTopByRoleIdAndComponentId(role.getId(), sceneComponent);
+            if (ObjectUtils.isEmpty(roleSceneInfo)) {
+                roleSceneInfo = new RoleSceneInfo();
+                initEntityNoCheckOid(roleSceneInfo);
+            }
+            // 角色信息
+            roleSceneInfo.setRole(role);
+            roleSceneInfo.setRoleId(role.getId());
+            roleSceneInfo.setProjectOid(projectOid);
+
+            // 组件信息
+            roleSceneInfo.setComponent(sceneComponent);
+            roleSceneInfo.setComponentId(sceneComponent.getId());
+
+            // 应用信息
+            roleSceneInfo.setSceneInfo(sceneInfo);
+            roleSceneInfo.setSceneInfoId(sceneInfo.getId());
+
+            // 项目管理的应用
+            roleSceneInfo.setProjectSceneInfo(projectSceneInfo);
+            roleSceneInfo.setProjectSceneInfoId(projectSceneInfo.getId());
+
+            roleSceneInfo.setSort(i);
+            list.add(roleSceneInfo);
+            i++;
         }
-        if (ObjectUtils.isNotEmpty(list)) {
-            roleSceneInfoDao.saveAll(list);
-        }
+        roleSceneInfoDao.saveAll(list);
         return ResultContent.buildSuccess();
     }
 
-    public RoleSceneInfo buildProjectSceneInfo(ProjectSceneInfo projectSceneInfo, Role role) {
-        RoleSceneInfo roleSceneInfo = roleSceneInfoDao.findTopByProjectSceneInfoIdAndRoleId(projectSceneInfo.getId(), role.getId());
-        if (ObjectUtils.isEmpty(roleSceneInfo)) {
-            roleSceneInfo = new RoleSceneInfo();
-            initEntityNoCheckOid(roleSceneInfo);
-            roleSceneInfo.setSceneInfo(projectSceneInfo.getSceneInfo());
-            roleSceneInfo.setSceneInfoId(projectSceneInfo.getId());
-            roleSceneInfo.setProjectSceneInfo(projectSceneInfo);
-            roleSceneInfo.setProjectSceneInfoId(projectSceneInfo.getId());
-        } else {
-            initUpdateEntity(roleSceneInfo);
+
+    public ResultContent deleteById(String id) {
+        RoleSceneInfo entity = roleSceneInfoDao.findTopById(id);
+        if (ObjectUtils.isEmpty(entity)) {
+            return ResultContent.buildFail(String.format(ResultMessage.DATA_NOT_EXIST, id));
         }
-        roleSceneInfo.setProjectOid(projectSceneInfo.getProjectOid());
-        roleSceneInfo.setRole(role);
-        roleSceneInfo.setRoleId(role.getId());
-        return roleSceneInfo;
+        // 判断是否可以删除
+        roleSceneInfoDao.delete(entity);
+        // 删除关联的信息
+        return ResultContent.buildSuccess();
     }
 
     /**
@@ -139,8 +152,52 @@ public class RoleSceneInfoService extends SuperService {
         return ResultContent.buildSuccess(models);
     }
 
+    public ResultContent<List<RoleSceneComTreeModel>> tree(List<String> roleIds) {
+        List<RoleSceneComTreeModel> models = new ArrayList<>();
+
+        List<RoleSceneInfo> list = roleSceneInfoDao.findByRoleIdInOrderBySortAsc(roleIds);
+        if (ObjectUtils.isNotEmpty(list)) {
+            // 以项目应用ID
+            Map<String, List<RoleSceneInfo>> map = list.stream().collect(
+                    Collectors.toMap(RoleSceneInfo::getProjectSceneInfoId, e -> {
+                        List<RoleSceneInfo> objects = new ArrayList<>();
+                        objects.add(e);
+                        return objects;
+                    }, (newList, oldList) -> {
+                        oldList.addAll(newList);
+                        return oldList;
+                    }));
+            for (String projectSceneInfoId : map.keySet()) {
+                ProjectSceneInfo projectSceneInfo = projectSceneInfoDao.findTopById(projectSceneInfoId);
+                if (ObjectUtils.isEmpty(projectSceneInfo)) {
+                    continue;
+                }
+                RoleSceneComTreeModel model = new RoleSceneComTreeModel();
+                SceneInfoModel sceneInfoModel = sceneInfoService.toModel(projectSceneInfo.getSceneInfo());
+                BeanUtils.copyProperties(sceneInfoModel, model);
+
+                model.setProjectSceneInfoId(projectSceneInfoId);
+
+                // 组件信息
+                List<RoleSceneInfo> roleSceneInfos = map.get(projectSceneInfoId);
+                List<RoleSceneComponentModel> children = roleSceneInfos.stream().map(it -> {
+                    RoleSceneComponentModel componentModel = new RoleSceneComponentModel();
+                    SceneComponentModel sceneComponentModel = sceneInfoService.toComponentModel(it.getComponent());
+                    BeanUtils.copyProperties(sceneComponentModel, componentModel);
+                    componentModel.setRoleSceneId(it.getId());
+
+                    return componentModel;
+                }).collect(Collectors.toList());
+
+                model.setChildren(children);
+                models.add(model);
+            }
+        }
+        return ResultContent.buildSuccess(models);
+    }
+
     /**
-     * 查询角色可用的场景
+     * 查询角色可用的应用
      *
      * @param roleId
      * @return
@@ -149,7 +206,7 @@ public class RoleSceneInfoService extends SuperService {
         List<SceneInfoAboutComModel> models = new ArrayList<>();
 
         if (StringUtils.isNotEmpty(roleId)) {
-            // 角色关联的场景数据
+            // 角色关联的应用数据
             List<RoleSceneInfo> list = roleSceneInfoDao.findByRoleIdOrderBySortAsc(roleId);
             if (ObjectUtils.isNotEmpty(list)) {
                 list.stream().forEach(it -> {
@@ -190,7 +247,7 @@ public class RoleSceneInfoService extends SuperService {
                 List<SceneInfoAboutComModel> reModels = new ArrayList<>();
                 HashMap<String, String> map = new HashMap<>();
                 for (SceneInfoAboutComModel model : models) {
-                    if(!map.containsKey(model.getId())) {
+                    if (!map.containsKey(model.getId())) {
                         map.put(model.getId(), model.getName());
                         reModels.add(model);
                     }
@@ -210,17 +267,6 @@ public class RoleSceneInfoService extends SuperService {
         return ResultContent.buildSuccess(toModel(entity));
     }
 
-    public ResultContent deleteById(String id) {
-        RoleSceneInfo entity = roleSceneInfoDao.findTopById(id);
-        if (ObjectUtils.isEmpty(entity)) {
-            return ResultContent.buildFail(String.format(ResultMessage.DATA_NOT_EXIST, id));
-        }
-        // 判断是否可以删除
-        roleSceneInfoDao.delete(entity);
-        // 删除关联的信息
-        return ResultContent.buildSuccess();
-    }
-
     /**
      * 数据排序
      *
@@ -246,31 +292,57 @@ public class RoleSceneInfoService extends SuperService {
     }
 
     /**
-     * 根据项目的场景id删除角色的
+     * 根据项目的应用id删除角色的
      *
      * @param projectSceneInfoId
      * @return
      */
     public ResultContent deleteByProjectSceneId(String projectSceneInfoId) {
-        if (ObjectUtils.isNotEmpty(projectSceneInfoId)) {
+        if (StringUtils.isNotEmpty(projectSceneInfoId)) {
             roleSceneInfoDao.deleteByProjectSceneInfoId(projectSceneInfoId);
         }
         return ResultContent.buildSuccess();
     }
 
     /**
-     * 根据平台的场景id删除
+     * 根据平台的应用id删除
      *
      * @param sceneInfoId
      * @return
      */
     public ResultContent deleteBySceneInfoId(String sceneInfoId) {
-        if (ObjectUtils.isNotEmpty(sceneInfoId)) {
+        if (StringUtils.isNotEmpty(sceneInfoId)) {
             roleSceneInfoDao.deleteBySceneInfoId(sceneInfoId);
         }
         return ResultContent.buildSuccess();
     }
 
+    /**
+     * 根据组件ID删除
+     *
+     * @param componentId
+     * @return
+     */
+    public ResultContent deleteByComponentId(String componentId) {
+        if (StringUtils.isNotEmpty(componentId)) {
+            roleSceneInfoDao.deleteByComponentId(componentId);
+        }
+        return ResultContent.buildSuccess();
+    }
+
+    /**
+     * 根据组件id集合删除
+     *
+     * @param componentIds
+     * @return
+     */
+    public ResultContent deleteByComponentIds(List<String> componentIds) {
+        if (ObjectUtils.isNotEmpty(componentIds)) {
+            roleSceneInfoDao.deleteByComponentIdIn(componentIds);
+        }
+        return ResultContent.buildSuccess();
+    }
+
     /**
      * 根据角色id删除数据
      *
@@ -278,7 +350,7 @@ public class RoleSceneInfoService extends SuperService {
      * @return
      */
     public ResultContent deleteByRoleId(String roleId) {
-        if (ObjectUtils.isNotEmpty(roleId)) {
+        if (StringUtils.isNotEmpty(roleId)) {
             roleSceneInfoDao.deleteByRoleId(roleId);
         }
         return ResultContent.buildSuccess();
@@ -288,7 +360,10 @@ public class RoleSceneInfoService extends SuperService {
         RoleSceneInfoModel model = new RoleSceneInfoModel();
         if (ObjectUtils.isNotEmpty(entity)) {
             BeanUtils.copyProperties(entity, model);
+            // 管理的应用信息
             model.setSceneInfo(sceneInfoService.toModel(entity.getSceneInfo()));
+            // 关联的组件信息
+            model.setSceneComponent(sceneInfoService.toComponentModel(entity.getComponent()));
         }
         return model;
     }

FullCardServer/src/main/java/com/zhongshu/card/server/core/service/scene/SceneInfoService.java

@@ -166,6 +166,12 @@ public class SceneInfoService extends SuperService {
         return ResultContent.buildSuccess();
     }
 
+    /**
+     * 根据应用id 查询所有的组件
+     *
+     * @param sceneInfoId
+     * @return
+     */
     public List<SceneComponentModel> getSceneAllComponents(String sceneInfoId) {
         List<SceneComponentModel> models = new ArrayList<>();
         if (StringUtils.isNotEmpty(sceneInfoId)) {
@@ -177,6 +183,14 @@ public class SceneInfoService extends SuperService {
         return models;
     }
 
+    public List<SceneComponentModel> getSceneAllComponents(List<SceneComponent> components) {
+        List<SceneComponentModel> models = new ArrayList<>();
+        if (ObjectUtils.isNotEmpty(components)) {
+            models = components.stream().map(this::toComponentModel).collect(Collectors.toUnmodifiableList());
+        }
+        return models;
+    }
+
     //--------------------------场景组件信息 end-----------------------
 
     /**