wangli/tyr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'feature/REQ-2298' into feature/REQ-2186-2298

Browse Source 
# Conflicts:
#	tyr-api/src/main/java/cn/axzo/tyr/client/common/enums/FeatureResourceType.java
#	tyr-api/src/main/java/cn/axzo/tyr/client/model/enums/DictWorkSpaceTypeEnum.java
#	tyr-api/src/main/java/cn/axzo/tyr/client/model/req/ListRoleReq.java
#	tyr-api/src/main/java/cn/axzo/tyr/client/model/req/PageRoleReq.java
#	tyr-server/pom.xml
#	tyr-server/src/main/java/cn/axzo/tyr/server/repository/mapper/SaasFeatureResourceMapper.java
#	tyr-server/src/main/java/cn/axzo/tyr/server/service/impl/FeatureResourceSyncServiceImpl.java
#	tyr-server/src/main/java/cn/axzo/tyr/server/service/impl/SaasFeatureResourceServiceImpl.java
This commit is contained in:
lilong 2024-05-24 17:42:55 +08:00
commit fa2b652d08
116 changed files with 4366 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

130
integration-test/src/test/resources/data-resource.http Normal file
View File

@ -0,0 +1,130 @@
###
POST {{host}}/api/data-resource/create
Accept: application/json
Content-Type: application/json
{
"name": "项目部通讯录列表",
"attrs": [
{
"label": "用户名",
"attr": "name"
},
{
"label": "用户Id",
"attr": "id"
},
{
"label": "手机号",
"attr": "phone"
}
],
"resourceScope": {
"op": "and",
"rules": [{"attr": "dataPermission", "op": "in", "value": ["WORKSPACE_SUPERIOR"]}],
"groups": [
{ "op": "or",
"rules": [{"attr": "dataPermission1", "op": "eq", "value": ["1"]},{"attr": "dataPermission2", "op": "eq", "value": ["1"]}]}
]
},
"resourceCode": "workspaceContact2",
"module": "PROJECT"
}
> reponse-check.js
###
POST {{host}}/api/data-resource/page
Accept: application/json
Content-Type: application/json
{
"page": 1,
"name": "项目部通讯录列表"
}
> reponse-check.js
###
POST {{host}}/api/data-resource/list
Accept: application/json
Content-Type: application/json
{
}
> reponse-check.js
###
POST {{host}}/api/data-resource/update
Accept: application/json
Content-Type: application/json
{
"id": 1,
"attrs": [{"label": "用户名", "attr": "name"}],
"ext": {"c": "测试"},
"resourceScope": [{"attr": "dep", "operation": "in", "value": ["ALL"]}]
}
> reponse-check.js
###
POST {{host}}/api/data-resource/saas-feature
Accept: application/json
Content-Type: application/json
{
"resourceCode": "testCode2",
"featureCodes": ["test"]
}
> reponse-check.js
###
POST {{host}}/api/data-resource/delete
Accept: application/json
Content-Type: application/json
{
"id": 1
}
> reponse-check.js
###
POST {{host}}/api/data-resource/saas-feature/delete
Accept: application/json
Content-Type: application/json
{
"resourceCode": "testCode2",
"featureCodes": ["test"]
}
> reponse-check.js
###
POST {{host}}/api/data-resource/saas-feature
Accept: application/json
Content-Type: application/json
{
"resourceCode": "testCode1",
"featureCodes": ["test"]
}
> reponse-check.js
###
POST {{host}}/api/data-resource/saas-feature/detail
Accept: application/json
Content-Type: application/json
{
"featureCode": "test"
}
> reponse-check.js

37
tyr-api/src/main/java/cn/axzo/tyr/client/common/annotation/RepeatedSubmit.java Normal file
View File

@ -0,0 +1,37 @@
package cn.axzo.tyr.client.common.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 重复提交
**/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RepeatedSubmit {
/**
* 是否加锁,同时只有一人可提交数据.否则每个人同时只能提交一次
*
* @return
*/
boolean unique() default false;
/**
* 支持spEl表达式,自定义key,如果存在自定义key,刚使用自定义key
* unique则无效
*
* @return
*/
String spElKey() default "";
/**
* 重复请求报错信息
* 默认： 请勿重复提交
*/
String msg() default "请勿重复提交";
}

39
tyr-api/src/main/java/cn/axzo/tyr/client/common/enums/AttrPermissionEnum.java Normal file
View File

@ -0,0 +1,39 @@
package cn.axzo.tyr.client.common.enums;
import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.Getter;
import java.util.List;
@Getter
@AllArgsConstructor
public enum AttrPermissionEnum {
SELF_ONLY(1, "仅本人数据"),
SELF_SUBORDINATE(2, "本人及下属数据"),
DEPARTMENT_ONLY(3, "仅本部门数据"),
DEPARTMENT_SUBORDINATE(4, "本部门及以下数据"),
UNIT_ONLY(5, "仅本单位数据"),
UNIT_DIRECT_SUBORDINATE(6, "本单位及下级直属单位数据"),
UNIT_COOPERATE_SUBORDINATE(7, "本单位及下级协同（直属+合作）单位数据"),
UNIT_ALL_SUBORDINATE(8, "本单位及以下协同（直属+合作）单位数据"),
WORKSPACE(9, "本项目部数据"),
EQUAL_TO_ROW(10, "同行级数据权限"),
;
private final Integer value;
private final String desc;
public static List<AttrPermissionEnum> listAttrPermissionForWorkspace() {
return Lists.newArrayList(AttrPermissionEnum.values());
}
public static List<AttrPermissionEnum> listAttrPermissionForNotWorkspace() {
return Lists.newArrayList(SELF_ONLY, SELF_SUBORDINATE,
DEPARTMENT_ONLY, DEPARTMENT_SUBORDINATE, UNIT_ONLY, EQUAL_TO_ROW);
}
}

27
tyr-api/src/main/java/cn/axzo/tyr/client/common/enums/DataResourceModuleEnum.java Normal file
View File

@ -0,0 +1,27 @@
package cn.axzo.tyr.client.common.enums;
import com.baomidou.mybatisplus.annotation.EnumValue;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @author haiyangjin
* @date 2024/1/16
*/
@Getter
@AllArgsConstructor
public enum DataResourceModuleEnum {
/**
* 项目
*/
PROJECT("PROJECT", "项目"),
/**
* 企业
*/
ENTERPRISE("ENTERPRISE", "企业"),
;
@EnumValue
private final String value;
private final String desc;
}

28
tyr-api/src/main/java/cn/axzo/tyr/client/common/enums/DataResourceOperationEnum.java Normal file
View File

@ -0,0 +1,28 @@
package cn.axzo.tyr.client.common.enums;
import com.baomidou.mybatisplus.annotation.EnumValue;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @author haiyangjin
* @date 2024/1/21
*/
@Getter
@AllArgsConstructor
public enum DataResourceOperationEnum {
/**
* 数据资源操作类型：读
*/
READ("READ", "读"),
/**
* 数据资源操作类型：写
*/
WRITE("WRITE", "写"),
;
@EnumValue
private final String value;
private final String desc;
}

28
tyr-api/src/main/java/cn/axzo/tyr/client/common/enums/DataResourceTypeEnum.java Normal file
View File

@ -0,0 +1,28 @@
package cn.axzo.tyr.client.common.enums;
import com.baomidou.mybatisplus.annotation.EnumValue;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @author haiyangjin
* @date 2024/1/16
*/
@Getter
@AllArgsConstructor
public enum DataResourceTypeEnum {
/**
* 数据资源 主对象
*/
MAIN_OBJECT("MAIN_OBJECT", "主对象"),
/**
* 数据资源 子对象
*/
SUB_OBJECT("SUB_OBJECT", "子对象"),
;
@EnumValue
private final String value;
private final String desc;
}

32
tyr-api/src/main/java/cn/axzo/tyr/client/common/enums/EnumTypeEnum.java Normal file
View File

@ -0,0 +1,32 @@
package cn.axzo.tyr.client.common.enums;
import cn.axzo.framework.domain.ServiceException;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 1-租户类型 2-行级权限规则&单位/OMS/政务监管平台的数据权限
* 3-行级权限规则&项目数据权限 4-字段值查看范围&单位/OMS/政务监管平台的数据权限 5-字段值查看范围&项目数据权限
*/
@Getter
@AllArgsConstructor
public enum EnumTypeEnum {
TENANT_SCOPE(1, "租户类型"),
ROW_PERMISSION_AND_NOT_WORKSPACE(2, "行级权限规则&单位/OMS/政务监管平台的数据权限"),
ROW_PERMISSION_AND_WORKSPACE(3, "行级权限规则&项目数据权限"),
ATTR_PERMISSION_AND_NOT_WORKSPACE(4, "字段值查看范围&单位/OMS/政务监管平台的数据权限"),
ATTR_PERMISSION_AND_WORKSPACE(5, "字段值查看范围&项目数据权限"),
;
public final Integer value;
private final String desc;
public static EnumTypeEnum valueOf(Integer type) {
for (EnumTypeEnum enumTypeEnum : EnumTypeEnum.values()) {
if (enumTypeEnum.getValue().equals(type)) {
return enumTypeEnum;
}
}
throw new ServiceException(ReturnCodeEnum.TYPE_UNKNOWN.getMessage());
}
}

1
tyr-api/src/main/java/cn/axzo/tyr/client/common/enums/FeatureResourceType.java
View File

