Merge remote-tracking branch 'origin/master'

FullCardClient/src/main/java/com/zhongshu/card/client/model/base/ProjectOidParam.java

@@ -1,11 +1,9 @@
 package com.zhongshu.card.client.model.base;
 
 import io.swagger.v3.oas.annotations.media.Schema;
-import jakarta.validation.constraints.NotEmpty;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
-import org.checkerframework.common.aliasing.qual.NonLeaked;
 
 /**
  * 项目oid参数模型

FullCardClient/src/main/java/com/zhongshu/card/client/model/base/SortParam.java

@@ -0,0 +1,22 @@
+package com.zhongshu.card.client.model.base;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.HashMap;
+
+/**
+ * @author TRX
+ * @date 2024/11/22
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class SortParam {
+
+    @Schema(description = "排序数据，如： {'id1': 1, 'id2': 3, 'id3': 2}")
+    private HashMap<String, Long> data = new HashMap<>();
+
+}

FullCardClient/src/main/java/com/zhongshu/card/client/model/scene/ProjectBindSceneParam.java

@@ -0,0 +1,23 @@
+package com.zhongshu.card.client.model.scene;
+
+import com.zhongshu.card.client.model.base.ProjectOidParam;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotEmpty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * @author TRX
+ * @date 2024/11/22
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class ProjectBindSceneParam extends ProjectOidParam {
+
+    @Schema(description = "场景数据id")
+    @NotEmpty
+    private String id;
+
+}

FullCardClient/src/main/java/com/zhongshu/card/client/model/scene/ProjectSceneInfoModel.java

@@ -0,0 +1,65 @@
+package com.zhongshu.card.client.model.scene;
+
+import com.zhongshu.card.client.model.base.SuperModel;
+import com.zhongshu.card.client.type.DataState;
+import com.zhongshu.card.client.type.scene.SceneType;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * @author TRX
+ * @date 2024/11/22
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class ProjectSceneInfoModel extends SuperModel {
+
+    @Schema(description = "平台场景信息")
+    private SceneInfoModel sceneInfo;
+
+    @Schema(description = "关联的数据ID")
+    private String sceneInfoId;
+
+    @Schema(description = "场景名称")
+    private String name;
+
+    @Schema(description = "类型")
+    private SceneType sceneType;
+
+    private String sceneTypeStr;
+
+    public String getSceneTypeStr() {
+        if (sceneType != null) {
+            return sceneType.getRemark();
+        }
+        return "";
+    }
+
+    @Schema(description = "外面的状态")
+    private DataState sceneState;
+
+    private String sceneStateStr;
+
+    public String getSceneStateStr() {
+        if (sceneState != null) {
+            return sceneState.getRemark();
+        }
+        return "";
+    }
+
+    @Schema(description = "状态")
+    private DataState state;
+
+    private String stateStr;
+
+    public String getStateStr() {
+        if (state != null) {
+            return state.getRemark();
+        }
+        return "";
+    }
+
+}

FullCardClient/src/main/java/com/zhongshu/card/client/model/scene/ProjectSceneInfoSearch.java

@@ -0,0 +1,35 @@
+package com.zhongshu.card.client.model.scene;
+
+import com.zhongshu.card.client.model.base.SuperSearch;
+import com.zhongshu.card.client.type.DataState;
+import com.zhongshu.card.client.type.scene.SceneType;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * @author TRX
+ * @date 2024/11/22
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class ProjectSceneInfoSearch extends SuperSearch {
+
+    @Schema(description = "关联的数据ID")
+    private String sceneInfoId;
+
+    @Schema(description = "场景名称")
+    private String name;
+
+    @Schema(description = "类型")
+    private SceneType sceneType;
+
+    @Schema(description = "外面的状态")
+    private DataState sceneState;
+
+    @Schema(description = "状态")
+    private DataState state = DataState.Enable;
+
+}

FullCardClient/src/main/java/com/zhongshu/card/client/model/scene/RoleBindSceneParam.java

@@ -0,0 +1,26 @@
+package com.zhongshu.card.client.model.scene;
+
+import com.zhongshu.card.client.model.base.ProjectOidParam;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotEmpty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * @author TRX
+ * @date 2024/11/22
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class RoleBindSceneParam {
+
+    @Schema(description = "场景数据id")
+    @NotEmpty
+    private String id;
+
+    @Schema(description = "角色ID")
+    private String roleId;
+
+}

FullCardClient/src/main/java/com/zhongshu/card/client/model/scene/RoleSceneInfoModel.java

@@ -0,0 +1,27 @@
+package com.zhongshu.card.client.model.scene;
+
+import com.zhongshu.card.client.model.base.SuperModel;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * @author TRX
+ * @date 2024/11/22
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class RoleSceneInfoModel extends SuperModel {
+
+    @Schema(description = "场景信息")
+    private SceneInfoModel sceneInfo;
+
+    @Schema(description = "项目管理的场景ID")
+    private String projectSceneInfoId;
+
+    @Schema(description = "角色ID")
+    private String roleId;
+
+}

FullCardClient/src/main/java/com/zhongshu/card/client/model/scene/SceneInfoModel.java

@@ -0,0 +1,53 @@
+package com.zhongshu.card.client.model.scene;
+
+import com.zhongshu.card.client.model.base.SuperModel;
+import com.zhongshu.card.client.type.DataState;
+import com.zhongshu.card.client.type.scene.SceneType;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * @author TRX
+ * @date 2024/11/22
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class SceneInfoModel extends SuperModel {
+
+    @Schema(description = "场景名称")
+    private String name;
+
+    @Schema(description = "图标")
+    private String logo;
+
+    @Schema(description = "类型")
+    private SceneType sceneType;
+
+    private String sceneTypeStr;
+
+    public String getSceneTypeStr() {
+        if (sceneType != null) {
+            return sceneType.getRemark();
+        }
+        return "";
+    }
+
+    @Schema(description = "布局尺寸")
+    private String size;
+
+    @Schema(description = "状态")
+    private DataState state;
+
+    private String stateStr;
+
+    public String getStateStr() {
+        if (state != null) {
+            return state.getRemark();
+        }
+        return "";
+    }
+
+}

FullCardClient/src/main/java/com/zhongshu/card/client/model/scene/SceneInfoParam.java

@@ -0,0 +1,41 @@
+package com.zhongshu.card.client.model.scene;
+
+import com.zhongshu.card.client.model.base.SuperParam;
+import com.zhongshu.card.client.type.DataState;
+import com.zhongshu.card.client.type.scene.SceneType;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotEmpty;
+import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * @author TRX
+ * @date 2024/11/22
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class SceneInfoParam extends SuperParam {
+
+    @Schema(description = "场景名称")
+    @NotEmpty
+    private String name;
+
+    @NotEmpty
+    @Schema(description = "图标")
+    private String logo;
+
+    @NotNull
+    @Schema(description = "类型")
+    private SceneType sceneType;
+
+    @NotEmpty
+    @Schema(description = "布局尺寸")
+    private String size;
+
+    @Schema(description = "状态")
+    private DataState state = DataState.Enable;
+
+}

FullCardClient/src/main/java/com/zhongshu/card/client/model/scene/SceneInfoSearch.java

@@ -0,0 +1,32 @@
+package com.zhongshu.card.client.model.scene;
+
+import com.zhongshu.card.client.model.base.SuperSearch;
+import com.zhongshu.card.client.type.DataState;
+import com.zhongshu.card.client.type.scene.SceneType;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * @author TRX
+ * @date 2024/11/22
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class SceneInfoSearch extends SuperSearch {
+
+    @Schema(description = "场景名称")
+    private String name;
+
+    @Schema(description = "类型")
+    private SceneType sceneType;
+
+    @Schema(description = "布局尺寸")
+    private String size;
+
+    @Schema(description = "状态")
+    private DataState state = DataState.Enable;
+
+}

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

@@ -0,0 +1,84 @@
+package com.zhongshu.card.server.core.controller.scene;
+
+import com.github.microservice.auth.security.annotations.ResourceAuth;
+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.*;
+import com.zhongshu.card.client.type.DataState;
+import com.zhongshu.card.server.core.service.scene.ProjectSceneInfoService;
+import com.zhongshu.card.server.core.service.scene.SceneInfoService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.web.PageableDefault;
+import org.springframework.util.Assert;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.validation.Valid;
+
+/**
+ * @author TRX
+ * @date 2024/6/5
+ */
+@RestController
+@RequestMapping("/projectSceneInfo")
+@Tag(name = "场景--项目场景管理")
+public class ProjectSceneInfoController {
+
+    @Autowired
+    private SceneInfoService sceneInfoService;
+
+    @Autowired
+    private ProjectSceneInfoService projectSceneInfoService;
+
+    @ResourceAuth(value = "user", type = AuthType.User)
+    @Operation(summary = "项目场景列表-分页查询", description = "项目场景列表-分页查询")
+    @RequestMapping(value = {"page"}, method = {RequestMethod.POST})
+    public ResultContent<Page<ProjectSceneInfoModel>> page(@Parameter(hidden = true) @PageableDefault(page = 0, size = 10) Pageable pageable, @Parameter(required = false) ProjectSceneInfoSearch param) {
+        Assert.hasText(param.getProjectOid(), "projectOid不能为空");
+        return projectSceneInfoService.page(param, pageable);
+    }
+
+    @ResourceAuth(value = "user", type = AuthType.User)
+    @Operation(summary = "绑定场景", description = "绑定场景")
+    @RequestMapping(value = "bindScene", method = {RequestMethod.POST})
+    public ResultContent bindScene(@RequestBody @Valid ProjectBindSceneParam param) {
+        return this.projectSceneInfoService.bindScene(param);
+    }
+
+    @ResourceAuth(value = "user", type = AuthType.User)
+    @Operation(summary = "根据场景数据ID 场景详情", description = "根据场景数据ID 场景详情")
+    @RequestMapping(value = "getDetailById", method = {RequestMethod.POST})
+    public ResultContent<ProjectSceneInfoModel> getDetailById(@RequestBody IDParam param) {
+        return this.projectSceneInfoService.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.projectSceneInfoService.deleteById(param.getId());
+    }
+
+    @ResourceAuth(value = "user", type = AuthType.User)
+    @Operation(summary = "禁用场景", description = "禁用场景")
+    @RequestMapping(value = "disableData", method = {RequestMethod.POST})
+    public ResultContent disableData(@RequestBody IDParam param) {
+        return this.projectSceneInfoService.changeState(param.getId(), DataState.Disable);
+    }
+
+    @ResourceAuth(value = "user", type = AuthType.User)
+    @Operation(summary = "启用场景", description = "启用场景")
+    @RequestMapping(value = "enableById", method = {RequestMethod.POST})
+    public ResultContent enableById(@RequestBody IDParam param) {
+        return this.projectSceneInfoService.changeState(param.getId(), DataState.Enable);
+    }
+
+}

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

