Merge branch 'feature/REQ-2299' into 'master'

Feature/req 2299

See merge request universal/infrastructure/backend/tyr!47
This commit is contained in:
金海洋 2024-05-08 08:25:20 +00:00
commit 09e660f9ec
87 changed files with 3799 additions and 22 deletions

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

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 "请勿重复提交";
}

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);
}
}

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;
}

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;
}

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;
}

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());
}
}

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;
}

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);
}
}

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;
}

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;
}

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);
}

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);
}

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);
}

View File

@ -5,6 +5,7 @@ import cn.axzo.framework.domain.web.result.ApiPageResult;
import cn.axzo.framework.domain.web.result.ApiResult;
import cn.axzo.tyr.client.model.req.ChangeGroupLeaderRoleReq;
import cn.axzo.tyr.client.model.req.FeatureRoleRelationReq;
import cn.axzo.tyr.client.model.req.ListRoleReq;
import cn.axzo.tyr.client.model.req.PageRoleReq;
import cn.axzo.tyr.client.model.req.QueryByIdentityIdTypeReq;
import cn.axzo.tyr.client.model.req.QueryRoleByNameReq;
@ -183,4 +184,12 @@ public interface TyrSaasRoleApi {
*/
@PostMapping("/api/saasRole/page")
ApiPageResult<SaasRoleRes> page(@RequestBody PageRoleReq request);
/**
* 角色列表接口
* @param request
* @return
*/
@PostMapping("/api/saasRole/list")
ApiListResult<SaasRoleRes> list(@RequestBody ListRoleReq request);
}

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-支持
}

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-可编辑
}

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-支持
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

View File