@ -24,6 +24,7 @@ public enum FeatureResourceType {
APP_ENTRY(3, "应用入口"),
COMPONENT(4, "组件"),
ROOT(5, "ROOT"),
GROUP(6, "分组"),
;
private static final Map<Integer, FeatureResourceType> MAPPING = new HashMap<>();

57
tyr-api/src/main/java/cn/axzo/tyr/client/common/enums/ReturnCodeEnum.java Normal file
View File

@ -0,0 +1,57 @@
package cn.axzo.tyr.client.common.enums;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
/**
* 系统返回码枚举类
*
* @author zhaoyong_sh
* @see ReturnCodeEnum
* @since 2021-03-29 18:16
*/
@RequiredArgsConstructor
@Getter
public enum ReturnCodeEnum{
/**
* 系统返回码枚举类
*/
SUCCESS(200, "success"),
INVALID_PARAMETER(400, "无效的请求参数"),
SYSTEM_ERROR(500, "system error"),
RPC_ERROR(601, "rpc error"),
/**
* 业务异常 900--1200
*/
PERMISSION_ERROR(901,"您无此操作权限"),
USER_NOT_FOUND(902, "用户不存在"),
IDENTITY_NOT_FOUND(903, "当前身份错误"),
IDENTITY_QUERY_USER_NOT_FOUND(904, "获取用户信息失败"),
PARAM_NOT_NULL(905, "参数不允许为空"),
DATA_OBJECT_NAME_DUPLICATE(906, "数据对象名重复，请修改对象名"),
DATA_OBJECT_CODE_DUPLICATE(907, "数据对象code重复，请修改对象code"),
DATA_OBJECT_NAME_CODE_DUPLICATE(907, "数据对象名、code均重复，请修改"),
DATA_OBJECT_ATTR_NAME_CODE_DUPLICATE(908, "数据对象字段名或code有重复，请检查"),
DATA_OBJECT_RULE_DUPLICATE(908, "规则名有重复，请检查"),
TYPE_UNKNOWN(909, "未知类型"),
DATA_NOT_EXIST(910, "数据不存在"),
ATTR_NOT_CONSISTENT(911, "对象字段与规则字段不一致"),
DEFAULT_RULE_NULL(912, "默认规则为空"),
;
private final Integer code;
private final String message;
}

47
tyr-api/src/main/java/cn/axzo/tyr/client/common/enums/RowPermissionEnum.java Normal file
View File

@ -0,0 +1,47 @@
package cn.axzo.tyr.client.common.enums;
import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.Getter;
import java.util.List;
/**
* 行级权限规则
*/
@Getter
@AllArgsConstructor
public enum RowPermissionEnum {
SELF_ONLY(1, "仅本人数据"),
SELF_SUBORDINATE(2, "本人及下属数据"),
DEPARTMENT_ONLY(3, "仅本部门数据"),
DEPARTMENT_SUBORDINATE(4, "本部门及以下数据"),
UNIT_ONLY(5, "仅本单位数据"),
UNIT_DIRECT_SUBORDINATE(6, "本单位及下级直属单位数据"),
UNIT_COOPERATE_SUBORDINATE(7, "本单位及下级协同（直属+合作）单位数据"),
UNIT_ALL_SUBORDINATE(8, "本单位及以下协同（直属+合作）单位数据"),
WORKSPACE(9, "本项目部数据"),
;
private final Integer value;
private final String desc;
public static List<RowPermissionEnum> listRowPermissionForWorkspace() {
return Lists.newArrayList(RowPermissionEnum.values());
}
public static List<RowPermissionEnum> listRowPermissionForNotWorkspace() {
return Lists.newArrayList(SELF_ONLY, SELF_SUBORDINATE,
DEPARTMENT_ONLY, DEPARTMENT_SUBORDINATE, UNIT_ONLY);
}
}

21
tyr-api/src/main/java/cn/axzo/tyr/client/common/enums/TenantScopeEnum.java Normal file
View File

@ -0,0 +1,21 @@
package cn.axzo.tyr.client.common.enums;
import cn.axzo.tyr.client.model.enums.DictWorkSpaceTypeEnum;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 租户范围
*/
@Getter
@AllArgsConstructor
public enum TenantScopeEnum {
WORKSPACE(DictWorkSpaceTypeEnum.PROJ.getWorkspaceType(), DictWorkSpaceTypeEnum.PROJ.getTenantScopeDesc()),
OU(DictWorkSpaceTypeEnum.ENT.getWorkspaceType(), DictWorkSpaceTypeEnum.ENT.getTenantScopeDesc()),
OMS(DictWorkSpaceTypeEnum.OMS.getWorkspaceType(), DictWorkSpaceTypeEnum.OMS.getTenantScopeDesc()),
GOVERNMENT(DictWorkSpaceTypeEnum.GOVERNMENT.getWorkspaceType(), DictWorkSpaceTypeEnum.GOVERNMENT.getTenantScopeDesc()),
;
private final Integer value;
private final String desc;
}

14
tyr-api/src/main/java/cn/axzo/tyr/client/common/enums/YesNoEnum.java Normal file
View File

@ -0,0 +1,14 @@
package cn.axzo.tyr.client.common.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public enum YesNoEnum {
YES(2),
NO(1),
;
private final Integer value;
}

66
tyr-api/src/main/java/cn/axzo/tyr/client/feign/DataObjectApi.java Normal file
View File

@ -0,0 +1,66 @@
package cn.axzo.tyr.client.feign;
import cn.axzo.basics.common.page.PageResult;
import cn.axzo.framework.domain.web.result.ApiResult;
import cn.axzo.tyr.client.common.annotation.RepeatedSubmit;
import cn.axzo.tyr.client.model.req.CreateDataObjectReq;
import cn.axzo.tyr.client.model.req.DeleteDataObjectReq;
import cn.axzo.tyr.client.model.req.EditDataObjectReq;
import cn.axzo.tyr.client.model.req.PageDataObjectReq;
import cn.axzo.tyr.client.model.res.DataObjectRes;
import cn.axzo.tyr.client.model.res.EnumRes;
import cn.axzo.tyr.client.model.res.SimpleDataObjectRes;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import javax.validation.Valid;
import java.util.List;
/**
* 数据权限
*/
@FeignClient(name = "tyr", url = "${axzo.service.tyr:http://tyr:8080}")
public interface DataObjectApi {
@PostMapping("/api/dataObject/create")
ApiResult<Long> createDataObject(@RequestBody @Valid CreateDataObjectReq req);
/**
* 修改数据对象
* @param req
* @return
*/
@PostMapping("/api/dataObject/edit")
ApiResult<Void> editDataObject(@RequestBody @Valid EditDataObjectReq req);
@PostMapping("/api/dataObject/delete")
ApiResult<Void> deleteDataObject(@RequestBody @Valid DeleteDataObjectReq req);
/**
* 分页查询数据对象列表
* @param req
* @return
*/
@PostMapping("/api/dataObject/page")
ApiResult<PageResult<SimpleDataObjectRes>> pageDataObject(@RequestBody @Valid PageDataObjectReq req);
/**
* 获取枚举值
* @param type 1-租户类型 2-行级权限规则&单位/OMS/政务监管平台的数据权限 3-行级权限规则&项目数据权限 4-字段值查看范围&单位/OMS/政务监管平台的数据权限 5-字段值查看范围&项目数据权限
* @return
*/
@GetMapping("/api/dataObject/enumerate")
ApiResult<List<EnumRes>> getEnumList(@RequestParam Integer type);
/**
* 查询数据对象
* @param dataObjectId
* @return
*/
@GetMapping("/api/dataObject/get")
ApiResult<DataObjectRes> getDataObject(@RequestParam Long dataObjectId);
}

4
tyr-api/src/main/java/cn/axzo/tyr/client/feign/DataPermissionApi.java
View File

@ -1,6 +1,7 @@
package cn.axzo.tyr.client.feign;
import cn.axzo.framework.domain.web.result.ApiResult;
import cn.axzo.tyr.client.model.req.CreateDataObjectReq;
import cn.axzo.tyr.client.model.req.GetWorkflowQueryAndUpdatePermissionReq;
import cn.axzo.tyr.client.model.res.GetWorkflowQueryAndUpdatePermissionRes;
import org.springframework.cloud.openfeign.FeignClient;
@ -8,6 +9,8 @@ import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import javax.validation.Valid;
/**
* 数据权限API接口
*/
@ -17,5 +20,4 @@ public interface DataPermissionApi {
/** 查询审批流表单查看/编辑权限 **/
@PostMapping(value = "/api/v1/dataPermission/getWorkflowQueryAndUpdatePermission")
ApiResult<GetWorkflowQueryAndUpdatePermissionRes> getWorkflowQueryAndUpdatePermission(@RequestBody @Validated GetWorkflowQueryAndUpdatePermissionReq req);
}

99
tyr-api/src/main/java/cn/axzo/tyr/client/feign/DataResourceApi.java Normal file
View File

@ -0,0 +1,99 @@
package cn.axzo.tyr.client.feign;
import cn.axzo.framework.domain.web.result.ApiPageResult;
import cn.axzo.framework.domain.web.result.ApiResult;
import cn.axzo.tyr.client.model.dataresource.req.CreateDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.DataResourceSaasFeatureParam;
import cn.axzo.tyr.client.model.dataresource.req.DeleteDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.GetSaasFeatureDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.PageDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.SearchDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.UpdateDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.resp.DataResourceResp;
import cn.axzo.tyr.client.model.dataresource.resp.PageDataResourceResp;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import java.util.List;
/**
* @author haiyangjin
* @date 2024/1/13
*/
@FeignClient(name = "tyr", url = "${axzo.service.tyr:http://tyr:8080}")
public interface DataResourceApi {
/**
* 创建数据资源规则
*
* @param param
* @return
*/
@PostMapping(value = "/api/data-resource/create")
ApiResult<Void> create(@RequestBody @Validated CreateDataResourceParam param);
/**
* 更新数据资源规则
*
* @param param
* @return
*/
@PostMapping(value = "/api/data-resource/update")
ApiResult<Boolean> update(@RequestBody @Validated UpdateDataResourceParam param);
/**
* 删除数据资源
*
* @param param
* @return
*/
@PostMapping(value = "/api/data-resource/delete")
ApiResult<Boolean> delete(@RequestBody @Validated DeleteDataResourceParam param);
/**
* 数据资源分页
*
* @param param
* @return
*/
@PostMapping(value = "/api/data-resource/page")
ApiPageResult<PageDataResourceResp> page(@RequestBody @Validated PageDataResourceParam param);
/**
* 数据资源列表
*
* @param param
* @return
*/
@PostMapping(value = "/api/data-resource/list")
ApiResult<List<DataResourceResp>> list(@RequestBody @Validated SearchDataResourceParam param);
/**
* 创建功能点和数据资源的关联
*
* @param param
* @return
*/
@PostMapping(value = "/api/data-resource/saas-feature")
ApiResult<Void> createDataResourceSaasFeature(@RequestBody @Validated DataResourceSaasFeatureParam param);
/**
* 删除功能点和数据资源的关联
*
* @param param
* @return
*/
@PostMapping(value = "/api/data-resource/saas-feature/delete")
ApiResult<Boolean> deleteDataResourceSaasFeature(@RequestBody @Validated DataResourceSaasFeatureParam param);
/**
* 获取某个功能点的数据资源信息
*
* @param param
* @return
*/
@PostMapping(value = "/api/data-resource/saas-feature/detail")
ApiResult<List<DataResourceResp>> getSaasFeatureDataResource(@RequestBody @Validated GetSaasFeatureDataResourceParam param);
}

11
tyr-api/src/main/java/cn/axzo/tyr/client/feign/TyrSaasRoleUserApi.java
View File

@ -3,6 +3,7 @@ package cn.axzo.tyr.client.feign;
import cn.axzo.framework.domain.web.result.ApiPageResult;
import cn.axzo.framework.domain.web.result.ApiResult;
import cn.axzo.tyr.client.model.roleuser.dto.GetUserAutoOwnRoleResp;
import cn.axzo.tyr.client.model.roleuser.dto.GetUserFeatureResourceIdsResp;
import cn.axzo.tyr.client.model.roleuser.dto.SaasRoleUserDTO;
import cn.axzo.tyr.client.model.roleuser.dto.SuperAminInfoResp;
import cn.axzo.tyr.client.model.roleuser.req.*;
@ -106,11 +107,17 @@ public interface TyrSaasRoleUserApi {
* 保存/更新 用户自定义权限，每次传入新的featureIds都会覆盖原来的所有featureIds
*/
@PostMapping("/api/saas-role-user/save-or-update-auto-own-role")
ApiResult<Void> saveOrUpdateAutoOwnRole(@RequestBody @Valid AutoOwnRoleUserReq req);
ApiResult<Void> saveOrUpdateAutoOwnRole(@RequestBody @Valid AutoOwnRoleUserReq req);
/**
* 查询用户自定义角色和权限
*/
@PostMapping("/api/saas-role-user/get-auto-own-role")
ApiResult<GetUserAutoOwnRoleResp> getUserAutoOwnRole(@RequestBody @Valid GetUserAutoOwnRoleReq req);
ApiResult<GetUserAutoOwnRoleResp> getUserAutoOwnRole(@RequestBody @Valid GetUserAutoOwnRoleReq req);
/**
* 查询用户权限（featureResourceId）
*/
@PostMapping("/api/saas-role-user/get-user-feature-resource-ids")
ApiResult<GetUserFeatureResourceIdsResp> getUserFeatureResourceIds(@RequestBody @Valid GetUserFeatureResourceIdsReq req);
}

27
tyr-api/src/main/java/cn/axzo/tyr/client/model/data/object/AttributeBO.java Normal file
View File

@ -0,0 +1,27 @@
package cn.axzo.tyr.client.model.data.object;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class AttributeBO {
/**
* 数据对象属性id
*/
private Long dataObjectAttrId;
private Integer sort; // 序号
private String attrName; //字段名
private String attrCode; // 字段code
private Integer unmaskSupport; // 是否支持脱敏 1-不支持 2-支持
private Integer editSupport; // 是否支持编辑 1-不支持 2-支持
}

21
tyr-api/src/main/java/cn/axzo/tyr/client/model/data/object/AttributePermissionBO.java Normal file
View File

@ -0,0 +1,21 @@
package cn.axzo.tyr.client.model.data.object;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class AttributePermissionBO {
private Integer sort; // 序号
private String attrName; //字段名
private String attrCode; // 字段code
private Integer visibilityScope; // 字段值查看范围 1:仅本人数据 2:本人及下属数据 3:仅本部门数据 4:本部门及以下数据 5:仅本单位数据 6:本单位及下级直属单位数据 7:本单位及下级协同（直属+合作）单位数据 8:本单位及以下协同（直属+合作）单位数据 9:本项目部数据 10:同行级数据权限
private Integer isUnmaskable; // 是否可脱敏 1-不可操作脱敏 2-可操作脱敏
private Integer isEditable; // 是否可编辑 1-不可编辑 2-可编辑
}

32
tyr-api/src/main/java/cn/axzo/tyr/client/model/data/object/DataObjectAttrQueryBO.java Normal file
View File

@ -0,0 +1,32 @@
package cn.axzo.tyr.client.model.data.object;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.util.List;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class DataObjectAttrQueryBO {
/**
* 数据对象id
*/
private Long dataObjectId;
/**
* 数据对象属性id
*/
private Long dataObjectAttrId;
private Integer sort; // 序号
private String attrName; //字段名
private List<String> attrNameList; //字段名List
private String attrCode; // 字段code
private List<String> attrCodeList; // 字段codeList
private Integer unmaskSupport; // 是否支持脱敏 1-不支持 2-支持
private Integer editSupport; // 是否支持编辑 1-不支持 2-支持
}

30
tyr-api/src/main/java/cn/axzo/tyr/client/model/data/object/DataObjectQueryBO.java Normal file
View File

@ -0,0 +1,30 @@
package cn.axzo.tyr.client.model.data.object;
import cn.axzo.core.domain.PageRequest;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class DataObjectQueryBO extends PageRequest {
/**
* 数据权限code
*/
private String dataObjectCode;
/**
* 数据权限名 全局唯一
*/
private String dataObjectName;
private Integer tenantScope;
/**
* 排序 （从小到大）
*/
private Integer sort;
}

53
tyr-api/src/main/java/cn/axzo/tyr/client/model/data/object/DataObjectRuleBO.java Normal file
View File

@ -0,0 +1,53 @@
package cn.axzo.tyr.client.model.data.object;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import java.util.List;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class DataObjectRuleBO {
/**
* 排序 （从小到大）
*/
private Integer sort;
/**
* 数据对象规则id
*/
private Long dataObjectRuleId;
/**
* 规则名称
*/
@NotEmpty(message = "请输入规则名称")
private String dataObjectRuleName;
/**
* 规则范围 1：岗位 2：角色
*/
@NotNull(message = "请选择规则范围")
private Integer ruleScopeType;
/**
* 岗位/角色id
*/
private List<Long> relationId;
/**
* 行级数据权限（单选） 1:仅本人数据 2:本人及下属数据 3:仅本部门数据 4:本部门及以下数据
* 5:仅本单位数据 6:本单位及下级直属单位数据 7:本单位及下级协同（直属+合作）单位数据 8:本单位及以下协同（直属+合作）单位数据 9:本项目部数据
*/
private Integer rowPermission;
/**
* 字段级权限规则
*/
private List<AttributePermissionBO> attributePermissionBOList;
}

26
tyr-api/src/main/java/cn/axzo/tyr/client/model/data/object/DataObjectRuleQueryBO.java Normal file
View File

@ -0,0 +1,26 @@
package cn.axzo.tyr.client.model.data.object;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import javax.validation.constraints.NotEmpty;
import java.util.List;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class DataObjectRuleQueryBO {
/**
* 数据对象id
*/
private Long dataObjectId;
/**
* 规则名称List
*/
private List<String> dataObjectRuleNameList;
}

44
tyr-api/src/main/java/cn/axzo/tyr/client/model/data/object/DefaultDataObjectRuleBO.java Normal file
View File

@ -0,0 +1,44 @@
package cn.axzo.tyr.client.model.data.object;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.util.List;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class DefaultDataObjectRuleBO {
/**
* 数据对象规则id
*/
private Long dataObjectRuleId;
/**
* 规则名称
*/
private String dataObjectRuleName;
/**
* 规则范围 1：岗位 2：角色
*/
private Integer ruleScopeType;
/**
* 岗位/角色id
*/
private List<Long> relationId;
/**
* 行级数据权限（单选） 1:仅本人数据 2:本人及下属数据 3:仅本部门数据 4:本部门及以下数据
* 5:仅本单位数据 6:本单位及下级直属单位数据 7:本单位及下级协同（直属+合作）单位数据 8:本单位及以下协同（直属+合作）单位数据 9:本项目部数据
*/
private Integer rowPermission;
/**
* 字段级权限规则
*/
private List<AttributePermissionBO> attributePermissionBOList;
}

18
tyr-api/src/main/java/cn/axzo/tyr/client/model/data/object/RuleAttrQueryBO.java Normal file
View File

@ -0,0 +1,18 @@
package cn.axzo.tyr.client.model.data.object;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.util.List;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class RuleAttrQueryBO {
private Long dataObjectId;
}

16
tyr-api/src/main/java/cn/axzo/tyr/client/model/data/object/RuleScopeQueryBO.java Normal file
View File

@ -0,0 +1,16 @@
package cn.axzo.tyr.client.model.data.object;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class RuleScopeQueryBO {
private Long dataObjectId;
}

25
tyr-api/src/main/java/cn/axzo/tyr/client/model/dataresource/DataResourceAttrs.java Normal file
View File

@ -0,0 +1,25 @@
package cn.axzo.tyr.client.model.dataresource;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author haiyangjin
* @date 2024/1/15
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class DataResourceAttrs {
/**
* 属性Code
*/
private String attr;
/**
* label 显示的名字
*/
private String label;
}

33
tyr-api/src/main/java/cn/axzo/tyr/client/model/dataresource/DataResourceRuleDTO.java Normal file
View File

@ -0,0 +1,33 @@
package cn.axzo.tyr.client.model.dataresource;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
/**
* @author haiyangjin
* @date 2024/1/21
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class DataResourceRuleDTO {
/**
* 属性
*/
private String attr;
/**
* 操作符
*/
private String op;
/**
* 属性值
*/
private List<String> value;
}

33
tyr-api/src/main/java/cn/axzo/tyr/client/model/dataresource/ResourceScope.java Normal file
View File

@ -0,0 +1,33 @@
package cn.axzo.tyr.client.model.dataresource;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
/**
* @author haiyangjin
* @date 2024/1/15
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ResourceScope {
/**
* 属性
*/
private List<DataResourceRuleDTO> rules;
/**
* 操作符 and 或者 or
*/
private String op;
/**
* 属性值
*/
private List<ResourceScope> groups;
}

33
tyr-api/src/main/java/cn/axzo/tyr/client/model/dataresource/UserScope.java Normal file
View File

@ -0,0 +1,33 @@
package cn.axzo.tyr.client.model.dataresource;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
/**
* @author haiyangjin
* @date 2024/1/19
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class UserScope {
/**
* 用户属性
*/
private List<UserScopeRuleDTO> rules;
/**
* 操作符 and 或者 or
*/
private String op;
/**
* 属性值
*/
private List<UserScope> groups;
}

33
tyr-api/src/main/java/cn/axzo/tyr/client/model/dataresource/UserScopeRuleDTO.java Normal file
View File

@ -0,0 +1,33 @@
package cn.axzo.tyr.client.model.dataresource;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
/**
* @author haiyangjin
* @date 2024/1/21
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class UserScopeRuleDTO {
/**
* 属性
*/
private String attr;
/**
* 操作符
*/
private String op;
/**
* 属性值
*/
private List<String> value;
}

84
tyr-api/src/main/java/cn/axzo/tyr/client/model/dataresource/req/CreateDataResourceParam.java Normal file
View File

@ -0,0 +1,84 @@
package cn.axzo.tyr.client.model.dataresource.req;
import cn.axzo.tyr.client.common.enums.DataResourceModuleEnum;
import cn.axzo.tyr.client.common.enums.DataResourceOperationEnum;
import cn.axzo.tyr.client.common.enums.DataResourceTypeEnum;
import cn.axzo.tyr.client.model.dataresource.DataResourceAttrs;
import cn.axzo.tyr.client.model.dataresource.ResourceScope;
import cn.axzo.tyr.client.model.dataresource.UserScope;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Builder.Default;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.util.List;
import java.util.Map;
/**
* @author haiyangjin
* @date 2024/1/13
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class CreateDataResourceParam {
/**
* 数据对象名称
*/
@NotBlank(message = "数据资源名称不能为空")
private String name;
/**
* 模块名称 @see DataResourceModuleEnum
*/
@NotNull(message = "数据资源所属模块不能为空")
private DataResourceModuleEnum module;
/**
* 数据对象code
*/
@NotBlank(message = "数据资源code不能为空")
private String resourceCode;
/**
* 对象属性例如：[{"attr": "name", "label": "名字"}]
*/
private List<DataResourceAttrs> attrs;
/**
* 数据范围
*/
private ResourceScope resourceScope;
/**
* 用户范围
*/
private UserScope userScope;
/**
* 数据资源类型0:主对象1:子对象
* @see DataResourceTypeEnum
*/
private DataResourceTypeEnum type;
/**
* 数据资源操作类型
* @see DataResourceOperationEnum
*/
@Default
private DataResourceOperationEnum operation = DataResourceOperationEnum.READ;
/**
* 数据对象code
*/
private Map ext;
/**
* 父对象ID
*/
private Long parentId;
}

32
tyr-api/src/main/java/cn/axzo/tyr/client/model/dataresource/req/DataResourceSaasFeatureParam.java Normal file
View File