@@ -0,0 +1,70 @@
+package com.zhongshu.card.server.core.controller.scene;
+
+import com.github.microservice.auth.security.annotations.ResourceAuth;
+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.RoleBindSceneParam;
+import com.zhongshu.card.client.model.scene.RoleSceneInfoModel;
+import com.zhongshu.card.server.core.service.scene.RoleSceneInfoService;
+import com.zhongshu.card.server.core.service.scene.SceneInfoService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.validation.Valid;
+import java.util.List;
+
+/**
+ * @author TRX
+ * @date 2024/6/5
+ */
+@RestController
+@RequestMapping("/roleSceneInfo")
+@Tag(name = "场景--角色场景管理")
+public class RoleSceneInfoController {
+
+    @Autowired
+    private RoleSceneInfoService roleSceneInfoService;
+
+    @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 = "角色绑定场景")
+    @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 = "根据场景数据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})
+    public ResultContent sort(@RequestBody SortParam param) {
+        return this.roleSceneInfoService.sort(param);
+    }
+
+}

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

@@ -0,0 +1,80 @@
+package com.zhongshu.card.server.core.controller.scene;
+
+import com.github.microservice.auth.security.annotations.ResourceAuth;
+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.SceneInfoModel;
+import com.zhongshu.card.client.model.scene.SceneInfoParam;
+import com.zhongshu.card.client.model.scene.SceneInfoSearch;
+import com.zhongshu.card.client.type.DataState;
+import com.zhongshu.card.server.core.service.scene.SceneInfoService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.web.PageableDefault;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.validation.Valid;
+
+/**
+ * @author TRX
+ * @date 2024/6/5
+ */
+@RestController
+@RequestMapping("/sceneInfo")
+@Tag(name = "场景--平台场景管理")
+public class SceneInfoController {
+
+    @Autowired
+    private SceneInfoService sceneInfoService;
+
+    @ResourceAuth(value = "user", type = AuthType.User)
+    @Operation(summary = "场景列表-分页查询", description = "场景列表-分页查询")
+    @RequestMapping(value = {"page"}, method = {RequestMethod.POST})
+    public ResultContent<Page<SceneInfoModel>> page(@Parameter(hidden = true) @PageableDefault(page = 0, size = 10) Pageable pageable, @Parameter(required = false) SceneInfoSearch param) {
+        return sceneInfoService.page(param, pageable);
+    }
+
+    @ResourceAuth(value = "user", type = AuthType.User)
+    @Operation(summary = "添加-编辑场景", description = "添加-编辑场景")
+    @RequestMapping(value = "saveInfo", method = {RequestMethod.POST})
+    public ResultContent saveInfo(@RequestBody @Valid SceneInfoParam param) {
+        return this.sceneInfoService.saveInfo(param);
+    }
+
+    @ResourceAuth(value = "user", type = AuthType.User)
+    @Operation(summary = "根据场景数据ID 场景详情", description = "根据场景数据ID 场景详情")
+    @RequestMapping(value = "getDetailById", method = {RequestMethod.POST})
+    public ResultContent<SceneInfoModel> getDetailById(@RequestBody IDParam param) {
+        return this.sceneInfoService.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.sceneInfoService.deleteById(param.getId());
+    }
+
+    @ResourceAuth(value = "user", type = AuthType.User)
+    @Operation(summary = "禁用场景", description = "禁用场景")
+    @RequestMapping(value = "disableData", method = {RequestMethod.POST})
+    public ResultContent disableData(@RequestBody IDParam param) {
+        return this.sceneInfoService.changeState(param.getId(), DataState.Disable);
+    }
+
+    @ResourceAuth(value = "user", type = AuthType.User)
+    @Operation(summary = "启用场景", description = "启用场景")
+    @RequestMapping(value = "enableById", method = {RequestMethod.POST})
+    public ResultContent enableById(@RequestBody IDParam param) {
+        return this.sceneInfoService.changeState(param.getId(), DataState.Enable);
+    }
+
+}

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