@ -2,6 +2,7 @@ package cn.axzo.tyr.client.model.enums;
import com.baomidou.mybatisplus.annotation.EnumValue;
import com.fasterxml.jackson.annotation.JsonValue;
import lombok.AllArgsConstructor;
import lombok.Getter;
import java.util.Arrays;
@ -13,27 +14,30 @@ import java.util.Arrays;
* @modifiedBy
* @version: 1.0
*/
@AllArgsConstructor
public enum DictWorkSpaceTypeEnum {
/**
* 企业工作台
*/
ENT("ent", "企业工作台", 7,1),
ENT("ent", "企业工作台", 7,1, "单位租户"),
/**
* 项目部工作台
*/
PROJ("proj", "项目部工作台",1,2),
PROJ("proj", "项目部工作台",1,2, "项目租户"),
GOVERNMENT("government", "政务监管平台",3,3, "政务监管平台"),
/**
* OMS工作台
*/
OMS("oms", "OMS工作台",6,6),
OMS("oms", "OMS工作台",6,6, "OMS"),
/**
* 班组工作台
*/
TEAM("team","班组工作台",0,0)
TEAM("team","班组工作台",0,0, "")
;
@EnumValue
@ -46,6 +50,8 @@ public enum DictWorkSpaceTypeEnum {
private final Integer superAdminProductType;
@Getter
private final Integer workspaceType;
@Getter
private final String tenantScopeDesc;
public String getValue() {
@ -56,13 +62,6 @@ public enum DictWorkSpaceTypeEnum {
return description;
}
DictWorkSpaceTypeEnum(String value, String description, Integer superAdminProductType, Integer workspaceType) {
this.value = value;
this.description = description;
this.superAdminProductType = superAdminProductType;
this.workspaceType = workspaceType;
}
/**
* 通过value值获取枚举类型
*

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;
}

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;
}

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;
}

View File

@ -0,0 +1,35 @@
package cn.axzo.tyr.client.model.req;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.util.List;
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class ListRoleReq {
private List<Long> roleIds;
private Integer workspaceType;
private Boolean isDisplay;
private String roleCode;
private List<Long> workspaceIds;
private List<Long> ouIds;
private Boolean enabled;
private List<String> roleTypes;
private Boolean needPermission;
private Boolean needRoleGroup;
}

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;
}

View File

@ -4,20 +4,17 @@ import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.util.List;
@Data
@Builder
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class PageRoleReq {
public class PageRoleReq extends ListRoleReq {
private List<Long> roleIds;
private Boolean needPermission;
private Boolean needRoleGroup;
private Integer page;

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;
}

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;
}

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;
}

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>
@ -127,6 +128,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>

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;

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----------------------------------------------------------");
}
}

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----------------------------------------------------------");
}
}

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----------------------------------------------------------");
}
}

View File

@ -25,7 +25,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());
}

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));
}
}

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));
}
}

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);
}
}

View File

@ -9,6 +9,7 @@ import cn.axzo.tyr.client.model.enums.DictWorkSpaceTypeEnum;
import cn.axzo.tyr.client.model.req.ChangeGroupLeaderRoleReq;
import cn.axzo.tyr.client.model.req.CommonDictQueryReq;
import cn.axzo.tyr.client.model.req.FeatureRoleRelationReq;
import cn.axzo.tyr.client.model.req.ListRoleReq;
import cn.axzo.tyr.client.model.req.PageRoleReq;
import cn.axzo.tyr.client.model.req.QueryByIdentityIdTypeReq;
import cn.axzo.tyr.client.model.req.QueryRoleByNameReq;
@ -297,6 +298,13 @@ public class SaasRoleController implements TyrSaasRoleApi {
return ApiPageResult.ok(page.getRecords(), page.getTotal(), (int) page.getCurrent(), (int) page.getSize());
}
@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

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();
}
}

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();
}
}

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();
}
}

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();
}
}

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();
}
}

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> {
}

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> {
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

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> {
}

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> {
}

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> {
}

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> {
}

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> {
}

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> {
}

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> {
}

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);
}

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);
}

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) {
// 校验
// objectNameobjectCode不能重复
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());
}
}
}
}

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);
}
}

View File

@ -0,0 +1,9 @@
package cn.axzo.tyr.server.utils;
import cn.axzo.pokonyan.config.mybatisplus.BaseEntity;
import com.baomidou.mybatisplus.extension.activerecord.Model;
public abstract class BaseDataEntity <T extends Model<T>> extends BaseEntity<T> {
public BaseDataEntity() {
}
}

View File

@ -0,0 +1,25 @@
package cn.axzo.tyr.server.utils;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import lombok.Data;
import lombok.experimental.SuperBuilder;
import java.io.Serializable;
@Data
public abstract class BaseOperatorEntity<T extends Model<T>> extends BaseDataEntity<T> implements Serializable {
@TableField(
fill = FieldFill.INSERT
)
protected Long createBy;
@TableField(
fill = FieldFill.UPDATE
)
protected Long updateBy;
protected boolean canEqual(final Object other) {
return other instanceof BaseOperatorEntity;
}
}

View File

@ -0,0 +1,181 @@
package cn.axzo.tyr.server.utils;
import cn.axzo.framework.auth.domain.ContextInfo;
import cn.axzo.framework.auth.domain.ContextInfoHolder;
import cn.axzo.framework.domain.ServiceException;
import cn.axzo.tyr.client.common.annotation.RepeatedSubmit;
import cn.hutool.core.text.CharSequenceUtil;
import cn.hutool.core.util.StrUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.StringJoiner;
import java.util.concurrent.TimeUnit;
/**
* 重复提交切面
*
**/
@Aspect
@Component
@Slf4j
@RequiredArgsConstructor
public class RepeatedSubmitAspect {
private final RedissonClient redissonClient;
@Around("@annotation(repeatedSubmit)")
public Object lock(ProceedingJoinPoint joinPoint, RepeatedSubmit repeatedSubmit)
throws Exception {
String redisKey;
RLock lock = null;
try {
RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
HttpServletRequest httpServletRequest = ((ServletRequestAttributes) attributes).getRequest();
String uri = httpServletRequest.getRequestURI();
String methodName = httpServletRequest.getMethod();
String errorMsg = repeatedSubmit.msg();
StringJoiner stringJoiner = new StringJoiner(":");
stringJoiner.add("URI_LIMIT");
String spElKey = repeatedSubmit.spElKey();
/*
* 1.如果指定了key,将使用自定义的key
* 2.否则使用uri当作redis的key
*/
if (CharSequenceUtil.isNotBlank(spElKey)) {
getKeyBySpElExpression(stringJoiner, joinPoint, repeatedSubmit);
} else {
stringJoiner.add(uri).add(methodName);
/*
* 1.unique为true时,redis不添加用户id
* 2.unique为false时,只针对当前用户做过滤
*/
if (!repeatedSubmit.unique()) {
ContextInfo contextInfo = ContextInfoHolder.get();
Long userId = null;
if (null != contextInfo) {
userId = contextInfo.getUserInfo().getPersonId();
}
if (null == userId) {
throw new ServiceException("获取用户信息失败");
}
stringJoiner.add(String.valueOf(userId));
}
}
redisKey = stringJoiner.toString();
/*
* redis加锁
*/
lock = redissonClient.getLock(redisKey);
boolean flag = lock.tryLock(1500, TimeUnit.MILLISECONDS);
if (!flag) {
/*防止释放别人的锁,所以将其置空*/
lock = null;
log.info("请稍后重试!,redisKey={}", redisKey);
throw new ServiceException(errorMsg);
}
return joinPoint.proceed();
} catch (Throwable throwable) {
throw (Exception) throwable;
} finally {
if (null != lock) {
try {
//释放锁时,有可能释放别人的锁,所以捕获异常,不抛异常
lock.unlock();
} catch (Exception e) {
}
}
}
}
/**
* 根据spEl获取key值
*
* @param stringJoiner
* @param joinPoint
* @param repeatedSubmit
*/
private void getKeyBySpElExpression(StringJoiner stringJoiner, ProceedingJoinPoint joinPoint
, RepeatedSubmit repeatedSubmit) {
//读取spEl表达式中的值
Object[] args = joinPoint.getArgs();
Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
String spElValue = getSpElValue(args, method, repeatedSubmit.spElKey());
stringJoiner.add(spElValue);
}
/**
* 获取spEl值
*
* @param arguments
* @param signatureMethod
* @param spelKey
* @return 返回spel值
*/
private String getSpElValue(Object[] arguments, Method signatureMethod, String spelKey) {
EvaluationContext context = getContext(arguments, signatureMethod);
if (null == context) {
return CharSequenceUtil.EMPTY;
}
String value = getValue(context, spelKey, String.class);
if (CharSequenceUtil.isBlank(value)) {
return CharSequenceUtil.EMPTY;
}
return value;
}
/**
* 获取spel 定义的参数值
*
* @param context 参数容器
* @param key key
* @param clazz 需要返回的类型
* @param <T> 返回泛型
* @return 参数值
*/
private <T> T getValue(EvaluationContext context, String key, Class<T> clazz) {
SpelExpressionParser spelExpressionParser = new SpelExpressionParser();
Expression expression = spelExpressionParser.parseExpression(key);
return expression.getValue(context, clazz);
}
/**
* 获取参数容器
*
* @param arguments 方法的参数列表
* @param signatureMethod 被执行的方法体
* @return 装载参数的容器
*/
private EvaluationContext getContext(Object[] arguments, Method signatureMethod) {
String[] parameterNames = new LocalVariableTableParameterNameDiscoverer()
.getParameterNames(signatureMethod);
if (parameterNames == null) {
return null;
}
EvaluationContext context = new StandardEvaluationContext();
for (int i = 0; i < arguments.length; i++) {
context.setVariable(parameterNames[i], arguments[i]);
}
return context;
}
}

View File

@ -0,0 +1,88 @@
package cn.axzo.tyr.server.utils.mapper;
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.DataObjectRuleBO;
import cn.axzo.tyr.client.model.data.object.DefaultDataObjectRuleBO;
import cn.axzo.tyr.client.model.req.CreateDataObjectReq;
import cn.axzo.tyr.client.model.req.EditDataObjectReq;
import cn.axzo.tyr.client.model.res.DataObjectRes;
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.hutool.core.collection.CollUtil;
import com.google.common.collect.Lists;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
import org.mapstruct.Named;
import org.mapstruct.factory.Mappers;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
@Mapper
public interface DataObjectMapper {
DataObjectMapper INSTANCE = Mappers.getMapper(DataObjectMapper.class);
DataObject createReq2DataObject(CreateDataObjectReq req);
DataObject editReq2DataObject(EditDataObjectReq req);
DataObjectRes dataObject2DataObjectRes(DataObject req);
DataObjectAttr attributeBO2DataObjectAttr(AttributeBO bo);
@Mapping(source = "id", target = "dataObjectAttrId")
AttributeBO dataObjectAttr2AttributeBO(DataObjectAttr bo);
DataObjectRuleAttr attrPermissionBO2RuleAttr(AttributePermissionBO bo);
AttributePermissionBO attr2AttrPermissionBO(DataObjectRuleAttr bo);
@Mapping(source = "dataObjectRuleName", target = "name")
@Mapping(source = "attributePermissionBOList", target = "dataObjectRuleAttrList")
@Mapping(source = "relationId", target = "dataObjectRuleScopeList", qualifiedByName = "mapRelationId2RuleScope")
DataObjectRule defaultRuleBO2Rule(DefaultDataObjectRuleBO bo);
@Mapping(source = "name", target = "dataObjectRuleName")
@Mapping(source = "id", target = "dataObjectRuleId")
DefaultDataObjectRuleBO rule2DefaultRuleBO(DataObjectRule bo);
@Mapping(source = "dataObjectRuleName", target = "name")
@Mapping(source = "attributePermissionBOList", target = "dataObjectRuleAttrList")
@Mapping(source = "relationId", target = "dataObjectRuleScopeList", qualifiedByName = "mapRelationId2RuleScope")
DataObjectRule ruleBO2Rule(DataObjectRuleBO bo);
@Mapping(source = "name", target = "dataObjectRuleName")
@Mapping(source = "id", target = "dataObjectRuleId")
DataObjectRuleBO rule2RuleBO(DataObjectRule bo);
List<DataObjectAttr> attributeBOs2DataObjectAttrs(List<AttributeBO> bo);
List<AttributeBO> dataObjectAttrs2AttributeBOs(List<DataObjectAttr> bo);
List<DataObjectRule> defaultRuleBOs2Rules(List<DefaultDataObjectRuleBO> bo);
List<DefaultDataObjectRuleBO> rules2defaultRuleBOs(List<DataObjectRule> bo);
List<DataObjectRule> ruleBOs2Rules(List<DataObjectRuleBO> bo);
List<DataObjectRuleBO> rules2RuleBOs(List<DataObjectRule> bo);
List<AttributePermissionBO> ruleAttrs2AttrPermissionBOs(List<DataObjectRuleAttr> bo);
@Named("mapRelationId2RuleScope")
default List<DataObjectRuleScope> mapIntegerToBoolean(List<Long> relationId) {
if (CollUtil.isNotEmpty(relationId)) {
return relationId.stream().distinct()
.map(id -> DataObjectRuleScope.builder().relationId(id).build())
.collect(Collectors.toList());
}
return Lists.newArrayList();
}
}