@ -0,0 +1,32 @@
package cn.axzo.tyr.client.model.dataresource.req;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotEmpty;
import java.util.List;
/**
* @author haiyangjin
* @date 2024/1/15
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class DataResourceSaasFeatureParam {
/**
* 数据对象code
*/
@NotBlank(message = "数据资源code不能为空")
private String resourceCode;
/**
* featureCode
*/
@NotEmpty(message = "数据资源code不能为空")
private List<String> featureCodes;
}

24
tyr-api/src/main/java/cn/axzo/tyr/client/model/dataresource/req/DeleteDataResourceParam.java Normal file
View File

@ -0,0 +1,24 @@
package cn.axzo.tyr.client.model.dataresource.req;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotNull;
/**
* @author haiyangjin
* @date 2024/1/16
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class DeleteDataResourceParam {
/**
* 主键ID
*/
@NotNull(message = "主键ID不能为空")
private Long id;
}

24
tyr-api/src/main/java/cn/axzo/tyr/client/model/dataresource/req/GetSaasFeatureDataResourceParam.java Normal file
View File

@ -0,0 +1,24 @@
package cn.axzo.tyr.client.model.dataresource.req;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotBlank;
/**
* @author haiyangjin
* @date 2024/1/15
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GetSaasFeatureDataResourceParam {
/**
* featureCode
*/
@NotBlank(message = "featureCode 不能是空字符！")
private String featureCode;
}

47
tyr-api/src/main/java/cn/axzo/tyr/client/model/dataresource/req/PageDataResourceParam.java Normal file
View File

@ -0,0 +1,47 @@
package cn.axzo.tyr.client.model.dataresource.req;
import cn.axzo.core.domain.PageRequest;
import cn.axzo.tyr.client.common.enums.DataResourceModuleEnum;
import cn.axzo.tyr.client.common.enums.DataResourceTypeEnum;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
/**
* @author haiyangjin
* @date 2024/1/16
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class PageDataResourceParam extends PageRequest {
/**
* 数据资源code列表
*/
private List<String> resourceCodes;
/**
* 名称
*/
private String name;
/**
* 模块名称
*/
private DataResourceModuleEnum module;
/**
* 数据对象类型0:主对象1:子对象
* @see DataResourceTypeEnum
*/
private DataResourceTypeEnum type;
/**
* 父对象ID
*/
private Long parentId;
}

23
tyr-api/src/main/java/cn/axzo/tyr/client/model/dataresource/req/SearchDataResourceParam.java Normal file
View File

@ -0,0 +1,23 @@
package cn.axzo.tyr.client.model.dataresource.req;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
/**
* @author haiyangjin
* @date 2024/1/15
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class SearchDataResourceParam {
/**
* 数据资源code列表
*/
private List<String> resourceCodes;
}

65
tyr-api/src/main/java/cn/axzo/tyr/client/model/dataresource/req/UpdateDataResourceParam.java Normal file
View File

@ -0,0 +1,65 @@
package cn.axzo.tyr.client.model.dataresource.req;
import cn.axzo.tyr.client.common.enums.DataResourceModuleEnum;
import cn.axzo.tyr.client.common.enums.DataResourceTypeEnum;
import cn.axzo.tyr.client.model.dataresource.DataResourceAttrs;
import cn.axzo.tyr.client.model.dataresource.ResourceScope;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotNull;
import java.util.List;
import java.util.Map;
/**
* @author haiyangjin
* @date 2024/1/15
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class UpdateDataResourceParam {
/**
* 主键ID
*/
@NotNull(message = "主键ID不能为空")
private Long id;
/**
* 数据对象名称
*/
private String name;
/**
* 对象属性例如：[{"attr": "name", "label": "名字"}]
*/
private List<DataResourceAttrs> attrs;
/**
* 数据范围
*/
private List<ResourceScope> resourceScope;
/**
* 数据对象类型0:主对象1:子对象
*/
private DataResourceTypeEnum type;
/**
* 模块名称 eg. 企业：enterprise, 项目：project
*/
private DataResourceModuleEnum module;
/**
* 扩展信息
*/
private Map ext;
/**
* 父对象ID
*/
private Long parentId;
}

81
tyr-api/src/main/java/cn/axzo/tyr/client/model/dataresource/resp/DataResourceResp.java Normal file
View File

@ -0,0 +1,81 @@
package cn.axzo.tyr.client.model.dataresource.resp;
import cn.axzo.tyr.client.common.enums.DataResourceModuleEnum;
import cn.axzo.tyr.client.common.enums.DataResourceOperationEnum;
import cn.axzo.tyr.client.common.enums.DataResourceTypeEnum;
import cn.axzo.tyr.client.model.dataresource.DataResourceAttrs;
import cn.axzo.tyr.client.model.dataresource.ResourceScope;
import cn.axzo.tyr.client.model.dataresource.UserScope;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
/**
* @author haiyangjin
* @date 2024/1/15
*/
@Data
@SuperBuilder
@AllArgsConstructor
@NoArgsConstructor
public class DataResourceResp implements Serializable {
/**
* 主键ID
*/
private Long id;
/**
* 数据对象名称
*/
private String name;
/**
* 数据对象操作类型
*/
private DataResourceOperationEnum operation;
/**
* 模块名称 eg. 企业：ENTERPRISE, 项目：PROJECT
*/
private DataResourceModuleEnum module;
/**
* 数据资源code
*/
private String resourceCode;
/**
* 对象属性例如：[{"attr": "name", "label": "名字"}]
*/
private List<DataResourceAttrs> attrs;
/**
* 数据范围
*/
private List<ResourceScope> resourceScope;
/**
* 用户范围
*/
private List<UserScope> userScope;
/**
* 数据对象类型0:主对象1:子对象
*/
private DataResourceTypeEnum type;
/**
* 扩展信息
*/
private Map ext;
/**
* 父对象ID
*/
private Long parentId;
}

18
tyr-api/src/main/java/cn/axzo/tyr/client/model/dataresource/resp/PageDataResourceResp.java Normal file
View File

@ -0,0 +1,18 @@
package cn.axzo.tyr.client.model.dataresource.resp;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @author haiyangjin
* @date 2024/1/16
*/
@Data
@SuperBuilder
@AllArgsConstructor
@NoArgsConstructor
public class PageDataResourceResp extends DataResourceResp {
private String description;
}

72
tyr-api/src/main/java/cn/axzo/tyr/client/model/req/CreateDataObjectReq.java Normal file
View File

@ -0,0 +1,72 @@
package cn.axzo.tyr.client.model.req;
import cn.axzo.tyr.client.model.data.object.AttributeBO;
import cn.axzo.tyr.client.model.data.object.DataObjectRuleBO;
import cn.axzo.tyr.client.model.data.object.DefaultDataObjectRuleBO;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.Valid;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import java.util.List;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class CreateDataObjectReq {
/**
* 数据对象code
*/
@NotEmpty(message = "请输入数据对象code")
private String dataObjectCode;
/**
* 数据对象名 全局唯一
*/
@NotNull(message = "请输入数据对象名")
@Size(min = 1, max = 10,message = "请输入数据对象名")
private String dataObjectName;
/**
* 备注
*/
private String memo;
/**
* 租户类型 2：项目租户 1：单位租户 6:OMS 3:政务监管平台
*/
@NotNull(message = "请选择租户范围")
private Integer tenantScope;
/**
* 字段
*/
private List<AttributeBO> attrs;
/**
* 默认规则
*/
@NotNull(message = "默认规则必须存在")
private DefaultDataObjectRuleBO defaultDataObjectRuleBO;
/**
* 自定义规则
*/
@Valid
private List<DataObjectRuleBO> dataObjectRuleBOList;
/**
* 排序 （从小到大）
*/
private Integer sort;
/**
* 创建人自然人id
*/
private Long createBy;
/**
* 修改人自然人id
*/
private Long updateBy;
}

20
tyr-api/src/main/java/cn/axzo/tyr/client/model/req/DeleteDataObjectReq.java Normal file
View File

@ -0,0 +1,20 @@
package cn.axzo.tyr.client.model.req;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.web.bind.annotation.RequestParam;
import javax.validation.constraints.NotNull;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class DeleteDataObjectReq {
@NotNull(message = "请选择要删除的数据对象")
private Long dataObjectId;
private Long updateBy;
}

71
tyr-api/src/main/java/cn/axzo/tyr/client/model/req/EditDataObjectReq.java Normal file
View File

@ -0,0 +1,71 @@
package cn.axzo.tyr.client.model.req;
import cn.axzo.tyr.client.model.data.object.AttributeBO;
import cn.axzo.tyr.client.model.data.object.DataObjectRuleBO;
import cn.axzo.tyr.client.model.data.object.DefaultDataObjectRuleBO;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import java.util.List;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class EditDataObjectReq {
/**
* 数据对象id
*/
@NotNull(message = "请选择要修改的数据对象")
private Long dataObjectId;
/**
* 数据对象名 全局唯一
*/
@NotNull(message = "请输入数据对象名")
@Size(min = 1, max = 10,message = "请输入数据对象名")
private String dataObjectName;
/**
* 备注
*/
private String memo;
/**
* 租户类型 2：项目租户 1：单位租户 6:OMS 3:政务监管平台
*/
private Integer tenantScope;
/**
* 字段
*/
private List<AttributeBO> attrs;
/**
* 默认规则
*/
@NotNull(message = "默认规则必须存在")
private DefaultDataObjectRuleBO defaultDataObjectRuleBO;
/**
* 自定义规则
*/
@Valid
private List<DataObjectRuleBO> dataObjectRuleBOList;
/**
* 排序 （从小到大）
*/
private Integer sort;
/**
* 创建人自然人id
*/
private Long createBy;
/**
* 修改人自然人id
*/
private Long updateBy;
}

12
tyr-api/src/main/java/cn/axzo/tyr/client/model/req/FeatureResourceTreeSaveReq.java
View File

