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

REQ-2299 基础开发&创建数据对象

Browse Source
This commit is contained in:
yangheng 2024-04-23 09:38:12 +08:00
parent 12caa4a41e
commit d185bb2b5f
48 changed files with 1191 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -0,0 +1,51 @@
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, "规则名有重复，请检查"),
;
private final Integer code;
private final String message;
}

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

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

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

@ -0,0 +1,29 @@
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.EditDataObjectReq;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import javax.validation.Valid;
/**
* 数据权限
*/
@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);
}

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

@ -1,7 +1,7 @@
package cn.axzo.tyr.client.feign;
import cn.axzo.framework.domain.web.result.ApiResult;
import cn.axzo.tyr.client.model.req.CreateDataPermissionReq;
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;
@ -20,9 +20,4 @@ public interface DataPermissionApi {
/** 查询审批流表单查看/编辑权限 **/
@PostMapping(value = "/api/v1/dataPermission/getWorkflowQueryAndUpdatePermission")
ApiResult<GetWorkflowQueryAndUpdatePermissionRes> getWorkflowQueryAndUpdatePermission(@RequestBody @Validated GetWorkflowQueryAndUpdatePermissionReq req);
// ******************************************************************
// 数据权限
@PostMapping("/api/dataPermission/create")
ApiResult<Long> createDataPermission(@RequestBody @Valid CreateDataPermissionReq req);
}

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

@ -0,0 +1,24 @@
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 AttributeBO {
/**
* 数据对象属性id
*/
private Long dataObjectAttrId;
Integer sort; // 序号
String attrName; //字段名
String attrCode; // 字段code
Integer unmaskSupport; // 是否支持脱敏 1-不支持 2-支持
Integer editSupport; // 是否支持编辑 1-不支持 2-支持
}

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

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

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

@ -0,0 +1,28 @@
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 dataObjectAttrId;
Integer sort; // 序号
String attrName; //字段名
List<String> attrNameList; //字段名List
String attrCode; // 字段code
List<String> attrCodeList; // 字段codeList
Integer unmaskSupport; // 是否支持脱敏 1-不支持 2-支持
Integer editSupport; // 是否支持编辑 1-不支持 2-支持
}

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

@ -0,0 +1,31 @@
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 DataObjectQueryBO {
/**
* 数据权限code
*/
private String dataObjectCode;
/**
* 数据权限名 全局唯一
*/
private String dataObjectName;
/**
* 租户范围（单选，插入后不可编辑） 1：项目租户 2：单位租户 3:OMS 4:政务监管平台
*/
private Integer tenantScope;
/**
* 排序 （从小到大）
*/
private Integer sort;
}

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

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

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

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

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

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

20
tyr-api/src/main/java/cn/axzo/tyr/client/model/data/permission/Attribute.java
View File

@ -1,20 +0,0 @@
package cn.axzo.tyr.client.model.data.permission;
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 Attribute {
Integer sort; // 序号
String attrName; //字段名
String attrCode;
Integer unmaskSupport; // 是否支持脱敏 1-支持 0-不支持
Integer editSupport; // 是否支持编辑 1-支持 0-不支持
}

21
tyr-api/src/main/java/cn/axzo/tyr/client/model/data/permission/AttributePermission.java
View File

@ -1,21 +0,0 @@
package cn.axzo.tyr.client.model.data.permission;
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 AttributePermission {
Integer sort; // 序号
String attrName; //字段名
String attrCode;
Integer visibilityScope; // 字段值查看范围 0:同行级数据权限 1:仅本人数据 2:本人及下属数据 3:仅本部门数据 4:本部门及以下数据 5:仅本单位数据 6:本单位及下级直属单位数据 7:本单位及下级协同（直属+合作）单位数据 8:本单位及以下协同（直属+合作）单位数据 9:本项目部数据
Integer isUnmaskable; // 是否可脱敏 1-可操作脱敏 0-不可操作脱敏
Integer isEditable; // 是否可编辑 1-可编辑 0-不可编辑
}

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