@@ -0,0 +1,20 @@
+package com.zhongshu.card.server.core.dao.scene;
+
+import com.github.microservice.components.data.mongo.mongo.dao.MongoDao;
+import com.zhongshu.card.server.core.dao.scene.extend.ProjectSceneInfoDaoExtend;
+import com.zhongshu.card.server.core.domain.scene.ProjectSceneInfo;
+import com.zhongshu.card.server.core.domain.scene.SceneInfo;
+
+public interface ProjectSceneInfoDao extends MongoDao<ProjectSceneInfo>, ProjectSceneInfoDaoExtend {
+
+    ProjectSceneInfo findTopById(String id);
+
+    ProjectSceneInfo findTopByName(String sceneName);
+
+    ProjectSceneInfo findTopBySceneInfoAndProjectOid(SceneInfo sceneInfo, String projectOid);
+
+    long deleteBySceneInfoId(String sceneInfoId);
+
+    long countBySceneInfoId(String sceneInfoId);
+
+}

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

@@ -0,0 +1,25 @@
+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 java.util.List;
+
+public interface RoleSceneInfoDao extends MongoDao<RoleSceneInfo> {
+
+    RoleSceneInfo findTopById(String id);
+
+    RoleSceneInfo findTopByProjectSceneInfoIdAndRoleId(String projectSceneInfoId, String roleId);
+
+    long countByRoleId(String roleId);
+
+    List<RoleSceneInfo> findByRoleIdOrderBySortAsc(String roleId);
+
+    long deleteByProjectSceneInfoId(String projectSceneInfoId);
+
+    long deleteBySceneInfoId(String sceneInfoId);
+
+    long deleteByRoleId(String roleId);
+
+}

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