@ -22,7 +22,7 @@ public class FeatureResourceTreeSaveReq extends BaseFeatureResourceDO {
/** 路由地址 **/
private String linkUrl;
/** 路由类型 1-PC 2-小程序 3-原生 **/
/** 路由类型 1-PC 2-小程序 3-原生 4-h5**/
private Integer linkType;
/** APP适配参数 **/
@ -34,6 +34,16 @@ public class FeatureResourceTreeSaveReq extends BaseFeatureResourceDO {
/** 授权类型 0-全部角色 1-指定角色 **/
private Integer authType;
/**
* 应用范围(租户类型)：1:企业工作台 2;项目工作台
*/
private Long workspaceType;
/**
* 最低版本序列,主要支持版本灰度策略
*/
private Integer version;
/** 页面组件对象 **/
private List<FeatureComponentSaveReq> componentSaveReqList;

18
tyr-api/src/main/java/cn/axzo/tyr/client/model/req/PageDataObjectReq.java Normal file
View File

@ -0,0 +1,18 @@
package cn.axzo.tyr.client.model.req;
import cn.axzo.core.domain.PageRequest;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class PageDataObjectReq extends PageRequest {
/**
* 数据对象名称 搜索
*/
private String keyword;
}

3
tyr-api/src/main/java/cn/axzo/tyr/client/model/req/PageRoleReq.java
View File

@ -1,6 +1,7 @@
package cn.axzo.tyr.client.model.req;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
@ -13,6 +14,8 @@ import java.util.List;
@AllArgsConstructor
public class PageRoleReq extends ListRoleReq {
private Integer page;
private Integer pageSize;

3
tyr-api/src/main/java/cn/axzo/tyr/client/model/req/QuerySaasRoleGroupReq.java
View File

@ -6,6 +6,7 @@ import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
import java.util.Set;
@Data
@AllArgsConstructor
@ -46,4 +47,6 @@ public class QuerySaasRoleGroupReq {
private List<Long> roleIds;
private Long parentId;
private Set<Long> parentIds;
}

53
tyr-api/src/main/java/cn/axzo/tyr/client/model/res/DataObjectRes.java Normal file
View File

@ -0,0 +1,53 @@
package cn.axzo.tyr.client.model.res;
import cn.axzo.tyr.client.model.data.object.AttributeBO;
import cn.axzo.tyr.client.model.data.object.DataObjectRuleBO;
import cn.axzo.tyr.client.model.data.object.DefaultDataObjectRuleBO;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class DataObjectRes {
/**
* 数据对象code
*/
private String dataObjectCode;
/**
* 数据对象名 全局唯一
*/
private String dataObjectName;
/**
* 备注
*/
private String memo;
/**
* 租户类型 2：项目租户 1：单位租户 6:OMS 3:政务监管平台
*/
private Integer tenantScope;
/**
* 字段
*/
private List<AttributeBO> attrs;
/**
* 默认规则
*/
private DefaultDataObjectRuleBO defaultDataObjectRuleBO;
/**
* 自定义规则
*/
private List<DataObjectRuleBO> dataObjectRuleBOList;
/**
* 排序 （从小到大）
*/
private Integer sort;
}

21
tyr-api/src/main/java/cn/axzo/tyr/client/model/res/EnumRes.java Normal file
View File

@ -0,0 +1,21 @@
package cn.axzo.tyr.client.model.res;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class EnumRes {
/**
* 枚举值数字，用于向后端传参
*/
private Integer value;
/**
* 枚举值文本，用于前端展示
*/
private String desc;
}

19
tyr-api/src/main/java/cn/axzo/tyr/client/model/res/FeatureResourceDTO.java
View File

@ -38,7 +38,7 @@ public class FeatureResourceDTO implements Serializable {
private String featureName;
/**
* 资源类型1-菜单 2-页面 3-应用入口 4-组件
* 资源类型1-菜单 2-页面 3-应用入口 4-组件 5-root 6-分组
*/
private Integer featureType;
@ -88,7 +88,7 @@ public class FeatureResourceDTO implements Serializable {
private String linkUrl;
/**
* 路由类型1-PC 2-小程序 3-原生
* 路由类型1-PC 2-小程序 3-原生 4-h5
*/
private Integer linkType;
@ -136,4 +136,19 @@ public class FeatureResourceDTO implements Serializable {
* 更新人
*/
private Long updateBy;
/**
* 应用范围(租户类型)：1:企业工作台 2;项目工作台
*/
private Long workspaceType;
/**
* 最低版本序列,主要支持版本灰度策略
*/
private Integer version;
/**
* 唯一编码，用于pre环境菜单同步
*/
private String uniCode;
}

2
tyr-api/src/main/java/cn/axzo/tyr/client/model/res/FeatureResourceTreeNode.java
View File

@ -24,6 +24,8 @@ public class FeatureResourceTreeNode extends FeatureResourceDTO implements IBase
private List<FeatureResourceTreeNode> children;
private List<String> roleCodes;
@JsonIgnore
@Override
public Long getNodeCode() {

13
tyr-api/src/main/java/cn/axzo/tyr/client/model/res/RoleTreeRes.java
View File

@ -23,8 +23,21 @@ public class RoleTreeRes {
*/
private String workspaceTypeCode;
/**
* 租户类型
*/
private String workspaceType;
/**
* 租户id
*/
private Long workspaceId;
/**
* 单位id
*/
private Long ouId;
/**
* 名字
*/

25
tyr-api/src/main/java/cn/axzo/tyr/client/model/res/SimpleDataObjectRes.java Normal file
View File

@ -0,0 +1,25 @@
package cn.axzo.tyr.client.model.res;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class SimpleDataObjectRes {
/**
* 数据对象id
*/
private Long dataObjectId;
/**
* 数据对象Code
*/
private String dataObjectCode;
/**
* 数据对象名称
*/
private String dataObjectName;
}

25
tyr-api/src/main/java/cn/axzo/tyr/client/model/roleuser/dto/GetUserFeatureResourceIdsResp.java Normal file
View File

@ -0,0 +1,25 @@
package cn.axzo.tyr.client.model.roleuser.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Set;
/**
* @author likunpeng
* @version 1.0
* @date 2024/5/22
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GetUserFeatureResourceIdsResp {
/**
* 资源ID列表
*/
private Set<Long> featureResourceIds;
}

7
tyr-api/src/main/java/cn/axzo/tyr/client/model/roleuser/dto/SaasRoleUserDTO.java
View File

@ -6,6 +6,8 @@ import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
/**
* @author haiyangjin
* @date 2023/9/14
@ -94,4 +96,9 @@ public class SaasRoleUserDTO {
* '是否启用'
*/
private Boolean enabled;
/**
* 更新时间
*/
private Date updateAt;
}

44
tyr-api/src/main/java/cn/axzo/tyr/client/model/roleuser/req/GetUserFeatureResourceIdsReq.java Normal file
View File

@ -0,0 +1,44 @@
package cn.axzo.tyr.client.model.roleuser.req;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotNull;
import java.util.List;
/**
* @author likunpeng
* @date 2024/4/2
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GetUserFeatureResourceIdsReq {
/**
* 工作台id
*/
@NotNull(message = "workspaceId不能为空")
private Long workspaceId;
/**
* 单位id
*/
@NotNull(message = "ouId不能为空")
private Long ouId;
/**
* 自然人id
*/
@NotNull(message = "personId不能为空")
private Long personId;
/**
* 查询的角色类型列表
*/
private List<Long> roleIds;
}

4
tyr-api/src/main/java/cn/axzo/tyr/client/model/roleuser/req/RoleUserReq.java
View File

@ -69,4 +69,8 @@ public class RoleUserReq {
*/
private boolean isRecycleModel;
/**
* 操作人
*/
private Long operator;
}

13
tyr-server/pom.xml
View File

@ -1,5 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>tyr</artifactId>
<groupId>cn.axzo.tyr</groupId>
@ -122,6 +123,11 @@
<type>pom</type>
</dependency>
<dependency>
<groupId>cn.axzo.foundation</groupId>
<artifactId>common-lib</artifactId>
<version>2.0.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>cn.axzo.basics</groupId>
<artifactId>basics-profiles-api</artifactId>
@ -132,6 +138,11 @@
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<mainClass>
cn.axzo.tyr.server.TyrApplication
</mainClass>
</configuration>
</plugin>
</plugins>
</build>

3
tyr-server/src/main/java/cn/axzo/tyr/server/TyrApplication.java
View File

@ -1,5 +1,8 @@
package cn.axzo.tyr.server;
import cn.axzo.pokonyan.config.mybatisplus.EntityMetaObjectHandler;
import cn.axzo.tyr.server.job.CMSRoleJobHandler;
import cn.hutool.extra.spring.SpringUtil;
import lombok.extern.slf4j.Slf4j;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;

53
tyr-server/src/main/java/cn/axzo/tyr/server/TyrServerDevApplication.java Normal file
View File

@ -0,0 +1,53 @@
package cn.axzo.tyr.server;
import lombok.extern.log4j.Log4j2;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.ApplicationContext;
import org.springframework.core.env.Environment;
import org.springframework.scheduling.annotation.EnableAsync;
@SpringBootApplication(scanBasePackages = "cn.axzo", exclude = {
org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration.class,
org.springframework.boot.actuate.autoconfigure.security.servlet.ManagementWebSecurityAutoConfiguration.class
})
@EnableFeignClients(basePackages = {"cn.axzo"})
@Log4j2
@EnableAsync
public class TyrServerDevApplication {
public static void main(String[] args) throws Exception {
System.setProperty("spring.profiles.active","dev");
System.setProperty("NACOS_HOST","https://dev-nacos.axzo.cn");
System.setProperty("NACOS_PORT","443");
System.setProperty("NACOS_NAMESPACE_ID","35eada10-9574-4db8-9fea-bc6a4960b6c7");
System.setProperty("CUSTOM_ENV","dev");
System.setProperty("spring.redis.port","31270");
System.setProperty("spring.redis.host","172.16.2.23");
System.setProperty("xxl.job.admin.addresses","http://dev-xxl-job.axzo.cn/xxl-job-admin");
System.setProperty("rocketmq.name-server", "172.16.2.82:9876");
SpringApplication application = new SpringApplication(TyrServerDevApplication.class);
ApplicationContext applicationContext = application.run(args);
Environment env = applicationContext.getEnvironment();
log.info(
"--------------------------------------------------------------------------------------------------------------------\n" +
"Application 【{}】 is running on 【{}】 environment!\n" +
"Api Local: \thttp://127.0.0.1:{}\n" +
"Mysql: \t{}\t username:{}\n" +
"Redis: \t{}:{}\t database:{}\n" +
"RabbitMQ: \t{}\t username:{}",
env.getProperty("spring.application.name"),
env.getProperty("spring.profiles.active"),
env.getProperty("server.port"),
env.getProperty("spring.datasource.url"),
env.getProperty("spring.datasource.username"),
env.getProperty("spring.redis.host"),
env.getProperty("spring.redis.port"),
env.getProperty("spring.redis.database"),
env.getProperty("spring.rabbitmq.addresses"),
env.getProperty("spring.rabbitmq.username") +
"\n----------------------------------------------------------");
}
}

54
tyr-server/src/main/java/cn/axzo/tyr/server/TyrServerPreApplication.java Normal file
View File

@ -0,0 +1,54 @@
package cn.axzo.tyr.server;
import lombok.extern.log4j.Log4j2;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.ApplicationContext;
import org.springframework.core.env.Environment;
import org.springframework.scheduling.annotation.EnableAsync;
/**
*/
@SpringBootApplication(scanBasePackages = "cn.axzo", exclude = {
org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration.class,
})
@EnableFeignClients(basePackages = {"cn.axzo"})
@Log4j2
@EnableAsync
public class TyrServerPreApplication {
public static void main(String[] args) throws Exception {
System.setProperty("spring.profiles.active", "pre");
System.setProperty("NACOS_HOST", "https://pre-nacos.axzo.cn");
System.setProperty("NACOS_NAMESPACE_ID", "8b4cf725-7595-4c92-b2a6-9260a51ce078");
System.setProperty("CUSTOM_ENV", "pre");
System.setProperty("NACOS_PORT", "443");
System.setProperty("spring.redis.port", "6379");
System.setProperty("spring.redis.host", "172.16.1.76");
SpringApplication application = new SpringApplication(TyrServerPreApplication.class);
ApplicationContext applicationContext = application.run(args);
Environment env = applicationContext.getEnvironment();
log.info(
"--------------------------------------------------------------------------------------------------------------------\n" +
"Application 【{}】 is running on 【{}】 environment!\n" +
"Api Local: \thttp://127.0.0.1:{}\n" +
"Mysql: \t{}\t username:{}\n" +
"Redis: \t{}:{}\t database:{}\n" +
"RabbitMQ: \t{}\t username:{}",
env.getProperty("spring.application.name"),
env.getProperty("spring.profiles.active"),
env.getProperty("server.port"),
env.getProperty("spring.datasource.url"),
env.getProperty("spring.datasource.username"),
env.getProperty("spring.redis.host"),
env.getProperty("spring.redis.port"),
env.getProperty("spring.redis.database"),
env.getProperty("spring.rabbitmq.addresses"),
env.getProperty("spring.rabbitmq.username") +
"\n----------------------------------------------------------");
}
}

56
tyr-server/src/main/java/cn/axzo/tyr/server/TyrServerTestApplication.java Normal file
View File

@ -0,0 +1,56 @@
package cn.axzo.tyr.server;
import lombok.extern.log4j.Log4j2;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.ApplicationContext;
import org.springframework.core.env.Environment;
import org.springframework.scheduling.annotation.EnableAsync;
/**
*/
@SpringBootApplication(scanBasePackages = "cn.axzo", exclude = {
org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration.class,
})
@EnableFeignClients(basePackages = {"cn.axzo"})
@Log4j2
@EnableAsync
public class TyrServerTestApplication {
public static void main(String[] args) throws Exception {
System.setProperty("spring.profiles.active", "test");
System.setProperty("NACOS_HOST", "https://test-nacos.axzo.cn");
System.setProperty("NACOS_NAMESPACE_ID","f3c0f0d2-bac4-4498-bee7-9c3636b3afdf");
System.setProperty("CUSTOM_ENV","test");
System.setProperty("NACOS_PORT", "443");
System.setProperty("spring.redis.port","6379");
System.setProperty("spring.redis.host","172.16.2.149");
System.setProperty("rocketmq.name-server", "172.16.2.82:9876");
SpringApplication application = new SpringApplication(TyrServerTestApplication.class);
ApplicationContext applicationContext = application.run(args);
Environment env = applicationContext.getEnvironment();
log.info(
"--------------------------------------------------------------------------------------------------------------------\n" +
"Application 【{}】 is running on 【{}】 environment!\n" +
"Api Local: \thttp://127.0.0.1:{}\n" +
"Mysql: \t{}\t username:{}\n" +
"Redis: \t{}:{}\t database:{}\n" +
"RabbitMQ: \t{}\t username:{}",
env.getProperty("spring.application.name"),
env.getProperty("spring.profiles.active"),
env.getProperty("server.port"),
env.getProperty("spring.datasource.url"),
env.getProperty("spring.datasource.username"),
env.getProperty("spring.redis.host"),
env.getProperty("spring.redis.port"),
env.getProperty("spring.redis.database"),
env.getProperty("spring.rabbitmq.addresses"),
env.getProperty("spring.rabbitmq.username") +
"\n----------------------------------------------------------");
}
}

15
tyr-server/src/main/java/cn/axzo/tyr/server/config/exception/BizResultCode.java Normal file
View File

@ -0,0 +1,15 @@
package cn.axzo.tyr.server.config.exception;
import cn.axzo.foundation.result.IResultCode;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public enum BizResultCode implements IResultCode {
CANT_DELETE_ROLE_GROUP("100001", "不能删除角色分组，当前角色分组下有子角色分组");
private String errorCode;
private String errorMessage;
}

10
tyr-server/src/main/java/cn/axzo/tyr/server/config/exception/ExceptionAdviceHandler.java
View File

@ -1,7 +1,8 @@
package cn.axzo.tyr.server.config.exception;
import cn.axzo.basics.common.exception.ServiceException;
import cn.axzo.foundation.exception.BusinessException;
import cn.axzo.framework.domain.web.result.ApiResult;
import cn.azxo.framework.common.model.CommonResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.annotation.Order;
import org.springframework.util.CollectionUtils;
@ -25,7 +26,7 @@ import java.util.List;
public class ExceptionAdviceHandler {
@ExceptionHandler(cn.axzo.framework.domain.ServiceException.class)
public ApiResult<Void> basicsServiceExceptionHandler(ServiceException e) {
public ApiResult<Void> basicsServiceExceptionHandler(cn.axzo.framework.domain.ServiceException e) {
log.warn("业务异常", e);
return ApiResult.err(e.getMessage());
}
@ -48,4 +49,9 @@ public class ExceptionAdviceHandler {
return ApiResult.err(objectErrorDefaultMessage);
}
@ExceptionHandler(BusinessException.class)
public CommonResponse<Void> businessExceptionHandler(BusinessException e) {
log.warn("参数错误", e);
return CommonResponse.error(Integer.valueOf(e.getErrorCode()), e.getErrorMsg());
}
}

74
tyr-server/src/main/java/cn/axzo/tyr/server/controller/DataResourceController.java Normal file
View File

@ -0,0 +1,74 @@
package cn.axzo.tyr.server.controller;
import cn.axzo.framework.domain.web.result.ApiPageResult;
import cn.axzo.framework.domain.web.result.ApiResult;
import cn.axzo.tyr.client.feign.DataResourceApi;
import cn.axzo.tyr.client.model.dataresource.req.CreateDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.DataResourceSaasFeatureParam;
import cn.axzo.tyr.client.model.dataresource.req.DeleteDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.GetSaasFeatureDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.PageDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.SearchDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.UpdateDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.resp.DataResourceResp;
import cn.axzo.tyr.client.model.dataresource.resp.PageDataResourceResp;
import cn.axzo.tyr.server.service.DataResourceService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* 数据资源相关接口
*
* @author haiyangjin
* @date 2024/1/13
*/
@Slf4j
@RestController
@RequiredArgsConstructor
public class DataResourceController implements DataResourceApi {
private final DataResourceService dataResourceService;
@Override
public ApiResult<Void> create(CreateDataResourceParam param) {
dataResourceService.create(param);
return ApiResult.ok();
}
@Override
public ApiResult<Boolean> update(UpdateDataResourceParam param) {
return ApiResult.ok(dataResourceService.update(param));
}
@Override
public ApiResult<Boolean> delete(DeleteDataResourceParam param) {
return ApiResult.ok(dataResourceService.delete(param));
}
@Override
public ApiPageResult<PageDataResourceResp> page(PageDataResourceParam param) {
return ApiPageResult.ok(dataResourceService.page(param));
}
@Override
public ApiResult<List<DataResourceResp>> list(SearchDataResourceParam param) {
return ApiResult.ok(dataResourceService.list(param));
}
@Override
public ApiResult<Void> createDataResourceSaasFeature(DataResourceSaasFeatureParam param) {
dataResourceService.createDataResourceSaasFeature(param);
return ApiResult.ok();
}
@Override
public ApiResult<Boolean> deleteDataResourceSaasFeature(DataResourceSaasFeatureParam param) {
return ApiResult.ok(dataResourceService.deleteDataResourceSaasFeature(param));
}
@Override
public ApiResult<List<DataResourceResp>> getSaasFeatureDataResource(GetSaasFeatureDataResourceParam param) {
return ApiResult.ok(dataResourceService.getSaasFeatureDataResource(param));
}
}

94
tyr-server/src/main/java/cn/axzo/tyr/server/controller/data/object/DataObjectController.java Normal file
View File

@ -0,0 +1,94 @@
package cn.axzo.tyr.server.controller.data.object;
import cn.axzo.basics.auth.enums.WorkspaceTypeWithLegacyEnum;
import cn.axzo.basics.common.page.PageResult;
import cn.axzo.framework.domain.ServiceException;
import cn.axzo.framework.domain.web.result.ApiResult;
import cn.axzo.tyr.client.common.annotation.RepeatedSubmit;
import cn.axzo.tyr.client.common.enums.AttrPermissionEnum;
import cn.axzo.tyr.client.common.enums.EnumTypeEnum;
import cn.axzo.tyr.client.common.enums.ReturnCodeEnum;
import cn.axzo.tyr.client.common.enums.RowPermissionEnum;
import cn.axzo.tyr.client.common.enums.TenantScopeEnum;
import cn.axzo.tyr.client.common.enums.WorkspaceJoinType;
import cn.axzo.tyr.client.feign.DataObjectApi;
import cn.axzo.tyr.client.model.req.CreateDataObjectReq;
import cn.axzo.tyr.client.model.req.DeleteDataObjectReq;
import cn.axzo.tyr.client.model.req.EditDataObjectReq;
import cn.axzo.tyr.client.model.req.PageDataObjectReq;
import cn.axzo.tyr.client.model.res.DataObjectRes;
import cn.axzo.tyr.client.model.res.EnumRes;
import cn.axzo.tyr.client.model.res.SimpleDataObjectRes;
import cn.axzo.tyr.server.service.DataObjectService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RestController;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* 数据权限
*/
@Slf4j
@RestController
@RequiredArgsConstructor
public class DataObjectController implements DataObjectApi {
private final DataObjectService dataObjectService;
@RepeatedSubmit(spElKey = "'createDataObject:' + #req.dataObjectCode")
public ApiResult<Long> createDataObject(CreateDataObjectReq req) {
return ApiResult.ok(dataObjectService.createDataObject(req));
}
@Override
public ApiResult<Void> editDataObject(EditDataObjectReq req) {
dataObjectService.editDataObject(req);
return ApiResult.ok();
}
@Override
public ApiResult<Void> deleteDataObject(DeleteDataObjectReq req) {
dataObjectService.deleteDataObject(req.getDataObjectId(), req.getUpdateBy());
return ApiResult.ok();
}
@Override
public ApiResult<PageResult<SimpleDataObjectRes>> pageDataObject(PageDataObjectReq req) {
return ApiResult.ok(dataObjectService.pageDataObject(req));
}
/**
* 1-租户类型 2-行级权限规则&单位/OMS/政务监管平台的数据权限
* 3-行级权限规则&项目数据权限 4-字段值查看范围&单位/OMS/政务监管平台的数据权限 5-字段值查看范围&项目数据权限
*
* @param type 1-租户类型 2-行级权限规则&单位/OMS/政务监管平台的数据权限 3-行级权限规则&项目数据权限 4-字段值查看范围&单位/OMS/政务监管平台的数据权限 5-字段值查看范围&项目数据权限
* @return
*/
@Override
public ApiResult<List<EnumRes>> getEnumList(Integer type) {
EnumTypeEnum typeEnum = EnumTypeEnum.valueOf(type);
switch (typeEnum) {
case TENANT_SCOPE:
return ApiResult.ok(Arrays.stream(TenantScopeEnum.values()).map(e -> EnumRes.builder().value(e.getValue()).desc(e.getDesc()).build()).collect(Collectors.toList()));
case ROW_PERMISSION_AND_NOT_WORKSPACE:
return ApiResult.ok(RowPermissionEnum.listRowPermissionForNotWorkspace().stream().map(e -> EnumRes.builder().value(e.getValue()).desc(e.getDesc()).build()).collect(Collectors.toList()));
case ROW_PERMISSION_AND_WORKSPACE:
return ApiResult.ok(RowPermissionEnum.listRowPermissionForWorkspace().stream().map(e -> EnumRes.builder().value(e.getValue()).desc(e.getDesc()).build()).collect(Collectors.toList()));
case ATTR_PERMISSION_AND_NOT_WORKSPACE:
return ApiResult.ok(AttrPermissionEnum.listAttrPermissionForNotWorkspace().stream().map(e -> EnumRes.builder().value(e.getValue()).desc(e.getDesc()).build()).collect(Collectors.toList()));
case ATTR_PERMISSION_AND_WORKSPACE:
return ApiResult.ok(AttrPermissionEnum.listAttrPermissionForWorkspace().stream().map(e -> EnumRes.builder().value(e.getValue()).desc(e.getDesc()).build()).collect(Collectors.toList()));
default:
throw new ServiceException(ReturnCodeEnum.TYPE_UNKNOWN.getMessage());
}
}
@Override
public ApiResult<DataObjectRes> getDataObject(Long dataObjectId) {
return ApiResult.ok(dataObjectService.getDataObject(dataObjectId));
}
}

5
tyr-server/src/main/java/cn/axzo/tyr/server/controller/dataPermission/DataPermissionController.java
View File

@ -1,17 +1,17 @@
package cn.axzo.tyr.server.controller.dataPermission;
import cn.axzo.framework.domain.web.ApiException;
import cn.axzo.framework.domain.web.result.ApiResult;
import cn.axzo.tyr.client.feign.DataPermissionApi;
import cn.axzo.tyr.client.model.req.CreateDataObjectReq;
import cn.axzo.tyr.client.model.req.GetWorkflowQueryAndUpdatePermissionReq;
import cn.axzo.tyr.client.model.res.GetWorkflowQueryAndUpdatePermissionRes;
import cn.axzo.tyr.server.service.DataObjectService;
import cn.axzo.tyr.server.utils.RpcExternalUtil;
import cn.axzo.workflow.client.feign.bpmn.ProcessInstanceApi;
import cn.axzo.workflow.client.feign.bpmn.ProcessTaskApi;
import cn.axzo.workflow.common.model.request.bpmn.process.BpmnProcessInstanceQueryDTO;
import cn.axzo.workflow.common.model.response.bpmn.process.BpmnProcessInstanceVO;
import cn.axzo.workflow.common.model.response.bpmn.task.BpmnHistoricTaskInstanceVO;
import cn.azxo.framework.common.model.CommonResponse;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
@ -65,4 +65,5 @@ public class DataPermissionController implements DataPermissionApi {
}
return ApiResult.ok(result);
}
}

9
tyr-server/src/main/java/cn/axzo/tyr/server/controller/role/SaasRoleController.java
View File

@ -304,6 +304,13 @@ public class SaasRoleController implements TyrSaasRoleApi {
return ApiListResult.ok(roleService.list(param));
}
@Override
public ApiListResult<SaasRoleRes> list(ListRoleReq request) {
RoleService.ListSaasRoleParam param = RoleService.ListSaasRoleParam.builder().build();
BeanUtils.copyProperties(request, param);
return ApiListResult.ok(roleService.list(param));
}
/**
* 只支持移动一位
* @param request
@ -410,6 +417,8 @@ public class SaasRoleController implements TyrSaasRoleApi {
.name(roleGroup.getName())
.type(ROLE_GROUP_TYPE)
.idStr(roleGroup.getId() + ":" + ROLE_GROUP_TYPE)
.workspaceId(roleGroup.getWorkspaceId())
.ouId(roleGroup.getOuId())
.build();
}

6
tyr-server/src/main/java/cn/axzo/tyr/server/controller/roleuser/RoleUserController.java
View File

@ -7,6 +7,7 @@ import cn.axzo.pokonyan.config.mybatisplus.BaseEntity;
import cn.axzo.tyr.client.feign.TyrSaasRoleUserApi;
import cn.axzo.tyr.client.model.enums.IdentityType;
import cn.axzo.tyr.client.model.roleuser.dto.GetUserAutoOwnRoleResp;
import cn.axzo.tyr.client.model.roleuser.dto.GetUserFeatureResourceIdsResp;
import cn.axzo.tyr.client.model.roleuser.dto.SaasRoleUserDTO;
import cn.axzo.tyr.client.model.roleuser.dto.SuperAminInfoResp;
import cn.axzo.tyr.client.model.roleuser.req.*;
@ -162,4 +163,9 @@ public class RoleUserController implements TyrSaasRoleUserApi {
public ApiResult<GetUserAutoOwnRoleResp> getUserAutoOwnRole(GetUserAutoOwnRoleReq req) {
return ApiResult.ok(saasRoleUserService.getUserAutoOwnRole(req));
}
@Override
public ApiResult<GetUserFeatureResourceIdsResp> getUserFeatureResourceIds(GetUserFeatureResourceIdsReq req) {
return ApiResult.ok(saasRoleUserService.getUserFeatureResourceIds(req));
}
}

22
tyr-server/src/main/java/cn/axzo/tyr/server/model/FeatureResourceRoleCodeDTO.java Normal file
View File

@ -0,0 +1,22 @@
package cn.axzo.tyr.server.model;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author likunpeng
* @version 1.0
* @date 2024/5/22
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class FeatureResourceRoleCodeDTO {
private Long featureResourceId;
private String roleCode;
}

38
tyr-server/src/main/java/cn/axzo/tyr/server/repository/dao/DataObjectAttrDao.java Normal file
View File

@ -0,0 +1,38 @@
package cn.axzo.tyr.server.repository.dao;
import cn.axzo.basics.common.constant.enums.DeleteEnum;
import cn.axzo.tyr.client.model.data.object.DataObjectAttrQueryBO;
import cn.axzo.tyr.server.repository.entity.DataObjectAttr;
import cn.axzo.tyr.server.repository.entity.DataObjectRule;
import cn.axzo.tyr.server.repository.mapper.DataObjectAttrMapper;
import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Objects;
@Repository
public class DataObjectAttrDao extends ServiceImpl<DataObjectAttrMapper, DataObjectAttr> {
public void deleteByDataObjectIdList(List<Long> dataObjectIdList, Long updateBy) {
lambdaUpdate()
.eq(DataObjectAttr::getIsDelete, DeleteEnum.NORMAL.getValue())
.in(DataObjectAttr::getDataObjectId, dataObjectIdList)
.set(Objects.nonNull(updateBy), DataObjectAttr::getUpdateBy, updateBy)
.set(DataObjectAttr::getIsDelete, DeleteEnum.DELETE.getValue())
.update();
}
public List<DataObjectAttr> listByBO(DataObjectAttrQueryBO bo) {
// 有插件有设置is_delete
return lambdaQuery()
.eq(Objects.nonNull(bo.getDataObjectAttrId()), DataObjectAttr::getId, bo.getDataObjectAttrId())
.eq(Objects.nonNull(bo.getDataObjectId()), DataObjectAttr::getDataObjectId, bo.getDataObjectId())
.eq(Objects.nonNull(bo.getAttrCode()), DataObjectAttr::getAttrCode, bo.getAttrCode())
.in(CollUtil.isNotEmpty(bo.getAttrCodeList()), DataObjectAttr::getAttrCode, bo.getAttrCodeList())
.eq(Objects.nonNull(bo.getUnmaskSupport()), DataObjectAttr::getUnmaskSupport, bo.getUnmaskSupport())
.eq(Objects.nonNull(bo.getEditSupport()), DataObjectAttr::getEditSupport, bo.getEditSupport())
.list();
}
}

44
tyr-server/src/main/java/cn/axzo/tyr/server/repository/dao/DataObjectDao.java Normal file
View File

@ -0,0 +1,44 @@
package cn.axzo.tyr.server.repository.dao;
import cn.axzo.basics.common.constant.enums.DeleteEnum;
import cn.axzo.tyr.client.model.data.object.DataObjectQueryBO;
import cn.axzo.tyr.server.repository.entity.DataObject;
import cn.axzo.tyr.server.repository.mapper.DataObjectMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Objects;
@Repository
public class DataObjectDao extends ServiceImpl<DataObjectMapper, DataObject> {
public List<DataObject> duplicateListByBO(DataObjectQueryBO bo) {
return lambdaQuery()
.eq(DataObject::getIsDelete, DeleteEnum.NORMAL.getValue())
.and(sql -> sql
.eq(StringUtils.isNotEmpty(bo.getDataObjectCode()), DataObject::getDataObjectCode, bo.getDataObjectCode())
.or(StringUtils.isNotEmpty(bo.getDataObjectCode()))
.eq(StringUtils.isNotEmpty(bo.getDataObjectName()), DataObject::getDataObjectName, bo.getDataObjectName()))
.list();
}
public IPage<DataObject> pageByBO(DataObjectQueryBO bo) {
return lambdaQuery()
.eq(DataObject::getIsDelete, DeleteEnum.NORMAL.getValue())
.eq(StringUtils.isNotEmpty(bo.getDataObjectCode()), DataObject::getDataObjectCode, bo.getDataObjectCode())
.like(StringUtils.isNotEmpty(bo.getDataObjectName()), DataObject::getDataObjectName, bo.getDataObjectName())
.page(bo.toPage());
}
public void deleteByIdList(List<Long> idList, Long updateBy) {
lambdaUpdate()
.eq(DataObject::getIsDelete, DeleteEnum.NORMAL.getValue())
.in(DataObject::getId, idList)
.set(Objects.nonNull(updateBy), DataObject::getUpdateBy, updateBy)
.set(DataObject::getIsDelete, DeleteEnum.DELETE.getValue())
.update();
}
}

30
tyr-server/src/main/java/cn/axzo/tyr/server/repository/dao/DataObjectRuleAttrDao.java Normal file
View File

@ -0,0 +1,30 @@
package cn.axzo.tyr.server.repository.dao;
import cn.axzo.basics.common.constant.enums.DeleteEnum;
import cn.axzo.tyr.client.model.data.object.RuleAttrQueryBO;
import cn.axzo.tyr.server.repository.entity.DataObjectAttr;
import cn.axzo.tyr.server.repository.entity.DataObjectRuleAttr;
import cn.axzo.tyr.server.repository.mapper.DataObjectRuleAttrMapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Objects;
@Repository
public class DataObjectRuleAttrDao extends ServiceImpl<DataObjectRuleAttrMapper, DataObjectRuleAttr> {
public void deleteByDataObjectIdList(List<Long> dataObjectIdList, Long updateBy) {
lambdaUpdate()
.eq(DataObjectRuleAttr::getIsDelete, DeleteEnum.NORMAL.getValue())
.in(DataObjectRuleAttr::getDataObjectId, dataObjectIdList)
.set(Objects.nonNull(updateBy), DataObjectRuleAttr::getUpdateBy, updateBy)
.set(DataObjectRuleAttr::getIsDelete, DeleteEnum.DELETE.getValue())
.update();
}
public List<DataObjectRuleAttr> listByBO(RuleAttrQueryBO bo) {
return lambdaQuery()
.eq(Objects.nonNull(bo.getDataObjectId()), DataObjectRuleAttr::getDataObjectId, bo.getDataObjectId())
.list();
}
}

34
tyr-server/src/main/java/cn/axzo/tyr/server/repository/dao/DataObjectRuleDao.java Normal file
View File

@ -0,0 +1,34 @@
package cn.axzo.tyr.server.repository.dao;
import cn.axzo.basics.common.constant.enums.DeleteEnum;
import cn.axzo.tyr.client.model.data.object.DataObjectRuleQueryBO;
import cn.axzo.tyr.server.repository.entity.DataObject;
import cn.axzo.tyr.server.repository.entity.DataObjectRule;
import cn.axzo.tyr.server.repository.mapper.DataObjectRuleMapper;
import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Objects;
@Repository
public class DataObjectRuleDao extends ServiceImpl<DataObjectRuleMapper, DataObjectRule> {
public List<DataObjectRule> listByBO(DataObjectRuleQueryBO bo) {
return lambdaQuery()
.eq(DataObjectRule::getIsDelete, DeleteEnum.NORMAL.getValue())
.eq(Objects.nonNull(bo.getDataObjectId()), DataObjectRule::getDataObjectId, bo.getDataObjectId())
.in(CollUtil.isNotEmpty(bo.getDataObjectRuleNameList()), DataObjectRule::getName, bo.getDataObjectRuleNameList())
.list();
}
public void deleteByDataObjectIdList(List<Long> dataObjectIdList, Long updateBy) {
lambdaUpdate()
.eq(DataObjectRule::getIsDelete, DeleteEnum.NORMAL.getValue())
.in(DataObjectRule::getDataObjectId, dataObjectIdList)
.set(Objects.nonNull(updateBy), DataObjectRule::getUpdateBy, updateBy)
.set(DataObjectRule::getIsDelete, DeleteEnum.DELETE.getValue())
.update();
}
}

30
tyr-server/src/main/java/cn/axzo/tyr/server/repository/dao/DataObjectRuleScopeDao.java Normal file
View File

@ -0,0 +1,30 @@
package cn.axzo.tyr.server.repository.dao;
import cn.axzo.basics.common.constant.enums.DeleteEnum;
import cn.axzo.tyr.client.model.data.object.RuleScopeQueryBO;
import cn.axzo.tyr.server.repository.entity.DataObjectRuleAttr;
import cn.axzo.tyr.server.repository.entity.DataObjectRuleScope;
import cn.axzo.tyr.server.repository.mapper.DataObjectRuleScopeMapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Objects;
@Repository
public class DataObjectRuleScopeDao extends ServiceImpl<DataObjectRuleScopeMapper, DataObjectRuleScope> {
public void deleteByDataObjectIdList(List<Long> dataObjectIdList, Long updateBy) {
lambdaUpdate()
.eq(DataObjectRuleScope::getIsDelete, DeleteEnum.NORMAL.getValue())
.in(DataObjectRuleScope::getDataObjectId, dataObjectIdList)
.set(Objects.nonNull(updateBy), DataObjectRuleScope::getUpdateBy, updateBy)
.set(DataObjectRuleScope::getIsDelete, DeleteEnum.DELETE.getValue())
.update();
}
public List<DataObjectRuleScope> listByBO(RuleScopeQueryBO bo) {
return lambdaQuery()
.eq(Objects.nonNull(bo.getDataObjectId()), DataObjectRuleScope::getDataObjectId, bo.getDataObjectId())
.list();
}
}

14
tyr-server/src/main/java/cn/axzo/tyr/server/repository/dao/DataResourceDao.java Normal file
View File

@ -0,0 +1,14 @@
package cn.axzo.tyr.server.repository.dao;
import cn.axzo.tyr.server.repository.entity.DataResource;
import cn.axzo.tyr.server.repository.mapper.DataResourceMapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Repository;
/**
* @author haiyangjin
* @date 2024/1/15
*/
@Repository
public class DataResourceDao extends ServiceImpl<DataResourceMapper, DataResource> {
}

14
tyr-server/src/main/java/cn/axzo/tyr/server/repository/dao/SaasFeatureDataResourceDao.java Normal file
View File

@ -0,0 +1,14 @@
package cn.axzo.tyr.server.repository.dao;
import cn.axzo.tyr.server.repository.entity.SaasFeatureDataResource;
import cn.axzo.tyr.server.repository.mapper.SaasFeatureDataResourceMapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Repository;
/**
* @author haiyangjin
* @date 2024/1/15
*/
@Repository
public class SaasFeatureDataResourceDao extends ServiceImpl<SaasFeatureDataResourceMapper, SaasFeatureDataResource> {
}

13
tyr-server/src/main/java/cn/axzo/tyr/server/repository/dao/SaasFeatureResourceDao.java
View File

@ -2,14 +2,18 @@ package cn.axzo.tyr.server.repository.dao;
import cn.axzo.basics.common.constant.enums.TableIsDeleteEnum;
import cn.axzo.tyr.client.model.req.GetFeatureResourceTreeReq;
import cn.axzo.tyr.server.model.FeatureResourceRoleCodeDTO;
import cn.axzo.tyr.server.repository.entity.SaasFeatureResource;
import cn.axzo.tyr.server.repository.mapper.SaasFeatureResourceMapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.collect.Maps;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
/**
* <p>
@ -39,4 +43,13 @@ public class SaasFeatureResourceDao extends ServiceImpl<SaasFeatureResourceMappe
.list();
}
public Map<Long, List<String>> getFeatureResourceRoleCodeMap(List<Long> featureResourceIds) {
if (org.apache.commons.collections4.CollectionUtils.isEmpty(featureResourceIds)) {
return Maps.newHashMap();
}
List<FeatureResourceRoleCodeDTO> featureResourceRoleCodes = this.baseMapper.listRoleCodes(featureResourceIds);
return org.apache.commons.collections4.CollectionUtils.emptyIfNull(featureResourceRoleCodes).stream()
.collect(Collectors.groupingBy(FeatureResourceRoleCodeDTO::getFeatureResourceId, Collectors.mapping(FeatureResourceRoleCodeDTO::getRoleCode, Collectors.toList())));
}
}

11
tyr-server/src/main/java/cn/axzo/tyr/server/repository/dao/SaasRoleDao.java
View File

@ -17,6 +17,7 @@ import org.springframework.stereotype.Repository;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
@ -120,5 +121,15 @@ public class SaasRoleDao extends ServiceImpl<SaasRoleMapper, SaasRole> {
public List<RoleFeatureRelation> listFeatureByIds(Set<Long> roleIds, Set<Long> featureIds) {
return this.baseMapper.listFeatureByIds(roleIds, featureIds);
}
public List<SaasRole> listByRoleCodes(List<String> roleCodes) {
if (CollectionUtils.isEmpty(roleCodes)) {
return Collections.emptyList();
}
return lambdaQuery().in(SaasRole::getRoleCode, roleCodes)
.eq(BaseEntity::getIsDelete, TableIsDeleteEnum.NORMAL)
.eq(SaasRole::getRoleType, RoleTypeEnum.INIT.getValue())
.list();
}
}

1
tyr-server/src/main/java/cn/axzo/tyr/server/repository/dao/SaasRoleGroupDao.java
View File

@ -39,6 +39,7 @@ public class SaasRoleGroupDao extends ServiceImpl<SaasRoleGroupMapper, SaasRoleG
.in(CollectionUtils.isNotEmpty(req.getWorkspaceIds()), SaasRoleGroup::getWorkspaceId, req.getWorkspaceIds())
.in(CollectionUtils.isNotEmpty(req.getOuIds()), SaasRoleGroup::getOuId, req.getOuIds())
.eq(Objects.nonNull(req.getParentId()), SaasRoleGroup::getParentId, req.getParentId())
.in(CollectionUtils.isNotEmpty(req.getParentIds()), SaasRoleGroup::getParentId, req.getParentIds())
.eq(BaseEntity::getIsDelete, TableIsDeleteEnum.NORMAL.value);
if(CollectionUtils.isNotEmpty(req.getOuTypeCode())){
eq.last(" AND (" + condition.substring(0, condition.length() - 2) + ")");

39
tyr-server/src/main/java/cn/axzo/tyr/server/repository/entity/DataObject.java Normal file
View File

@ -0,0 +1,39 @@
package cn.axzo.tyr.server.repository.entity;
import cn.axzo.pokonyan.config.mybatisplus.BaseEntity;
import cn.axzo.tyr.server.utils.BaseOperatorEntity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import lombok.experimental.SuperBuilder;
import java.io.Serializable;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
@TableName(value = "data_object", autoResultMap = true)
public class DataObject extends BaseOperatorEntity<DataObject> implements Serializable {
/**
* 数据权限code
*/
private String dataObjectCode;
/**
* 数据权限名 全局唯一
*/
private String dataObjectName;
/**
* 备注
*/
private String memo;
private Integer tenantScope;
private Integer sort;
}

47
tyr-server/src/main/java/cn/axzo/tyr/server/repository/entity/DataObjectAttr.java Normal file
View File

@ -0,0 +1,47 @@
package cn.axzo.tyr.server.repository.entity;
import cn.axzo.tyr.server.utils.BaseOperatorEntity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.io.Serializable;
@Data
@Builder
@Accessors(chain = true)
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "data_object_attr", autoResultMap = true)
public class DataObjectAttr extends BaseOperatorEntity<DataObjectAttr> implements Serializable {
/**
* 数据权限id
*/
private Long dataObjectId;
/**
* 数据权限code
*/
private String dataObjectCode;
/**
* 序号
*/
private Integer sort;
/**
* 字段名
*/
private String attrName;
private String attrCode;
/**
* 是否支持脱敏 1-不支持 2-支持
*/
// @TableField(value = "unmask_support")
private Integer unmaskSupport;
/**
* 是否支持编辑 1-不支持 2-支持
*/
private Integer editSupport;
}

64
tyr-server/src/main/java/cn/axzo/tyr/server/repository/entity/DataObjectRule.java Normal file
View File

@ -0,0 +1,64 @@
package cn.axzo.tyr.server.repository.entity;
import cn.axzo.pokonyan.config.mybatisplus.BaseEntity;
import cn.axzo.tyr.server.utils.BaseOperatorEntity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.List;
@Data
@Builder
@Accessors(chain = true)
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "data_object_rule", autoResultMap = true)
public class DataObjectRule extends BaseOperatorEntity<DataObjectRule> implements Serializable {
/**
* 数据权限id
*/
private Long dataObjectId;
/**
* 数据权限code
*/
private String dataObjectCode;
/**
* 规则名
*/
private String name;
/**
* 行级数据权限（单选） 1:仅本人数据 2:本人及下属数据 3:仅本部门数据 4:本部门及以下数据
* 5:仅本单位数据 6:本单位及下级直属单位数据 7:本单位及下级协同（直属+合作）单位数据 8:本单位及以下协同（直属+合作）单位数据 9:本项目部数据
*/
private Integer rowPermission;
/**
* 规则范围 1：岗位 2：角色
*/
private Integer ruleScopeType;
/**
* 是否为默认规则 1-不是 2-是
*/
private Integer isDefault;
/**
* 排序 （从小到大）
*/
private Integer sort;
/**
* 规则字段
*/
@TableField(exist = false)
private List<DataObjectRuleAttr> dataObjectRuleAttrList;
/**
* 规则范围
*/
@TableField(exist = false)
private List<DataObjectRuleScope> dataObjectRuleScopeList;
}