@ -0,0 +1,70 @@
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;
/**
* 租户范围（单选，插入后不可编辑） 1：项目租户 2：单位租户 3:OMS 4:政务监管平台
*/
@NotNull(message = "请选择租户范围")
private Integer tenantScope;
/**
* 字段
*/
private List<AttributeBO> attrs;
/**
* 默认规则
*/
private List<DefaultDataObjectRuleBO> defaultDataObjectRuleBOList;
/**
* 自定义规则
*/
@Valid
private List<DataObjectRuleBO> dataObjectRuleBOList;
/**
* 排序 （从小到大）
*/
private Integer sort;
/**
* 创建人自然人id
*/
private Long createBy;
/**
* 修改人自然人id
*/
private Long updateBy;
}

52
tyr-api/src/main/java/cn/axzo/tyr/client/model/req/CreateDataPermissionReq.java
View File

@ -1,52 +0,0 @@
package cn.axzo.tyr.client.model.req;
import cn.axzo.tyr.client.model.data.permission.Attribute;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.hibernate.validator.constraints.Length;
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 CreateDataPermissionReq {
/**
* 数据权限code
*/
@NotEmpty(message = "请输入数据权限code")
private String dataPermissionCode;
/**
* 数据权限名 全局唯一
*/
@NotNull(message = "请输入数据权限名")
@Size(min = 1, max = 10,message = "请输入数据权限名")
private String dataPermissionName;
/**
* 备注
*/
private String memo;
/**
* 字段
*/
private List<Attribute> attrs;
/**
* 排序 （从小到大）
*/
private Integer sort;
/**
* 创建人自然人id
*/
private Long createBy;
/**
* 修改人自然人id
*/
private Long updateBy;
}

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

@ -0,0 +1,68 @@
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
*/
private Long dataObjectId;
/**
* 数据对象名 全局唯一
*/
@NotNull(message = "请输入数据对象名")
@Size(min = 1, max = 10,message = "请输入数据对象名")
private String dataObjectName;
/**
* 备注
*/
private String memo;
/**
* 租户范围（单选，插入后不可编辑） 1：项目租户 2：单位租户 3:OMS 4:政务监管平台
*/
private Integer tenantScope;
/**
* 字段
*/
private List<AttributeBO> attrs;
/**
* 默认规则
*/
private DefaultDataObjectRuleBO defaultDataObjectRuleBO;
/**
* 自定义规则
*/
@Valid
private List<DataObjectRuleBO> z;
/**
* 排序 （从小到大）
*/
private Integer sort;
/**
* 创建人自然人id
*/
private Long createBy;
/**
* 修改人自然人id
*/
private Long updateBy;
}

8
tyr-server/pom.xml
View File

@ -1,5 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>tyr</artifactId>
<groupId>cn.axzo.tyr</groupId>
@ -97,6 +98,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>

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

@ -1,5 +1,6 @@
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;

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

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

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

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

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

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

27
tyr-server/src/main/java/cn/axzo/tyr/server/config/mybatisplus/MybatisPlusConfig.java Normal file
View File

@ -0,0 +1,27 @@
package cn.axzo.tyr.server.config.mybatisplus;
import cn.axzo.pokonyan.config.mybatisplus.EntityMetaObjectHandler;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.transaction.annotation.EnableTransactionManagement;
/**
* @author lijiacheng 李嘉成 Jache
*/
@EnableTransactionManagement
@Configuration
public class MybatisPlusConfig {
@Bean
public MybatisPlusInterceptor paginationInterceptor() {
MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
return mybatisPlusInterceptor;
}
}

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

@ -0,0 +1,33 @@
package cn.axzo.tyr.server.controller.data.object;
import cn.axzo.framework.auth.domain.ContextInfoHolder;
import cn.axzo.framework.domain.web.result.ApiResult;
import cn.axzo.tyr.client.feign.DataObjectApi;
import cn.axzo.tyr.client.model.req.CreateDataObjectReq;
import cn.axzo.tyr.client.model.req.EditDataObjectReq;
import cn.axzo.tyr.server.service.DataObjectService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RestController;
/**
* 数据权限
*/
@Slf4j
@RestController
@RequiredArgsConstructor
public class DataObjectController implements DataObjectApi {
private final DataObjectService dataObjectService;
public ApiResult<Long> createDataObject(CreateDataObjectReq req) {
return ApiResult.ok(dataObjectService.createDataObject(req));
}
@Override
public ApiResult<Void> editDataObject(EditDataObjectReq req) {
return ApiResult.ok(dataObjectService.editDataObject(req));
}
}

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