@@ -0,0 +1,15 @@
+package com.zhongshu.card.server.core.dao.scene;
+
+import com.github.microservice.components.data.mongo.mongo.dao.MongoDao;
+import com.zhongshu.card.client.type.ShareOrderType;
+import com.zhongshu.card.server.core.dao.scene.extend.SceneInfoDaoExtend;
+import com.zhongshu.card.server.core.domain.pay.ShareOrder;
+import com.zhongshu.card.server.core.domain.scene.SceneInfo;
+
+public interface SceneInfoDao extends MongoDao<SceneInfo>, SceneInfoDaoExtend {
+
+    SceneInfo findTopById(String id);
+
+    SceneInfo findTopByName(String sceneName);
+
+}

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

@@ -0,0 +1,19 @@
+package com.zhongshu.card.server.core.dao.scene.extend;
+
+import com.zhongshu.card.client.model.scene.ProjectSceneInfoSearch;
+import com.zhongshu.card.client.model.scene.SceneInfoSearch;
+import com.zhongshu.card.server.core.domain.scene.ProjectSceneInfo;
+import com.zhongshu.card.server.core.domain.scene.SceneInfo;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/7/7
+ * @Version: 1.0
+ */
+public interface ProjectSceneInfoDaoExtend {
+
+    Page<ProjectSceneInfo> page(Pageable pageable, ProjectSceneInfoSearch param);
+
+}

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

@@ -0,0 +1,17 @@
+package com.zhongshu.card.server.core.dao.scene.extend;
+
+import com.zhongshu.card.client.model.scene.SceneInfoSearch;
+import com.zhongshu.card.server.core.domain.scene.SceneInfo;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/7/7
+ * @Version: 1.0
+ */
+public interface SceneInfoDaoExtend {
+
+    Page<SceneInfo> page(Pageable pageable, SceneInfoSearch param);
+
+}

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

@@ -0,0 +1,82 @@
+package com.zhongshu.card.server.core.dao.scene.impl;
+
+import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.zhongshu.card.client.model.scene.ProjectSceneInfoSearch;
+import com.zhongshu.card.client.model.scene.SceneInfoSearch;
+import com.zhongshu.card.server.core.dao.BaseImpl;
+import com.zhongshu.card.server.core.dao.scene.ProjectSceneInfoDao;
+import com.zhongshu.card.server.core.dao.scene.extend.ProjectSceneInfoDaoExtend;
+import com.zhongshu.card.server.core.dao.scene.extend.SceneInfoDaoExtend;
+import com.zhongshu.card.server.core.domain.scene.ProjectSceneInfo;
+import com.zhongshu.card.server.core.domain.scene.SceneInfo;
+import com.zhongshu.card.server.core.util.CommonUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/4/12
+ * @Version: 1.0
+ */
+public class ProjectSceneInfoDaoImpl extends BaseImpl implements ProjectSceneInfoDaoExtend {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private DBHelper dbHelper;
+
+    @Override
+    public Page<ProjectSceneInfo> page(Pageable pageable, ProjectSceneInfoSearch param) {
+        param.setOid("");
+        Criteria criteria = buildCriteria(param);
+
+        if (param.getSceneType() != null) {
+            criteria.and("sceneType").is(param.getSceneType());
+        }
+
+        if (param.getState() != null) {
+            criteria.and("state").is(param.getState());
+        }
+
+        if (!CommonUtil.longIsEmpty(param.getStartTime()) && !CommonUtil.longIsEmpty(param.getEndTime())) {
+            criteria.and("createTime").gte(param.getStartTime()).and("createTime").lte(param.getEndTime());
+        }
+
+        if (StringUtils.isNotEmpty(param.getSceneInfoId())) {
+            criteria.and("sceneInfoId").is(param.getSceneInfoId());
+        }
+
+        if (StringUtils.isNotEmpty(param.getProjectOid())) {
+            criteria.and("projectOid").is(param.getProjectOid());
+        }
+
+        // 模糊搜索
+        List<Criteria> criterias = new ArrayList<>();
+        if (StringUtils.isNotEmpty(param.getName())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getName() + ".*$");
+            criterias.add(Criteria.where("name").is(pattern));
+        }
+
+        if (!CollectionUtils.isEmpty(criterias)) {
+            criteria.andOperator(criterias.toArray(new Criteria[]{}));
+        }
+
+        Sort sort = buildSort(param);
+        Query query = Query.query(criteria);
+        query.with(sort);
+        return dbHelper.pages(query, pageable, ProjectSceneInfo.class);
+    }
+
+}

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