56
tyr-server/src/main/java/cn/axzo/tyr/server/repository/entity/DataObjectRuleAttr.java Normal file
View File

@ -0,0 +1,56 @@
package cn.axzo.tyr.server.repository.entity;
import cn.axzo.tyr.server.utils.BaseOperatorEntity;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "data_object_rule_attr", autoResultMap = true)
public class DataObjectRuleAttr extends BaseOperatorEntity<DataObjectRuleAttr> implements Serializable {
/**
* 数据对象id
*/
private Long dataObjectId;
/**
* 数据对象code
*/
private String dataObjectCode;
/**
* 数据对象字段id
*/
private Long dataObjectAttrId;
/**
* 数据对象规则id
*/
private Long dataObjectRuleId;
/**
* 字段code
*/
String attrCode;
/**
* 序号
*/
private Integer sort;
/**
* 字段值查看范围 1:仅本人数据 2:本人及下属数据 3:仅本部门数据 4:本部门及以下数据
* 5:仅本单位数据 6:本单位及下级直属单位数据 7:本单位及下级协同（直属+合作）单位数据 8:本单位及以下协同（直属+合作）单位数据 9:本项目部数据
* 10:同行级数据权限
*/
private Integer visibilityScope;
/**
* 是否可脱敏 1-不可操作脱敏 2-可操作脱敏
*/
private Integer isUnmaskable;
/**
* 是否可编辑 1-不可编辑 2-可编辑
*/
private Integer isEditable;
}