@ -1,19 +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.CreateDataPermissionReq;
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.DataPermissionService;
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;
@ -34,10 +32,6 @@ public class DataPermissionController implements DataPermissionApi {
private final ProcessTaskApi processTaskApi;
private final ProcessInstanceApi processInstanceApi;
// ******************************************************************
// 数据权限
private final DataPermissionService dataPermissionService;
@Override
public ApiResult<GetWorkflowQueryAndUpdatePermissionRes> getWorkflowQueryAndUpdatePermission(GetWorkflowQueryAndUpdatePermissionReq req) {
@ -72,11 +66,4 @@ public class DataPermissionController implements DataPermissionApi {
return ApiResult.ok(result);
}
// ******************************************************************
// 数据权限
@Override
public ApiResult<Long> createDataPermission(CreateDataPermissionReq req) {
return ApiResult.ok(dataPermissionService.createDataPermission(req));
}
}

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

@ -0,0 +1,11 @@
package cn.axzo.tyr.server.repository.dao;
import cn.axzo.tyr.server.repository.entity.DataObjectAttr;
import cn.axzo.tyr.server.repository.mapper.DataObjectAttrMapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Repository;
@Repository
public class DataObjectAttrDao extends ServiceImpl<DataObjectAttrMapper, DataObjectAttr> {
}

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

@ -0,0 +1,22 @@
package cn.axzo.tyr.server.repository.dao;
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.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public class DataObjectDao extends ServiceImpl<DataObjectMapper, DataObject> {
public List<DataObject> duplicateListByBO(DataObjectQueryBO bo) {
return lambdaQuery()
.eq(StringUtils.isNotEmpty(bo.getDataObjectCode()), DataObject::getDataObjectCode, bo.getDataObjectCode())
.or(StringUtils.isNotEmpty(bo.getDataObjectCode()))
.eq(StringUtils.isNotEmpty(bo.getDataObjectName()), DataObject::getDataObjectName, bo.getDataObjectName())
.list();
}
}

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

@ -0,0 +1,10 @@
package cn.axzo.tyr.server.repository.dao;
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;
@Repository
public class DataObjectRuleAttrDao extends ServiceImpl<DataObjectRuleAttrMapper, DataObjectRuleAttr> {
}

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

@ -0,0 +1,22 @@
package cn.axzo.tyr.server.repository.dao;
import cn.axzo.tyr.client.model.data.object.DataObjectRuleQueryBO;
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(Objects.nonNull(bo.getDataObjectId()), DataObjectRule::getDataObjectId, bo.getDataObjectId())
.in(CollUtil.isNotEmpty(bo.getDataObjectRuleNameList()), DataObjectRule::getName, bo.getDataObjectRuleNameList())
.list();
}
}

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

@ -0,0 +1,10 @@
package cn.axzo.tyr.server.repository.dao;
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;
@Repository
public class DataObjectRuleScopeDao extends ServiceImpl<DataObjectRuleScopeMapper, DataObjectRuleScope> {
}

10
tyr-server/src/main/java/cn/axzo/tyr/server/repository/dao/DataPermissionDao.java
View File

@ -1,10 +0,0 @@
package cn.axzo.tyr.server.repository.dao;
import cn.axzo.tyr.server.repository.entity.DataPermission;
import cn.axzo.tyr.server.repository.mapper.DataPermissionMapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Repository;
@Repository
public class DataPermissionDao extends ServiceImpl<DataPermissionMapper, DataPermission> {
}

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