@@ -0,0 +1,74 @@
+package com.zhongshu.card.server.core.dao.scene.impl;
+
+import com.github.microservice.components.data.mongo.mongo.helper.DBHelper;
+import com.zhongshu.card.client.model.scene.SceneInfoSearch;
+import com.zhongshu.card.server.core.dao.BaseImpl;
+import com.zhongshu.card.server.core.dao.scene.extend.SceneInfoDaoExtend;
+import com.zhongshu.card.server.core.domain.scene.SceneInfo;
+import com.zhongshu.card.server.core.util.CommonUtil;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+/**
+ * @Author TRX
+ * @CreateDate: 2023/4/12
+ * @Version: 1.0
+ */
+public class SceneInfoDaoImpl extends BaseImpl implements SceneInfoDaoExtend {
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private DBHelper dbHelper;
+
+    @Override
+    public Page<SceneInfo> page(Pageable pageable, SceneInfoSearch param) {
+        param.setOid("");
+        Criteria criteria = buildCriteria(param);
+
+        if (param.getSceneType() != null) {
+            criteria.and("sceneType").is(param.getSceneType());
+        }
+
+        if (param.getSize() != null) {
+            criteria.and("size").is(param.getSize());
+        }
+
+        if (param.getState() != null) {
+            criteria.and("state").is(param.getState());
+        }
+
+        if (!CommonUtil.longIsEmpty(param.getStartTime()) && !CommonUtil.longIsEmpty(param.getEndTime())) {
+            criteria.and("createTime").gte(param.getStartTime()).and("createTime").lte(param.getEndTime());
+        }
+
+        // 模糊搜索
+        List<Criteria> criterias = new ArrayList<>();
+        if (StringUtils.isNotEmpty(param.getName())) {
+            Pattern pattern = Pattern.compile("^.*" + param.getName() + ".*$");
+            criterias.add(Criteria.where("name").is(pattern));
+        }
+
+        if (!CollectionUtils.isEmpty(criterias)) {
+            criteria.andOperator(criterias.toArray(new Criteria[]{}));
+        }
+
+        Sort sort = buildSort(param);
+        Query query = Query.query(criteria);
+        query.with(sort);
+        return dbHelper.pages(query, pageable, SceneInfo.class);
+    }
+
+}

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

@@ -0,0 +1,48 @@
+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 io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.springframework.data.mongodb.core.mapping.DBRef;
+import org.springframework.data.mongodb.core.mapping.Document;
+
+/**
+ * 项目引用场景
+ *
+ * @author TRX
+ * @date 2024/11/22
+ */
+@Data
+@Builder
+@Document
+@AllArgsConstructor
+@NoArgsConstructor
+public class ProjectSceneInfo extends SuperMain {
+
+    //-------------------场景信息 start -------------------
+    @Schema(description = "场景数据")
+    @DBRef(lazy = true)
+    private SceneInfo sceneInfo;
+
+    @Schema(description = "关联的数据ID")
+    private String sceneInfoId;
+
+    @Schema(description = "场景名称")
+    private String name;
+
+    @Schema(description = "类型")
+    private SceneType sceneType;
+
+    @Schema(description = "外面的状态")
+    private DataState sceneState;
+    //-------------------场景信息 end --------------------
+
+    @Schema(description = "状态")
+    private DataState state = DataState.Enable;
+
+}

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

@@ -0,0 +1,48 @@
+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;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.springframework.data.mongodb.core.mapping.DBRef;
+import org.springframework.data.mongodb.core.mapping.Document;
+
+/**
+ * 项目引用场景
+ *
+ * @author TRX
+ * @date 2024/11/22
+ */
+@Data
+@Builder
+@Document
+@AllArgsConstructor
+@NoArgsConstructor
+public class RoleSceneInfo extends SuperMain {
+
+    @Schema(description = "场景数据")
+    @DBRef(lazy = true)
+    private SceneInfo sceneInfo;
+
+    @Schema(description = "关联的数据ID")
+    private String sceneInfoId;
+
+    @Schema(description = "项目管理的数据")
+    @DBRef(lazy = true)
+    private ProjectSceneInfo projectSceneInfo;
+
+    @Schema(description = "项目管理的场景ID")
+    private String projectSceneInfoId;
+
+    @Schema(description = "场景数据")
+    @DBRef(lazy = true)
+    private Role role;
+
+    @Schema(description = "角色ID")
+    private String roleId;
+}

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

@@ -23,19 +23,19 @@ import org.springframework.data.mongodb.core.mapping.Document;
 @NoArgsConstructor
 public class SceneInfo extends SuperMain {
 
-    @Schema(description = "")
+    @Schema(description = "场景名称")
     private String name;
 
-    @Schema(description = "")
+    @Schema(description = "图标")
     private String logo;
 
-    @Schema(description = "")
+    @Schema(description = "类型")
     private SceneType sceneType;
 
-    @Schema(description = "")
+    @Schema(description = "布局尺寸")
     private String size;
 
-    @Schema(description = "")
-    private DataState state;
+    @Schema(description = "状态")
+    private DataState state = DataState.Enable;
 
 }

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