39
tyr-server/src/main/java/cn/axzo/tyr/server/repository/entity/DataObjectRuleScope.java Normal file
View File

@ -0,0 +1,39 @@
package cn.axzo.tyr.server.repository.entity;
import cn.axzo.pokonyan.config.mybatisplus.BaseEntity;
import cn.axzo.tyr.server.utils.BaseOperatorEntity;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "data_object_rule_scope", autoResultMap = true)
public class DataObjectRuleScope extends BaseOperatorEntity<DataObjectRuleScope> implements Serializable {
/**
* 数据权限id
*/
private Long dataObjectId;
/**
* 数据权限code
*/
private String dataObjectCode;
/**
* 数据权限规则id
*/
private Long dataObjectRuleId;
/**
* 规则范围 1：岗位 2：角色
*/
private Integer ruleScopeType;
/**
* 岗位id/角色id
*/
private Long relationId;
}

94
tyr-server/src/main/java/cn/axzo/tyr/server/repository/entity/DataResource.java Normal file
View File

@ -0,0 +1,94 @@
package cn.axzo.tyr.server.repository.entity;
import cn.axzo.pokonyan.config.mybatisplus.BaseEntity;
import cn.axzo.tyr.client.common.enums.DataResourceModuleEnum;
import cn.axzo.tyr.client.common.enums.DataResourceOperationEnum;
import cn.axzo.tyr.client.common.enums.DataResourceTypeEnum;
import cn.axzo.tyr.client.model.dataresource.DataResourceAttrs;
import cn.axzo.tyr.client.model.dataresource.ResourceScope;
import cn.axzo.tyr.client.model.dataresource.UserScope;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.handlers.FastjsonTypeHandler;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
import java.util.Map;
/**
* @author haiyangjin
* @date 2024/1/9
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@TableName(value = "data_resource", autoResultMap = true)
public class DataResource extends BaseEntity<DataResource> implements Serializable {
/**
* 数据资源名称
*/
@TableField("name")
private String name;
/**
* 模块名称 eg. 企业：ENTERPRISE, 项目：PROJECT
* @see DataResourceModuleEnum
*/
@TableField("module")
private DataResourceModuleEnum module;
/**
* 数据资源code
*/
@TableField("resource_code")
private String resourceCode;
/**
* 对象属性例如：[{"attr": "name", "label": "名字"}]
*/
@TableField(value = "attrs", typeHandler = FastjsonTypeHandler.class)
private List<DataResourceAttrs> attrs;
/**
* 数据范围
*/
@TableField(value = "resource_scope", typeHandler = FastjsonTypeHandler.class)
private ResourceScope resourceScope;
/**
* 用户范围
*/
@TableField(value = "user_scope", typeHandler = FastjsonTypeHandler.class)
private UserScope userScope;
/**
* 数据对象类型0:主对象1:子对象
*/
@TableField("type")
private DataResourceTypeEnum type;
/**
* 数据对象类型0:主对象1:子对象
*/
@TableField("operation")
private DataResourceOperationEnum operation;
/**
* 数据对象code
*/
@TableField(value = "ext", typeHandler = FastjsonTypeHandler.class)
private Map ext;
/**
* 父对象ID
*/
@TableField("parent_id")
private Long parentId;
}

34
tyr-server/src/main/java/cn/axzo/tyr/server/repository/entity/SaasFeatureDataResource.java Normal file
View File

@ -0,0 +1,34 @@
package cn.axzo.tyr.server.repository.entity;
import cn.axzo.pokonyan.config.mybatisplus.BaseEntity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @author haiyangjin
* @date 2024/1/15
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@TableName(value = "saas_feature_data_resource", autoResultMap = true)
public class SaasFeatureDataResource extends BaseEntity<SaasFeatureDataResource> implements Serializable {
/**
* featureCode
*/
@TableField("feature_code")
private String featureCode;
/**
* 数据资源code
*/
@TableField("resource_code")
private String resourceCode;
}

15
tyr-server/src/main/java/cn/axzo/tyr/server/repository/entity/SaasFeatureResource.java
View File

