ly
/
Stwzhj-Cloud-Plus
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add 集成 EasyExcel 框架 完成业务功能切换 

update 优化 Validation 校验框架功能
update 移除掉 StringUtils 语义不明确的api方法 使用特定工具替换
2.X
疯狂的狮子li 2022-01-21 18:19:22 +08:00
parent f2b11d704b
commit 07ba70ec8c
101 changed files with 7990 additions and 8459 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
README.md
View File

@ -50,8 +50,8 @@
| 多数据源框架 | Dynamic-Datasource | [dynamic-ds文档](https://www.kancloud.cn/tracy5546/dynamic-datasource/content) | 支持主从与多种类数据库异构 | | 多数据源框架 | Dynamic-Datasource | [dynamic-ds文档](https://www.kancloud.cn/tracy5546/dynamic-datasource/content) | 支持主从与多种类数据库异构 |
| 序列化框架 | Jackson | [Jackson官网](https://github.com/FasterXML/jackson) | 统一使用 jackson 高效可靠 | | 序列化框架 | Jackson | [Jackson官网](https://github.com/FasterXML/jackson) | 统一使用 jackson 高效可靠 |
| Redis客户端 | Redisson | [Redisson文档](https://github.com/redisson/redisson/wiki/%E7%9B%AE%E5%BD%95) | 支持单机、集群配置 | | Redis客户端 | Redisson | [Redisson文档](https://github.com/redisson/redisson/wiki/%E7%9B%AE%E5%BD%95) | 支持单机、集群配置 |
| 校验框架(待优化) | Validation | [Validation文档](https://docs.jboss.org/hibernate/stable/validator/reference/en-US/html_single/) | 增强接口安全性、严谨性 支持国际化 | | 校验框架 | Validation | [Validation文档](https://docs.jboss.org/hibernate/stable/validator/reference/en-US/html_single/) | 增强接口安全性、严谨性 支持国际化 |
| Excel框架(未完成) | Alibaba EasyExcel | [EasyExcel文档](https://www.yuque.com/easyexcel/doc/easyexcel) | 性能优异 扩展性强 | | Excel框架 | Alibaba EasyExcel | [EasyExcel文档](https://www.yuque.com/easyexcel/doc/easyexcel) | 性能优异 扩展性强 |
| 文档框架 | Knife4j | [Knife4j文档](https://doc.xiaominfo.com/knife4j/documentation/) | 美化接口文档 | | 文档框架 | Knife4j | [Knife4j文档](https://doc.xiaominfo.com/knife4j/documentation/) | 美化接口文档 |
| 工具类框架 | Hutool、Lombok | [Hutool文档](https://www.hutool.cn/docs/) | 减少代码冗余 增加安全性 | | 工具类框架 | Hutool、Lombok | [Hutool文档](https://www.hutool.cn/docs/) | 减少代码冗余 增加安全性 |
| 代码生成器(未完成) | 适配MP、Knife4j规范化代码 | [Hutool文档](https://www.hutool.cn/docs/) | 一键生成前后端代码 | | 代码生成器(未完成) | 适配MP、Knife4j规范化代码 | [Hutool文档](https://www.hutool.cn/docs/) | 一键生成前后端代码 |

24
pom.xml
View File

@ -34,6 +34,8 @@
<velocity.version>2.3</velocity.version> <velocity.version>2.3</velocity.version>
<minio.version>8.2.2</minio.version> <minio.version>8.2.2</minio.version>
<poi.version>4.1.2</poi.version> <poi.version>4.1.2</poi.version>
<easyexcel.version>3.0.5</easyexcel.version>
<cglib.version>3.3.0</cglib.version>
<commons-collections.version>3.2.2</commons-collections.version> <commons-collections.version>3.2.2</commons-collections.version>
<transmittable-thread-local.version>2.12.2</transmittable-thread-local.version> <transmittable-thread-local.version>2.12.2</transmittable-thread-local.version>
<hutool.version>5.7.18</hutool.version> <hutool.version>5.7.18</hutool.version>
@ -224,6 +226,28 @@
<version>${poi.version}</version> <version>${poi.version}</version>
</dependency> </dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>easyexcel</artifactId>
<version>${easyexcel.version}</version>
<exclusions>
<exclusion>
<groupId>org.apache.poi</groupId>
<artifactId>poi</artifactId>
</exclusion>
<exclusion>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml-schemas</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>${cglib.version}</version>
</dependency>
<!-- 文件上传工具类 --> <!-- 文件上传工具类 -->
<dependency> <dependency>
<groupId>commons-fileupload</groupId> <groupId>commons-fileupload</groupId>

61
ruoyi-api/ruoyi-api-system/pom.xml
View File

@ -1,28 +1,33 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" <project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://maven.apache.org/POM/4.0.0" xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent> <parent>
<groupId>com.ruoyi</groupId> <groupId>com.ruoyi</groupId>
<artifactId>ruoyi-api</artifactId> <artifactId>ruoyi-api</artifactId>
<version>0.3.0</version> <version>0.3.0</version>
</parent> </parent>
<modelVersion>4.0.0</modelVersion> <modelVersion>4.0.0</modelVersion>
<artifactId>ruoyi-api-system</artifactId> <artifactId>ruoyi-api-system</artifactId>
<description> <description>
ruoyi-api-system系统接口模块 ruoyi-api-system系统接口模块
</description> </description>
<dependencies> <dependencies>
<!-- RuoYi Common Core--> <!-- RuoYi Common Core-->
<dependency> <dependency>
<groupId>com.ruoyi</groupId> <groupId>com.ruoyi</groupId>
<artifactId>ruoyi-common-core</artifactId> <artifactId>ruoyi-common-core</artifactId>
</dependency> </dependency>
</dependencies> <dependency>
<groupId>com.ruoyi</groupId>
</project> <artifactId>ruoyi-common-excel</artifactId>
</dependency>
</dependencies>
</project>

180
ruoyi-api/ruoyi-api-system/src/main/java/com/ruoyi/system/api/domain/SysDept.java
View File

@ -1,93 +1,87 @@
package com.ruoyi.system.api.domain; package com.ruoyi.system.api.domain;
import com.ruoyi.common.core.web.domain.BaseEntity; import com.ruoyi.common.core.web.domain.TreeEntity;
import lombok.Data; import io.swagger.annotations.ApiModel;
import lombok.EqualsAndHashCode; import io.swagger.annotations.ApiModelProperty;
import lombok.NoArgsConstructor; import lombok.Data;
import lombok.experimental.Accessors; import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import javax.validation.constraints.Email;
import javax.validation.constraints.NotBlank; import javax.validation.constraints.Email;
import javax.validation.constraints.Size; import javax.validation.constraints.NotBlank;
import java.util.ArrayList; import javax.validation.constraints.Size;
import java.util.List;
/**
/** * 部门表 sys_dept
* 部门表 sys_dept *
* * @author Lion Li
* @author ruoyi */
*/
@Data @Data
@EqualsAndHashCode(callSuper = true) @EqualsAndHashCode(callSuper = true)
@NoArgsConstructor @Accessors(chain = true)
@Accessors(chain = true) @ApiModel("部门业务对象")
public class SysDept extends BaseEntity { public class SysDept extends TreeEntity {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
/** /**
* 部门ID * 部门ID
*/ */
private Long deptId; @ApiModelProperty(value = "部门id")
private Long deptId;
/**
* 父部门ID /**
*/ * 部门名称
private Long parentId; */
@ApiModelProperty(value = "部门名称")
/** @NotBlank(message = "部门名称不能为空")
* 祖级列表 @Size(min = 0, max = 30, message = "部门名称长度不能超过30个字符")
*/ private String deptName;
private String ancestors;
/**
/** * 显示顺序
* 部门名称 */
*/ @ApiModelProperty(value = "显示顺序")
@NotBlank(message = "部门名称不能为空") @NotBlank(message = "显示顺序不能为空")
@Size(min = 0, max = 30, message = "部门名称长度不能超过30个字符") private String orderNum;
private String deptName;
/**
/** * 负责人
* 显示顺序 */
*/ @ApiModelProperty(value = "负责人")
@NotBlank(message = "显示顺序不能为空") private String leader;
private String orderNum;
/**
/** * 联系电话
* 负责人 */
*/ @ApiModelProperty(value = "联系电话")
private String leader; @Size(min = 0, max = 11, message = "联系电话长度不能超过11个字符")
private String phone;
/**
* 联系电话 /**
*/ * 邮箱
@Size(min = 0, max = 11, message = "联系电话长度不能超过11个字符") */
private String phone; @ApiModelProperty(value = "邮箱")
@Email(message = "邮箱格式不正确")
/** @Size(min = 0, max = 50, message = "邮箱长度不能超过50个字符")
* 邮箱 private String email;
*/
@Email(message = "邮箱格式不正确") /**
@Size(min = 0, max = 50, message = "邮箱长度不能超过50个字符") * 部门状态:0正常,1停用
private String email; */
@ApiModelProperty(value = "部门状态:0正常,1停用")
/** private String status;
* 部门状态:0正常,1停用
*/ /**
private String status; * 删除标志（0代表存在 2代表删除）
*/
/** @ApiModelProperty(value = "删除标志（0代表存在 2代表删除）")
* 删除标志（0代表存在 2代表删除） private String delFlag;
*/
private String delFlag; /**
* 祖级列表
/** */
* 父部门名称 @ApiModelProperty(value = "祖级列表")
*/ private String ancestors;
private String parentName;
}
/**
* 子部门
*/
private List<SysDept> children = new ArrayList<SysDept>();
}

201
ruoyi-api/ruoyi-api-system/src/main/java/com/ruoyi/system/api/domain/SysDictData.java
View File

@ -1,90 +1,111 @@
package com.ruoyi.system.api.domain; package com.ruoyi.system.api.domain;
import com.ruoyi.common.core.annotation.Excel; import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.ruoyi.common.core.annotation.Excel.ColumnType; import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.core.constant.UserConstants; import com.ruoyi.common.core.constant.UserConstants;
import com.ruoyi.common.core.web.domain.BaseEntity; import com.ruoyi.common.core.web.domain.BaseEntity;
import lombok.Data; import com.ruoyi.common.excel.annotation.ExcelDictFormat;
import lombok.EqualsAndHashCode; import com.ruoyi.common.excel.convert.ExcelDictConvert;
import lombok.NoArgsConstructor; import io.swagger.annotations.ApiModel;
import lombok.experimental.Accessors; import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import javax.validation.constraints.NotBlank; import lombok.EqualsAndHashCode;
import javax.validation.constraints.Size; import lombok.experimental.Accessors;
/** import javax.validation.constraints.NotBlank;
* 字典数据表 sys_dict_data import javax.validation.constraints.Size;
*
* @author ruoyi /**
*/ * 字典数据表 sys_dict_data
@Data *
@EqualsAndHashCode(callSuper = true) * @author Lion Li
@NoArgsConstructor */
@Accessors(chain = true)
public class SysDictData extends BaseEntity { @Data
private static final long serialVersionUID = 1L; @EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
/** @ExcelIgnoreUnannotated
* 字典编码 @ApiModel("字典数据业务对象")
*/ public class SysDictData extends BaseEntity {
@Excel(name = "字典编码", cellType = ColumnType.NUMERIC)
private Long dictCode; /**
* 字典编码
/** */
* 字典排序 @ApiModelProperty(value = "字典编码")
*/ @ExcelProperty(value = "字典编码")
@Excel(name = "字典排序", cellType = ColumnType.NUMERIC) private Long dictCode;
private Long dictSort;
/**
/** * 字典排序
* 字典标签 */
*/ @ApiModelProperty(value = "字典排序")
@NotBlank(message = "字典标签不能为空") @ExcelProperty(value = "字典排序")
@Size(min = 0, max = 100, message = "字典标签长度不能超过100个字符") private Long dictSort;
@Excel(name = "字典标签")
private String dictLabel; /**
* 字典标签
/** */
* 字典键值 @ApiModelProperty(value = "字典标签")
*/ @ExcelProperty(value = "字典标签")
@NotBlank(message = "字典键值不能为空") @NotBlank(message = "字典标签不能为空")
@Size(min = 0, max = 100, message = "字典键值长度不能超过100个字符") @Size(min = 0, max = 100, message = "字典标签长度不能超过100个字符")
@Excel(name = "字典键值") private String dictLabel;
private String dictValue;
/**
/** * 字典键值
* 字典类型 */
*/ @ApiModelProperty(value = "字典键值")
@NotBlank(message = "字典类型不能为空") @ExcelProperty(value = "字典键值")
@Size(min = 0, max = 100, message = "字典类型长度不能超过100个字符") @NotBlank(message = "字典键值不能为空")
@Excel(name = "字典类型") @Size(min = 0, max = 100, message = "字典键值长度不能超过100个字符")
private String dictType; private String dictValue;
/** /**
* 样式属性（其他样式扩展） * 字典类型
*/ */
@Size(min = 0, max = 100, message = "样式属性长度不能超过100个字符") @ApiModelProperty(value = "字典类型")
private String cssClass; @ExcelProperty(value = "字典类型")
@NotBlank(message = "字典类型不能为空")
/** @Size(min = 0, max = 100, message = "字典类型长度不能超过100个字符")
* 表格字典样式 private String dictType;
*/
private String listClass; /**
* 样式属性（其他样式扩展）
/** */
* 是否默认（Y是 N否） @ApiModelProperty(value = "样式属性（其他样式扩展）")
*/ @Size(min = 0, max = 100, message = "样式属性长度不能超过100个字符")
@Excel(name = "是否默认", readConverterExp = "Y=是,N=否") private String cssClass;
private String isDefault;
/**
/** * 表格字典样式
* 状态（0正常 1停用） */
*/ @ApiModelProperty(value = "表格字典样式")
@Excel(name = "状态", readConverterExp = "0=正常,1=停用") private String listClass;
private String status;
/**
public boolean getDefault() { * 是否默认（Y是 N否）
return UserConstants.YES.equals(this.isDefault) ? true : false; */
} @ApiModelProperty(value = "是否默认（Y是 N否）")
@ExcelProperty(value = "是否默认", converter = ExcelDictConvert.class)
} @ExcelDictFormat(dictType = "sys_yes_no")
private String isDefault;
/**
* 状态（0正常 1停用）
*/
@ApiModelProperty(value = "状态（0正常 1停用）")
@ExcelProperty(value = "状态", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "sys_normal_disable")
private String status;
/**
* 备注
*/
@ApiModelProperty(value = "备注")
private String remark;
public boolean getDefault() {
return UserConstants.YES.equals(this.isDefault);
}
}

123
ruoyi-api/ruoyi-api-system/src/main/java/com/ruoyi/system/api/domain/SysDictType.java
View File

@ -1,54 +1,69 @@
package com.ruoyi.system.api.domain; package com.ruoyi.system.api.domain;
import com.ruoyi.common.core.annotation.Excel; import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.ruoyi.common.core.annotation.Excel.ColumnType; import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.core.web.domain.BaseEntity; import com.ruoyi.common.core.web.domain.BaseEntity;
import lombok.Data; import com.ruoyi.common.excel.annotation.ExcelDictFormat;
import lombok.EqualsAndHashCode; import com.ruoyi.common.excel.convert.ExcelDictConvert;
import lombok.NoArgsConstructor; import io.swagger.annotations.ApiModel;
import lombok.experimental.Accessors; import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import javax.validation.constraints.NotBlank; import lombok.EqualsAndHashCode;
import javax.validation.constraints.Size; import lombok.experimental.Accessors;
/** import javax.validation.constraints.NotBlank;
* 字典类型表 sys_dict_type import javax.validation.constraints.Size;
*
* @author ruoyi /**
*/ * 字典类型表 sys_dict_type
@Data *
@EqualsAndHashCode(callSuper = true) * @author Lion Li
@NoArgsConstructor */
@Accessors(chain = true)
public class SysDictType extends BaseEntity { @Data
private static final long serialVersionUID = 1L; @EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
/** @ExcelIgnoreUnannotated
* 字典主键 @ApiModel("字典类型业务对象")
*/ public class SysDictType extends BaseEntity {
@Excel(name = "字典主键", cellType = ColumnType.NUMERIC)
private Long dictId; /**
* 字典主键
/** */
* 字典名称 @ApiModelProperty(value = "字典主键")
*/ @ExcelProperty(value = "字典主键")
@NotBlank(message = "字典名称不能为空") private Long dictId;
@Size(min = 0, max = 100, message = "字典类型名称长度不能超过100个字符")
@Excel(name = "字典名称") /**
private String dictName; * 字典名称
*/
/** @ApiModelProperty(value = "字典名称")
* 字典类型 @ExcelProperty(value = "字典名称")
*/ @NotBlank(message = "字典名称不能为空")
@NotBlank(message = "字典类型不能为空") @Size(min = 0, max = 100, message = "字典类型名称长度不能超过100个字符")
@Size(min = 0, max = 100, message = "字典类型类型长度不能超过100个字符") private String dictName;
@Excel(name = "字典类型")
private String dictType; /**
* 字典类型
/** */
* 状态（0正常 1停用） @ApiModelProperty(value = "字典类型")
*/ @ExcelProperty(value = "字典类型")
@Excel(name = "状态", readConverterExp = "0=正常,1=停用") @NotBlank(message = "字典类型不能为空")
private String status; @Size(min = 0, max = 100, message = "字典类型类型长度不能超过100个字符")
private String dictType;
}
/**
* 状态（0正常 1停用）
*/
@ApiModelProperty(value = "状态（0正常 1停用）")
@ExcelProperty(value = "状态", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "sys_normal_disable")
private String status;
/**
* 备注
*/
@ApiModelProperty(value = "备注")
private String remark;
}

139
ruoyi-api/ruoyi-api-system/src/main/java/com/ruoyi/system/api/domain/SysLogininfor.java
View File

@ -1,60 +1,79 @@
package com.ruoyi.system.api.domain; package com.ruoyi.system.api.domain;
import com.ruoyi.common.core.annotation.Excel; import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.ruoyi.common.core.annotation.Excel.ColumnType; import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.core.web.domain.BaseEntity; import com.ruoyi.common.excel.annotation.ExcelDictFormat;
import lombok.Data; import com.ruoyi.common.excel.convert.ExcelDictConvert;
import lombok.EqualsAndHashCode; import io.swagger.annotations.ApiModel;
import lombok.NoArgsConstructor; import io.swagger.annotations.ApiModelProperty;
import lombok.experimental.Accessors; import lombok.Data;
import lombok.experimental.Accessors;
import java.util.Date;
import java.io.Serializable;
/** import java.util.Date;
* 系统访问记录表 sys_logininfor import java.util.HashMap;
* import java.util.Map;
* @author ruoyi
*/ /**
@Data * 系统访问记录表 sys_logininfor
@EqualsAndHashCode(callSuper = true) *
@NoArgsConstructor * @author Lion Li
@Accessors(chain = true) */
public class SysLogininfor extends BaseEntity {
@Data
/** @Accessors(chain = true)
* ID @ExcelIgnoreUnannotated
*/ @ApiModel("系统访问记录业务对象")
@Excel(name = "序号", cellType = ColumnType.NUMERIC) public class SysLogininfor implements Serializable {
private Long infoId; private static final long serialVersionUID = 1L;
/** /**
* 用户账号 * ID
*/ */
@Excel(name = "用户账号") @ApiModelProperty(value = "访问ID")
private String userName; @ExcelProperty(value = "序号")
private Long infoId;
/**
* 状态 0成功 1失败 /**
*/ * 用户账号
@Excel(name = "状态", readConverterExp = "0=成功,1=失败") */
private String status; @ApiModelProperty(value = "用户账号")
@ExcelProperty(value = "用户账号")
/** private String userName;
* 地址
*/ /**
@Excel(name = "地址") * 状态 0成功 1失败
private String ipaddr; */
@ApiModelProperty(value = "状态 0成功 1失败")
/** @ExcelProperty(value = "状态", converter = ExcelDictConvert.class)
* 描述 @ExcelDictFormat(dictType = "sys_common_status")
*/ private String status;
@Excel(name = "描述")
private String msg; /**
* 地址
/** */
* 访问时间 @ApiModelProperty(value = "地址")
*/ @ExcelProperty(value = "地址")
@Excel(name = "访问时间", width = 30, dateFormat = "yyyy-MM-dd HH:mm:ss") private String ipaddr;
private Date accessTime;
/**
} * 描述
*/
@ApiModelProperty(value = "描述")
@ExcelProperty(value = "描述")
private String msg;
/**
* 访问时间
*/
@ApiModelProperty(value = "访问时间")
@ExcelProperty(value = "访问时间")
private Date accessTime;
/**
* 请求参数
*/
@ApiModelProperty(value = "请求参数")
private Map<String, Object> params = new HashMap<>();
}

270
ruoyi-api/ruoyi-api-system/src/main/java/com/ruoyi/system/api/domain/SysOperLog.java
View File

@ -1,119 +1,151 @@
package com.ruoyi.system.api.domain; package com.ruoyi.system.api.domain;
import com.ruoyi.common.core.annotation.Excel; import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.ruoyi.common.core.annotation.Excel.ColumnType; import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.core.web.domain.BaseEntity; import com.ruoyi.common.excel.annotation.ExcelDictFormat;
import lombok.Data; import com.ruoyi.common.excel.convert.ExcelDictConvert;
import lombok.EqualsAndHashCode; import io.swagger.annotations.ApiModel;
import lombok.NoArgsConstructor; import io.swagger.annotations.ApiModelProperty;
import lombok.experimental.Accessors; import lombok.Data;
import lombok.experimental.Accessors;
import java.util.Date;
import java.io.Serializable;
/** import java.util.Date;
* 操作日志记录表 oper_log import java.util.HashMap;
* import java.util.Map;
* @author ruoyi
*/ /**
@Data * 操作日志记录表 oper_log
@EqualsAndHashCode(callSuper = true) *
@NoArgsConstructor * @author Lion Li
@Accessors(chain = true) */
public class SysOperLog extends BaseEntity {
@Data
/** @Accessors(chain = true)
* 日志主键 @ExcelIgnoreUnannotated
*/ @ApiModel("操作日志记录业务对象")
@Excel(name = "操作序号", cellType = ColumnType.NUMERIC) public class SysOperLog implements Serializable {
private Long operId;
private static final long serialVersionUID = 1L;
/**
* 操作模块 /**
*/ * 日志主键
@Excel(name = "操作模块") */
private String title; @ApiModelProperty(value = "日志主键")
@ExcelProperty(value = "日志主键")
/** private Long operId;
* 业务类型（0其它 1新增 2修改 3删除）
*/ /**
@Excel(name = "业务类型", readConverterExp = "0=其它,1=新增,2=修改,3=删除,4=授权,5=导出,6=导入,7=强退,8=生成代码,9=清空数据") * 操作模块
private Integer businessType; */
@ApiModelProperty(value = "操作模块")
/** @ExcelProperty(value = "操作模块")
* 业务类型数组 private String title;
*/
private Integer[] businessTypes; /**
* 业务类型（0其它 1新增 2修改 3删除）
/** */
* 请求方法 @ApiModelProperty(value = "业务类型（0其它 1新增 2修改 3删除）")
*/ @ExcelProperty(value = "业务类型", converter = ExcelDictConvert.class)
@Excel(name = "请求方法") @ExcelDictFormat(dictType = "sys_oper_type")
private String method; private Integer businessType;
/** /**
* 请求方式 * 业务类型数组
*/ */
@Excel(name = "请求方式") @ApiModelProperty(value = "业务类型数组")
private String requestMethod; private Integer[] businessTypes;
/** /**
* 操作类别（0其它 1后台用户 2手机端用户） * 请求方法
*/ */
@Excel(name = "操作类别", readConverterExp = "0=其它,1=后台用户,2=手机端用户") @ApiModelProperty(value = "请求方法")
private Integer operatorType; @ExcelProperty(value = "请求方法")
private String method;
/**
* 操作人员 /**
*/ * 请求方式
@Excel(name = "操作人员") */
private String operName; @ApiModelProperty(value = "请求方式")
@ExcelProperty(value = "请求方式")
/** private String requestMethod;
* 部门名称
*/ /**
@Excel(name = "部门名称") * 操作类别（0其它 1后台用户 2手机端用户）
private String deptName; */
@ApiModelProperty(value = "操作类别（0其它 1后台用户 2手机端用户）")
/** @ExcelProperty(value = "操作类别", converter = ExcelDictConvert.class)
* 请求url @ExcelDictFormat(readConverterExp = "0=其它,1=后台用户,2=手机端用户")
*/ private Integer operatorType;
@Excel(name = "请求地址")
private String operUrl; /**
* 操作人员
/** */
* 操作地址 @ApiModelProperty(value = "操作人员")
*/ @ExcelProperty(value = "操作人员")
@Excel(name = "操作地址") private String operName;
private String operIp;
/**
/** * 部门名称
* 请求参数 */
*/ @ApiModelProperty(value = "部门名称")
@Excel(name = "请求参数") @ExcelProperty(value = "部门名称")
private String operParam; private String deptName;
/** /**
* 返回参数 * 请求url
*/ */
@Excel(name = "返回参数") @ApiModelProperty(value = "请求url")
private String jsonResult; @ExcelProperty(value = "请求地址")
private String operUrl;
/**
* 操作状态（0正常 1异常） /**
*/ * 操作地址
@Excel(name = "状态", readConverterExp = "0=正常,1=异常") */
private Integer status; @ApiModelProperty(value = "操作地址")
@ExcelProperty(value = "操作地址")
/** private String operIp;
* 错误消息
*/ /**
@Excel(name = "错误消息") * 请求参数
private String errorMsg; */
@ApiModelProperty(value = "请求参数")
/** @ExcelProperty(value = "请求参数")
* 操作时间 private String operParam;
*/
@Excel(name = "操作时间", width = 30, dateFormat = "yyyy-MM-dd HH:mm:ss") /**
private Date operTime; * 返回参数
*/
} @ApiModelProperty(value = "返回参数")
@ExcelProperty(value = "返回参数")
private String jsonResult;
/**
* 操作状态（0正常 1异常）
*/
@ApiModelProperty(value = "操作状态（0正常 1异常）")
@ExcelProperty(value = "状态", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "sys_common_status")
private Integer status;
/**
* 错误消息
*/
@ApiModelProperty(value = "错误消息")
@ExcelProperty(value = "错误消息")
private String errorMsg;
/**
* 操作时间
*/
@ApiModelProperty(value = "操作时间")
@ExcelProperty(value = "操作时间")
private Date operTime;
/**
* 请求参数
*/
@ApiModelProperty(value = "请求参数")
private Map<String, Object> params = new HashMap<>();
}

242
ruoyi-api/ruoyi-api-system/src/main/java/com/ruoyi/system/api/domain/SysRole.java
View File

@ -1,108 +1,134 @@
package com.ruoyi.system.api.domain; package com.ruoyi.system.api.domain;
import com.ruoyi.common.core.annotation.Excel; import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.ruoyi.common.core.annotation.Excel.ColumnType; import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.core.web.domain.BaseEntity; import com.ruoyi.common.core.web.domain.BaseEntity;
import lombok.Data; import com.ruoyi.common.excel.annotation.ExcelDictFormat;
import lombok.EqualsAndHashCode; import com.ruoyi.common.excel.convert.ExcelDictConvert;
import lombok.NoArgsConstructor; import io.swagger.annotations.ApiModelProperty;
import lombok.experimental.Accessors; import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.NotBlank; import lombok.NoArgsConstructor;
import javax.validation.constraints.Size; import lombok.experimental.Accessors;
/** import javax.validation.constraints.NotBlank;
* 角色表 sys_role import javax.validation.constraints.Size;
*
* @author ruoyi /**
*/ * 角色表 sys_role
@Data *
@EqualsAndHashCode(callSuper = true) * @author Lion Li
@NoArgsConstructor */
@Accessors(chain = true)
public class SysRole extends BaseEntity { @Data
@NoArgsConstructor
/** @EqualsAndHashCode(callSuper = true)
* 角色ID @Accessors(chain = true)
*/ @ExcelIgnoreUnannotated
@Excel(name = "角色序号", cellType = ColumnType.NUMERIC) public class SysRole extends BaseEntity {
private Long roleId;
/**
/** * 角色ID
* 角色名称 */
*/ @ApiModelProperty(value = "角色ID")
@NotBlank(message = "角色名称不能为空") @ExcelProperty(value = "角色序号")
@Size(min = 0, max = 30, message = "角色名称长度不能超过30个字符") private Long roleId;
@Excel(name = "角色名称")
private String roleName; /**
* 角色名称
/** */
* 角色权限 @ApiModelProperty(value = "角色名称")
*/ @ExcelProperty(value = "角色名称")
@NotBlank(message = "权限字符不能为空") @NotBlank(message = "角色名称不能为空")
@Size(min = 0, max = 100, message = "权限字符长度不能超过100个字符") @Size(min = 0, max = 30, message = "角色名称长度不能超过30个字符")
@Excel(name = "角色权限") private String roleName;
private String roleKey;
/**
/** * 角色权限
* 角色排序 */
*/ @ApiModelProperty(value = "角色权限")
@NotBlank(message = "显示顺序不能为空") @ExcelProperty(value = "角色权限")
@Excel(name = "角色排序") @NotBlank(message = "权限字符不能为空")
private String roleSort; @Size(min = 0, max = 100, message = "权限字符长度不能超过100个字符")
private String roleKey;
/**
* 数据范围（1：所有数据权限；2：自定义数据权限；3：本部门数据权限；4：本部门及以下数据权限；5：仅本人数据权限） /**
*/ * 角色排序
@Excel(name = "数据范围", readConverterExp = "1=所有数据权限,2=自定义数据权限,3=本部门数据权限,4=本部门及以下数据权限,5=仅本人数据权限") */
private String dataScope; @ApiModelProperty(value = "角色排序")
@ExcelProperty(value = "角色排序")
/** @NotBlank(message = "显示顺序不能为空")
* 菜单树选择项是否关联显示（ 0：父子不互相关联显示 1：父子互相关联显示） private String roleSort;
*/
private boolean menuCheckStrictly; /**
* 数据范围（1：所有数据权限；2：自定义数据权限；3：本部门数据权限；4：本部门及以下数据权限；5：仅本人数据权限）
/** */
* 部门树选择项是否关联显示（0：父子不互相关联显示 1：父子互相关联显示 ） @ApiModelProperty(value = "数据范围（1：所有数据权限；2：自定义数据权限；3：本部门数据权限；4：本部门及以下数据权限；5：仅本人数据权限）")
*/ @ExcelProperty(value = "数据范围", converter = ExcelDictConvert.class)
private boolean deptCheckStrictly; @ExcelDictFormat(readConverterExp = "1=所有数据权限,2=自定义数据权限,3=本部门数据权限,4=本部门及以下数据权限,5=仅本人数据权限")
private String dataScope;
/**
* 角色状态（0正常 1停用） /**
*/ * 菜单树选择项是否关联显示（ 0：父子不互相关联显示 1：父子互相关联显示）
@Excel(name = "角色状态", readConverterExp = "0=正常,1=停用") */
private String status; @ApiModelProperty(value = "菜单树选择项是否关联显示（ 0：父子不互相关联显示 1：父子互相关联显示）")
private boolean menuCheckStrictly;
/**
* 删除标志（0代表存在 2代表删除） /**
*/ * 部门树选择项是否关联显示（0：父子不互相关联显示 1：父子互相关联显示 ）
private String delFlag; */
@ApiModelProperty(value = "部门树选择项是否关联显示（0：父子不互相关联显示 1：父子互相关联显示 ）")
/** private boolean deptCheckStrictly;
* 用户是否存在此角色标识 默认不存在
*/ /**
private boolean flag = false; * 角色状态（0正常 1停用）
*/
/** @ApiModelProperty(value = "角色状态（0正常 1停用）")
* 菜单组 @ExcelProperty(value = "角色状态", converter = ExcelDictConvert.class)
*/ @ExcelDictFormat(dictType = "sys_common_status")
private Long[] menuIds; private String status;
/** /**
* 部门组（数据权限） * 删除标志（0代表存在 2代表删除）
*/ */
private Long[] deptIds; @ApiModelProperty(value = "删除标志（0代表存在 2代表删除）")
private String delFlag;
public SysRole(Long roleId) {
this.roleId = roleId; /**
} * 备注
*/
public boolean isAdmin() { @ApiModelProperty(value = "备注")
return isAdmin(this.roleId); private String remark;
}
/**
public static boolean isAdmin(Long roleId) { * 用户是否存在此角色标识 默认不存在
return roleId != null && 1L == roleId; */
} @ApiModelProperty(value = "用户是否存在此角色标识 默认不存在")
private boolean flag = false;
}
/**
* 菜单组
*/
@ApiModelProperty(value = "菜单组")
private Long[] menuIds;
/**
* 部门组（数据权限）
*/
@ApiModelProperty(value = "部门组（数据权限）")
private Long[] deptIds;
public SysRole(Long roleId) {
this.roleId = roleId;
}
@ApiModelProperty(value = "是否管理员")
public boolean isAdmin() {
return isAdmin(this.roleId);
}
public static boolean isAdmin(Long roleId) {
return roleId != null && 1L == roleId;
}
}

336
ruoyi-api/ruoyi-api-system/src/main/java/com/ruoyi/system/api/domain/SysUser.java
View File

@ -1,157 +1,179 @@
package com.ruoyi.system.api.domain; package com.ruoyi.system.api.domain;
import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonIgnore;
import com.ruoyi.common.core.annotation.Excel; import com.fasterxml.jackson.annotation.JsonProperty;
import com.ruoyi.common.core.annotation.Excel.ColumnType; import com.ruoyi.common.core.web.domain.BaseEntity;
import com.ruoyi.common.core.annotation.Excel.Type; import com.ruoyi.common.core.xss.Xss;
import com.ruoyi.common.core.annotation.Excels; import io.swagger.annotations.ApiModel;
import com.ruoyi.common.core.web.domain.BaseEntity; import io.swagger.annotations.ApiModelProperty;
import com.ruoyi.common.core.xss.Xss; import lombok.Data;
import lombok.Data; import lombok.EqualsAndHashCode;
import lombok.EqualsAndHashCode; import lombok.NoArgsConstructor;
import lombok.NoArgsConstructor; import lombok.experimental.Accessors;
import lombok.experimental.Accessors;
import javax.validation.constraints.Email;
import javax.validation.constraints.Email; import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotBlank; import javax.validation.constraints.Size;
import javax.validation.constraints.Size; import java.util.Date;
import java.util.Date; import java.util.List;
import java.util.List;
/**
/** * 用户对象 sys_user
* 用户对象 sys_user *
* * @author Lion Li
* @author ruoyi */
*/
@Data @Data
@EqualsAndHashCode(callSuper = true) @NoArgsConstructor
@NoArgsConstructor @EqualsAndHashCode(callSuper = true)
@Accessors(chain = true) @Accessors(chain = true)
public class SysUser extends BaseEntity { @ApiModel("用户信息业务对象")
public class SysUser extends BaseEntity {
/**
* 用户ID /**
*/ * 用户ID
@Excel(name = "用户序号", cellType = ColumnType.NUMERIC, prompt = "用户编号") */
private Long userId; @ApiModelProperty(value = "用户ID")
private Long userId;
/**
* 部门ID /**
*/ * 部门ID
@Excel(name = "部门编号", type = Type.IMPORT) */
private Long deptId; @ApiModelProperty(value = "部门ID")
private Long deptId;
/**
* 用户账号 /**
*/ * 用户账号
@Xss(message = "用户账号不能包含脚本字符") */
@NotBlank(message = "用户账号不能为空") @ApiModelProperty(value = "用户账号")
@Size(min = 0, max = 30, message = "用户账号长度不能超过30个字符") @Xss(message = "用户账号不能包含脚本字符")
@Excel(name = "登录名称") @NotBlank(message = "用户账号不能为空")
private String userName; @Size(min = 0, max = 30, message = "用户账号长度不能超过30个字符")
private String userName;
/**
* 用户昵称 /**
*/ * 用户昵称
@Xss(message = "用户昵称不能包含脚本字符") */
@Size(min = 0, max = 30, message = "用户昵称长度不能超过30个字符") @ApiModelProperty(value = "用户昵称")
@Excel(name = "用户名称") @Xss(message = "用户昵称不能包含脚本字符")
private String nickName; @Size(min = 0, max = 30, message = "用户昵称长度不能超过30个字符")
private String nickName;
/**
* 用户邮箱 /**
*/ * 用户类型（sys_user系统用户）
@Email(message = "邮箱格式不正确") */
@Size(min = 0, max = 50, message = "邮箱长度不能超过50个字符") @ApiModelProperty(value = "用户类型")
@Excel(name = "用户邮箱") private String userType;
private String email;
/**
/** * 用户邮箱
* 手机号码 */
*/ @ApiModelProperty(value = "用户邮箱")
@Size(min = 0, max = 11, message = "手机号码长度不能超过11个字符") @Email(message = "邮箱格式不正确")
@Excel(name = "手机号码") @Size(min = 0, max = 50, message = "邮箱长度不能超过50个字符")
private String phonenumber; private String email;
/** /**
* 用户性别 * 手机号码
*/ */
@Excel(name = "用户性别", readConverterExp = "0=男,1=女,2=未知") @ApiModelProperty(value = "手机号码")
private String sex; private String phonenumber;
/** /**
* 用户头像 * 用户性别
*/ */
private String avatar; @ApiModelProperty(value = "用户性别")
private String sex;
/**
* 密码 /**
*/ * 用户头像
@JsonProperty */
private String password; @ApiModelProperty(value = "用户头像")
private String avatar;
/**
* 帐号状态（0正常 1停用） /**
*/ * 密码
@Excel(name = "帐号状态", readConverterExp = "0=正常,1=停用") */
private String status; @ApiModelProperty(value = "密码")
private String password;
/**
* 删除标志（0代表存在 2代表删除） @JsonIgnore
*/ @JsonProperty
private String delFlag; public String getPassword() {
return password;
/** }
* 最后登录IP
*/ /**
@Excel(name = "最后登录IP", type = Type.EXPORT) * 帐号状态（0正常 1停用）
private String loginIp; */
@ApiModelProperty(value = "帐号状态（0正常 1停用）")
/** private String status;
* 最后登录时间
*/ /**
@Excel(name = "最后登录时间", width = 30, dateFormat = "yyyy-MM-dd HH:mm:ss", type = Type.EXPORT) * 删除标志（0代表存在 2代表删除）
private Date loginDate; */
@ApiModelProperty(value = "删除标志（0代表存在 2代表删除）")
/** private String delFlag;
* 部门对象
*/ /**
@Excels({ * 最后登录IP
@Excel(name = "部门名称", targetAttr = "deptName", type = Type.EXPORT), */
@Excel(name = "部门负责人", targetAttr = "leader", type = Type.EXPORT) @ApiModelProperty(value = "最后登录IP")
}) private String loginIp;
private SysDept dept;
/**
/** * 最后登录时间
* 角色对象 */
*/ @ApiModelProperty(value = "最后登录时间")
private List<SysRole> roles; private Date loginDate;
/** /**
* 角色组 * 备注
*/ */
private Long[] roleIds; @ApiModelProperty(value = "备注")
private String remark;
/**
* 岗位组 /**
*/ * 部门对象
private Long[] postIds; */
@ApiModelProperty(value = "部门对象")
/** private SysDept dept;
* 角色ID
*/ /**
private Long roleId; * 角色对象
*/
public SysUser(Long userId) { @ApiModelProperty(value = "角色对象")
this.userId = userId; private List<SysRole> roles;
}
/**
public boolean isAdmin() { * 角色组
return isAdmin(this.userId); */
} @ApiModelProperty(value = "角色组")
private Long[] roleIds;
public static boolean isAdmin(Long userId) {
return userId != null && 1L == userId; /**
} * 岗位组
*/
} @ApiModelProperty(value = "岗位组")
private Long[] postIds;
/**
* 数据权限 当前角色ID
*/
@ApiModelProperty(value = "角色ID")
private Long roleId;
public SysUser(Long userId) {
this.userId = userId;
}
@ApiModelProperty(value = "是否管理员")
public boolean isAdmin() {
return isAdmin(this.userId);
}
public static boolean isAdmin(Long userId) {
return userId != null && 1L == userId;
}
}

145
ruoyi-auth/src/main/java/com/ruoyi/auth/controller/TokenController.java
View File

@ -1,72 +1,73 @@
package com.ruoyi.auth.controller; package com.ruoyi.auth.controller;
import com.ruoyi.auth.form.LoginBody; import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.auth.form.RegisterBody; import com.ruoyi.auth.form.LoginBody;
import com.ruoyi.auth.service.SysLoginService; import com.ruoyi.auth.form.RegisterBody;
import com.ruoyi.common.core.domain.R; import com.ruoyi.auth.service.SysLoginService;
import com.ruoyi.common.core.utils.JwtUtils; import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.utils.StringUtils; import com.ruoyi.common.core.utils.JwtUtils;
import com.ruoyi.common.security.auth.AuthUtil; import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.security.service.TokenService; import com.ruoyi.common.security.auth.AuthUtil;
import com.ruoyi.common.security.utils.SecurityUtils; import com.ruoyi.common.security.service.TokenService;
import com.ruoyi.system.api.model.LoginUser; import com.ruoyi.common.security.utils.SecurityUtils;
import lombok.RequiredArgsConstructor; import com.ruoyi.system.api.model.LoginUser;
import org.springframework.beans.factory.annotation.Autowired; import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.DeleteMapping; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequest;
/**
* token 控制 /**
* * token 控制
* @author ruoyi *
*/ * @author ruoyi
@RequiredArgsConstructor(onConstructor_ = @Autowired) */
@RestController @RequiredArgsConstructor(onConstructor_ = @Autowired)
public class TokenController { @RestController
public class TokenController {
private final TokenService tokenService;
private final SysLoginService sysLoginService; private final TokenService tokenService;
private final SysLoginService sysLoginService;
@PostMapping("login")
public R<?> login(@RequestBody LoginBody form) { @PostMapping("login")
// 用户登录 public R<?> login(@RequestBody LoginBody form) {
LoginUser userInfo = sysLoginService.login(form.getUsername(), form.getPassword()); // 用户登录
// 获取登录token LoginUser userInfo = sysLoginService.login(form.getUsername(), form.getPassword());
return R.ok(tokenService.createToken(userInfo)); // 获取登录token
} return R.ok(tokenService.createToken(userInfo));
}
@DeleteMapping("logout")
public R<?> logout(HttpServletRequest request) { @DeleteMapping("logout")
String token = SecurityUtils.getToken(request); public R<?> logout(HttpServletRequest request) {
if (StringUtils.isNotEmpty(token)) { String token = SecurityUtils.getToken(request);
String username = JwtUtils.getUserName(token); if (StringUtils.isNotEmpty(token)) {
// 删除用户缓存记录 String username = JwtUtils.getUserName(token);
AuthUtil.logoutByToken(token); // 删除用户缓存记录
// 记录用户退出日志 AuthUtil.logoutByToken(token);
sysLoginService.logout(username); // 记录用户退出日志
} sysLoginService.logout(username);
return R.ok(); }
} return R.ok();
}
@PostMapping("refresh")
public R<?> refresh(HttpServletRequest request) { @PostMapping("refresh")
LoginUser loginUser = tokenService.getLoginUser(request); public R<?> refresh(HttpServletRequest request) {
if (StringUtils.isNotNull(loginUser)) { LoginUser loginUser = tokenService.getLoginUser(request);
// 刷新令牌有效期 if (ObjectUtil.isNotNull(loginUser)) {
tokenService.refreshToken(loginUser); // 刷新令牌有效期
return R.ok(); tokenService.refreshToken(loginUser);
} return R.ok();
return R.ok(); }
} return R.ok();
}
@PostMapping("register")
public R<?> register(@RequestBody RegisterBody registerBody) { @PostMapping("register")
// 用户注册 public R<?> register(@RequestBody RegisterBody registerBody) {
sysLoginService.register(registerBody.getUsername(), registerBody.getPassword()); // 用户注册
return R.ok(); sysLoginService.register(registerBody.getUsername(), registerBody.getPassword());
} return R.ok();
} }
}

8
ruoyi-auth/src/main/java/com/ruoyi/auth/service/SysLoginService.java
View File

@ -1,5 +1,6 @@
package com.ruoyi.auth.service; package com.ruoyi.auth.service;
import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.constant.Constants; import com.ruoyi.common.core.constant.Constants;
import com.ruoyi.common.core.constant.SecurityConstants; import com.ruoyi.common.core.constant.SecurityConstants;
import com.ruoyi.common.core.constant.UserConstants; import com.ruoyi.common.core.constant.UserConstants;
@ -7,7 +8,6 @@ import com.ruoyi.common.core.enums.UserStatus;
import com.ruoyi.common.core.exception.ServiceException; import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.core.utils.ServletUtils; import com.ruoyi.common.core.utils.ServletUtils;
import com.ruoyi.common.core.utils.StringUtils; import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.core.utils.ip.IpUtils;
import com.ruoyi.common.security.utils.SecurityUtils; import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.system.api.RemoteLogService; import com.ruoyi.system.api.RemoteLogService;
import com.ruoyi.system.api.RemoteUserService; import com.ruoyi.system.api.RemoteUserService;
@ -54,7 +54,7 @@ public class SysLoginService {
// 查询用户信息 // 查询用户信息
LoginUser userInfo = remoteUserService.getUserInfo(username, SecurityConstants.INNER); LoginUser userInfo = remoteUserService.getUserInfo(username, SecurityConstants.INNER);
if (StringUtils.isNull(userInfo)) { if (ObjectUtil.isNull(userInfo)) {
recordLogininfor(username, Constants.LOGIN_FAIL, "登录用户不存在"); recordLogininfor(username, Constants.LOGIN_FAIL, "登录用户不存在");
throw new ServiceException("登录用户：" + username + " 不存在"); throw new ServiceException("登录用户：" + username + " 不存在");
} }
@ -117,7 +117,7 @@ public class SysLoginService {
public void recordLogininfor(String username, String status, String message) { public void recordLogininfor(String username, String status, String message) {
SysLogininfor logininfor = new SysLogininfor(); SysLogininfor logininfor = new SysLogininfor();
logininfor.setUserName(username); logininfor.setUserName(username);
logininfor.setIpaddr(IpUtils.getIpAddr(ServletUtils.getRequest())); logininfor.setIpaddr(ServletUtils.getClientIP());
logininfor.setMsg(message); logininfor.setMsg(message);
// 日志状态 // 日志状态
if (StringUtils.equalsAny(status, Constants.LOGIN_SUCCESS, Constants.LOGOUT, Constants.REGISTER)) { if (StringUtils.equalsAny(status, Constants.LOGIN_SUCCESS, Constants.LOGOUT, Constants.REGISTER)) {
@ -127,4 +127,4 @@ public class SysLoginService {
} }
remoteLogService.saveLogininfor(logininfor, SecurityConstants.INNER); remoteLogService.saveLogininfor(logininfor, SecurityConstants.INNER);
} }
} }

1
ruoyi-common/pom.xml
View File

@ -12,6 +12,7 @@
<module>ruoyi-common-bom</module> <module>ruoyi-common-bom</module>
<module>ruoyi-common-log</module> <module>ruoyi-common-log</module>
<module>ruoyi-common-dict</module> <module>ruoyi-common-dict</module>
<module>ruoyi-common-excel</module>
<module>ruoyi-common-core</module> <module>ruoyi-common-core</module>
<module>ruoyi-common-redis</module> <module>ruoyi-common-redis</module>
<module>ruoyi-common-swagger</module> <module>ruoyi-common-swagger</module>

7
ruoyi-common/ruoyi-common-bom/pom.xml
View File

@ -64,6 +64,13 @@
<version>${project.version}</version> <version>${project.version}</version>
</dependency> </dependency>
<!-- excel -->
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>ruoyi-common-excel</artifactId>
<version>${project.version}</version>
</dependency>
<!-- 缓存服务 --> <!-- 缓存服务 -->
<dependency> <dependency>
<groupId>com.ruoyi</groupId> <groupId>com.ruoyi</groupId>

10
ruoyi-common/ruoyi-common-core/pom.xml
View File

@ -93,10 +93,9 @@
<artifactId>commons-fileupload</artifactId> <artifactId>commons-fileupload</artifactId>
</dependency> </dependency>
<!-- excel工具 -->
<dependency> <dependency>
<groupId>org.apache.poi</groupId> <groupId>cglib</groupId>
<artifactId>poi-ooxml</artifactId> <artifactId>cglib</artifactId>
</dependency> </dependency>
<!-- Java Servlet --> <!-- Java Servlet -->
@ -126,6 +125,11 @@
<artifactId>hutool-jwt</artifactId> <artifactId>hutool-jwt</artifactId>
</dependency> </dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-http</artifactId>
</dependency>
<dependency> <dependency>
<groupId>cn.hutool</groupId> <groupId>cn.hutool</groupId>
<artifactId>hutool-extra</artifactId> <artifactId>hutool-extra</artifactId>

162
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/annotation/Excel.java
View File

@ -1,162 +0,0 @@
package com.ruoyi.common.core.annotation;
import com.ruoyi.common.core.utils.poi.ExcelHandlerAdapter;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.math.BigDecimal;
/**
* 自定义导出Excel数据注解
*
* @author ruoyi
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Excel {
/**
* 导出时在excel中排序
*/
public int sort() default Integer.MAX_VALUE;
/**
* 导出到Excel中的名字.
*/
public String name() default "";
/**
* 日期格式, 如: yyyy-MM-dd
*/
public String dateFormat() default "";
/**
* 读取内容转表达式 (如: 0=男,1=女,2=未知)
*/
public String readConverterExp() default "";
/**
* 分隔符，读取字符串组内容
*/
public String separator() default ",";
/**
* BigDecimal 精度 默认:-1(默认不开启BigDecimal格式化)
*/
public int scale() default -1;
/**
* BigDecimal 舍入规则 默认:BigDecimal.ROUND_HALF_EVEN
*/
public int roundingMode() default BigDecimal.ROUND_HALF_EVEN;
/**
* 导出类型（0数字 1字符串）
*/
public ColumnType cellType() default ColumnType.STRING;
/**
* 导出时在excel中每个列的高度 单位为字符
*/
public double height() default 14;
/**
* 导出时在excel中每个列的宽 单位为字符
*/
public double width() default 16;
/**
* 文字后缀,如% 90 变成90%
*/
public String suffix() default "";
/**
* 当值为空时,字段的默认值
*/
public String defaultValue() default "";
/**
* 提示信息
*/
public String prompt() default "";
/**
* 设置只能选择不能输入的列内容.
*/
public String[] combo() default {};
/**
* 是否导出数据,应对需求:有时我们需要导出一份模板,这是标题需要但内容需要用户手工填写.
*/
public boolean isExport() default true;
/**
* 另一个类中的属性名称,支持多级获取,以小数点隔开
*/
public String targetAttr() default "";
/**
* 是否自动统计数据,在最后追加一行统计数据总和
*/
public boolean isStatistics() default false;
/**
* 导出字段对齐方式（0：默认；1：靠左；2：居中；3：靠右）
*/
public Align align() default Align.AUTO;
/**
* 自定义数据处理器
*/
public Class<?> handler() default ExcelHandlerAdapter.class;
/**
* 自定义数据处理器参数
*/
public String[] args() default {};
public enum Align {
AUTO(0), LEFT(1), CENTER(2), RIGHT(3);
private final int value;
Align(int value) {
this.value = value;
}
public int value() {
return this.value;
}
}
/**
* 字段类型（0：导出导入；1：仅导出；2：仅导入）
*/
Type type() default Type.ALL;
public enum Type {
ALL(0), EXPORT(1), IMPORT(2);
private final int value;
Type(int value) {
this.value = value;
}
public int value() {
return this.value;
}
}
public enum ColumnType {
NUMERIC(0), STRING(1), IMAGE(2);
private final int value;
ColumnType(int value) {
this.value = value;
}
public int value() {
return this.value;
}
}
}

17
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/annotation/Excels.java
View File

@ -1,17 +0,0 @@
package com.ruoyi.common.core.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Excel注解集
*
* @author ruoyi
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Excels {
Excel[] value();
}

43
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/config/ValidatorConfig.java Normal file
View File

@ -0,0 +1,43 @@
package com.ruoyi.common.core.config;
import org.hibernate.validator.HibernateValidator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.MessageSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.validation.beanvalidation.LocalValidatorFactoryBean;
import javax.validation.Validator;
import java.util.Properties;
/**
* 校验框架配置类
*
* @author Lion Li
*/
@Configuration
public class ValidatorConfig {
@Autowired
private MessageSource messageSource;
/**
* 配置校验框架 快速返回模式
*/
@Bean
public Validator validator() {
LocalValidatorFactoryBean factoryBean = new LocalValidatorFactoryBean();
// 国际化
factoryBean.setValidationMessageSource(messageSource);
// 设置使用 HibernateValidator 校验器
factoryBean.setProviderClass(HibernateValidator.class);
Properties properties = new Properties();
// 设置 快速异常返回
properties.setProperty("hibernate.validator.fail_fast", "true");
factoryBean.setValidationProperties(properties);
// 加载配置
factoryBean.afterPropertiesSet();
return factoryBean.getValidator();
}
}

2
ruoyi-common/ruoyi-common-dict/src/main/java/com/ruoyi/common/dict/service/DictService.java → ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/service/DictService.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.common.dict.service; package com.ruoyi.common.core.service;
/** /**
* 字典服务服务 * 字典服务服务

121
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/utils/BeanCopyUtils.java Normal file
View File

@ -0,0 +1,121 @@
package com.ruoyi.common.core.utils;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.extra.cglib.CglibUtil;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import java.util.List;
import java.util.Map;
/**
* bean深拷贝工具(基于 cglib 性能优异)
*
* @author Lion Li
*/
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class BeanCopyUtils {
/**
* 单对象基于class创建拷贝
*
* @param source 数据来源实体
* @param desc 描述对象 转换后的对象
* @return desc
*/
public static <T, V> V copy(T source, Class<V> desc) {
if (ObjectUtil.isNull(source)) {
return null;
}
if (ObjectUtil.isNull(desc)) {
return null;
}
return CglibUtil.copy(source, desc);
}
/**
* 单对象基于对象创建拷贝
*
* @param source 数据来源实体
* @param desc 转换后的对象
* @return desc
*/
public static <T, V> V copy(T source, V desc) {
if (ObjectUtil.isNull(source)) {
return null;
}
if (ObjectUtil.isNull(desc)) {
return null;
}
CglibUtil.copy(source, desc);
return desc;
}
/**
* 列表对象基于class创建拷贝
*
* @param sourceList 数据来源实体列表
* @param desc 描述对象 转换后的对象
* @return desc
*/
public static <T, V> List<V> copyList(List<T> sourceList, Class<V> desc) {
if (ObjectUtil.isNull(sourceList)) {
return null;
}
if (CollUtil.isEmpty(sourceList)) {
return CollUtil.newArrayList();
}
return CglibUtil.copyList(sourceList, () -> ReflectUtil.newInstanceIfPossible(desc));
}
/**
* bean拷贝到map
*
* @param bean 数据来源实体
* @return map对象
*/
@SuppressWarnings("all")
public static <T> Map<String, Object> copyToMap(T bean) {
if (ObjectUtil.isNull(bean)) {
return null;
}
return CglibUtil.toMap(bean);
}
/**
* map拷贝到bean
*
* @param map 数据来源
* @param beanClass bean类
* @return bean对象
*/
public static <T> T mapToBean(Map<String, Object> map, Class<T> beanClass) {
if (MapUtil.isEmpty(map)) {
return null;
}
if (ObjectUtil.isNull(beanClass)) {
return null;
}
return CglibUtil.toBean(map, beanClass);
}
/**
* map拷贝到bean
*
* @param map 数据来源
* @param bean bean对象
* @return bean对象
*/
public static <T> T mapToBean(Map<String, Object> map, T bean) {
if (MapUtil.isEmpty(map)) {
return null;
}
if (ObjectUtil.isNull(bean)) {
return null;
}
return CglibUtil.fillBean(map, bean);
}
}

274
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/utils/DateUtils.java
View File

@ -1,135 +1,139 @@
package com.ruoyi.common.core.utils; package com.ruoyi.common.core.utils;
import org.apache.commons.lang3.time.DateFormatUtils; import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import java.lang.management.ManagementFactory; import org.apache.commons.lang3.time.DateFormatUtils;
import java.text.ParseException;
import java.text.SimpleDateFormat; import java.lang.management.ManagementFactory;
import java.util.Date; import java.text.ParseException;
import java.text.SimpleDateFormat;
/** import java.util.Date;
* 时间工具类
* /**
* @author ruoyi * 时间工具类
*/ *
public class DateUtils extends org.apache.commons.lang3.time.DateUtils { * @author ruoyi
public static String YYYY = "yyyy"; */
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public static String YYYY_MM = "yyyy-MM"; public class DateUtils extends org.apache.commons.lang3.time.DateUtils {
public static String YYYY_MM_DD = "yyyy-MM-dd"; public static String YYYY = "yyyy";
public static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss"; public static String YYYY_MM = "yyyy-MM";
public static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss"; public static String YYYY_MM_DD = "yyyy-MM-dd";
private static String[] parsePatterns = { public static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
"yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM",
"yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM", public static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
"yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM"};
private static String[] parsePatterns = {
/** "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM",
* 获取当前Date型日期 "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM",
* "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM"};
* @return Date() 当前日期
*/ /**
public static Date getNowDate() { * 获取当前Date型日期
return new Date(); *
} * @return Date() 当前日期
*/
/** public static Date getNowDate() {
* 获取当前日期, 默认格式为yyyy-MM-dd return new Date();
* }
* @return String
*/ /**
public static String getDate() { * 获取当前日期, 默认格式为yyyy-MM-dd
return dateTimeNow(YYYY_MM_DD); *
} * @return String
*/
public static final String getTime() { public static String getDate() {
return dateTimeNow(YYYY_MM_DD_HH_MM_SS); return dateTimeNow(YYYY_MM_DD);
} }
public static final String dateTimeNow() { public static final String getTime() {
return dateTimeNow(YYYYMMDDHHMMSS); return dateTimeNow(YYYY_MM_DD_HH_MM_SS);
} }
public static final String dateTimeNow(final String format) { public static final String dateTimeNow() {
return parseDateToStr(format, new Date()); return dateTimeNow(YYYYMMDDHHMMSS);
} }
public static final String dateTime(final Date date) { public static final String dateTimeNow(final String format) {
return parseDateToStr(YYYY_MM_DD, date); return parseDateToStr(format, new Date());
} }
public static final String parseDateToStr(final String format, final Date date) { public static final String dateTime(final Date date) {
return new SimpleDateFormat(format).format(date); return parseDateToStr(YYYY_MM_DD, date);
} }
public static final Date dateTime(final String format, final String ts) { public static final String parseDateToStr(final String format, final Date date) {
try { return new SimpleDateFormat(format).format(date);
return new SimpleDateFormat(format).parse(ts); }
} catch (ParseException e) {
throw new RuntimeException(e); public static final Date dateTime(final String format, final String ts) {
} try {
} return new SimpleDateFormat(format).parse(ts);
} catch (ParseException e) {
/** throw new RuntimeException(e);
* 日期路径 即年/月/日 如2018/08/08 }
*/ }
public static final String datePath() {
Date now = new Date(); /**
return DateFormatUtils.format(now, "yyyy/MM/dd"); * 日期路径 即年/月/日 如2018/08/08
} */
public static final String datePath() {
/** Date now = new Date();
* 日期路径 即年/月/日 如20180808 return DateFormatUtils.format(now, "yyyy/MM/dd");
*/ }
public static final String dateTime() {
Date now = new Date(); /**
return DateFormatUtils.format(now, "yyyyMMdd"); * 日期路径 即年/月/日 如20180808
} */
public static final String dateTime() {
/** Date now = new Date();
* 日期型字符串转化为日期 格式 return DateFormatUtils.format(now, "yyyyMMdd");
*/ }
public static Date parseDate(Object str) {
if (str == null) { /**
return null; * 日期型字符串转化为日期 格式
} */
try { public static Date parseDate(Object str) {
return parseDate(str.toString(), parsePatterns); if (str == null) {
} catch (ParseException e) { return null;
return null; }
} try {
} return parseDate(str.toString(), parsePatterns);
} catch (ParseException e) {
/** return null;
* 获取服务器启动时间 }
*/ }
public static Date getServerStartDate() {
long time = ManagementFactory.getRuntimeMXBean().getStartTime(); /**
return new Date(time); * 获取服务器启动时间
} */
public static Date getServerStartDate() {
/** long time = ManagementFactory.getRuntimeMXBean().getStartTime();
* 计算两个时间差 return new Date(time);
*/ }
public static String getDatePoor(Date endDate, Date nowDate) {
long nd = 1000 * 24 * 60 * 60; /**
long nh = 1000 * 60 * 60; * 计算两个时间差
long nm = 1000 * 60; */
// long ns = 1000; public static String getDatePoor(Date endDate, Date nowDate) {
// 获得两个时间的毫秒时间差异 long nd = 1000 * 24 * 60 * 60;
long diff = endDate.getTime() - nowDate.getTime(); long nh = 1000 * 60 * 60;
// 计算差多少天 long nm = 1000 * 60;
long day = diff / nd; // long ns = 1000;
// 计算差多少小时 // 获得两个时间的毫秒时间差异
long hour = diff % nd / nh; long diff = endDate.getTime() - nowDate.getTime();
// 计算差多少分钟 // 计算差多少天
long min = diff % nd % nh / nm; long day = diff / nd;
// 计算差多少秒//输出结果 // 计算差多少小时
// long sec = diff % nd % nh % nm / ns; long hour = diff % nd / nh;
return day + "天" + hour + "小时" + min + "分钟"; // 计算差多少分钟
} long min = diff % nd % nh / nm;
} // 计算差多少秒//输出结果
// long sec = diff % nd % nh % nm / ns;
return day + "天" + hour + "小时" + min + "分钟";
}
}

3
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/utils/JsonUtils.java
View File

@ -1,6 +1,7 @@
package com.ruoyi.common.core.utils; package com.ruoyi.common.core.utils;
import cn.hutool.core.util.ArrayUtil; import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.ObjectUtil;
import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.ObjectMapper;
@ -23,7 +24,7 @@ public class JsonUtils {
private static ObjectMapper objectMapper = SpringUtils.getBean(ObjectMapper.class); private static ObjectMapper objectMapper = SpringUtils.getBean(ObjectMapper.class);
public static String toJsonString(Object object) { public static String toJsonString(Object object) {
if (StringUtils.isNull(object)) { if (ObjectUtil.isNull(object)) {
return null; return null;
} }
try { try {

3
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/utils/PageUtils.java
View File

@ -1,5 +1,6 @@
package com.ruoyi.common.core.utils; package com.ruoyi.common.core.utils;
import cn.hutool.core.util.ObjectUtil;
import com.github.pagehelper.PageHelper; import com.github.pagehelper.PageHelper;
import com.ruoyi.common.core.utils.sql.SqlUtil; import com.ruoyi.common.core.utils.sql.SqlUtil;
import com.ruoyi.common.core.web.page.PageDomain; import com.ruoyi.common.core.web.page.PageDomain;
@ -18,7 +19,7 @@ public class PageUtils extends PageHelper {
PageDomain pageDomain = TableSupport.buildPageRequest(); PageDomain pageDomain = TableSupport.buildPageRequest();
Integer pageNum = pageDomain.getPageNum(); Integer pageNum = pageDomain.getPageNum();
Integer pageSize = pageDomain.getPageSize(); Integer pageSize = pageDomain.getPageSize();
if (StringUtils.isNotNull(pageNum) && StringUtils.isNotNull(pageSize)) { if (ObjectUtil.isNotNull(pageNum) && ObjectUtil.isNotNull(pageSize)) {
String orderBy = SqlUtil.escapeOrderBySql(pageDomain.getOrderBy()); String orderBy = SqlUtil.escapeOrderBySql(pageDomain.getOrderBy());
Boolean reasonable = pageDomain.getReasonable(); Boolean reasonable = pageDomain.getReasonable();
PageHelper.startPage(pageNum, pageSize, orderBy).setReasonable(reasonable); PageHelper.startPage(pageNum, pageSize, orderBy).setReasonable(reasonable);

417
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/utils/ServletUtils.java
View File

@ -1,202 +1,215 @@
package com.ruoyi.common.core.utils; package com.ruoyi.common.core.utils;
import cn.hutool.core.convert.Convert; import cn.hutool.core.convert.Convert;
import com.ruoyi.common.core.constant.Constants; import cn.hutool.extra.servlet.ServletUtil;
import org.springframework.web.context.request.RequestAttributes; import cn.hutool.http.HttpStatus;
import org.springframework.web.context.request.RequestContextHolder; import com.ruoyi.common.core.constant.Constants;
import org.springframework.web.context.request.ServletRequestAttributes; import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import javax.servlet.http.HttpServletRequest; import org.springframework.http.MediaType;
import javax.servlet.http.HttpServletResponse; import org.springframework.web.context.request.RequestAttributes;
import javax.servlet.http.HttpSession; import org.springframework.web.context.request.RequestContextHolder;
import java.io.IOException; import org.springframework.web.context.request.ServletRequestAttributes;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder; import javax.servlet.http.HttpServletRequest;
import java.net.URLEncoder; import javax.servlet.http.HttpServletResponse;
import java.util.Enumeration; import javax.servlet.http.HttpSession;
import java.util.LinkedHashMap; import java.io.IOException;
import java.util.Map; import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
/** import java.net.URLEncoder;
* 客户端工具类 import java.nio.charset.StandardCharsets;
* import java.util.Enumeration;
* @author ruoyi import java.util.LinkedHashMap;
*/ import java.util.Map;
public class ServletUtils {
/** /**
* 获取String参数 * 客户端工具类
*/ *
public static String getParameter(String name) { * @author ruoyi
return getRequest().getParameter(name); */
} @NoArgsConstructor(access = AccessLevel.PRIVATE)
public class ServletUtils extends ServletUtil {
/**
* 获取String参数 /**
*/ * 获取String参数
public static String getParameter(String name, String defaultValue) { */
return Convert.toStr(getRequest().getParameter(name), defaultValue); public static String getParameter(String name) {
} return getRequest().getParameter(name);
}
/**
* 获取Integer参数 /**
*/ * 获取String参数
public static Integer getParameterToInt(String name) { */
return Convert.toInt(getRequest().getParameter(name)); public static String getParameter(String name, String defaultValue) {
} return Convert.toStr(getRequest().getParameter(name), defaultValue);
}
/**
* 获取Integer参数 /**
*/ * 获取Integer参数
public static Integer getParameterToInt(String name, Integer defaultValue) { */
return Convert.toInt(getRequest().getParameter(name), defaultValue); public static Integer getParameterToInt(String name) {
} return Convert.toInt(getRequest().getParameter(name));
}
/**
* 获取Boolean参数 /**
*/ * 获取Integer参数
public static Boolean getParameterToBool(String name) { */
return Convert.toBool(getRequest().getParameter(name)); public static Integer getParameterToInt(String name, Integer defaultValue) {
} return Convert.toInt(getRequest().getParameter(name), defaultValue);
}
/**
* 获取Boolean参数 /**
*/ * 获取Boolean参数
public static Boolean getParameterToBool(String name, Boolean defaultValue) { */
return Convert.toBool(getRequest().getParameter(name), defaultValue); public static Boolean getParameterToBool(String name) {
} return Convert.toBool(getRequest().getParameter(name));
}
/**
* 获取request /**
*/ * 获取Boolean参数
public static HttpServletRequest getRequest() { */
try { public static Boolean getParameterToBool(String name, Boolean defaultValue) {
return getRequestAttributes().getRequest(); return Convert.toBool(getRequest().getParameter(name), defaultValue);
} catch (Exception e) { }
return null;
} /**
} * 获取request
*/
/** public static HttpServletRequest getRequest() {
* 获取response try {
*/ return getRequestAttributes().getRequest();
public static HttpServletResponse getResponse() { } catch (Exception e) {
try { return null;
return getRequestAttributes().getResponse(); }
} catch (Exception e) { }
return null;
} /**
} * 获取response
*/
/** public static HttpServletResponse getResponse() {
* 获取session try {
*/ return getRequestAttributes().getResponse();
public static HttpSession getSession() { } catch (Exception e) {
return getRequest().getSession(); return null;
} }
}
public static ServletRequestAttributes getRequestAttributes() {
try { /**
RequestAttributes attributes = RequestContextHolder.getRequestAttributes(); * 获取session
return (ServletRequestAttributes) attributes; */
} catch (Exception e) { public static HttpSession getSession() {
return null; return getRequest().getSession();
} }
}
public static ServletRequestAttributes getRequestAttributes() {
public static String getHeader(HttpServletRequest request, String name) { try {
String value = request.getHeader(name); RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
if (StringUtils.isEmpty(value)) { return (ServletRequestAttributes) attributes;
return StringUtils.EMPTY; } catch (Exception e) {
} return null;
return urlDecode(value); }
} }
public static Map<String, String> getHeaders(HttpServletRequest request) { public static String getHeader(HttpServletRequest request, String name) {
Map<String, String> map = new LinkedHashMap<>(); String value = request.getHeader(name);
Enumeration<String> enumeration = request.getHeaderNames(); if (StringUtils.isEmpty(value)) {
if (enumeration != null) { return StringUtils.EMPTY;
while (enumeration.hasMoreElements()) { }
String key = enumeration.nextElement(); return urlDecode(value);
String value = request.getHeader(key); }
map.put(key, value);
} public static Map<String, String> getHeaders(HttpServletRequest request) {
} Map<String, String> map = new LinkedHashMap<>();
return map; Enumeration<String> enumeration = request.getHeaderNames();
} if (enumeration != null) {
while (enumeration.hasMoreElements()) {
/** String key = enumeration.nextElement();
* 将字符串渲染到客户端 String value = request.getHeader(key);
* map.put(key, value);
* @param response 渲染对象 }
* @param string 待渲染的字符串 }
* @return null return map;
*/ }
public static String renderString(HttpServletResponse response, String string) {
try { /**
response.setStatus(200); * 将字符串渲染到客户端
response.setContentType("application/json"); *
response.setCharacterEncoding("utf-8"); * @param response 渲染对象
response.getWriter().print(string); * @param string 待渲染的字符串
} catch (IOException e) { * @return null
e.printStackTrace(); */
} public static String renderString(HttpServletResponse response, String string) {
return null; try {
} response.setStatus(HttpStatus.HTTP_OK);
response.setContentType(MediaType.APPLICATION_JSON_VALUE);
/** response.setCharacterEncoding(StandardCharsets.UTF_8.toString());
* 是否是Ajax异步请求 response.getWriter().print(string);
* } catch (IOException e) {
* @param request e.printStackTrace();
*/ }
public static boolean isAjaxRequest(HttpServletRequest request) { return null;
String accept = request.getHeader("accept"); }
if (accept != null && accept.indexOf("application/json") != -1) {
return true; /**
} * 是否是Ajax异步请求
*
String xRequestedWith = request.getHeader("X-Requested-With"); * @param request
if (xRequestedWith != null && xRequestedWith.indexOf("XMLHttpRequest") != -1) { */
return true; public static boolean isAjaxRequest(HttpServletRequest request) {
}
String accept = request.getHeader("accept");
String uri = request.getRequestURI(); if (accept != null && accept.indexOf("application/json") != -1) {
if (StringUtils.inStringIgnoreCase(uri, ".json", ".xml")) { return true;
return true; }
}
String xRequestedWith = request.getHeader("X-Requested-With");
String ajax = request.getParameter("__ajax"); if (xRequestedWith != null && xRequestedWith.indexOf("XMLHttpRequest") != -1) {
if (StringUtils.inStringIgnoreCase(ajax, "json", "xml")) { return true;
return true; }
}
return false; String uri = request.getRequestURI();
} if (StringUtils.equalsAnyIgnoreCase(uri, ".json", ".xml")) {
return true;
/** }
* 内容编码
* String ajax = request.getParameter("__ajax");
* @param str 内容 if (StringUtils.equalsAnyIgnoreCase(ajax, "json", "xml")) {
* @return 编码后的内容 return true;
*/ }
public static String urlEncode(String str) { return false;
try { }
return URLEncoder.encode(str, Constants.UTF8);
} catch (UnsupportedEncodingException e) { public static String getClientIP() {
return StringUtils.EMPTY; return getClientIP(getRequest());
} }
}
/**
/** * 内容编码
* 内容解码 *
* * @param str 内容
* @param str 内容 * @return 编码后的内容
* @return 解码后的内容 */
*/ public static String urlEncode(String str) {
public static String urlDecode(String str) { try {
try { return URLEncoder.encode(str, Constants.UTF8);
return URLDecoder.decode(str, Constants.UTF8); } catch (UnsupportedEncodingException e) {
} catch (UnsupportedEncodingException e) { return StringUtils.EMPTY;
return StringUtils.EMPTY; }
} }
}
/**
} * 内容解码
*
* @param str 内容
* @return 解码后的内容
*/
public static String urlDecode(String str) {
try {
return URLDecoder.decode(str, Constants.UTF8);
} catch (UnsupportedEncodingException e) {
return StringUtils.EMPTY;
}
}
}

132
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/utils/StringUtils.java
View File

@ -2,15 +2,15 @@ package com.ruoyi.common.core.utils;
import cn.hutool.core.collection.CollUtil; import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.Validator; import cn.hutool.core.lang.Validator;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil; import cn.hutool.core.util.StrUtil;
import lombok.AccessLevel; import lombok.AccessLevel;
import lombok.NoArgsConstructor; import lombok.NoArgsConstructor;
import org.springframework.util.AntPathMatcher; import org.springframework.util.AntPathMatcher;
import java.util.*; import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/** /**
* 字符串工具类 * 字符串工具类
@ -20,16 +20,6 @@ import java.util.*;
@NoArgsConstructor(access = AccessLevel.PRIVATE) @NoArgsConstructor(access = AccessLevel.PRIVATE)
public class StringUtils extends org.apache.commons.lang3.StringUtils { public class StringUtils extends org.apache.commons.lang3.StringUtils {
/**
* 获取参数不为空值
*
* @param value defaultValue 要判断的value
* @return value 返回值
*/
public static <T> T nvl(T value, T defaultValue) {
return ObjectUtil.defaultIfNull(value, defaultValue);
}
/** /**
* 获取参数不为空值 * 获取参数不为空值
* *
@ -40,86 +30,6 @@ public class StringUtils extends org.apache.commons.lang3.StringUtils {
return StrUtil.blankToDefault(str, defaultValue); return StrUtil.blankToDefault(str, defaultValue);
} }
/**
* * 判断一个Collection是否为空， 包含List，Set，Queue
*
* @param coll 要判断的Collection
* @return true：为空 false：非空
*/
public static boolean isEmpty(Collection<?> coll) {
return CollUtil.isEmpty(coll);
}
/**
* * 判断一个Collection是否非空，包含List，Set，Queue
*
* @param coll 要判断的Collection
* @return true：非空 false：空
*/
public static boolean isNotEmpty(Collection<?> coll) {
return !isEmpty(coll);
}
/**
* * 判断一个对象数组是否为空
*
* @param objects 要判断的对象数组
* * @return true：为空 false：非空
*/
public static boolean isEmpty(Object[] objects) {
return ArrayUtil.isEmpty(objects);
}
/**
* * 判断一个对象数组是否非空
*
* @param objects 要判断的对象数组
* @return true：非空 false：空
*/
public static boolean isNotEmpty(Object[] objects) {
return !isEmpty(objects);
}
/**
* * 判断一个对象是否为空
*
* @param object 要判断的对象数组
* * @return true：为空 false：非空
*/
public static boolean isEmpty(Object object) {
return ObjectUtil.isEmpty(object);
}
/**
* * 判断一个对象是否非空
*
* @param object 要判断的对象数组
* @return true：非空 false：空
*/
public static boolean isNotEmpty(Object object) {
return !isEmpty(object);
}
/**
* * 判断一个Map是否为空
*
* @param map 要判断的Map
* @return true：为空 false：非空
*/
public static boolean isEmpty(Map<?, ?> map) {
return MapUtil.isEmpty(map);
}
/**
* * 判断一个Map是否为空
*
* @param map 要判断的Map
* @return true：非空 false：空
*/
public static boolean isNotEmpty(Map<?, ?> map) {
return !isEmpty(map);
}
/** /**
* * 判断一个字符串是否为空串 * * 判断一个字符串是否为空串
* *
@ -140,36 +50,6 @@ public class StringUtils extends org.apache.commons.lang3.StringUtils {
return !isEmpty(str); return !isEmpty(str);
} }
/**
* * 判断一个对象是否为空
*
* @param object Object
* @return true：为空 false：非空
*/
public static boolean isNull(Object object) {
return ObjectUtil.isNull(object);
}
/**
* * 判断一个对象是否非空
*
* @param object Object
* @return true：非空 false：空
*/
public static boolean isNotNull(Object object) {
return !isNull(object);
}
/**
* * 判断一个对象是否是数组类型（Java基本型别的数组）
*
* @param object 对象
* @return true：是数组 false：不是数组
*/
public static boolean isArray(Object object) {
return ArrayUtil.isArray(object);
}
/** /**
* 去空格 * 去空格
*/ */
@ -325,7 +205,7 @@ public class StringUtils extends org.apache.commons.lang3.StringUtils {
* @return 是否匹配 * @return 是否匹配
*/ */
public static boolean matches(String str, List<String> strs) { public static boolean matches(String str, List<String> strs) {
if (isEmpty(str) || isEmpty(strs)) { if (isEmpty(str) || CollUtil.isEmpty(strs)) {
return false; return false;
} }
for (String pattern : strs) { for (String pattern : strs) {
@ -355,4 +235,4 @@ public class StringUtils extends org.apache.commons.lang3.StringUtils {
public static <T> T cast(Object obj) { public static <T> T cast(Object obj) {
return (T) obj; return (T) obj;
} }
} }

29
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/utils/TreeBuildUtils.java Normal file
View File

@ -0,0 +1,29 @@
package com.ruoyi.common.core.utils;
import cn.hutool.core.lang.tree.Tree;
import cn.hutool.core.lang.tree.TreeNodeConfig;
import cn.hutool.core.lang.tree.TreeUtil;
import cn.hutool.core.lang.tree.parser.NodeParser;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import java.util.List;
/**
* 扩展 hutool TreeUtil 封装系统树构建
*
* @author Lion Li
*/
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class TreeBuildUtils extends TreeUtil {
/**
* 根据前端定制差异化字段
*/
public static final TreeNodeConfig DEFAULT_CONFIG = TreeNodeConfig.DEFAULT_CONFIG.setNameKey("label");
public static <T> List<Tree<Long>> build(List<T> list, Long parentId, NodeParser<T, Long> nodeParser) {
return TreeUtil.build(list, parentId, DEFAULT_CONFIG, nodeParser);
}
}

28
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/utils/ValidatorUtils.java Normal file
View File

@ -0,0 +1,28 @@
package com.ruoyi.common.core.utils;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import javax.validation.ConstraintViolation;
import javax.validation.ConstraintViolationException;
import javax.validation.Validator;
import java.util.Set;
/**
* Validator 校验框架工具
*
* @author Lion Li
*/
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class ValidatorUtils {
private static final Validator VALID = SpringUtils.getBean(Validator.class);
public static <T> void validate(T object, Class<?>... groups) {
Set<ConstraintViolation<T>> validate = VALID.validate(object, groups);
if (!validate.isEmpty()) {
throw new ConstraintViolationException("参数校验异常", validate);
}
}
}

104
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/utils/bean/BeanUtils.java
View File

@ -1,104 +0,0 @@
package com.ruoyi.common.core.utils.bean;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Bean 工具类
*
* @author ruoyi
*/
public class BeanUtils extends org.springframework.beans.BeanUtils {
/**
* Bean方法名中属性名开始的下标
*/
private static final int BEAN_METHOD_PROP_INDEX = 3;
/**
* 匹配getter方法的正则表达式
*/
private static final Pattern GET_PATTERN = Pattern.compile("get(\\p{javaUpperCase}\\w*)");
/**
* 匹配setter方法的正则表达式
*/
private static final Pattern SET_PATTERN = Pattern.compile("set(\\p{javaUpperCase}\\w*)");
/**
* Bean属性复制工具方法。
*
* @param dest 目标对象
* @param src 源对象
*/
public static void copyBeanProp(Object dest, Object src) {
try {
copyProperties(src, dest);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取对象的setter方法。
*
* @param obj 对象
* @return 对象的setter方法列表
*/
public static List<Method> getSetterMethods(Object obj) {
// setter方法列表
List<Method> setterMethods = new ArrayList<Method>();
// 获取所有方法
Method[] methods = obj.getClass().getMethods();
// 查找setter方法
for (Method method : methods) {
Matcher m = SET_PATTERN.matcher(method.getName());
if (m.matches() && (method.getParameterTypes().length == 1)) {
setterMethods.add(method);
}
}
// 返回setter方法列表
return setterMethods;
}
/**
* 获取对象的getter方法。
*
* @param obj 对象
* @return 对象的getter方法列表
*/
public static List<Method> getGetterMethods(Object obj) {
// getter方法列表
List<Method> getterMethods = new ArrayList<Method>();
// 获取所有方法
Method[] methods = obj.getClass().getMethods();
// 查找getter方法
for (Method method : methods) {
Matcher m = GET_PATTERN.matcher(method.getName());
if (m.matches() && (method.getParameterTypes().length == 0)) {
getterMethods.add(method);
}
}
// 返回getter方法列表
return getterMethods;
}
/**
* 检查Bean方法名中的属性名是否相等。<br>
* 如getName()和setName()属性名一样，getName()和setAge()属性名不一样。
*
* @param m1 方法名1
* @param m2 方法名2
* @return 属性名一样返回true，否则返回false
*/
public static boolean isMethodPropEquals(String m1, String m2) {
return m1.substring(BEAN_METHOD_PROP_INDEX).equals(m2.substring(BEAN_METHOD_PROP_INDEX));
}
}

21
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/utils/bean/BeanValidators.java
View File

@ -1,21 +0,0 @@
package com.ruoyi.common.core.utils.bean;
import javax.validation.ConstraintViolation;
import javax.validation.ConstraintViolationException;
import javax.validation.Validator;
import java.util.Set;
/**
* bean对象属性验证
*
* @author ruoyi
*/
public class BeanValidators {
public static void validateWithException(Validator validator, Object object, Class<?>... groups)
throws ConstraintViolationException {
Set<ConstraintViolation<Object>> constraintViolations = validator.validate(object, groups);
if (!constraintViolations.isEmpty()) {
throw new ConstraintViolationException(constraintViolations);
}
}
}

275
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/utils/file/FileUtils.java
View File

@ -1,221 +1,54 @@
package com.ruoyi.common.core.utils.file; package com.ruoyi.common.core.utils.file;
import com.ruoyi.common.core.utils.StringUtils; import cn.hutool.core.io.FileUtil;
import org.apache.commons.lang3.ArrayUtils; import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import java.io.*; import java.io.UnsupportedEncodingException;
import java.net.URLEncoder; import java.net.URLEncoder;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
/** /**
* 文件处理工具类 * 文件处理工具类
* *
* @author ruoyi * @author Lion Li
*/ */
public class FileUtils { @NoArgsConstructor(access = AccessLevel.PRIVATE)
/** public class FileUtils extends FileUtil {
* 字符常量：斜杠 {@code '/'}
*/ /**
public static final char SLASH = '/'; * 下载文件名重新编码
*
/** * @param response 响应对象
* 字符常量：反斜杠 {@code '\\'} * @param realFileName 真实文件名
*/ * @return
public static final char BACKSLASH = '\\'; */
public static void setAttachmentResponseHeader(HttpServletResponse response, String realFileName) throws UnsupportedEncodingException {
public static String FILENAME_PATTERN = "[a-zA-Z0-9_\\-\\|\\.\\u4e00-\\u9fa5]+"; String percentEncodedFileName = percentEncode(realFileName);
/** StringBuilder contentDispositionValue = new StringBuilder();
* 输出指定文件的byte数组 contentDispositionValue.append("attachment; filename=")
* .append(percentEncodedFileName)
* @param filePath 文件路径 .append(";")
* @param os 输出流 .append("filename*=")
* @return .append("utf-8''")
*/ .append(percentEncodedFileName);
public static void writeBytes(String filePath, OutputStream os) throws IOException {
FileInputStream fis = null; response.addHeader("Access-Control-Allow-Origin", "*");
try { response.addHeader("Access-Control-Expose-Headers", "Content-Disposition,download-filename");
File file = new File(filePath); response.setHeader("Content-disposition", contentDispositionValue.toString());
if (!file.exists()) { response.setHeader("download-filename", percentEncodedFileName);
throw new FileNotFoundException(filePath); }
}
fis = new FileInputStream(file); /**
byte[] b = new byte[1024]; * 百分号编码工具方法
int length; *
while ((length = fis.read(b)) > 0) { * @param s 需要百分号编码的字符串
os.write(b, 0, length); * @return 百分号编码后的字符串
} */
} catch (IOException e) { public static String percentEncode(String s) throws UnsupportedEncodingException {
throw e; String encode = URLEncoder.encode(s, StandardCharsets.UTF_8.toString());
} finally { return encode.replaceAll("\\+", "%20");
if (os != null) { }
try { }
os.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
if (fis != null) {
try {
fis.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
}
/**
* 删除文件
*
* @param filePath 文件
* @return
*/
public static boolean deleteFile(String filePath) {
boolean flag = false;
File file = new File(filePath);
// 路径为文件且不为空则进行删除
if (file.isFile() && file.exists()) {
file.delete();
flag = true;
}
return flag;
}
/**
* 文件名称验证
*
* @param filename 文件名称
* @return true 正常 false 非法
*/
public static boolean isValidFilename(String filename) {
return filename.matches(FILENAME_PATTERN);
}
/**
* 检查文件是否可下载
*
* @param resource 需要下载的文件
* @return true 正常 false 非法
*/
public static boolean checkAllowDownload(String resource) {
// 禁止目录上跳级别
if (StringUtils.contains(resource, "..")) {
return false;
}
// 检查允许下载的文件规则
if (ArrayUtils.contains(MimeTypeUtils.DEFAULT_ALLOWED_EXTENSION, FileTypeUtils.getFileType(resource))) {
return true;
}
// 不在允许下载的文件规则
return false;
}
/**
* 下载文件名重新编码
*
* @param request 请求对象
* @param fileName 文件名
* @return 编码后的文件名
*/
public static String setFileDownloadHeader(HttpServletRequest request, String fileName) throws UnsupportedEncodingException {
final String agent = request.getHeader("USER-AGENT");
String filename = fileName;
if (agent.contains("MSIE")) {
// IE浏览器
filename = URLEncoder.encode(filename, "utf-8");
filename = filename.replace("+", " ");
} else if (agent.contains("Firefox")) {
// 火狐浏览器
filename = new String(fileName.getBytes(), "ISO8859-1");
} else if (agent.contains("Chrome")) {
// google浏览器
filename = URLEncoder.encode(filename, "utf-8");
} else {
// 其它浏览器
filename = URLEncoder.encode(filename, "utf-8");
}
return filename;
}
/**
* 返回文件名
*
* @param filePath 文件
* @return 文件名
*/
public static String getName(String filePath) {
if (null == filePath) {
return null;
}
int len = filePath.length();
if (0 == len) {
return filePath;
}
if (isFileSeparator(filePath.charAt(len - 1))) {
// 以分隔符结尾的去掉结尾分隔符
len--;
}
int begin = 0;
char c;
for (int i = len - 1; i > -1; i--) {
c = filePath.charAt(i);
if (isFileSeparator(c)) {
// 查找最后一个路径分隔符（/或者\）
begin = i + 1;
break;
}
}
return filePath.substring(begin, len);
}
/**
* 是否为Windows或者Linux（Unix）文件分隔符<br>
* Windows平台下分隔符为\，Linux（Unix）为/
*
* @param c 字符
* @return 是否为Windows或者Linux（Unix）文件分隔符
*/
public static boolean isFileSeparator(char c) {
return SLASH == c || BACKSLASH == c;
}
/**
* 下载文件名重新编码
*
* @param response 响应对象
* @param realFileName 真实文件名
* @return
*/
public static void setAttachmentResponseHeader(HttpServletResponse response, String realFileName) throws UnsupportedEncodingException {
String percentEncodedFileName = percentEncode(realFileName);
StringBuilder contentDispositionValue = new StringBuilder();
contentDispositionValue.append("attachment; filename=")
.append(percentEncodedFileName)
.append(";")
.append("filename*=")
.append("utf-8''")
.append(percentEncodedFileName);
response.setHeader("Content-disposition", contentDispositionValue.toString());
response.setHeader("download-filename", percentEncodedFileName);
}
/**
* 百分号编码工具方法
*
* @param s 需要百分号编码的字符串
* @return 百分号编码后的字符串
*/
public static String percentEncode(String s) throws UnsupportedEncodingException {
String encode = URLEncoder.encode(s, StandardCharsets.UTF_8.toString());
return encode.replaceAll("\\+", "%20");
}
}

142
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/utils/file/ImageUtils.java
View File

@ -1,71 +1,71 @@
package com.ruoyi.common.core.utils.file; package com.ruoyi.common.core.utils.file;
import org.apache.poi.util.IOUtils; import org.apache.commons.io.IOUtils;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import java.io.ByteArrayInputStream; import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream; import java.io.ByteArrayOutputStream;
import java.io.InputStream; import java.io.InputStream;
import java.net.URL; import java.net.URL;
import java.net.URLConnection; import java.net.URLConnection;
import java.util.Arrays; import java.util.Arrays;
/** /**
* 图片处理工具类 * 图片处理工具类
* *
* @author ruoyi * @author ruoyi
*/ */
public class ImageUtils { public class ImageUtils {
private static final Logger log = LoggerFactory.getLogger(ImageUtils.class); private static final Logger log = LoggerFactory.getLogger(ImageUtils.class);
public static byte[] getImage(String imagePath) { public static byte[] getImage(String imagePath) {
InputStream is = getFile(imagePath); InputStream is = getFile(imagePath);
try { try {
return IOUtils.toByteArray(is); return IOUtils.toByteArray(is);
} catch (Exception e) { } catch (Exception e) {
log.error("图片加载异常 {}", e); log.error("图片加载异常 {}", e);
return null; return null;
} finally { } finally {
IOUtils.closeQuietly(is); IOUtils.closeQuietly(is);
} }
} }
public static InputStream getFile(String imagePath) { public static InputStream getFile(String imagePath) {
try { try {
byte[] result = readFile(imagePath); byte[] result = readFile(imagePath);
result = Arrays.copyOf(result, result.length); result = Arrays.copyOf(result, result.length);
return new ByteArrayInputStream(result); return new ByteArrayInputStream(result);
} catch (Exception e) { } catch (Exception e) {
log.error("获取图片异常 {}", e); log.error("获取图片异常 {}", e);
} }
return null; return null;
} }
/** /**
* 读取文件为字节数据 * 读取文件为字节数据
* *
* @param key 地址 * @param key 地址
* @return 字节数据 * @return 字节数据
*/ */
public static byte[] readFile(String url) { public static byte[] readFile(String url) {
InputStream in = null; InputStream in = null;
ByteArrayOutputStream baos = null; ByteArrayOutputStream baos = null;
try { try {
// 网络地址 // 网络地址
URL urlObj = new URL(url); URL urlObj = new URL(url);
URLConnection urlConnection = urlObj.openConnection(); URLConnection urlConnection = urlObj.openConnection();
urlConnection.setConnectTimeout(30 * 1000); urlConnection.setConnectTimeout(30 * 1000);
urlConnection.setReadTimeout(60 * 1000); urlConnection.setReadTimeout(60 * 1000);
urlConnection.setDoInput(true); urlConnection.setDoInput(true);
in = urlConnection.getInputStream(); in = urlConnection.getInputStream();
return IOUtils.toByteArray(in); return IOUtils.toByteArray(in);
} catch (Exception e) { } catch (Exception e) {
log.error("访问文件异常 {}", e); log.error("访问文件异常 {}", e);
return null; return null;
} finally { } finally {
IOUtils.closeQuietly(in); IOUtils.closeQuietly(in);
IOUtils.closeQuietly(baos); IOUtils.closeQuietly(baos);
} }
} }
} }

179
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/utils/ip/IpUtils.java
View File

@ -1,179 +0,0 @@
package com.ruoyi.common.core.utils.ip;
import com.ruoyi.common.core.utils.StringUtils;
import javax.servlet.http.HttpServletRequest;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
* 获取IP方法
*
* @author ruoyi
*/
public class IpUtils {
public static String getIpAddr(HttpServletRequest request) {
if (request == null) {
return null;
}
String ip = null;
// X-Forwarded-For：Squid 服务代理
String ipAddresses = request.getHeader("X-Forwarded-For");
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
// Proxy-Client-IP：apache 服务代理
ipAddresses = request.getHeader("Proxy-Client-IP");
}
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
// WL-Proxy-Client-IP：weblogic 服务代理
ipAddresses = request.getHeader("WL-Proxy-Client-IP");
}
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
// HTTP_CLIENT_IP：有些代理服务器
ipAddresses = request.getHeader("HTTP_CLIENT_IP");
}
if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
// X-Real-IP：nginx服务代理
ipAddresses = request.getHeader("X-Real-IP");
}
// 有些网络通过多层代理，那么获取到的ip就会有多个，一般都是通过逗号（,）分割开来，并且第一个ip为客户端的真实IP
if (ipAddresses != null && ipAddresses.length() != 0) {
ip = ipAddresses.split(",")[0];
}
// 还是不能获取到，最后再通过request.getRemoteAddr();获取
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
ip = request.getRemoteAddr();
}
return ip.equals("0:0:0:0:0:0:0:1") ? "127.0.0.1" : ip;
}
public static boolean internalIp(String ip) {
byte[] addr = textToNumericFormatV4(ip);
return internalIp(addr) || "127.0.0.1".equals(ip);
}
private static boolean internalIp(byte[] addr) {
if (StringUtils.isNull(addr) || addr.length < 2) {
return true;
}
final byte b0 = addr[0];
final byte b1 = addr[1];
// 10.x.x.x/8
final byte SECTION_1 = 0x0A;
// 172.16.x.x/12
final byte SECTION_2 = (byte) 0xAC;
final byte SECTION_3 = (byte) 0x10;
final byte SECTION_4 = (byte) 0x1F;
// 192.168.x.x/16
final byte SECTION_5 = (byte) 0xC0;
final byte SECTION_6 = (byte) 0xA8;
switch (b0) {
case SECTION_1:
return true;
case SECTION_2:
if (b1 >= SECTION_3 && b1 <= SECTION_4) {
return true;
}
case SECTION_5:
switch (b1) {
case SECTION_6:
return true;
}
default:
return false;
}
}
/**
* 将IPv4地址转换成字节
*
* @param text IPv4地址
* @return byte 字节
*/
public static byte[] textToNumericFormatV4(String text) {
if (text.length() == 0) {
return null;
}
byte[] bytes = new byte[4];
String[] elements = text.split("\\.", -1);
try {
long l;
int i;
switch (elements.length) {
case 1:
l = Long.parseLong(elements[0]);
if ((l < 0L) || (l > 4294967295L)) {
return null;
}
bytes[0] = (byte) (int) (l >> 24 & 0xFF);
bytes[1] = (byte) (int) ((l & 0xFFFFFF) >> 16 & 0xFF);
bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
bytes[3] = (byte) (int) (l & 0xFF);
break;
case 2:
l = Integer.parseInt(elements[0]);
if ((l < 0L) || (l > 255L)) {
return null;
}
bytes[0] = (byte) (int) (l & 0xFF);
l = Integer.parseInt(elements[1]);
if ((l < 0L) || (l > 16777215L)) {
return null;
}
bytes[1] = (byte) (int) (l >> 16 & 0xFF);
bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
bytes[3] = (byte) (int) (l & 0xFF);
break;
case 3:
for (i = 0; i < 2; ++i) {
l = Integer.parseInt(elements[i]);
if ((l < 0L) || (l > 255L)) {
return null;
}
bytes[i] = (byte) (int) (l & 0xFF);
}
l = Integer.parseInt(elements[2]);
if ((l < 0L) || (l > 65535L)) {
return null;
}
bytes[2] = (byte) (int) (l >> 8 & 0xFF);
bytes[3] = (byte) (int) (l & 0xFF);
break;
case 4:
for (i = 0; i < 4; ++i) {
l = Integer.parseInt(elements[i]);
if ((l < 0L) || (l > 255L)) {
return null;
}
bytes[i] = (byte) (int) (l & 0xFF);
}
break;
default:
return null;
}
} catch (NumberFormatException e) {
return null;
}
return bytes;
}
public static String getHostIp() {
try {
return InetAddress.getLocalHost().getHostAddress();
} catch (UnknownHostException e) {
}
return "127.0.0.1";
}
public static String getHostName() {
try {
return InetAddress.getLocalHost().getHostName();
} catch (UnknownHostException e) {
}
return "未知";
}
}

17
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/utils/poi/ExcelHandlerAdapter.java
View File

@ -1,17 +0,0 @@
package com.ruoyi.common.core.utils.poi;
/**
* Excel数据格式处理适配器
*
* @author ruoyi
*/
public interface ExcelHandlerAdapter {
/**
* 格式化
*
* @param value 单元格数据值
* @param args excel注解args参数组
* @return 处理后的值
*/
Object format(Object value, String[] args);
}

944
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/utils/poi/ExcelUtil.java
View File

@ -1,944 +0,0 @@
package com.ruoyi.common.core.utils.poi;
import cn.hutool.core.convert.Convert;
import com.ruoyi.common.core.annotation.Excel;
import com.ruoyi.common.core.annotation.Excel.ColumnType;
import com.ruoyi.common.core.annotation.Excel.Type;
import com.ruoyi.common.core.annotation.Excels;
import com.ruoyi.common.core.utils.DateUtils;
import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.core.utils.file.FileTypeUtils;
import com.ruoyi.common.core.utils.file.ImageUtils;
import com.ruoyi.common.core.utils.reflect.ReflectUtils;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.ss.util.CellRangeAddressList;
import org.apache.poi.util.IOUtils;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFClientAnchor;
import org.apache.poi.xssf.usermodel.XSSFDataValidation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.*;
import java.util.stream.Collectors;
/**
* Excel相关处理
*
* @author ruoyi
*/
public class ExcelUtil<T> {
private static final Logger log = LoggerFactory.getLogger(ExcelUtil.class);
/**
* Excel sheet最大行数，默认65536
*/
public static final int sheetSize = 65536;
/**
* 工作表名称
*/
private String sheetName;
/**
* 导出类型（EXPORT:导出数据；IMPORT：导入模板）
*/
private Type type;
/**
* 工作薄对象
*/
private Workbook wb;
/**
* 工作表对象
*/
private Sheet sheet;
/**
* 样式列表
*/
private Map<String, CellStyle> styles;
/**
* 导入导出数据列表
*/
private List<T> list;
/**
* 注解列表
*/
private List<Object[]> fields;
/**
* 当前行号
*/
private int rownum;
/**
* 标题
*/
private String title;
/**
* 最大高度
*/
private short maxHeight;
/**
* 统计列表
*/
private Map<Integer, Double> statistics = new HashMap<Integer, Double>();
/**
* 数字格式
*/
private static final DecimalFormat DOUBLE_FORMAT = new DecimalFormat("######0.00");
/**
* 实体对象
*/
public Class<T> clazz;
public ExcelUtil(Class<T> clazz) {
this.clazz = clazz;
}
public void init(List<T> list, String sheetName, String title, Type type) {
if (list == null) {
list = new ArrayList<T>();
}
this.list = list;
this.sheetName = sheetName;
this.type = type;
this.title = title;
createExcelField();
createWorkbook();
createTitle();
}
/**
* 创建excel第一行标题
*/
public void createTitle() {
if (StringUtils.isNotEmpty(title)) {
Row titleRow = sheet.createRow(rownum == 0 ? rownum++ : 0);
titleRow.setHeightInPoints(30);
Cell titleCell = titleRow.createCell(0);
titleCell.setCellStyle(styles.get("title"));
titleCell.setCellValue(title);
sheet.addMergedRegion(new CellRangeAddress(titleRow.getRowNum(), titleRow.getRowNum(), titleRow.getRowNum(),
this.fields.size() - 1));
}
}
/**
* 对excel表单默认第一个索引名转换成list
*
* @param is 输入流
* @return 转换后集合
*/
public List<T> importExcel(InputStream is) throws Exception {
return importExcel(is, 0);
}
/**
* 对excel表单默认第一个索引名转换成list
*
* @param is 输入流
* @param titleNum 标题占用行数
* @return 转换后集合
*/
public List<T> importExcel(InputStream is, int titleNum) throws Exception {
return importExcel(StringUtils.EMPTY, is, titleNum);
}
/**
* 对excel表单指定表格索引名转换成list
*
* @param sheetName 表格索引名
* @param titleNum 标题占用行数
* @param is 输入流
* @return 转换后集合
*/
public List<T> importExcel(String sheetName, InputStream is, int titleNum) throws Exception {
this.type = Type.IMPORT;
this.wb = WorkbookFactory.create(is);
List<T> list = new ArrayList<T>();
// 如果指定sheet名,则取指定sheet中的内容 否则默认指向第1个sheet
Sheet sheet = StringUtils.isNotEmpty(sheetName) ? wb.getSheet(sheetName) : wb.getSheetAt(0);
if (sheet == null) {
throw new IOException("文件sheet不存在");
}
// 获取最后一个非空行的行下标，比如总行数为n，则返回的为n-1
int rows = sheet.getLastRowNum();
if (rows > 0) {
// 定义一个map用于存放excel列的序号和field.
Map<String, Integer> cellMap = new HashMap<String, Integer>();
// 获取表头
Row heard = sheet.getRow(titleNum);
for (int i = 0; i < heard.getPhysicalNumberOfCells(); i++) {
Cell cell = heard.getCell(i);
if (StringUtils.isNotNull(cell)) {
String value = this.getCellValue(heard, i).toString();
cellMap.put(value, i);
} else {
cellMap.put(null, i);
}
}
// 有数据时才处理 得到类的所有field.
List<Object[]> fields = this.getFields();
Map<Integer, Object[]> fieldsMap = new HashMap<Integer, Object[]>();
for (Object[] objects : fields) {
Excel attr = (Excel) objects[1];
Integer column = cellMap.get(attr.name());
if (column != null) {
fieldsMap.put(column, objects);
}
}
for (int i = titleNum + 1; i <= rows; i++) {
// 从第2行开始取数据,默认第一行是表头.
Row row = sheet.getRow(i);
// 判断当前行是否是空行
if (isRowEmpty(row)) {
continue;
}
T entity = null;
for (Map.Entry<Integer, Object[]> entry : fieldsMap.entrySet()) {
Object val = this.getCellValue(row, entry.getKey());
// 如果不存在实例则新建.
entity = (entity == null ? clazz.newInstance() : entity);
// 从map中得到对应列的field.
Field field = (Field) entry.getValue()[0];
Excel attr = (Excel) entry.getValue()[1];
// 取得类型,并根据对象类型设置值.
Class<?> fieldType = field.getType();
if (String.class == fieldType) {
String s = Convert.toStr(val);
if (StringUtils.endsWith(s, ".0")) {
val = StringUtils.substringBefore(s, ".0");
} else {
String dateFormat = field.getAnnotation(Excel.class).dateFormat();
if (StringUtils.isNotEmpty(dateFormat)) {
val = DateUtils.parseDateToStr(dateFormat, (Date) val);
} else {
val = Convert.toStr(val);
}
}
} else if ((Integer.TYPE == fieldType || Integer.class == fieldType) && StringUtils.isNumeric(Convert.toStr(val))) {
val = Convert.toInt(val);
} else if (Long.TYPE == fieldType || Long.class == fieldType) {
val = Convert.toLong(val);
} else if (Double.TYPE == fieldType || Double.class == fieldType) {
val = Convert.toDouble(val);
} else if (Float.TYPE == fieldType || Float.class == fieldType) {
val = Convert.toFloat(val);
} else if (BigDecimal.class == fieldType) {
val = Convert.toBigDecimal(val);
} else if (Date.class == fieldType) {
if (val instanceof String) {
val = DateUtils.parseDate(val);
} else if (val instanceof Double) {
val = DateUtil.getJavaDate((Double) val);
}
} else if (Boolean.TYPE == fieldType || Boolean.class == fieldType) {
val = Convert.toBool(val, false);
}
if (StringUtils.isNotNull(fieldType)) {
String propertyName = field.getName();
if (StringUtils.isNotEmpty(attr.targetAttr())) {
propertyName = field.getName() + "." + attr.targetAttr();
} else if (StringUtils.isNotEmpty(attr.readConverterExp())) {
val = reverseByExp(Convert.toStr(val), attr.readConverterExp(), attr.separator());
} else if (!attr.handler().equals(ExcelHandlerAdapter.class)) {
val = dataFormatHandlerAdapter(val, attr);
}
ReflectUtils.invokeSetter(entity, propertyName, val);
}
}
list.add(entity);
}
}
return list;
}
/**
* 对list数据源将其里面的数据导入到excel表单
*
* @param response 返回数据
* @param list 导出数据集合
* @param sheetName 工作表的名称
* @return 结果
* @throws IOException
*/
public void exportExcel(HttpServletResponse response, List<T> list, String sheetName) {
exportExcel(response, list, sheetName, StringUtils.EMPTY);
}
/**
* 对list数据源将其里面的数据导入到excel表单
*
* @param response 返回数据
* @param list 导出数据集合
* @param sheetName 工作表的名称
* @param title 标题
* @return 结果
* @throws IOException
*/
public void exportExcel(HttpServletResponse response, List<T> list, String sheetName, String title) {
response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
response.setCharacterEncoding("utf-8");
this.init(list, sheetName, title, Type.EXPORT);
exportExcel(response);
}
/**
* 对list数据源将其里面的数据导入到excel表单
*
* @param sheetName 工作表的名称
* @return 结果
*/
/**
* 对list数据源将其里面的数据导入到excel表单
*
* @param sheetName 工作表的名称
* @return 结果
*/
public void importTemplateExcel(HttpServletResponse response, String sheetName) {
importTemplateExcel(response, sheetName, StringUtils.EMPTY);
}
/**
* 对list数据源将其里面的数据导入到excel表单
*
* @param sheetName 工作表的名称
* @param title 标题
* @return 结果
*/
public void importTemplateExcel(HttpServletResponse response, String sheetName, String title) {
response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
response.setCharacterEncoding("utf-8");
this.init(null, sheetName, title, Type.IMPORT);
exportExcel(response);
}
/**
* 对list数据源将其里面的数据导入到excel表单
*
* @return 结果
*/
public void exportExcel(HttpServletResponse response) {
try {
writeSheet();
wb.write(response.getOutputStream());
} catch (Exception e) {
log.error("导出Excel异常{}", e.getMessage());
} finally {
IOUtils.closeQuietly(wb);
}
}
/**
* 创建写入数据到Sheet
*/
public void writeSheet() {
// 取出一共有多少个sheet.
int sheetNo = Math.max(1, (int) Math.ceil(list.size() * 1.0 / sheetSize));
for (int index = 0; index < sheetNo; index++) {
createSheet(sheetNo, index);
// 产生一行
Row row = sheet.createRow(rownum);
int column = 0;
// 写入各个字段的列头名称
for (Object[] os : fields) {
Excel excel = (Excel) os[1];
this.createCell(excel, row, column++);
}
if (Type.EXPORT.equals(type)) {
fillExcelData(index, row);
addStatisticsRow();
}
}
}
/**
* 填充excel数据
*
* @param index 序号
* @param row 单元格行
*/
public void fillExcelData(int index, Row row) {
int startNo = index * sheetSize;
int endNo = Math.min(startNo + sheetSize, list.size());
for (int i = startNo; i < endNo; i++) {
row = sheet.createRow(i + 1 + rownum - startNo);
// 得到导出对象.
T vo = (T) list.get(i);
int column = 0;
for (Object[] os : fields) {
Field field = (Field) os[0];
Excel excel = (Excel) os[1];
this.addCell(excel, row, vo, field, column++);
}
}
}
/**
* 创建表格样式
*
* @param wb 工作薄对象
* @return 样式列表
*/
private Map<String, CellStyle> createStyles(Workbook wb) {
// 写入各条记录,每条记录对应excel表中的一行
Map<String, CellStyle> styles = new HashMap<String, CellStyle>();
CellStyle style = wb.createCellStyle();
style.setAlignment(HorizontalAlignment.CENTER);
style.setVerticalAlignment(VerticalAlignment.CENTER);
Font titleFont = wb.createFont();
titleFont.setFontName("Arial");
titleFont.setFontHeightInPoints((short) 16);
titleFont.setBold(true);
style.setFont(titleFont);
styles.put("title", style);
style = wb.createCellStyle();
style.setAlignment(HorizontalAlignment.CENTER);
style.setVerticalAlignment(VerticalAlignment.CENTER);
style.setBorderRight(BorderStyle.THIN);
style.setRightBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
style.setBorderLeft(BorderStyle.THIN);
style.setLeftBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
style.setBorderTop(BorderStyle.THIN);
style.setTopBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
style.setBorderBottom(BorderStyle.THIN);
style.setBottomBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
Font dataFont = wb.createFont();
dataFont.setFontName("Arial");
dataFont.setFontHeightInPoints((short) 10);
style.setFont(dataFont);
styles.put("data", style);
style = wb.createCellStyle();
style.cloneStyleFrom(styles.get("data"));
style.setAlignment(HorizontalAlignment.CENTER);
style.setVerticalAlignment(VerticalAlignment.CENTER);
style.setFillForegroundColor(IndexedColors.GREY_50_PERCENT.getIndex());
style.setFillPattern(FillPatternType.SOLID_FOREGROUND);
Font headerFont = wb.createFont();
headerFont.setFontName("Arial");
headerFont.setFontHeightInPoints((short) 10);
headerFont.setBold(true);
headerFont.setColor(IndexedColors.WHITE.getIndex());
style.setFont(headerFont);
styles.put("header", style);
style = wb.createCellStyle();
style.setAlignment(HorizontalAlignment.CENTER);
style.setVerticalAlignment(VerticalAlignment.CENTER);
Font totalFont = wb.createFont();
totalFont.setFontName("Arial");
totalFont.setFontHeightInPoints((short) 10);
style.setFont(totalFont);
styles.put("total", style);
style = wb.createCellStyle();
style.cloneStyleFrom(styles.get("data"));
style.setAlignment(HorizontalAlignment.LEFT);
styles.put("data1", style);
style = wb.createCellStyle();
style.cloneStyleFrom(styles.get("data"));
style.setAlignment(HorizontalAlignment.CENTER);
styles.put("data2", style);
style = wb.createCellStyle();
style.cloneStyleFrom(styles.get("data"));
style.setAlignment(HorizontalAlignment.RIGHT);
styles.put("data3", style);
return styles;
}
/**
* 创建单元格
*/
public Cell createCell(Excel attr, Row row, int column) {
// 创建列
Cell cell = row.createCell(column);
// 写入列信息
cell.setCellValue(attr.name());
setDataValidation(attr, row, column);
cell.setCellStyle(styles.get("header"));
return cell;
}
/**
* 设置单元格信息
*
* @param value 单元格值
* @param attr 注解相关
* @param cell 单元格信息
*/
public void setCellVo(Object value, Excel attr, Cell cell) {
if (ColumnType.STRING == attr.cellType()) {
cell.setCellValue(StringUtils.isNull(value) ? attr.defaultValue() : value + attr.suffix());
} else if (ColumnType.NUMERIC == attr.cellType()) {
if (StringUtils.isNotNull(value)) {
cell.setCellValue(StringUtils.contains(Convert.toStr(value), ".") ? Convert.toDouble(value) : Convert.toInt(value));
}
} else if (ColumnType.IMAGE == attr.cellType()) {
ClientAnchor anchor = new XSSFClientAnchor(0, 0, 0, 0, (short) cell.getColumnIndex(), cell.getRow().getRowNum(), (short) (cell.getColumnIndex() + 1), cell.getRow().getRowNum() + 1);
String imagePath = Convert.toStr(value);
if (StringUtils.isNotEmpty(imagePath)) {
byte[] data = ImageUtils.getImage(imagePath);
getDrawingPatriarch(cell.getSheet()).createPicture(anchor,
cell.getSheet().getWorkbook().addPicture(data, getImageType(data)));
}
}
}
/**
* 获取画布
*/
public static Drawing<?> getDrawingPatriarch(Sheet sheet) {
if (sheet.getDrawingPatriarch() == null) {
sheet.createDrawingPatriarch();
}
return sheet.getDrawingPatriarch();
}
/**
* 获取图片类型,设置图片插入类型
*/
public int getImageType(byte[] value) {
String type = FileTypeUtils.getFileExtendName(value);
if ("JPG".equalsIgnoreCase(type)) {
return Workbook.PICTURE_TYPE_JPEG;
} else if ("PNG".equalsIgnoreCase(type)) {
return Workbook.PICTURE_TYPE_PNG;
}
return Workbook.PICTURE_TYPE_JPEG;
}
/**
* 创建表格样式
*/
public void setDataValidation(Excel attr, Row row, int column) {
if (attr.name().indexOf("注：") >= 0) {
sheet.setColumnWidth(column, 6000);
} else {
// 设置列宽
sheet.setColumnWidth(column, (int) ((attr.width() + 0.72) * 256));
}
// 如果设置了提示信息则鼠标放上去提示.
if (StringUtils.isNotEmpty(attr.prompt())) {
// 这里默认设了2-101列提示.
setXSSFPrompt(sheet, "", attr.prompt(), 1, 100, column, column);
}
// 如果设置了combo属性则本列只能选择不能输入
if (attr.combo().length > 0) {
// 这里默认设了2-101列只能选择不能输入.
setXSSFValidation(sheet, attr.combo(), 1, 100, column, column);
}
}
/**
* 添加单元格
*/
public Cell addCell(Excel attr, Row row, T vo, Field field, int column) {
Cell cell = null;
try {
// 设置行高
row.setHeight(maxHeight);
// 根据Excel中设置情况决定是否导出,有些情况需要保持为空,希望用户填写这一列.
if (attr.isExport()) {
// 创建cell
cell = row.createCell(column);
int align = attr.align().value();
cell.setCellStyle(styles.get("data" + (align >= 1 && align <= 3 ? align : "")));
// 用于读取对象中的属性
Object value = getTargetValue(vo, field, attr);
String dateFormat = attr.dateFormat();
String readConverterExp = attr.readConverterExp();
String separator = attr.separator();
if (StringUtils.isNotEmpty(dateFormat) && StringUtils.isNotNull(value)) {
cell.setCellValue(DateUtils.parseDateToStr(dateFormat, (Date) value));
} else if (StringUtils.isNotEmpty(readConverterExp) && StringUtils.isNotNull(value)) {
cell.setCellValue(convertByExp(Convert.toStr(value), readConverterExp, separator));
} else if (value instanceof BigDecimal && -1 != attr.scale()) {
cell.setCellValue((((BigDecimal) value).setScale(attr.scale(), attr.roundingMode())).toString());
} else if (!attr.handler().equals(ExcelHandlerAdapter.class)) {
cell.setCellValue(dataFormatHandlerAdapter(value, attr));
} else {
// 设置列类型
setCellVo(value, attr, cell);
}
addStatisticsData(column, Convert.toStr(value), attr);
}
} catch (Exception e) {
log.error("导出Excel失败{}", e);
}
return cell;
}
/**
* 设置 POI XSSFSheet 单元格提示
*
* @param sheet 表单
* @param promptTitle 提示标题
* @param promptContent 提示内容
* @param firstRow 开始行
* @param endRow 结束行
* @param firstCol 开始列
* @param endCol 结束列
*/
public void setXSSFPrompt(Sheet sheet, String promptTitle, String promptContent, int firstRow, int endRow,
int firstCol, int endCol) {
DataValidationHelper helper = sheet.getDataValidationHelper();
DataValidationConstraint constraint = helper.createCustomConstraint("DD1");
CellRangeAddressList regions = new CellRangeAddressList(firstRow, endRow, firstCol, endCol);
DataValidation dataValidation = helper.createValidation(constraint, regions);
dataValidation.createPromptBox(promptTitle, promptContent);
dataValidation.setShowPromptBox(true);
sheet.addValidationData(dataValidation);
}
/**
* 设置某些列的值只能输入预制的数据,显示下拉框.
*
* @param sheet 要设置的sheet.
* @param textlist 下拉框显示的内容
* @param firstRow 开始行
* @param endRow 结束行
* @param firstCol 开始列
* @param endCol 结束列
* @return 设置好的sheet.
*/
public void setXSSFValidation(Sheet sheet, String[] textlist, int firstRow, int endRow, int firstCol, int endCol) {
DataValidationHelper helper = sheet.getDataValidationHelper();
// 加载下拉列表内容
DataValidationConstraint constraint = helper.createExplicitListConstraint(textlist);
// 设置数据有效性加载在哪个单元格上,四个参数分别是：起始行、终止行、起始列、终止列
CellRangeAddressList regions = new CellRangeAddressList(firstRow, endRow, firstCol, endCol);
// 数据有效性对象
DataValidation dataValidation = helper.createValidation(constraint, regions);
// 处理Excel兼容性问题
if (dataValidation instanceof XSSFDataValidation) {
dataValidation.setSuppressDropDownArrow(true);
dataValidation.setShowErrorBox(true);
} else {
dataValidation.setSuppressDropDownArrow(false);
}
sheet.addValidationData(dataValidation);
}
/**
* 解析导出值 0=男,1=女,2=未知
*
* @param propertyValue 参数值
* @param converterExp 翻译注解
* @param separator 分隔符
* @return 解析后值
*/
public static String convertByExp(String propertyValue, String converterExp, String separator) {
StringBuilder propertyString = new StringBuilder();
String[] convertSource = converterExp.split(",");
for (String item : convertSource) {
String[] itemArray = item.split("=");
if (StringUtils.containsAny(separator, propertyValue)) {
for (String value : propertyValue.split(separator)) {
if (itemArray[0].equals(value)) {
propertyString.append(itemArray[1] + separator);
break;
}
}
} else {
if (itemArray[0].equals(propertyValue)) {
return itemArray[1];
}
}
}
return StringUtils.stripEnd(propertyString.toString(), separator);
}
/**
* 反向解析值 男=0,女=1,未知=2
*
* @param propertyValue 参数值
* @param converterExp 翻译注解
* @param separator 分隔符
* @return 解析后值
*/
public static String reverseByExp(String propertyValue, String converterExp, String separator) {
StringBuilder propertyString = new StringBuilder();
String[] convertSource = converterExp.split(",");
for (String item : convertSource) {
String[] itemArray = item.split("=");
if (StringUtils.containsAny(separator, propertyValue)) {
for (String value : propertyValue.split(separator)) {
if (itemArray[1].equals(value)) {
propertyString.append(itemArray[0] + separator);
break;
}
}
} else {
if (itemArray[1].equals(propertyValue)) {
return itemArray[0];
}
}
}
return StringUtils.stripEnd(propertyString.toString(), separator);
}
/**
* 数据处理器
*
* @param value 数据值
* @param excel 数据注解
* @return
*/
public String dataFormatHandlerAdapter(Object value, Excel excel) {
try {
Object instance = excel.handler().newInstance();
Method formatMethod = excel.handler().getMethod("format", new Class[]{Object.class, String[].class});
value = formatMethod.invoke(instance, value, excel.args());
} catch (Exception e) {
log.error("不能格式化数据 " + excel.handler(), e.getMessage());
}
return Convert.toStr(value);
}
/**
* 合计统计信息
*/
private void addStatisticsData(Integer index, String text, Excel entity) {
if (entity != null && entity.isStatistics()) {
Double temp = 0D;
if (!statistics.containsKey(index)) {
statistics.put(index, temp);
}
try {
temp = Double.valueOf(text);
} catch (NumberFormatException e) {
}
statistics.put(index, statistics.get(index) + temp);
}
}
/**
* 创建统计行
*/
public void addStatisticsRow() {
if (statistics.size() > 0) {
Row row = sheet.createRow(sheet.getLastRowNum() + 1);
Set<Integer> keys = statistics.keySet();
Cell cell = row.createCell(0);
cell.setCellStyle(styles.get("total"));
cell.setCellValue("合计");
for (Integer key : keys) {
cell = row.createCell(key);
cell.setCellStyle(styles.get("total"));
cell.setCellValue(DOUBLE_FORMAT.format(statistics.get(key)));
}
statistics.clear();
}
}
/**
* 获取bean中的属性值
*
* @param vo 实体对象
* @param field 字段
* @param excel 注解
* @return 最终的属性值
* @throws Exception
*/
private Object getTargetValue(T vo, Field field, Excel excel) throws Exception {
Object o = field.get(vo);
if (StringUtils.isNotEmpty(excel.targetAttr())) {
String target = excel.targetAttr();
if (target.indexOf(".") > -1) {
String[] targets = target.split("[.]");
for (String name : targets) {
o = getValue(o, name);
}
} else {
o = getValue(o, target);
}
}
return o;
}
/**
* 以类的属性的get方法方法形式获取值
*
* @param o
* @param name
* @return value
* @throws Exception
*/
private Object getValue(Object o, String name) throws Exception {
if (StringUtils.isNotNull(o) && StringUtils.isNotEmpty(name)) {
Class<?> clazz = o.getClass();
Field field = clazz.getDeclaredField(name);
field.setAccessible(true);
o = field.get(o);
}
return o;
}
/**
* 得到所有定义字段
*/
private void createExcelField() {
this.fields = getFields();
this.fields = this.fields.stream().sorted(Comparator.comparing(objects -> ((Excel) objects[1]).sort())).collect(Collectors.toList());
this.maxHeight = getRowHeight();
}
/**
* 获取字段注解信息
*/
public List<Object[]> getFields() {
List<Object[]> fields = new ArrayList<Object[]>();
List<Field> tempFields = new ArrayList<>();
tempFields.addAll(Arrays.asList(clazz.getSuperclass().getDeclaredFields()));
tempFields.addAll(Arrays.asList(clazz.getDeclaredFields()));
for (Field field : tempFields) {
// 单注解
if (field.isAnnotationPresent(Excel.class)) {
Excel attr = field.getAnnotation(Excel.class);
if (attr != null && (attr.type() == Type.ALL || attr.type() == type)) {
field.setAccessible(true);
fields.add(new Object[]{field, attr});
}
}
// 多注解
if (field.isAnnotationPresent(Excels.class)) {
Excels attrs = field.getAnnotation(Excels.class);
Excel[] excels = attrs.value();
for (Excel attr : excels) {
if (attr != null && (attr.type() == Type.ALL || attr.type() == type)) {
field.setAccessible(true);
fields.add(new Object[]{field, attr});
}
}
}
}
return fields;
}
/**
* 根据注解获取最大行高
*/
public short getRowHeight() {
double maxHeight = 0;
for (Object[] os : this.fields) {
Excel excel = (Excel) os[1];
maxHeight = maxHeight > excel.height() ? maxHeight : excel.height();
}
return (short) (maxHeight * 20);
}
/**
* 创建一个工作簿
*/
public void createWorkbook() {
this.wb = new SXSSFWorkbook(500);
this.sheet = wb.createSheet();
wb.setSheetName(0, sheetName);
this.styles = createStyles(wb);
}
/**
* 创建工作表
*
* @param sheetNo sheet数量
* @param index 序号
*/
public void createSheet(int sheetNo, int index) {
// 设置工作表的名称.
if (sheetNo > 1 && index > 0) {
this.sheet = wb.createSheet();
this.createTitle();
wb.setSheetName(index, sheetName + index);
}
}
/**
* 获取单元格值
*
* @param row 获取的行
* @param column 获取单元格列号
* @return 单元格值
*/
public Object getCellValue(Row row, int column) {
if (row == null) {
return row;
}
Object val = "";
try {
Cell cell = row.getCell(column);
if (StringUtils.isNotNull(cell)) {
if (cell.getCellType() == CellType.NUMERIC || cell.getCellType() == CellType.FORMULA) {
val = cell.getNumericCellValue();
if (DateUtil.isCellDateFormatted(cell)) {
val = DateUtil.getJavaDate((Double) val); // POI Excel 日期格式转换
} else {
if ((Double) val % 1 != 0) {
val = new BigDecimal(val.toString());
} else {
val = new DecimalFormat("0").format(val);
}
}
} else if (cell.getCellType() == CellType.STRING) {
val = cell.getStringCellValue();
} else if (cell.getCellType() == CellType.BOOLEAN) {
val = cell.getBooleanCellValue();
} else if (cell.getCellType() == CellType.ERROR) {
val = cell.getErrorCellValue();
}
}
} catch (Exception e) {
return val;
}
return val;
}
/**
* 判断是否是空行
*
* @param row 判断的行
* @return
*/
private boolean isRowEmpty(Row row) {
if (row == null) {
return true;
}
for (int i = row.getFirstCellNum(); i < row.getLastCellNum(); i++) {
Cell cell = row.getCell(i);
if (cell != null && cell.getCellType() != CellType.BLANK) {
return false;
}
}
return true;
}
}

110
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/utils/sql/SqlUtil.java
View File

@ -1,53 +1,57 @@
package com.ruoyi.common.core.utils.sql; package com.ruoyi.common.core.utils.sql;
import com.ruoyi.common.core.exception.UtilException; import com.ruoyi.common.core.exception.UtilException;
import com.ruoyi.common.core.utils.StringUtils; import com.ruoyi.common.core.utils.StringUtils;
import lombok.AccessLevel;
/** import lombok.NoArgsConstructor;
* sql操作工具类
* /**
* @author ruoyi * sql操作工具类
*/ *
public class SqlUtil { * @author ruoyi
/** */
* 定义常用的 sql关键字 @NoArgsConstructor(access = AccessLevel.PRIVATE)
*/ public class SqlUtil {
public static String SQL_REGEX = "select |insert |delete |update |drop |count |exec |chr |mid |master |truncate |char |and |declare ";
/**
/** * 定义常用的 sql关键字
* 仅支持字母、数字、下划线、空格、逗号、小数点（支持多个字段排序） */
*/ public static final String SQL_REGEX = "select |insert |delete |update |drop |count |exec |chr |mid |master |truncate |char |and |declare ";
public static String SQL_PATTERN = "[a-zA-Z0-9_\\ \\,\\.]+";
/**
/** * 仅支持字母、数字、下划线、空格、逗号、小数点（支持多个字段排序）
* 检查字符，防止注入绕过 */
*/ public static final String SQL_PATTERN = "[a-zA-Z0-9_\\ \\,\\.]+";
public static String escapeOrderBySql(String value) {
if (StringUtils.isNotEmpty(value) && !isValidOrderBySql(value)) { /**
throw new UtilException("参数不符合规范，不能进行查询"); * 检查字符，防止注入绕过
} */
return value; public static String escapeOrderBySql(String value) {
} if (StringUtils.isNotEmpty(value) && !isValidOrderBySql(value)) {
throw new UtilException("参数不符合规范，不能进行查询");
/** }
* 验证 order by 语法是否符合规范 return value;
*/ }
public static boolean isValidOrderBySql(String value) {
return value.matches(SQL_PATTERN); /**
} * 验证 order by 语法是否符合规范
*/
/** public static boolean isValidOrderBySql(String value) {
* SQL关键字检查 return value.matches(SQL_PATTERN);
*/ }
public static void filterKeyword(String value) {
if (StringUtils.isEmpty(value)) { /**
return; * SQL关键字检查
} */
String[] sqlKeywords = StringUtils.split(SQL_REGEX, "\\|"); public static void filterKeyword(String value) {
for (int i = 0; i < sqlKeywords.length; i++) { if (StringUtils.isEmpty(value)) {
if (StringUtils.indexOfIgnoreCase(value, sqlKeywords[i]) > -1) { return;
throw new UtilException("参数存在SQL注入风险"); }
} String[] sqlKeywords = StringUtils.split(SQL_REGEX, "\\|");
} for (String sqlKeyword : sqlKeywords) {
} if (StringUtils.indexOfIgnoreCase(value, sqlKeyword) > -1) {
} throw new UtilException("参数存在SQL注入风险");
}
}
}
}

311
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/web/domain/AjaxResult.java
View File

@ -1,155 +1,156 @@
package com.ruoyi.common.core.web.domain; package com.ruoyi.common.core.web.domain;
import com.ruoyi.common.core.constant.HttpStatus; import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.utils.StringUtils; import com.ruoyi.common.core.constant.HttpStatus;
import com.ruoyi.common.core.utils.StringUtils;
import java.util.HashMap;
import java.util.HashMap;
/**
* 操作消息提醒 /**
* * 操作消息提醒
* @author ruoyi *
*/ * @author ruoyi
public class AjaxResult extends HashMap<String, Object> { */
private static final long serialVersionUID = 1L; public class AjaxResult extends HashMap<String, Object> {
private static final long serialVersionUID = 1L;
/**
* 状态码 /**
*/ * 状态码
public static final String CODE_TAG = "code"; */
public static final String CODE_TAG = "code";
/**
* 返回内容 /**
*/ * 返回内容
public static final String MSG_TAG = "msg"; */
public static final String MSG_TAG = "msg";
/**
* 数据对象 /**
*/ * 数据对象
public static final String DATA_TAG = "data"; */
public static final String DATA_TAG = "data";
/**
* 初始化一个新创建的 AjaxResult 对象，使其表示一个空消息。 /**
*/ * 初始化一个新创建的 AjaxResult 对象，使其表示一个空消息。
public AjaxResult() { */
} public AjaxResult() {
}
/**
* 初始化一个新创建的 AjaxResult 对象 /**
* * 初始化一个新创建的 AjaxResult 对象
* @param code 状态码 *
* @param msg 返回内容 * @param code 状态码
*/ * @param msg 返回内容
public AjaxResult(int code, String msg) { */
super.put(CODE_TAG, code); public AjaxResult(int code, String msg) {
super.put(MSG_TAG, msg); super.put(CODE_TAG, code);
} super.put(MSG_TAG, msg);
}
/**
* 初始化一个新创建的 AjaxResult 对象 /**
* * 初始化一个新创建的 AjaxResult 对象
* @param code 状态码 *
* @param msg 返回内容 * @param code 状态码
* @param data 数据对象 * @param msg 返回内容
*/ * @param data 数据对象
public AjaxResult(int code, String msg, Object data) { */
super.put(CODE_TAG, code); public AjaxResult(int code, String msg, Object data) {
super.put(MSG_TAG, msg); super.put(CODE_TAG, code);
if (StringUtils.isNotNull(data)) { super.put(MSG_TAG, msg);
super.put(DATA_TAG, data); if (ObjectUtil.isNotNull(data)) {
} super.put(DATA_TAG, data);
} }
}
/**
* 方便链式调用 /**
* * 方便链式调用
* @param key *
* @param value * @param key
* @return * @param value
*/ * @return
@Override */
public AjaxResult put(String key, Object value) { @Override
super.put(key, value); public AjaxResult put(String key, Object value) {
return this; super.put(key, value);
} return this;
}
/**
* 返回成功消息 /**
* * 返回成功消息
* @return 成功消息 *
*/ * @return 成功消息
public static AjaxResult success() { */
return AjaxResult.success("操作成功"); public static AjaxResult success() {
} return AjaxResult.success("操作成功");
}
/**
* 返回成功数据 /**
* * 返回成功数据
* @return 成功消息 *
*/ * @return 成功消息
public static AjaxResult success(Object data) { */
return AjaxResult.success("操作成功", data); public static AjaxResult success(Object data) {
} return AjaxResult.success("操作成功", data);
}
/**
* 返回成功消息 /**
* * 返回成功消息
* @param msg 返回内容 *
* @return 成功消息 * @param msg 返回内容
*/ * @return 成功消息
public static AjaxResult success(String msg) { */
return AjaxResult.success(msg, null); public static AjaxResult success(String msg) {
} return AjaxResult.success(msg, null);
}
/**
* 返回成功消息 /**
* * 返回成功消息
* @param msg 返回内容 *
* @param data 数据对象 * @param msg 返回内容
* @return 成功消息 * @param data 数据对象
*/ * @return 成功消息
public static AjaxResult success(String msg, Object data) { */
return new AjaxResult(HttpStatus.SUCCESS, msg, data); public static AjaxResult success(String msg, Object data) {
} return new AjaxResult(HttpStatus.SUCCESS, msg, data);
}
/**
* 返回错误消息 /**
* * 返回错误消息
* @return *
*/ * @return
public static AjaxResult error() { */
return AjaxResult.error("操作失败"); public static AjaxResult error() {
} return AjaxResult.error("操作失败");
}
/**
* 返回错误消息 /**
* * 返回错误消息
* @param msg 返回内容 *
* @return 警告消息 * @param msg 返回内容
*/ * @return 警告消息
public static AjaxResult error(String msg) { */
return AjaxResult.error(msg, null); public static AjaxResult error(String msg) {
} return AjaxResult.error(msg, null);
}
/**
* 返回错误消息 /**
* * 返回错误消息
* @param msg 返回内容 *
* @param data 数据对象 * @param msg 返回内容
* @return 警告消息 * @param data 数据对象
*/ * @return 警告消息
public static AjaxResult error(String msg, Object data) { */
return new AjaxResult(HttpStatus.ERROR, msg, data); public static AjaxResult error(String msg, Object data) {
} return new AjaxResult(HttpStatus.ERROR, msg, data);
}
/**
* 返回错误消息 /**
* * 返回错误消息
* @param code 状态码 *
* @param msg 返回内容 * @param code 状态码
* @return 警告消息 * @param msg 返回内容
*/ * @return 警告消息
public static AjaxResult error(int code, String msg) { */
return new AjaxResult(code, msg, null); public static AjaxResult error(int code, String msg) {
} return new AjaxResult(code, msg, null);
} }
}

121
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/web/domain/BaseEntity.java
View File

@ -1,61 +1,60 @@
package com.ruoyi.common.core.web.domain; package com.ruoyi.common.core.web.domain;
import lombok.Data; import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable; import lombok.experimental.Accessors;
import java.util.Date;
import java.util.HashMap; import java.io.Serializable;
import java.util.Map; import java.util.Date;
import java.util.HashMap;
/** import java.util.Map;
* Entity基类
* /**
* @author ruoyi * Entity基类
*/ *
@Data * @author Lion Li
public class BaseEntity implements Serializable { */
private static final long serialVersionUID = 1L;
@Data
/** @Accessors(chain = true)
* 搜索值 public class BaseEntity implements Serializable {
*/
private String searchValue; private static final long serialVersionUID = 1L;
/** /**
* 创建者 * 搜索值
*/ */
private String createBy; @ApiModelProperty(value = "搜索值")
private String searchValue;
/**
* 创建时间 /**
*/ * 创建者
private Date createTime; */
@ApiModelProperty(value = "创建者")
/** private String createBy;
* 更新者
*/ /**
private String updateBy; * 创建时间
*/
/** @ApiModelProperty(value = "创建时间")
* 更新时间 private Date createTime;
*/
private Date updateTime; /**
* 更新者
/** */
* 备注 @ApiModelProperty(value = "更新者")
*/ private String updateBy;
private String remark;
/**
/** * 更新时间
* 请求参数 */
*/ @ApiModelProperty(value = "更新时间")
private Map<String, Object> params; private Date updateTime;
public Map<String, Object> getParams() { /**
if (params == null) { * 请求参数
params = new HashMap<>(); */
} @ApiModelProperty(value = "请求参数")
return params; private Map<String, Object> params = new HashMap<>();
}
}
}

86
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/web/domain/TreeEntity.java
View File

@ -1,44 +1,42 @@
package com.ruoyi.common.core.web.domain; package com.ruoyi.common.core.web.domain;
import lombok.Data; import io.swagger.annotations.ApiModelProperty;
import lombok.EqualsAndHashCode; import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.ArrayList; import lombok.experimental.Accessors;
import java.util.List;
import java.util.ArrayList;
/** import java.util.List;
* Tree基类
* /**
* @author ruoyi * Tree基类
*/ *
@Data * @author Lion Li
@EqualsAndHashCode(callSuper = true) */
public class TreeEntity extends BaseEntity {
private static final long serialVersionUID = 1L; @Data
@EqualsAndHashCode(callSuper = true)
/** @Accessors(chain = true)
* 父菜单名称 public class TreeEntity extends BaseEntity {
*/
private String parentName; private static final long serialVersionUID = 1L;
/** /**
* 父菜单ID * 父菜单名称
*/ */
private Long parentId; @ApiModelProperty(value = "父菜单名称")
private String parentName;
/**
* 显示顺序 /**
*/ * 父菜单ID
private Integer orderNum; */
@ApiModelProperty(value = "父菜单ID")
/** private Long parentId;
* 祖级列表
*/ /**
private String ancestors; * 子部门
*/
/** @ApiModelProperty(value = "子部门")
* 子部门 private List<?> children = new ArrayList<>();
*/
private List<?> children = new ArrayList<>(); }
}

129
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/web/page/PageDomain.java
View File

@ -1,64 +1,65 @@
package com.ruoyi.common.core.web.page; package com.ruoyi.common.core.web.page;
import com.ruoyi.common.core.utils.StringUtils; import cn.hutool.core.util.ObjectUtil;
import lombok.Data; import com.ruoyi.common.core.utils.StringUtils;
import lombok.Data;
/**
* 分页数据 /**
* * 分页数据
* @author ruoyi *
*/ * @author ruoyi
@Data */
public class PageDomain { @Data
/** public class PageDomain {
* 当前记录起始索引 /**
*/ * 当前记录起始索引
private Integer pageNum; */
private Integer pageNum;
/**
* 每页显示记录数 /**
*/ * 每页显示记录数
private Integer pageSize; */
private Integer pageSize;
/**
* 排序列 /**
*/ * 排序列
private String orderByColumn; */
private String orderByColumn;
/**
* 排序的方向desc或者asc /**
*/ * 排序的方向desc或者asc
private String isAsc = "asc"; */
private String isAsc = "asc";
/**
* 分页参数合理化 /**
*/ * 分页参数合理化
private Boolean reasonable = true; */
private Boolean reasonable = true;
public String getOrderBy() {
if (StringUtils.isEmpty(orderByColumn)) { public String getOrderBy() {
return ""; if (StringUtils.isEmpty(orderByColumn)) {
} return "";
return StringUtils.toUnderScoreCase(orderByColumn) + " " + isAsc; }
} return StringUtils.toUnderScoreCase(orderByColumn) + " " + isAsc;
}
public void setIsAsc(String isAsc) {
if (StringUtils.isNotEmpty(isAsc)) { public void setIsAsc(String isAsc) {
// 兼容前端排序类型 if (StringUtils.isNotEmpty(isAsc)) {
if ("ascending".equals(isAsc)) { // 兼容前端排序类型
isAsc = "asc"; if ("ascending".equals(isAsc)) {
} else if ("descending".equals(isAsc)) { isAsc = "asc";
isAsc = "desc"; } else if ("descending".equals(isAsc)) {
} isAsc = "desc";
this.isAsc = isAsc; }
} this.isAsc = isAsc;
} }
}
public Boolean getReasonable() {
if (StringUtils.isNull(reasonable)) { public Boolean getReasonable() {
return Boolean.TRUE; if (ObjectUtil.isNull(reasonable)) {
} return Boolean.TRUE;
return reasonable; }
} return reasonable;
}
}
}

11
ruoyi-common/ruoyi-common-core/src/main/resources/META-INF/spring.factories
View File

@ -1,5 +1,6 @@
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.ruoyi.common.core.utils.SpringUtils,\ com.ruoyi.common.core.utils.SpringUtils,\
com.ruoyi.common.core.config.JacksonConfig com.ruoyi.common.core.config.JacksonConfig,\
com.ruoyi.common.core.config.ValidatorConfig

255
ruoyi-common/ruoyi-common-datascope/src/main/java/com/ruoyi/common/datascope/aspect/DataScopeAspect.java
View File

@ -1,127 +1,128 @@
package com.ruoyi.common.datascope.aspect; package com.ruoyi.common.datascope.aspect;
import com.ruoyi.common.core.utils.StringUtils; import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.web.domain.BaseEntity; import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.datascope.annotation.DataScope; import com.ruoyi.common.core.web.domain.BaseEntity;
import com.ruoyi.common.security.utils.SecurityUtils; import com.ruoyi.common.datascope.annotation.DataScope;
import com.ruoyi.system.api.domain.SysRole; import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.system.api.domain.SysUser; import com.ruoyi.system.api.domain.SysRole;
import com.ruoyi.system.api.model.LoginUser; import com.ruoyi.system.api.domain.SysUser;
import org.aspectj.lang.JoinPoint; import com.ruoyi.system.api.model.LoginUser;
import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Before; import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component; import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
/**
* 数据过滤处理 /**
* * 数据过滤处理
* @author ruoyi *
*/ * @author ruoyi
@Aspect */
@Component @Aspect
public class DataScopeAspect { @Component
/** public class DataScopeAspect {
* 全部数据权限 /**
*/ * 全部数据权限
public static final String DATA_SCOPE_ALL = "1"; */
public static final String DATA_SCOPE_ALL = "1";
/**
* 自定数据权限 /**
*/ * 自定数据权限
public static final String DATA_SCOPE_CUSTOM = "2"; */
public static final String DATA_SCOPE_CUSTOM = "2";
/**
* 部门数据权限 /**
*/ * 部门数据权限
public static final String DATA_SCOPE_DEPT = "3"; */
public static final String DATA_SCOPE_DEPT = "3";
/**
* 部门及以下数据权限 /**
*/ * 部门及以下数据权限
public static final String DATA_SCOPE_DEPT_AND_CHILD = "4"; */
public static final String DATA_SCOPE_DEPT_AND_CHILD = "4";
/**
* 仅本人数据权限 /**
*/ * 仅本人数据权限
public static final String DATA_SCOPE_SELF = "5"; */
public static final String DATA_SCOPE_SELF = "5";
/**
* 数据权限过滤关键字 /**
*/ * 数据权限过滤关键字
public static final String DATA_SCOPE = "dataScope"; */
public static final String DATA_SCOPE = "dataScope";
@Before("@annotation(controllerDataScope)")
public void doBefore(JoinPoint point, DataScope controllerDataScope) throws Throwable { @Before("@annotation(controllerDataScope)")
clearDataScope(point); public void doBefore(JoinPoint point, DataScope controllerDataScope) throws Throwable {
handleDataScope(point, controllerDataScope); clearDataScope(point);
} handleDataScope(point, controllerDataScope);
}
protected void handleDataScope(final JoinPoint joinPoint, DataScope controllerDataScope) {
// 获取当前的用户 protected void handleDataScope(final JoinPoint joinPoint, DataScope controllerDataScope) {
LoginUser loginUser = SecurityUtils.getLoginUser(); // 获取当前的用户
if (StringUtils.isNotNull(loginUser)) { LoginUser loginUser = SecurityUtils.getLoginUser();
SysUser currentUser = loginUser.getSysUser(); if (ObjectUtil.isNotNull(loginUser)) {
// 如果是超级管理员，则不过滤数据 SysUser currentUser = loginUser.getSysUser();
if (StringUtils.isNotNull(currentUser) && !currentUser.isAdmin()) { // 如果是超级管理员，则不过滤数据
dataScopeFilter(joinPoint, currentUser, controllerDataScope.deptAlias(), if (ObjectUtil.isNotNull(currentUser) && !currentUser.isAdmin()) {
controllerDataScope.userAlias()); dataScopeFilter(joinPoint, currentUser, controllerDataScope.deptAlias(),
} controllerDataScope.userAlias());
} }
} }
}
/**
* 数据范围过滤 /**
* * 数据范围过滤
* @param joinPoint 切点 *
* @param user 用户 * @param joinPoint 切点
* @param deptAlias 部门别名 * @param user 用户
* @param userAlias 用户别名 * @param deptAlias 部门别名
*/ * @param userAlias 用户别名
public static void dataScopeFilter(JoinPoint joinPoint, SysUser user, String deptAlias, String userAlias) { */
StringBuilder sqlString = new StringBuilder(); public static void dataScopeFilter(JoinPoint joinPoint, SysUser user, String deptAlias, String userAlias) {
StringBuilder sqlString = new StringBuilder();
for (SysRole role : user.getRoles()) {
String dataScope = role.getDataScope(); for (SysRole role : user.getRoles()) {
if (DATA_SCOPE_ALL.equals(dataScope)) { String dataScope = role.getDataScope();
sqlString = new StringBuilder(); if (DATA_SCOPE_ALL.equals(dataScope)) {
break; sqlString = new StringBuilder();
} else if (DATA_SCOPE_CUSTOM.equals(dataScope)) { break;
sqlString.append(StringUtils.format( } else if (DATA_SCOPE_CUSTOM.equals(dataScope)) {
" OR {}.dept_id IN ( SELECT dept_id FROM sys_role_dept WHERE role_id = {} ) ", deptAlias, sqlString.append(StringUtils.format(
role.getRoleId())); " OR {}.dept_id IN ( SELECT dept_id FROM sys_role_dept WHERE role_id = {} ) ", deptAlias,
} else if (DATA_SCOPE_DEPT.equals(dataScope)) { role.getRoleId()));
sqlString.append(StringUtils.format(" OR {}.dept_id = {} ", deptAlias, user.getDeptId())); } else if (DATA_SCOPE_DEPT.equals(dataScope)) {
} else if (DATA_SCOPE_DEPT_AND_CHILD.equals(dataScope)) { sqlString.append(StringUtils.format(" OR {}.dept_id = {} ", deptAlias, user.getDeptId()));
sqlString.append(StringUtils.format( } else if (DATA_SCOPE_DEPT_AND_CHILD.equals(dataScope)) {
" OR {}.dept_id IN ( SELECT dept_id FROM sys_dept WHERE dept_id = {} or find_in_set( {} , ancestors ) )", sqlString.append(StringUtils.format(
deptAlias, user.getDeptId(), user.getDeptId())); " OR {}.dept_id IN ( SELECT dept_id FROM sys_dept WHERE dept_id = {} or find_in_set( {} , ancestors ) )",
} else if (DATA_SCOPE_SELF.equals(dataScope)) { deptAlias, user.getDeptId(), user.getDeptId()));
if (StringUtils.isNotBlank(userAlias)) { } else if (DATA_SCOPE_SELF.equals(dataScope)) {
sqlString.append(StringUtils.format(" OR {}.user_id = {} ", userAlias, user.getUserId())); if (StringUtils.isNotBlank(userAlias)) {
} else { sqlString.append(StringUtils.format(" OR {}.user_id = {} ", userAlias, user.getUserId()));
// 数据权限为仅本人且没有userAlias别名不查询任何数据 } else {
sqlString.append(" OR 1=0 "); // 数据权限为仅本人且没有userAlias别名不查询任何数据
} sqlString.append(" OR 1=0 ");
} }
} }
}
if (StringUtils.isNotBlank(sqlString.toString())) {
Object params = joinPoint.getArgs()[0]; if (StringUtils.isNotBlank(sqlString.toString())) {
if (StringUtils.isNotNull(params) && params instanceof BaseEntity) { Object params = joinPoint.getArgs()[0];
BaseEntity baseEntity = (BaseEntity) params; if (ObjectUtil.isNotNull(params) && params instanceof BaseEntity) {
baseEntity.getParams().put(DATA_SCOPE, " AND (" + sqlString.substring(4) + ")"); BaseEntity baseEntity = (BaseEntity) params;
} baseEntity.getParams().put(DATA_SCOPE, " AND (" + sqlString.substring(4) + ")");
} }
} }
}
/**
* 拼接权限sql前先清空params.dataScope参数防止注入 /**
*/ * 拼接权限sql前先清空params.dataScope参数防止注入
private void clearDataScope(final JoinPoint joinPoint) { */
Object params = joinPoint.getArgs()[0]; private void clearDataScope(final JoinPoint joinPoint) {
if (StringUtils.isNotNull(params) && params instanceof BaseEntity) { Object params = joinPoint.getArgs()[0];
BaseEntity baseEntity = (BaseEntity) params; if (ObjectUtil.isNotNull(params) && params instanceof BaseEntity) {
baseEntity.getParams().put(DATA_SCOPE, ""); BaseEntity baseEntity = (BaseEntity) params;
} baseEntity.getParams().put(DATA_SCOPE, "");
} }
} }
}

8
ruoyi-common/ruoyi-common-dict/pom.xml
View File

@ -8,15 +8,15 @@
<version>0.3.0</version> <version>0.3.0</version>
</parent> </parent>
<modelVersion>4.0.0</modelVersion> <modelVersion>4.0.0</modelVersion>
<artifactId>ruoyi-common-dict</artifactId> <artifactId>ruoyi-common-dict</artifactId>
<description> <description>
ruoyi-common-dict 字典 ruoyi-common-dict 字典
</description> </description>
<dependencies> <dependencies>
<!-- RuoYi Common Security --> <!-- RuoYi Common Security -->
<dependency> <dependency>
<groupId>com.ruoyi</groupId> <groupId>com.ruoyi</groupId>
@ -35,4 +35,4 @@
</dependency> </dependency>
</dependencies> </dependencies>
</project> </project>

2
ruoyi-common/ruoyi-common-dict/src/main/java/com/ruoyi/common/dict/service/impl/DictServiceImpl.java
View File

@ -1,6 +1,6 @@
package com.ruoyi.common.dict.service.impl; package com.ruoyi.common.dict.service.impl;
import com.ruoyi.common.dict.service.DictService; import com.ruoyi.common.core.service.DictService;
import com.ruoyi.system.api.RemoteDictService; import com.ruoyi.system.api.RemoteDictService;
import org.apache.dubbo.config.annotation.DubboReference; import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;

4
ruoyi-common/ruoyi-common-dict/src/main/java/com/ruoyi/common/dict/utils/DictUtils.java
View File

@ -1,7 +1,7 @@
package com.ruoyi.common.dict.utils; package com.ruoyi.common.dict.utils;
import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.constant.Constants; import com.ruoyi.common.core.constant.Constants;
import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.redis.utils.RedisUtils; import com.ruoyi.common.redis.utils.RedisUtils;
import com.ruoyi.system.api.domain.SysDictData; import com.ruoyi.system.api.domain.SysDictData;
@ -32,7 +32,7 @@ public class DictUtils {
*/ */
public static List<SysDictData> getDictCache(String key) { public static List<SysDictData> getDictCache(String key) {
List<SysDictData> dictDatas = RedisUtils.getCacheObject(getCacheKey(key)); List<SysDictData> dictDatas = RedisUtils.getCacheObject(getCacheKey(key));
if (StringUtils.isNotNull(dictDatas)) { if (ObjectUtil.isNotNull(dictDatas)) {
return dictDatas; return dictDatas;
} }
return null; return null;

38
ruoyi-common/ruoyi-common-excel/pom.xml Normal file
View File

@ -0,0 +1,38 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<groupId>com.ruoyi</groupId>
<artifactId>ruoyi-common</artifactId>
<version>0.3.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>ruoyi-common-excel</artifactId>
<description>
ruoyi-common-excel
</description>
<dependencies>
<dependency>
<groupId>com.ruoyi</groupId>
<artifactId>ruoyi-common-core</artifactId>
<scope>provided</scope>
</dependency>
<!-- excel工具 -->
<dependency>
<groupId>org.apache.poi</groupId>
<artifactId>poi-ooxml</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>easyexcel</artifactId>
</dependency>
</dependencies>
</project>

30
ruoyi-common/ruoyi-common-excel/src/main/java/com/ruoyi/common/excel/annotation/ExcelDictFormat.java Normal file
View File

@ -0,0 +1,30 @@
package com.ruoyi.common.excel.annotation;
import java.lang.annotation.*;
/**
* 字典格式化
*
* @author Lion Li
*/
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface ExcelDictFormat {
/**
* 如果是字典类型，请设置字典的type值 (如: sys_user_sex)
*/
String dictType() default "";
/**
* 读取内容转表达式 (如: 0=男,1=女,2=未知)
*/
String readConverterExp() default "";
/**
* 分隔符，读取字符串组内容
*/
String separator() default ",";
}

52
ruoyi-common/ruoyi-common-excel/src/main/java/com/ruoyi/common/excel/convert/ExcelBigNumberConvert.java Normal file
View File

@ -0,0 +1,52 @@
package com.ruoyi.common.excel.convert;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
import lombok.extern.slf4j.Slf4j;
import java.math.BigDecimal;
/**
* 大数值转换
* Excel 数值长度位15位 大于15位的数值转换位字符串
*
* @author Lion Li
*/
@Slf4j
public class ExcelBigNumberConvert implements Converter<Long> {
@Override
public Class<Long> supportJavaTypeKey() {
return Long.class;
}
@Override
public CellDataTypeEnum supportExcelTypeKey() {
return CellDataTypeEnum.STRING;
}
@Override
public Long convertToJavaData(ReadCellData<?> cellData, ExcelContentProperty contentProperty, GlobalConfiguration globalConfiguration) {
return Convert.toLong(cellData.getData());
}
@Override
public WriteCellData<Object> convertToExcelData(Long object, ExcelContentProperty contentProperty, GlobalConfiguration globalConfiguration) {
if (ObjectUtil.isNotNull(object)) {
String str = Convert.toStr(object);
if (str.length() > 15) {
return new WriteCellData<>(str);
}
}
WriteCellData<Object> cellData = new WriteCellData<>(new BigDecimal(object));
cellData.setType(CellDataTypeEnum.NUMBER);
return cellData;
}
}

73
ruoyi-common/ruoyi-common-excel/src/main/java/com/ruoyi/common/excel/convert/ExcelDictConvert.java Normal file
View File

@ -0,0 +1,73 @@
package com.ruoyi.common.excel.convert;
import cn.hutool.core.annotation.AnnotationUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.excel.converters.Converter;
import com.alibaba.excel.enums.CellDataTypeEnum;
import com.alibaba.excel.metadata.GlobalConfiguration;
import com.alibaba.excel.metadata.data.ReadCellData;
import com.alibaba.excel.metadata.data.WriteCellData;
import com.alibaba.excel.metadata.property.ExcelContentProperty;
import com.ruoyi.common.core.service.DictService;
import com.ruoyi.common.core.utils.SpringUtils;
import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.excel.annotation.ExcelDictFormat;
import com.ruoyi.common.excel.utils.ExcelUtil;
import lombok.extern.slf4j.Slf4j;
import java.lang.reflect.Field;
/**
* 字典格式化转换处理
*
* @author Lion Li
*/
@Slf4j
public class ExcelDictConvert implements Converter<Object> {
@Override
public Class<Object> supportJavaTypeKey() {
return Object.class;
}
@Override
public CellDataTypeEnum supportExcelTypeKey() {
return null;
}
@Override
public Object convertToJavaData(ReadCellData<?> cellData, ExcelContentProperty contentProperty, GlobalConfiguration globalConfiguration) {
ExcelDictFormat anno = getAnnotation(contentProperty.getField());
String type = anno.dictType();
String label = cellData.getStringValue();
String value;
if (StringUtils.isBlank(type)) {
value = ExcelUtil.reverseByExp(label, anno.readConverterExp(), anno.separator());
} else {
value = SpringUtils.getBean(DictService.class).getDictValue(type, label, anno.separator());
}
return Convert.convert(contentProperty.getField().getType(), value);
}
@Override
public WriteCellData<String> convertToExcelData(Object object, ExcelContentProperty contentProperty, GlobalConfiguration globalConfiguration) {
if (ObjectUtil.isNull(object)) {
return new WriteCellData<>("");
}
ExcelDictFormat anno = getAnnotation(contentProperty.getField());
String type = anno.dictType();
String value = Convert.toStr(object);
String label;
if (StringUtils.isBlank(type)) {
label = ExcelUtil.convertByExp(value, anno.readConverterExp(), anno.separator());
} else {
label = SpringUtils.getBean(DictService.class).getDictLabel(type, value, anno.separator());
}
return new WriteCellData<>(label);
}
private ExcelDictFormat getAnnotation(Field field) {
return AnnotationUtil.getAnnotation(field, ExcelDictFormat.class);
}
}

108
ruoyi-common/ruoyi-common-excel/src/main/java/com/ruoyi/common/excel/core/DefaultExcelListener.java Normal file
View File

@ -0,0 +1,108 @@
package com.ruoyi.common.excel.core;
import cn.hutool.core.util.StrUtil;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.excel.exception.ExcelAnalysisException;
import com.alibaba.excel.exception.ExcelDataConvertException;
import com.ruoyi.common.core.utils.JsonUtils;
import com.ruoyi.common.core.utils.ValidatorUtils;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import javax.validation.ConstraintViolation;
import javax.validation.ConstraintViolationException;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
/**
* Excel 导入监听
*
* @author Yjoioooo
* @author Lion Li
*/
@Slf4j
@NoArgsConstructor
public class DefaultExcelListener<T> extends AnalysisEventListener<T> implements ExcelListener<T> {
/**
* 是否Validator检验，默认为是
*/
private Boolean isValidate = Boolean.TRUE;
/**
* excel 表头数据
*/
private Map<Integer, String> headMap;
/**
* 导入回执
*/
private ExcelResult<T> excelResult;
public DefaultExcelListener(boolean isValidate) {
this.excelResult = new DefautExcelResult<>();
this.isValidate = isValidate;
}
/**
* 处理异常
*
* @param exception ExcelDataConvertException
* @param context Excel 上下文
*/
@Override
public void onException(Exception exception, AnalysisContext context) throws Exception {
String errMsg = null;
if (exception instanceof ExcelDataConvertException) {
// 如果是某一个单元格的转换异常 能获取到具体行号
ExcelDataConvertException excelDataConvertException = (ExcelDataConvertException) exception;
Integer rowIndex = excelDataConvertException.getRowIndex();
Integer columnIndex = excelDataConvertException.getColumnIndex();
errMsg = StrUtil.format("第{}行-第{}列-表头{}: 解析异常<br/>",
rowIndex + 1, columnIndex + 1, headMap.get(columnIndex));
if (log.isDebugEnabled()) {
log.error(errMsg);
}
}
if (exception instanceof ConstraintViolationException) {
ConstraintViolationException constraintViolationException = (ConstraintViolationException) exception;
Set<ConstraintViolation<?>> constraintViolations = constraintViolationException.getConstraintViolations();
String constraintViolationsMsg = constraintViolations.stream()
.map(ConstraintViolation::getMessage)
.collect(Collectors.joining(", "));
errMsg = StrUtil.format("第{}行数据校验异常: {}", context.readRowHolder().getRowIndex() + 1, constraintViolationsMsg);
if (log.isDebugEnabled()) {
log.error(errMsg);
}
}
excelResult.getErrorList().add(errMsg);
throw new ExcelAnalysisException(errMsg);
}
@Override
public void invokeHeadMap(Map<Integer, String> headMap, AnalysisContext context) {
this.headMap = headMap;
log.debug("解析到一条表头数据: {}", JsonUtils.toJsonString(headMap));
}
@Override
public void invoke(T data, AnalysisContext context) {
if (isValidate) {
ValidatorUtils.validate(data);
}
excelResult.getList().add(data);
}
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
log.debug("所有数据解析完成！");
}
@Override
public ExcelResult<T> getExcelResult() {
return excelResult;
}
}

73
ruoyi-common/ruoyi-common-excel/src/main/java/com/ruoyi/common/excel/core/DefautExcelResult.java Normal file
View File

@ -0,0 +1,73 @@
package com.ruoyi.common.excel.core;
import cn.hutool.core.util.StrUtil;
import lombok.Setter;
import java.util.ArrayList;
import java.util.List;
/**
* 默认excel返回对象
*
* @author Yjoioooo
* @author Lion Li
*/
public class DefautExcelResult<T> implements ExcelResult<T> {
/**
* 数据对象list
*/
@Setter
private List<T> list;
/**
* 错误信息列表
*/
@Setter
private List<String> errorList;
public DefautExcelResult() {
this.list = new ArrayList<>();
this.errorList = new ArrayList<>();
}
public DefautExcelResult(List<T> list, List<String> errorList) {
this.list = list;
this.errorList = errorList;
}
public DefautExcelResult(ExcelResult<T> excelResult) {
this.list = excelResult.getList();
this.errorList = excelResult.getErrorList();
}
@Override
public List<T> getList() {
return list;
}
@Override
public List<String> getErrorList() {
return errorList;
}
/**
* 获取导入回执
*
* @return 导入回执
*/
@Override
public String getAnalysis() {
int successCount = list.size();
int errorCount = errorList.size();
if (successCount == 0) {
return "读取失败，未解析到数据";
} else {
if (errorCount == 0) {
return StrUtil.format("恭喜您，全部读取成功！共{}条", successCount);
} else {
return "";
}
}
}
}

14
ruoyi-common/ruoyi-common-excel/src/main/java/com/ruoyi/common/excel/core/ExcelListener.java Normal file
View File

@ -0,0 +1,14 @@
package com.ruoyi.common.excel.core;
import com.alibaba.excel.read.listener.ReadListener;
/**
* Excel 导入监听
*
* @author Lion Li
*/
public interface ExcelListener<T> extends ReadListener<T> {
ExcelResult<T> getExcelResult();
}

26
ruoyi-common/ruoyi-common-excel/src/main/java/com/ruoyi/common/excel/core/ExcelResult.java Normal file
View File

@ -0,0 +1,26 @@
package com.ruoyi.common.excel.core;
import java.util.List;
/**
* excel返回对象
*
* @author Lion Li
*/
public interface ExcelResult<T> {
/**
* 对象列表
*/
List<T> getList();
/**
* 错误列表
*/
List<String> getErrorList();
/**
* 导入回执
*/
String getAnalysis();
}

158
ruoyi-common/ruoyi-common-excel/src/main/java/com/ruoyi/common/excel/utils/ExcelUtil.java Normal file
View File

@ -0,0 +1,158 @@
package com.ruoyi.common.excel.utils;
import cn.hutool.core.util.IdUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.write.style.column.LongestMatchColumnWidthStyleStrategy;
import com.ruoyi.common.excel.convert.ExcelBigNumberConvert;
import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.core.utils.file.FileUtils;
import com.ruoyi.common.excel.core.DefaultExcelListener;
import com.ruoyi.common.excel.core.ExcelListener;
import com.ruoyi.common.excel.core.ExcelResult;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
/**
* Excel相关处理
*
* @author Lion Li
*/
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class ExcelUtil {
/**
* 同步导入(适用于小数据量)
*
* @param is 输入流
* @return 转换后集合
*/
public static <T> List<T> importExcel(InputStream is, Class<T> clazz) {
return EasyExcel.read(is).head(clazz).autoCloseStream(false).sheet().doReadSync();
}
/**
* 使用校验监听器 异步导入 同步返回
*
* @param is 输入流
* @param clazz 对象类型
* @param isValidate 是否 Validator 检验 默认为是
* @return 转换后集合
*/
public static <T> ExcelResult<T> importExcel(InputStream is, Class<T> clazz, boolean isValidate) {
DefaultExcelListener<T> listener = new DefaultExcelListener<>(isValidate);
EasyExcel.read(is, clazz, listener).sheet().doRead();
return listener.getExcelResult();
}
/**
* 使用自定义监听器 异步导入 自定义返回
*
* @param is 输入流
* @param clazz 对象类型
* @param listener 自定义监听器
* @return 转换后集合
*/
public static <T> ExcelResult<T> importExcel(InputStream is, Class<T> clazz, ExcelListener<T> listener) {
EasyExcel.read(is, clazz, listener).sheet().doRead();
return listener.getExcelResult();
}
/**
* 导出excel
*
* @param list 导出数据集合
* @param sheetName 工作表的名称
* @return 结果
*/
public static <T> void exportExcel(List<T> list, String sheetName, Class<T> clazz, HttpServletResponse response) {
try {
String filename = encodingFilename(sheetName);
response.reset();
FileUtils.setAttachmentResponseHeader(response, filename);
response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=UTF-8");
ServletOutputStream os = response.getOutputStream();
EasyExcel.write(os, clazz)
.autoCloseStream(false)
// 自动适配
.registerWriteHandler(new LongestMatchColumnWidthStyleStrategy())
// 大数值自动转换 防止失真
.registerConverter(new ExcelBigNumberConvert())
.sheet(sheetName).doWrite(list);
} catch (IOException e) {
throw new RuntimeException("导出Excel异常");
}
}
/**
* 解析导出值 0=男,1=女,2=未知
*
* @param propertyValue 参数值
* @param converterExp 翻译注解
* @param separator 分隔符
* @return 解析后值
*/
public static String convertByExp(String propertyValue, String converterExp, String separator) {
StringBuilder propertyString = new StringBuilder();
String[] convertSource = converterExp.split(",");
for (String item : convertSource) {
String[] itemArray = item.split("=");
if (StringUtils.containsAny(separator, propertyValue)) {
for (String value : propertyValue.split(separator)) {
if (itemArray[0].equals(value)) {
propertyString.append(itemArray[1] + separator);
break;
}
}
} else {
if (itemArray[0].equals(propertyValue)) {
return itemArray[1];
}
}
}
return StringUtils.stripEnd(propertyString.toString(), separator);
}
/**
* 反向解析值 男=0,女=1,未知=2
*
* @param propertyValue 参数值
* @param converterExp 翻译注解
* @param separator 分隔符
* @return 解析后值
*/
public static String reverseByExp(String propertyValue, String converterExp, String separator) {
StringBuilder propertyString = new StringBuilder();
String[] convertSource = converterExp.split(",");
for (String item : convertSource) {
String[] itemArray = item.split("=");
if (StringUtils.containsAny(separator, propertyValue)) {
for (String value : propertyValue.split(separator)) {
if (itemArray[1].equals(value)) {
propertyString.append(itemArray[0] + separator);
break;
}
}
} else {
if (itemArray[1].equals(propertyValue)) {
return itemArray[0];
}
}
}
return StringUtils.stripEnd(propertyString.toString(), separator);
}
/**
* 编码文件名
*/
public static String encodingFilename(String filename) {
return IdUtil.fastSimpleUUID() + "_" + filename + ".xlsx";
}
}

1
ruoyi-common/ruoyi-common-excel/src/main/resources/META-INF/spring.factories Normal file
View File

@ -0,0 +1 @@
org.springframework.boot.autoconfigure.EnableAutoConfiguration=

361
ruoyi-common/ruoyi-common-log/src/main/java/com/ruoyi/common/log/aspect/LogAspect.java
View File

@ -1,181 +1,180 @@
package com.ruoyi.common.log.aspect; package com.ruoyi.common.log.aspect;
import com.ruoyi.common.core.utils.JsonUtils; import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.utils.ServletUtils; import com.ruoyi.common.core.utils.JsonUtils;
import com.ruoyi.common.core.utils.StringUtils; import com.ruoyi.common.core.utils.ServletUtils;
import com.ruoyi.common.core.utils.ip.IpUtils; import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.log.annotation.Log; import com.ruoyi.common.log.annotation.Log;
import com.ruoyi.common.log.enums.BusinessStatus; import com.ruoyi.common.log.enums.BusinessStatus;
import com.ruoyi.common.log.service.AsyncLogService; import com.ruoyi.common.log.service.AsyncLogService;
import com.ruoyi.common.security.utils.SecurityUtils; import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.system.api.domain.SysOperLog; import com.ruoyi.system.api.domain.SysOperLog;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint; import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing; import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpMethod; import org.springframework.http.HttpMethod;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import org.springframework.validation.BindingResult; import org.springframework.validation.BindingResult;
import org.springframework.web.multipart.MultipartFile; import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import java.util.Collection; import java.util.Collection;
import java.util.Map; import java.util.Map;
/** /**
* 操作日志记录处理 * 操作日志记录处理
* *
* @author ruoyi * @author ruoyi
*/ */
@Slf4j @Slf4j
@Aspect @Aspect
@Component @Component
public class LogAspect { public class LogAspect {
@Autowired @Autowired
private AsyncLogService asyncLogService; private AsyncLogService asyncLogService;
/** /**
* 处理完请求后执行 * 处理完请求后执行
* *
* @param joinPoint 切点 * @param joinPoint 切点
*/ */
@AfterReturning(pointcut = "@annotation(controllerLog)", returning = "jsonResult") @AfterReturning(pointcut = "@annotation(controllerLog)", returning = "jsonResult")
public void doAfterReturning(JoinPoint joinPoint, Log controllerLog, Object jsonResult) { public void doAfterReturning(JoinPoint joinPoint, Log controllerLog, Object jsonResult) {
handleLog(joinPoint, controllerLog, null, jsonResult); handleLog(joinPoint, controllerLog, null, jsonResult);
} }
/** /**
* 拦截异常操作 * 拦截异常操作
* *
* @param joinPoint 切点 * @param joinPoint 切点
* @param e 异常 * @param e 异常
*/ */
@AfterThrowing(value = "@annotation(controllerLog)", throwing = "e") @AfterThrowing(value = "@annotation(controllerLog)", throwing = "e")
public void doAfterThrowing(JoinPoint joinPoint, Log controllerLog, Exception e) { public void doAfterThrowing(JoinPoint joinPoint, Log controllerLog, Exception e) {
handleLog(joinPoint, controllerLog, e, null); handleLog(joinPoint, controllerLog, e, null);
} }
protected void handleLog(final JoinPoint joinPoint, Log controllerLog, final Exception e, Object jsonResult) { protected void handleLog(final JoinPoint joinPoint, Log controllerLog, final Exception e, Object jsonResult) {
try { try {
// *========数据库日志=========*// // *========数据库日志=========*//
SysOperLog operLog = new SysOperLog(); SysOperLog operLog = new SysOperLog();
operLog.setStatus(BusinessStatus.SUCCESS.ordinal()); operLog.setStatus(BusinessStatus.SUCCESS.ordinal());
// 请求的地址 // 请求的地址
String ip = IpUtils.getIpAddr(ServletUtils.getRequest()); operLog.setOperIp(ServletUtils.getClientIP());
operLog.setOperIp(ip); operLog.setOperUrl(ServletUtils.getRequest().getRequestURI());
operLog.setOperUrl(ServletUtils.getRequest().getRequestURI()); String username = SecurityUtils.getUsername();
String username = SecurityUtils.getUsername(); if (StringUtils.isNotBlank(username)) {
if (StringUtils.isNotBlank(username)) { operLog.setOperName(username);
operLog.setOperName(username); }
}
if (e != null) {
if (e != null) { operLog.setStatus(BusinessStatus.FAIL.ordinal());
operLog.setStatus(BusinessStatus.FAIL.ordinal()); operLog.setErrorMsg(StringUtils.substring(e.getMessage(), 0, 2000));
operLog.setErrorMsg(StringUtils.substring(e.getMessage(), 0, 2000)); }
} // 设置方法名称
// 设置方法名称 String className = joinPoint.getTarget().getClass().getName();
String className = joinPoint.getTarget().getClass().getName(); String methodName = joinPoint.getSignature().getName();
String methodName = joinPoint.getSignature().getName(); operLog.setMethod(className + "." + methodName + "()");
operLog.setMethod(className + "." + methodName + "()"); // 设置请求方式
// 设置请求方式 operLog.setRequestMethod(ServletUtils.getRequest().getMethod());
operLog.setRequestMethod(ServletUtils.getRequest().getMethod()); // 处理设置注解上的参数
// 处理设置注解上的参数 getControllerMethodDescription(joinPoint, controllerLog, operLog, jsonResult);
getControllerMethodDescription(joinPoint, controllerLog, operLog, jsonResult); // 保存数据库
// 保存数据库 asyncLogService.saveSysLog(operLog);
asyncLogService.saveSysLog(operLog); } catch (Exception exp) {
} catch (Exception exp) { // 记录本地异常日志
// 记录本地异常日志 log.error("==前置通知异常==");
log.error("==前置通知异常=="); log.error("异常信息:{}", exp.getMessage());
log.error("异常信息:{}", exp.getMessage()); exp.printStackTrace();
exp.printStackTrace(); }
} }
}
/**
/** * 获取注解中对方法的描述信息 用于Controller层注解
* 获取注解中对方法的描述信息 用于Controller层注解 *
* * @param log 日志
* @param log 日志 * @param operLog 操作日志
* @param operLog 操作日志 * @throws Exception
* @throws Exception */
*/ public void getControllerMethodDescription(JoinPoint joinPoint, Log log, SysOperLog operLog, Object jsonResult) throws Exception {
public void getControllerMethodDescription(JoinPoint joinPoint, Log log, SysOperLog operLog, Object jsonResult) throws Exception { // 设置action动作
// 设置action动作 operLog.setBusinessType(log.businessType().ordinal());
operLog.setBusinessType(log.businessType().ordinal()); // 设置标题
// 设置标题 operLog.setTitle(log.title());
operLog.setTitle(log.title()); // 设置操作人类别
// 设置操作人类别 operLog.setOperatorType(log.operatorType().ordinal());
operLog.setOperatorType(log.operatorType().ordinal()); // 是否需要保存request，参数和值
// 是否需要保存request，参数和值 if (log.isSaveRequestData()) {
if (log.isSaveRequestData()) { // 获取参数的信息，传入到数据库中。
// 获取参数的信息，传入到数据库中。 setRequestValue(joinPoint, operLog);
setRequestValue(joinPoint, operLog); }
} // 是否需要保存response，参数和值
// 是否需要保存response，参数和值 if (log.isSaveResponseData() && ObjectUtil.isNotNull(jsonResult)) {
if (log.isSaveResponseData() && StringUtils.isNotNull(jsonResult)) { operLog.setJsonResult(StringUtils.substring(JsonUtils.toJsonString(jsonResult), 0, 2000));
operLog.setJsonResult(StringUtils.substring(JsonUtils.toJsonString(jsonResult), 0, 2000)); }
} }
}
/**
/** * 获取请求的参数，放到log中
* 获取请求的参数，放到log中 *
* * @param operLog 操作日志
* @param operLog 操作日志 * @throws Exception 异常
* @throws Exception 异常 */
*/ private void setRequestValue(JoinPoint joinPoint, SysOperLog operLog) throws Exception {
private void setRequestValue(JoinPoint joinPoint, SysOperLog operLog) throws Exception { String requestMethod = operLog.getRequestMethod();
String requestMethod = operLog.getRequestMethod(); if (HttpMethod.PUT.name().equals(requestMethod) || HttpMethod.POST.name().equals(requestMethod)) {
if (HttpMethod.PUT.name().equals(requestMethod) || HttpMethod.POST.name().equals(requestMethod)) { String params = argsArrayToString(joinPoint.getArgs());
String params = argsArrayToString(joinPoint.getArgs()); operLog.setOperParam(StringUtils.substring(params, 0, 2000));
operLog.setOperParam(StringUtils.substring(params, 0, 2000)); }
} }
}
/**
/** * 参数拼装
* 参数拼装 */
*/ private String argsArrayToString(Object[] paramsArray) {
private String argsArrayToString(Object[] paramsArray) { StringBuilder params = new StringBuilder();
StringBuilder params = new StringBuilder(); if (paramsArray != null && paramsArray.length > 0) {
if (paramsArray != null && paramsArray.length > 0) { for (Object o : paramsArray) {
for (Object o : paramsArray) { if (ObjectUtil.isNotNull(o) && !isFilterObject(o)) {
if (StringUtils.isNotNull(o) && !isFilterObject(o)) { try {
try { params.append(JsonUtils.toJsonString(o)).append(" ");
params.append(JsonUtils.toJsonString(o)).append(" "); } catch (Exception e) {
} catch (Exception e) { }
} }
} }
} }
} return params.toString().trim();
return params.toString().trim(); }
}
/**
/** * 判断是否需要过滤的对象。
* 判断是否需要过滤的对象。 *
* * @param o 对象信息。
* @param o 对象信息。 * @return 如果是需要过滤的对象，则返回true；否则返回false。
* @return 如果是需要过滤的对象，则返回true；否则返回false。 */
*/ @SuppressWarnings("rawtypes")
@SuppressWarnings("rawtypes") public boolean isFilterObject(final Object o) {
public boolean isFilterObject(final Object o) { Class<?> clazz = o.getClass();
Class<?> clazz = o.getClass(); if (clazz.isArray()) {
if (clazz.isArray()) { return clazz.getComponentType().isAssignableFrom(MultipartFile.class);
return clazz.getComponentType().isAssignableFrom(MultipartFile.class); } else if (Collection.class.isAssignableFrom(clazz)) {
} else if (Collection.class.isAssignableFrom(clazz)) { Collection collection = (Collection) o;
Collection collection = (Collection) o; for (Object value : collection) {
for (Object value : collection) { return value instanceof MultipartFile;
return value instanceof MultipartFile; }
} } else if (Map.class.isAssignableFrom(clazz)) {
} else if (Map.class.isAssignableFrom(clazz)) { Map map = (Map) o;
Map map = (Map) o; for (Object value : map.entrySet()) {
for (Object value : map.entrySet()) { Map.Entry entry = (Map.Entry) value;
Map.Entry entry = (Map.Entry) value; return entry.getValue() instanceof MultipartFile;
return entry.getValue() instanceof MultipartFile; }
} }
} return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse
return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse || o instanceof BindingResult;
|| o instanceof BindingResult; }
} }
}

8
ruoyi-common/ruoyi-common-seata/pom.xml
View File

@ -28,11 +28,17 @@
<groupId>com.esotericsoftware</groupId> <groupId>com.esotericsoftware</groupId>
<artifactId>kryo</artifactId> <artifactId>kryo</artifactId>
<version>4.0.2</version> <version>4.0.2</version>
<exclusions>
<exclusion>
<artifactId>asm</artifactId>
<groupId>org.ow2.asm</groupId>
</exclusion>
</exclusions>
</dependency> </dependency>
<dependency> <dependency>
<groupId>de.javakaffee</groupId> <groupId>de.javakaffee</groupId>
<artifactId>kryo-serializers</artifactId> <artifactId>kryo-serializers</artifactId>
<version>0.45</version> <version>0.43</version>
</dependency> </dependency>
</dependencies> </dependencies>

91
ruoyi-common/ruoyi-common-security/pom.xml
View File

@ -1,45 +1,46 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0" <project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent> <parent>
<groupId>com.ruoyi</groupId> <groupId>com.ruoyi</groupId>
<artifactId>ruoyi-common</artifactId> <artifactId>ruoyi-common</artifactId>
<version>0.3.0</version> <version>0.3.0</version>
</parent> </parent>
<modelVersion>4.0.0</modelVersion> <modelVersion>4.0.0</modelVersion>
<artifactId>ruoyi-common-security</artifactId> <artifactId>ruoyi-common-security</artifactId>
<description> <description>
ruoyi-common-security安全模块 ruoyi-common-security安全模块
</description> </description>
<dependencies> <dependencies>
<!-- Spring Web --> <!-- Spring Web -->
<dependency> <dependency>
<groupId>org.springframework</groupId> <groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId> <artifactId>spring-webmvc</artifactId>
</dependency> </dependency>
<!-- RuoYi Api System --> <!-- RuoYi Api System -->
<dependency> <dependency>
<groupId>com.ruoyi</groupId> <groupId>com.ruoyi</groupId>
<artifactId>ruoyi-api-system</artifactId> <artifactId>ruoyi-api-system</artifactId>
</dependency> <version>${project.version}</version>
</dependency>
<!-- RuoYi Common Redis-->
<dependency> <!-- RuoYi Common Redis-->
<groupId>com.ruoyi</groupId> <dependency>
<artifactId>ruoyi-common-redis</artifactId> <groupId>com.ruoyi</groupId>
</dependency> <artifactId>ruoyi-common-redis</artifactId>
</dependency>
<!-- <dependency>-->
<!-- <groupId>com.ruoyi</groupId>--> <!-- <dependency>-->
<!-- <artifactId>ruoyi-common-dubbo</artifactId>--> <!-- <groupId>com.ruoyi</groupId>-->
<!-- <scope>provided</scope>--> <!-- <artifactId>ruoyi-common-dubbo</artifactId>-->
<!-- </dependency>--> <!-- <scope>provided</scope>-->
<!-- </dependency>-->
</dependencies>
</dependencies>
</project>
</project>

250
ruoyi-common/ruoyi-common-security/src/main/java/com/ruoyi/common/security/handler/GlobalExceptionHandler.java
View File

@ -1,125 +1,125 @@
package com.ruoyi.common.security.handler; package com.ruoyi.common.security.handler;
import com.ruoyi.common.core.constant.HttpStatus; import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.exception.DemoModeException; import com.ruoyi.common.core.constant.HttpStatus;
import com.ruoyi.common.core.exception.InnerAuthException; import com.ruoyi.common.core.exception.DemoModeException;
import com.ruoyi.common.core.exception.ServiceException; import com.ruoyi.common.core.exception.InnerAuthException;
import com.ruoyi.common.core.exception.auth.NotPermissionException; import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.core.exception.auth.NotRoleException; import com.ruoyi.common.core.exception.auth.NotPermissionException;
import com.ruoyi.common.core.utils.StringUtils; import com.ruoyi.common.core.exception.auth.NotRoleException;
import com.ruoyi.common.core.web.domain.AjaxResult; import com.ruoyi.common.core.web.domain.AjaxResult;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.BindException; import org.springframework.validation.BindException;
import org.springframework.web.HttpRequestMethodNotSupportedException; import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException; import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler; import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice; import org.springframework.web.bind.annotation.RestControllerAdvice;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
/** /**
* 全局异常处理器 * 全局异常处理器
* *
* @author ruoyi * @author ruoyi
*/ */
@Slf4j @Slf4j
@RestControllerAdvice @RestControllerAdvice
public class GlobalExceptionHandler { public class GlobalExceptionHandler {
/** /**
* 权限码异常 * 权限码异常
*/ */
@ExceptionHandler(NotPermissionException.class) @ExceptionHandler(NotPermissionException.class)
public AjaxResult handleNotPermissionException(NotPermissionException e, HttpServletRequest request) { public AjaxResult handleNotPermissionException(NotPermissionException e, HttpServletRequest request) {
String requestURI = request.getRequestURI(); String requestURI = request.getRequestURI();
log.error("请求地址'{}',权限码校验失败'{}'", requestURI, e.getMessage()); log.error("请求地址'{}',权限码校验失败'{}'", requestURI, e.getMessage());
return AjaxResult.error(HttpStatus.FORBIDDEN, "没有访问权限，请联系管理员授权"); return AjaxResult.error(HttpStatus.FORBIDDEN, "没有访问权限，请联系管理员授权");
} }
/** /**
* 角色权限异常 * 角色权限异常
*/ */
@ExceptionHandler(NotRoleException.class) @ExceptionHandler(NotRoleException.class)
public AjaxResult handleNotRoleException(NotRoleException e, HttpServletRequest request) { public AjaxResult handleNotRoleException(NotRoleException e, HttpServletRequest request) {
String requestURI = request.getRequestURI(); String requestURI = request.getRequestURI();
log.error("请求地址'{}',角色权限校验失败'{}'", requestURI, e.getMessage()); log.error("请求地址'{}',角色权限校验失败'{}'", requestURI, e.getMessage());
return AjaxResult.error(HttpStatus.FORBIDDEN, "没有访问权限，请联系管理员授权"); return AjaxResult.error(HttpStatus.FORBIDDEN, "没有访问权限，请联系管理员授权");
} }
/** /**
* 请求方式不支持 * 请求方式不支持
*/ */
@ExceptionHandler(HttpRequestMethodNotSupportedException.class) @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
public AjaxResult handleHttpRequestMethodNotSupported(HttpRequestMethodNotSupportedException e, public AjaxResult handleHttpRequestMethodNotSupported(HttpRequestMethodNotSupportedException e,
HttpServletRequest request) { HttpServletRequest request) {
String requestURI = request.getRequestURI(); String requestURI = request.getRequestURI();
log.error("请求地址'{}',不支持'{}'请求", requestURI, e.getMethod()); log.error("请求地址'{}',不支持'{}'请求", requestURI, e.getMethod());
return AjaxResult.error(e.getMessage()); return AjaxResult.error(e.getMessage());
} }
/** /**
* 业务异常 * 业务异常
*/ */
@ExceptionHandler(ServiceException.class) @ExceptionHandler(ServiceException.class)
public AjaxResult handleServiceException(ServiceException e, HttpServletRequest request) { public AjaxResult handleServiceException(ServiceException e, HttpServletRequest request) {
log.error(e.getMessage(), e); log.error(e.getMessage(), e);
Integer code = e.getCode(); Integer code = e.getCode();
return StringUtils.isNotNull(code) ? AjaxResult.error(code, e.getMessage()) : AjaxResult.error(e.getMessage()); return ObjectUtil.isNotNull(code) ? AjaxResult.error(code, e.getMessage()) : AjaxResult.error(e.getMessage());
} }
/** /**
* 拦截未知的运行时异常 * 拦截未知的运行时异常
*/ */
@ExceptionHandler(RuntimeException.class) @ExceptionHandler(RuntimeException.class)
public AjaxResult handleRuntimeException(RuntimeException e, HttpServletRequest request) { public AjaxResult handleRuntimeException(RuntimeException e, HttpServletRequest request) {
String requestURI = request.getRequestURI(); String requestURI = request.getRequestURI();
log.error("请求地址'{}',发生未知异常.", requestURI, e); log.error("请求地址'{}',发生未知异常.", requestURI, e);
return AjaxResult.error(e.getMessage()); return AjaxResult.error(e.getMessage());
} }
/** /**
* 系统异常 * 系统异常
*/ */
@ExceptionHandler(Exception.class) @ExceptionHandler(Exception.class)
public AjaxResult handleException(Exception e, HttpServletRequest request) { public AjaxResult handleException(Exception e, HttpServletRequest request) {
String requestURI = request.getRequestURI(); String requestURI = request.getRequestURI();
log.error("请求地址'{}',发生系统异常.", requestURI, e); log.error("请求地址'{}',发生系统异常.", requestURI, e);
return AjaxResult.error(e.getMessage()); return AjaxResult.error(e.getMessage());
} }
/** /**
* 自定义验证异常 * 自定义验证异常
*/ */
@ExceptionHandler(BindException.class) @ExceptionHandler(BindException.class)
public AjaxResult handleBindException(BindException e) { public AjaxResult handleBindException(BindException e) {
log.error(e.getMessage(), e); log.error(e.getMessage(), e);
String message = e.getAllErrors().get(0).getDefaultMessage(); String message = e.getAllErrors().get(0).getDefaultMessage();
return AjaxResult.error(message); return AjaxResult.error(message);
} }
/** /**
* 自定义验证异常 * 自定义验证异常
*/ */
@ExceptionHandler(MethodArgumentNotValidException.class) @ExceptionHandler(MethodArgumentNotValidException.class)
public Object handleMethodArgumentNotValidException(MethodArgumentNotValidException e) { public Object handleMethodArgumentNotValidException(MethodArgumentNotValidException e) {
log.error(e.getMessage(), e); log.error(e.getMessage(), e);
String message = e.getBindingResult().getFieldError().getDefaultMessage(); String message = e.getBindingResult().getFieldError().getDefaultMessage();
return AjaxResult.error(message); return AjaxResult.error(message);
} }
/** /**
* 内部认证异常 * 内部认证异常
*/ */
@ExceptionHandler(InnerAuthException.class) @ExceptionHandler(InnerAuthException.class)
public AjaxResult handleInnerAuthException(InnerAuthException e) { public AjaxResult handleInnerAuthException(InnerAuthException e) {
return AjaxResult.error(e.getMessage()); return AjaxResult.error(e.getMessage());
} }
/** /**
* 演示模式异常 * 演示模式异常
*/ */
@ExceptionHandler(DemoModeException.class) @ExceptionHandler(DemoModeException.class)
public AjaxResult handleDemoModeException(DemoModeException e) { public AjaxResult handleDemoModeException(DemoModeException e) {
return AjaxResult.error("演示模式，不允许操作"); return AjaxResult.error("演示模式，不允许操作");
} }
} }

99
ruoyi-common/ruoyi-common-security/src/main/java/com/ruoyi/common/security/interceptor/HeaderInterceptor.java
View File

@ -1,49 +1,50 @@
package com.ruoyi.common.security.interceptor; package com.ruoyi.common.security.interceptor;
import com.ruoyi.common.core.constant.SecurityConstants; import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.context.SecurityContextHolder; import com.ruoyi.common.core.constant.SecurityConstants;
import com.ruoyi.common.core.utils.ServletUtils; import com.ruoyi.common.core.context.SecurityContextHolder;
import com.ruoyi.common.core.utils.StringUtils; import com.ruoyi.common.core.utils.ServletUtils;
import com.ruoyi.common.security.auth.AuthUtil; import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.security.utils.SecurityUtils; import com.ruoyi.common.security.auth.AuthUtil;
import com.ruoyi.system.api.model.LoginUser; import com.ruoyi.common.security.utils.SecurityUtils;
import org.springframework.web.method.HandlerMethod; import com.ruoyi.system.api.model.LoginUser;
import org.springframework.web.servlet.AsyncHandlerInterceptor; import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.AsyncHandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 自定义请求头拦截器，将Header数据封装到线程变量中方便获取 /**
* 注意：此拦截器会同时验证当前用户有效期自动刷新有效期 * 自定义请求头拦截器，将Header数据封装到线程变量中方便获取
* * 注意：此拦截器会同时验证当前用户有效期自动刷新有效期
* @author ruoyi *
*/ * @author ruoyi
public class HeaderInterceptor implements AsyncHandlerInterceptor { */
@Override public class HeaderInterceptor implements AsyncHandlerInterceptor {
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { @Override
if (!(handler instanceof HandlerMethod)) { public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
return true; if (!(handler instanceof HandlerMethod)) {
} return true;
}
SecurityContextHolder.setUserId(ServletUtils.getHeader(request, SecurityConstants.DETAILS_USER_ID));
SecurityContextHolder.setUserName(ServletUtils.getHeader(request, SecurityConstants.DETAILS_USERNAME)); SecurityContextHolder.setUserId(ServletUtils.getHeader(request, SecurityConstants.DETAILS_USER_ID));
SecurityContextHolder.setUserKey(ServletUtils.getHeader(request, SecurityConstants.USER_KEY)); SecurityContextHolder.setUserName(ServletUtils.getHeader(request, SecurityConstants.DETAILS_USERNAME));
SecurityContextHolder.setUserKey(ServletUtils.getHeader(request, SecurityConstants.USER_KEY));
String token = SecurityUtils.getToken();
if (StringUtils.isNotEmpty(token)) { String token = SecurityUtils.getToken();
LoginUser loginUser = AuthUtil.getLoginUser(token); if (StringUtils.isNotEmpty(token)) {
if (StringUtils.isNotNull(loginUser)) { LoginUser loginUser = AuthUtil.getLoginUser(token);
AuthUtil.verifyLoginUserExpire(loginUser); if (ObjectUtil.isNotNull(loginUser)) {
SecurityContextHolder.set(SecurityConstants.LOGIN_USER, loginUser); AuthUtil.verifyLoginUserExpire(loginUser);
} SecurityContextHolder.set(SecurityConstants.LOGIN_USER, loginUser);
} }
return true; }
} return true;
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) @Override
throws Exception { public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
SecurityContextHolder.remove(); throws Exception {
} SecurityContextHolder.remove();
} }
}

8
ruoyi-common/ruoyi-common-security/src/main/java/com/ruoyi/common/security/service/TokenService.java
View File

@ -1,12 +1,12 @@
package com.ruoyi.common.security.service; package com.ruoyi.common.security.service;
import cn.hutool.core.util.IdUtil; import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.constant.CacheConstants; import com.ruoyi.common.core.constant.CacheConstants;
import com.ruoyi.common.core.constant.SecurityConstants; import com.ruoyi.common.core.constant.SecurityConstants;
import com.ruoyi.common.core.utils.JwtUtils; import com.ruoyi.common.core.utils.JwtUtils;
import com.ruoyi.common.core.utils.ServletUtils; import com.ruoyi.common.core.utils.ServletUtils;
import com.ruoyi.common.core.utils.StringUtils; import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.core.utils.ip.IpUtils;
import com.ruoyi.common.redis.utils.RedisUtils; import com.ruoyi.common.redis.utils.RedisUtils;
import com.ruoyi.common.security.utils.SecurityUtils; import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.system.api.model.LoginUser; import com.ruoyi.system.api.model.LoginUser;
@ -45,7 +45,7 @@ public class TokenService {
loginUser.setToken(token); loginUser.setToken(token);
loginUser.setUserid(userId); loginUser.setUserid(userId);
loginUser.setUsername(userName); loginUser.setUsername(userName);
loginUser.setIpaddr(IpUtils.getIpAddr(ServletUtils.getRequest())); loginUser.setIpaddr(ServletUtils.getClientIP());
refreshToken(loginUser); refreshToken(loginUser);
// Jwt存储信息 // Jwt存储信息
@ -103,7 +103,7 @@ public class TokenService {
* 设置用户身份信息 * 设置用户身份信息
*/ */
public void setLoginUser(LoginUser loginUser) { public void setLoginUser(LoginUser loginUser) {
if (StringUtils.isNotNull(loginUser) && StringUtils.isNotEmpty(loginUser.getToken())) { if (ObjectUtil.isNotNull(loginUser) && StringUtils.isNotEmpty(loginUser.getToken())) {
refreshToken(loginUser); refreshToken(loginUser);
} }
} }
@ -147,4 +147,4 @@ public class TokenService {
private String getTokenKey(String token) { private String getTokenKey(String token) {
return ACCESS_TOKEN + token; return ACCESS_TOKEN + token;
} }
} }

12
ruoyi-modules/ruoyi-gen/src/main/java/com/ruoyi/gen/service/GenTableServiceImpl.java
View File

@ -1,5 +1,7 @@
package com.ruoyi.gen.service; package com.ruoyi.gen.service;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.constant.Constants; import com.ruoyi.common.core.constant.Constants;
import com.ruoyi.common.core.constant.GenConstants; import com.ruoyi.common.core.constant.GenConstants;
import com.ruoyi.common.core.exception.ServiceException; import com.ruoyi.common.core.exception.ServiceException;
@ -261,7 +263,7 @@ public class GenTableServiceImpl implements IGenTableService {
Map<String, GenTableColumn> tableColumnMap = tableColumns.stream().collect(Collectors.toMap(GenTableColumn::getColumnName, Function.identity())); Map<String, GenTableColumn> tableColumnMap = tableColumns.stream().collect(Collectors.toMap(GenTableColumn::getColumnName, Function.identity()));
List<GenTableColumn> dbTableColumns = genTableColumnMapper.selectDbTableColumnsByName(tableName); List<GenTableColumn> dbTableColumns = genTableColumnMapper.selectDbTableColumnsByName(tableName);
if (StringUtils.isEmpty(dbTableColumns)) { if (CollUtil.isEmpty(dbTableColumns)) {
throw new ServiceException("同步数据失败，原表结构不存在"); throw new ServiceException("同步数据失败，原表结构不存在");
} }
List<String> dbTableColumnNames = dbTableColumns.stream().map(GenTableColumn::getColumnName).collect(Collectors.toList()); List<String> dbTableColumnNames = dbTableColumns.stream().map(GenTableColumn::getColumnName).collect(Collectors.toList());
@ -282,7 +284,7 @@ public class GenTableServiceImpl implements IGenTableService {
}); });
List<GenTableColumn> delColumns = tableColumns.stream().filter(column -> !dbTableColumnNames.contains(column.getColumnName())).collect(Collectors.toList()); List<GenTableColumn> delColumns = tableColumns.stream().filter(column -> !dbTableColumnNames.contains(column.getColumnName())).collect(Collectors.toList());
if (StringUtils.isNotEmpty(delColumns)) { if (CollUtil.isNotEmpty(delColumns)) {
genTableColumnMapper.deleteGenTableColumns(delColumns); genTableColumnMapper.deleteGenTableColumns(delColumns);
} }
} }
@ -377,7 +379,7 @@ public class GenTableServiceImpl implements IGenTableService {
break; break;
} }
} }
if (StringUtils.isNull(table.getPkColumn())) { if (ObjectUtil.isNull(table.getPkColumn())) {
table.setPkColumn(table.getColumns().get(0)); table.setPkColumn(table.getColumns().get(0));
} }
if (GenConstants.TPL_SUB.equals(table.getTplCategory())) { if (GenConstants.TPL_SUB.equals(table.getTplCategory())) {
@ -387,7 +389,7 @@ public class GenTableServiceImpl implements IGenTableService {
break; break;
} }
} }
if (StringUtils.isNull(table.getSubTable().getPkColumn())) { if (ObjectUtil.isNull(table.getSubTable().getPkColumn())) {
table.getSubTable().setPkColumn(table.getSubTable().getColumns().get(0)); table.getSubTable().setPkColumn(table.getSubTable().getColumns().get(0));
} }
} }
@ -412,7 +414,7 @@ public class GenTableServiceImpl implements IGenTableService {
*/ */
public void setTableFromOptions(GenTable genTable) { public void setTableFromOptions(GenTable genTable) {
Map<String, String> paramsObj = JsonUtils.parseMap(genTable.getOptions()); Map<String, String> paramsObj = JsonUtils.parseMap(genTable.getOptions());
if (StringUtils.isNotNull(paramsObj)) { if (ObjectUtil.isNotNull(paramsObj)) {
String treeCode = paramsObj.get(GenConstants.TREE_CODE); String treeCode = paramsObj.get(GenConstants.TREE_CODE);
String treeParentCode = paramsObj.get(GenConstants.TREE_PARENT_CODE); String treeParentCode = paramsObj.get(GenConstants.TREE_PARENT_CODE);
String treeName = paramsObj.get(GenConstants.TREE_NAME); String treeName = paramsObj.get(GenConstants.TREE_NAME);

662
ruoyi-modules/ruoyi-gen/src/main/java/com/ruoyi/gen/util/VelocityUtils.java
View File

@ -1,330 +1,332 @@
package com.ruoyi.gen.util; package com.ruoyi.gen.util;
import com.ruoyi.common.core.constant.GenConstants; import cn.hutool.core.collection.CollUtil;
import com.ruoyi.common.core.utils.DateUtils; import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.utils.JsonUtils; import com.ruoyi.common.core.constant.GenConstants;
import com.ruoyi.common.core.utils.StringUtils; import com.ruoyi.common.core.utils.DateUtils;
import com.ruoyi.gen.domain.GenTable; import com.ruoyi.common.core.utils.JsonUtils;
import com.ruoyi.gen.domain.GenTableColumn; import com.ruoyi.common.core.utils.StringUtils;
import org.apache.velocity.VelocityContext; import com.ruoyi.gen.domain.GenTable;
import com.ruoyi.gen.domain.GenTableColumn;
import java.util.*; import org.apache.velocity.VelocityContext;
/** import java.util.*;
* 模板工具类
* /**
* @author ruoyi * 模板工具类
*/ *
public class VelocityUtils { * @author ruoyi
/** */
* 项目空间路径 public class VelocityUtils {
*/ /**
private static final String PROJECT_PATH = "main/java"; * 项目空间路径
*/
/** private static final String PROJECT_PATH = "main/java";
* mybatis空间路径
*/ /**
private static final String MYBATIS_PATH = "main/resources/mapper"; * mybatis空间路径
*/
/** private static final String MYBATIS_PATH = "main/resources/mapper";
* 默认上级菜单，系统工具
*/ /**
private static final String DEFAULT_PARENT_MENU_ID = "3"; * 默认上级菜单，系统工具
*/
/** private static final String DEFAULT_PARENT_MENU_ID = "3";
* 设置模板变量信息
* /**
* @return 模板列表 * 设置模板变量信息
*/ *
public static VelocityContext prepareContext(GenTable genTable) { * @return 模板列表
String moduleName = genTable.getModuleName(); */
String businessName = genTable.getBusinessName(); public static VelocityContext prepareContext(GenTable genTable) {
String packageName = genTable.getPackageName(); String moduleName = genTable.getModuleName();
String tplCategory = genTable.getTplCategory(); String businessName = genTable.getBusinessName();
String functionName = genTable.getFunctionName(); String packageName = genTable.getPackageName();
String tplCategory = genTable.getTplCategory();
VelocityContext velocityContext = new VelocityContext(); String functionName = genTable.getFunctionName();
velocityContext.put("tplCategory", genTable.getTplCategory());
velocityContext.put("tableName", genTable.getTableName()); VelocityContext velocityContext = new VelocityContext();
velocityContext.put("functionName", StringUtils.isNotEmpty(functionName) ? functionName : "【请填写功能名称】"); velocityContext.put("tplCategory", genTable.getTplCategory());
velocityContext.put("ClassName", genTable.getClassName()); velocityContext.put("tableName", genTable.getTableName());
velocityContext.put("className", StringUtils.uncapitalize(genTable.getClassName())); velocityContext.put("functionName", StringUtils.isNotEmpty(functionName) ? functionName : "【请填写功能名称】");
velocityContext.put("moduleName", genTable.getModuleName()); velocityContext.put("ClassName", genTable.getClassName());
velocityContext.put("BusinessName", StringUtils.capitalize(genTable.getBusinessName())); velocityContext.put("className", StringUtils.uncapitalize(genTable.getClassName()));
velocityContext.put("businessName", genTable.getBusinessName()); velocityContext.put("moduleName", genTable.getModuleName());
velocityContext.put("basePackage", getPackagePrefix(packageName)); velocityContext.put("BusinessName", StringUtils.capitalize(genTable.getBusinessName()));
velocityContext.put("packageName", packageName); velocityContext.put("businessName", genTable.getBusinessName());
velocityContext.put("author", genTable.getFunctionAuthor()); velocityContext.put("basePackage", getPackagePrefix(packageName));
velocityContext.put("datetime", DateUtils.getDate()); velocityContext.put("packageName", packageName);
velocityContext.put("pkColumn", genTable.getPkColumn()); velocityContext.put("author", genTable.getFunctionAuthor());
velocityContext.put("importList", getImportList(genTable)); velocityContext.put("datetime", DateUtils.getDate());
velocityContext.put("permissionPrefix", getPermissionPrefix(moduleName, businessName)); velocityContext.put("pkColumn", genTable.getPkColumn());
velocityContext.put("columns", genTable.getColumns()); velocityContext.put("importList", getImportList(genTable));
velocityContext.put("table", genTable); velocityContext.put("permissionPrefix", getPermissionPrefix(moduleName, businessName));
velocityContext.put("dicts", getDicts(genTable)); velocityContext.put("columns", genTable.getColumns());
setMenuVelocityContext(velocityContext, genTable); velocityContext.put("table", genTable);
if (GenConstants.TPL_TREE.equals(tplCategory)) { velocityContext.put("dicts", getDicts(genTable));
setTreeVelocityContext(velocityContext, genTable); setMenuVelocityContext(velocityContext, genTable);
} if (GenConstants.TPL_TREE.equals(tplCategory)) {
if (GenConstants.TPL_SUB.equals(tplCategory)) { setTreeVelocityContext(velocityContext, genTable);
setSubVelocityContext(velocityContext, genTable); }
} if (GenConstants.TPL_SUB.equals(tplCategory)) {
return velocityContext; setSubVelocityContext(velocityContext, genTable);
} }
return velocityContext;
public static void setMenuVelocityContext(VelocityContext context, GenTable genTable) { }
String options = genTable.getOptions();
Map<String, String> paramsObj = JsonUtils.parseMap(options); public static void setMenuVelocityContext(VelocityContext context, GenTable genTable) {
String parentMenuId = getParentMenuId(paramsObj); String options = genTable.getOptions();
context.put("parentMenuId", parentMenuId); Map<String, String> paramsObj = JsonUtils.parseMap(options);
} String parentMenuId = getParentMenuId(paramsObj);
context.put("parentMenuId", parentMenuId);
public static void setTreeVelocityContext(VelocityContext context, GenTable genTable) { }
String options = genTable.getOptions();
Map<String, String> paramsObj = JsonUtils.parseMap(options); public static void setTreeVelocityContext(VelocityContext context, GenTable genTable) {
String treeCode = getTreecode(paramsObj); String options = genTable.getOptions();
String treeParentCode = getTreeParentCode(paramsObj); Map<String, String> paramsObj = JsonUtils.parseMap(options);
String treeName = getTreeName(paramsObj); String treeCode = getTreecode(paramsObj);
String treeParentCode = getTreeParentCode(paramsObj);
context.put("treeCode", treeCode); String treeName = getTreeName(paramsObj);
context.put("treeParentCode", treeParentCode);
context.put("treeName", treeName); context.put("treeCode", treeCode);
context.put("expandColumn", getExpandColumn(genTable)); context.put("treeParentCode", treeParentCode);
if (paramsObj.containsKey(GenConstants.TREE_PARENT_CODE)) { context.put("treeName", treeName);
context.put("tree_parent_code", paramsObj.get(GenConstants.TREE_PARENT_CODE)); context.put("expandColumn", getExpandColumn(genTable));
} if (paramsObj.containsKey(GenConstants.TREE_PARENT_CODE)) {
if (paramsObj.containsKey(GenConstants.TREE_NAME)) { context.put("tree_parent_code", paramsObj.get(GenConstants.TREE_PARENT_CODE));
context.put("tree_name", paramsObj.get(GenConstants.TREE_NAME)); }
} if (paramsObj.containsKey(GenConstants.TREE_NAME)) {
} context.put("tree_name", paramsObj.get(GenConstants.TREE_NAME));
}
public static void setSubVelocityContext(VelocityContext context, GenTable genTable) { }
GenTable subTable = genTable.getSubTable();
String subTableName = genTable.getSubTableName(); public static void setSubVelocityContext(VelocityContext context, GenTable genTable) {
String subTableFkName = genTable.getSubTableFkName(); GenTable subTable = genTable.getSubTable();
String subClassName = genTable.getSubTable().getClassName(); String subTableName = genTable.getSubTableName();
String subTableFkClassName = StringUtils.convertToCamelCase(subTableFkName); String subTableFkName = genTable.getSubTableFkName();
String subClassName = genTable.getSubTable().getClassName();
context.put("subTable", subTable); String subTableFkClassName = StringUtils.convertToCamelCase(subTableFkName);
context.put("subTableName", subTableName);
context.put("subTableFkName", subTableFkName); context.put("subTable", subTable);
context.put("subTableFkClassName", subTableFkClassName); context.put("subTableName", subTableName);
context.put("subTableFkclassName", StringUtils.uncapitalize(subTableFkClassName)); context.put("subTableFkName", subTableFkName);
context.put("subClassName", subClassName); context.put("subTableFkClassName", subTableFkClassName);
context.put("subclassName", StringUtils.uncapitalize(subClassName)); context.put("subTableFkclassName", StringUtils.uncapitalize(subTableFkClassName));
context.put("subImportList", getImportList(genTable.getSubTable())); context.put("subClassName", subClassName);
} context.put("subclassName", StringUtils.uncapitalize(subClassName));
context.put("subImportList", getImportList(genTable.getSubTable()));
/** }
* 获取模板信息
* /**
* @return 模板列表 * 获取模板信息
*/ *
public static List<String> getTemplateList(String tplCategory) { * @return 模板列表
List<String> templates = new ArrayList<String>(); */
templates.add("vm/java/domain.java.vm"); public static List<String> getTemplateList(String tplCategory) {
templates.add("vm/java/mapper.java.vm"); List<String> templates = new ArrayList<String>();
templates.add("vm/java/service.java.vm"); templates.add("vm/java/domain.java.vm");
templates.add("vm/java/serviceImpl.java.vm"); templates.add("vm/java/mapper.java.vm");
templates.add("vm/java/controller.java.vm"); templates.add("vm/java/service.java.vm");
templates.add("vm/xml/mapper.xml.vm"); templates.add("vm/java/serviceImpl.java.vm");
templates.add("vm/sql/sql.vm"); templates.add("vm/java/controller.java.vm");
templates.add("vm/js/api.js.vm"); templates.add("vm/xml/mapper.xml.vm");
if (GenConstants.TPL_CRUD.equals(tplCategory)) { templates.add("vm/sql/sql.vm");
templates.add("vm/vue/index.vue.vm"); templates.add("vm/js/api.js.vm");
} else if (GenConstants.TPL_TREE.equals(tplCategory)) { if (GenConstants.TPL_CRUD.equals(tplCategory)) {
templates.add("vm/vue/index-tree.vue.vm"); templates.add("vm/vue/index.vue.vm");
} else if (GenConstants.TPL_SUB.equals(tplCategory)) { } else if (GenConstants.TPL_TREE.equals(tplCategory)) {
templates.add("vm/vue/index.vue.vm"); templates.add("vm/vue/index-tree.vue.vm");
templates.add("vm/java/sub-domain.java.vm"); } else if (GenConstants.TPL_SUB.equals(tplCategory)) {
} templates.add("vm/vue/index.vue.vm");
return templates; templates.add("vm/java/sub-domain.java.vm");
} }
return templates;
/** }
* 获取文件名
*/ /**
public static String getFileName(String template, GenTable genTable) { * 获取文件名
// 文件名称 */
String fileName = ""; public static String getFileName(String template, GenTable genTable) {
// 包路径 // 文件名称
String packageName = genTable.getPackageName(); String fileName = "";
// 模块名 // 包路径
String moduleName = genTable.getModuleName(); String packageName = genTable.getPackageName();
// 大写类名 // 模块名
String className = genTable.getClassName(); String moduleName = genTable.getModuleName();
// 业务名称 // 大写类名
String businessName = genTable.getBusinessName(); String className = genTable.getClassName();
// 业务名称
String javaPath = PROJECT_PATH + "/" + StringUtils.replace(packageName, ".", "/"); String businessName = genTable.getBusinessName();
String mybatisPath = MYBATIS_PATH + "/" + moduleName;
String vuePath = "vue"; String javaPath = PROJECT_PATH + "/" + StringUtils.replace(packageName, ".", "/");
String mybatisPath = MYBATIS_PATH + "/" + moduleName;
if (template.contains("domain.java.vm")) { String vuePath = "vue";
fileName = StringUtils.format("{}/domain/{}.java", javaPath, className);
} if (template.contains("domain.java.vm")) {
if (template.contains("sub-domain.java.vm") && StringUtils.equals(GenConstants.TPL_SUB, genTable.getTplCategory())) { fileName = StringUtils.format("{}/domain/{}.java", javaPath, className);
fileName = StringUtils.format("{}/domain/{}.java", javaPath, genTable.getSubTable().getClassName()); }
} else if (template.contains("mapper.java.vm")) { if (template.contains("sub-domain.java.vm") && StringUtils.equals(GenConstants.TPL_SUB, genTable.getTplCategory())) {
fileName = StringUtils.format("{}/mapper/{}Mapper.java", javaPath, className); fileName = StringUtils.format("{}/domain/{}.java", javaPath, genTable.getSubTable().getClassName());
} else if (template.contains("service.java.vm")) { } else if (template.contains("mapper.java.vm")) {
fileName = StringUtils.format("{}/service/I{}Service.java", javaPath, className); fileName = StringUtils.format("{}/mapper/{}Mapper.java", javaPath, className);
} else if (template.contains("serviceImpl.java.vm")) { } else if (template.contains("service.java.vm")) {
fileName = StringUtils.format("{}/service/impl/{}ServiceImpl.java", javaPath, className); fileName = StringUtils.format("{}/service/I{}Service.java", javaPath, className);
} else if (template.contains("controller.java.vm")) { } else if (template.contains("serviceImpl.java.vm")) {
fileName = StringUtils.format("{}/controller/{}Controller.java", javaPath, className); fileName = StringUtils.format("{}/service/impl/{}ServiceImpl.java", javaPath, className);
} else if (template.contains("mapper.xml.vm")) { } else if (template.contains("controller.java.vm")) {
fileName = StringUtils.format("{}/{}Mapper.xml", mybatisPath, className); fileName = StringUtils.format("{}/controller/{}Controller.java", javaPath, className);
} else if (template.contains("sql.vm")) { } else if (template.contains("mapper.xml.vm")) {
fileName = businessName + "Menu.sql"; fileName = StringUtils.format("{}/{}Mapper.xml", mybatisPath, className);
} else if (template.contains("api.js.vm")) { } else if (template.contains("sql.vm")) {
fileName = StringUtils.format("{}/api/{}/{}.js", vuePath, moduleName, businessName); fileName = businessName + "Menu.sql";
} else if (template.contains("index.vue.vm")) { } else if (template.contains("api.js.vm")) {
fileName = StringUtils.format("{}/views/{}/{}/index.vue", vuePath, moduleName, businessName); fileName = StringUtils.format("{}/api/{}/{}.js", vuePath, moduleName, businessName);
} else if (template.contains("index-tree.vue.vm")) { } else if (template.contains("index.vue.vm")) {
fileName = StringUtils.format("{}/views/{}/{}/index.vue", vuePath, moduleName, businessName); fileName = StringUtils.format("{}/views/{}/{}/index.vue", vuePath, moduleName, businessName);
} } else if (template.contains("index-tree.vue.vm")) {
return fileName; fileName = StringUtils.format("{}/views/{}/{}/index.vue", vuePath, moduleName, businessName);
} }
return fileName;
/** }
* 获取包前缀
* /**
* @param packageName 包名称 * 获取包前缀
* @return 包前缀名称 *
*/ * @param packageName 包名称
public static String getPackagePrefix(String packageName) { * @return 包前缀名称
int lastIndex = packageName.lastIndexOf("."); */
String basePackage = StringUtils.substring(packageName, 0, lastIndex); public static String getPackagePrefix(String packageName) {
return basePackage; int lastIndex = packageName.lastIndexOf(".");
} String basePackage = StringUtils.substring(packageName, 0, lastIndex);
return basePackage;
/** }
* 根据列类型获取导入包
* /**
* @param genTable 业务表对象 * 根据列类型获取导入包
* @return 返回需要导入的包列表 *
*/ * @param genTable 业务表对象
public static HashSet<String> getImportList(GenTable genTable) { * @return 返回需要导入的包列表
List<GenTableColumn> columns = genTable.getColumns(); */
GenTable subGenTable = genTable.getSubTable(); public static HashSet<String> getImportList(GenTable genTable) {
HashSet<String> importList = new HashSet<String>(); List<GenTableColumn> columns = genTable.getColumns();
if (StringUtils.isNotNull(subGenTable)) { GenTable subGenTable = genTable.getSubTable();
importList.add("java.util.List"); HashSet<String> importList = new HashSet<String>();
} if (ObjectUtil.isNotNull(subGenTable)) {
for (GenTableColumn column : columns) { importList.add("java.util.List");
if (!column.isSuperColumn() && GenConstants.TYPE_DATE.equals(column.getJavaType())) { }
importList.add("java.util.Date"); for (GenTableColumn column : columns) {
} else if (!column.isSuperColumn() && GenConstants.TYPE_BIGDECIMAL.equals(column.getJavaType())) { if (!column.isSuperColumn() && GenConstants.TYPE_DATE.equals(column.getJavaType())) {
importList.add("java.math.BigDecimal"); importList.add("java.util.Date");
} } else if (!column.isSuperColumn() && GenConstants.TYPE_BIGDECIMAL.equals(column.getJavaType())) {
} importList.add("java.math.BigDecimal");
return importList; }
} }
return importList;
/** }
* 根据列类型获取字典组
* /**
* @param genTable 业务表对象 * 根据列类型获取字典组
* @return 返回字典组 *
*/ * @param genTable 业务表对象
public static String getDicts(GenTable genTable) { * @return 返回字典组
List<GenTableColumn> columns = genTable.getColumns(); */
Set<String> dicts = new HashSet<String>(); public static String getDicts(GenTable genTable) {
for (GenTableColumn column : columns) { List<GenTableColumn> columns = genTable.getColumns();
if (!column.isSuperColumn() && StringUtils.isNotEmpty(column.getDictType()) && StringUtils.equalsAny( Set<String> dicts = new HashSet<String>();
column.getHtmlType(), for (GenTableColumn column : columns) {
new String[]{GenConstants.HTML_SELECT, GenConstants.HTML_RADIO, GenConstants.HTML_CHECKBOX})) { if (!column.isSuperColumn() && StringUtils.isNotEmpty(column.getDictType()) && StringUtils.equalsAny(
dicts.add("'" + column.getDictType() + "'"); column.getHtmlType(),
} new String[]{GenConstants.HTML_SELECT, GenConstants.HTML_RADIO, GenConstants.HTML_CHECKBOX})) {
} dicts.add("'" + column.getDictType() + "'");
return StringUtils.join(dicts, ", "); }
} }
return StringUtils.join(dicts, ", ");
/** }
* 获取权限前缀
* /**
* @param moduleName 模块名称 * 获取权限前缀
* @param businessName 业务名称 *
* @return 返回权限前缀 * @param moduleName 模块名称
*/ * @param businessName 业务名称
public static String getPermissionPrefix(String moduleName, String businessName) { * @return 返回权限前缀
return StringUtils.format("{}:{}", moduleName, businessName); */
} public static String getPermissionPrefix(String moduleName, String businessName) {
return StringUtils.format("{}:{}", moduleName, businessName);
/** }
* 获取上级菜单ID字段
* /**
* @param paramsObj 生成其他选项 * 获取上级菜单ID字段
* @return 上级菜单ID字段 *
*/ * @param paramsObj 生成其他选项
public static String getParentMenuId(Map<String, String> paramsObj) { * @return 上级菜单ID字段
if (StringUtils.isNotEmpty(paramsObj) && paramsObj.containsKey(GenConstants.PARENT_MENU_ID) */
&& StringUtils.isNotEmpty(paramsObj.get(GenConstants.PARENT_MENU_ID))) { public static String getParentMenuId(Map<String, String> paramsObj) {
return paramsObj.get(GenConstants.PARENT_MENU_ID); if (CollUtil.isNotEmpty(paramsObj) && paramsObj.containsKey(GenConstants.PARENT_MENU_ID)
} && StringUtils.isNotEmpty(paramsObj.get(GenConstants.PARENT_MENU_ID))) {
return DEFAULT_PARENT_MENU_ID; return paramsObj.get(GenConstants.PARENT_MENU_ID);
} }
return DEFAULT_PARENT_MENU_ID;
/** }
* 获取树编码
* /**
* @param paramsObj 生成其他选项 * 获取树编码
* @return 树编码 *
*/ * @param paramsObj 生成其他选项
public static String getTreecode(Map<String, String> paramsObj) { * @return 树编码
if (paramsObj.containsKey(GenConstants.TREE_CODE)) { */
return StringUtils.toCamelCase(paramsObj.get(GenConstants.TREE_CODE)); public static String getTreecode(Map<String, String> paramsObj) {
} if (paramsObj.containsKey(GenConstants.TREE_CODE)) {
return StringUtils.EMPTY; return StringUtils.toCamelCase(paramsObj.get(GenConstants.TREE_CODE));
} }
return StringUtils.EMPTY;
/** }
* 获取树父编码
* /**
* @param paramsObj 生成其他选项 * 获取树父编码
* @return 树父编码 *
*/ * @param paramsObj 生成其他选项
public static String getTreeParentCode(Map<String, String> paramsObj) { * @return 树父编码
if (paramsObj.containsKey(GenConstants.TREE_PARENT_CODE)) { */
return StringUtils.toCamelCase(paramsObj.get(GenConstants.TREE_PARENT_CODE)); public static String getTreeParentCode(Map<String, String> paramsObj) {
} if (paramsObj.containsKey(GenConstants.TREE_PARENT_CODE)) {
return StringUtils.EMPTY; return StringUtils.toCamelCase(paramsObj.get(GenConstants.TREE_PARENT_CODE));
} }
return StringUtils.EMPTY;
/** }
* 获取树名称
* /**
* @param paramsObj 生成其他选项 * 获取树名称
* @return 树名称 *
*/ * @param paramsObj 生成其他选项
public static String getTreeName(Map<String, String> paramsObj) { * @return 树名称
if (paramsObj.containsKey(GenConstants.TREE_NAME)) { */
return StringUtils.toCamelCase(paramsObj.get(GenConstants.TREE_NAME)); public static String getTreeName(Map<String, String> paramsObj) {
} if (paramsObj.containsKey(GenConstants.TREE_NAME)) {
return StringUtils.EMPTY; return StringUtils.toCamelCase(paramsObj.get(GenConstants.TREE_NAME));
} }
return StringUtils.EMPTY;
/** }
* 获取需要在哪一列上面显示展开按钮
* /**
* @param genTable 业务表对象 * 获取需要在哪一列上面显示展开按钮
* @return 展开按钮列序号 *
*/ * @param genTable 业务表对象
public static int getExpandColumn(GenTable genTable) { * @return 展开按钮列序号
String options = genTable.getOptions(); */
Map<String, String> paramsObj = JsonUtils.parseMap(options); public static int getExpandColumn(GenTable genTable) {
String treeName = paramsObj.get(GenConstants.TREE_NAME); String options = genTable.getOptions();
int num = 0; Map<String, String> paramsObj = JsonUtils.parseMap(options);
for (GenTableColumn column : genTable.getColumns()) { String treeName = paramsObj.get(GenConstants.TREE_NAME);
if (column.isList()) { int num = 0;
num++; for (GenTableColumn column : genTable.getColumns()) {
String columnName = column.getColumnName(); if (column.isList()) {
if (columnName.equals(treeName)) { num++;
break; String columnName = column.getColumnName();
} if (columnName.equals(treeName)) {
} break;
} }
return num; }
} }
} return num;
}
}

231
ruoyi-modules/ruoyi-gen/src/main/resources/vm/java/controller.java.vm
View File

@ -1,116 +1,115 @@
package ${packageName}.controller; package ${packageName}.controller;
import java.util.List; import java.util.List;
import java.io.IOException; import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponse; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.PutMapping; import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.DeleteMapping; import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RestController; import com.ruoyi.common.log.annotation.Log;
import com.ruoyi.common.log.annotation.Log; import com.ruoyi.common.log.enums.BusinessType;
import com.ruoyi.common.log.enums.BusinessType; import com.ruoyi.common.security.annotation.RequiresPermissions;
import com.ruoyi.common.security.annotation.RequiresPermissions; import ${packageName}.domain.${ClassName};
import ${packageName}.domain.${ClassName}; import ${packageName}.service.I${ClassName}Service;
import ${packageName}.service.I${ClassName}Service; import com.ruoyi.common.core.web.controller.BaseController;
import com.ruoyi.common.core.web.controller.BaseController; import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.core.web.domain.AjaxResult; import com.ruoyi.common.core.utils.poi.ExcelUtil;
import com.ruoyi.common.core.utils.poi.ExcelUtil; #if($table.crud || $table.sub)
#if($table.crud || $table.sub) import com.ruoyi.common.core.web.page.TableDataInfo;
import com.ruoyi.common.core.web.page.TableDataInfo; #elseif($table.tree)
#elseif($table.tree) #end
#end
/**
/** * ${functionName}Controller
* ${functionName}Controller *
* * @author ${author}
* @author ${author} * @date ${datetime}
* @date ${datetime} */
*/ @RestController
@RestController @RequestMapping("/${businessName}")
@RequestMapping("/${businessName}") public class ${ClassName}Controller extends BaseController
public class ${ClassName}Controller extends BaseController {
{ @Autowired
@Autowired private I${ClassName}Service ${className}Service;
private I${ClassName}Service ${className}Service;
/**
/** * 查询${functionName}列表
* 查询${functionName}列表 */
*/ @RequiresPermissions("${permissionPrefix}:list")
@RequiresPermissions("${permissionPrefix}:list") @GetMapping("/list")
@GetMapping("/list") #if($table.crud || $table.sub)
#if($table.crud || $table.sub) public TableDataInfo list(${ClassName} ${className})
public TableDataInfo list(${ClassName} ${className}) {
{ startPage();
startPage(); List<${ClassName}> list = ${className}Service.select${ClassName}List(${className});
List<${ClassName}> list = ${className}Service.select${ClassName}List(${className}); return getDataTable(list);
return getDataTable(list); }
} #elseif($table.tree)
#elseif($table.tree) public AjaxResult list(${ClassName} ${className})
public AjaxResult list(${ClassName} ${className}) {
{ List<${ClassName}> list = ${className}Service.select${ClassName}List(${className});
List<${ClassName}> list = ${className}Service.select${ClassName}List(${className}); return AjaxResult.success(list);
return AjaxResult.success(list); }
} #end
#end
/**
/** * 导出${functionName}列表
* 导出${functionName}列表 */
*/ @RequiresPermissions("${permissionPrefix}:export")
@RequiresPermissions("${permissionPrefix}:export") @Log(title = "${functionName}", businessType = BusinessType.EXPORT)
@Log(title = "${functionName}", businessType = BusinessType.EXPORT) @PostMapping("/export")
@PostMapping("/export") public void export(HttpServletResponse response, ${ClassName} ${className})
public void export(HttpServletResponse response, ${ClassName} ${className}) {
{ List<${ClassName}> list = ${className}Service.select${ClassName}List(${className});
List<${ClassName}> list = ${className}Service.select${ClassName}List(${className}); ExcelUtil<${ClassName}> util = new ExcelUtil<${ClassName}>(${ClassName}.class);
ExcelUtil<${ClassName}> util = new ExcelUtil<${ClassName}>(${ClassName}.class); util.exportExcel(response, list, "${functionName}数据");
util.exportExcel(response, list, "${functionName}数据"); }
}
/**
/** * 获取${functionName}详细信息
* 获取${functionName}详细信息 */
*/ @RequiresPermissions("${permissionPrefix}:query")
@RequiresPermissions("${permissionPrefix}:query") @GetMapping(value = "/{${pkColumn.javaField}}")
@GetMapping(value = "/{${pkColumn.javaField}}") public AjaxResult getInfo(@PathVariable("${pkColumn.javaField}") ${pkColumn.javaType} ${pkColumn.javaField})
public AjaxResult getInfo(@PathVariable("${pkColumn.javaField}") ${pkColumn.javaType} ${pkColumn.javaField}) {
{ return AjaxResult.success(${className}Service.select${ClassName}By${pkColumn.capJavaField}(${pkColumn.javaField}));
return AjaxResult.success(${className}Service.select${ClassName}By${pkColumn.capJavaField}(${pkColumn.javaField})); }
}
/**
/** * 新增${functionName}
* 新增${functionName} */
*/ @RequiresPermissions("${permissionPrefix}:add")
@RequiresPermissions("${permissionPrefix}:add") @Log(title = "${functionName}", businessType = BusinessType.INSERT)
@Log(title = "${functionName}", businessType = BusinessType.INSERT) @PostMapping
@PostMapping public AjaxResult add(@RequestBody ${ClassName} ${className})
public AjaxResult add(@RequestBody ${ClassName} ${className}) {
{ return toAjax(${className}Service.insert${ClassName}(${className}));
return toAjax(${className}Service.insert${ClassName}(${className})); }
}
/**
/** * 修改${functionName}
* 修改${functionName} */
*/ @RequiresPermissions("${permissionPrefix}:edit")
@RequiresPermissions("${permissionPrefix}:edit") @Log(title = "${functionName}", businessType = BusinessType.UPDATE)
@Log(title = "${functionName}", businessType = BusinessType.UPDATE) @PutMapping
@PutMapping public AjaxResult edit(@RequestBody ${ClassName} ${className})
public AjaxResult edit(@RequestBody ${ClassName} ${className}) {
{ return toAjax(${className}Service.update${ClassName}(${className}));
return toAjax(${className}Service.update${ClassName}(${className})); }
}
/**
/** * 删除${functionName}
* 删除${functionName} */
*/ @RequiresPermissions("${permissionPrefix}:remove")
@RequiresPermissions("${permissionPrefix}:remove") @Log(title = "${functionName}", businessType = BusinessType.DELETE)
@Log(title = "${functionName}", businessType = BusinessType.DELETE) @DeleteMapping("/{${pkColumn.javaField}s}")
@DeleteMapping("/{${pkColumn.javaField}s}") public AjaxResult remove(@PathVariable ${pkColumn.javaType}[] ${pkColumn.javaField}s)
public AjaxResult remove(@PathVariable ${pkColumn.javaType}[] ${pkColumn.javaField}s) {
{ return toAjax(${className}Service.delete${ClassName}By${pkColumn.capJavaField}s(${pkColumn.javaField}s));
return toAjax(${className}Service.delete${ClassName}By${pkColumn.capJavaField}s(${pkColumn.javaField}s)); }
} }
}

5
ruoyi-modules/ruoyi-system/pom.xml
View File

@ -107,6 +107,11 @@
<artifactId>ruoyi-api-file</artifactId> <artifactId>ruoyi-api-file</artifactId>
</dependency> </dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-stream-rabbit</artifactId>
</dependency>
</dependencies> </dependencies>
<build> <build>

237
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/controller/SysConfigController.java
View File

@ -1,119 +1,118 @@
package com.ruoyi.system.controller; package com.ruoyi.system.controller;
import com.ruoyi.common.core.constant.UserConstants; import com.ruoyi.common.core.constant.UserConstants;
import com.ruoyi.common.core.utils.poi.ExcelUtil; import com.ruoyi.common.core.web.controller.BaseController;
import com.ruoyi.common.core.web.controller.BaseController; import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.core.web.domain.AjaxResult; import com.ruoyi.common.core.web.page.TableDataInfo;
import com.ruoyi.common.core.web.page.TableDataInfo; import com.ruoyi.common.excel.utils.ExcelUtil;
import com.ruoyi.common.log.annotation.Log; import com.ruoyi.common.log.annotation.Log;
import com.ruoyi.common.log.enums.BusinessType; import com.ruoyi.common.log.enums.BusinessType;
import com.ruoyi.common.security.annotation.RequiresPermissions; import com.ruoyi.common.security.annotation.RequiresPermissions;
import com.ruoyi.common.security.utils.SecurityUtils; import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.system.domain.SysConfig; import com.ruoyi.system.domain.SysConfig;
import com.ruoyi.system.service.ISysConfigService; import com.ruoyi.system.service.ISysConfigService;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated; import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import java.util.List; import java.util.List;
/** /**
* 参数配置 信息操作处理 * 参数配置 信息操作处理
* *
* @author ruoyi * @author ruoyi
*/ */
@RequiredArgsConstructor(onConstructor_ = @Autowired) @RequiredArgsConstructor(onConstructor_ = @Autowired)
@RestController @RestController
@RequestMapping("/config") @RequestMapping("/config")
public class SysConfigController extends BaseController { public class SysConfigController extends BaseController {
private final ISysConfigService configService; private final ISysConfigService configService;
/** /**
* 获取参数配置列表 * 获取参数配置列表
*/ */
@RequiresPermissions("system:config:list") @RequiresPermissions("system:config:list")
@GetMapping("/list") @GetMapping("/list")
public TableDataInfo list(SysConfig config) { public TableDataInfo list(SysConfig config) {
startPage(); startPage();
List<SysConfig> list = configService.selectConfigList(config); List<SysConfig> list = configService.selectConfigList(config);
return getDataTable(list); return getDataTable(list);
} }
@Log(title = "参数管理", businessType = BusinessType.EXPORT) @Log(title = "参数管理", businessType = BusinessType.EXPORT)
@RequiresPermissions("system:config:export") @RequiresPermissions("system:config:export")
@PostMapping("/export") @PostMapping("/export")
public void export(HttpServletResponse response, SysConfig config) { public void export(HttpServletResponse response, SysConfig config) {
List<SysConfig> list = configService.selectConfigList(config); List<SysConfig> list = configService.selectConfigList(config);
ExcelUtil<SysConfig> util = new ExcelUtil<SysConfig>(SysConfig.class); ExcelUtil.exportExcel(list, "参数数据", SysConfig.class, response);
util.exportExcel(response, list, "参数数据"); }
}
/**
/** * 根据参数编号获取详细信息
* 根据参数编号获取详细信息 */
*/ @GetMapping(value = "/{configId}")
@GetMapping(value = "/{configId}") public AjaxResult getInfo(@PathVariable Long configId) {
public AjaxResult getInfo(@PathVariable Long configId) { return AjaxResult.success(configService.selectConfigById(configId));
return AjaxResult.success(configService.selectConfigById(configId)); }
}
/**
/** * 根据参数键名查询参数值
* 根据参数键名查询参数值 */
*/ @GetMapping(value = "/configKey/{configKey}")
@GetMapping(value = "/configKey/{configKey}") public AjaxResult getConfigKey(@PathVariable String configKey) {
public AjaxResult getConfigKey(@PathVariable String configKey) { return AjaxResult.success(configService.selectConfigByKey(configKey));
return AjaxResult.success(configService.selectConfigByKey(configKey)); }
}
/**
/** * 新增参数配置
* 新增参数配置 */
*/ @RequiresPermissions("system:config:add")
@RequiresPermissions("system:config:add") @Log(title = "参数管理", businessType = BusinessType.INSERT)
@Log(title = "参数管理", businessType = BusinessType.INSERT) @PostMapping
@PostMapping public AjaxResult add(@Validated @RequestBody SysConfig config) {
public AjaxResult add(@Validated @RequestBody SysConfig config) { if (UserConstants.NOT_UNIQUE.equals(configService.checkConfigKeyUnique(config))) {
if (UserConstants.NOT_UNIQUE.equals(configService.checkConfigKeyUnique(config))) { return AjaxResult.error("新增参数'" + config.getConfigName() + "'失败，参数键名已存在");
return AjaxResult.error("新增参数'" + config.getConfigName() + "'失败，参数键名已存在"); }
} config.setCreateBy(SecurityUtils.getUsername());
config.setCreateBy(SecurityUtils.getUsername()); return toAjax(configService.insertConfig(config));
return toAjax(configService.insertConfig(config)); }
}
/**
/** * 修改参数配置
* 修改参数配置 */
*/ @RequiresPermissions("system:config:edit")
@RequiresPermissions("system:config:edit") @Log(title = "参数管理", businessType = BusinessType.UPDATE)
@Log(title = "参数管理", businessType = BusinessType.UPDATE) @PutMapping
@PutMapping public AjaxResult edit(@Validated @RequestBody SysConfig config) {
public AjaxResult edit(@Validated @RequestBody SysConfig config) { if (UserConstants.NOT_UNIQUE.equals(configService.checkConfigKeyUnique(config))) {
if (UserConstants.NOT_UNIQUE.equals(configService.checkConfigKeyUnique(config))) { return AjaxResult.error("修改参数'" + config.getConfigName() + "'失败，参数键名已存在");
return AjaxResult.error("修改参数'" + config.getConfigName() + "'失败，参数键名已存在"); }
} config.setUpdateBy(SecurityUtils.getUsername());
config.setUpdateBy(SecurityUtils.getUsername()); return toAjax(configService.updateConfig(config));
return toAjax(configService.updateConfig(config)); }
}
/**
/** * 删除参数配置
* 删除参数配置 */
*/ @RequiresPermissions("system:config:remove")
@RequiresPermissions("system:config:remove") @Log(title = "参数管理", businessType = BusinessType.DELETE)
@Log(title = "参数管理", businessType = BusinessType.DELETE) @DeleteMapping("/{configIds}")
@DeleteMapping("/{configIds}") public AjaxResult remove(@PathVariable Long[] configIds) {
public AjaxResult remove(@PathVariable Long[] configIds) { configService.deleteConfigByIds(configIds);
configService.deleteConfigByIds(configIds); return success();
return success(); }
}
/**
/** * 刷新参数缓存
* 刷新参数缓存 */
*/ @RequiresPermissions("system:config:remove")
@RequiresPermissions("system:config:remove") @Log(title = "参数管理", businessType = BusinessType.CLEAN)
@Log(title = "参数管理", businessType = BusinessType.CLEAN) @DeleteMapping("/refreshCache")
@DeleteMapping("/refreshCache") public AjaxResult refreshCache() {
public AjaxResult refreshCache() { configService.resetConfigCache();
configService.resetConfigCache(); return AjaxResult.success();
return AjaxResult.success(); }
} }
}

213
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/controller/SysDictDataController.java
View File

@ -1,107 +1,106 @@
package com.ruoyi.system.controller; package com.ruoyi.system.controller;
import com.ruoyi.common.core.utils.StringUtils; import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.utils.poi.ExcelUtil; import com.ruoyi.common.core.web.controller.BaseController;
import com.ruoyi.common.core.web.controller.BaseController; import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.core.web.domain.AjaxResult; import com.ruoyi.common.core.web.page.TableDataInfo;
import com.ruoyi.common.core.web.page.TableDataInfo; import com.ruoyi.common.excel.utils.ExcelUtil;
import com.ruoyi.common.log.annotation.Log; import com.ruoyi.common.log.annotation.Log;
import com.ruoyi.common.log.enums.BusinessType; import com.ruoyi.common.log.enums.BusinessType;
import com.ruoyi.common.security.annotation.RequiresPermissions; import com.ruoyi.common.security.annotation.RequiresPermissions;
import com.ruoyi.common.security.utils.SecurityUtils; import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.system.api.domain.SysDictData; import com.ruoyi.system.api.domain.SysDictData;
import com.ruoyi.system.service.ISysDictDataService; import com.ruoyi.system.service.ISysDictDataService;
import com.ruoyi.system.service.ISysDictTypeService; import com.ruoyi.system.service.ISysDictTypeService;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated; import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
/** /**
* 数据字典信息 * 数据字典信息
* *
* @author ruoyi * @author ruoyi
*/ */
@RequiredArgsConstructor(onConstructor_ = @Autowired) @RequiredArgsConstructor(onConstructor_ = @Autowired)
@RestController @RestController
@RequestMapping("/dict/data") @RequestMapping("/dict/data")
public class SysDictDataController extends BaseController { public class SysDictDataController extends BaseController {
private final ISysDictDataService dictDataService; private final ISysDictDataService dictDataService;
private final ISysDictTypeService dictTypeService; private final ISysDictTypeService dictTypeService;
@RequiresPermissions("system:dict:list") @RequiresPermissions("system:dict:list")
@GetMapping("/list") @GetMapping("/list")
public TableDataInfo list(SysDictData dictData) { public TableDataInfo list(SysDictData dictData) {
startPage(); startPage();
List<SysDictData> list = dictDataService.selectDictDataList(dictData); List<SysDictData> list = dictDataService.selectDictDataList(dictData);
return getDataTable(list); return getDataTable(list);
} }
@Log(title = "字典数据", businessType = BusinessType.EXPORT) @Log(title = "字典数据", businessType = BusinessType.EXPORT)
@RequiresPermissions("system:dict:export") @RequiresPermissions("system:dict:export")
@PostMapping("/export") @PostMapping("/export")
public void export(HttpServletResponse response, SysDictData dictData) { public void export(HttpServletResponse response, SysDictData dictData) {
List<SysDictData> list = dictDataService.selectDictDataList(dictData); List<SysDictData> list = dictDataService.selectDictDataList(dictData);
ExcelUtil<SysDictData> util = new ExcelUtil<SysDictData>(SysDictData.class); ExcelUtil.exportExcel(list, "字典数据", SysDictData.class, response);
util.exportExcel(response, list, "字典数据"); }
}
/**
/** * 查询字典数据详细
* 查询字典数据详细 */
*/ @RequiresPermissions("system:dict:query")
@RequiresPermissions("system:dict:query") @GetMapping(value = "/{dictCode}")
@GetMapping(value = "/{dictCode}") public AjaxResult getInfo(@PathVariable Long dictCode) {
public AjaxResult getInfo(@PathVariable Long dictCode) { return AjaxResult.success(dictDataService.selectDictDataById(dictCode));
return AjaxResult.success(dictDataService.selectDictDataById(dictCode)); }
}
/**
/** * 根据字典类型查询字典数据信息
* 根据字典类型查询字典数据信息 */
*/ @GetMapping(value = "/type/{dictType}")
@GetMapping(value = "/type/{dictType}") public AjaxResult dictType(@PathVariable String dictType) {
public AjaxResult dictType(@PathVariable String dictType) { List<SysDictData> data = dictTypeService.selectDictDataByType(dictType);
List<SysDictData> data = dictTypeService.selectDictDataByType(dictType); if (ObjectUtil.isNull(data)) {
if (StringUtils.isNull(data)) { data = new ArrayList<SysDictData>();
data = new ArrayList<SysDictData>(); }
} return AjaxResult.success(data);
return AjaxResult.success(data); }
}
/**
/** * 新增字典类型
* 新增字典类型 */
*/ @RequiresPermissions("system:dict:add")
@RequiresPermissions("system:dict:add") @Log(title = "字典数据", businessType = BusinessType.INSERT)
@Log(title = "字典数据", businessType = BusinessType.INSERT) @PostMapping
@PostMapping public AjaxResult add(@Validated @RequestBody SysDictData dict) {
public AjaxResult add(@Validated @RequestBody SysDictData dict) { dict.setCreateBy(SecurityUtils.getUsername());
dict.setCreateBy(SecurityUtils.getUsername()); return toAjax(dictDataService.insertDictData(dict));
return toAjax(dictDataService.insertDictData(dict)); }
}
/**
/** * 修改保存字典类型
* 修改保存字典类型 */
*/ @RequiresPermissions("system:dict:edit")
@RequiresPermissions("system:dict:edit") @Log(title = "字典数据", businessType = BusinessType.UPDATE)
@Log(title = "字典数据", businessType = BusinessType.UPDATE) @PutMapping
@PutMapping public AjaxResult edit(@Validated @RequestBody SysDictData dict) {
public AjaxResult edit(@Validated @RequestBody SysDictData dict) { dict.setUpdateBy(SecurityUtils.getUsername());
dict.setUpdateBy(SecurityUtils.getUsername()); return toAjax(dictDataService.updateDictData(dict));
return toAjax(dictDataService.updateDictData(dict)); }
}
/**
/** * 删除字典类型
* 删除字典类型 */
*/ @RequiresPermissions("system:dict:remove")
@RequiresPermissions("system:dict:remove") @Log(title = "字典类型", businessType = BusinessType.DELETE)
@Log(title = "字典类型", businessType = BusinessType.DELETE) @DeleteMapping("/{dictCodes}")
@DeleteMapping("/{dictCodes}") public AjaxResult remove(@PathVariable Long[] dictCodes) {
public AjaxResult remove(@PathVariable Long[] dictCodes) { dictDataService.deleteDictDataByIds(dictCodes);
dictDataService.deleteDictDataByIds(dictCodes); return success();
return success(); }
} }
}

235
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/controller/SysDictTypeController.java
View File

@ -1,118 +1,117 @@
package com.ruoyi.system.controller; package com.ruoyi.system.controller;
import com.ruoyi.common.core.constant.UserConstants; import com.ruoyi.common.core.constant.UserConstants;
import com.ruoyi.common.core.utils.poi.ExcelUtil; import com.ruoyi.common.core.web.controller.BaseController;
import com.ruoyi.common.core.web.controller.BaseController; import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.core.web.domain.AjaxResult; import com.ruoyi.common.core.web.page.TableDataInfo;
import com.ruoyi.common.core.web.page.TableDataInfo; import com.ruoyi.common.excel.utils.ExcelUtil;
import com.ruoyi.common.log.annotation.Log; import com.ruoyi.common.log.annotation.Log;
import com.ruoyi.common.log.enums.BusinessType; import com.ruoyi.common.log.enums.BusinessType;
import com.ruoyi.common.security.annotation.RequiresPermissions; import com.ruoyi.common.security.annotation.RequiresPermissions;
import com.ruoyi.common.security.utils.SecurityUtils; import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.system.api.domain.SysDictType; import com.ruoyi.system.api.domain.SysDictType;
import com.ruoyi.system.service.ISysDictTypeService; import com.ruoyi.system.service.ISysDictTypeService;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated; import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import java.util.List; import java.util.List;
/** /**
* 数据字典信息 * 数据字典信息
* *
* @author ruoyi * @author ruoyi
*/ */
@RequiredArgsConstructor(onConstructor_ = @Autowired) @RequiredArgsConstructor(onConstructor_ = @Autowired)
@RestController @RestController
@RequestMapping("/dict/type") @RequestMapping("/dict/type")
public class SysDictTypeController extends BaseController { public class SysDictTypeController extends BaseController {
private final ISysDictTypeService dictTypeService; private final ISysDictTypeService dictTypeService;
@RequiresPermissions("system:dict:list") @RequiresPermissions("system:dict:list")
@GetMapping("/list") @GetMapping("/list")
public TableDataInfo list(SysDictType dictType) { public TableDataInfo list(SysDictType dictType) {
startPage(); startPage();
List<SysDictType> list = dictTypeService.selectDictTypeList(dictType); List<SysDictType> list = dictTypeService.selectDictTypeList(dictType);
return getDataTable(list); return getDataTable(list);
} }
@Log(title = "字典类型", businessType = BusinessType.EXPORT) @Log(title = "字典类型", businessType = BusinessType.EXPORT)
@RequiresPermissions("system:dict:export") @RequiresPermissions("system:dict:export")
@PostMapping("/export") @PostMapping("/export")
public void export(HttpServletResponse response, SysDictType dictType) { public void export(HttpServletResponse response, SysDictType dictType) {
List<SysDictType> list = dictTypeService.selectDictTypeList(dictType); List<SysDictType> list = dictTypeService.selectDictTypeList(dictType);
ExcelUtil<SysDictType> util = new ExcelUtil<SysDictType>(SysDictType.class); ExcelUtil.exportExcel(list, "字典类型", SysDictType.class, response);
util.exportExcel(response, list, "字典类型"); }
}
/**
/** * 查询字典类型详细
* 查询字典类型详细 */
*/ @RequiresPermissions("system:dict:query")
@RequiresPermissions("system:dict:query") @GetMapping(value = "/{dictId}")
@GetMapping(value = "/{dictId}") public AjaxResult getInfo(@PathVariable Long dictId) {
public AjaxResult getInfo(@PathVariable Long dictId) { return AjaxResult.success(dictTypeService.selectDictTypeById(dictId));
return AjaxResult.success(dictTypeService.selectDictTypeById(dictId)); }
}
/**
/** * 新增字典类型
* 新增字典类型 */
*/ @RequiresPermissions("system:dict:add")
@RequiresPermissions("system:dict:add") @Log(title = "字典类型", businessType = BusinessType.INSERT)
@Log(title = "字典类型", businessType = BusinessType.INSERT) @PostMapping
@PostMapping public AjaxResult add(@Validated @RequestBody SysDictType dict) {
public AjaxResult add(@Validated @RequestBody SysDictType dict) { if (UserConstants.NOT_UNIQUE.equals(dictTypeService.checkDictTypeUnique(dict))) {
if (UserConstants.NOT_UNIQUE.equals(dictTypeService.checkDictTypeUnique(dict))) { return AjaxResult.error("新增字典'" + dict.getDictName() + "'失败，字典类型已存在");
return AjaxResult.error("新增字典'" + dict.getDictName() + "'失败，字典类型已存在"); }
} dict.setCreateBy(SecurityUtils.getUsername());
dict.setCreateBy(SecurityUtils.getUsername()); return toAjax(dictTypeService.insertDictType(dict));
return toAjax(dictTypeService.insertDictType(dict)); }
}
/**
/** * 修改字典类型
* 修改字典类型 */
*/ @RequiresPermissions("system:dict:edit")
@RequiresPermissions("system:dict:edit") @Log(title = "字典类型", businessType = BusinessType.UPDATE)
@Log(title = "字典类型", businessType = BusinessType.UPDATE) @PutMapping
@PutMapping public AjaxResult edit(@Validated @RequestBody SysDictType dict) {
public AjaxResult edit(@Validated @RequestBody SysDictType dict) { if (UserConstants.NOT_UNIQUE.equals(dictTypeService.checkDictTypeUnique(dict))) {
if (UserConstants.NOT_UNIQUE.equals(dictTypeService.checkDictTypeUnique(dict))) { return AjaxResult.error("修改字典'" + dict.getDictName() + "'失败，字典类型已存在");
return AjaxResult.error("修改字典'" + dict.getDictName() + "'失败，字典类型已存在"); }
} dict.setUpdateBy(SecurityUtils.getUsername());
dict.setUpdateBy(SecurityUtils.getUsername()); return toAjax(dictTypeService.updateDictType(dict));
return toAjax(dictTypeService.updateDictType(dict)); }
}
/**
/** * 删除字典类型
* 删除字典类型 */
*/ @RequiresPermissions("system:dict:remove")
@RequiresPermissions("system:dict:remove") @Log(title = "字典类型", businessType = BusinessType.DELETE)
@Log(title = "字典类型", businessType = BusinessType.DELETE) @DeleteMapping("/{dictIds}")
@DeleteMapping("/{dictIds}") public AjaxResult remove(@PathVariable Long[] dictIds) {
public AjaxResult remove(@PathVariable Long[] dictIds) { dictTypeService.deleteDictTypeByIds(dictIds);
dictTypeService.deleteDictTypeByIds(dictIds); return success();
return success(); }
}
/**
/** * 刷新字典缓存
* 刷新字典缓存 */
*/ @RequiresPermissions("system:dict:remove")
@RequiresPermissions("system:dict:remove") @Log(title = "字典类型", businessType = BusinessType.CLEAN)
@Log(title = "字典类型", businessType = BusinessType.CLEAN) @DeleteMapping("/refreshCache")
@DeleteMapping("/refreshCache") public AjaxResult refreshCache() {
public AjaxResult refreshCache() { dictTypeService.resetDictCache();
dictTypeService.resetDictCache(); return AjaxResult.success();
return AjaxResult.success(); }
}
/**
/** * 获取字典选择框列表
* 获取字典选择框列表 */
*/ @GetMapping("/optionselect")
@GetMapping("/optionselect") public AjaxResult optionselect() {
public AjaxResult optionselect() { List<SysDictType> dictTypes = dictTypeService.selectDictTypeAll();
List<SysDictType> dictTypes = dictTypeService.selectDictTypeAll(); return AjaxResult.success(dictTypes);
return AjaxResult.success(dictTypes); }
} }
}

137
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/controller/SysLogininforController.java
View File

@ -1,69 +1,68 @@
package com.ruoyi.system.controller; package com.ruoyi.system.controller;
import com.ruoyi.common.core.utils.poi.ExcelUtil; import com.ruoyi.common.core.web.controller.BaseController;
import com.ruoyi.common.core.web.controller.BaseController; import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.core.web.domain.AjaxResult; import com.ruoyi.common.core.web.page.TableDataInfo;
import com.ruoyi.common.core.web.page.TableDataInfo; import com.ruoyi.common.excel.utils.ExcelUtil;
import com.ruoyi.common.log.annotation.Log; import com.ruoyi.common.log.annotation.Log;
import com.ruoyi.common.log.enums.BusinessType; import com.ruoyi.common.log.enums.BusinessType;
import com.ruoyi.common.security.annotation.InnerAuth; import com.ruoyi.common.security.annotation.InnerAuth;
import com.ruoyi.common.security.annotation.RequiresPermissions; import com.ruoyi.common.security.annotation.RequiresPermissions;
import com.ruoyi.system.api.domain.SysLogininfor; import com.ruoyi.system.api.domain.SysLogininfor;
import com.ruoyi.system.service.ISysLogininforService; import com.ruoyi.system.service.ISysLogininforService;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import java.util.List; import java.util.List;
/** /**
* 系统访问记录 * 系统访问记录
* *
* @author ruoyi * @author ruoyi
*/ */
@RequiredArgsConstructor(onConstructor_ = @Autowired) @RequiredArgsConstructor(onConstructor_ = @Autowired)
@RestController @RestController
@RequestMapping("/logininfor") @RequestMapping("/logininfor")
public class SysLogininforController extends BaseController { public class SysLogininforController extends BaseController {
private final ISysLogininforService logininforService; private final ISysLogininforService logininforService;
@RequiresPermissions("system:logininfor:list") @RequiresPermissions("system:logininfor:list")
@GetMapping("/list") @GetMapping("/list")
public TableDataInfo list(SysLogininfor logininfor) { public TableDataInfo list(SysLogininfor logininfor) {
startPage(); startPage();
List<SysLogininfor> list = logininforService.selectLogininforList(logininfor); List<SysLogininfor> list = logininforService.selectLogininforList(logininfor);
return getDataTable(list); return getDataTable(list);
} }
@Log(title = "登录日志", businessType = BusinessType.EXPORT) @Log(title = "登录日志", businessType = BusinessType.EXPORT)
@RequiresPermissions("system:logininfor:export") @RequiresPermissions("system:logininfor:export")
@PostMapping("/export") @PostMapping("/export")
public void export(HttpServletResponse response, SysLogininfor logininfor) { public void export(HttpServletResponse response, SysLogininfor logininfor) {
List<SysLogininfor> list = logininforService.selectLogininforList(logininfor); List<SysLogininfor> list = logininforService.selectLogininforList(logininfor);
ExcelUtil<SysLogininfor> util = new ExcelUtil<SysLogininfor>(SysLogininfor.class); ExcelUtil.exportExcel(list, "登录日志", SysLogininfor.class, response);
util.exportExcel(response, list, "登录日志"); }
}
@RequiresPermissions("system:logininfor:remove")
@RequiresPermissions("system:logininfor:remove") @Log(title = "登录日志", businessType = BusinessType.DELETE)
@Log(title = "登录日志", businessType = BusinessType.DELETE) @DeleteMapping("/{infoIds}")
@DeleteMapping("/{infoIds}") public AjaxResult remove(@PathVariable Long[] infoIds) {
public AjaxResult remove(@PathVariable Long[] infoIds) { return toAjax(logininforService.deleteLogininforByIds(infoIds));
return toAjax(logininforService.deleteLogininforByIds(infoIds)); }
}
@RequiresPermissions("system:logininfor:remove")
@RequiresPermissions("system:logininfor:remove") @Log(title = "登录日志", businessType = BusinessType.DELETE)
@Log(title = "登录日志", businessType = BusinessType.DELETE) @DeleteMapping("/clean")
@DeleteMapping("/clean") public AjaxResult clean() {
public AjaxResult clean() { logininforService.cleanLogininfor();
logininforService.cleanLogininfor(); return AjaxResult.success();
return AjaxResult.success(); }
}
@InnerAuth
@InnerAuth @PostMapping
@PostMapping public AjaxResult add(@RequestBody SysLogininfor logininfor) {
public AjaxResult add(@RequestBody SysLogininfor logininfor) { return toAjax(logininforService.insertLogininfor(logininfor));
return toAjax(logininforService.insertLogininfor(logininfor)); }
} }
}

135
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/controller/SysOperlogController.java
View File

@ -1,68 +1,67 @@
package com.ruoyi.system.controller; package com.ruoyi.system.controller;
import com.ruoyi.common.core.utils.poi.ExcelUtil; import com.ruoyi.common.core.web.controller.BaseController;
import com.ruoyi.common.core.web.controller.BaseController; import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.core.web.domain.AjaxResult; import com.ruoyi.common.core.web.page.TableDataInfo;
import com.ruoyi.common.core.web.page.TableDataInfo; import com.ruoyi.common.excel.utils.ExcelUtil;
import com.ruoyi.common.log.annotation.Log; import com.ruoyi.common.log.annotation.Log;
import com.ruoyi.common.log.enums.BusinessType; import com.ruoyi.common.log.enums.BusinessType;
import com.ruoyi.common.security.annotation.InnerAuth; import com.ruoyi.common.security.annotation.InnerAuth;
import com.ruoyi.common.security.annotation.RequiresPermissions; import com.ruoyi.common.security.annotation.RequiresPermissions;
import com.ruoyi.system.api.domain.SysOperLog; import com.ruoyi.system.api.domain.SysOperLog;
import com.ruoyi.system.service.ISysOperLogService; import com.ruoyi.system.service.ISysOperLogService;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import java.util.List; import java.util.List;
/** /**
* 操作日志记录 * 操作日志记录
* *
* @author ruoyi * @author ruoyi
*/ */
@RequiredArgsConstructor(onConstructor_ = @Autowired) @RequiredArgsConstructor(onConstructor_ = @Autowired)
@RestController @RestController
@RequestMapping("/operlog") @RequestMapping("/operlog")
public class SysOperlogController extends BaseController { public class SysOperlogController extends BaseController {
private final ISysOperLogService operLogService; private final ISysOperLogService operLogService;
@RequiresPermissions("system:operlog:list") @RequiresPermissions("system:operlog:list")
@GetMapping("/list") @GetMapping("/list")
public TableDataInfo list(SysOperLog operLog) { public TableDataInfo list(SysOperLog operLog) {
startPage(); startPage();
List<SysOperLog> list = operLogService.selectOperLogList(operLog); List<SysOperLog> list = operLogService.selectOperLogList(operLog);
return getDataTable(list); return getDataTable(list);
} }
@Log(title = "操作日志", businessType = BusinessType.EXPORT) @Log(title = "操作日志", businessType = BusinessType.EXPORT)
@RequiresPermissions("system:operlog:export") @RequiresPermissions("system:operlog:export")
@PostMapping("/export") @PostMapping("/export")
public void export(HttpServletResponse response, SysOperLog operLog) { public void export(HttpServletResponse response, SysOperLog operLog) {
List<SysOperLog> list = operLogService.selectOperLogList(operLog); List<SysOperLog> list = operLogService.selectOperLogList(operLog);
ExcelUtil<SysOperLog> util = new ExcelUtil<SysOperLog>(SysOperLog.class); ExcelUtil.exportExcel(list, "操作日志", SysOperLog.class, response);
util.exportExcel(response, list, "操作日志"); }
}
@Log(title = "操作日志", businessType = BusinessType.DELETE)
@Log(title = "操作日志", businessType = BusinessType.DELETE) @RequiresPermissions("system:operlog:remove")
@RequiresPermissions("system:operlog:remove") @DeleteMapping("/{operIds}")
@DeleteMapping("/{operIds}") public AjaxResult remove(@PathVariable Long[] operIds) {
public AjaxResult remove(@PathVariable Long[] operIds) { return toAjax(operLogService.deleteOperLogByIds(operIds));
return toAjax(operLogService.deleteOperLogByIds(operIds)); }
}
@RequiresPermissions("system:operlog:remove")
@RequiresPermissions("system:operlog:remove") @Log(title = "操作日志", businessType = BusinessType.CLEAN)
@Log(title = "操作日志", businessType = BusinessType.CLEAN) @DeleteMapping("/clean")
@DeleteMapping("/clean") public AjaxResult clean() {
public AjaxResult clean() { operLogService.cleanOperLog();
operLogService.cleanOperLog(); return AjaxResult.success();
return AjaxResult.success(); }
}
@InnerAuth
@InnerAuth @PostMapping
@PostMapping public AjaxResult add(@RequestBody SysOperLog operLog) {
public AjaxResult add(@RequestBody SysOperLog operLog) { return toAjax(operLogService.insertOperlog(operLog));
return toAjax(operLogService.insertOperlog(operLog)); }
} }
}

225
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/controller/SysPostController.java
View File

@ -1,113 +1,112 @@
package com.ruoyi.system.controller; package com.ruoyi.system.controller;
import com.ruoyi.common.core.constant.UserConstants; import com.ruoyi.common.core.constant.UserConstants;
import com.ruoyi.common.core.utils.poi.ExcelUtil; import com.ruoyi.common.core.web.controller.BaseController;
import com.ruoyi.common.core.web.controller.BaseController; import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.core.web.domain.AjaxResult; import com.ruoyi.common.core.web.page.TableDataInfo;
import com.ruoyi.common.core.web.page.TableDataInfo; import com.ruoyi.common.excel.utils.ExcelUtil;
import com.ruoyi.common.log.annotation.Log; import com.ruoyi.common.log.annotation.Log;
import com.ruoyi.common.log.enums.BusinessType; import com.ruoyi.common.log.enums.BusinessType;
import com.ruoyi.common.security.annotation.RequiresPermissions; import com.ruoyi.common.security.annotation.RequiresPermissions;
import com.ruoyi.common.security.utils.SecurityUtils; import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.system.domain.SysPost; import com.ruoyi.system.domain.SysPost;
import com.ruoyi.system.service.ISysPostService; import com.ruoyi.system.service.ISysPostService;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated; import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import java.util.List; import java.util.List;
/** /**
* 岗位信息操作处理 * 岗位信息操作处理
* *
* @author ruoyi * @author ruoyi
*/ */
@RequiredArgsConstructor(onConstructor_ = @Autowired) @RequiredArgsConstructor(onConstructor_ = @Autowired)
@RestController @RestController
@RequestMapping("/post") @RequestMapping("/post")
public class SysPostController extends BaseController { public class SysPostController extends BaseController {
private final ISysPostService postService; private final ISysPostService postService;
/** /**
* 获取岗位列表 * 获取岗位列表
*/ */
@RequiresPermissions("system:post:list") @RequiresPermissions("system:post:list")
@GetMapping("/list") @GetMapping("/list")
public TableDataInfo list(SysPost post) { public TableDataInfo list(SysPost post) {
startPage(); startPage();
List<SysPost> list = postService.selectPostList(post); List<SysPost> list = postService.selectPostList(post);
return getDataTable(list); return getDataTable(list);
} }
@Log(title = "岗位管理", businessType = BusinessType.EXPORT) @Log(title = "岗位管理", businessType = BusinessType.EXPORT)
@RequiresPermissions("system:post:export") @RequiresPermissions("system:post:export")
@PostMapping("/export") @PostMapping("/export")
public void export(HttpServletResponse response, SysPost post) { public void export(HttpServletResponse response, SysPost post) {
List<SysPost> list = postService.selectPostList(post); List<SysPost> list = postService.selectPostList(post);
ExcelUtil<SysPost> util = new ExcelUtil<SysPost>(SysPost.class); ExcelUtil.exportExcel(list, "岗位数据", SysPost.class, response);
util.exportExcel(response, list, "岗位数据"); }
}
/**
/** * 根据岗位编号获取详细信息
* 根据岗位编号获取详细信息 */
*/ @RequiresPermissions("system:post:query")
@RequiresPermissions("system:post:query") @GetMapping(value = "/{postId}")
@GetMapping(value = "/{postId}") public AjaxResult getInfo(@PathVariable Long postId) {
public AjaxResult getInfo(@PathVariable Long postId) { return AjaxResult.success(postService.selectPostById(postId));
return AjaxResult.success(postService.selectPostById(postId)); }
}
/**
/** * 新增岗位
* 新增岗位 */
*/ @RequiresPermissions("system:post:add")
@RequiresPermissions("system:post:add") @Log(title = "岗位管理", businessType = BusinessType.INSERT)
@Log(title = "岗位管理", businessType = BusinessType.INSERT) @PostMapping
@PostMapping public AjaxResult add(@Validated @RequestBody SysPost post) {
public AjaxResult add(@Validated @RequestBody SysPost post) { if (UserConstants.NOT_UNIQUE.equals(postService.checkPostNameUnique(post))) {
if (UserConstants.NOT_UNIQUE.equals(postService.checkPostNameUnique(post))) { return AjaxResult.error("新增岗位'" + post.getPostName() + "'失败，岗位名称已存在");
return AjaxResult.error("新增岗位'" + post.getPostName() + "'失败，岗位名称已存在"); } else if (UserConstants.NOT_UNIQUE.equals(postService.checkPostCodeUnique(post))) {
} else if (UserConstants.NOT_UNIQUE.equals(postService.checkPostCodeUnique(post))) { return AjaxResult.error("新增岗位'" + post.getPostName() + "'失败，岗位编码已存在");
return AjaxResult.error("新增岗位'" + post.getPostName() + "'失败，岗位编码已存在"); }
} post.setCreateBy(SecurityUtils.getUsername());
post.setCreateBy(SecurityUtils.getUsername()); return toAjax(postService.insertPost(post));
return toAjax(postService.insertPost(post)); }
}
/**
/** * 修改岗位
* 修改岗位 */
*/ @RequiresPermissions("system:post:edit")
@RequiresPermissions("system:post:edit") @Log(title = "岗位管理", businessType = BusinessType.UPDATE)
@Log(title = "岗位管理", businessType = BusinessType.UPDATE) @PutMapping
@PutMapping public AjaxResult edit(@Validated @RequestBody SysPost post) {
public AjaxResult edit(@Validated @RequestBody SysPost post) { if (UserConstants.NOT_UNIQUE.equals(postService.checkPostNameUnique(post))) {
if (UserConstants.NOT_UNIQUE.equals(postService.checkPostNameUnique(post))) { return AjaxResult.error("修改岗位'" + post.getPostName() + "'失败，岗位名称已存在");
return AjaxResult.error("修改岗位'" + post.getPostName() + "'失败，岗位名称已存在"); } else if (UserConstants.NOT_UNIQUE.equals(postService.checkPostCodeUnique(post))) {
} else if (UserConstants.NOT_UNIQUE.equals(postService.checkPostCodeUnique(post))) { return AjaxResult.error("修改岗位'" + post.getPostName() + "'失败，岗位编码已存在");
return AjaxResult.error("修改岗位'" + post.getPostName() + "'失败，岗位编码已存在"); }
} post.setUpdateBy(SecurityUtils.getUsername());
post.setUpdateBy(SecurityUtils.getUsername()); return toAjax(postService.updatePost(post));
return toAjax(postService.updatePost(post)); }
}
/**
/** * 删除岗位
* 删除岗位 */
*/ @RequiresPermissions("system:post:remove")
@RequiresPermissions("system:post:remove") @Log(title = "岗位管理", businessType = BusinessType.DELETE)
@Log(title = "岗位管理", businessType = BusinessType.DELETE) @DeleteMapping("/{postIds}")
@DeleteMapping("/{postIds}") public AjaxResult remove(@PathVariable Long[] postIds) {
public AjaxResult remove(@PathVariable Long[] postIds) { return toAjax(postService.deletePostByIds(postIds));
return toAjax(postService.deletePostByIds(postIds)); }
}
/**
/** * 获取岗位选择框列表
* 获取岗位选择框列表 */
*/ @GetMapping("/optionselect")
@GetMapping("/optionselect") public AjaxResult optionselect() {
public AjaxResult optionselect() { List<SysPost> posts = postService.selectPostAll();
List<SysPost> posts = postService.selectPostAll(); return AjaxResult.success(posts);
return AjaxResult.success(posts); }
} }
}

3
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/controller/SysProfileController.java
View File

@ -1,5 +1,6 @@
package com.ruoyi.system.controller; package com.ruoyi.system.controller;
import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.constant.UserConstants; import com.ruoyi.common.core.constant.UserConstants;
import com.ruoyi.common.core.utils.StringUtils; import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.core.web.controller.BaseController; import com.ruoyi.common.core.web.controller.BaseController;
@ -118,7 +119,7 @@ public class SysProfileController extends BaseController {
if (!file.isEmpty()) { if (!file.isEmpty()) {
LoginUser loginUser = SecurityUtils.getLoginUser(); LoginUser loginUser = SecurityUtils.getLoginUser();
SysFile sysFile = remoteFileService.upload(file.getName(), file.getOriginalFilename(), file.getContentType(), file.getBytes()); SysFile sysFile = remoteFileService.upload(file.getName(), file.getOriginalFilename(), file.getContentType(), file.getBytes());
if (StringUtils.isNull(sysFile)) { if (ObjectUtil.isNull(sysFile)) {
return AjaxResult.error("文件服务异常，请联系管理员"); return AjaxResult.error("文件服务异常，请联系管理员");
} }
String url = sysFile.getUrl(); String url = sysFile.getUrl();

383
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/controller/SysRoleController.java
View File

@ -1,192 +1,191 @@
package com.ruoyi.system.controller; package com.ruoyi.system.controller;
import com.ruoyi.common.core.constant.UserConstants; import com.ruoyi.common.core.constant.UserConstants;
import com.ruoyi.common.core.utils.poi.ExcelUtil; import com.ruoyi.common.core.web.controller.BaseController;
import com.ruoyi.common.core.web.controller.BaseController; import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.core.web.domain.AjaxResult; import com.ruoyi.common.core.web.page.TableDataInfo;
import com.ruoyi.common.core.web.page.TableDataInfo; import com.ruoyi.common.excel.utils.ExcelUtil;
import com.ruoyi.common.log.annotation.Log; import com.ruoyi.common.log.annotation.Log;
import com.ruoyi.common.log.enums.BusinessType; import com.ruoyi.common.log.enums.BusinessType;
import com.ruoyi.common.security.annotation.RequiresPermissions; import com.ruoyi.common.security.annotation.RequiresPermissions;
import com.ruoyi.common.security.utils.SecurityUtils; import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.system.api.domain.SysRole; import com.ruoyi.system.api.domain.SysRole;
import com.ruoyi.system.api.domain.SysUser; import com.ruoyi.system.api.domain.SysUser;
import com.ruoyi.system.domain.SysUserRole; import com.ruoyi.system.domain.SysUserRole;
import com.ruoyi.system.service.ISysRoleService; import com.ruoyi.system.service.ISysRoleService;
import com.ruoyi.system.service.ISysUserService; import com.ruoyi.system.service.ISysUserService;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated; import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*; import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import java.util.List; import java.util.List;
/** /**
* 角色信息 * 角色信息
* *
* @author ruoyi * @author ruoyi
*/ */
@RequiredArgsConstructor(onConstructor_ = @Autowired) @RequiredArgsConstructor(onConstructor_ = @Autowired)
@RestController @RestController
@RequestMapping("/role") @RequestMapping("/role")
public class SysRoleController extends BaseController { public class SysRoleController extends BaseController {
private final ISysRoleService roleService; private final ISysRoleService roleService;
private final ISysUserService userService; private final ISysUserService userService;
@RequiresPermissions("system:role:list") @RequiresPermissions("system:role:list")
@GetMapping("/list") @GetMapping("/list")
public TableDataInfo list(SysRole role) { public TableDataInfo list(SysRole role) {
startPage(); startPage();
List<SysRole> list = roleService.selectRoleList(role); List<SysRole> list = roleService.selectRoleList(role);
return getDataTable(list); return getDataTable(list);
} }
@Log(title = "角色管理", businessType = BusinessType.EXPORT) @Log(title = "角色管理", businessType = BusinessType.EXPORT)
@RequiresPermissions("system:role:export") @RequiresPermissions("system:role:export")
@PostMapping("/export") @PostMapping("/export")
public void export(HttpServletResponse response, SysRole role) { public void export(HttpServletResponse response, SysRole role) {
List<SysRole> list = roleService.selectRoleList(role); List<SysRole> list = roleService.selectRoleList(role);
ExcelUtil<SysRole> util = new ExcelUtil<SysRole>(SysRole.class); ExcelUtil.exportExcel(list, "角色数据", SysRole.class, response);
util.exportExcel(response, list, "角色数据"); }
}
/**
/** * 根据角色编号获取详细信息
* 根据角色编号获取详细信息 */
*/ @RequiresPermissions("system:role:query")
@RequiresPermissions("system:role:query") @GetMapping(value = "/{roleId}")
@GetMapping(value = "/{roleId}") public AjaxResult getInfo(@PathVariable Long roleId) {
public AjaxResult getInfo(@PathVariable Long roleId) { roleService.checkRoleDataScope(roleId);
roleService.checkRoleDataScope(roleId); return AjaxResult.success(roleService.selectRoleById(roleId));
return AjaxResult.success(roleService.selectRoleById(roleId)); }
}
/**
/** * 新增角色
* 新增角色 */
*/ @RequiresPermissions("system:role:add")
@RequiresPermissions("system:role:add") @Log(title = "角色管理", businessType = BusinessType.INSERT)
@Log(title = "角色管理", businessType = BusinessType.INSERT) @PostMapping
@PostMapping public AjaxResult add(@Validated @RequestBody SysRole role) {
public AjaxResult add(@Validated @RequestBody SysRole role) { if (UserConstants.NOT_UNIQUE.equals(roleService.checkRoleNameUnique(role))) {
if (UserConstants.NOT_UNIQUE.equals(roleService.checkRoleNameUnique(role))) { return AjaxResult.error("新增角色'" + role.getRoleName() + "'失败，角色名称已存在");
return AjaxResult.error("新增角色'" + role.getRoleName() + "'失败，角色名称已存在"); } else if (UserConstants.NOT_UNIQUE.equals(roleService.checkRoleKeyUnique(role))) {
} else if (UserConstants.NOT_UNIQUE.equals(roleService.checkRoleKeyUnique(role))) { return AjaxResult.error("新增角色'" + role.getRoleName() + "'失败，角色权限已存在");
return AjaxResult.error("新增角色'" + role.getRoleName() + "'失败，角色权限已存在"); }
} role.setCreateBy(SecurityUtils.getUsername());
role.setCreateBy(SecurityUtils.getUsername()); return toAjax(roleService.insertRole(role));
return toAjax(roleService.insertRole(role));
}
}
/**
/** * 修改保存角色
* 修改保存角色 */
*/ @RequiresPermissions("system:role:edit")
@RequiresPermissions("system:role:edit") @Log(title = "角色管理", businessType = BusinessType.UPDATE)
@Log(title = "角色管理", businessType = BusinessType.UPDATE) @PutMapping
@PutMapping public AjaxResult edit(@Validated @RequestBody SysRole role) {
public AjaxResult edit(@Validated @RequestBody SysRole role) { roleService.checkRoleAllowed(role);
roleService.checkRoleAllowed(role); if (UserConstants.NOT_UNIQUE.equals(roleService.checkRoleNameUnique(role))) {
if (UserConstants.NOT_UNIQUE.equals(roleService.checkRoleNameUnique(role))) { return AjaxResult.error("修改角色'" + role.getRoleName() + "'失败，角色名称已存在");
return AjaxResult.error("修改角色'" + role.getRoleName() + "'失败，角色名称已存在"); } else if (UserConstants.NOT_UNIQUE.equals(roleService.checkRoleKeyUnique(role))) {
} else if (UserConstants.NOT_UNIQUE.equals(roleService.checkRoleKeyUnique(role))) { return AjaxResult.error("修改角色'" + role.getRoleName() + "'失败，角色权限已存在");
return AjaxResult.error("修改角色'" + role.getRoleName() + "'失败，角色权限已存在"); }
} role.setUpdateBy(SecurityUtils.getUsername());
role.setUpdateBy(SecurityUtils.getUsername()); return toAjax(roleService.updateRole(role));
return toAjax(roleService.updateRole(role)); }
}
/**
/** * 修改保存数据权限
* 修改保存数据权限 */
*/ @RequiresPermissions("system:role:edit")
@RequiresPermissions("system:role:edit") @Log(title = "角色管理", businessType = BusinessType.UPDATE)
@Log(title = "角色管理", businessType = BusinessType.UPDATE) @PutMapping("/dataScope")
@PutMapping("/dataScope") public AjaxResult dataScope(@RequestBody SysRole role) {
public AjaxResult dataScope(@RequestBody SysRole role) { roleService.checkRoleAllowed(role);
roleService.checkRoleAllowed(role); return toAjax(roleService.authDataScope(role));
return toAjax(roleService.authDataScope(role)); }
}
/**
/** * 状态修改
* 状态修改 */
*/ @RequiresPermissions("system:role:edit")
@RequiresPermissions("system:role:edit") @Log(title = "角色管理", businessType = BusinessType.UPDATE)
@Log(title = "角色管理", businessType = BusinessType.UPDATE) @PutMapping("/changeStatus")
@PutMapping("/changeStatus") public AjaxResult changeStatus(@RequestBody SysRole role) {
public AjaxResult changeStatus(@RequestBody SysRole role) { roleService.checkRoleAllowed(role);
roleService.checkRoleAllowed(role); role.setUpdateBy(SecurityUtils.getUsername());
role.setUpdateBy(SecurityUtils.getUsername()); return toAjax(roleService.updateRoleStatus(role));
return toAjax(roleService.updateRoleStatus(role)); }
}
/**
/** * 删除角色
* 删除角色 */
*/ @RequiresPermissions("system:role:remove")
@RequiresPermissions("system:role:remove") @Log(title = "角色管理", businessType = BusinessType.DELETE)
@Log(title = "角色管理", businessType = BusinessType.DELETE) @DeleteMapping("/{roleIds}")
@DeleteMapping("/{roleIds}") public AjaxResult remove(@PathVariable Long[] roleIds) {
public AjaxResult remove(@PathVariable Long[] roleIds) { return toAjax(roleService.deleteRoleByIds(roleIds));
return toAjax(roleService.deleteRoleByIds(roleIds)); }
}
/**
/** * 获取角色选择框列表
* 获取角色选择框列表 */
*/ @RequiresPermissions("system:role:query")
@RequiresPermissions("system:role:query") @GetMapping("/optionselect")
@GetMapping("/optionselect") public AjaxResult optionselect() {
public AjaxResult optionselect() { return AjaxResult.success(roleService.selectRoleAll());
return AjaxResult.success(roleService.selectRoleAll()); }
}
/**
/** * 查询已分配用户角色列表
* 查询已分配用户角色列表 */
*/ @RequiresPermissions("system:role:list")
@RequiresPermissions("system:role:list") @GetMapping("/authUser/allocatedList")
@GetMapping("/authUser/allocatedList") public TableDataInfo allocatedList(SysUser user) {
public TableDataInfo allocatedList(SysUser user) { startPage();
startPage(); List<SysUser> list = userService.selectAllocatedList(user);
List<SysUser> list = userService.selectAllocatedList(user); return getDataTable(list);
return getDataTable(list); }
}
/**
/** * 查询未分配用户角色列表
* 查询未分配用户角色列表 */
*/ @RequiresPermissions("system:role:list")
@RequiresPermissions("system:role:list") @GetMapping("/authUser/unallocatedList")
@GetMapping("/authUser/unallocatedList") public TableDataInfo unallocatedList(SysUser user) {
public TableDataInfo unallocatedList(SysUser user) { startPage();
startPage(); List<SysUser> list = userService.selectUnallocatedList(user);
List<SysUser> list = userService.selectUnallocatedList(user); return getDataTable(list);
return getDataTable(list); }
}
/**
/** * 取消授权用户
* 取消授权用户 */
*/ @RequiresPermissions("system:role:edit")
@RequiresPermissions("system:role:edit") @Log(title = "角色管理", businessType = BusinessType.GRANT)
@Log(title = "角色管理", businessType = BusinessType.GRANT) @PutMapping("/authUser/cancel")
@PutMapping("/authUser/cancel") public AjaxResult cancelAuthUser(@RequestBody SysUserRole userRole) {
public AjaxResult cancelAuthUser(@RequestBody SysUserRole userRole) { return toAjax(roleService.deleteAuthUser(userRole));
return toAjax(roleService.deleteAuthUser(userRole)); }
}
/**
/** * 批量取消授权用户
* 批量取消授权用户 */
*/ @RequiresPermissions("system:role:edit")
@RequiresPermissions("system:role:edit") @Log(title = "角色管理", businessType = BusinessType.GRANT)
@Log(title = "角色管理", businessType = BusinessType.GRANT) @PutMapping("/authUser/cancelAll")
@PutMapping("/authUser/cancelAll") public AjaxResult cancelAuthUserAll(Long roleId, Long[] userIds) {
public AjaxResult cancelAuthUserAll(Long roleId, Long[] userIds) { return toAjax(roleService.deleteAuthUsers(roleId, userIds));
return toAjax(roleService.deleteAuthUsers(roleId, userIds)); }
}
/**
/** * 批量选择用户授权
* 批量选择用户授权 */
*/ @RequiresPermissions("system:role:edit")
@RequiresPermissions("system:role:edit") @Log(title = "角色管理", businessType = BusinessType.GRANT)
@Log(title = "角色管理", businessType = BusinessType.GRANT) @PutMapping("/authUser/selectAll")
@PutMapping("/authUser/selectAll") public AjaxResult selectAuthUserAll(Long roleId, Long[] userIds) {
public AjaxResult selectAuthUserAll(Long roleId, Long[] userIds) { return toAjax(roleService.insertAuthUsers(roleId, userIds));
return toAjax(roleService.insertAuthUsers(roleId, userIds)); }
} }
}

458
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/controller/SysUserController.java
View File

@ -1,223 +1,235 @@
package com.ruoyi.system.controller; package com.ruoyi.system.controller;
import com.ruoyi.common.core.constant.UserConstants; import cn.hutool.core.bean.BeanUtil;
import com.ruoyi.common.core.utils.StringUtils; import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.utils.poi.ExcelUtil; import com.ruoyi.common.core.constant.UserConstants;
import com.ruoyi.common.core.web.controller.BaseController; import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.core.web.domain.AjaxResult; import com.ruoyi.common.core.web.controller.BaseController;
import com.ruoyi.common.core.web.page.TableDataInfo; import com.ruoyi.common.core.web.domain.AjaxResult;
import com.ruoyi.common.log.annotation.Log; import com.ruoyi.common.core.web.page.TableDataInfo;
import com.ruoyi.common.log.enums.BusinessType; import com.ruoyi.common.excel.core.ExcelResult;
import com.ruoyi.common.security.annotation.RequiresPermissions; import com.ruoyi.common.excel.utils.ExcelUtil;
import com.ruoyi.common.security.utils.SecurityUtils; import com.ruoyi.common.log.annotation.Log;
import com.ruoyi.system.api.domain.SysRole; import com.ruoyi.common.log.enums.BusinessType;
import com.ruoyi.system.api.domain.SysUser; import com.ruoyi.common.security.annotation.RequiresPermissions;
import com.ruoyi.system.service.*; import com.ruoyi.common.security.utils.SecurityUtils;
import lombok.RequiredArgsConstructor; import com.ruoyi.system.api.domain.SysDept;
import org.apache.commons.lang3.ArrayUtils; import com.ruoyi.system.api.domain.SysRole;
import org.springframework.beans.factory.annotation.Autowired; import com.ruoyi.system.api.domain.SysUser;
import org.springframework.validation.annotation.Validated; import com.ruoyi.system.domain.vo.SysUserExportVo;
import org.springframework.web.bind.annotation.*; import com.ruoyi.system.domain.vo.SysUserImportVo;
import org.springframework.web.multipart.MultipartFile; import com.ruoyi.system.listener.SysUserImportListener;
import com.ruoyi.system.service.*;
import javax.servlet.http.HttpServletResponse; import lombok.RequiredArgsConstructor;
import java.io.IOException; import org.apache.commons.lang3.ArrayUtils;
import java.util.List; import org.springframework.beans.factory.annotation.Autowired;
import java.util.Set; import org.springframework.validation.annotation.Validated;
import java.util.stream.Collectors; import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
/**
* 用户信息 import javax.servlet.http.HttpServletResponse;
* import java.io.IOException;
* @author ruoyi import java.util.ArrayList;
*/ import java.util.List;
@RequiredArgsConstructor(onConstructor_ = @Autowired) import java.util.Set;
@RestController import java.util.stream.Collectors;
@RequestMapping("/user")
public class SysUserController extends BaseController { /**
* 用户信息
private final ISysUserService userService; *
private final ISysRoleService roleService; * @author ruoyi
private final ISysPostService postService; */
private final ISysPermissionService permissionService; @RequiredArgsConstructor(onConstructor_ = @Autowired)
private final ISysConfigService configService; @RestController
@RequestMapping("/user")
/** public class SysUserController extends BaseController {
* 获取用户列表
*/ private final ISysUserService userService;
@RequiresPermissions("system:user:list") private final ISysRoleService roleService;
@GetMapping("/list") private final ISysPostService postService;
public TableDataInfo list(SysUser user) { private final ISysPermissionService permissionService;
startPage(); private final ISysConfigService configService;
List<SysUser> list = userService.selectUserList(user);
return getDataTable(list); /**
} * 获取用户列表
*/
@Log(title = "用户管理", businessType = BusinessType.EXPORT) @RequiresPermissions("system:user:list")
@RequiresPermissions("system:user:export") @GetMapping("/list")
@PostMapping("/export") public TableDataInfo list(SysUser user) {
public void export(HttpServletResponse response, SysUser user) { startPage();
List<SysUser> list = userService.selectUserList(user); List<SysUser> list = userService.selectUserList(user);
ExcelUtil<SysUser> util = new ExcelUtil<SysUser>(SysUser.class); return getDataTable(list);
util.exportExcel(response, list, "用户数据"); }
}
@Log(title = "用户管理", businessType = BusinessType.EXPORT)
@Log(title = "用户管理", businessType = BusinessType.IMPORT) @RequiresPermissions("system:user:export")
@RequiresPermissions("system:user:import") @PostMapping("/export")
@PostMapping("/importData") public void export(HttpServletResponse response, SysUser user) {
public AjaxResult importData(MultipartFile file, boolean updateSupport) throws Exception { List<SysUser> list = userService.selectUserList(user);
ExcelUtil<SysUser> util = new ExcelUtil<SysUser>(SysUser.class); List<SysUserExportVo> listVo = BeanUtil.copyToList(list, SysUserExportVo.class);
List<SysUser> userList = util.importExcel(file.getInputStream()); for (int i = 0; i < list.size(); i++) {
String operName = SecurityUtils.getUsername(); SysDept dept = list.get(i).getDept();
String message = userService.importUser(userList, updateSupport, operName); SysUserExportVo vo = listVo.get(i);
return AjaxResult.success(message); if (ObjectUtil.isNotEmpty(dept)) {
} vo.setDeptName(dept.getDeptName());
vo.setLeader(dept.getLeader());
@PostMapping("/importTemplate") }
public void importTemplate(HttpServletResponse response) throws IOException { }
ExcelUtil<SysUser> util = new ExcelUtil<SysUser>(SysUser.class); ExcelUtil.exportExcel(listVo, "用户数据", SysUserExportVo.class, response);
util.importTemplateExcel(response, "用户数据"); }
}
@Log(title = "用户管理", businessType = BusinessType.IMPORT)
/** @RequiresPermissions("system:user:import")
* 获取用户信息 @PostMapping("/importData")
* public AjaxResult importData(MultipartFile file, boolean updateSupport) throws Exception {
* @return 用户信息 ExcelResult<SysUserImportVo> result = ExcelUtil.importExcel(file.getInputStream(), SysUserImportVo.class, new SysUserImportListener(updateSupport));
*/ return AjaxResult.success(result.getAnalysis());
@GetMapping("getInfo") }
public AjaxResult getInfo() {
Long userId = SecurityUtils.getUserId(); @PostMapping("/importTemplate")
// 角色集合 public void importTemplate(HttpServletResponse response) throws IOException {
Set<String> roles = permissionService.getRolePermission(userId); ExcelUtil.exportExcel(new ArrayList<>(), "用户数据", SysUserImportVo.class, response);
// 权限集合 }
Set<String> permissions = permissionService.getMenuPermission(userId);
AjaxResult ajax = AjaxResult.success(); /**
ajax.put("user", userService.selectUserById(userId)); * 获取用户信息
ajax.put("roles", roles); *
ajax.put("permissions", permissions); * @return 用户信息
return ajax; */
} @GetMapping("getInfo")
public AjaxResult getInfo() {
/** Long userId = SecurityUtils.getUserId();
* 根据用户编号获取详细信息 // 角色集合
*/ Set<String> roles = permissionService.getRolePermission(userId);
@RequiresPermissions("system:user:query") // 权限集合
@GetMapping(value = {"/", "/{userId}"}) Set<String> permissions = permissionService.getMenuPermission(userId);
public AjaxResult getInfo(@PathVariable(value = "userId", required = false) Long userId) { AjaxResult ajax = AjaxResult.success();
userService.checkUserDataScope(userId); ajax.put("user", userService.selectUserById(userId));
AjaxResult ajax = AjaxResult.success(); ajax.put("roles", roles);
List<SysRole> roles = roleService.selectRoleAll(); ajax.put("permissions", permissions);
ajax.put("roles", SysUser.isAdmin(userId) ? roles : roles.stream().filter(r -> !r.isAdmin()).collect(Collectors.toList())); return ajax;
ajax.put("posts", postService.selectPostAll()); }
if (StringUtils.isNotNull(userId)) {
SysUser sysUser = userService.selectUserById(userId); /**
ajax.put(AjaxResult.DATA_TAG, sysUser); * 根据用户编号获取详细信息
ajax.put("postIds", postService.selectPostListByUserId(userId)); */
ajax.put("roleIds", sysUser.getRoles().stream().map(SysRole::getRoleId).collect(Collectors.toList())); @RequiresPermissions("system:user:query")
} @GetMapping(value = {"/", "/{userId}"})
return ajax; public AjaxResult getInfo(@PathVariable(value = "userId", required = false) Long userId) {
} userService.checkUserDataScope(userId);
AjaxResult ajax = AjaxResult.success();
/** List<SysRole> roles = roleService.selectRoleAll();
* 新增用户 ajax.put("roles", SysUser.isAdmin(userId) ? roles : roles.stream().filter(r -> !r.isAdmin()).collect(Collectors.toList()));
*/ ajax.put("posts", postService.selectPostAll());
@RequiresPermissions("system:user:add") if (ObjectUtil.isNotNull(userId)) {
@Log(title = "用户管理", businessType = BusinessType.INSERT) SysUser sysUser = userService.selectUserById(userId);
@PostMapping ajax.put(AjaxResult.DATA_TAG, sysUser);
public AjaxResult add(@Validated @RequestBody SysUser user) { ajax.put("postIds", postService.selectPostListByUserId(userId));
if (UserConstants.NOT_UNIQUE.equals(userService.checkUserNameUnique(user.getUserName()))) { ajax.put("roleIds", sysUser.getRoles().stream().map(SysRole::getRoleId).collect(Collectors.toList()));
return AjaxResult.error("新增用户'" + user.getUserName() + "'失败，登录账号已存在"); }
} else if (StringUtils.isNotEmpty(user.getPhonenumber()) return ajax;
&& UserConstants.NOT_UNIQUE.equals(userService.checkPhoneUnique(user))) { }
return AjaxResult.error("新增用户'" + user.getUserName() + "'失败，手机号码已存在");
} else if (StringUtils.isNotEmpty(user.getEmail()) /**
&& UserConstants.NOT_UNIQUE.equals(userService.checkEmailUnique(user))) { * 新增用户
return AjaxResult.error("新增用户'" + user.getUserName() + "'失败，邮箱账号已存在"); */
} @RequiresPermissions("system:user:add")
user.setCreateBy(SecurityUtils.getUsername()); @Log(title = "用户管理", businessType = BusinessType.INSERT)
user.setPassword(SecurityUtils.encryptPassword(user.getPassword())); @PostMapping
return toAjax(userService.insertUser(user)); public AjaxResult add(@Validated @RequestBody SysUser user) {
} if (UserConstants.NOT_UNIQUE.equals(userService.checkUserNameUnique(user.getUserName()))) {
return AjaxResult.error("新增用户'" + user.getUserName() + "'失败，登录账号已存在");
/** } else if (StringUtils.isNotEmpty(user.getPhonenumber())
* 修改用户 && UserConstants.NOT_UNIQUE.equals(userService.checkPhoneUnique(user))) {
*/ return AjaxResult.error("新增用户'" + user.getUserName() + "'失败，手机号码已存在");
@RequiresPermissions("system:user:edit") } else if (StringUtils.isNotEmpty(user.getEmail())
@Log(title = "用户管理", businessType = BusinessType.UPDATE) && UserConstants.NOT_UNIQUE.equals(userService.checkEmailUnique(user))) {
@PutMapping return AjaxResult.error("新增用户'" + user.getUserName() + "'失败，邮箱账号已存在");
public AjaxResult edit(@Validated @RequestBody SysUser user) { }
userService.checkUserAllowed(user); user.setCreateBy(SecurityUtils.getUsername());
if (StringUtils.isNotEmpty(user.getPhonenumber()) user.setPassword(SecurityUtils.encryptPassword(user.getPassword()));
&& UserConstants.NOT_UNIQUE.equals(userService.checkPhoneUnique(user))) { return toAjax(userService.insertUser(user));
return AjaxResult.error("修改用户'" + user.getUserName() + "'失败，手机号码已存在"); }
} else if (StringUtils.isNotEmpty(user.getEmail())
&& UserConstants.NOT_UNIQUE.equals(userService.checkEmailUnique(user))) { /**
return AjaxResult.error("修改用户'" + user.getUserName() + "'失败，邮箱账号已存在"); * 修改用户
} */
user.setUpdateBy(SecurityUtils.getUsername()); @RequiresPermissions("system:user:edit")
return toAjax(userService.updateUser(user)); @Log(title = "用户管理", businessType = BusinessType.UPDATE)
} @PutMapping
public AjaxResult edit(@Validated @RequestBody SysUser user) {
/** userService.checkUserAllowed(user);
* 删除用户 if (StringUtils.isNotEmpty(user.getPhonenumber())
*/ && UserConstants.NOT_UNIQUE.equals(userService.checkPhoneUnique(user))) {
@RequiresPermissions("system:user:remove") return AjaxResult.error("修改用户'" + user.getUserName() + "'失败，手机号码已存在");
@Log(title = "用户管理", businessType = BusinessType.DELETE) } else if (StringUtils.isNotEmpty(user.getEmail())
@DeleteMapping("/{userIds}") && UserConstants.NOT_UNIQUE.equals(userService.checkEmailUnique(user))) {
public AjaxResult remove(@PathVariable Long[] userIds) { return AjaxResult.error("修改用户'" + user.getUserName() + "'失败，邮箱账号已存在");
if (ArrayUtils.contains(userIds, SecurityUtils.getUserId())) { }
return AjaxResult.error("当前用户不能删除"); user.setUpdateBy(SecurityUtils.getUsername());
} return toAjax(userService.updateUser(user));
return toAjax(userService.deleteUserByIds(userIds)); }
}
/**
/** * 删除用户
* 重置密码 */
*/ @RequiresPermissions("system:user:remove")
@RequiresPermissions("system:user:edit") @Log(title = "用户管理", businessType = BusinessType.DELETE)
@Log(title = "用户管理", businessType = BusinessType.UPDATE) @DeleteMapping("/{userIds}")
@PutMapping("/resetPwd") public AjaxResult remove(@PathVariable Long[] userIds) {
public AjaxResult resetPwd(@RequestBody SysUser user) { if (ArrayUtils.contains(userIds, SecurityUtils.getUserId())) {
userService.checkUserAllowed(user); return AjaxResult.error("当前用户不能删除");
user.setPassword(SecurityUtils.encryptPassword(user.getPassword())); }
user.setUpdateBy(SecurityUtils.getUsername()); return toAjax(userService.deleteUserByIds(userIds));
return toAjax(userService.resetPwd(user)); }
}
/**
/** * 重置密码
* 状态修改 */
*/ @RequiresPermissions("system:user:edit")
@RequiresPermissions("system:user:edit") @Log(title = "用户管理", businessType = BusinessType.UPDATE)
@Log(title = "用户管理", businessType = BusinessType.UPDATE) @PutMapping("/resetPwd")
@PutMapping("/changeStatus") public AjaxResult resetPwd(@RequestBody SysUser user) {
public AjaxResult changeStatus(@RequestBody SysUser user) { userService.checkUserAllowed(user);
userService.checkUserAllowed(user); user.setPassword(SecurityUtils.encryptPassword(user.getPassword()));
user.setUpdateBy(SecurityUtils.getUsername()); user.setUpdateBy(SecurityUtils.getUsername());
return toAjax(userService.updateUserStatus(user)); return toAjax(userService.resetPwd(user));
} }
/** /**
* 根据用户编号获取授权角色 * 状态修改
*/ */
@RequiresPermissions("system:user:query") @RequiresPermissions("system:user:edit")
@GetMapping("/authRole/{userId}") @Log(title = "用户管理", businessType = BusinessType.UPDATE)
public AjaxResult authRole(@PathVariable("userId") Long userId) { @PutMapping("/changeStatus")
AjaxResult ajax = AjaxResult.success(); public AjaxResult changeStatus(@RequestBody SysUser user) {
SysUser user = userService.selectUserById(userId); userService.checkUserAllowed(user);
List<SysRole> roles = roleService.selectRolesByUserId(userId); user.setUpdateBy(SecurityUtils.getUsername());
ajax.put("user", user); return toAjax(userService.updateUserStatus(user));
ajax.put("roles", SysUser.isAdmin(userId) ? roles : roles.stream().filter(r -> !r.isAdmin()).collect(Collectors.toList())); }
return ajax;
} /**
* 根据用户编号获取授权角色
/** */
* 用户授权角色 @RequiresPermissions("system:user:query")
*/ @GetMapping("/authRole/{userId}")
@RequiresPermissions("system:user:edit") public AjaxResult authRole(@PathVariable("userId") Long userId) {
@Log(title = "用户管理", businessType = BusinessType.GRANT) AjaxResult ajax = AjaxResult.success();
@PutMapping("/authRole") SysUser user = userService.selectUserById(userId);
public AjaxResult insertAuthRole(Long userId, Long[] roleIds) { List<SysRole> roles = roleService.selectRolesByUserId(userId);
userService.insertUserAuth(userId, roleIds); ajax.put("user", user);
return success(); ajax.put("roles", SysUser.isAdmin(userId) ? roles : roles.stream().filter(r -> !r.isAdmin()).collect(Collectors.toList()));
} return ajax;
} }
/**
* 用户授权角色
*/
@RequiresPermissions("system:user:edit")
@Log(title = "用户管理", businessType = BusinessType.GRANT)
@PutMapping("/authRole")
public AjaxResult insertAuthRole(Long userId, Long[] roleIds) {
userService.insertUserAuth(userId, roleIds);
return success();
}
}

140
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/SysConfig.java
View File

@ -1,62 +1,78 @@
package com.ruoyi.system.domain; package com.ruoyi.system.domain;
import com.ruoyi.common.core.annotation.Excel; import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.ruoyi.common.core.annotation.Excel.ColumnType; import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.core.web.domain.BaseEntity; import com.ruoyi.common.core.web.domain.BaseEntity;
import lombok.Data; import com.ruoyi.common.excel.annotation.ExcelDictFormat;
import lombok.EqualsAndHashCode; import com.ruoyi.common.excel.convert.ExcelDictConvert;
import lombok.NoArgsConstructor; import io.swagger.annotations.ApiModel;
import lombok.experimental.Accessors; import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import javax.validation.constraints.NotBlank; import lombok.EqualsAndHashCode;
import javax.validation.constraints.Size; import lombok.experimental.Accessors;
/** import javax.validation.constraints.NotBlank;
* 参数配置表 sys_config import javax.validation.constraints.Size;
*
* @author ruoyi /**
*/ * 参数配置表 sys_config
@Data *
@EqualsAndHashCode(callSuper = true) * @author Lion Li
@NoArgsConstructor */
@Accessors(chain = true)
public class SysConfig extends BaseEntity { @Data
private static final long serialVersionUID = 1L; @EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
/** @ExcelIgnoreUnannotated
* 参数主键 @ApiModel("参数配置业务对象")
*/ public class SysConfig extends BaseEntity {
@Excel(name = "参数主键", cellType = ColumnType.NUMERIC)
private Long configId; /**
* 参数主键
/** */
* 参数名称 @ApiModelProperty(value = "参数主键")
*/ @ExcelProperty(value = "参数主键")
@NotBlank(message = "参数名称不能为空") private Long configId;
@Size(min = 0, max = 100, message = "参数名称不能超过100个字符")
@Excel(name = "参数名称") /**
private String configName; * 参数名称
*/
/** @ApiModelProperty(value = "参数名称")
* 参数键名 @ExcelProperty(value = "参数名称")
*/ @NotBlank(message = "参数名称不能为空")
@NotBlank(message = "参数键名长度不能为空") @Size(min = 0, max = 100, message = "参数名称不能超过100个字符")
@Size(min = 0, max = 100, message = "参数键名长度不能超过100个字符") private String configName;
@Excel(name = "参数键名")
private String configKey; /**
* 参数键名
/** */
* 参数键值 @ApiModelProperty(value = "参数键名")
*/ @ExcelProperty(value = "参数键名")
@NotBlank(message = "参数键值不能为空") @NotBlank(message = "参数键名长度不能为空")
@Size(min = 0, max = 500, message = "参数键值长度不能超过500个字符") @Size(min = 0, max = 100, message = "参数键名长度不能超过100个字符")
@Excel(name = "参数键值") private String configKey;
private String configValue;
/**
/** * 参数键值
* 系统内置（Y是 N否） */
*/ @ApiModelProperty(value = "参数键值")
@Excel(name = "系统内置", readConverterExp = "Y=是,N=否") @ExcelProperty(value = "参数键值")
private String configType; @NotBlank(message = "参数键值不能为空")
@Size(min = 0, max = 500, message = "参数键值长度不能超过500个字符")
} private String configValue;
/**
* 系统内置（Y是 N否）
*/
@ApiModelProperty(value = "系统内置（Y是 N否）")
@ExcelProperty(value = "系统内置", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "sys_yes_no")
private String configType;
/**
* 备注
*/
@ApiModelProperty(value = "备注")
private String remark;
}

229
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/SysMenu.java
View File

@ -1,113 +1,116 @@
package com.ruoyi.system.domain; package com.ruoyi.system.domain;
import com.ruoyi.common.core.web.domain.BaseEntity; import com.ruoyi.common.core.web.domain.TreeEntity;
import lombok.Data; import io.swagger.annotations.ApiModel;
import lombok.EqualsAndHashCode; import io.swagger.annotations.ApiModelProperty;
import lombok.NoArgsConstructor; import lombok.Data;
import lombok.experimental.Accessors; import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size; import javax.validation.constraints.NotBlank;
import java.util.ArrayList; import javax.validation.constraints.Size;
import java.util.List;
/**
/** * 菜单权限表 sys_menu
* 菜单权限表 sys_menu *
* * @author Lion Li
* @author ruoyi */
*/
@Data @Data
@EqualsAndHashCode(callSuper = true) @EqualsAndHashCode(callSuper = true)
@NoArgsConstructor @Accessors(chain = true)
@Accessors(chain = true) @ApiModel("菜单权限业务对象")
public class SysMenu extends BaseEntity { public class SysMenu extends TreeEntity {
private static final long serialVersionUID = 1L;
/**
/** * 菜单ID
* 菜单ID */
*/ @ApiModelProperty(value = "菜单ID")
private Long menuId; private Long menuId;
/** /**
* 菜单名称 * 菜单名称
*/ */
@NotBlank(message = "菜单名称不能为空") @ApiModelProperty(value = "菜单名称")
@Size(min = 0, max = 50, message = "菜单名称长度不能超过50个字符") @NotBlank(message = "菜单名称不能为空")
private String menuName; @Size(min = 0, max = 50, message = "菜单名称长度不能超过50个字符")
private String menuName;
/**
* 父菜单名称 /**
*/ * 显示顺序
private String parentName; */
@ApiModelProperty(value = "显示顺序")
/** @NotBlank(message = "显示顺序不能为空")
* 父菜单ID private String orderNum;
*/
private Long parentId; /**
* 路由地址
/** */
* 显示顺序 @ApiModelProperty(value = "路由地址")
*/ @Size(min = 0, max = 200, message = "路由地址不能超过200个字符")
@NotBlank(message = "显示顺序不能为空") private String path;
private String orderNum;
/**
/** * 组件路径
* 路由地址 */
*/ @ApiModelProperty(value = "组件路径")
@Size(min = 0, max = 200, message = "路由地址不能超过200个字符") @Size(min = 0, max = 200, message = "组件路径不能超过255个字符")
private String path; private String component;
/** /**
* 组件路径 * 路由参数
*/ */
@Size(min = 0, max = 200, message = "组件路径不能超过255个字符") @ApiModelProperty(value = "路由参数")
private String component; private String query;
/** /**
* 路由参数 * 是否为外链（0是 1否）
*/ */
private String query; @ApiModelProperty(value = "是否为外链（0是 1否）")
private String isFrame;
/**
* 是否为外链（0是 1否） /**
*/ * 是否缓存（0缓存 1不缓存）
private String isFrame; */
@ApiModelProperty(value = "是否缓存（0缓存 1不缓存）")
/** private String isCache;
* 是否缓存（0缓存 1不缓存）
*/ /**
private String isCache; * 类型（M目录 C菜单 F按钮）
*/
/** @ApiModelProperty(value = "类型（M目录 C菜单 F按钮）")
* 类型（M目录 C菜单 F按钮） @NotBlank(message = "菜单类型不能为空")
*/ private String menuType;
@NotBlank(message = "菜单类型不能为空")
private String menuType; /**
* 显示状态（0显示 1隐藏）
/** */
* 显示状态（0显示 1隐藏） @ApiModelProperty(value = "显示状态（0显示 1隐藏）")
*/ private String visible;
private String visible;
/**
/** * 菜单状态（0显示 1隐藏）
* 菜单状态（0显示 1隐藏） */
*/ @ApiModelProperty(value = "菜单状态（0显示 1隐藏）")
private String status; private String status;
/** /**
* 权限字符串 * 权限字符串
*/ */
@Size(min = 0, max = 100, message = "权限标识长度不能超过100个字符") @ApiModelProperty(value = "权限字符串")
private String perms; @Size(min = 0, max = 100, message = "权限标识长度不能超过100个字符")
private String perms;
/**
* 菜单图标 /**
*/ * 菜单图标
private String icon; */
@ApiModelProperty(value = "菜单图标")
/** private String icon;
* 子菜单
*/ /**
private List<SysMenu> children = new ArrayList<SysMenu>(); * 备注
*/
} @ApiModelProperty(value = "备注")
private String remark;
}

116
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/SysNotice.java
View File

@ -1,53 +1,63 @@
package com.ruoyi.system.domain; package com.ruoyi.system.domain;
import com.ruoyi.common.core.web.domain.BaseEntity; import com.ruoyi.common.core.web.domain.BaseEntity;
import com.ruoyi.common.core.xss.Xss; import com.ruoyi.common.core.xss.Xss;
import lombok.Data; import io.swagger.annotations.ApiModelProperty;
import lombok.EqualsAndHashCode; import lombok.Data;
import lombok.NoArgsConstructor; import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors; import lombok.experimental.Accessors;
import javax.validation.constraints.NotBlank; import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size; import javax.validation.constraints.Size;
/**
* 通知公告表 sys_notice /**
* * 通知公告表 sys_notice
* @author ruoyi *
*/ * @author Lion Li
@Data */
@EqualsAndHashCode(callSuper = true) @Data
@NoArgsConstructor @EqualsAndHashCode(callSuper = true)
@Accessors(chain = true) @Accessors(chain = true)
public class SysNotice extends BaseEntity { public class SysNotice extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
/** * 公告ID
* 公告ID */
*/ @ApiModelProperty(value = "公告ID")
private Long noticeId; private Long noticeId;
/** /**
* 公告标题 * 公告标题
*/ */
@Xss(message = "公告标题不能包含脚本字符") @Xss(message = "公告标题不能包含脚本字符")
@NotBlank(message = "公告标题不能为空") @ApiModelProperty(value = "公告标题")
@Size(min = 0, max = 50, message = "公告标题不能超过50个字符") @NotBlank(message = "公告标题不能为空")
private String noticeTitle; @Size(min = 0, max = 50, message = "公告标题不能超过50个字符")
private String noticeTitle;
/**
* 公告类型（1通知 2公告） /**
*/ * 公告类型（1通知 2公告）
private String noticeType; */
@ApiModelProperty(value = "公告类型（1通知 2公告）")
/** private String noticeType;
* 公告内容
*/ /**
private String noticeContent; * 公告内容
*/
/** @ApiModelProperty(value = "公告内容")
* 公告状态（0正常 1关闭） private String noticeContent;
*/
private String status; /**
* 公告状态（0正常 1关闭）
} */
@ApiModelProperty(value = "公告状态（0正常 1关闭）")
private String status;
/**
* 备注
*/
@ApiModelProperty(value = "备注")
private String remark;
}

149
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/SysPost.java
View File

@ -1,66 +1,83 @@
package com.ruoyi.system.domain; package com.ruoyi.system.domain;
import com.ruoyi.common.core.annotation.Excel; import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.ruoyi.common.core.annotation.Excel.ColumnType; import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.core.web.domain.BaseEntity; import com.ruoyi.common.core.web.domain.BaseEntity;
import lombok.Data; import com.ruoyi.common.excel.annotation.ExcelDictFormat;
import lombok.EqualsAndHashCode; import com.ruoyi.common.excel.convert.ExcelDictConvert;
import lombok.NoArgsConstructor; import io.swagger.annotations.ApiModel;
import lombok.experimental.Accessors; import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import javax.validation.constraints.NotBlank; import lombok.EqualsAndHashCode;
import javax.validation.constraints.Size; import lombok.experimental.Accessors;
/** import javax.validation.constraints.NotBlank;
* 岗位表 sys_post import javax.validation.constraints.Size;
*
* @author ruoyi /**
*/ * 岗位表 sys_post
@Data *
@EqualsAndHashCode(callSuper = true) * @author Lion Li
@NoArgsConstructor */
@Accessors(chain = true)
public class SysPost extends BaseEntity { @Data
private static final long serialVersionUID = 1L; @EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
/** @ExcelIgnoreUnannotated
* 岗位序号 @ApiModel("岗位信息业务对象")
*/ public class SysPost extends BaseEntity {
@Excel(name = "岗位序号", cellType = ColumnType.NUMERIC)
private Long postId; /**
* 岗位序号
/** */
* 岗位编码 @ApiModelProperty(value = "岗位序号")
*/ @ExcelProperty(value = "岗位序号")
@NotBlank(message = "岗位编码不能为空") private Long postId;
@Size(min = 0, max = 64, message = "岗位编码长度不能超过64个字符")
@Excel(name = "岗位编码") /**
private String postCode; * 岗位编码
*/
/** @ApiModelProperty(value = "岗位编码")
* 岗位名称 @ExcelProperty(value = "岗位编码")
*/ @NotBlank(message = "岗位编码不能为空")
@NotBlank(message = "岗位名称不能为空") @Size(min = 0, max = 64, message = "岗位编码长度不能超过64个字符")
@Size(min = 0, max = 50, message = "岗位名称长度不能超过50个字符") private String postCode;
@Excel(name = "岗位名称")
private String postName; /**
* 岗位名称
/** */
* 岗位排序 @ApiModelProperty(value = "岗位名称")
*/ @ExcelProperty(value = "岗位名称")
@NotBlank(message = "显示顺序不能为空") @NotBlank(message = "岗位名称不能为空")
@Excel(name = "岗位排序") @Size(min = 0, max = 50, message = "岗位名称长度不能超过50个字符")
private String postSort; private String postName;
/** /**
* 状态（0正常 1停用） * 岗位排序
*/ */
@Excel(name = "状态", readConverterExp = "0=正常,1=停用") @ApiModelProperty(value = "岗位排序")
private String status; @ExcelProperty(value = "岗位排序")
@NotBlank(message = "显示顺序不能为空")
/** private String postSort;
* 用户是否存在此岗位标识 默认不存在
*/ /**
private boolean flag = false; * 状态（0正常 1停用）
*/
} @ApiModelProperty(value = "状态（0正常 1停用）")
@ExcelProperty(value = "状态", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "sys_common_status")
private String status;
/**
* 备注
*/
@ApiModelProperty(value = "备注")
private String remark;
/**
* 用户是否存在此岗位标识 默认不存在
*/
@ApiModelProperty(value = "用户是否存在此岗位标识 默认不存在")
private boolean flag = false;
}

58
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/SysRoleDept.java
View File

@ -1,27 +1,31 @@
package com.ruoyi.system.domain; package com.ruoyi.system.domain;
import lombok.Data; import io.swagger.annotations.ApiModel;
import lombok.NoArgsConstructor; import io.swagger.annotations.ApiModelProperty;
import lombok.experimental.Accessors; import lombok.Data;
import lombok.experimental.Accessors;
/**
* 角色和部门关联 sys_role_dept /**
* * 角色和部门关联 sys_role_dept
* @author ruoyi *
*/ * @author Lion Li
@Data */
@NoArgsConstructor
@Accessors(chain = true) @Data
public class SysRoleDept { @Accessors(chain = true)
@ApiModel("角色和部门关联")
/** public class SysRoleDept {
* 角色ID
*/ /**
private Long roleId; * 角色ID
*/
/** @ApiModelProperty(value = "角色ID")
* 部门ID private Long roleId;
*/
private Long deptId; /**
* 部门ID
} */
@ApiModelProperty(value = "部门ID")
private Long deptId;
}

58
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/SysRoleMenu.java
View File

@ -1,27 +1,31 @@
package com.ruoyi.system.domain; package com.ruoyi.system.domain;
import lombok.Data; import io.swagger.annotations.ApiModel;
import lombok.NoArgsConstructor; import io.swagger.annotations.ApiModelProperty;
import lombok.experimental.Accessors; import lombok.Data;
import lombok.experimental.Accessors;
/**
* 角色和菜单关联 sys_role_menu /**
* * 角色和菜单关联 sys_role_menu
* @author ruoyi *
*/ * @author Lion Li
@Data */
@NoArgsConstructor
@Accessors(chain = true) @Data
public class SysRoleMenu { @Accessors(chain = true)
@ApiModel("角色和菜单关联")
/** public class SysRoleMenu {
* 角色ID
*/ /**
private Long roleId; * 角色ID
*/
/** @ApiModelProperty(value = "角色ID")
* 菜单ID private Long roleId;
*/
private Long menuId; /**
* 菜单ID
} */
@ApiModelProperty(value = "角色ID")
private Long menuId;
}

21
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/SysUserOnline.java
View File

@ -1,52 +1,67 @@
package com.ruoyi.system.domain; package com.ruoyi.system.domain;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data; import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors; import lombok.experimental.Accessors;
/** /**
* 当前在线会话 * 当前在线会话
* *
* @author ruoyi * @author Lion Li
*/ */
@Data @Data
@NoArgsConstructor
@Accessors(chain = true) @Accessors(chain = true)
@ApiModel("当前在线会话业务对象")
public class SysUserOnline { public class SysUserOnline {
/** /**
* 会话编号 * 会话编号
*/ */
@ApiModelProperty(value = "会话编号")
private String tokenId; private String tokenId;
/**
* 部门名称
*/
@ApiModelProperty(value = "部门名称")
private String deptName;
/** /**
* 用户名称 * 用户名称
*/ */
@ApiModelProperty(value = "用户名称")
private String userName; private String userName;
/** /**
* 登录IP地址 * 登录IP地址
*/ */
@ApiModelProperty(value = "登录IP地址")
private String ipaddr; private String ipaddr;
/** /**
* 登录地址 * 登录地址
*/ */
@ApiModelProperty(value = "登录地址")
private String loginLocation; private String loginLocation;
/** /**
* 浏览器类型 * 浏览器类型
*/ */
@ApiModelProperty(value = "浏览器类型")
private String browser; private String browser;
/** /**
* 操作系统 * 操作系统
*/ */
@ApiModelProperty(value = "操作系统")
private String os; private String os;
/** /**
* 登录时间 * 登录时间
*/ */
@ApiModelProperty(value = "登录时间")
private Long loginTime; private Long loginTime;
} }

58
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/SysUserPost.java
View File

@ -1,27 +1,31 @@
package com.ruoyi.system.domain; package com.ruoyi.system.domain;
import lombok.Data; import io.swagger.annotations.ApiModel;
import lombok.NoArgsConstructor; import io.swagger.annotations.ApiModelProperty;
import lombok.experimental.Accessors; import lombok.Data;
import lombok.experimental.Accessors;
/**
* 用户和岗位关联 sys_user_post /**
* * 用户和岗位关联 sys_user_post
* @author ruoyi *
*/ * @author Lion Li
@Data */
@NoArgsConstructor
@Accessors(chain = true) @Data
public class SysUserPost { @Accessors(chain = true)
@ApiModel("用户和岗位关联")
/** public class SysUserPost {
* 用户ID
*/ /**
private Long userId; * 用户ID
*/
/** @ApiModelProperty(value = "用户ID")
* 岗位ID private Long userId;
*/
private Long postId; /**
* 岗位ID
} */
@ApiModelProperty(value = "岗位ID")
private Long postId;
}

58
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/SysUserRole.java
View File

@ -1,27 +1,31 @@
package com.ruoyi.system.domain; package com.ruoyi.system.domain;
import lombok.Data; import io.swagger.annotations.ApiModel;
import lombok.NoArgsConstructor; import io.swagger.annotations.ApiModelProperty;
import lombok.experimental.Accessors; import lombok.Data;
import lombok.experimental.Accessors;
/**
* 用户和角色关联 sys_user_role /**
* * 用户和角色关联 sys_user_role
* @author ruoyi *
*/ * @author Lion Li
@Data */
@NoArgsConstructor
@Accessors(chain = true) @Data
public class SysUserRole { @Accessors(chain = true)
@ApiModel("用户和角色关联")
/** public class SysUserRole {
* 用户ID
*/ /**
private Long userId; * 用户ID
*/
/** @ApiModelProperty(value = "用户ID")
* 角色ID private Long userId;
*/
private Long roleId; /**
* 角色ID
} */
@ApiModelProperty(value = "角色ID")
private Long roleId;
}

93
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/vo/SysUserExportVo.java Normal file
View File

@ -0,0 +1,93 @@
package com.ruoyi.system.domain.vo;
import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.excel.annotation.ExcelDictFormat;
import com.ruoyi.common.excel.convert.ExcelDictConvert;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Date;
/**
* 用户对象导出VO
*
* @author Lion Li
*/
@Data
@NoArgsConstructor
@Accessors(chain = true)
public class SysUserExportVo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 用户ID
*/
@ExcelProperty(value = "用户序号")
private Long userId;
/**
* 用户账号
*/
@ExcelProperty(value = "登录名称")
private String userName;
/**
* 用户昵称
*/
@ExcelProperty(value = "用户名称")
private String nickName;
/**
* 用户邮箱
*/
@ExcelProperty(value = "用户邮箱")
private String email;
/**
* 手机号码
*/
@ExcelProperty(value = "手机号码")
private String phonenumber;
/**
* 用户性别
*/
@ExcelProperty(value = "用户性别", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "sys_user_sex")
private String sex;
/**
* 帐号状态（0正常 1停用）
*/
@ExcelProperty(value = "帐号状态", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "sys_common_status")
private String status;
/**
* 最后登录IP
*/
@ExcelProperty(value = "最后登录IP")
private String loginIp;
/**
* 最后登录时间
*/
@ExcelProperty(value = "最后登录时间")
private Date loginDate;
/**
* 部门名称
*/
@ExcelProperty(value = "部门名称")
private String deptName;
/**
* 负责人
*/
@ExcelProperty(value = "部门负责人")
private String leader;
}

73
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/vo/SysUserImportVo.java Normal file
View File

@ -0,0 +1,73 @@
package com.ruoyi.system.domain.vo;
import com.alibaba.excel.annotation.ExcelProperty;
import com.ruoyi.common.excel.annotation.ExcelDictFormat;
import com.ruoyi.common.excel.convert.ExcelDictConvert;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* 用户对象导入VO
*
* @author Lion Li
*/
@Data
@NoArgsConstructor
// @Accessors(chain = true) // 导入不允许使用 会找不到set方法
public class SysUserImportVo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 用户ID
*/
@ExcelProperty(value = "用户序号")
private Long userId;
/**
* 部门ID
*/
@ExcelProperty(value = "部门编号")
private Long deptId;
/**
* 用户账号
*/
@ExcelProperty(value = "登录名称")
private String userName;
/**
* 用户昵称
*/
@ExcelProperty(value = "用户名称")
private String nickName;
/**
* 用户邮箱
*/
@ExcelProperty(value = "用户邮箱")
private String email;
/**
* 手机号码
*/
@ExcelProperty(value = "手机号码")
private String phonenumber;
/**
* 用户性别
*/
@ExcelProperty(value = "用户性别", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "sys_user_sex")
private String sex;
/**
* 帐号状态（0正常 1停用）
*/
@ExcelProperty(value = "帐号状态", converter = ExcelDictConvert.class)
@ExcelDictFormat(dictType = "sys_normal_disable")
private String status;
}

53
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/domain/vo/TreeSelect.java
View File

@ -1,53 +0,0 @@
package com.ruoyi.system.domain.vo;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.ruoyi.system.api.domain.SysDept;
import com.ruoyi.system.domain.SysMenu;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.List;
import java.util.stream.Collectors;
/**
* Treeselect树结构实体类
*
* @author ruoyi
*/
@Data
@NoArgsConstructor
@Accessors(chain = true)
public class TreeSelect implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 节点ID
*/
private Long id;
/**
* 节点名称
*/
private String label;
/**
* 子节点
*/
@JsonInclude(JsonInclude.Include.NON_EMPTY)
private List<TreeSelect> children;
public TreeSelect(SysDept dept) {
this.id = dept.getDeptId();
this.label = dept.getDeptName();
this.children = dept.getChildren().stream().map(TreeSelect::new).collect(Collectors.toList());
}
public TreeSelect(SysMenu menu) {
this.id = menu.getMenuId();
this.label = menu.getMenuName();
this.children = menu.getChildren().stream().map(TreeSelect::new).collect(Collectors.toList());
}
}

4
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/dubbo/RemoteUserServiceImpl.java
View File

@ -1,8 +1,8 @@
package com.ruoyi.system.dubbo; package com.ruoyi.system.dubbo;
import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.constant.UserConstants; import com.ruoyi.common.core.constant.UserConstants;
import com.ruoyi.common.core.exception.ServiceException; import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.system.api.RemoteUserService; import com.ruoyi.system.api.RemoteUserService;
import com.ruoyi.system.api.domain.SysUser; import com.ruoyi.system.api.domain.SysUser;
import com.ruoyi.system.api.model.LoginUser; import com.ruoyi.system.api.model.LoginUser;
@ -33,7 +33,7 @@ public class RemoteUserServiceImpl implements RemoteUserService {
@Override @Override
public LoginUser getUserInfo(String username, String source) { public LoginUser getUserInfo(String username, String source) {
SysUser sysUser = userService.selectUserByUserName(username); SysUser sysUser = userService.selectUserByUserName(username);
if (StringUtils.isNull(sysUser)) { if (ObjectUtil.isNull(sysUser)) {
throw new ServiceException("用户名或密码错误"); throw new ServiceException("用户名或密码错误");
} }
// 角色集合 // 角色集合

112
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/listener/SysUserImportListener.java Normal file
View File

@ -0,0 +1,112 @@
package com.ruoyi.system.listener;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.core.utils.SpringUtils;
import com.ruoyi.common.core.utils.ValidatorUtils;
import com.ruoyi.common.excel.core.ExcelListener;
import com.ruoyi.common.excel.core.ExcelResult;
import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.system.api.domain.SysUser;
import com.ruoyi.system.domain.vo.SysUserImportVo;
import com.ruoyi.system.service.ISysConfigService;
import com.ruoyi.system.service.ISysUserService;
import lombok.extern.slf4j.Slf4j;
import java.util.List;
/**
* 系统用户自定义导入
*
* @author Lion Li
*/
@Slf4j
public class SysUserImportListener extends AnalysisEventListener<SysUserImportVo> implements ExcelListener<SysUserImportVo> {
private final ISysUserService userService;
private final String password;
private final Boolean isUpdateSupport;
private final String operName;
private int successNum = 0;
private int failureNum = 0;
private final StringBuilder successMsg = new StringBuilder();
private final StringBuilder failureMsg = new StringBuilder();
public SysUserImportListener(Boolean isUpdateSupport) {
String initPassword = SpringUtils.getBean(ISysConfigService.class).selectConfigByKey("sys.user.initPassword");
this.userService = SpringUtils.getBean(ISysUserService.class);
this.password = SecurityUtils.encryptPassword(initPassword);
this.isUpdateSupport = isUpdateSupport;
this.operName = SecurityUtils.getUsername();
}
@Override
public void invoke(SysUserImportVo userVo, AnalysisContext context) {
SysUser user = this.userService.selectUserByUserName(userVo.getUserName());
try {
// 验证是否存在这个用户
if (ObjectUtil.isNull(user)) {
user = BeanUtil.toBean(userVo, SysUser.class);
ValidatorUtils.validate(user);
user.setPassword(password);
user.setCreateBy(operName);
userService.insertUser(user);
successNum++;
successMsg.append("<br/>").append(successNum).append("、账号 ").append(user.getUserName()).append(" 导入成功");
} else if (isUpdateSupport) {
ValidatorUtils.validate(user);
user.setUpdateBy(operName);
userService.updateUser(user);
successNum++;
successMsg.append("<br/>").append(successNum).append("、账号 ").append(user.getUserName()).append(" 更新成功");
} else {
failureNum++;
failureMsg.append("<br/>").append(failureNum).append("、账号 ").append(user.getUserName()).append(" 已存在");
}
} catch (Exception e) {
failureNum++;
String msg = "<br/>" + failureNum + "、账号 " + user.getUserName() + " 导入失败：";
failureMsg.append(msg).append(e.getMessage());
log.error(msg, e);
}
}
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
}
@Override
public ExcelResult<SysUserImportVo> getExcelResult() {
return new ExcelResult<SysUserImportVo>() {
@Override
public String getAnalysis() {
if (failureNum > 0) {
failureMsg.insert(0, "很抱歉，导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
throw new ServiceException(failureMsg.toString());
} else {
successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
}
return successMsg.toString();
}
@Override
public List<SysUserImportVo> getList() {
return null;
}
@Override
public List<String> getErrorList() {
return null;
}
};
}
}

232
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/service/ISysDeptService.java
View File

@ -1,116 +1,116 @@
package com.ruoyi.system.service; package com.ruoyi.system.service;
import com.ruoyi.system.api.domain.SysDept; import cn.hutool.core.lang.tree.Tree;
import com.ruoyi.system.domain.vo.TreeSelect; import com.ruoyi.system.api.domain.SysDept;
import java.util.List; import java.util.List;
/** /**
* 部门管理 服务层 * 部门管理 服务层
* *
* @author ruoyi * @author ruoyi
*/ */
public interface ISysDeptService { public interface ISysDeptService {
/** /**
* 查询部门管理数据 * 查询部门管理数据
* *
* @param dept 部门信息 * @param dept 部门信息
* @return 部门信息集合 * @return 部门信息集合
*/ */
List<SysDept> selectDeptList(SysDept dept); List<SysDept> selectDeptList(SysDept dept);
/** /**
* 构建前端所需要树结构 * 构建前端所需要树结构
* *
* @param depts 部门列表 * @param depts 部门列表
* @return 树结构列表 * @return 树结构列表
*/ */
List<SysDept> buildDeptTree(List<SysDept> depts); List<SysDept> buildDeptTree(List<SysDept> depts);
/** /**
* 构建前端所需要下拉树结构 * 构建前端所需要下拉树结构
* *
* @param depts 部门列表 * @param depts 部门列表
* @return 下拉树结构列表 * @return 下拉树结构列表
*/ */
List<TreeSelect> buildDeptTreeSelect(List<SysDept> depts); List<Tree<Long>> buildDeptTreeSelect(List<SysDept> depts);
/** /**
* 根据角色ID查询部门树信息 * 根据角色ID查询部门树信息
* *
* @param roleId 角色ID * @param roleId 角色ID
* @return 选中部门列表 * @return 选中部门列表
*/ */
List<Long> selectDeptListByRoleId(Long roleId); List<Long> selectDeptListByRoleId(Long roleId);
/** /**
* 根据部门ID查询信息 * 根据部门ID查询信息
* *
* @param deptId 部门ID * @param deptId 部门ID
* @return 部门信息 * @return 部门信息
*/ */
SysDept selectDeptById(Long deptId); SysDept selectDeptById(Long deptId);
/** /**
* 根据ID查询所有子部门（正常状态） * 根据ID查询所有子部门（正常状态）
* *
* @param deptId 部门ID * @param deptId 部门ID
* @return 子部门数 * @return 子部门数
*/ */
int selectNormalChildrenDeptById(Long deptId); int selectNormalChildrenDeptById(Long deptId);
/** /**
* 是否存在部门子节点 * 是否存在部门子节点
* *
* @param deptId 部门ID * @param deptId 部门ID
* @return 结果 * @return 结果
*/ */
boolean hasChildByDeptId(Long deptId); boolean hasChildByDeptId(Long deptId);
/** /**
* 查询部门是否存在用户 * 查询部门是否存在用户
* *
* @param deptId 部门ID * @param deptId 部门ID
* @return 结果 true 存在 false 不存在 * @return 结果 true 存在 false 不存在
*/ */
boolean checkDeptExistUser(Long deptId); boolean checkDeptExistUser(Long deptId);
/** /**
* 校验部门名称是否唯一 * 校验部门名称是否唯一
* *
* @param dept 部门信息 * @param dept 部门信息
* @return 结果 * @return 结果
*/ */
String checkDeptNameUnique(SysDept dept); String checkDeptNameUnique(SysDept dept);
/** /**
* 校验部门是否有数据权限 * 校验部门是否有数据权限
* *
* @param deptId 部门id * @param deptId 部门id
*/ */
void checkDeptDataScope(Long deptId); void checkDeptDataScope(Long deptId);
/** /**
* 新增保存部门信息 * 新增保存部门信息
* *
* @param dept 部门信息 * @param dept 部门信息
* @return 结果 * @return 结果
*/ */
int insertDept(SysDept dept); int insertDept(SysDept dept);
/** /**
* 修改保存部门信息 * 修改保存部门信息
* *
* @param dept 部门信息 * @param dept 部门信息
* @return 结果 * @return 结果
*/ */
int updateDept(SysDept dept); int updateDept(SysDept dept);
/** /**
* 删除部门管理信息 * 删除部门管理信息
* *
* @param deptId 部门ID * @param deptId 部门ID
* @return 结果 * @return 结果
*/ */
int deleteDeptById(Long deptId); int deleteDeptById(Long deptId);
} }

264
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/service/ISysMenuService.java
View File

@ -1,136 +1,128 @@
package com.ruoyi.system.service; package com.ruoyi.system.service;
import com.ruoyi.system.domain.SysMenu; import cn.hutool.core.lang.tree.Tree;
import com.ruoyi.system.domain.vo.RouterVo; import com.ruoyi.system.domain.SysMenu;
import com.ruoyi.system.domain.vo.TreeSelect; import com.ruoyi.system.domain.vo.RouterVo;
import java.util.List; import java.util.List;
import java.util.Set; import java.util.Set;
/** /**
* 菜单 业务层 * 菜单 业务层
* *
* @author ruoyi * @author ruoyi
*/ */
public interface ISysMenuService { public interface ISysMenuService {
/** /**
* 根据用户查询系统菜单列表 * 根据用户查询系统菜单列表
* *
* @param userId 用户ID * @param userId 用户ID
* @return 菜单列表 * @return 菜单列表
*/ */
List<SysMenu> selectMenuList(Long userId); List<SysMenu> selectMenuList(Long userId);
/** /**
* 根据用户查询系统菜单列表 * 根据用户查询系统菜单列表
* *
* @param menu 菜单信息 * @param menu 菜单信息
* @param userId 用户ID * @param userId 用户ID
* @return 菜单列表 * @return 菜单列表
*/ */
List<SysMenu> selectMenuList(SysMenu menu, Long userId); List<SysMenu> selectMenuList(SysMenu menu, Long userId);
/** /**
* 根据用户ID查询权限 * 根据用户ID查询权限
* *
* @param userId 用户ID * @param userId 用户ID
* @return 权限列表 * @return 权限列表
*/ */
Set<String> selectMenuPermsByUserId(Long userId); Set<String> selectMenuPermsByUserId(Long userId);
/** /**
* 根据用户ID查询菜单树信息 * 根据用户ID查询菜单树信息
* *
* @param userId 用户ID * @param userId 用户ID
* @return 菜单列表 * @return 菜单列表
*/ */
List<SysMenu> selectMenuTreeByUserId(Long userId); List<SysMenu> selectMenuTreeByUserId(Long userId);
/** /**
* 根据角色ID查询菜单树信息 * 根据角色ID查询菜单树信息
* *
* @param roleId 角色ID * @param roleId 角色ID
* @return 选中菜单列表 * @return 选中菜单列表
*/ */
List<Long> selectMenuListByRoleId(Long roleId); List<Long> selectMenuListByRoleId(Long roleId);
/** /**
* 构建前端路由所需要的菜单 * 构建前端路由所需要的菜单
* *
* @param menus 菜单列表 * @param menus 菜单列表
* @return 路由列表 * @return 路由列表
*/ */
List<RouterVo> buildMenus(List<SysMenu> menus); List<RouterVo> buildMenus(List<SysMenu> menus);
/** /**
* 构建前端所需要树结构 * 构建前端所需要下拉树结构
* *
* @param menus 菜单列表 * @param menus 菜单列表
* @return 树结构列表 * @return 下拉树结构列表
*/ */
List<SysMenu> buildMenuTree(List<SysMenu> menus); List<Tree<Long>> buildMenuTreeSelect(List<SysMenu> menus);
/** /**
* 构建前端所需要下拉树结构 * 根据菜单ID查询信息
* *
* @param menus 菜单列表 * @param menuId 菜单ID
* @return 下拉树结构列表 * @return 菜单信息
*/ */
List<TreeSelect> buildMenuTreeSelect(List<SysMenu> menus); SysMenu selectMenuById(Long menuId);
/** /**
* 根据菜单ID查询信息 * 是否存在菜单子节点
* *
* @param menuId 菜单ID * @param menuId 菜单ID
* @return 菜单信息 * @return 结果 true 存在 false 不存在
*/ */
SysMenu selectMenuById(Long menuId); boolean hasChildByMenuId(Long menuId);
/** /**
* 是否存在菜单子节点 * 查询菜单是否存在角色
* *
* @param menuId 菜单ID * @param menuId 菜单ID
* @return 结果 true 存在 false 不存在 * @return 结果 true 存在 false 不存在
*/ */
boolean hasChildByMenuId(Long menuId); boolean checkMenuExistRole(Long menuId);
/** /**
* 查询菜单是否存在角色 * 新增保存菜单信息
* *
* @param menuId 菜单ID * @param menu 菜单信息
* @return 结果 true 存在 false 不存在 * @return 结果
*/ */
boolean checkMenuExistRole(Long menuId); int insertMenu(SysMenu menu);
/** /**
* 新增保存菜单信息 * 修改保存菜单信息
* *
* @param menu 菜单信息 * @param menu 菜单信息
* @return 结果 * @return 结果
*/ */
int insertMenu(SysMenu menu); int updateMenu(SysMenu menu);
/** /**
* 修改保存菜单信息 * 删除菜单管理信息
* *
* @param menu 菜单信息 * @param menuId 菜单ID
* @return 结果 * @return 结果
*/ */
int updateMenu(SysMenu menu); int deleteMenuById(Long menuId);
/** /**
* 删除菜单管理信息 * 校验菜单名称是否唯一
* *
* @param menuId 菜单ID * @param menu 菜单信息
* @return 结果 * @return 结果
*/ */
int deleteMenuById(Long menuId); String checkMenuNameUnique(SysMenu menu);
}
/**
* 校验菜单名称是否唯一
*
* @param menu 菜单信息
* @return 结果
*/
String checkMenuNameUnique(SysMenu menu);
}

403
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/service/ISysUserService.java
View File

@ -1,206 +1,197 @@
package com.ruoyi.system.service; package com.ruoyi.system.service;
import com.ruoyi.system.api.domain.SysUser; import com.ruoyi.system.api.domain.SysUser;
import java.util.List; import java.util.List;
/** /**
* 用户 业务层 * 用户 业务层
* *
* @author ruoyi * @author ruoyi
*/ */
public interface ISysUserService { public interface ISysUserService {
/** /**
* 根据条件分页查询用户列表 * 根据条件分页查询用户列表
* *
* @param user 用户信息 * @param user 用户信息
* @return 用户信息集合信息 * @return 用户信息集合信息
*/ */
List<SysUser> selectUserList(SysUser user); List<SysUser> selectUserList(SysUser user);
/** /**
* 根据条件分页查询已分配用户角色列表 * 根据条件分页查询已分配用户角色列表
* *
* @param user 用户信息 * @param user 用户信息
* @return 用户信息集合信息 * @return 用户信息集合信息
*/ */
List<SysUser> selectAllocatedList(SysUser user); List<SysUser> selectAllocatedList(SysUser user);
/** /**
* 根据条件分页查询未分配用户角色列表 * 根据条件分页查询未分配用户角色列表
* *
* @param user 用户信息 * @param user 用户信息
* @return 用户信息集合信息 * @return 用户信息集合信息
*/ */
List<SysUser> selectUnallocatedList(SysUser user); List<SysUser> selectUnallocatedList(SysUser user);
/** /**
* 通过用户名查询用户 * 通过用户名查询用户
* *
* @param userName 用户名 * @param userName 用户名
* @return 用户对象信息 * @return 用户对象信息
*/ */
SysUser selectUserByUserName(String userName); SysUser selectUserByUserName(String userName);
/** /**
* 通过用户ID查询用户 * 通过用户ID查询用户
* *
* @param userId 用户ID * @param userId 用户ID
* @return 用户对象信息 * @return 用户对象信息
*/ */
SysUser selectUserById(Long userId); SysUser selectUserById(Long userId);
/** /**
* 根据用户ID查询用户所属角色组 * 根据用户ID查询用户所属角色组
* *
* @param userName 用户名 * @param userName 用户名
* @return 结果 * @return 结果
*/ */
String selectUserRoleGroup(String userName); String selectUserRoleGroup(String userName);
/** /**
* 根据用户ID查询用户所属岗位组 * 根据用户ID查询用户所属岗位组
* *
* @param userName 用户名 * @param userName 用户名
* @return 结果 * @return 结果
*/ */
String selectUserPostGroup(String userName); String selectUserPostGroup(String userName);
/** /**
* 校验用户名称是否唯一 * 校验用户名称是否唯一
* *
* @param userName 用户名称 * @param userName 用户名称
* @return 结果 * @return 结果
*/ */
String checkUserNameUnique(String userName); String checkUserNameUnique(String userName);
/** /**
* 校验手机号码是否唯一 * 校验手机号码是否唯一
* *
* @param user 用户信息 * @param user 用户信息
* @return 结果 * @return 结果
*/ */
String checkPhoneUnique(SysUser user); String checkPhoneUnique(SysUser user);
/** /**
* 校验email是否唯一 * 校验email是否唯一
* *
* @param user 用户信息 * @param user 用户信息
* @return 结果 * @return 结果
*/ */
String checkEmailUnique(SysUser user); String checkEmailUnique(SysUser user);
/** /**
* 校验用户是否允许操作 * 校验用户是否允许操作
* *
* @param user 用户信息 * @param user 用户信息
*/ */
void checkUserAllowed(SysUser user); void checkUserAllowed(SysUser user);
/** /**
* 校验用户是否有数据权限 * 校验用户是否有数据权限
* *
* @param userId 用户id * @param userId 用户id
*/ */
void checkUserDataScope(Long userId); void checkUserDataScope(Long userId);
/** /**
* 新增用户信息 * 新增用户信息
* *
* @param user 用户信息 * @param user 用户信息
* @return 结果 * @return 结果
*/ */
int insertUser(SysUser user); int insertUser(SysUser user);
/** /**
* 注册用户信息 * 注册用户信息
* *
* @param user 用户信息 * @param user 用户信息
* @return 结果 * @return 结果
*/ */
boolean registerUser(SysUser user); boolean registerUser(SysUser user);
/** /**
* 修改用户信息 * 修改用户信息
* *
* @param user 用户信息 * @param user 用户信息
* @return 结果 * @return 结果
*/ */
int updateUser(SysUser user); int updateUser(SysUser user);
/** /**
* 用户授权角色 * 用户授权角色
* *
* @param userId 用户ID * @param userId 用户ID
* @param roleIds 角色组 * @param roleIds 角色组
*/ */
void insertUserAuth(Long userId, Long[] roleIds); void insertUserAuth(Long userId, Long[] roleIds);
/** /**
* 修改用户状态 * 修改用户状态
* *
* @param user 用户信息 * @param user 用户信息
* @return 结果 * @return 结果
*/ */
int updateUserStatus(SysUser user); int updateUserStatus(SysUser user);
/** /**
* 修改用户基本信息 * 修改用户基本信息
* *
* @param user 用户信息 * @param user 用户信息
* @return 结果 * @return 结果
*/ */
int updateUserProfile(SysUser user); int updateUserProfile(SysUser user);
/** /**
* 修改用户头像 * 修改用户头像
* *
* @param userName 用户名 * @param userName 用户名
* @param avatar 头像地址 * @param avatar 头像地址
* @return 结果 * @return 结果
*/ */
boolean updateUserAvatar(String userName, String avatar); boolean updateUserAvatar(String userName, String avatar);
/** /**
* 重置用户密码 * 重置用户密码
* *
* @param user 用户信息 * @param user 用户信息
* @return 结果 * @return 结果
*/ */
int resetPwd(SysUser user); int resetPwd(SysUser user);
/** /**
* 重置用户密码 * 重置用户密码
* *
* @param userName 用户名 * @param userName 用户名
* @param password 密码 * @param password 密码
* @return 结果 * @return 结果
*/ */
int resetUserPwd(String userName, String password); int resetUserPwd(String userName, String password);
/** /**
* 通过用户ID删除用户 * 通过用户ID删除用户
* *
* @param userId 用户ID * @param userId 用户ID
* @return 结果 * @return 结果
*/ */
int deleteUserById(Long userId); int deleteUserById(Long userId);
/** /**
* 批量删除用户信息 * 批量删除用户信息
* *
* @param userIds 需要删除的用户ID * @param userIds 需要删除的用户ID
* @return 结果 * @return 结果
*/ */
int deleteUserByIds(Long[] userIds); int deleteUserByIds(Long[] userIds);
/** }
* 导入用户数据
*
* @param userList 用户数据列表
* @param isUpdateSupport 是否更新支持，如果已存在，则进行更新数据
* @param operName 操作用户
* @return 结果
*/
String importUser(List<SysUser> userList, Boolean isUpdateSupport, String operName);
}

375
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysConfigServiceImpl.java
View File

@ -1,187 +1,188 @@
package com.ruoyi.system.service.impl; package com.ruoyi.system.service.impl;
import cn.hutool.core.convert.Convert; import cn.hutool.core.convert.Convert;
import com.ruoyi.common.core.constant.Constants; import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.constant.UserConstants; import com.ruoyi.common.core.constant.Constants;
import com.ruoyi.common.core.exception.ServiceException; import com.ruoyi.common.core.constant.UserConstants;
import com.ruoyi.common.core.utils.StringUtils; import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.redis.utils.RedisUtils; import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.system.domain.SysConfig; import com.ruoyi.common.redis.utils.RedisUtils;
import com.ruoyi.system.mapper.SysConfigMapper; import com.ruoyi.system.domain.SysConfig;
import com.ruoyi.system.service.ISysConfigService; import com.ruoyi.system.mapper.SysConfigMapper;
import lombok.RequiredArgsConstructor; import com.ruoyi.system.service.ISysConfigService;
import org.springframework.beans.factory.annotation.Autowired; import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import java.util.Collection; import javax.annotation.PostConstruct;
import java.util.List; import java.util.Collection;
import java.util.List;
/**
* 参数配置 服务层实现 /**
* * 参数配置 服务层实现
* @author ruoyi *
*/ * @author ruoyi
@RequiredArgsConstructor(onConstructor_ = @Autowired) */
@Service @RequiredArgsConstructor(onConstructor_ = @Autowired)
public class SysConfigServiceImpl implements ISysConfigService { @Service
public class SysConfigServiceImpl implements ISysConfigService {
private final SysConfigMapper configMapper;
private final SysConfigMapper configMapper;
/**
* 项目启动时，初始化参数到缓存 /**
*/ * 项目启动时，初始化参数到缓存
@PostConstruct */
public void init() { @PostConstruct
loadingConfigCache(); public void init() {
} loadingConfigCache();
}
/**
* 查询参数配置信息 /**
* * 查询参数配置信息
* @param configId 参数配置ID *
* @return 参数配置信息 * @param configId 参数配置ID
*/ * @return 参数配置信息
@Override */
public SysConfig selectConfigById(Long configId) { @Override
SysConfig config = new SysConfig(); public SysConfig selectConfigById(Long configId) {
config.setConfigId(configId); SysConfig config = new SysConfig();
return configMapper.selectConfig(config); config.setConfigId(configId);
} return configMapper.selectConfig(config);
}
/**
* 根据键名查询参数配置信息 /**
* * 根据键名查询参数配置信息
* @param configKey 参数key *
* @return 参数键值 * @param configKey 参数key
*/ * @return 参数键值
@Override */
public String selectConfigByKey(String configKey) { @Override
String configValue = Convert.toStr(RedisUtils.getCacheObject(getCacheKey(configKey))); public String selectConfigByKey(String configKey) {
if (StringUtils.isNotEmpty(configValue)) { String configValue = Convert.toStr(RedisUtils.getCacheObject(getCacheKey(configKey)));
return configValue; if (StringUtils.isNotEmpty(configValue)) {
} return configValue;
SysConfig config = new SysConfig(); }
config.setConfigKey(configKey); SysConfig config = new SysConfig();
SysConfig retConfig = configMapper.selectConfig(config); config.setConfigKey(configKey);
if (StringUtils.isNotNull(retConfig)) { SysConfig retConfig = configMapper.selectConfig(config);
RedisUtils.setCacheObject(getCacheKey(configKey), retConfig.getConfigValue()); if (ObjectUtil.isNotNull(retConfig)) {
return retConfig.getConfigValue(); RedisUtils.setCacheObject(getCacheKey(configKey), retConfig.getConfigValue());
} return retConfig.getConfigValue();
return StringUtils.EMPTY; }
} return StringUtils.EMPTY;
}
/**
* 查询参数配置列表 /**
* * 查询参数配置列表
* @param config 参数配置信息 *
* @return 参数配置集合 * @param config 参数配置信息
*/ * @return 参数配置集合
@Override */
public List<SysConfig> selectConfigList(SysConfig config) { @Override
return configMapper.selectConfigList(config); public List<SysConfig> selectConfigList(SysConfig config) {
} return configMapper.selectConfigList(config);
}
/**
* 新增参数配置 /**
* * 新增参数配置
* @param config 参数配置信息 *
* @return 结果 * @param config 参数配置信息
*/ * @return 结果
@Override */
public int insertConfig(SysConfig config) { @Override
int row = configMapper.insertConfig(config); public int insertConfig(SysConfig config) {
if (row > 0) { int row = configMapper.insertConfig(config);
RedisUtils.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue()); if (row > 0) {
} RedisUtils.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
return row; }
} return row;
}
/**
* 修改参数配置 /**
* * 修改参数配置
* @param config 参数配置信息 *
* @return 结果 * @param config 参数配置信息
*/ * @return 结果
@Override */
public int updateConfig(SysConfig config) { @Override
int row = configMapper.updateConfig(config); public int updateConfig(SysConfig config) {
if (row > 0) { int row = configMapper.updateConfig(config);
RedisUtils.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue()); if (row > 0) {
} RedisUtils.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
return row; }
} return row;
}
/**
* 批量删除参数信息 /**
* * 批量删除参数信息
* @param configIds 需要删除的参数ID *
* @return 结果 * @param configIds 需要删除的参数ID
*/ * @return 结果
@Override */
public void deleteConfigByIds(Long[] configIds) { @Override
for (Long configId : configIds) { public void deleteConfigByIds(Long[] configIds) {
SysConfig config = selectConfigById(configId); for (Long configId : configIds) {
if (StringUtils.equals(UserConstants.YES, config.getConfigType())) { SysConfig config = selectConfigById(configId);
throw new ServiceException(String.format("内置参数【%1$s】不能删除 ", config.getConfigKey())); if (StringUtils.equals(UserConstants.YES, config.getConfigType())) {
} throw new ServiceException(String.format("内置参数【%1$s】不能删除 ", config.getConfigKey()));
configMapper.deleteConfigById(configId); }
RedisUtils.deleteObject(getCacheKey(config.getConfigKey())); configMapper.deleteConfigById(configId);
} RedisUtils.deleteObject(getCacheKey(config.getConfigKey()));
} }
}
/**
* 加载参数缓存数据 /**
*/ * 加载参数缓存数据
@Override */
public void loadingConfigCache() { @Override
List<SysConfig> configsList = configMapper.selectConfigList(new SysConfig()); public void loadingConfigCache() {
for (SysConfig config : configsList) { List<SysConfig> configsList = configMapper.selectConfigList(new SysConfig());
RedisUtils.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue()); for (SysConfig config : configsList) {
} RedisUtils.setCacheObject(getCacheKey(config.getConfigKey()), config.getConfigValue());
} }
}
/**
* 清空参数缓存数据 /**
*/ * 清空参数缓存数据
@Override */
public void clearConfigCache() { @Override
Collection<String> keys = RedisUtils.keys(Constants.SYS_CONFIG_KEY + "*"); public void clearConfigCache() {
RedisUtils.deleteObject(keys); Collection<String> keys = RedisUtils.keys(Constants.SYS_CONFIG_KEY + "*");
} RedisUtils.deleteObject(keys);
}
/**
* 重置参数缓存数据 /**
*/ * 重置参数缓存数据
@Override */
public void resetConfigCache() { @Override
clearConfigCache(); public void resetConfigCache() {
loadingConfigCache(); clearConfigCache();
} loadingConfigCache();
}
/**
* 校验参数键名是否唯一 /**
* * 校验参数键名是否唯一
* @param config 参数配置信息 *
* @return 结果 * @param config 参数配置信息
*/ * @return 结果
@Override */
public String checkConfigKeyUnique(SysConfig config) { @Override
Long configId = StringUtils.isNull(config.getConfigId()) ? -1L : config.getConfigId(); public String checkConfigKeyUnique(SysConfig config) {
SysConfig info = configMapper.checkConfigKeyUnique(config.getConfigKey()); Long configId = ObjectUtil.isNull(config.getConfigId()) ? -1L : config.getConfigId();
if (StringUtils.isNotNull(info) && info.getConfigId().longValue() != configId.longValue()) { SysConfig info = configMapper.checkConfigKeyUnique(config.getConfigKey());
return UserConstants.NOT_UNIQUE; if (ObjectUtil.isNotNull(info) && info.getConfigId().longValue() != configId.longValue()) {
} return UserConstants.NOT_UNIQUE;
return UserConstants.UNIQUE; }
} return UserConstants.UNIQUE;
}
/**
* 设置cache key /**
* * 设置cache key
* @param configKey 参数键 *
* @return 缓存键key * @param configKey 参数键
*/ * @return 缓存键key
private String getCacheKey(String configKey) { */
return Constants.SYS_CONFIG_KEY + configKey; private String getCacheKey(String configKey) {
} return Constants.SYS_CONFIG_KEY + configKey;
} }
}

599
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDeptServiceImpl.java
View File

@ -1,296 +1,303 @@
package com.ruoyi.system.service.impl; package com.ruoyi.system.service.impl;
import cn.hutool.core.convert.Convert; import cn.hutool.core.collection.CollUtil;
import com.ruoyi.common.core.constant.UserConstants; import cn.hutool.core.convert.Convert;
import com.ruoyi.common.core.exception.ServiceException; import cn.hutool.core.lang.tree.Tree;
import com.ruoyi.common.core.utils.SpringUtils; import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.utils.StringUtils; import com.ruoyi.common.core.constant.UserConstants;
import com.ruoyi.common.datascope.annotation.DataScope; import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.security.utils.SecurityUtils; import com.ruoyi.common.core.utils.SpringUtils;
import com.ruoyi.system.api.domain.SysDept; import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.system.api.domain.SysRole; import com.ruoyi.common.core.utils.TreeBuildUtils;
import com.ruoyi.system.api.domain.SysUser; import com.ruoyi.common.datascope.annotation.DataScope;
import com.ruoyi.system.domain.vo.TreeSelect; import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.system.mapper.SysDeptMapper; import com.ruoyi.system.api.domain.SysDept;
import com.ruoyi.system.mapper.SysRoleMapper; import com.ruoyi.system.api.domain.SysRole;
import com.ruoyi.system.service.ISysDeptService; import com.ruoyi.system.api.domain.SysUser;
import lombok.RequiredArgsConstructor; import com.ruoyi.system.mapper.SysDeptMapper;
import org.springframework.beans.factory.annotation.Autowired; import com.ruoyi.system.mapper.SysRoleMapper;
import org.springframework.stereotype.Service; import com.ruoyi.system.service.ISysDeptService;
import lombok.RequiredArgsConstructor;
import java.util.ArrayList; import org.springframework.beans.factory.annotation.Autowired;
import java.util.Iterator; import org.springframework.stereotype.Service;
import java.util.List;
import java.util.stream.Collectors; import java.util.ArrayList;
import java.util.Iterator;
/** import java.util.List;
* 部门管理 服务实现
* /**
* @author ruoyi * 部门管理 服务实现
*/ *
@RequiredArgsConstructor(onConstructor_ = @Autowired) * @author ruoyi
@Service */
public class SysDeptServiceImpl implements ISysDeptService { @RequiredArgsConstructor(onConstructor_ = @Autowired)
@Service
private final SysDeptMapper deptMapper; public class SysDeptServiceImpl implements ISysDeptService {
private final SysRoleMapper roleMapper;
private final SysDeptMapper deptMapper;
/** private final SysRoleMapper roleMapper;
* 查询部门管理数据
* /**
* @param dept 部门信息 * 查询部门管理数据
* @return 部门信息集合 *
*/ * @param dept 部门信息
@Override * @return 部门信息集合
@DataScope(deptAlias = "d") */
public List<SysDept> selectDeptList(SysDept dept) { @Override
return deptMapper.selectDeptList(dept); @DataScope(deptAlias = "d")
} public List<SysDept> selectDeptList(SysDept dept) {
return deptMapper.selectDeptList(dept);
/** }
* 构建前端所需要树结构
* /**
* @param depts 部门列表 * 构建前端所需要树结构
* @return 树结构列表 *
*/ * @param depts 部门列表
@Override * @return 树结构列表
public List<SysDept> buildDeptTree(List<SysDept> depts) { */
List<SysDept> returnList = new ArrayList<SysDept>(); @Override
List<Long> tempList = new ArrayList<Long>(); public List<SysDept> buildDeptTree(List<SysDept> depts) {
for (SysDept dept : depts) { List<SysDept> returnList = new ArrayList<SysDept>();
tempList.add(dept.getDeptId()); List<Long> tempList = new ArrayList<Long>();
} for (SysDept dept : depts) {
for (Iterator<SysDept> iterator = depts.iterator(); iterator.hasNext(); ) { tempList.add(dept.getDeptId());
SysDept dept = (SysDept) iterator.next(); }
// 如果是顶级节点, 遍历该父节点的所有子节点 for (Iterator<SysDept> iterator = depts.iterator(); iterator.hasNext(); ) {
if (!tempList.contains(dept.getParentId())) { SysDept dept = (SysDept) iterator.next();
recursionFn(depts, dept); // 如果是顶级节点, 遍历该父节点的所有子节点
returnList.add(dept); if (!tempList.contains(dept.getParentId())) {
} recursionFn(depts, dept);
} returnList.add(dept);
if (returnList.isEmpty()) { }
returnList = depts; }
} if (returnList.isEmpty()) {
return returnList; returnList = depts;
} }
return returnList;
/** }
* 构建前端所需要下拉树结构
* /**
* @param depts 部门列表 * 构建前端所需要下拉树结构
* @return 下拉树结构列表 *
*/ * @param depts 部门列表
@Override * @return 下拉树结构列表
public List<TreeSelect> buildDeptTreeSelect(List<SysDept> depts) { */
List<SysDept> deptTrees = buildDeptTree(depts); @Override
return deptTrees.stream().map(TreeSelect::new).collect(Collectors.toList()); public List<Tree<Long>> buildDeptTreeSelect(List<SysDept> depts) {
} if (CollUtil.isEmpty(depts)) {
return CollUtil.newArrayList();
/** }
* 根据角色ID查询部门树信息 Long parentId = depts.get(0).getParentId();
* return TreeBuildUtils.build(depts, parentId, (dept, tree) ->
* @param roleId 角色ID tree.setId(dept.getDeptId())
* @return 选中部门列表 .setParentId(dept.getParentId())
*/ .setName(dept.getDeptName())
@Override .setWeight(dept.getOrderNum()));
public List<Long> selectDeptListByRoleId(Long roleId) { }
SysRole role = roleMapper.selectRoleById(roleId);
return deptMapper.selectDeptListByRoleId(roleId, role.isDeptCheckStrictly()); /**
} * 根据角色ID查询部门树信息
*
/** * @param roleId 角色ID
* 根据部门ID查询信息 * @return 选中部门列表
* */
* @param deptId 部门ID @Override
* @return 部门信息 public List<Long> selectDeptListByRoleId(Long roleId) {
*/ SysRole role = roleMapper.selectRoleById(roleId);
@Override return deptMapper.selectDeptListByRoleId(roleId, role.isDeptCheckStrictly());
public SysDept selectDeptById(Long deptId) { }
return deptMapper.selectDeptById(deptId);
} /**
* 根据部门ID查询信息
/** *
* 根据ID查询所有子部门（正常状态） * @param deptId 部门ID
* * @return 部门信息
* @param deptId 部门ID */
* @return 子部门数 @Override
*/ public SysDept selectDeptById(Long deptId) {
@Override return deptMapper.selectDeptById(deptId);
public int selectNormalChildrenDeptById(Long deptId) { }
return deptMapper.selectNormalChildrenDeptById(deptId);
} /**
* 根据ID查询所有子部门（正常状态）
/** *
* 是否存在子节点 * @param deptId 部门ID
* * @return 子部门数
* @param deptId 部门ID */
* @return 结果 @Override
*/ public int selectNormalChildrenDeptById(Long deptId) {
@Override return deptMapper.selectNormalChildrenDeptById(deptId);
public boolean hasChildByDeptId(Long deptId) { }
int result = deptMapper.hasChildByDeptId(deptId);
return result > 0 ? true : false; /**
} * 是否存在子节点
*
/** * @param deptId 部门ID
* 查询部门是否存在用户 * @return 结果
* */
* @param deptId 部门ID @Override
* @return 结果 true 存在 false 不存在 public boolean hasChildByDeptId(Long deptId) {
*/ int result = deptMapper.hasChildByDeptId(deptId);
@Override return result > 0 ? true : false;
public boolean checkDeptExistUser(Long deptId) { }
int result = deptMapper.checkDeptExistUser(deptId);
return result > 0 ? true : false; /**
} * 查询部门是否存在用户
*
/** * @param deptId 部门ID
* 校验部门名称是否唯一 * @return 结果 true 存在 false 不存在
* */
* @param dept 部门信息 @Override
* @return 结果 public boolean checkDeptExistUser(Long deptId) {
*/ int result = deptMapper.checkDeptExistUser(deptId);
@Override return result > 0 ? true : false;
public String checkDeptNameUnique(SysDept dept) { }
Long deptId = StringUtils.isNull(dept.getDeptId()) ? -1L : dept.getDeptId();
SysDept info = deptMapper.checkDeptNameUnique(dept.getDeptName(), dept.getParentId()); /**
if (StringUtils.isNotNull(info) && info.getDeptId().longValue() != deptId.longValue()) { * 校验部门名称是否唯一
return UserConstants.NOT_UNIQUE; *
} * @param dept 部门信息
return UserConstants.UNIQUE; * @return 结果
} */
@Override
/** public String checkDeptNameUnique(SysDept dept) {
* 校验部门是否有数据权限 Long deptId = ObjectUtil.isNull(dept.getDeptId()) ? -1L : dept.getDeptId();
* SysDept info = deptMapper.checkDeptNameUnique(dept.getDeptName(), dept.getParentId());
* @param deptId 部门id if (ObjectUtil.isNotNull(info) && info.getDeptId().longValue() != deptId.longValue()) {
*/ return UserConstants.NOT_UNIQUE;
@Override }
public void checkDeptDataScope(Long deptId) { return UserConstants.UNIQUE;
if (!SysUser.isAdmin(SecurityUtils.getUserId())) { }
SysDept dept = new SysDept();
dept.setDeptId(deptId); /**
List<SysDept> depts = SpringUtils.getAopProxy(this).selectDeptList(dept); * 校验部门是否有数据权限
if (StringUtils.isEmpty(depts)) { *
throw new ServiceException("没有权限访问部门数据！"); * @param deptId 部门id
} */
} @Override
} public void checkDeptDataScope(Long deptId) {
if (!SysUser.isAdmin(SecurityUtils.getUserId())) {
/** SysDept dept = new SysDept();
* 新增保存部门信息 dept.setDeptId(deptId);
* List<SysDept> depts = SpringUtils.getAopProxy(this).selectDeptList(dept);
* @param dept 部门信息 if (CollUtil.isEmpty(depts)) {
* @return 结果 throw new ServiceException("没有权限访问部门数据！");
*/ }
@Override }
public int insertDept(SysDept dept) { }
SysDept info = deptMapper.selectDeptById(dept.getParentId());
// 如果父节点不为正常状态,则不允许新增子节点 /**
if (!UserConstants.DEPT_NORMAL.equals(info.getStatus())) { * 新增保存部门信息
throw new ServiceException("部门停用，不允许新增"); *
} * @param dept 部门信息
dept.setAncestors(info.getAncestors() + "," + dept.getParentId()); * @return 结果
return deptMapper.insertDept(dept); */
} @Override
public int insertDept(SysDept dept) {
/** SysDept info = deptMapper.selectDeptById(dept.getParentId());
* 修改保存部门信息 // 如果父节点不为正常状态,则不允许新增子节点
* if (!UserConstants.DEPT_NORMAL.equals(info.getStatus())) {
* @param dept 部门信息 throw new ServiceException("部门停用，不允许新增");
* @return 结果 }
*/ dept.setAncestors(info.getAncestors() + "," + dept.getParentId());
@Override return deptMapper.insertDept(dept);
public int updateDept(SysDept dept) { }
SysDept newParentDept = deptMapper.selectDeptById(dept.getParentId());
SysDept oldDept = deptMapper.selectDeptById(dept.getDeptId()); /**
if (StringUtils.isNotNull(newParentDept) && StringUtils.isNotNull(oldDept)) { * 修改保存部门信息
String newAncestors = newParentDept.getAncestors() + "," + newParentDept.getDeptId(); *
String oldAncestors = oldDept.getAncestors(); * @param dept 部门信息
dept.setAncestors(newAncestors); * @return 结果
updateDeptChildren(dept.getDeptId(), newAncestors, oldAncestors); */
} @Override
int result = deptMapper.updateDept(dept); public int updateDept(SysDept dept) {
if (UserConstants.DEPT_NORMAL.equals(dept.getStatus()) && StringUtils.isNotEmpty(dept.getAncestors()) SysDept newParentDept = deptMapper.selectDeptById(dept.getParentId());
&& !StringUtils.equals("0", dept.getAncestors())) { SysDept oldDept = deptMapper.selectDeptById(dept.getDeptId());
// 如果该部门是启用状态，则启用该部门的所有上级部门 if (ObjectUtil.isNotNull(newParentDept) && ObjectUtil.isNotNull(oldDept)) {
updateParentDeptStatusNormal(dept); String newAncestors = newParentDept.getAncestors() + "," + newParentDept.getDeptId();
} String oldAncestors = oldDept.getAncestors();
return result; dept.setAncestors(newAncestors);
} updateDeptChildren(dept.getDeptId(), newAncestors, oldAncestors);
}
/** int result = deptMapper.updateDept(dept);
* 修改该部门的父级部门状态 if (UserConstants.DEPT_NORMAL.equals(dept.getStatus()) && StringUtils.isNotEmpty(dept.getAncestors())
* && !StringUtils.equals("0", dept.getAncestors())) {
* @param dept 当前部门 // 如果该部门是启用状态，则启用该部门的所有上级部门
*/ updateParentDeptStatusNormal(dept);
private void updateParentDeptStatusNormal(SysDept dept) { }
String ancestors = dept.getAncestors(); return result;
Long[] deptIds = Convert.toLongArray(ancestors); }
deptMapper.updateDeptStatusNormal(deptIds);
} /**
* 修改该部门的父级部门状态
/** *
* 修改子元素关系 * @param dept 当前部门
* */
* @param deptId 被修改的部门ID private void updateParentDeptStatusNormal(SysDept dept) {
* @param newAncestors 新的父ID集合 String ancestors = dept.getAncestors();
* @param oldAncestors 旧的父ID集合 Long[] deptIds = Convert.toLongArray(ancestors);
*/ deptMapper.updateDeptStatusNormal(deptIds);
public void updateDeptChildren(Long deptId, String newAncestors, String oldAncestors) { }
List<SysDept> children = deptMapper.selectChildrenDeptById(deptId);
for (SysDept child : children) { /**
child.setAncestors(child.getAncestors().replaceFirst(oldAncestors, newAncestors)); * 修改子元素关系
} *
if (children.size() > 0) { * @param deptId 被修改的部门ID
deptMapper.updateDeptChildren(children); * @param newAncestors 新的父ID集合
} * @param oldAncestors 旧的父ID集合
} */
public void updateDeptChildren(Long deptId, String newAncestors, String oldAncestors) {
/** List<SysDept> children = deptMapper.selectChildrenDeptById(deptId);
* 删除部门管理信息 for (SysDept child : children) {
* child.setAncestors(child.getAncestors().replaceFirst(oldAncestors, newAncestors));
* @param deptId 部门ID }
* @return 结果 if (children.size() > 0) {
*/ deptMapper.updateDeptChildren(children);
@Override }
public int deleteDeptById(Long deptId) { }
return deptMapper.deleteDeptById(deptId);
} /**
* 删除部门管理信息
/** *
* 递归列表 * @param deptId 部门ID
*/ * @return 结果
private void recursionFn(List<SysDept> list, SysDept t) { */
// 得到子节点列表 @Override
List<SysDept> childList = getChildList(list, t); public int deleteDeptById(Long deptId) {
t.setChildren(childList); return deptMapper.deleteDeptById(deptId);
for (SysDept tChild : childList) { }
if (hasChild(list, tChild)) {
recursionFn(list, tChild); /**
} * 递归列表
} */
} private void recursionFn(List<SysDept> list, SysDept t) {
// 得到子节点列表
/** List<SysDept> childList = getChildList(list, t);
* 得到子节点列表 t.setChildren(childList);
*/ for (SysDept tChild : childList) {
private List<SysDept> getChildList(List<SysDept> list, SysDept t) { if (hasChild(list, tChild)) {
List<SysDept> tlist = new ArrayList<SysDept>(); recursionFn(list, tChild);
Iterator<SysDept> it = list.iterator(); }
while (it.hasNext()) { }
SysDept n = (SysDept) it.next(); }
if (StringUtils.isNotNull(n.getParentId()) && n.getParentId().longValue() == t.getDeptId().longValue()) {
tlist.add(n); /**
} * 得到子节点列表
} */
return tlist; private List<SysDept> getChildList(List<SysDept> list, SysDept t) {
} List<SysDept> tlist = new ArrayList<SysDept>();
for (SysDept n : list) {
/** if (ObjectUtil.isNotNull(n.getParentId()) && n.getParentId().longValue() == t.getDeptId().longValue()) {
* 判断是否有子节点 tlist.add(n);
*/ }
private boolean hasChild(List<SysDept> list, SysDept t) { }
return getChildList(list, t).size() > 0 ? true : false; return tlist;
} }
}
/**
* 判断是否有子节点
*/
private boolean hasChild(List<SysDept> list, SysDept t) {
return getChildList(list, t).size() > 0 ? true : false;
}
}

253
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDictDataServiceImpl.java
View File

@ -1,127 +1,126 @@
package com.ruoyi.system.service.impl; package com.ruoyi.system.service.impl;
import cn.hutool.core.collection.CollUtil; import cn.hutool.core.collection.CollUtil;
import com.ruoyi.common.core.utils.StringUtils; import com.ruoyi.common.dict.utils.DictUtils;
import com.ruoyi.common.dict.utils.DictUtils; import com.ruoyi.system.api.domain.SysDictData;
import com.ruoyi.system.api.domain.SysDictData; import com.ruoyi.system.mapper.SysDictDataMapper;
import com.ruoyi.system.mapper.SysDictDataMapper; import com.ruoyi.system.service.ISysDictDataService;
import com.ruoyi.system.service.ISysDictDataService; import lombok.RequiredArgsConstructor;
import lombok.RequiredArgsConstructor; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.List;
/**
/** * 字典 业务层处理
* 字典 业务层处理 *
* * @author ruoyi
* @author ruoyi */
*/ @RequiredArgsConstructor(onConstructor_ = @Autowired)
@RequiredArgsConstructor(onConstructor_ = @Autowired) @Service
@Service public class SysDictDataServiceImpl implements ISysDictDataService {
public class SysDictDataServiceImpl implements ISysDictDataService {
private final SysDictDataMapper dictDataMapper;
private final SysDictDataMapper dictDataMapper;
/**
/** * 根据条件分页查询字典数据
* 根据条件分页查询字典数据 *
* * @param dictData 字典数据信息
* @param dictData 字典数据信息 * @return 字典数据集合信息
* @return 字典数据集合信息 */
*/ @Override
@Override public List<SysDictData> selectDictDataList(SysDictData dictData) {
public List<SysDictData> selectDictDataList(SysDictData dictData) { return dictDataMapper.selectDictDataList(dictData);
return dictDataMapper.selectDictDataList(dictData); }
}
/**
/** * 根据字典类型和字典键值查询字典数据信息
* 根据字典类型和字典键值查询字典数据信息 *
* * @param dictType 字典类型
* @param dictType 字典类型 * @param dictValue 字典键值
* @param dictValue 字典键值 * @return 字典标签
* @return 字典标签 */
*/ @Override
@Override public String selectDictLabel(String dictType, String dictValue) {
public String selectDictLabel(String dictType, String dictValue) { return dictDataMapper.selectDictLabel(dictType, dictValue);
return dictDataMapper.selectDictLabel(dictType, dictValue); }
}
/**
/** * 根据字典类型查询字典数据
* 根据字典类型查询字典数据 *
* * @param dictType 字典类型
* @param dictType 字典类型 * @return 字典数据集合信息
* @return 字典数据集合信息 */
*/ @Override
@Override public List<SysDictData> selectDictDataByType(String dictType) {
public List<SysDictData> selectDictDataByType(String dictType) { List<SysDictData> dictDatas = DictUtils.getDictCache(dictType);
List<SysDictData> dictDatas = DictUtils.getDictCache(dictType); if (CollUtil.isNotEmpty(dictDatas)) {
if (StringUtils.isNotEmpty(dictDatas)) { return dictDatas;
return dictDatas; }
} dictDatas = dictDataMapper.selectDictDataByType(dictType);
dictDatas = dictDataMapper.selectDictDataByType(dictType); if (CollUtil.isNotEmpty(dictDatas)) {
if (CollUtil.isNotEmpty(dictDatas)) { DictUtils.setDictCache(dictType, dictDatas);
DictUtils.setDictCache(dictType, dictDatas); return dictDatas;
return dictDatas; }
} return null;
return null; }
}
/**
/** * 根据字典数据ID查询信息
* 根据字典数据ID查询信息 *
* * @param dictCode 字典数据ID
* @param dictCode 字典数据ID * @return 字典数据
* @return 字典数据 */
*/ @Override
@Override public SysDictData selectDictDataById(Long dictCode) {
public SysDictData selectDictDataById(Long dictCode) { return dictDataMapper.selectDictDataById(dictCode);
return dictDataMapper.selectDictDataById(dictCode); }
}
/**
/** * 批量删除字典数据信息
* 批量删除字典数据信息 *
* * @param dictCodes 需要删除的字典数据ID
* @param dictCodes 需要删除的字典数据ID * @return 结果
* @return 结果 */
*/ @Override
@Override public void deleteDictDataByIds(Long[] dictCodes) {
public void deleteDictDataByIds(Long[] dictCodes) { for (Long dictCode : dictCodes) {
for (Long dictCode : dictCodes) { SysDictData data = selectDictDataById(dictCode);
SysDictData data = selectDictDataById(dictCode); dictDataMapper.deleteDictDataById(dictCode);
dictDataMapper.deleteDictDataById(dictCode); List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType());
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType()); DictUtils.setDictCache(data.getDictType(), dictDatas);
DictUtils.setDictCache(data.getDictType(), dictDatas); }
} }
}
/**
/** * 新增保存字典数据信息
* 新增保存字典数据信息 *
* * @param data 字典数据信息
* @param data 字典数据信息 * @return 结果
* @return 结果 */
*/ @Override
@Override public int insertDictData(SysDictData data) {
public int insertDictData(SysDictData data) { int row = dictDataMapper.insertDictData(data);
int row = dictDataMapper.insertDictData(data); if (row > 0) {
if (row > 0) { List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType());
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType()); DictUtils.setDictCache(data.getDictType(), dictDatas);
DictUtils.setDictCache(data.getDictType(), dictDatas); }
} return row;
return row; }
}
/**
/** * 修改保存字典数据信息
* 修改保存字典数据信息 *
* * @param data 字典数据信息
* @param data 字典数据信息 * @return 结果
* @return 结果 */
*/ @Override
@Override public int updateDictData(SysDictData data) {
public int updateDictData(SysDictData data) { int row = dictDataMapper.updateDictData(data);
int row = dictDataMapper.updateDictData(data); if (row > 0) {
if (row > 0) { List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType());
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(data.getDictType()); DictUtils.setDictCache(data.getDictType(), dictDatas);
DictUtils.setDictCache(data.getDictType(), dictDatas); }
} return row;
return row; }
} }
}

10
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDictTypeServiceImpl.java
View File

@ -1,5 +1,7 @@
package com.ruoyi.system.service.impl; package com.ruoyi.system.service.impl;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.constant.UserConstants; import com.ruoyi.common.core.constant.UserConstants;
import com.ruoyi.common.core.exception.ServiceException; import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.core.utils.StringUtils; import com.ruoyi.common.core.utils.StringUtils;
@ -70,11 +72,11 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService {
@Override @Override
public List<SysDictData> selectDictDataByType(String dictType) { public List<SysDictData> selectDictDataByType(String dictType) {
List<SysDictData> dictDatas = DictUtils.getDictCache(dictType); List<SysDictData> dictDatas = DictUtils.getDictCache(dictType);
if (StringUtils.isNotEmpty(dictDatas)) { if (CollUtil.isNotEmpty(dictDatas)) {
return dictDatas; return dictDatas;
} }
dictDatas = dictDataMapper.selectDictDataByType(dictType); dictDatas = dictDataMapper.selectDictDataByType(dictType);
if (StringUtils.isNotEmpty(dictDatas)) { if (CollUtil.isNotEmpty(dictDatas)) {
DictUtils.setDictCache(dictType, dictDatas); DictUtils.setDictCache(dictType, dictDatas);
return dictDatas; return dictDatas;
} }
@ -193,9 +195,9 @@ public class SysDictTypeServiceImpl implements ISysDictTypeService {
*/ */
@Override @Override
public String checkDictTypeUnique(SysDictType dict) { public String checkDictTypeUnique(SysDictType dict) {
Long dictId = StringUtils.isNull(dict.getDictId()) ? -1L : dict.getDictId(); Long dictId = ObjectUtil.isNull(dict.getDictId()) ? -1L : dict.getDictId();
SysDictType dictType = dictTypeMapper.checkDictTypeUnique(dict.getDictType()); SysDictType dictType = dictTypeMapper.checkDictTypeUnique(dict.getDictType());
if (StringUtils.isNotNull(dictType) && dictType.getDictId().longValue() != dictId.longValue()) { if (ObjectUtil.isNotNull(dictType) && dictType.getDictId().longValue() != dictId.longValue()) {
return UserConstants.NOT_UNIQUE; return UserConstants.NOT_UNIQUE;
} }
return UserConstants.UNIQUE; return UserConstants.UNIQUE;

867
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysMenuServiceImpl.java
View File

@ -1,444 +1,423 @@
package com.ruoyi.system.service.impl; package com.ruoyi.system.service.impl;
import com.ruoyi.common.core.constant.Constants; import cn.hutool.core.collection.CollUtil;
import com.ruoyi.common.core.constant.UserConstants; import cn.hutool.core.lang.tree.Tree;
import com.ruoyi.common.core.utils.StringUtils; import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.security.utils.SecurityUtils; import com.ruoyi.common.core.constant.Constants;
import com.ruoyi.system.api.domain.SysRole; import com.ruoyi.common.core.constant.UserConstants;
import com.ruoyi.system.api.domain.SysUser; import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.system.domain.SysMenu; import com.ruoyi.common.core.utils.TreeBuildUtils;
import com.ruoyi.system.domain.vo.MetaVo; import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.system.domain.vo.RouterVo; import com.ruoyi.system.api.domain.SysRole;
import com.ruoyi.system.domain.vo.TreeSelect; import com.ruoyi.system.api.domain.SysUser;
import com.ruoyi.system.mapper.SysMenuMapper; import com.ruoyi.system.domain.SysMenu;
import com.ruoyi.system.mapper.SysRoleMapper; import com.ruoyi.system.domain.vo.MetaVo;
import com.ruoyi.system.mapper.SysRoleMenuMapper; import com.ruoyi.system.domain.vo.RouterVo;
import com.ruoyi.system.service.ISysMenuService; import com.ruoyi.system.mapper.SysMenuMapper;
import lombok.RequiredArgsConstructor; import com.ruoyi.system.mapper.SysRoleMapper;
import org.springframework.beans.factory.annotation.Autowired; import com.ruoyi.system.mapper.SysRoleMenuMapper;
import org.springframework.stereotype.Service; import com.ruoyi.system.service.ISysMenuService;
import lombok.RequiredArgsConstructor;
import java.util.*; import org.springframework.beans.factory.annotation.Autowired;
import java.util.stream.Collectors; import org.springframework.stereotype.Service;
/** import java.util.*;
* 菜单 业务层处理
* /**
* @author ruoyi * 菜单 业务层处理
*/ *
@RequiredArgsConstructor(onConstructor_ = @Autowired) * @author ruoyi
@Service */
public class SysMenuServiceImpl implements ISysMenuService { @RequiredArgsConstructor(onConstructor_ = @Autowired)
@Service
private final SysMenuMapper menuMapper; public class SysMenuServiceImpl implements ISysMenuService {
private final SysRoleMapper roleMapper;
private final SysRoleMenuMapper roleMenuMapper; private final SysMenuMapper menuMapper;
private final SysRoleMapper roleMapper;
/** private final SysRoleMenuMapper roleMenuMapper;
* 根据用户查询系统菜单列表
* /**
* @param userId 用户ID * 根据用户查询系统菜单列表
* @return 菜单列表 *
*/ * @param userId 用户ID
@Override * @return 菜单列表
public List<SysMenu> selectMenuList(Long userId) { */
return selectMenuList(new SysMenu(), userId); @Override
} public List<SysMenu> selectMenuList(Long userId) {
return selectMenuList(new SysMenu(), userId);
/** }
* 查询系统菜单列表
* /**
* @param menu 菜单信息 * 查询系统菜单列表
* @return 菜单列表 *
*/ * @param menu 菜单信息
@Override * @return 菜单列表
public List<SysMenu> selectMenuList(SysMenu menu, Long userId) { */
List<SysMenu> menuList = null; @Override
// 管理员显示所有菜单信息 public List<SysMenu> selectMenuList(SysMenu menu, Long userId) {
if (SysUser.isAdmin(userId)) { List<SysMenu> menuList = null;
menuList = menuMapper.selectMenuList(menu); // 管理员显示所有菜单信息
} else { if (SysUser.isAdmin(userId)) {
menu.getParams().put("userId", userId); menuList = menuMapper.selectMenuList(menu);
menuList = menuMapper.selectMenuListByUserId(menu); } else {
} menu.getParams().put("userId", userId);
return menuList; menuList = menuMapper.selectMenuListByUserId(menu);
} }
return menuList;
/** }
* 根据用户ID查询权限
* /**
* @param userId 用户ID * 根据用户ID查询权限
* @return 权限列表 *
*/ * @param userId 用户ID
@Override * @return 权限列表
public Set<String> selectMenuPermsByUserId(Long userId) { */
List<String> perms = menuMapper.selectMenuPermsByUserId(userId); @Override
Set<String> permsSet = new HashSet<>(); public Set<String> selectMenuPermsByUserId(Long userId) {
for (String perm : perms) { List<String> perms = menuMapper.selectMenuPermsByUserId(userId);
if (StringUtils.isNotEmpty(perm)) { Set<String> permsSet = new HashSet<>();
permsSet.addAll(Arrays.asList(perm.trim().split(","))); for (String perm : perms) {
} if (StringUtils.isNotEmpty(perm)) {
} permsSet.addAll(Arrays.asList(perm.trim().split(",")));
return permsSet; }
} }
return permsSet;
/** }
* 根据用户ID查询菜单
* /**
* @param userId 用户名称 * 根据用户ID查询菜单
* @return 菜单列表 *
*/ * @param userId 用户名称
@Override * @return 菜单列表
public List<SysMenu> selectMenuTreeByUserId(Long userId) { */
List<SysMenu> menus = null; @Override
if (SecurityUtils.isAdmin(userId)) { public List<SysMenu> selectMenuTreeByUserId(Long userId) {
menus = menuMapper.selectMenuTreeAll(); List<SysMenu> menus = null;
} else { if (SecurityUtils.isAdmin(userId)) {
menus = menuMapper.selectMenuTreeByUserId(userId); menus = menuMapper.selectMenuTreeAll();
} } else {
return getChildPerms(menus, 0); menus = menuMapper.selectMenuTreeByUserId(userId);
} }
return getChildPerms(menus, 0);
/** }
* 根据角色ID查询菜单树信息
* /**
* @param roleId 角色ID * 根据角色ID查询菜单树信息
* @return 选中菜单列表 *
*/ * @param roleId 角色ID
@Override * @return 选中菜单列表
public List<Long> selectMenuListByRoleId(Long roleId) { */
SysRole role = roleMapper.selectRoleById(roleId); @Override
return menuMapper.selectMenuListByRoleId(roleId, role.isMenuCheckStrictly()); public List<Long> selectMenuListByRoleId(Long roleId) {
} SysRole role = roleMapper.selectRoleById(roleId);
return menuMapper.selectMenuListByRoleId(roleId, role.isMenuCheckStrictly());
/** }
* 构建前端路由所需要的菜单
* /**
* @param menus 菜单列表 * 构建前端路由所需要的菜单
* @return 路由列表 *
*/ * @param menus 菜单列表
@Override * @return 路由列表
public List<RouterVo> buildMenus(List<SysMenu> menus) { */
List<RouterVo> routers = new LinkedList<RouterVo>(); @Override
for (SysMenu menu : menus) { public List<RouterVo> buildMenus(List<SysMenu> menus) {
RouterVo router = new RouterVo(); List<RouterVo> routers = new LinkedList<RouterVo>();
router.setHidden("1".equals(menu.getVisible())); for (SysMenu menu : menus) {
router.setName(getRouteName(menu)); RouterVo router = new RouterVo();
router.setPath(getRouterPath(menu)); router.setHidden("1".equals(menu.getVisible()));
router.setComponent(getComponent(menu)); router.setName(getRouteName(menu));
router.setQuery(menu.getQuery()); router.setPath(getRouterPath(menu));
router.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), StringUtils.equals("1", menu.getIsCache()), menu.getPath())); router.setComponent(getComponent(menu));
List<SysMenu> cMenus = menu.getChildren(); router.setQuery(menu.getQuery());
if (!cMenus.isEmpty() && cMenus.size() > 0 && UserConstants.TYPE_DIR.equals(menu.getMenuType())) { router.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), StringUtils.equals("1", menu.getIsCache()), menu.getPath()));
router.setAlwaysShow(true); List<SysMenu> cMenus = (List<SysMenu>) menu.getChildren();
router.setRedirect("noRedirect"); if (!cMenus.isEmpty() && cMenus.size() > 0 && UserConstants.TYPE_DIR.equals(menu.getMenuType())) {
router.setChildren(buildMenus(cMenus)); router.setAlwaysShow(true);
} else if (isMenuFrame(menu)) { router.setRedirect("noRedirect");
router.setMeta(null); router.setChildren(buildMenus(cMenus));
List<RouterVo> childrenList = new ArrayList<RouterVo>(); } else if (isMenuFrame(menu)) {
RouterVo children = new RouterVo(); router.setMeta(null);
children.setPath(menu.getPath()); List<RouterVo> childrenList = new ArrayList<RouterVo>();
children.setComponent(menu.getComponent()); RouterVo children = new RouterVo();
children.setName(StringUtils.capitalize(menu.getPath())); children.setPath(menu.getPath());
children.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), StringUtils.equals("1", menu.getIsCache()), menu.getPath())); children.setComponent(menu.getComponent());
children.setQuery(menu.getQuery()); children.setName(StringUtils.capitalize(menu.getPath()));
childrenList.add(children); children.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), StringUtils.equals("1", menu.getIsCache()), menu.getPath()));
router.setChildren(childrenList); children.setQuery(menu.getQuery());
} else if (menu.getParentId().intValue() == 0 && isInnerLink(menu)) { childrenList.add(children);
router.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon())); router.setChildren(childrenList);
router.setPath("/inner"); } else if (menu.getParentId().intValue() == 0 && isInnerLink(menu)) {
List<RouterVo> childrenList = new ArrayList<RouterVo>(); router.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon()));
RouterVo children = new RouterVo(); router.setPath("/inner");
String routerPath = innerLinkReplaceEach(menu.getPath()); List<RouterVo> childrenList = new ArrayList<RouterVo>();
children.setPath(routerPath); RouterVo children = new RouterVo();
children.setComponent(UserConstants.INNER_LINK); String routerPath = innerLinkReplaceEach(menu.getPath());
children.setName(StringUtils.capitalize(routerPath)); children.setPath(routerPath);
children.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), menu.getPath())); children.setComponent(UserConstants.INNER_LINK);
childrenList.add(children); children.setName(StringUtils.capitalize(routerPath));
router.setChildren(childrenList); children.setMeta(new MetaVo(menu.getMenuName(), menu.getIcon(), menu.getPath()));
} childrenList.add(children);
routers.add(router); router.setChildren(childrenList);
} }
return routers; routers.add(router);
} }
return routers;
/** }
* 构建前端所需要树结构
* /**
* @param menus 菜单列表 * 构建前端所需要下拉树结构
* @return 树结构列表 *
*/ * @param menus 菜单列表
@Override * @return 下拉树结构列表
public List<SysMenu> buildMenuTree(List<SysMenu> menus) { */
List<SysMenu> returnList = new ArrayList<SysMenu>(); @Override
List<Long> tempList = new ArrayList<Long>(); public List<Tree<Long>> buildMenuTreeSelect(List<SysMenu> menus) {
for (SysMenu dept : menus) { if (CollUtil.isEmpty(menus)) {
tempList.add(dept.getMenuId()); return CollUtil.newArrayList();
} }
for (Iterator<SysMenu> iterator = menus.iterator(); iterator.hasNext(); ) { Long parentId = menus.get(0).getParentId();
SysMenu menu = (SysMenu) iterator.next(); return TreeBuildUtils.build(menus, parentId, (menu, tree) ->
// 如果是顶级节点, 遍历该父节点的所有子节点 tree.setId(menu.getMenuId())
if (!tempList.contains(menu.getParentId())) { .setParentId(menu.getParentId())
recursionFn(menus, menu); .setName(menu.getMenuName())
returnList.add(menu); .setWeight(menu.getOrderNum()));
} }
}
if (returnList.isEmpty()) { /**
returnList = menus; * 根据菜单ID查询信息
} *
return returnList; * @param menuId 菜单ID
} * @return 菜单信息
*/
/** @Override
* 构建前端所需要下拉树结构 public SysMenu selectMenuById(Long menuId) {
* return menuMapper.selectMenuById(menuId);
* @param menus 菜单列表 }
* @return 下拉树结构列表
*/ /**
@Override * 是否存在菜单子节点
public List<TreeSelect> buildMenuTreeSelect(List<SysMenu> menus) { *
List<SysMenu> menuTrees = buildMenuTree(menus); * @param menuId 菜单ID
return menuTrees.stream().map(TreeSelect::new).collect(Collectors.toList()); * @return 结果
} */
@Override
/** public boolean hasChildByMenuId(Long menuId) {
* 根据菜单ID查询信息 int result = menuMapper.hasChildByMenuId(menuId);
* return result > 0 ? true : false;
* @param menuId 菜单ID }
* @return 菜单信息
*/ /**
@Override * 查询菜单使用数量
public SysMenu selectMenuById(Long menuId) { *
return menuMapper.selectMenuById(menuId); * @param menuId 菜单ID
} * @return 结果
*/
/** @Override
* 是否存在菜单子节点 public boolean checkMenuExistRole(Long menuId) {
* int result = roleMenuMapper.checkMenuExistRole(menuId);
* @param menuId 菜单ID return result > 0 ? true : false;
* @return 结果 }
*/
@Override /**
public boolean hasChildByMenuId(Long menuId) { * 新增保存菜单信息
int result = menuMapper.hasChildByMenuId(menuId); *
return result > 0 ? true : false; * @param menu 菜单信息
} * @return 结果
*/
/** @Override
* 查询菜单使用数量 public int insertMenu(SysMenu menu) {
* return menuMapper.insertMenu(menu);
* @param menuId 菜单ID }
* @return 结果
*/ /**
@Override * 修改保存菜单信息
public boolean checkMenuExistRole(Long menuId) { *
int result = roleMenuMapper.checkMenuExistRole(menuId); * @param menu 菜单信息
return result > 0 ? true : false; * @return 结果
} */
@Override
/** public int updateMenu(SysMenu menu) {
* 新增保存菜单信息 return menuMapper.updateMenu(menu);
* }
* @param menu 菜单信息
* @return 结果 /**
*/ * 删除菜单管理信息
@Override *
public int insertMenu(SysMenu menu) { * @param menuId 菜单ID
return menuMapper.insertMenu(menu); * @return 结果
} */
@Override
/** public int deleteMenuById(Long menuId) {
* 修改保存菜单信息 return menuMapper.deleteMenuById(menuId);
* }
* @param menu 菜单信息
* @return 结果 /**
*/ * 校验菜单名称是否唯一
@Override *
public int updateMenu(SysMenu menu) { * @param menu 菜单信息
return menuMapper.updateMenu(menu); * @return 结果
} */
@Override
/** public String checkMenuNameUnique(SysMenu menu) {
* 删除菜单管理信息 Long menuId = ObjectUtil.isNull(menu.getMenuId()) ? -1L : menu.getMenuId();
* SysMenu info = menuMapper.checkMenuNameUnique(menu.getMenuName(), menu.getParentId());
* @param menuId 菜单ID if (ObjectUtil.isNotNull(info) && info.getMenuId().longValue() != menuId.longValue()) {
* @return 结果 return UserConstants.NOT_UNIQUE;
*/ }
@Override return UserConstants.UNIQUE;
public int deleteMenuById(Long menuId) { }
return menuMapper.deleteMenuById(menuId);
} /**
* 获取路由名称
/** *
* 校验菜单名称是否唯一 * @param menu 菜单信息
* * @return 路由名称
* @param menu 菜单信息 */
* @return 结果 public String getRouteName(SysMenu menu) {
*/ String routerName = StringUtils.capitalize(menu.getPath());
@Override // 非外链并且是一级目录（类型为目录）
public String checkMenuNameUnique(SysMenu menu) { if (isMenuFrame(menu)) {
Long menuId = StringUtils.isNull(menu.getMenuId()) ? -1L : menu.getMenuId(); routerName = StringUtils.EMPTY;
SysMenu info = menuMapper.checkMenuNameUnique(menu.getMenuName(), menu.getParentId()); }
if (StringUtils.isNotNull(info) && info.getMenuId().longValue() != menuId.longValue()) { return routerName;
return UserConstants.NOT_UNIQUE; }
}
return UserConstants.UNIQUE; /**
} * 获取路由地址
*
/** * @param menu 菜单信息
* 获取路由名称 * @return 路由地址
* */
* @param menu 菜单信息 public String getRouterPath(SysMenu menu) {
* @return 路由名称 String routerPath = menu.getPath();
*/ // 内链打开外网方式
public String getRouteName(SysMenu menu) { if (menu.getParentId().intValue() != 0 && isInnerLink(menu)) {
String routerName = StringUtils.capitalize(menu.getPath()); routerPath = innerLinkReplaceEach(routerPath);
// 非外链并且是一级目录（类型为目录） }
if (isMenuFrame(menu)) { // 非外链并且是一级目录（类型为目录）
routerName = StringUtils.EMPTY; if (0 == menu.getParentId().intValue() && UserConstants.TYPE_DIR.equals(menu.getMenuType())
} && UserConstants.NO_FRAME.equals(menu.getIsFrame())) {
return routerName; routerPath = "/" + menu.getPath();
} }
// 非外链并且是一级目录（类型为菜单）
/** else if (isMenuFrame(menu)) {
* 获取路由地址 routerPath = "/";
* }
* @param menu 菜单信息 return routerPath;
* @return 路由地址 }
*/
public String getRouterPath(SysMenu menu) { /**
String routerPath = menu.getPath(); * 获取组件信息
// 内链打开外网方式 *
if (menu.getParentId().intValue() != 0 && isInnerLink(menu)) { * @param menu 菜单信息
routerPath = innerLinkReplaceEach(routerPath); * @return 组件信息
} */
// 非外链并且是一级目录（类型为目录） public String getComponent(SysMenu menu) {
if (0 == menu.getParentId().intValue() && UserConstants.TYPE_DIR.equals(menu.getMenuType()) String component = UserConstants.LAYOUT;
&& UserConstants.NO_FRAME.equals(menu.getIsFrame())) { if (StringUtils.isNotEmpty(menu.getComponent()) && !isMenuFrame(menu)) {
routerPath = "/" + menu.getPath(); component = menu.getComponent();
} } else if (StringUtils.isEmpty(menu.getComponent()) && menu.getParentId().intValue() != 0 && isInnerLink(menu)) {
// 非外链并且是一级目录（类型为菜单） component = UserConstants.INNER_LINK;
else if (isMenuFrame(menu)) { } else if (StringUtils.isEmpty(menu.getComponent()) && isParentView(menu)) {
routerPath = "/"; component = UserConstants.PARENT_VIEW;
} }
return routerPath; return component;
} }
/** /**
* 获取组件信息 * 是否为菜单内部跳转
* *
* @param menu 菜单信息 * @param menu 菜单信息
* @return 组件信息 * @return 结果
*/ */
public String getComponent(SysMenu menu) { public boolean isMenuFrame(SysMenu menu) {
String component = UserConstants.LAYOUT; return menu.getParentId().intValue() == 0 && UserConstants.TYPE_MENU.equals(menu.getMenuType())
if (StringUtils.isNotEmpty(menu.getComponent()) && !isMenuFrame(menu)) { && menu.getIsFrame().equals(UserConstants.NO_FRAME);
component = menu.getComponent(); }
} else if (StringUtils.isEmpty(menu.getComponent()) && menu.getParentId().intValue() != 0 && isInnerLink(menu)) {
component = UserConstants.INNER_LINK; /**
} else if (StringUtils.isEmpty(menu.getComponent()) && isParentView(menu)) { * 是否为内链组件
component = UserConstants.PARENT_VIEW; *
} * @param menu 菜单信息
return component; * @return 结果
} */
public boolean isInnerLink(SysMenu menu) {
/** return menu.getIsFrame().equals(UserConstants.NO_FRAME) && StringUtils.ishttp(menu.getPath());
* 是否为菜单内部跳转 }
*
* @param menu 菜单信息 /**
* @return 结果 * 是否为parent_view组件
*/ *
public boolean isMenuFrame(SysMenu menu) { * @param menu 菜单信息
return menu.getParentId().intValue() == 0 && UserConstants.TYPE_MENU.equals(menu.getMenuType()) * @return 结果
&& menu.getIsFrame().equals(UserConstants.NO_FRAME); */
} public boolean isParentView(SysMenu menu) {
return menu.getParentId().intValue() != 0 && UserConstants.TYPE_DIR.equals(menu.getMenuType());
/** }
* 是否为内链组件
* /**
* @param menu 菜单信息 * 根据父节点的ID获取所有子节点
* @return 结果 *
*/ * @param list 分类表
public boolean isInnerLink(SysMenu menu) { * @param parentId 传入的父节点ID
return menu.getIsFrame().equals(UserConstants.NO_FRAME) && StringUtils.ishttp(menu.getPath()); * @return String
} */
public List<SysMenu> getChildPerms(List<SysMenu> list, int parentId) {
/** List<SysMenu> returnList = new ArrayList<SysMenu>();
* 是否为parent_view组件 for (SysMenu t : list) {
* // 一、根据传入的某个父节点ID,遍历该父节点的所有子节点
* @param menu 菜单信息 if (t.getParentId() == parentId) {
* @return 结果 recursionFn(list, t);
*/ returnList.add(t);
public boolean isParentView(SysMenu menu) { }
return menu.getParentId().intValue() != 0 && UserConstants.TYPE_DIR.equals(menu.getMenuType()); }
} return returnList;
}
/**
* 根据父节点的ID获取所有子节点 /**
* * 递归列表
* @param list 分类表 *
* @param parentId 传入的父节点ID * @param list
* @return String * @param t
*/ */
public List<SysMenu> getChildPerms(List<SysMenu> list, int parentId) { private void recursionFn(List<SysMenu> list, SysMenu t) {
List<SysMenu> returnList = new ArrayList<SysMenu>(); // 得到子节点列表
for (Iterator<SysMenu> iterator = list.iterator(); iterator.hasNext(); ) { List<SysMenu> childList = getChildList(list, t);
SysMenu t = (SysMenu) iterator.next(); t.setChildren(childList);
// 一、根据传入的某个父节点ID,遍历该父节点的所有子节点 for (SysMenu tChild : childList) {
if (t.getParentId() == parentId) { if (hasChild(list, tChild)) {
recursionFn(list, t); recursionFn(list, tChild);
returnList.add(t); }
} }
} }
return returnList;
} /**
* 得到子节点列表
/** */
* 递归列表 private List<SysMenu> getChildList(List<SysMenu> list, SysMenu t) {
* List<SysMenu> tlist = new ArrayList<SysMenu>();
* @param list for (SysMenu n : list) {
* @param t if (n.getParentId().longValue() == t.getMenuId().longValue()) {
*/ tlist.add(n);
private void recursionFn(List<SysMenu> list, SysMenu t) { }
// 得到子节点列表 }
List<SysMenu> childList = getChildList(list, t); return tlist;
t.setChildren(childList); }
for (SysMenu tChild : childList) {
if (hasChild(list, tChild)) { /**
recursionFn(list, tChild); * 判断是否有子节点
} */
} private boolean hasChild(List<SysMenu> list, SysMenu t) {
} return getChildList(list, t).size() > 0 ? true : false;
}
/**
* 得到子节点列表 /**
*/ * 内链域名特殊字符替换
private List<SysMenu> getChildList(List<SysMenu> list, SysMenu t) { *
List<SysMenu> tlist = new ArrayList<SysMenu>(); * @return
Iterator<SysMenu> it = list.iterator(); */
while (it.hasNext()) { public String innerLinkReplaceEach(String path) {
SysMenu n = (SysMenu) it.next(); return StringUtils.replaceEach(path, new String[]{Constants.HTTP, Constants.HTTPS},
if (n.getParentId().longValue() == t.getMenuId().longValue()) { new String[]{"", ""});
tlist.add(n); }
} }
}
return tlist;
}
/**
* 判断是否有子节点
*/
private boolean hasChild(List<SysMenu> list, SysMenu t) {
return getChildList(list, t).size() > 0 ? true : false;
}
/**
* 内链域名特殊字符替换
*
* @return
*/
public String innerLinkReplaceEach(String path) {
return StringUtils.replaceEach(path, new String[]{Constants.HTTP, Constants.HTTPS},
new String[]{"", ""});
}
}

328
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysPostServiceImpl.java
View File

@ -1,164 +1,164 @@
package com.ruoyi.system.service.impl; package com.ruoyi.system.service.impl;
import com.ruoyi.common.core.constant.UserConstants; import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.exception.ServiceException; import com.ruoyi.common.core.constant.UserConstants;
import com.ruoyi.common.core.utils.StringUtils; import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.system.domain.SysPost; import com.ruoyi.system.domain.SysPost;
import com.ruoyi.system.mapper.SysPostMapper; import com.ruoyi.system.mapper.SysPostMapper;
import com.ruoyi.system.mapper.SysUserPostMapper; import com.ruoyi.system.mapper.SysUserPostMapper;
import com.ruoyi.system.service.ISysPostService; import com.ruoyi.system.service.ISysPostService;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.util.List; import java.util.List;
/** /**
* 岗位信息 服务层处理 * 岗位信息 服务层处理
* *
* @author ruoyi * @author ruoyi
*/ */
@RequiredArgsConstructor(onConstructor_ = @Autowired) @RequiredArgsConstructor(onConstructor_ = @Autowired)
@Service @Service
public class SysPostServiceImpl implements ISysPostService { public class SysPostServiceImpl implements ISysPostService {
private final SysPostMapper postMapper; private final SysPostMapper postMapper;
private final SysUserPostMapper userPostMapper; private final SysUserPostMapper userPostMapper;
/** /**
* 查询岗位信息集合 * 查询岗位信息集合
* *
* @param post 岗位信息 * @param post 岗位信息
* @return 岗位信息集合 * @return 岗位信息集合
*/ */
@Override @Override
public List<SysPost> selectPostList(SysPost post) { public List<SysPost> selectPostList(SysPost post) {
return postMapper.selectPostList(post); return postMapper.selectPostList(post);
} }
/** /**
* 查询所有岗位 * 查询所有岗位
* *
* @return 岗位列表 * @return 岗位列表
*/ */
@Override @Override
public List<SysPost> selectPostAll() { public List<SysPost> selectPostAll() {
return postMapper.selectPostAll(); return postMapper.selectPostAll();
} }
/** /**
* 通过岗位ID查询岗位信息 * 通过岗位ID查询岗位信息
* *
* @param postId 岗位ID * @param postId 岗位ID
* @return 角色对象信息 * @return 角色对象信息
*/ */
@Override @Override
public SysPost selectPostById(Long postId) { public SysPost selectPostById(Long postId) {
return postMapper.selectPostById(postId); return postMapper.selectPostById(postId);
} }
/** /**
* 根据用户ID获取岗位选择框列表 * 根据用户ID获取岗位选择框列表
* *
* @param userId 用户ID * @param userId 用户ID
* @return 选中岗位ID列表 * @return 选中岗位ID列表
*/ */
@Override @Override
public List<Long> selectPostListByUserId(Long userId) { public List<Long> selectPostListByUserId(Long userId) {
return postMapper.selectPostListByUserId(userId); return postMapper.selectPostListByUserId(userId);
} }
/** /**
* 校验岗位名称是否唯一 * 校验岗位名称是否唯一
* *
* @param post 岗位信息 * @param post 岗位信息
* @return 结果 * @return 结果
*/ */
@Override @Override
public String checkPostNameUnique(SysPost post) { public String checkPostNameUnique(SysPost post) {
Long postId = StringUtils.isNull(post.getPostId()) ? -1L : post.getPostId(); Long postId = ObjectUtil.isNull(post.getPostId()) ? -1L : post.getPostId();
SysPost info = postMapper.checkPostNameUnique(post.getPostName()); SysPost info = postMapper.checkPostNameUnique(post.getPostName());
if (StringUtils.isNotNull(info) && info.getPostId().longValue() != postId.longValue()) { if (ObjectUtil.isNotNull(info) && info.getPostId().longValue() != postId.longValue()) {
return UserConstants.NOT_UNIQUE; return UserConstants.NOT_UNIQUE;
} }
return UserConstants.UNIQUE; return UserConstants.UNIQUE;
} }
/** /**
* 校验岗位编码是否唯一 * 校验岗位编码是否唯一
* *
* @param post 岗位信息 * @param post 岗位信息
* @return 结果 * @return 结果
*/ */
@Override @Override
public String checkPostCodeUnique(SysPost post) { public String checkPostCodeUnique(SysPost post) {
Long postId = StringUtils.isNull(post.getPostId()) ? -1L : post.getPostId(); Long postId = ObjectUtil.isNull(post.getPostId()) ? -1L : post.getPostId();
SysPost info = postMapper.checkPostCodeUnique(post.getPostCode()); SysPost info = postMapper.checkPostCodeUnique(post.getPostCode());
if (StringUtils.isNotNull(info) && info.getPostId().longValue() != postId.longValue()) { if (ObjectUtil.isNotNull(info) && info.getPostId().longValue() != postId.longValue()) {
return UserConstants.NOT_UNIQUE; return UserConstants.NOT_UNIQUE;
} }
return UserConstants.UNIQUE; return UserConstants.UNIQUE;
} }
/** /**
* 通过岗位ID查询岗位使用数量 * 通过岗位ID查询岗位使用数量
* *
* @param postId 岗位ID * @param postId 岗位ID
* @return 结果 * @return 结果
*/ */
@Override @Override
public int countUserPostById(Long postId) { public int countUserPostById(Long postId) {
return userPostMapper.countUserPostById(postId); return userPostMapper.countUserPostById(postId);
} }
/** /**
* 删除岗位信息 * 删除岗位信息
* *
* @param postId 岗位ID * @param postId 岗位ID
* @return 结果 * @return 结果
*/ */
@Override @Override
public int deletePostById(Long postId) { public int deletePostById(Long postId) {
return postMapper.deletePostById(postId); return postMapper.deletePostById(postId);
} }
/** /**
* 批量删除岗位信息 * 批量删除岗位信息
* *
* @param postIds 需要删除的岗位ID * @param postIds 需要删除的岗位ID
* @return 结果 * @return 结果
* @throws Exception 异常 * @throws Exception 异常
*/ */
@Override @Override
public int deletePostByIds(Long[] postIds) { public int deletePostByIds(Long[] postIds) {
for (Long postId : postIds) { for (Long postId : postIds) {
SysPost post = selectPostById(postId); SysPost post = selectPostById(postId);
if (countUserPostById(postId) > 0) { if (countUserPostById(postId) > 0) {
throw new ServiceException(String.format("%1$s已分配,不能删除", post.getPostName())); throw new ServiceException(String.format("%1$s已分配,不能删除", post.getPostName()));
} }
} }
return postMapper.deletePostByIds(postIds); return postMapper.deletePostByIds(postIds);
} }
/** /**
* 新增保存岗位信息 * 新增保存岗位信息
* *
* @param post 岗位信息 * @param post 岗位信息
* @return 结果 * @return 结果
*/ */
@Override @Override
public int insertPost(SysPost post) { public int insertPost(SysPost post) {
return postMapper.insertPost(post); return postMapper.insertPost(post);
} }
/** /**
* 修改保存岗位信息 * 修改保存岗位信息
* *
* @param post 岗位信息 * @param post 岗位信息
* @return 结果 * @return 结果
*/ */
@Override @Override
public int updatePost(SysPost post) { public int updatePost(SysPost post) {
return postMapper.updatePost(post); return postMapper.updatePost(post);
} }
} }

753
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysRoleServiceImpl.java
View File

@ -1,376 +1,377 @@
package com.ruoyi.system.service.impl; package com.ruoyi.system.service.impl;
import com.ruoyi.common.core.constant.UserConstants; import cn.hutool.core.collection.CollUtil;
import com.ruoyi.common.core.exception.ServiceException; import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.utils.SpringUtils; import com.ruoyi.common.core.constant.UserConstants;
import com.ruoyi.common.core.utils.StringUtils; import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.datascope.annotation.DataScope; import com.ruoyi.common.core.utils.SpringUtils;
import com.ruoyi.common.security.utils.SecurityUtils; import com.ruoyi.common.datascope.annotation.DataScope;
import com.ruoyi.system.api.domain.SysRole; import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.system.api.domain.SysUser; import com.ruoyi.system.api.domain.SysRole;
import com.ruoyi.system.domain.SysRoleDept; import com.ruoyi.system.api.domain.SysUser;
import com.ruoyi.system.domain.SysRoleMenu; import com.ruoyi.system.domain.SysRoleDept;
import com.ruoyi.system.domain.SysUserRole; import com.ruoyi.system.domain.SysRoleMenu;
import com.ruoyi.system.mapper.SysRoleDeptMapper; import com.ruoyi.system.domain.SysUserRole;
import com.ruoyi.system.mapper.SysRoleMapper; import com.ruoyi.system.mapper.SysRoleDeptMapper;
import com.ruoyi.system.mapper.SysRoleMenuMapper; import com.ruoyi.system.mapper.SysRoleMapper;
import com.ruoyi.system.mapper.SysUserRoleMapper; import com.ruoyi.system.mapper.SysRoleMenuMapper;
import com.ruoyi.system.service.ISysRoleService; import com.ruoyi.system.mapper.SysUserRoleMapper;
import lombok.RequiredArgsConstructor; import com.ruoyi.system.service.ISysRoleService;
import org.springframework.beans.factory.annotation.Autowired; import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import java.util.*;
/**
* 角色 业务层处理 /**
* * 角色 业务层处理
* @author ruoyi *
*/ * @author ruoyi
@RequiredArgsConstructor(onConstructor_ = @Autowired) */
@Service @RequiredArgsConstructor(onConstructor_ = @Autowired)
public class SysRoleServiceImpl implements ISysRoleService { @Service
public class SysRoleServiceImpl implements ISysRoleService {
private final SysRoleMapper roleMapper;
private final SysRoleMenuMapper roleMenuMapper; private final SysRoleMapper roleMapper;
private final SysUserRoleMapper userRoleMapper; private final SysRoleMenuMapper roleMenuMapper;
private final SysRoleDeptMapper roleDeptMapper; private final SysUserRoleMapper userRoleMapper;
private final SysRoleDeptMapper roleDeptMapper;
/**
* 根据条件分页查询角色数据 /**
* * 根据条件分页查询角色数据
* @param role 角色信息 *
* @return 角色数据集合信息 * @param role 角色信息
*/ * @return 角色数据集合信息
@Override */
@DataScope(deptAlias = "d") @Override
public List<SysRole> selectRoleList(SysRole role) { @DataScope(deptAlias = "d")
return roleMapper.selectRoleList(role); public List<SysRole> selectRoleList(SysRole role) {
} return roleMapper.selectRoleList(role);
}
/**
* 根据用户ID查询角色 /**
* * 根据用户ID查询角色
* @param userId 用户ID *
* @return 角色列表 * @param userId 用户ID
*/ * @return 角色列表
@Override */
public List<SysRole> selectRolesByUserId(Long userId) { @Override
List<SysRole> userRoles = roleMapper.selectRolePermissionByUserId(userId); public List<SysRole> selectRolesByUserId(Long userId) {
List<SysRole> roles = selectRoleAll(); List<SysRole> userRoles = roleMapper.selectRolePermissionByUserId(userId);
for (SysRole role : roles) { List<SysRole> roles = selectRoleAll();
for (SysRole userRole : userRoles) { for (SysRole role : roles) {
if (role.getRoleId().longValue() == userRole.getRoleId().longValue()) { for (SysRole userRole : userRoles) {
role.setFlag(true); if (role.getRoleId().longValue() == userRole.getRoleId().longValue()) {
break; role.setFlag(true);
} break;
} }
} }
return roles; }
} return roles;
}
/**
* 根据用户ID查询权限 /**
* * 根据用户ID查询权限
* @param userId 用户ID *
* @return 权限列表 * @param userId 用户ID
*/ * @return 权限列表
@Override */
public Set<String> selectRolePermissionByUserId(Long userId) { @Override
List<SysRole> perms = roleMapper.selectRolePermissionByUserId(userId); public Set<String> selectRolePermissionByUserId(Long userId) {
Set<String> permsSet = new HashSet<>(); List<SysRole> perms = roleMapper.selectRolePermissionByUserId(userId);
for (SysRole perm : perms) { Set<String> permsSet = new HashSet<>();
if (StringUtils.isNotNull(perm)) { for (SysRole perm : perms) {
permsSet.addAll(Arrays.asList(perm.getRoleKey().trim().split(","))); if (ObjectUtil.isNotNull(perm)) {
} permsSet.addAll(Arrays.asList(perm.getRoleKey().trim().split(",")));
} }
return permsSet; }
} return permsSet;
}
/**
* 查询所有角色 /**
* * 查询所有角色
* @return 角色列表 *
*/ * @return 角色列表
@Override */
public List<SysRole> selectRoleAll() { @Override
return SpringUtils.getAopProxy(this).selectRoleList(new SysRole()); public List<SysRole> selectRoleAll() {
} return SpringUtils.getAopProxy(this).selectRoleList(new SysRole());
}
/**
* 根据用户ID获取角色选择框列表 /**
* * 根据用户ID获取角色选择框列表
* @param userId 用户ID *
* @return 选中角色ID列表 * @param userId 用户ID
*/ * @return 选中角色ID列表
@Override */
public List<Long> selectRoleListByUserId(Long userId) { @Override
return roleMapper.selectRoleListByUserId(userId); public List<Long> selectRoleListByUserId(Long userId) {
} return roleMapper.selectRoleListByUserId(userId);
}
/**
* 通过角色ID查询角色 /**
* * 通过角色ID查询角色
* @param roleId 角色ID *
* @return 角色对象信息 * @param roleId 角色ID
*/ * @return 角色对象信息
@Override */
public SysRole selectRoleById(Long roleId) { @Override
return roleMapper.selectRoleById(roleId); public SysRole selectRoleById(Long roleId) {
} return roleMapper.selectRoleById(roleId);
}
/**
* 校验角色名称是否唯一 /**
* * 校验角色名称是否唯一
* @param role 角色信息 *
* @return 结果 * @param role 角色信息
*/ * @return 结果
@Override */
public String checkRoleNameUnique(SysRole role) { @Override
Long roleId = StringUtils.isNull(role.getRoleId()) ? -1L : role.getRoleId(); public String checkRoleNameUnique(SysRole role) {
SysRole info = roleMapper.checkRoleNameUnique(role.getRoleName()); Long roleId = ObjectUtil.isNull(role.getRoleId()) ? -1L : role.getRoleId();
if (StringUtils.isNotNull(info) && info.getRoleId().longValue() != roleId.longValue()) { SysRole info = roleMapper.checkRoleNameUnique(role.getRoleName());
return UserConstants.NOT_UNIQUE; if (ObjectUtil.isNotNull(info) && info.getRoleId().longValue() != roleId.longValue()) {
} return UserConstants.NOT_UNIQUE;
return UserConstants.UNIQUE; }
} return UserConstants.UNIQUE;
}
/**
* 校验角色权限是否唯一 /**
* * 校验角色权限是否唯一
* @param role 角色信息 *
* @return 结果 * @param role 角色信息
*/ * @return 结果
@Override */
public String checkRoleKeyUnique(SysRole role) { @Override
Long roleId = StringUtils.isNull(role.getRoleId()) ? -1L : role.getRoleId(); public String checkRoleKeyUnique(SysRole role) {
SysRole info = roleMapper.checkRoleKeyUnique(role.getRoleKey()); Long roleId = ObjectUtil.isNull(role.getRoleId()) ? -1L : role.getRoleId();
if (StringUtils.isNotNull(info) && info.getRoleId().longValue() != roleId.longValue()) { SysRole info = roleMapper.checkRoleKeyUnique(role.getRoleKey());
return UserConstants.NOT_UNIQUE; if (ObjectUtil.isNotNull(info) && info.getRoleId().longValue() != roleId.longValue()) {
} return UserConstants.NOT_UNIQUE;
return UserConstants.UNIQUE; }
} return UserConstants.UNIQUE;
}
/**
* 校验角色是否允许操作 /**
* * 校验角色是否允许操作
* @param role 角色信息 *
*/ * @param role 角色信息
@Override */
public void checkRoleAllowed(SysRole role) { @Override
if (StringUtils.isNotNull(role.getRoleId()) && role.isAdmin()) { public void checkRoleAllowed(SysRole role) {
throw new ServiceException("不允许操作超级管理员角色"); if (ObjectUtil.isNotNull(role.getRoleId()) && role.isAdmin()) {
} throw new ServiceException("不允许操作超级管理员角色");
} }
}
/**
* 校验角色是否有数据权限 /**
* * 校验角色是否有数据权限
* @param roleId 角色id *
*/ * @param roleId 角色id
@Override */
public void checkRoleDataScope(Long roleId) { @Override
if (!SysUser.isAdmin(SecurityUtils.getUserId())) { public void checkRoleDataScope(Long roleId) {
SysRole role = new SysRole(); if (!SysUser.isAdmin(SecurityUtils.getUserId())) {
role.setRoleId(roleId); SysRole role = new SysRole();
List<SysRole> roles = SpringUtils.getAopProxy(this).selectRoleList(role); role.setRoleId(roleId);
if (StringUtils.isEmpty(roles)) { List<SysRole> roles = SpringUtils.getAopProxy(this).selectRoleList(role);
throw new ServiceException("没有权限访问角色数据！"); if (CollUtil.isEmpty(roles)) {
} throw new ServiceException("没有权限访问角色数据！");
} }
} }
}
/**
* 通过角色ID查询角色使用数量 /**
* * 通过角色ID查询角色使用数量
* @param roleId 角色ID *
* @return 结果 * @param roleId 角色ID
*/ * @return 结果
@Override */
public int countUserRoleByRoleId(Long roleId) { @Override
return userRoleMapper.countUserRoleByRoleId(roleId); public int countUserRoleByRoleId(Long roleId) {
} return userRoleMapper.countUserRoleByRoleId(roleId);
}
/**
* 新增保存角色信息 /**
* * 新增保存角色信息
* @param role 角色信息 *
* @return 结果 * @param role 角色信息
*/ * @return 结果
@Override */
@Transactional @Override
public int insertRole(SysRole role) { @Transactional
// 新增角色信息 public int insertRole(SysRole role) {
roleMapper.insertRole(role); // 新增角色信息
return insertRoleMenu(role); roleMapper.insertRole(role);
} return insertRoleMenu(role);
}
/**
* 修改保存角色信息 /**
* * 修改保存角色信息
* @param role 角色信息 *
* @return 结果 * @param role 角色信息
*/ * @return 结果
@Override */
@Transactional @Override
public int updateRole(SysRole role) { @Transactional
// 修改角色信息 public int updateRole(SysRole role) {
roleMapper.updateRole(role); // 修改角色信息
// 删除角色与菜单关联 roleMapper.updateRole(role);
roleMenuMapper.deleteRoleMenuByRoleId(role.getRoleId()); // 删除角色与菜单关联
return insertRoleMenu(role); roleMenuMapper.deleteRoleMenuByRoleId(role.getRoleId());
} return insertRoleMenu(role);
}
/**
* 修改角色状态 /**
* * 修改角色状态
* @param role 角色信息 *
* @return 结果 * @param role 角色信息
*/ * @return 结果
@Override */
public int updateRoleStatus(SysRole role) { @Override
return roleMapper.updateRole(role); public int updateRoleStatus(SysRole role) {
} return roleMapper.updateRole(role);
}
/**
* 修改数据权限信息 /**
* * 修改数据权限信息
* @param role 角色信息 *
* @return 结果 * @param role 角色信息
*/ * @return 结果
@Override */
@Transactional @Override
public int authDataScope(SysRole role) { @Transactional
// 修改角色信息 public int authDataScope(SysRole role) {
roleMapper.updateRole(role); // 修改角色信息
// 删除角色与部门关联 roleMapper.updateRole(role);
roleDeptMapper.deleteRoleDeptByRoleId(role.getRoleId()); // 删除角色与部门关联
// 新增角色和部门信息（数据权限） roleDeptMapper.deleteRoleDeptByRoleId(role.getRoleId());
return insertRoleDept(role); // 新增角色和部门信息（数据权限）
} return insertRoleDept(role);
}
/**
* 新增角色菜单信息 /**
* * 新增角色菜单信息
* @param role 角色对象 *
*/ * @param role 角色对象
public int insertRoleMenu(SysRole role) { */
int rows = 1; public int insertRoleMenu(SysRole role) {
// 新增用户与角色管理 int rows = 1;
List<SysRoleMenu> list = new ArrayList<SysRoleMenu>(); // 新增用户与角色管理
for (Long menuId : role.getMenuIds()) { List<SysRoleMenu> list = new ArrayList<SysRoleMenu>();
SysRoleMenu rm = new SysRoleMenu(); for (Long menuId : role.getMenuIds()) {
rm.setRoleId(role.getRoleId()); SysRoleMenu rm = new SysRoleMenu();
rm.setMenuId(menuId); rm.setRoleId(role.getRoleId());
list.add(rm); rm.setMenuId(menuId);
} list.add(rm);
if (list.size() > 0) { }
rows = roleMenuMapper.batchRoleMenu(list); if (list.size() > 0) {
} rows = roleMenuMapper.batchRoleMenu(list);
return rows; }
} return rows;
}
/**
* 新增角色部门信息(数据权限) /**
* * 新增角色部门信息(数据权限)
* @param role 角色对象 *
*/ * @param role 角色对象
public int insertRoleDept(SysRole role) { */
int rows = 1; public int insertRoleDept(SysRole role) {
// 新增角色与部门（数据权限）管理 int rows = 1;
List<SysRoleDept> list = new ArrayList<SysRoleDept>(); // 新增角色与部门（数据权限）管理
for (Long deptId : role.getDeptIds()) { List<SysRoleDept> list = new ArrayList<SysRoleDept>();
SysRoleDept rd = new SysRoleDept(); for (Long deptId : role.getDeptIds()) {
rd.setRoleId(role.getRoleId()); SysRoleDept rd = new SysRoleDept();
rd.setDeptId(deptId); rd.setRoleId(role.getRoleId());
list.add(rd); rd.setDeptId(deptId);
} list.add(rd);
if (list.size() > 0) { }
rows = roleDeptMapper.batchRoleDept(list); if (list.size() > 0) {
} rows = roleDeptMapper.batchRoleDept(list);
return rows; }
} return rows;
}
/**
* 通过角色ID删除角色 /**
* * 通过角色ID删除角色
* @param roleId 角色ID *
* @return 结果 * @param roleId 角色ID
*/ * @return 结果
@Override */
@Transactional @Override
public int deleteRoleById(Long roleId) { @Transactional
// 删除角色与菜单关联 public int deleteRoleById(Long roleId) {
roleMenuMapper.deleteRoleMenuByRoleId(roleId); // 删除角色与菜单关联
// 删除角色与部门关联 roleMenuMapper.deleteRoleMenuByRoleId(roleId);
roleDeptMapper.deleteRoleDeptByRoleId(roleId); // 删除角色与部门关联
return roleMapper.deleteRoleById(roleId); roleDeptMapper.deleteRoleDeptByRoleId(roleId);
} return roleMapper.deleteRoleById(roleId);
}
/**
* 批量删除角色信息 /**
* * 批量删除角色信息
* @param roleIds 需要删除的角色ID *
* @return 结果 * @param roleIds 需要删除的角色ID
*/ * @return 结果
@Override */
@Transactional @Override
public int deleteRoleByIds(Long[] roleIds) { @Transactional
for (Long roleId : roleIds) { public int deleteRoleByIds(Long[] roleIds) {
checkRoleAllowed(new SysRole(roleId)); for (Long roleId : roleIds) {
SysRole role = selectRoleById(roleId); checkRoleAllowed(new SysRole(roleId));
if (countUserRoleByRoleId(roleId) > 0) { SysRole role = selectRoleById(roleId);
throw new ServiceException(String.format("%1$s已分配,不能删除", role.getRoleName())); if (countUserRoleByRoleId(roleId) > 0) {
} throw new ServiceException(String.format("%1$s已分配,不能删除", role.getRoleName()));
} }
// 删除角色与菜单关联 }
roleMenuMapper.deleteRoleMenu(roleIds); // 删除角色与菜单关联
// 删除角色与部门关联 roleMenuMapper.deleteRoleMenu(roleIds);
roleDeptMapper.deleteRoleDept(roleIds); // 删除角色与部门关联
return roleMapper.deleteRoleByIds(roleIds); roleDeptMapper.deleteRoleDept(roleIds);
} return roleMapper.deleteRoleByIds(roleIds);
}
/**
* 取消授权用户角色 /**
* * 取消授权用户角色
* @param userRole 用户和角色关联信息 *
* @return 结果 * @param userRole 用户和角色关联信息
*/ * @return 结果
@Override */
public int deleteAuthUser(SysUserRole userRole) { @Override
return userRoleMapper.deleteUserRoleInfo(userRole); public int deleteAuthUser(SysUserRole userRole) {
} return userRoleMapper.deleteUserRoleInfo(userRole);
}
/**
* 批量取消授权用户角色 /**
* * 批量取消授权用户角色
* @param roleId 角色ID *
* @param userIds 需要取消授权的用户数据ID * @param roleId 角色ID
* @return 结果 * @param userIds 需要取消授权的用户数据ID
*/ * @return 结果
@Override */
public int deleteAuthUsers(Long roleId, Long[] userIds) { @Override
return userRoleMapper.deleteUserRoleInfos(roleId, userIds); public int deleteAuthUsers(Long roleId, Long[] userIds) {
} return userRoleMapper.deleteUserRoleInfos(roleId, userIds);
}
/**
* 批量选择授权用户角色 /**
* * 批量选择授权用户角色
* @param roleId 角色ID *
* @param userIds 需要删除的用户数据ID * @param roleId 角色ID
* @return 结果 * @param userIds 需要删除的用户数据ID
*/ * @return 结果
@Override */
public int insertAuthUsers(Long roleId, Long[] userIds) { @Override
// 新增用户与角色管理 public int insertAuthUsers(Long roleId, Long[] userIds) {
List<SysUserRole> list = new ArrayList<SysUserRole>(); // 新增用户与角色管理
for (Long userId : userIds) { List<SysUserRole> list = new ArrayList<SysUserRole>();
SysUserRole ur = new SysUserRole(); for (Long userId : userIds) {
ur.setUserId(userId); SysUserRole ur = new SysUserRole();
ur.setRoleId(roleId); ur.setUserId(userId);
list.add(ur); ur.setRoleId(roleId);
} list.add(ur);
return userRoleMapper.batchUserRole(list); }
} return userRoleMapper.batchUserRole(list);
} }
}

161
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysUserOnlineServiceImpl.java
View File

@ -1,80 +1,81 @@
package com.ruoyi.system.service.impl; package com.ruoyi.system.service.impl;
import com.ruoyi.common.core.utils.StringUtils; import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.system.api.model.LoginUser; import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.system.domain.SysUserOnline; import com.ruoyi.system.api.model.LoginUser;
import com.ruoyi.system.service.ISysUserOnlineService; import com.ruoyi.system.domain.SysUserOnline;
import org.springframework.stereotype.Service; import com.ruoyi.system.service.ISysUserOnlineService;
import org.springframework.stereotype.Service;
/**
* 在线用户 服务层处理 /**
* * 在线用户 服务层处理
* @author ruoyi *
*/ * @author ruoyi
@Service */
public class SysUserOnlineServiceImpl implements ISysUserOnlineService { @Service
/** public class SysUserOnlineServiceImpl implements ISysUserOnlineService {
* 通过登录地址查询信息 /**
* * 通过登录地址查询信息
* @param ipaddr 登录地址 *
* @param user 用户信息 * @param ipaddr 登录地址
* @return 在线用户信息 * @param user 用户信息
*/ * @return 在线用户信息
@Override */
public SysUserOnline selectOnlineByIpaddr(String ipaddr, LoginUser user) { @Override
if (StringUtils.equals(ipaddr, user.getIpaddr())) { public SysUserOnline selectOnlineByIpaddr(String ipaddr, LoginUser user) {
return loginUserToUserOnline(user); if (StringUtils.equals(ipaddr, user.getIpaddr())) {
} return loginUserToUserOnline(user);
return null; }
} return null;
}
/**
* 通过用户名称查询信息 /**
* * 通过用户名称查询信息
* @param userName 用户名称 *
* @param user 用户信息 * @param userName 用户名称
* @return 在线用户信息 * @param user 用户信息
*/ * @return 在线用户信息
@Override */
public SysUserOnline selectOnlineByUserName(String userName, LoginUser user) { @Override
if (StringUtils.equals(userName, user.getUsername())) { public SysUserOnline selectOnlineByUserName(String userName, LoginUser user) {
return loginUserToUserOnline(user); if (StringUtils.equals(userName, user.getUsername())) {
} return loginUserToUserOnline(user);
return null; }
} return null;
}
/**
* 通过登录地址/用户名称查询信息 /**
* * 通过登录地址/用户名称查询信息
* @param ipaddr 登录地址 *
* @param userName 用户名称 * @param ipaddr 登录地址
* @param user 用户信息 * @param userName 用户名称
* @return 在线用户信息 * @param user 用户信息
*/ * @return 在线用户信息
@Override */
public SysUserOnline selectOnlineByInfo(String ipaddr, String userName, LoginUser user) { @Override
if (StringUtils.equals(ipaddr, user.getIpaddr()) && StringUtils.equals(userName, user.getUsername())) { public SysUserOnline selectOnlineByInfo(String ipaddr, String userName, LoginUser user) {
return loginUserToUserOnline(user); if (StringUtils.equals(ipaddr, user.getIpaddr()) && StringUtils.equals(userName, user.getUsername())) {
} return loginUserToUserOnline(user);
return null; }
} return null;
}
/**
* 设置在线用户信息 /**
* * 设置在线用户信息
* @param user 用户信息 *
* @return 在线用户 * @param user 用户信息
*/ * @return 在线用户
@Override */
public SysUserOnline loginUserToUserOnline(LoginUser user) { @Override
if (StringUtils.isNull(user)) { public SysUserOnline loginUserToUserOnline(LoginUser user) {
return null; if (ObjectUtil.isNull(user)) {
} return null;
SysUserOnline sysUserOnline = new SysUserOnline(); }
sysUserOnline.setTokenId(user.getToken()); SysUserOnline sysUserOnline = new SysUserOnline();
sysUserOnline.setUserName(user.getUsername()); sysUserOnline.setTokenId(user.getToken());
sysUserOnline.setIpaddr(user.getIpaddr()); sysUserOnline.setUserName(user.getUsername());
sysUserOnline.setLoginTime(user.getLoginTime()); sysUserOnline.setIpaddr(user.getIpaddr());
return sysUserOnline; sysUserOnline.setLoginTime(user.getLoginTime());
} return sysUserOnline;
} }
}

922
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysUserServiceImpl.java
View File

@ -1,488 +1,434 @@
package com.ruoyi.system.service.impl; package com.ruoyi.system.service.impl;
import com.ruoyi.common.core.constant.UserConstants; import cn.hutool.core.collection.CollUtil;
import com.ruoyi.common.core.exception.ServiceException; import cn.hutool.core.util.ObjectUtil;
import com.ruoyi.common.core.utils.SpringUtils; import com.ruoyi.common.core.constant.UserConstants;
import com.ruoyi.common.core.utils.StringUtils; import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.core.utils.bean.BeanValidators; import com.ruoyi.common.core.utils.SpringUtils;
import com.ruoyi.common.datascope.annotation.DataScope; import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.security.utils.SecurityUtils; import com.ruoyi.common.datascope.annotation.DataScope;
import com.ruoyi.system.api.domain.SysRole; import com.ruoyi.common.security.utils.SecurityUtils;
import com.ruoyi.system.api.domain.SysUser; import com.ruoyi.system.api.domain.SysRole;
import com.ruoyi.system.domain.SysPost; import com.ruoyi.system.api.domain.SysUser;
import com.ruoyi.system.domain.SysUserPost; import com.ruoyi.system.domain.SysPost;
import com.ruoyi.system.domain.SysUserRole; import com.ruoyi.system.domain.SysUserPost;
import com.ruoyi.system.mapper.*; import com.ruoyi.system.domain.SysUserRole;
import com.ruoyi.system.service.ISysConfigService; import com.ruoyi.system.mapper.*;
import com.ruoyi.system.service.ISysUserService; import com.ruoyi.system.service.ISysConfigService;
import lombok.RequiredArgsConstructor; import com.ruoyi.system.service.ISysUserService;
import lombok.extern.slf4j.Slf4j; import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired; import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional; import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils; import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import javax.validation.Validator;
import java.util.ArrayList; import javax.validation.Validator;
import java.util.List; import java.util.ArrayList;
import java.util.stream.Collectors; import java.util.List;
import java.util.stream.Collectors;
/**
* 用户 业务层处理 /**
* * 用户 业务层处理
* @author ruoyi *
*/ * @author ruoyi
@Slf4j */
@RequiredArgsConstructor(onConstructor_ = @Autowired) @Slf4j
@Service @RequiredArgsConstructor(onConstructor_ = @Autowired)
public class SysUserServiceImpl implements ISysUserService { @Service
public class SysUserServiceImpl implements ISysUserService {
private final SysUserMapper userMapper;
private final SysRoleMapper roleMapper; private final SysUserMapper userMapper;
private final SysPostMapper postMapper; private final SysRoleMapper roleMapper;
private final SysUserRoleMapper userRoleMapper; private final SysPostMapper postMapper;
private final SysUserPostMapper userPostMapper; private final SysUserRoleMapper userRoleMapper;
private final ISysConfigService configService; private final SysUserPostMapper userPostMapper;
protected final Validator validator; private final ISysConfigService configService;
protected final Validator validator;
/**
* 根据条件分页查询用户列表 /**
* * 根据条件分页查询用户列表
* @param user 用户信息 *
* @return 用户信息集合信息 * @param user 用户信息
*/ * @return 用户信息集合信息
@Override */
@DataScope(deptAlias = "d", userAlias = "u") @Override
public List<SysUser> selectUserList(SysUser user) { @DataScope(deptAlias = "d", userAlias = "u")
return userMapper.selectUserList(user); public List<SysUser> selectUserList(SysUser user) {
} return userMapper.selectUserList(user);
}
/**
* 根据条件分页查询已分配用户角色列表 /**
* * 根据条件分页查询已分配用户角色列表
* @param user 用户信息 *
* @return 用户信息集合信息 * @param user 用户信息
*/ * @return 用户信息集合信息
@Override */
@DataScope(deptAlias = "d", userAlias = "u") @Override
public List<SysUser> selectAllocatedList(SysUser user) { @DataScope(deptAlias = "d", userAlias = "u")
return userMapper.selectAllocatedList(user); public List<SysUser> selectAllocatedList(SysUser user) {
} return userMapper.selectAllocatedList(user);
}
/**
* 根据条件分页查询未分配用户角色列表 /**
* * 根据条件分页查询未分配用户角色列表
* @param user 用户信息 *
* @return 用户信息集合信息 * @param user 用户信息
*/ * @return 用户信息集合信息
@Override */
@DataScope(deptAlias = "d", userAlias = "u") @Override
public List<SysUser> selectUnallocatedList(SysUser user) { @DataScope(deptAlias = "d", userAlias = "u")
return userMapper.selectUnallocatedList(user); public List<SysUser> selectUnallocatedList(SysUser user) {
} return userMapper.selectUnallocatedList(user);
}
/**
* 通过用户名查询用户 /**
* * 通过用户名查询用户
* @param userName 用户名 *
* @return 用户对象信息 * @param userName 用户名
*/ * @return 用户对象信息
@Override */
public SysUser selectUserByUserName(String userName) { @Override
return userMapper.selectUserByUserName(userName); public SysUser selectUserByUserName(String userName) {
} return userMapper.selectUserByUserName(userName);
}
/**
* 通过用户ID查询用户 /**
* * 通过用户ID查询用户
* @param userId 用户ID *
* @return 用户对象信息 * @param userId 用户ID
*/ * @return 用户对象信息
@Override */
public SysUser selectUserById(Long userId) { @Override
return userMapper.selectUserById(userId); public SysUser selectUserById(Long userId) {
} return userMapper.selectUserById(userId);
}
/**
* 查询用户所属角色组 /**
* * 查询用户所属角色组
* @param userName 用户名 *
* @return 结果 * @param userName 用户名
*/ * @return 结果
@Override */
public String selectUserRoleGroup(String userName) { @Override
List<SysRole> list = roleMapper.selectRolesByUserName(userName); public String selectUserRoleGroup(String userName) {
if (CollectionUtils.isEmpty(list)) { List<SysRole> list = roleMapper.selectRolesByUserName(userName);
return StringUtils.EMPTY; if (CollectionUtils.isEmpty(list)) {
} return StringUtils.EMPTY;
return list.stream().map(SysRole::getRoleName).collect(Collectors.joining(",")); }
} return list.stream().map(SysRole::getRoleName).collect(Collectors.joining(","));
}
/**
* 查询用户所属岗位组 /**
* * 查询用户所属岗位组
* @param userName 用户名 *
* @return 结果 * @param userName 用户名
*/ * @return 结果
@Override */
public String selectUserPostGroup(String userName) { @Override
List<SysPost> list = postMapper.selectPostsByUserName(userName); public String selectUserPostGroup(String userName) {
if (CollectionUtils.isEmpty(list)) { List<SysPost> list = postMapper.selectPostsByUserName(userName);
return StringUtils.EMPTY; if (CollectionUtils.isEmpty(list)) {
} return StringUtils.EMPTY;
return list.stream().map(SysPost::getPostName).collect(Collectors.joining(",")); }
} return list.stream().map(SysPost::getPostName).collect(Collectors.joining(","));
}
/**
* 校验用户名称是否唯一 /**
* * 校验用户名称是否唯一
* @param userName 用户名称 *
* @return 结果 * @param userName 用户名称
*/ * @return 结果
@Override */
public String checkUserNameUnique(String userName) { @Override
int count = userMapper.checkUserNameUnique(userName); public String checkUserNameUnique(String userName) {
if (count > 0) { int count = userMapper.checkUserNameUnique(userName);
return UserConstants.NOT_UNIQUE; if (count > 0) {
} return UserConstants.NOT_UNIQUE;
return UserConstants.UNIQUE; }
} return UserConstants.UNIQUE;
}
/**
* 校验手机号码是否唯一 /**
* * 校验手机号码是否唯一
* @param user 用户信息 *
* @return * @param user 用户信息
*/ * @return
@Override */
public String checkPhoneUnique(SysUser user) { @Override
Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId(); public String checkPhoneUnique(SysUser user) {
SysUser info = userMapper.checkPhoneUnique(user.getPhonenumber()); Long userId = ObjectUtil.isNull(user.getUserId()) ? -1L : user.getUserId();
if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue()) { SysUser info = userMapper.checkPhoneUnique(user.getPhonenumber());
return UserConstants.NOT_UNIQUE; if (ObjectUtil.isNotNull(info) && info.getUserId().longValue() != userId.longValue()) {
} return UserConstants.NOT_UNIQUE;
return UserConstants.UNIQUE; }
} return UserConstants.UNIQUE;
}
/**
* 校验email是否唯一 /**
* * 校验email是否唯一
* @param user 用户信息 *
* @return * @param user 用户信息
*/ * @return
@Override */
public String checkEmailUnique(SysUser user) { @Override
Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId(); public String checkEmailUnique(SysUser user) {
SysUser info = userMapper.checkEmailUnique(user.getEmail()); Long userId = ObjectUtil.isNull(user.getUserId()) ? -1L : user.getUserId();
if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue()) { SysUser info = userMapper.checkEmailUnique(user.getEmail());
return UserConstants.NOT_UNIQUE; if (ObjectUtil.isNotNull(info) && info.getUserId().longValue() != userId.longValue()) {
} return UserConstants.NOT_UNIQUE;
return UserConstants.UNIQUE; }
} return UserConstants.UNIQUE;
}
/**
* 校验用户是否允许操作 /**
* * 校验用户是否允许操作
* @param user 用户信息 *
*/ * @param user 用户信息
@Override */
public void checkUserAllowed(SysUser user) { @Override
if (StringUtils.isNotNull(user.getUserId()) && user.isAdmin()) { public void checkUserAllowed(SysUser user) {
throw new ServiceException("不允许操作超级管理员用户"); if (ObjectUtil.isNotNull(user.getUserId()) && user.isAdmin()) {
} throw new ServiceException("不允许操作超级管理员用户");
} }
}
/**
* 校验用户是否有数据权限 /**
* * 校验用户是否有数据权限
* @param userId 用户id *
*/ * @param userId 用户id
@Override */
public void checkUserDataScope(Long userId) { @Override
if (!SysUser.isAdmin(SecurityUtils.getUserId())) { public void checkUserDataScope(Long userId) {
SysUser user = new SysUser(); if (!SysUser.isAdmin(SecurityUtils.getUserId())) {
user.setUserId(userId); SysUser user = new SysUser();
List<SysUser> users = SpringUtils.getAopProxy(this).selectUserList(user); user.setUserId(userId);
if (StringUtils.isEmpty(users)) { List<SysUser> users = SpringUtils.getAopProxy(this).selectUserList(user);
throw new ServiceException("没有权限访问用户数据！"); if (CollUtil.isEmpty(users)) {
} throw new ServiceException("没有权限访问用户数据！");
} }
} }
}
/**
* 新增保存用户信息 /**
* * 新增保存用户信息
* @param user 用户信息 *
* @return 结果 * @param user 用户信息
*/ * @return 结果
@Override */
@Transactional @Override
public int insertUser(SysUser user) { @Transactional
// 新增用户信息 public int insertUser(SysUser user) {
int rows = userMapper.insertUser(user); // 新增用户信息
// 新增用户岗位关联 int rows = userMapper.insertUser(user);
insertUserPost(user); // 新增用户岗位关联
// 新增用户与角色管理 insertUserPost(user);
insertUserRole(user); // 新增用户与角色管理
return rows; insertUserRole(user);
} return rows;
}
/**
* 注册用户信息 /**
* * 注册用户信息
* @param user 用户信息 *
* @return 结果 * @param user 用户信息
*/ * @return 结果
@Override */
public boolean registerUser(SysUser user) { @Override
return userMapper.insertUser(user) > 0; public boolean registerUser(SysUser user) {
} return userMapper.insertUser(user) > 0;
}
/**
* 修改保存用户信息 /**
* * 修改保存用户信息
* @param user 用户信息 *
* @return 结果 * @param user 用户信息
*/ * @return 结果
@Override */
@Transactional @Override
public int updateUser(SysUser user) { @Transactional
Long userId = user.getUserId(); public int updateUser(SysUser user) {
// 删除用户与角色关联 Long userId = user.getUserId();
userRoleMapper.deleteUserRoleByUserId(userId); // 删除用户与角色关联
// 新增用户与角色管理 userRoleMapper.deleteUserRoleByUserId(userId);
insertUserRole(user); // 新增用户与角色管理
// 删除用户与岗位关联 insertUserRole(user);
userPostMapper.deleteUserPostByUserId(userId); // 删除用户与岗位关联
// 新增用户与岗位管理 userPostMapper.deleteUserPostByUserId(userId);
insertUserPost(user); // 新增用户与岗位管理
return userMapper.updateUser(user); insertUserPost(user);
} return userMapper.updateUser(user);
}
/**
* 用户授权角色 /**
* * 用户授权角色
* @param userId 用户ID *
* @param roleIds 角色组 * @param userId 用户ID
*/ * @param roleIds 角色组
@Override */
@Transactional @Override
public void insertUserAuth(Long userId, Long[] roleIds) { @Transactional
userRoleMapper.deleteUserRoleByUserId(userId); public void insertUserAuth(Long userId, Long[] roleIds) {
insertUserRole(userId, roleIds); userRoleMapper.deleteUserRoleByUserId(userId);
} insertUserRole(userId, roleIds);
}
/**
* 修改用户状态 /**
* * 修改用户状态
* @param user 用户信息 *
* @return 结果 * @param user 用户信息
*/ * @return 结果
@Override */
public int updateUserStatus(SysUser user) { @Override
return userMapper.updateUser(user); public int updateUserStatus(SysUser user) {
} return userMapper.updateUser(user);
}
/**
* 修改用户基本信息 /**
* * 修改用户基本信息
* @param user 用户信息 *
* @return 结果 * @param user 用户信息
*/ * @return 结果
@Override */
public int updateUserProfile(SysUser user) { @Override
return userMapper.updateUser(user); public int updateUserProfile(SysUser user) {
} return userMapper.updateUser(user);
}
/**
* 修改用户头像 /**
* * 修改用户头像
* @param userName 用户名 *
* @param avatar 头像地址 * @param userName 用户名
* @return 结果 * @param avatar 头像地址
*/ * @return 结果
@Override */
public boolean updateUserAvatar(String userName, String avatar) { @Override
return userMapper.updateUserAvatar(userName, avatar) > 0; public boolean updateUserAvatar(String userName, String avatar) {
} return userMapper.updateUserAvatar(userName, avatar) > 0;
}
/**
* 重置用户密码 /**
* * 重置用户密码
* @param user 用户信息 *
* @return 结果 * @param user 用户信息
*/ * @return 结果
@Override */
public int resetPwd(SysUser user) { @Override
return userMapper.updateUser(user); public int resetPwd(SysUser user) {
} return userMapper.updateUser(user);
}
/**
* 重置用户密码 /**
* * 重置用户密码
* @param userName 用户名 *
* @param password 密码 * @param userName 用户名
* @return 结果 * @param password 密码
*/ * @return 结果
@Override */
public int resetUserPwd(String userName, String password) { @Override
return userMapper.resetUserPwd(userName, password); public int resetUserPwd(String userName, String password) {
} return userMapper.resetUserPwd(userName, password);
}
/**
* 新增用户角色信息 /**
* * 新增用户角色信息
* @param user 用户对象 *
*/ * @param user 用户对象
public void insertUserRole(SysUser user) { */
Long[] roles = user.getRoleIds(); public void insertUserRole(SysUser user) {
if (StringUtils.isNotNull(roles)) { Long[] roles = user.getRoleIds();
// 新增用户与角色管理 if (ObjectUtil.isNotNull(roles)) {
List<SysUserRole> list = new ArrayList<SysUserRole>(); // 新增用户与角色管理
for (Long roleId : roles) { List<SysUserRole> list = new ArrayList<SysUserRole>();
SysUserRole ur = new SysUserRole(); for (Long roleId : roles) {
ur.setUserId(user.getUserId()); SysUserRole ur = new SysUserRole();
ur.setRoleId(roleId); ur.setUserId(user.getUserId());
list.add(ur); ur.setRoleId(roleId);
} list.add(ur);
if (list.size() > 0) { }
userRoleMapper.batchUserRole(list); if (list.size() > 0) {
} userRoleMapper.batchUserRole(list);
} }
} }
}
/**
* 新增用户岗位信息 /**
* * 新增用户岗位信息
* @param user 用户对象 *
*/ * @param user 用户对象
public void insertUserPost(SysUser user) { */
Long[] posts = user.getPostIds(); public void insertUserPost(SysUser user) {
if (StringUtils.isNotNull(posts)) { Long[] posts = user.getPostIds();
// 新增用户与岗位管理 if (ObjectUtil.isNotNull(posts)) {
List<SysUserPost> list = new ArrayList<SysUserPost>(); // 新增用户与岗位管理
for (Long postId : posts) { List<SysUserPost> list = new ArrayList<SysUserPost>();
SysUserPost up = new SysUserPost(); for (Long postId : posts) {
up.setUserId(user.getUserId()); SysUserPost up = new SysUserPost();
up.setPostId(postId); up.setUserId(user.getUserId());
list.add(up); up.setPostId(postId);
} list.add(up);
if (list.size() > 0) { }
userPostMapper.batchUserPost(list); if (list.size() > 0) {
} userPostMapper.batchUserPost(list);
} }
} }
}
/**
* 新增用户角色信息 /**
* * 新增用户角色信息
* @param userId 用户ID *
* @param roleIds 角色组 * @param userId 用户ID
*/ * @param roleIds 角色组
public void insertUserRole(Long userId, Long[] roleIds) { */
if (StringUtils.isNotNull(roleIds)) { public void insertUserRole(Long userId, Long[] roleIds) {
// 新增用户与角色管理 if (ObjectUtil.isNotNull(roleIds)) {
List<SysUserRole> list = new ArrayList<SysUserRole>(); // 新增用户与角色管理
for (Long roleId : roleIds) { List<SysUserRole> list = new ArrayList<SysUserRole>();
SysUserRole ur = new SysUserRole(); for (Long roleId : roleIds) {
ur.setUserId(userId); SysUserRole ur = new SysUserRole();
ur.setRoleId(roleId); ur.setUserId(userId);
list.add(ur); ur.setRoleId(roleId);
} list.add(ur);
if (list.size() > 0) { }
userRoleMapper.batchUserRole(list); if (list.size() > 0) {
} userRoleMapper.batchUserRole(list);
} }
} }
}
/**
* 通过用户ID删除用户 /**
* * 通过用户ID删除用户
* @param userId 用户ID *
* @return 结果 * @param userId 用户ID
*/ * @return 结果
@Override */
@Transactional @Override
public int deleteUserById(Long userId) { @Transactional
// 删除用户与角色关联 public int deleteUserById(Long userId) {
userRoleMapper.deleteUserRoleByUserId(userId); // 删除用户与角色关联
// 删除用户与岗位表 userRoleMapper.deleteUserRoleByUserId(userId);
userPostMapper.deleteUserPostByUserId(userId); // 删除用户与岗位表
return userMapper.deleteUserById(userId); userPostMapper.deleteUserPostByUserId(userId);
} return userMapper.deleteUserById(userId);
}
/**
* 批量删除用户信息 /**
* * 批量删除用户信息
* @param userIds 需要删除的用户ID *
* @return 结果 * @param userIds 需要删除的用户ID
*/ * @return 结果
@Override */
@Transactional @Override
public int deleteUserByIds(Long[] userIds) { @Transactional
for (Long userId : userIds) { public int deleteUserByIds(Long[] userIds) {
checkUserAllowed(new SysUser(userId)); for (Long userId : userIds) {
} checkUserAllowed(new SysUser(userId));
// 删除用户与角色关联 }
userRoleMapper.deleteUserRole(userIds); // 删除用户与角色关联
// 删除用户与岗位关联 userRoleMapper.deleteUserRole(userIds);
userPostMapper.deleteUserPost(userIds); // 删除用户与岗位关联
return userMapper.deleteUserByIds(userIds); userPostMapper.deleteUserPost(userIds);
} return userMapper.deleteUserByIds(userIds);
}
/**
* 导入用户数据 }
*
* @param userList 用户数据列表
* @param isUpdateSupport 是否更新支持，如果已存在，则进行更新数据
* @param operName 操作用户
* @return 结果
*/
@Override
public String importUser(List<SysUser> userList, Boolean isUpdateSupport, String operName) {
if (StringUtils.isNull(userList) || userList.size() == 0) {
throw new ServiceException("导入用户数据不能为空！");
}
int successNum = 0;
int failureNum = 0;
StringBuilder successMsg = new StringBuilder();
StringBuilder failureMsg = new StringBuilder();
String password = configService.selectConfigByKey("sys.user.initPassword");
for (SysUser user : userList) {
try {
// 验证是否存在这个用户
SysUser u = userMapper.selectUserByUserName(user.getUserName());
if (StringUtils.isNull(u)) {
BeanValidators.validateWithException(validator, user);
user.setPassword(SecurityUtils.encryptPassword(password));
user.setCreateBy(operName);
this.insertUser(user);
successNum++;
successMsg.append("<br/>" + successNum + "、账号 " + user.getUserName() + " 导入成功");
} else if (isUpdateSupport) {
BeanValidators.validateWithException(validator, user);
user.setUpdateBy(operName);
this.updateUser(user);
successNum++;
successMsg.append("<br/>" + successNum + "、账号 " + user.getUserName() + " 更新成功");
} else {
failureNum++;
failureMsg.append("<br/>" + failureNum + "、账号 " + user.getUserName() + " 已存在");
}
} catch (Exception e) {
failureNum++;
String msg = "<br/>" + failureNum + "、账号 " + user.getUserName() + " 导入失败：";
failureMsg.append(msg + e.getMessage());
log.error(msg, e);
}
}
if (failureNum > 0) {
failureMsg.insert(0, "很抱歉，导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
throw new ServiceException(failureMsg.toString());
} else {
successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
}
return successMsg.toString();
}
}

31
ruoyi-modules/ruoyi-system/src/main/resources/bootstrap.yml
View File

@ -13,6 +13,37 @@ spring:
profiles: profiles:
# 环境配置 # 环境配置
active: @profiles.active@ active: @profiles.active@
---
spring:
rabbitmq:
host: 81.70.150.73
port: 5672
username: lihongbo
password: lihongbo.123
cloud:
stream:
function:
# 重点配置 与 binding 名与消费者对应
definition: delay
rabbit:
bindings:
delay-in-0:
consumer:
delayedExchange: true
delay-out-0:
producer:
delayedExchange: true
bindings:
delay-in-0:
destination: delay.exchange.cloud
content-type: application/json
group: delay-group
binder: rabbit
delay-out-0:
destination: delay.exchange.cloud
content-type: application/json
group: delay-group
binder: rabbit
--- # nacos 配置 --- # nacos 配置
spring: spring:

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