@@ -0,0 +1,177 @@
+package com.zhongshu.card.server.core.service.scene;
+
+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.ProjectSceneInfoModel;
+import com.zhongshu.card.client.model.scene.ProjectSceneInfoSearch;
+import com.zhongshu.card.client.type.DataState;
+import com.zhongshu.card.server.core.dao.org.OrganizationDao;
+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.SceneInfoDao;
+import com.zhongshu.card.server.core.domain.org.Organization;
+import com.zhongshu.card.server.core.domain.scene.ProjectSceneInfo;
+import com.zhongshu.card.server.core.domain.scene.SceneInfo;
+import com.zhongshu.card.server.core.service.base.CommonService;
+import com.zhongshu.card.server.core.service.base.SuperService;
+import com.zhongshu.card.server.core.util.BeanUtils;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.ObjectUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author TRX
+ * @date 2024/11/22
+ */
+@Slf4j
+@Service
+public class ProjectSceneInfoService extends SuperService {
+
+    @Autowired
+    private SceneInfoDao sceneInfoDao;
+
+    @Autowired
+    private ProjectSceneInfoDao projectSceneInfoDao;
+
+    @Autowired
+    private RoleSceneInfoDao roleSceneInfoDao;
+
+    @Autowired
+    private OrganizationDao organizationDao;
+
+    @Autowired
+    private SceneInfoService sceneInfoService;
+
+    @Autowired
+    private RoleSceneInfoService roleSceneInfoService;
+
+    @Autowired
+    private CommonService commonService;
+
+    public ResultContent bindScene(ProjectBindSceneParam param) {
+        SceneInfo entity = sceneInfoDao.findTopById(param.getId());
+        if (ObjectUtils.isEmpty(entity)) {
+            return ResultContent.buildFail(String.format(ResultMessage.DATA_NOT_EXIST, param.getId()));
+        }
+        Organization organization = organizationDao.findTopByOid(param.getProjectOid());
+        if (ObjectUtils.isEmpty(organization)) {
+            return ResultContent.buildFail("项目不存在");
+        }
+        ProjectSceneInfo projectSceneInfo = projectSceneInfoDao.findTopBySceneInfoAndProjectOid(entity, param.getProjectOid());
+        if (ObjectUtils.isNotEmpty(projectSceneInfo)) {
+            return ResultContent.buildFail(String.format("项目已存在场景：%s", entity.getName()));
+        }
+        projectSceneInfo = new ProjectSceneInfo();
+        projectSceneInfo.setSceneInfo(entity);
+        projectSceneInfo.setSceneInfoId(entity.getId());
+        projectSceneInfo.setName(entity.getName());
+        projectSceneInfo.setSceneType(entity.getSceneType());
+        projectSceneInfo.setSceneState(entity.getState());
+
+        projectSceneInfo.setState(entity.getState());
+        projectSceneInfoDao.save(projectSceneInfo);
+        return ResultContent.buildSuccess();
+    }
+
+    public ResultContent<Page<ProjectSceneInfoModel>> page(ProjectSceneInfoSearch param, Pageable pageable) {
+        Page<ProjectSceneInfo> page = projectSceneInfoDao.page(pageable, param);
+        return ResultContent.buildSuccess(PageEntityUtil.concurrent2PageModel(page, this::toModel));
+    }
+
+    public ResultContent<ProjectSceneInfoModel> getDetailById(String id) {
+        ProjectSceneInfo entity = projectSceneInfoDao.findTopById(id);
+        if (ObjectUtils.isEmpty(entity)) {
+            return ResultContent.buildFail(String.format(ResultMessage.DATA_NOT_EXIST, id));
+        }
+        return ResultContent.buildSuccess(toModel(entity));
+    }
+
+    public ResultContent deleteById(String id) {
+        ProjectSceneInfo entity = projectSceneInfoDao.findTopById(id);
+        if (ObjectUtils.isEmpty(entity)) {
+            return ResultContent.buildFail(String.format(ResultMessage.DATA_NOT_EXIST, id));
+        }
+        // 判断是否可以删除
+        projectSceneInfoDao.delete(entity);
+
+        // 删除关联的信息
+        roleSceneInfoService.deleteByProjectSceneId(entity.getId());
+        return ResultContent.buildSuccess();
+    }
+
+    public ResultContent changeState(String id, DataState state) {
+        ProjectSceneInfo entity = projectSceneInfoDao.findTopById(id);
+        if (ObjectUtils.isEmpty(entity)) {
+            return ResultContent.buildFail(String.format(ResultMessage.DATA_NOT_EXIST, id));
+        }
+        if (state == DataState.Enable) {
+            DataState sceneState = entity.getSceneInfo().getState();
+            if (sceneState == DataState.Disable) {
+                return ResultContent.buildFail("平台上的场景已禁用，不能启用");
+            }
+        }
+        entity.setState(state);
+        projectSceneInfoDao.save(entity);
+        return ResultContent.buildSuccess();
+    }
+
+    public ResultContent changeStateBySceneInfoId(String sceneInfoId, DataState state) {
+        if (StringUtils.isNotEmpty(sceneInfoId)) {
+            Map<String, Object> where = new HashMap<>();
+            where.put("sceneInfoId", sceneInfoId);
+
+            Map<String, Object> standardData = new HashMap<>();
+            standardData.put("sceneState", state);
+
+            commonService.updateData(where, standardData, ProjectSceneInfo.class.getSimpleName());
+        }
+        return ResultContent.buildSuccess();
+    }
+
+    /**
+     * 场景信息发送变化，编辑项目上的关联数据
+     *
+     * @param sceneInfo
+     * @return
+     */
+    public ResultContent updateAllSceneInfo(SceneInfo sceneInfo) {
+        if (ObjectUtils.isNotEmpty(sceneInfo)) {
+            Map<String, Object> where = new HashMap<>();
+            where.put("sceneInfoId", sceneInfo.getId());
+
+            Map<String, Object> standardData = new HashMap<>();
+            standardData.put("name", sceneInfo.getName());
+            standardData.put("sceneType", sceneInfo.getSceneType());
+            standardData.put("sceneState", sceneInfo.getState());
+
+            commonService.updateData(where, standardData, ProjectSceneInfo.class.getSimpleName());
+        }
+        return ResultContent.buildSuccess();
+    }
+
+    public ResultContent deleteBySceneInfoId(String sceneInfoId) {
+        if (ObjectUtils.isNotEmpty(sceneInfoId)) {
+            projectSceneInfoDao.deleteBySceneInfoId(sceneInfoId);
+        }
+        return ResultContent.buildSuccess();
+    }
+
+    public ProjectSceneInfoModel toModel(ProjectSceneInfo entity) {
+        ProjectSceneInfoModel model = new ProjectSceneInfoModel();
+        if (ObjectUtils.isNotEmpty(entity)) {
+            BeanUtils.copyProperties(entity, model);
+            model.setSceneInfo(sceneInfoService.toModel(entity.getSceneInfo()));
+        }
+        return model;
+    }
+
+}

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