@ -134,6 +134,21 @@ public class SaasFeatureResource extends BaseEntity<SaasFeature> {
*/
private Long updateBy;
/**
* 应用范围(租户类型)：1:企业工作台 2;项目工作台
*/
private Long workspaceType;
/**
* 最低版本序列,主要支持版本灰度策略
*/
private Integer version;
/**
* 唯一编码，用于pre环境菜单同步
*/
private String uniCode;
public List<Long> splitPath() {
if (StrUtil.isBlank(this.path)) {
return Collections.emptyList();

9
tyr-server/src/main/java/cn/axzo/tyr/server/repository/mapper/DataObjectAttrMapper.java Normal file
View File

@ -0,0 +1,9 @@
package cn.axzo.tyr.server.repository.mapper;
import cn.axzo.tyr.server.repository.entity.DataObjectAttr;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface DataObjectAttrMapper extends BaseMapper<DataObjectAttr> {
}

9
tyr-server/src/main/java/cn/axzo/tyr/server/repository/mapper/DataObjectMapper.java Normal file
View File

@ -0,0 +1,9 @@
package cn.axzo.tyr.server.repository.mapper;
import cn.axzo.tyr.server.repository.entity.DataObject;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface DataObjectMapper extends BaseMapper<DataObject> {
}

9
tyr-server/src/main/java/cn/axzo/tyr/server/repository/mapper/DataObjectRuleAttrMapper.java Normal file
View File

@ -0,0 +1,9 @@
package cn.axzo.tyr.server.repository.mapper;
import cn.axzo.tyr.server.repository.entity.DataObjectRuleAttr;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface DataObjectRuleAttrMapper extends BaseMapper<DataObjectRuleAttr> {
}

9
tyr-server/src/main/java/cn/axzo/tyr/server/repository/mapper/DataObjectRuleMapper.java Normal file
View File

@ -0,0 +1,9 @@
package cn.axzo.tyr.server.repository.mapper;
import cn.axzo.tyr.server.repository.entity.DataObjectRule;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface DataObjectRuleMapper extends BaseMapper<DataObjectRule> {
}

9
tyr-server/src/main/java/cn/axzo/tyr/server/repository/mapper/DataObjectRuleScopeMapper.java Normal file
View File

@ -0,0 +1,9 @@
package cn.axzo.tyr.server.repository.mapper;
import cn.axzo.tyr.server.repository.entity.DataObjectRuleScope;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface DataObjectRuleScopeMapper extends BaseMapper<DataObjectRuleScope> {
}

13
tyr-server/src/main/java/cn/axzo/tyr/server/repository/mapper/DataResourceMapper.java Normal file
View File

@ -0,0 +1,13 @@
package cn.axzo.tyr.server.repository.mapper;
import cn.axzo.tyr.server.repository.entity.DataResource;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
* @author haiyangjin
* @date 2024/1/15
*/
@Mapper
public interface DataResourceMapper extends BaseMapper<DataResource> {
}

13
tyr-server/src/main/java/cn/axzo/tyr/server/repository/mapper/SaasFeatureDataResourceMapper.java Normal file
View File

@ -0,0 +1,13 @@
package cn.axzo.tyr.server.repository.mapper;
import cn.axzo.tyr.server.repository.entity.SaasFeatureDataResource;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
* @author haiyangjin
* @date 2024/1/15
*/
@Mapper
public interface SaasFeatureDataResourceMapper extends BaseMapper<SaasFeatureDataResource> {
}

11
tyr-server/src/main/java/cn/axzo/tyr/server/repository/mapper/SaasFeatureResourceMapper.java
View File

@ -1,7 +1,12 @@
package cn.axzo.tyr.server.repository.mapper;
import cn.axzo.tyr.server.model.FeatureResourceRoleCodeDTO;
import cn.axzo.tyr.server.repository.entity.SaasFeatureResource;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Update;
import java.util.List;
/**
* <p>
@ -13,4 +18,10 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
*/
public interface SaasFeatureResourceMapper extends BaseMapper<SaasFeatureResource> {
@Update("UPDATE saas_feature_resource" +
" SET path = REPLACE(path, #{oldPath}, #{newPath})" +
" WHERE is_delete = 0 AND path LIKE CONCAT(#{oldPath}, '%')")
void replacePath(@Param("oldPath") String oldPath, @Param("newPath") String newPath);
List<FeatureResourceRoleCodeDTO> listRoleCodes(@Param("ids") List<Long> ids);
}

20
tyr-server/src/main/java/cn/axzo/tyr/server/service/DataObjectService.java Normal file
View File

@ -0,0 +1,20 @@
package cn.axzo.tyr.server.service;
import cn.axzo.basics.common.page.PageResult;
import cn.axzo.tyr.client.model.req.CreateDataObjectReq;
import cn.axzo.tyr.client.model.req.EditDataObjectReq;
import cn.axzo.tyr.client.model.req.PageDataObjectReq;
import cn.axzo.tyr.client.model.res.DataObjectRes;
import cn.axzo.tyr.client.model.res.SimpleDataObjectRes;
public interface DataObjectService {
Long createDataObject(CreateDataObjectReq req);
void editDataObject(EditDataObjectReq req);
void deleteDataObject(Long dataObjectId, Long updateBy);
PageResult<SimpleDataObjectRes> pageDataObject(PageDataObjectReq req);
DataObjectRes getDataObject(Long dataObjectId);
}

82
tyr-server/src/main/java/cn/axzo/tyr/server/service/DataResourceService.java Normal file
View File

@ -0,0 +1,82 @@
package cn.axzo.tyr.server.service;
import cn.axzo.framework.domain.page.PageResp;
import cn.axzo.tyr.client.model.dataresource.req.CreateDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.DataResourceSaasFeatureParam;
import cn.axzo.tyr.client.model.dataresource.req.DeleteDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.GetSaasFeatureDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.PageDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.SearchDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.UpdateDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.resp.DataResourceResp;
import cn.axzo.tyr.client.model.dataresource.resp.PageDataResourceResp;
import java.util.List;
/**
* @author haiyangjin
* @date 2024/1/15
*/
public interface DataResourceService {
/**
* 创建数据资源
*
* @param param
*/
void create(CreateDataResourceParam param);
/**
* 删除数据资源
*
* @param param
* @return
*/
boolean delete(DeleteDataResourceParam param);
/**
* 数据资源列表
*
* @param param
* @return
*/
List<DataResourceResp> list(SearchDataResourceParam param);
/**
* 数据资源分页
*
* @param param
* @return
*/
PageResp<PageDataResourceResp> page(PageDataResourceParam param);
/**
* 数据资源更新
*
* @param param
* @return
*/
boolean update(UpdateDataResourceParam param);
/**
* 创建数据资源和featureCode关联关系
*
* @param param
*/
void createDataResourceSaasFeature(DataResourceSaasFeatureParam param);
/**
* 删除数据资源和featureCode关联关系
*
* @param param
* @return
*/
boolean deleteDataResourceSaasFeature(DataResourceSaasFeatureParam param);
/**
* 获取featureCode关联的数据资源
*
* @param param
* @return
*/
List<DataResourceResp> getSaasFeatureDataResource(GetSaasFeatureDataResourceParam param);
}

9
tyr-server/src/main/java/cn/axzo/tyr/server/service/SaasRoleUserService.java
View File

@ -2,6 +2,7 @@ package cn.axzo.tyr.server.service;
import cn.axzo.tyr.client.model.enums.IdentityType;
import cn.axzo.tyr.client.model.roleuser.dto.GetUserAutoOwnRoleResp;
import cn.axzo.tyr.client.model.roleuser.dto.GetUserFeatureResourceIdsResp;
import cn.axzo.tyr.client.model.roleuser.dto.SuperAminInfoResp;
import cn.axzo.tyr.client.model.roleuser.req.*;
import cn.axzo.tyr.server.repository.entity.SaasRoleUserRelation;
@ -97,4 +98,12 @@ public interface SaasRoleUserService {
* @return
*/
GetUserAutoOwnRoleResp getUserAutoOwnRole(GetUserAutoOwnRoleReq req);
/**
* 查询用户已有的功能资源
*
* @param req
* @return
*/
GetUserFeatureResourceIdsResp getUserFeatureResourceIds(GetUserFeatureResourceIdsReq req);
}

431
tyr-server/src/main/java/cn/axzo/tyr/server/service/impl/DataObjectServiceImpl.java Normal file
View File

@ -0,0 +1,431 @@
package cn.axzo.tyr.server.service.impl;
import cn.axzo.basics.common.exception.ServiceException;
import cn.axzo.basics.common.page.PageResult;
import cn.axzo.tyr.client.common.enums.ReturnCodeEnum;
import cn.axzo.tyr.client.common.enums.YesNoEnum;
import cn.axzo.tyr.client.model.data.object.AttributeBO;
import cn.axzo.tyr.client.model.data.object.AttributePermissionBO;
import cn.axzo.tyr.client.model.data.object.DataObjectAttrQueryBO;
import cn.axzo.tyr.client.model.data.object.DataObjectQueryBO;
import cn.axzo.tyr.client.model.data.object.DataObjectRuleBO;
import cn.axzo.tyr.client.model.data.object.DataObjectRuleQueryBO;
import cn.axzo.tyr.client.model.data.object.DefaultDataObjectRuleBO;
import cn.axzo.tyr.client.model.data.object.RuleAttrQueryBO;
import cn.axzo.tyr.client.model.data.object.RuleScopeQueryBO;
import cn.axzo.tyr.client.model.req.CreateDataObjectReq;
import cn.axzo.tyr.client.model.req.EditDataObjectReq;
import cn.axzo.tyr.client.model.req.PageDataObjectReq;
import cn.axzo.tyr.client.model.res.DataObjectRes;
import cn.axzo.tyr.client.model.res.SimpleDataObjectRes;
import cn.axzo.tyr.server.repository.dao.DataObjectAttrDao;
import cn.axzo.tyr.server.repository.dao.DataObjectDao;
import cn.axzo.tyr.server.repository.dao.DataObjectRuleAttrDao;
import cn.axzo.tyr.server.repository.dao.DataObjectRuleDao;
import cn.axzo.tyr.server.repository.dao.DataObjectRuleScopeDao;
import cn.axzo.tyr.server.repository.entity.DataObject;
import cn.axzo.tyr.server.repository.entity.DataObjectAttr;
import cn.axzo.tyr.server.repository.entity.DataObjectRule;
import cn.axzo.tyr.server.repository.entity.DataObjectRuleAttr;
import cn.axzo.tyr.server.repository.entity.DataObjectRuleScope;
import cn.axzo.tyr.server.service.DataObjectService;
import cn.axzo.tyr.server.utils.mapper.DataObjectMapper;
import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.google.common.collect.Lists;
import groovy.lang.Tuple2;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.support.TransactionTemplate;
import javax.annotation.Resource;
import javax.jws.Oneway;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
@Slf4j
@RequiredArgsConstructor
@Service
public class DataObjectServiceImpl implements DataObjectService {
private final DataObjectDao dataObjectDao;
private final DataObjectRuleDao dataObjectRuleDao;
private final DataObjectAttrDao dataObjectAttrDao;
private final DataObjectRuleAttrDao dataObjectRuleAttrDao;
private final DataObjectRuleScopeDao dataObjectRuleScopeDao;
@Resource
private TransactionTemplate transactionTemplate;
@Override
public Long createDataObject(CreateDataObjectReq req) {
// 校验
// objectName、objectCode不能重复
checkObjectNameOrCodeUnique(req.getDataObjectCode(), req.getDataObjectName());
// 对象属性名和code不能重复
checkObjectAttrNameOrCodeUnique(req.getAttrs());
// 规则名 不能重复
checkRuleNameUnique(req.getDataObjectRuleBOList());
// 对象属性与规则属性要一致
checkRuleAttrs(req.getAttrs(), req.getDataObjectRuleBOList(), req.getDefaultDataObjectRuleBO());
// 准备
DataObject dataObject = DataObjectMapper.INSTANCE.createReq2DataObject(req);
dataObject.setCreateBy(req.getCreateBy());
List<DataObjectAttr> objectAttrList = DataObjectMapper.INSTANCE.attributeBOs2DataObjectAttrs(req.getAttrs());
List<DataObjectRule> defaultDataObjectRules = DataObjectMapper.INSTANCE.defaultRuleBOs2Rules(Objects.nonNull(req.getDefaultDataObjectRuleBO()) ? Lists.newArrayList(req.getDefaultDataObjectRuleBO()) : null);
if (CollUtil.isNotEmpty(req.getDataObjectRuleBOList())) {
AtomicInteger sortId = new AtomicInteger(1);
req.getDataObjectRuleBOList().forEach(e -> e.setSort(sortId.getAndIncrement()));
}
List<DataObjectRule> dataObjectRules = DataObjectMapper.INSTANCE.ruleBOs2Rules(req.getDataObjectRuleBOList());
int size = (CollUtil.isNotEmpty(defaultDataObjectRules) ? defaultDataObjectRules.size() : 0)
+ (CollUtil.isNotEmpty(dataObjectRules) ? dataObjectRules.size() : 0);
List<DataObjectRule> generalObjectRuleList = new ArrayList<>(size);
// 入库
transactionTemplate.executeWithoutResult(status -> {
// 数据对象
dataObjectDao.save(dataObject);
// 数据对象规则
buildRuleList(defaultDataObjectRules, dataObject, req.getCreateBy(), generalObjectRuleList, dataObjectRules);
createSubordinate(req.getCreateBy(), dataObject, objectAttrList, generalObjectRuleList);
});
return dataObject.getId();
}
private void createSubordinate(Long createBy,
DataObject dataObject,
List<DataObjectAttr> objectAttrList,
List<DataObjectRule> generalObjectRuleList) {
// 数据对象字段
Map<String, Long> attrMap;
if (CollUtil.isNotEmpty(objectAttrList)) {
objectAttrList.forEach(e -> e.setDataObjectId(dataObject.getId())
.setDataObjectCode(dataObject.getDataObjectCode())
.setCreateBy(createBy));
dataObjectAttrDao.saveBatch(objectAttrList);
attrMap = objectAttrList.stream().collect(Collectors.toMap(DataObjectAttr::getAttrCode, DataObjectAttr::getId, (a, b) -> a));
} else {
attrMap = null;
}
if (CollUtil.isNotEmpty(generalObjectRuleList)) {
dataObjectRuleDao.saveBatch(generalObjectRuleList);
// 数据对象规则字段&范围
List<DataObjectRuleAttr> ruleAttrList = new ArrayList<>(CollUtil.isNotEmpty(attrMap) ? attrMap.size() : 0);
int sum = generalObjectRuleList.stream().map(e -> e.getDataObjectRuleScopeList().size()).mapToInt(Integer::intValue).sum();
List<DataObjectRuleScope> scopeList = new ArrayList<>(sum);
AtomicInteger sortId = new AtomicInteger();
generalObjectRuleList.forEach(rule -> {
if (CollUtil.isNotEmpty(attrMap) && CollUtil.isNotEmpty(rule.getDataObjectRuleAttrList())) {
sortId.set(1);
rule.getDataObjectRuleAttrList().forEach(ruleAttr -> {
Long id = attrMap.get(ruleAttr.getAttrCode());
if (Objects.isNull(id)) {
throw new cn.axzo.framework.domain.ServiceException(ReturnCodeEnum.ATTR_NOT_CONSISTENT.getMessage());
}
ruleAttr.setDataObjectAttrId(id);
ruleAttr.setDataObjectId(dataObject.getId());
ruleAttr.setDataObjectCode(dataObject.getDataObjectCode());
ruleAttr.setDataObjectRuleId(rule.getId());
ruleAttr.setCreateBy(createBy);
ruleAttr.setSort(sortId.getAndIncrement());
ruleAttrList.add(ruleAttr);
});
}
if (CollUtil.isNotEmpty(rule.getDataObjectRuleScopeList())) {
rule.getDataObjectRuleScopeList().forEach(scope -> {
scope.setRuleScopeType(rule.getRuleScopeType());
scope.setCreateBy(createBy);
scope.setDataObjectRuleId(rule.getId());
scope.setDataObjectId(rule.getDataObjectId());
scope.setDataObjectCode(rule.getDataObjectCode());
scopeList.add(scope);
});
}
});
dataObjectRuleAttrDao.saveBatch(ruleAttrList);
dataObjectRuleScopeDao.saveBatch(scopeList);
}
}
@Override
public void editDataObject(EditDataObjectReq req) {
// 对象属性名和code不能重复
checkObjectAttrNameOrCodeUnique(req.getAttrs());
// 规则名 不能重复
checkRuleNameUnique(req.getDataObjectRuleBOList());
// 对象属性与规则属性要一致
checkRuleAttrs(req.getAttrs(), req.getDataObjectRuleBOList(), req.getDefaultDataObjectRuleBO());
DataObject dataObject = dataObjectDao.getById(req.getDataObjectId());
if (Objects.isNull(dataObject)) {
throw new cn.axzo.framework.domain.ServiceException(ReturnCodeEnum.DATA_NOT_EXIST.getMessage());
}
if (!StringUtils.equals(req.getDataObjectName(), dataObject.getDataObjectName())) {
checkObjectNameOrCodeUnique(null, req.getDataObjectName());
dataObject.setDataObjectName(req.getDataObjectName());
}
dataObject.setMemo(req.getMemo());
dataObject.setTenantScope(req.getTenantScope());
dataObject.setSort(req.getSort());
dataObject.setUpdateBy(req.getUpdateBy());
List<DataObjectAttr> objectAttrList = DataObjectMapper.INSTANCE.attributeBOs2DataObjectAttrs(req.getAttrs());
List<DataObjectRule> defaultDataObjectRules = DataObjectMapper.INSTANCE.defaultRuleBOs2Rules(Lists.newArrayList(req.getDefaultDataObjectRuleBO()));
if (CollUtil.isNotEmpty(req.getDataObjectRuleBOList())) {
AtomicInteger sortId = new AtomicInteger(1);
req.getDataObjectRuleBOList().forEach(e -> e.setSort(sortId.getAndIncrement()));
}
List<DataObjectRule> dataObjectRules = DataObjectMapper.INSTANCE.ruleBOs2Rules(req.getDataObjectRuleBOList());
int size = (CollUtil.isNotEmpty(defaultDataObjectRules) ? defaultDataObjectRules.size() : 0)
+ (CollUtil.isNotEmpty(dataObjectRules) ? dataObjectRules.size() : 0);
List<DataObjectRule> generalObjectRuleList = new ArrayList<>(size);
buildRuleList(defaultDataObjectRules, dataObject, req.getUpdateBy(), generalObjectRuleList, dataObjectRules);
transactionTemplate.executeWithoutResult(status -> {
dataObjectDao.updateById(dataObject);
deleteSubordinat(req.getUpdateBy(), Collections.singletonList(req.getDataObjectId()));
createSubordinate(req.getUpdateBy(), dataObject, objectAttrList, generalObjectRuleList);
});
}
private static void buildRuleList(List<DataObjectRule> defaultDataObjectRules,
DataObject dataObject,
Long createBy,
List<DataObjectRule> generalObjectRuleList, List<DataObjectRule> dataObjectRules) {
// 数据对象规则
if (CollUtil.isNotEmpty(defaultDataObjectRules)) {
defaultDataObjectRules.forEach(e -> e.setDataObjectId(dataObject.getId())
.setDataObjectCode(dataObject.getDataObjectCode())
.setIsDefault(YesNoEnum.YES.getValue())
.setCreateBy(createBy));
generalObjectRuleList.addAll(defaultDataObjectRules);
}
if (CollUtil.isNotEmpty(dataObjectRules)) {
dataObjectRules.forEach(e -> e.setDataObjectId(dataObject.getId())
.setDataObjectCode(dataObject.getDataObjectCode())
.setIsDefault(YesNoEnum.NO.getValue())
.setCreateBy(createBy));
generalObjectRuleList.addAll(dataObjectRules);
}
}
@Override
public void deleteDataObject(Long dataObjectId, Long updateBy) {
List<Long> idList = Collections.singletonList(dataObjectId);
transactionTemplate.executeWithoutResult(status -> {
dataObjectDao.deleteByIdList(idList, updateBy);
deleteSubordinat(updateBy, idList);
});
}
private void deleteSubordinat(Long updateBy, List<Long> idList) {
dataObjectRuleDao.deleteByDataObjectIdList(idList, updateBy);
dataObjectAttrDao.deleteByDataObjectIdList(idList, updateBy);
dataObjectRuleAttrDao.deleteByDataObjectIdList(idList, updateBy);
dataObjectRuleScopeDao.deleteByDataObjectIdList(idList, updateBy);
}
@Override
public PageResult<SimpleDataObjectRes> pageDataObject(PageDataObjectReq req) {
DataObjectQueryBO bo = DataObjectQueryBO.builder().dataObjectName(req.getKeyword()).build();
bo.setPage(req.getPage());
bo.setPageSize(req.getPageSize());
IPage<DataObject> dataObjectIPage = dataObjectDao.pageByBO(bo);
List<SimpleDataObjectRes> resList = dataObjectIPage.getRecords().stream()
.map(e -> SimpleDataObjectRes.builder()
.dataObjectId(e.getId())
.dataObjectCode(e.getDataObjectCode())
.dataObjectName(e.getDataObjectName())
.build())
.collect(Collectors.toList());
return new PageResult<>(resList, dataObjectIPage.getTotal());
}
@Override
public DataObjectRes getDataObject(Long dataObjectId) {
// 获取数据对象
DataObject dataObject = dataObjectDao.getById(dataObjectId);
if (Objects.isNull(dataObject)) {
throw new cn.axzo.framework.domain.ServiceException(ReturnCodeEnum.DATA_NOT_EXIST.getMessage());
}
DataObjectRes res = DataObjectMapper.INSTANCE.dataObject2DataObjectRes(dataObject);
// 获取数据对象字段
DataObjectAttrQueryBO bo1 = DataObjectAttrQueryBO.builder().dataObjectId(dataObjectId).build();
List<DataObjectAttr> objectAttrList = dataObjectAttrDao.listByBO(bo1);
Map<String, String> attrMap;
if (CollUtil.isNotEmpty(objectAttrList)) {
List<AttributeBO> attributeBOS = DataObjectMapper.INSTANCE.dataObjectAttrs2AttributeBOs(objectAttrList);
List<AttributeBO> attributeBOList = attributeBOS.stream().sorted(Comparator.comparing(AttributeBO::getSort)).collect(Collectors.toList());
res.setAttrs(attributeBOList);
attrMap = attributeBOList.stream().collect(Collectors.toMap(AttributeBO::getAttrCode, AttributeBO::getAttrName, (a, b) -> a));
} else {
attrMap = null;
}
// 获取数据对象规则
DataObjectRuleQueryBO bo2 = DataObjectRuleQueryBO.builder().dataObjectId(dataObjectId).build();
List<DataObjectRule> dataObjectRules = dataObjectRuleDao.listByBO(bo2);
if (CollUtil.isNotEmpty(dataObjectRules)) {
res.setDataObjectRuleBOList(new ArrayList<>(dataObjectRules.size() - 1));
dataObjectRules.forEach(e -> {
if (YesNoEnum.YES.getValue().equals(e.getIsDefault())) {
DefaultDataObjectRuleBO ruleBO = DataObjectMapper.INSTANCE.rule2DefaultRuleBO(e);
res.setDefaultDataObjectRuleBO(ruleBO);
} else {
DataObjectRuleBO ruleBO = DataObjectMapper.INSTANCE.rule2RuleBO(e);
res.getDataObjectRuleBOList().add(ruleBO);
}
});
if (CollUtil.isNotEmpty(res.getDataObjectRuleBOList())) {
List<DataObjectRuleBO> sortedRuleList = res.getDataObjectRuleBOList().stream().sorted(Comparator.comparing(DataObjectRuleBO::getSort)).collect(Collectors.toList());
res.setDataObjectRuleBOList(sortedRuleList);
}
}
// 获取数据对象规则字段
RuleAttrQueryBO bo3 = RuleAttrQueryBO.builder().dataObjectId(dataObjectId).build();
List<DataObjectRuleAttr> ruleAttrList = dataObjectRuleAttrDao.listByBO(bo3);
if (CollUtil.isNotEmpty(attrMap) && CollUtil.isNotEmpty(ruleAttrList)) {
Map<Long, List<DataObjectRuleAttr>> ruleAttrMap = ruleAttrList.stream().collect(Collectors.groupingBy(DataObjectRuleAttr::getDataObjectRuleId));
// 默认
List<DataObjectRuleAttr> ruleAttrList1 = ruleAttrMap.get(res.getDefaultDataObjectRuleBO().getDataObjectRuleId());
if (CollUtil.isNotEmpty(ruleAttrList1)) {
List<AttributePermissionBO> permissionBOs = DataObjectMapper.INSTANCE.ruleAttrs2AttrPermissionBOs(ruleAttrList1);
permissionBOs.forEach(e -> e.setAttrName(attrMap.get(e.getAttrCode())));
List<AttributePermissionBO> permissionBOList = permissionBOs.stream().sorted(Comparator.comparing(AttributePermissionBO::getSort)).collect(Collectors.toList());
res.getDefaultDataObjectRuleBO().setAttributePermissionBOList(permissionBOList);
}
//自定义
if (CollUtil.isNotEmpty(res.getDataObjectRuleBOList())) {
res.getDataObjectRuleBOList().forEach(e -> buildRuleAttr(attrMap, ruleAttrMap, e));
}
}
// 获取数据对象规则范围
RuleScopeQueryBO bo4 = RuleScopeQueryBO.builder().dataObjectId(dataObjectId).build();
List<DataObjectRuleScope> scopeList = dataObjectRuleScopeDao.listByBO(bo4);
if (CollUtil.isNotEmpty(scopeList)) {
Map<Long, List<DataObjectRuleScope>> scopeMap = scopeList.stream().collect(Collectors.groupingBy(DataObjectRuleScope::getDataObjectRuleId));
// 默认
List<DataObjectRuleScope> defaultScopeList = scopeMap.get(res.getDefaultDataObjectRuleBO().getDataObjectRuleId());
if (CollUtil.isNotEmpty(defaultScopeList)) {
List<Long> relationIdList = defaultScopeList.stream().map(DataObjectRuleScope::getRelationId).collect(Collectors.toList());
res.getDefaultDataObjectRuleBO().setRelationId(relationIdList);
}
//自定义
if (CollUtil.isNotEmpty(res.getDataObjectRuleBOList())) {
res.getDataObjectRuleBOList().forEach(e -> {
List<DataObjectRuleScope> scopeList1 = scopeMap.get(e.getDataObjectRuleId());
if (CollUtil.isNotEmpty(scopeList1)) {
List<Long> relationIdList = scopeList1.stream().map(DataObjectRuleScope::getRelationId).collect(Collectors.toList());
e.setRelationId(relationIdList);
}
});
}
}
return res;
}
private static void buildRuleAttr(Map<String, String> attrMap, Map<Long, List<DataObjectRuleAttr>> ruleAttrMap, DataObjectRuleBO e) {
List<DataObjectRuleAttr> ruleAttrList2 = ruleAttrMap.get(e.getDataObjectRuleId());
if (CollUtil.isNotEmpty(ruleAttrList2)) {
List<AttributePermissionBO> permissionBOs = DataObjectMapper.INSTANCE.ruleAttrs2AttrPermissionBOs(ruleAttrList2);
permissionBOs.forEach(bo -> bo.setAttrName(attrMap.get(bo.getAttrCode())));
List<AttributePermissionBO> permissionBOList = permissionBOs.stream().sorted(Comparator.comparing(AttributePermissionBO::getSort)).collect(Collectors.toList());
e.setAttributePermissionBOList(permissionBOList);
}
}
private void checkRuleAttrs(List<AttributeBO> attrs, List<DataObjectRuleBO> dataObjectRuleBOList, DefaultDataObjectRuleBO defaultDataObjectRuleBO) {
int attrSize = CollUtil.isNotEmpty(attrs) ? attrs.size() : 0;
int defaultAttrSize = CollUtil.isNotEmpty(defaultDataObjectRuleBO.getAttributePermissionBOList()) ? defaultDataObjectRuleBO.getAttributePermissionBOList().size() : 0;
if (attrSize != defaultAttrSize) {
throw new ServiceException(ReturnCodeEnum.ATTR_NOT_CONSISTENT.getMessage());
}
if (CollUtil.isNotEmpty(dataObjectRuleBOList)) {
dataObjectRuleBOList.forEach(e -> {
int ruleAttrSize = CollUtil.isNotEmpty(e.getAttributePermissionBOList()) ? e.getAttributePermissionBOList().size() : 0;
if (attrSize != ruleAttrSize) {
throw new ServiceException(ReturnCodeEnum.ATTR_NOT_CONSISTENT.getMessage());
}
});
}
}
private void checkRuleNameUnique(List<DataObjectRuleBO> dataObjectRuleBOList) {
if (CollUtil.isNotEmpty(dataObjectRuleBOList)) {
List<String> nameList = dataObjectRuleBOList.stream().map(DataObjectRuleBO::getDataObjectRuleName).distinct().collect(Collectors.toList());
if (nameList.size() < dataObjectRuleBOList.size()) {
throw new ServiceException(ReturnCodeEnum.DATA_OBJECT_RULE_DUPLICATE.getMessage());
}
}
}
private static void checkObjectAttrNameOrCodeUnique(List<AttributeBO> attrs) {
if (CollUtil.isNotEmpty(attrs)) {
List<String> attrNameList = attrs.stream().map(AttributeBO::getAttrName).distinct().collect(Collectors.toList());
List<String> attrCodeList = attrs.stream().map(AttributeBO::getAttrCode).distinct().collect(Collectors.toList());
if (attrNameList.size() < attrs.size() || attrCodeList.size() < attrs.size()) {
throw new ServiceException(ReturnCodeEnum.DATA_OBJECT_ATTR_NAME_CODE_DUPLICATE.getMessage());
}
}
}
private void checkObjectNameOrCodeUnique(String dataObjectCode, String dataObjectName) {
DataObjectQueryBO bo = DataObjectQueryBO.builder()
.dataObjectName(dataObjectName)
.dataObjectCode(dataObjectCode)
.build();
List<DataObject> dataObjects = dataObjectDao.duplicateListByBO(bo);
if (CollUtil.isNotEmpty(dataObjects)) {
boolean nameDuplicate = false;
boolean codeDuplicate = false;
for (DataObject dataObject : dataObjects) {
if (dataObject.getDataObjectName().equals(dataObjectName)) {
nameDuplicate = true;
}
if (dataObject.getDataObjectCode().equals(dataObjectCode)) {
codeDuplicate = true;
}
}
if (nameDuplicate && codeDuplicate) {
throw new ServiceException(ReturnCodeEnum.DATA_OBJECT_NAME_CODE_DUPLICATE.getMessage());
} else if (nameDuplicate) {
throw new ServiceException(ReturnCodeEnum.DATA_OBJECT_NAME_DUPLICATE.getMessage());
} else if (codeDuplicate) {
throw new ServiceException(ReturnCodeEnum.DATA_OBJECT_CODE_DUPLICATE.getMessage());
}
}
}
}

175
tyr-server/src/main/java/cn/axzo/tyr/server/service/impl/DataResourceServiceImpl.java Normal file
View File

@ -0,0 +1,175 @@
package cn.axzo.tyr.server.service.impl;
import cn.axzo.basics.common.BeanMapper;
import cn.axzo.basics.common.constant.enums.TableIsDeleteEnum;
import cn.axzo.framework.domain.page.PageResp;
import cn.axzo.framework.domain.web.code.BaseCode;
import cn.axzo.tyr.client.common.enums.DataResourceTypeEnum;
import cn.axzo.tyr.client.model.dataresource.req.CreateDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.DataResourceSaasFeatureParam;
import cn.axzo.tyr.client.model.dataresource.req.DeleteDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.GetSaasFeatureDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.PageDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.SearchDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.req.UpdateDataResourceParam;
import cn.axzo.tyr.client.model.dataresource.resp.DataResourceResp;
import cn.axzo.tyr.client.model.dataresource.resp.PageDataResourceResp;
import cn.axzo.tyr.server.common.util.Throws;
import cn.axzo.tyr.server.repository.dao.DataResourceDao;
import cn.axzo.tyr.server.repository.dao.SaasFeatureDao;
import cn.axzo.tyr.server.repository.dao.SaasFeatureDataResourceDao;
import cn.axzo.tyr.server.repository.entity.DataResource;
import cn.axzo.tyr.server.repository.entity.SaasFeature;
import cn.axzo.tyr.server.repository.entity.SaasFeatureDataResource;
import cn.axzo.tyr.server.service.DataResourceService;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
/**
* @author haiyangjin
* @date 2024/1/15
*/
@Slf4j
@RequiredArgsConstructor
@Service
public class DataResourceServiceImpl implements DataResourceService {
private final DataResourceDao dataResourceDao;
private final SaasFeatureDao saasFeatureDao;
private final SaasFeatureDataResourceDao saasFeatureDataResourceDao;
@Override
public void create(CreateDataResourceParam param) {
DataResource existDataResource = dataResourceDao.lambdaQuery()
.eq(DataResource::getResourceCode, param.getResourceCode())
.eq(DataResource::getIsDelete, TableIsDeleteEnum.NORMAL.value)
.last("limit 1")
.one();
if (Objects.nonNull(existDataResource)) {
Throws.bizException(BaseCode.BAD_REQUEST, "数据对象code已经存在！");
}
DataResource dataResource = new DataResource();
BeanUtils.copyProperties(param, dataResource);
if (Objects.nonNull(param.getParentId()) && param.getParentId() > 0) {
DataResource parent = dataResourceDao.getById(param.getParentId());
if (Objects.isNull(parent)) {
Throws.bizException(BaseCode.BAD_REQUEST, "数据对象不存在！");
}
dataResource.setType(DataResourceTypeEnum.SUB_OBJECT);
}
dataResourceDao.save(dataResource);
}
@Override
public boolean delete(DeleteDataResourceParam param) {
DataResource dataResource = dataResourceDao.getById(param.getId());
if (Objects.nonNull(dataResource)) {
List<SaasFeatureDataResource> saasFeatureDataResources = saasFeatureDataResourceDao.lambdaQuery()
.eq(SaasFeatureDataResource::getResourceCode, dataResource.getResourceCode())
.eq(SaasFeatureDataResource::getIsDelete, TableIsDeleteEnum.NORMAL.value)
.list();
if (CollectionUtils.isNotEmpty(saasFeatureDataResources)) {
Throws.bizException(BaseCode.BAD_REQUEST, "该数据资源和功能权限有关联不能删除！");
}
dataResourceDao.removeById(dataResource.getId());
}
return true;
}
@Override
public List<DataResourceResp> list(SearchDataResourceParam param) {
List<DataResource> dataResources = dataResourceDao.lambdaQuery()
.in(CollectionUtils.isNotEmpty(param.getResourceCodes()), DataResource::getResourceCode, param.getResourceCodes())
.list();
return BeanUtil.copyToList(dataResources, DataResourceResp.class);
}
@Override
public PageResp<PageDataResourceResp> page(PageDataResourceParam param) {
IPage<DataResource> page = dataResourceDao.lambdaQuery()
.like(Objects.nonNull(param.getName()), DataResource::getName, param.getName())
.eq(CollectionUtils.isNotEmpty(param.getResourceCodes()), DataResource::getResourceCode, param.getResourceCodes())
.eq(Objects.nonNull(param.getModule()), DataResource::getModule, param.getModule())
.eq(Objects.nonNull(param.getType()), DataResource::getType, param.getType())
.eq(Objects.nonNull(param.getParentId()), DataResource::getParentId, param.getParentId())
.page(param.toPage());
List<PageDataResourceResp> list = BeanMapper.copyList(page.getRecords(), PageDataResourceResp.class);
return PageResp.list(page.getCurrent(), page.getSize(), page.getTotal(), list);
}
@Override
public boolean update(UpdateDataResourceParam param) {
DataResource dataResource = new DataResource();
BeanUtils.copyProperties(param, dataResource);
return dataResourceDao.updateById(dataResource);
}
@Override
public void createDataResourceSaasFeature(DataResourceSaasFeatureParam param) {
DataResource existDataResource = dataResourceDao.lambdaQuery()
.eq(DataResource::getResourceCode, param.getResourceCode())
.eq(DataResource::getIsDelete, TableIsDeleteEnum.NORMAL.value)
.last("limit 1")
.one();
if (Objects.isNull(existDataResource)) {
Throws.bizException(BaseCode.BAD_REQUEST, "数据对象不存在！");
}
List<String> existFeatureCodes = saasFeatureDataResourceDao.lambdaQuery()
.eq(SaasFeatureDataResource::getResourceCode, param.getResourceCode())
.in(SaasFeatureDataResource::getFeatureCode, param.getFeatureCodes())
.eq(SaasFeatureDataResource::getIsDelete, TableIsDeleteEnum.NORMAL.value)
.list()
.stream()
.map(SaasFeatureDataResource::getFeatureCode)
.collect(Collectors.toList());
param.getFeatureCodes().removeAll(existFeatureCodes);
if (CollectionUtils.isEmpty(param.getFeatureCodes())) {
return;
}
List<SaasFeature> saasFeatures = saasFeatureDao.lambdaQuery()
.in(SaasFeature::getFeatureCode, param.getFeatureCodes())
.eq(SaasFeature::getIsDelete, TableIsDeleteEnum.NORMAL.value)
.list();
Set<SaasFeatureDataResource> saasFeatureDataResources = saasFeatures.stream().map(e -> SaasFeatureDataResource.builder()
.resourceCode(param.getResourceCode())
.featureCode(e.getFeatureCode())
.build()).collect(Collectors.toSet());
saasFeatureDataResourceDao.saveBatch(saasFeatureDataResources);
}
@Override
public boolean deleteDataResourceSaasFeature(DataResourceSaasFeatureParam param) {
return saasFeatureDataResourceDao.remove(new LambdaQueryWrapper<SaasFeatureDataResource>()
.eq(SaasFeatureDataResource::getResourceCode, param.getResourceCode())
.in(SaasFeatureDataResource::getFeatureCode, param.getFeatureCodes()));
}
@Override
public List<DataResourceResp> getSaasFeatureDataResource(GetSaasFeatureDataResourceParam param) {
Set<String> dataResourceCodes = saasFeatureDataResourceDao.lambdaQuery()
.eq(SaasFeatureDataResource::getFeatureCode, param.getFeatureCode())
.eq(SaasFeatureDataResource::getIsDelete, TableIsDeleteEnum.NORMAL.value)
.list()
.stream().map(SaasFeatureDataResource::getResourceCode).collect(Collectors.toSet());
List<DataResource> dataResources = dataResourceDao.lambdaQuery()
.in(DataResource::getResourceCode, dataResourceCodes)
.eq(DataResource::getIsDelete, TableIsDeleteEnum.NORMAL.value)
.list();
return BeanUtil.copyToList(dataResources, DataResourceResp.class);
}
}

Some files were not shown because too many files have changed in this diff Show More