@ -1,11 +0,0 @@
package cn.axzo.tyr.server.repository.dao;
import cn.axzo.tyr.server.repository.entity.DataPermission;
import cn.axzo.tyr.server.repository.entity.DataObjectRule;
import cn.axzo.tyr.server.repository.mapper.DataPermissionRuleMapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Repository;
@Repository
public class DataPermissionRuleDao extends ServiceImpl<DataPermissionRuleMapper, DataObjectRule> {
}

13
tyr-server/src/main/java/cn/axzo/tyr/server/repository/entity/DataObject.java
View File

@ -1,6 +1,7 @@
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;
@ -14,7 +15,7 @@ import java.io.Serializable;
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "data_object", autoResultMap = true)
public class DataObject extends BaseEntity<DataObject> implements Serializable {
public class DataObject extends BaseOperatorEntity<DataObject> implements Serializable {
/**
* 数据权限code
*/
@ -28,19 +29,11 @@ public class DataObject extends BaseEntity<DataObject> implements Serializable {
*/
private String memo;
/**
* 租户范围（插入后不可编辑） 1：项目租户 2：单位租户 3:OMS 4:政务监管平台
* 租户范围（单选，插入后不可编辑） 1：项目租户 2：单位租户 3:OMS 4:政务监管平台
*/
private Integer tenantScope;
/**
* 排序 （从小到大）
*/
private Integer sort;
/**
* 创建人自然人id
*/
private Long createBy;
/**
* 修改人自然人id
*/
private Long updateBy;
}

28
tyr-server/src/main/java/cn/axzo/tyr/server/repository/entity/DataObjectAttr.java
View File

@ -1,20 +1,31 @@
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;
@Data
@Builder
@Accessors(chain = true)
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "data_object_attr", autoResultMap = true)
public class DataObjectAttr extends BaseEntity<DataObjectAttr> implements Serializable {
public class DataObjectAttr extends BaseOperatorEntity<DataObjectAttr> implements Serializable {
/**
* 数据权限id
*/
private Long dataObjectId;
/**
* 数据权限code
*/
private String dataObjectCode;
/**
* 序号
*/
@ -25,19 +36,12 @@ public class DataObjectAttr extends BaseEntity<DataObjectAttr> implements Seria
private String attrName;
private String attrCode;
/**
* 是否支持脱敏 1-支持 0-不支持
* 是否支持脱敏 1-不支持 2-支持
*/
// @TableField(value = "unmask_support")
private Integer unmaskSupport;
/**
* 是否支持编辑 1-支持 0-不支持
* 是否支持编辑 1-不支持 2-支持
*/
private Integer editSupport;
/**
* 创建人自然人id
*/
private Long createBy;
/**
* 修改人自然人id
*/
private Long updateBy;
}

33
tyr-server/src/main/java/cn/axzo/tyr/server/repository/entity/DataObjectRule.java
View File

@ -1,24 +1,29 @@
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 BaseEntity<DataObjectRule> implements Serializable {
public class DataObjectRule extends BaseOperatorEntity<DataObjectRule> implements Serializable {
/**
* 数据权限id
*/
private String dataObjectId;
private Long dataObjectId;
/**
* 数据权限code
*/
@ -35,29 +40,25 @@ public class DataObjectRule extends BaseEntity<DataObjectRule> implements Serial
/**
* 规则范围 1：岗位 2：角色
*/
private Integer ruleScope;
private Integer ruleScopeType;
/**
* 岗位id
*/
private Long jobId;
/**
* 角色id
*/
private Long roleId;
/**
* 是否为默认规则 0-不是 1-是
* 是否为默认规则 1-不是 2-是
*/
private Integer isDefault;
/**
* 排序 （从小到大）
*/
private Integer sort;
/**
* 创建人自然人id
* 规则字段
*/
private Long createBy;
@TableField(exist = false)
private List<DataObjectRuleAttr> dataObjectRuleAttrList;
/**
* 修改人自然人id
* 规则范围
*/
private Long updateBy;
@TableField(exist = false)
private List<DataObjectRuleScope> dataObjectRuleScopeList;
}

32
tyr-server/src/main/java/cn/axzo/tyr/server/repository/entity/DataObjectRuleAttrRelation.java → tyr-server/src/main/java/cn/axzo/tyr/server/repository/entity/DataObjectRuleAttr.java
View File

@ -1,17 +1,20 @@
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_relation", autoResultMap = true)
public class DataObjectRuleAttrRelation {
@TableName(value = "data_object_rule_attr", autoResultMap = true)
public class DataObjectRuleAttr extends BaseOperatorEntity<DataObjectRuleAttr> implements Serializable {
/**
* 数据对象id
*/
@ -19,34 +22,35 @@ public class DataObjectRuleAttrRelation {
/**
* 数据对象code
*/
private Long dataObjectName;
private String dataObjectCode;
/**
* 数据对象字段id
*/
private Long dataObjectAttrId;
/**
* 数据对象规则id
*/
private Long dataObjectRuleId;
/**
* 字段code
*/
String attrCode;
/**
* 序号
*/
private Integer sort;
/**
* 字段值查看范围 0:同行级数据权限 1:仅本人数据 2:本人及下属数据 3:仅本部门数据 4:本部门及以下数据
* 字段值查看范围 1:仅本人数据 2:本人及下属数据 3:仅本部门数据 4:本部门及以下数据
* 5:仅本单位数据 6:本单位及下级直属单位数据 7:本单位及下级协同（直属+合作）单位数据 8:本单位及以下协同（直属+合作）单位数据 9:本项目部数据
* 10:同行级数据权限
*/
private Integer visibilityScope;
/**
* 是否可脱敏 1-可操作脱敏 0-不可操作脱敏
* 是否可脱敏 1-不可操作脱敏 2-可操作脱敏
*/
private Integer isUnmaskable;
/**
* 是否可编辑 1-可编辑 0-不可编辑
* 是否可编辑 1-不可编辑 2-可编辑
*/
private Integer isEditable;
/**
* 创建人自然人id
*/
private Long createBy;
/**
* 修改人自然人id
*/
private Long updateBy;
}

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

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

4
tyr-server/src/main/java/cn/axzo/tyr/server/repository/mapper/DataPermissionMapper.java → tyr-server/src/main/java/cn/axzo/tyr/server/repository/mapper/DataObjectAttrMapper.java
View File

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

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

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

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

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

2
tyr-server/src/main/java/cn/axzo/tyr/server/repository/mapper/DataPermissionRuleMapper.java → tyr-server/src/main/java/cn/axzo/tyr/server/repository/mapper/DataObjectRuleMapper.java
View File

@ -5,5 +5,5 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface DataPermissionRuleMapper extends BaseMapper<DataObjectRule> {
public interface DataObjectRuleMapper extends BaseMapper<DataObjectRule> {
}

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

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

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

@ -0,0 +1,10 @@
package cn.axzo.tyr.server.service;
import cn.axzo.tyr.client.model.req.CreateDataObjectReq;
import cn.axzo.tyr.client.model.req.EditDataObjectReq;
public interface DataObjectService {
Long createDataObject(CreateDataObjectReq req);
Void editDataObject(EditDataObjectReq req);
}

7
tyr-server/src/main/java/cn/axzo/tyr/server/service/DataPermissionService.java
View File

@ -1,7 +0,0 @@
package cn.axzo.tyr.server.service;
import cn.axzo.tyr.client.model.req.CreateDataPermissionReq;
public interface DataPermissionService {
Long createDataPermission(CreateDataPermissionReq req);
}

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

@ -0,0 +1,196 @@
package cn.axzo.tyr.server.service.impl;
import cn.axzo.basics.common.exception.ServiceException;
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.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.req.CreateDataObjectReq;
import cn.axzo.tyr.client.model.req.EditDataObjectReq;
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 lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.support.TransactionTemplate;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@Slf4j
@RequiredArgsConstructor
@Service
public class DataObjectServiceImpl implements DataObjectService {
private final DataObjectDao dataObjectDao;
private final DataObjectRuleDao dataObjectRuleDao;
private final DataObjectAttrDao dataObjectAttrDao;
private final DataObjectRuleAttrDao dataObjectRuleAttrDao;
private final DataObjectRuleScopeDao dataObjectRuleScopeDao;
@Resource
private TransactionTemplate transactionTemplate;
@Override
public Long createDataObject(CreateDataObjectReq req) {
// 校验
// objectName、objectCode不能重复
checkObjectNameOrCodeUnique(req);
// // 对象属性名和code不能重复
// checkObjectAttrNameOrCodeUnique(req);
// // 规则名 不能重复
// checkRuleNameUnique(req);
// 准备
DataObject dataObject = DataObjectMapper.INSTANCE.createReq2DataObject(req);
List<DataObjectAttr> objectAttrList = DataObjectMapper.INSTANCE.attributeBOs2DataObjectAttrs(req.getAttrs());
List<DataObjectRule> defaultDataObjectRules = DataObjectMapper.INSTANCE.defaultRuleBOs2Rules(req.getDefaultDataObjectRuleBOList());
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);
// 数据对象字段
Map<String, Long> attrMap;
if (CollUtil.isNotEmpty(objectAttrList)) {
objectAttrList.forEach(e -> e.setDataObjectId(dataObject.getId())
.setDataObjectCode(dataObject.getDataObjectCode())
.setCreateBy(req.getCreateBy()));
dataObjectAttrDao.saveBatch(objectAttrList);
attrMap = objectAttrList.stream().collect(Collectors.toMap(DataObjectAttr::getAttrCode, DataObjectAttr::getId, (a, b) -> a));
} else {
attrMap = null;
}
// 数据对象规则
if (CollUtil.isNotEmpty(defaultDataObjectRules)) {
defaultDataObjectRules.forEach(e -> e.setDataObjectId(dataObject.getId())
.setDataObjectCode(dataObject.getDataObjectCode())
.setIsDefault(YesNoEnum.YES.getValue())
.setCreateBy(req.getCreateBy()));
;
generalObjectRuleList.addAll(defaultDataObjectRules);
}
if (CollUtil.isNotEmpty(dataObjectRules)) {
dataObjectRules.forEach(e -> e.setDataObjectId(dataObject.getId())
.setDataObjectCode(dataObject.getDataObjectCode())
.setIsDefault(YesNoEnum.NO.getValue())
.setCreateBy(req.getCreateBy()));
;
generalObjectRuleList.addAll(dataObjectRules);
}
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);
generalObjectRuleList.forEach(rule -> {
if (CollUtil.isNotEmpty(attrMap) && CollUtil.isNotEmpty(rule.getDataObjectRuleAttrList())) {
rule.getDataObjectRuleAttrList().forEach(ruleAttr -> {
ruleAttr.setDataObjectAttrId(attrMap.get(ruleAttr.getAttrCode()));
ruleAttr.setDataObjectId(dataObject.getId());
ruleAttr.setDataObjectCode(dataObject.getDataObjectCode());
ruleAttr.setDataObjectRuleId(rule.getId());
ruleAttr.setCreateBy(req.getCreateBy());
ruleAttrList.add(ruleAttr);
});
rule.getDataObjectRuleScopeList().forEach(scope -> {
scope.setRuleScopeType(rule.getRuleScopeType());
scope.setCreateBy(req.getCreateBy());
scope.setDataObjectRuleId(rule.getId());
scope.setDataObjectId(rule.getDataObjectId());
scope.setDataObjectCode(rule.getDataObjectCode());
scopeList.add(scope);
});
}
});
dataObjectRuleAttrDao.saveBatch(ruleAttrList);
dataObjectRuleScopeDao.saveBatch(scopeList);
}
});
return dataObject.getId();
}
@Override
public Void editDataObject(EditDataObjectReq req) {
}
private void checkRuleNameUnique(CreateDataObjectReq req) {
if (CollUtil.isNotEmpty(req.getDataObjectRuleBOList())) {
List<String> nameList = req.getDataObjectRuleBOList().stream().map(DataObjectRuleBO::getDataObjectRuleName).distinct().collect(Collectors.toList());
if (nameList.size() < req.getDataObjectRuleBOList().size()) {
throw new ServiceException(ReturnCodeEnum.DATA_OBJECT_RULE_DUPLICATE.getMessage());
}
}
}
private static void checkObjectAttrNameOrCodeUnique(CreateDataObjectReq req) {
if (CollUtil.isNotEmpty(req.getAttrs())) {
List<String> attrNameList = req.getAttrs().stream().map(AttributeBO::getAttrName).distinct().collect(Collectors.toList());
List<String> attrCodeList = req.getAttrs().stream().map(AttributeBO::getAttrCode).distinct().collect(Collectors.toList());
if (attrNameList.size() < req.getAttrs().size() || attrCodeList.size() < req.getAttrs().size()) {
throw new ServiceException(ReturnCodeEnum.DATA_OBJECT_ATTR_NAME_CODE_DUPLICATE.getMessage());
}
}
}
private void checkObjectNameOrCodeUnique(CreateDataObjectReq req) {
DataObjectQueryBO bo = DataObjectQueryBO.builder()
.dataObjectName(req.getDataObjectName())
.dataObjectCode(req.getDataObjectCode())
.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(req.getDataObjectName())) {
nameDuplicate = true;
}
if (dataObject.getDataObjectCode().equals(req.getDataObjectCode())) {
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());
}
}
}
}