@@ -0,0 +1,176 @@
+package com.zhongshu.card.server.core.service.scene;
+
+import com.github.microservice.net.ResultContent;
+import com.github.microservice.net.ResultMessage;
+import com.zhongshu.card.client.model.base.SortParam;
+import com.zhongshu.card.client.model.scene.RoleBindSceneParam;
+import com.zhongshu.card.client.model.scene.RoleSceneInfoModel;
+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.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.service.base.SuperService;
+import com.zhongshu.card.server.core.util.BeanUtils;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.ObjectUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * @author TRX
+ * @date 2024/11/22
+ */
+@Slf4j
+@Service
+public class RoleSceneInfoService extends SuperService {
+
+    @Autowired
+    private SceneInfoDao sceneInfoDao;
+
+    @Autowired
+    private ProjectSceneInfoDao projectSceneInfoDao;
+
+    @Autowired
+    private RoleSceneInfoDao roleSceneInfoDao;
+
+    @Autowired
+    private RoleDao roleDao;
+
+    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("角色不存在");
+        }
+
+        RoleSceneInfo roleSceneInfo = roleSceneInfoDao.findTopByProjectSceneInfoIdAndRoleId(entity.getId(), role.getId());
+        if (ObjectUtils.isNotEmpty(roleSceneInfo)) {
+            return ResultContent.buildFail(String.format("角色已存在场景：%s", entity.getName()));
+        }
+        roleSceneInfo = new RoleSceneInfo();
+        roleSceneInfo.setSceneInfo(entity.getSceneInfo());
+        roleSceneInfo.setSceneInfoId(entity.getId());
+
+        roleSceneInfo.setProjectSceneInfo(entity);
+        roleSceneInfo.setProjectSceneInfoId(entity.getId());
+
+        roleSceneInfo.setRole(role);
+        roleSceneInfo.setRoleId(role.getId());
+
+        long index = roleSceneInfoDao.countByRoleId(role.getId());
+        roleSceneInfo.setSort(index + 1);
+        roleSceneInfoDao.save(roleSceneInfo);
+        return ResultContent.buildSuccess();
+    }
+
+    public ResultContent<List<RoleSceneInfoModel>> list(String roleId) {
+        List<RoleSceneInfoModel> models = new ArrayList<>();
+        List<RoleSceneInfo> list = roleSceneInfoDao.findByRoleIdOrderBySortAsc(roleId);
+        if (ObjectUtils.isNotEmpty(list)) {
+            models = list.stream().map(this::toModel).collect(Collectors.toUnmodifiableList());
+        }
+        return ResultContent.buildSuccess(models);
+    }
+
+    public ResultContent<RoleSceneInfoModel> getDetailById(String id) {
+        RoleSceneInfo entity = roleSceneInfoDao.findTopById(id);
+        if (ObjectUtils.isEmpty(entity)) {
+            return ResultContent.buildFail(String.format(ResultMessage.DATA_NOT_EXIST, id));
+        }
+        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();
+    }
+
+    /**
+     * 数据排序
+     *
+     * @param param
+     * @return
+     */
+    public ResultContent sort(SortParam param) {
+        HashMap<String, Long> data = param.getData();
+        if (data != null && !data.isEmpty()) {
+            List<RoleSceneInfo> list = new ArrayList<>();
+            data.keySet().stream().forEach(it -> {
+                RoleSceneInfo entity = roleSceneInfoDao.findTopById(it);
+                if (ObjectUtils.isNotEmpty(entity)) {
+                    entity.setSort(data.get(it));
+                    list.add(entity);
+                }
+            });
+            if (ObjectUtils.isNotEmpty(list)) {
+                roleSceneInfoDao.saveAll(list);
+            }
+        }
+        return ResultContent.buildSuccess();
+    }
+
+    /**
+     * 根据项目的场景id删除角色的
+     *
+     * @param projectSceneInfoId
+     * @return
+     */
+    public ResultContent deleteByProjectSceneId(String projectSceneInfoId) {
+        if (ObjectUtils.isNotEmpty(projectSceneInfoId)) {
+            roleSceneInfoDao.deleteByProjectSceneInfoId(projectSceneInfoId);
+        }
+        return ResultContent.buildSuccess();
+    }
+
+    /**
+     * 根据平台的场景id删除
+     *
+     * @param sceneInfoId
+     * @return
+     */
+    public ResultContent deleteBySceneInfoId(String sceneInfoId) {
+        if (ObjectUtils.isNotEmpty(sceneInfoId)) {
+            roleSceneInfoDao.deleteBySceneInfoId(sceneInfoId);
+        }
+        return ResultContent.buildSuccess();
+    }
+
+    /**
+     * 根据角色id删除数据
+     *
+     * @param roleId
+     * @return
+     */
+    public ResultContent deleteByRoleId(String roleId) {
+        if (ObjectUtils.isNotEmpty(roleId)) {
+            roleSceneInfoDao.deleteByRoleId(roleId);
+        }
+        return ResultContent.buildSuccess();
+    }
+
+    public RoleSceneInfoModel toModel(RoleSceneInfo entity) {
+        RoleSceneInfoModel model = new RoleSceneInfoModel();
+        if (ObjectUtils.isNotEmpty(entity)) {
+            BeanUtils.copyProperties(entity, model);
+        }
+        return model;
+    }
+
+}

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

@@ -0,0 +1,123 @@
+package com.zhongshu.card.server.core.service.scene;
+
+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.SceneInfoModel;
+import com.zhongshu.card.client.model.scene.SceneInfoParam;
+import com.zhongshu.card.client.model.scene.SceneInfoSearch;
+import com.zhongshu.card.client.type.DataState;
+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.SceneInfoDao;
+import com.zhongshu.card.server.core.domain.scene.ProjectSceneInfo;
+import com.zhongshu.card.server.core.domain.scene.SceneInfo;
+import com.zhongshu.card.server.core.service.base.SuperService;
+import com.zhongshu.card.server.core.util.BeanUtils;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.ObjectUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * @author TRX
+ * @date 2024/11/22
+ */
+@Slf4j
+@Service
+public class SceneInfoService extends SuperService {
+
+    @Autowired
+    private SceneInfoDao sceneInfoDao;
+
+    @Autowired
+    private RoleSceneInfoService roleSceneInfoService;
+
+    @Autowired
+    private ProjectSceneInfoService projectSceneInfoService;
+
+    public ResultContent saveInfo(SceneInfoParam param) {
+        boolean isAdd = true;
+        SceneInfo entity = null;
+        SceneInfo temp = sceneInfoDao.findTopByName(param.getName());
+        if (StringUtils.isNotEmpty(param.getId())) {
+            entity = sceneInfoDao.findTopById(param.getId());
+            if (ObjectUtils.isEmpty(entity)) {
+                return ResultContent.buildFail(String.format(ResultMessage.DATA_NOT_EXIST, param.getId()));
+            }
+            if (ObjectUtils.isNotEmpty(temp) && !temp.getId().equals(entity.getId())) {
+                return ResultContent.buildFail(String.format("名称已存在：%s", param.getName()));
+            }
+            initUpdateEntity(entity);
+            isAdd = false;
+        } else {
+            if (ObjectUtils.isNotEmpty(temp)) {
+                return ResultContent.buildFail(String.format("名称已存在：%s", param.getName()));
+            }
+            entity = new SceneInfo();
+            initEntityNoCheckOid(entity);
+        }
+        BeanUtils.copyPropertiesWithoutNull(param, entity);
+        sceneInfoDao.save(entity);
+
+        // 编辑关联的信息
+        if (!isAdd) {
+            projectSceneInfoService.updateAllSceneInfo(entity);
+        }
+        return ResultContent.buildSuccess();
+    }
+
+    public ResultContent<Page<SceneInfoModel>> page(SceneInfoSearch param, Pageable pageable) {
+        Page<SceneInfo> page = sceneInfoDao.page(pageable, param);
+        return ResultContent.buildSuccess(PageEntityUtil.concurrent2PageModel(page, this::toModel));
+    }
+
+    public ResultContent<SceneInfoModel> getDetailById(String id) {
+        SceneInfo entity = sceneInfoDao.findTopById(id);
+        if (ObjectUtils.isEmpty(entity)) {
+            return ResultContent.buildFail(String.format(ResultMessage.DATA_NOT_EXIST, id));
+        }
+        return ResultContent.buildSuccess(toModel(entity));
+    }
+
+    public ResultContent deleteById(String id) {
+        SceneInfo entity = sceneInfoDao.findTopById(id);
+        if (ObjectUtils.isEmpty(entity)) {
+            return ResultContent.buildFail(String.format(ResultMessage.DATA_NOT_EXIST, id));
+        }
+        // 判断是否可以删除
+        sceneInfoDao.delete(entity);
+
+        // 删除关联的信息
+        projectSceneInfoService.deleteBySceneInfoId(entity.getId());
+        roleSceneInfoService.deleteBySceneInfoId(entity.getId());
+        return ResultContent.buildSuccess();
+    }
+
+    @Transactional
+    public ResultContent changeState(String id, DataState state) {
+        SceneInfo entity = sceneInfoDao.findTopById(id);
+        if (ObjectUtils.isEmpty(entity)) {
+            return ResultContent.buildFail(String.format(ResultMessage.DATA_NOT_EXIST, id));
+        }
+        entity.setState(state);
+        sceneInfoDao.save(entity);
+
+        // 改变项目已绑定的场景状态
+        projectSceneInfoService.changeStateBySceneInfoId(entity.getId(), state);
+        return ResultContent.buildSuccess();
+    }
+
+    public SceneInfoModel toModel(SceneInfo entity) {
+        SceneInfoModel model = new SceneInfoModel();
+        if (ObjectUtils.isNotEmpty(entity)) {
+            BeanUtils.copyProperties(entity, model);
+        }
+        return model;
+    }
+
+}