22
tyr-server/src/main/java/cn/axzo/tyr/server/service/impl/DataPermissionServiceImpl.java
View File

@ -1,22 +0,0 @@
package cn.axzo.tyr.server.service.impl;
import cn.axzo.tyr.client.model.req.CreateDataPermissionReq;
import cn.axzo.tyr.server.repository.dao.DataPermissionDao;
import cn.axzo.tyr.server.repository.dao.DataPermissionRuleDao;
import cn.axzo.tyr.server.service.DataPermissionService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
@Slf4j
@RequiredArgsConstructor
@Service
public class DataPermissionServiceImpl implements DataPermissionService {
private final DataPermissionDao dataPermissionDao;
private final DataPermissionRuleDao dataPermissionRuleDao;
@Override
public Long createDataPermission(CreateDataPermissionReq req) {
}
}

9
tyr-server/src/main/java/cn/axzo/tyr/server/utils/BaseDataEntity.java Normal file
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() {
}
}

24
tyr-server/src/main/java/cn/axzo/tyr/server/utils/BaseOperatorEntity.java Normal file
View File

@ -0,0 +1,24 @@
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 java.io.Serializable;
@Data
public abstract class BaseOperatorEntity<T extends Model<T>> extends BaseDataEntity<T> implements Serializable {
@TableField(
fill = FieldFill.INSERT
)
protected Long createBy = 0L;
@TableField(
fill = FieldFill.UPDATE
)
protected Long updateBy = 0L;
protected boolean canEqual(final Object other) {
return other instanceof BaseOperatorEntity;
}
}

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

@ -0,0 +1,61 @@
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.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);
DataObjectAttr attributeBO2DataObjectAttr(AttributeBO bo);
DataObjectRuleAttr attrBO2Attr(AttributePermissionBO bo);
@Mapping(source = "dataObjectRuleName", target = "name")
@Mapping(source = "attributePermissionBOList", target = "dataObjectRuleAttrList")
@Mapping(source = "relationId", target = "dataObjectRuleScopeList", qualifiedByName = "mapRelationId2RuleScope")
DataObjectRule defaultRuleBO2Rule(DefaultDataObjectRuleBO bo);
@Mapping(source = "dataObjectRuleName", target = "name")
@Mapping(source = "attributePermissionBOList", target = "dataObjectRuleAttrList")
@Mapping(source = "relationId", target = "dataObjectRuleScopeList", qualifiedByName = "mapRelationId2RuleScope")
DataObjectRule ruleBO2Rule(DataObjectRuleBO bo);
List<DataObjectAttr> attributeBOs2DataObjectAttrs(List<AttributeBO> bo);
List<DataObjectRule> defaultRuleBOs2Rules(List<DefaultDataObjectRuleBO> bo);
List<DataObjectRule> ruleBOs2Rules(List<DataObjectRuleBO> 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();
}
}