sx/map
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

das接口新增

Browse Source
This commit is contained in:
chenhaojie 2024-06-24 09:13:14 +08:00
parent dfd8b0416c
commit 650aa83bdd
44 changed files with 2221 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
das/pom.xml
View File

@ -17,7 +17,7 @@
<properties>
<java.version>17</java.version>
<hutool.version>5.8.18</hutool.version>
<maven.plugin.version>3.8.1</maven.plugin.version>
<mybatis.plus.spring.boot>3.5.5</mybatis.plus.spring.boot>
<hutool.version>5.8.25</hutool.version>
@ -65,6 +65,14 @@
<version>${sa.version}</version>
</dependency>
<!-- hutool 的依赖配置-->
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>${hutool.version}</version>
</dependency>
<dependency>
<groupId>cn.dev33</groupId>
<artifactId>sa-token-redis-jackson</artifactId>
@ -89,6 +97,11 @@
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
<!--mybatis-plus-->
<dependency>
<groupId>com.baomidou</groupId>

8
das/src/main/java/com/das/common/constant/BaseEntity.java
View File

@ -24,7 +24,7 @@ public class BaseEntity implements Serializable {
* 创建人
*/
@JsonSerialize(using = ToStringSerializer.class)
@TableField(fill = FieldFill.INSERT)
@TableField("created_by")
private Long createdBy;
/**
@ -32,14 +32,14 @@ public class BaseEntity implements Serializable {
*/
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@TableField(fill = FieldFill.INSERT)
@TableField("created_time")
private Date createdTime;
/**
* 更新人
*/
@JsonSerialize(using = ToStringSerializer.class)
@TableField(fill = FieldFill.INSERT_UPDATE)
@TableField("updated_by")
private Long updatedBy;
/**
@ -47,7 +47,7 @@ public class BaseEntity implements Serializable {
*/
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@TableField(fill = FieldFill.INSERT_UPDATE)
@TableField("updated_time")
private Date updatedTime;
}

4
das/src/main/java/com/das/common/result/R.java
View File

@ -86,6 +86,10 @@ public class R<T> implements Serializable {
return new R(ResultCode.SUCCESS, data,"操作成功");
}
public static <T> R<T> success() {
return new R(ResultCode.SUCCESS,null, "操作成功");
}
public static <T> R<T> success(IResultCode resultCode) {
return new R(resultCode);
}

200
das/src/main/java/com/das/common/utils/BeanCopyUtils.java Normal file
View File

@ -0,0 +1,200 @@
package com.das.common.utils;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.SimpleCache;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.StrUtil;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.springframework.cglib.beans.BeanCopier;
import org.springframework.cglib.beans.BeanMap;
import org.springframework.cglib.core.Converter;
import java.util.LinkedHashMap;
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;
}
final V target = ReflectUtil.newInstanceIfPossible(desc);
return copy(source, target);
}
/**
* 单对象基于对象创建拷贝
*
* @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;
}
BeanCopier beanCopier = BeanCopierCache.INSTANCE.get(source.getClass(), desc.getClass(), null);
beanCopier.copy(source, desc, null);
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 StreamUtils.toList(sourceList, source -> {
V target = ReflectUtil.newInstanceIfPossible(desc);
copy(source, target);
return target;
});
}
/**
* bean拷贝到map
*
* @param bean 数据来源实体
* @return map对象
*/
@SuppressWarnings("unchecked")
public static <T> Map<String, Object> copyToMap(T bean) {
if (ObjectUtil.isNull(bean)) {
return null;
}
return BeanMap.create(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;
}
T bean = ReflectUtil.newInstanceIfPossible(beanClass);
return mapToBean(map, bean);
}
/**
* 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;
}
BeanMap.create(bean).putAll(map);
return bean;
}
/**
* map拷贝到map
*
* @param map 数据来源
* @param clazz 返回的对象类型
* @return map对象
*/
public static <T, V> Map<String, V> mapToMap(Map<String, T> map, Class<V> clazz) {
if (MapUtil.isEmpty(map)) {
return null;
}
if (ObjectUtil.isNull(clazz)) {
return null;
}
Map<String, V> copyMap = new LinkedHashMap<>(map.size());
map.forEach((k, v) -> copyMap.put(k, copy(v, clazz)));
return copyMap;
}
/**
* BeanCopier属性缓存<br>
* 缓存用于防止多次反射造成的性能问题
*
* @author Looly
* @since 5.4.1
*/
public enum BeanCopierCache {
/**
* BeanCopier属性缓存单例
*/
INSTANCE;
private final SimpleCache<String, BeanCopier> cache = new SimpleCache<>();
/**
* 获得类与转换器生成的key在{@link BeanCopier}的Map中对应的元素
*
* @param srcClass 源Bean的类
* @param targetClass 目标Bean的类
* @param converter 转换器
* @return Map中对应的BeanCopier
*/
public BeanCopier get(Class<?> srcClass, Class<?> targetClass, Converter converter) {
final String key = genKey(srcClass, targetClass, converter);
return cache.get(key, () -> BeanCopier.create(srcClass, targetClass, converter != null));
}
/**
* 获得类与转换器生成的key
*
* @param srcClass 源Bean的类
* @param targetClass 目标Bean的类
* @param converter 转换器
* @return 属性名和Map映射的key
*/
private String genKey(Class<?> srcClass, Class<?> targetClass, Converter converter) {
final StringBuilder key = StrUtil.builder()
.append(srcClass.getName()).append('#').append(targetClass.getName());
if(null != converter){
key.append('#').append(converter.getClass().getName());
}
return key.toString();
}
}
}

76
das/src/main/java/com/das/common/utils/PageDataInfo.java Normal file
View File

@ -0,0 +1,76 @@
package com.das.common.utils;
import cn.hutool.http.HttpStatus;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* 分页数据对象
*/
@Data
@NoArgsConstructor
public class PageDataInfo<T> implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 总记录数
*/
private long total;
/**
* 列表数据
*/
private List<T> rows;
/**
* 消息状态码
*/
private int code;
/**
* 消息内容
*/
private String msg;
/**
* 分页
*
* @param list 列表数据
* @param total 总记录数
*/
public PageDataInfo(List<T> list, long total) {
this.rows = list;
this.total = total;
}
public static <T> PageDataInfo<T> build(List<T> list, long total) {
PageDataInfo<T> rspData = new PageDataInfo<>();
rspData.setCode(HttpStatus.HTTP_OK);
rspData.setMsg("查询成功");
rspData.setRows(list);
rspData.setTotal(total);
return rspData;
}
public static <T> PageDataInfo<T> build(List<T> list) {
PageDataInfo<T> rspData = new PageDataInfo<>();
rspData.setCode(HttpStatus.HTTP_OK);
rspData.setMsg("查询成功");
rspData.setRows(list);
rspData.setTotal(list.size());
return rspData;
}
public static <T> PageDataInfo<T> build() {
PageDataInfo<T> rspData = new PageDataInfo<>();
rspData.setCode(HttpStatus.HTTP_OK);
rspData.setMsg("查询成功");
return rspData;
}
}

110
das/src/main/java/com/das/common/utils/PageQuery.java Normal file
View File

@ -0,0 +1,110 @@
package com.das.common.utils;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.das.common.exceptions.ServiceException;
import com.das.common.utils.SqlUtil;
import com.das.common.utils.StringUtils;
import lombok.Data;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
/**
* 分页查询实体类
*/
@Data
public class PageQuery implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 分页大小
*/
private Integer pageSize;
/**
* 当前页数
*/
private Integer pageNum;
/**
* 排序列
*/
private String orderByColumn;
/**
* 排序的方向desc或者asc
*/
private String isAsc;
/**
* 当前记录起始索引 默认值
*/
public static final int DEFAULT_PAGE_NUM = 1;
/**
* 每页显示记录数 默认值 默认查全部
*/
public static final int DEFAULT_PAGE_SIZE = Integer.MAX_VALUE;
public <T> Page<T> build() {
Integer pageNum = ObjectUtil.defaultIfNull(getPageNum(), DEFAULT_PAGE_NUM);
Integer pageSize = ObjectUtil.defaultIfNull(getPageSize(), DEFAULT_PAGE_SIZE);
if (pageNum <= 0) {
pageNum = DEFAULT_PAGE_NUM;
}
Page<T> page = new Page<>(pageNum, pageSize);
List<OrderItem> orderItems = buildOrderItem();
if (CollUtil.isNotEmpty(orderItems)) {
page.addOrder(orderItems);
}
return page;
}
/**
* 构建排序
* <p>
* 支持的用法如下:
* {isAsc:"asc",orderByColumn:"id"} order by id asc
* {isAsc:"asc",orderByColumn:"id,createTime"} order by id asc,create_time asc
* {isAsc:"desc",orderByColumn:"id,createTime"} order by id desc,create_time desc
* {isAsc:"asc,desc",orderByColumn:"id,createTime"} order by id asc,create_time desc
*/
private List<OrderItem> buildOrderItem() {
if (StringUtils.isBlank(orderByColumn) || StringUtils.isBlank(isAsc)) {
return null;
}
String orderBy = SqlUtil.escapeOrderBySql(orderByColumn);
orderBy = StringUtils.toUnderScoreCase(orderBy);
// 兼容前端排序类型
isAsc = StringUtils.replaceEach(isAsc, new String[]{"ascending", "descending"}, new String[]{"asc", "desc"});
String[] orderByArr = orderBy.split(StringUtils.SEPARATOR);
String[] isAscArr = isAsc.split(StringUtils.SEPARATOR);
if (isAscArr.length != 1 && isAscArr.length != orderByArr.length) {
throw new ServiceException("排序参数有误");
}
List<OrderItem> list = new ArrayList<>();
// 每个字段各自排序
for (int i = 0; i < orderByArr.length; i++) {
String orderByStr = orderByArr[i];
String isAscStr = isAscArr.length == 1 ? isAscArr[0] : isAscArr[i];
if ("asc".equals(isAscStr)) {
list.add(OrderItem.asc(orderByStr));
} else if ("desc".equals(isAscStr)) {
list.add(OrderItem.desc(orderByStr));
} else {
throw new ServiceException("排序参数有误");
}
}
return list;
}
}

12
das/src/main/java/com/das/common/utils/SequenceUtils.java Normal file
View File

@ -0,0 +1,12 @@
package com.das.common.utils;
public class SequenceUtils {
private static final SnowFlakeGenerator SNOW_FLAKE_GENERATOR = new SnowFlakeGenerator();
public SequenceUtils() {
}
public static Long generateId() {
return SNOW_FLAKE_GENERATOR.generateLongId();
}
}

55
das/src/main/java/com/das/common/utils/SnowFlakeGenerator.java Normal file
View File

@ -0,0 +1,55 @@
package com.das.common.utils;
public class SnowFlakeGenerator {
private static long datacenterId = 0L;
private static final long DATACENTER_ID_BITS = 6L;
private static final long MAX_DATACENTER_ID = 63L;
private static long sequenceBits = 12L;
private static final long SEQUENCE_MAX;
private static final long TWEPOCH = 1440000000000L;
private long datacenterIdShift;
private long timestampLeftShift;
private volatile long lastTimestamp;
private volatile long sequence;
public SnowFlakeGenerator() {
this.datacenterIdShift = sequenceBits;
this.timestampLeftShift = sequenceBits + 6L;
this.lastTimestamp = -1L;
this.sequence = 0L;
if (datacenterId > 63L || datacenterId < 0L) {
throw new RuntimeException("datacenterId > MAX_DATACENTER_ID");
}
}
public synchronized Long generateLongId() {
long timestamp = System.currentTimeMillis();
if (timestamp < this.lastTimestamp) {
throw new RuntimeException("Clock moved backwards. Refusing to generate id for " + (this.lastTimestamp - timestamp) + " milliseconds.");
} else {
if (this.lastTimestamp == timestamp) {
this.sequence = (this.sequence + 1L) % SEQUENCE_MAX;
if (this.sequence == 0L) {
timestamp = this.tilNextMillis(this.lastTimestamp);
}
} else {
this.sequence = 0L;
}
this.lastTimestamp = timestamp;
return timestamp - 1440000000000L << (int)this.timestampLeftShift | datacenterId << (int)this.datacenterIdShift | this.sequence;
}
}
protected long tilNextMillis(long lastTimestamp) {
long timestamp;
for(timestamp = System.currentTimeMillis(); timestamp <= lastTimestamp; timestamp = System.currentTimeMillis()) {
}
return timestamp;
}
static {
SEQUENCE_MAX = ~(-1L << (int)sequenceBits);
}
}

54
das/src/main/java/com/das/common/utils/SqlUtil.java Normal file
View File

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

252
das/src/main/java/com/das/common/utils/StreamUtils.java Normal file
View File

@ -0,0 +1,252 @@
package com.das.common.utils;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.StrUtil;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import java.util.*;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
/**
* stream 流工具类
*
* @author Lion Li
*/
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class StreamUtils {
/**
* 将collection过滤
*
* @param collection 需要转化的集合
* @param function 过滤方法
* @return 过滤后的list
*/
public static <E> List<E> filter(Collection<E> collection, Predicate<E> function) {
if (CollUtil.isEmpty(collection)) {
return CollUtil.newArrayList();
}
return collection.stream().filter(function).collect(Collectors.toList());
}
/**
* 将collection拼接
*
* @param collection 需要转化的集合
* @param function 拼接方法
* @return 拼接后的list
*/
public static <E> String join(Collection<E> collection, Function<E, String> function) {
return join(collection, function, StringUtils.SEPARATOR);
}
/**
* 将collection拼接
*
* @param collection 需要转化的集合
* @param function 拼接方法
* @param delimiter 拼接符
* @return 拼接后的list
*/
public static <E> String join(Collection<E> collection, Function<E, String> function, CharSequence delimiter) {
if (CollUtil.isEmpty(collection)) {
return StrUtil.EMPTY;
}
return collection.stream().map(function).filter(Objects::nonNull).collect(Collectors.joining(delimiter));
}
/**
* 将collection排序
*
* @param collection 需要转化的集合
* @param comparing 排序方法
* @return 排序后的list
*/
public static <E> List<E> sorted(Collection<E> collection, Comparator<E> comparing) {
if (CollUtil.isEmpty(collection)) {
return CollUtil.newArrayList();
}
return collection.stream().sorted(comparing).collect(Collectors.toList());
}
/**
* 将collection转化为类型不变的map<br>
* <B>{@code Collection<V> ----> Map<K,V>}</B>
*
* @param collection 需要转化的集合
* @param key V类型转化为K类型的lambda方法
* @param <V> collection中的泛型
* @param <K> map中的key类型
* @return 转化后的map
*/
public static <V, K> Map<K, V> toIdentityMap(Collection<V> collection, Function<V, K> key) {
if (CollUtil.isEmpty(collection)) {
return MapUtil.newHashMap();
}
return collection.stream().collect(Collectors.toMap(key, Function.identity(), (l, r) -> l));
}
/**
* 将Collection转化为map(value类型与collection的泛型不同)<br>
* <B>{@code Collection<E> -----> Map<K,V> }</B>
*
* @param collection 需要转化的集合
* @param key E类型转化为K类型的lambda方法
* @param value E类型转化为V类型的lambda方法
* @param <E> collection中的泛型
* @param <K> map中的key类型
* @param <V> map中的value类型
* @return 转化后的map
*/
public static <E, K, V> Map<K, V> toMap(Collection<E> collection, Function<E, K> key, Function<E, V> value) {
if (CollUtil.isEmpty(collection)) {
return MapUtil.newHashMap();
}
return collection.stream().collect(Collectors.toMap(key, value, (l, r) -> l));
}
/**
* 将collection按照规则(比如有相同的班级id)分类成map<br>
* <B>{@code Collection<E> -------> Map<K,List<E>> } </B>
*
* @param collection 需要分类的集合
* @param key 分类的规则
* @param <E> collection中的泛型
* @param <K> map中的key类型
* @return 分类后的map
*/
public static <E, K> Map<K, List<E>> groupByKey(Collection<E> collection, Function<E, K> key) {
if (CollUtil.isEmpty(collection)) {
return MapUtil.newHashMap();
}
return collection
.stream()
.collect(Collectors.groupingBy(key, LinkedHashMap::new, Collectors.toList()));
}
/**
* 将collection按照两个规则(比如有相同的年级id,班级id)分类成双层map<br>
* <B>{@code Collection<E> ---> Map<T,Map<U,List<E>>> } </B>
*
* @param collection 需要分类的集合
* @param key1 第一个分类的规则
* @param key2 第二个分类的规则
* @param <E> 集合元素类型
* @param <K> 第一个map中的key类型
* @param <U> 第二个map中的key类型
* @return 分类后的map
*/
public static <E, K, U> Map<K, Map<U, List<E>>> groupBy2Key(Collection<E> collection, Function<E, K> key1, Function<E, U> key2) {
if (CollUtil.isEmpty(collection)) {
return MapUtil.newHashMap();
}
return collection
.stream()
.collect(Collectors.groupingBy(key1, LinkedHashMap::new, Collectors.groupingBy(key2, LinkedHashMap::new, Collectors.toList())));
}
/**
* 将collection按照两个规则(比如有相同的年级id,班级id)分类成双层map<br>
* <B>{@code Collection<E> ---> Map<T,Map<U,E>> } </B>
*
* @param collection 需要分类的集合
* @param key1 第一个分类的规则
* @param key2 第二个分类的规则
* @param <T> 第一个map中的key类型
* @param <U> 第二个map中的key类型
* @param <E> collection中的泛型
* @return 分类后的map
*/
public static <E, T, U> Map<T, Map<U, E>> group2Map(Collection<E> collection, Function<E, T> key1, Function<E, U> key2) {
if (CollUtil.isEmpty(collection) || key1 == null || key2 == null) {
return MapUtil.newHashMap();
}
return collection
.stream()
.collect(Collectors.groupingBy(key1, LinkedHashMap::new, Collectors.toMap(key2, Function.identity(), (l, r) -> l)));
}
/**
* 将collection转化为List集合，但是两者的泛型不同<br>
* <B>{@code Collection<E> ------> List<T> } </B>
*
* @param collection 需要转化的集合
* @param function collection中的泛型转化为list泛型的lambda表达式
* @param <E> collection中的泛型
* @param <T> List中的泛型
* @return 转化后的list
*/
public static <E, T> List<T> toList(Collection<E> collection, Function<E, T> function) {
if (CollUtil.isEmpty(collection)) {
return CollUtil.newArrayList();
}
return collection
.stream()
.map(function)
.filter(Objects::nonNull)
.collect(Collectors.toList());
}
/**
* 将collection转化为Set集合，但是两者的泛型不同<br>
* <B>{@code Collection<E> ------> Set<T> } </B>
*
* @param collection 需要转化的集合
* @param function collection中的泛型转化为set泛型的lambda表达式
* @param <E> collection中的泛型
* @param <T> Set中的泛型
* @return 转化后的Set
*/
public static <E, T> Set<T> toSet(Collection<E> collection, Function<E, T> function) {
if (CollUtil.isEmpty(collection) || function == null) {
return CollUtil.newHashSet();
}
return collection
.stream()
.map(function)
.filter(Objects::nonNull)
.collect(Collectors.toSet());
}
/**
* 合并两个相同key类型的map
*
* @param map1 第一个需要合并的 map
* @param map2 第二个需要合并的 map
* @param merge 合并的lambda，将key value1 value2合并成最终的类型,注意value可能为空的情况
* @param <K> map中的key类型
* @param <X> 第一个 map的value类型
* @param <Y> 第二个 map的value类型
* @param <V> 最终map的value类型
* @return 合并后的map
*/
public static <K, X, Y, V> Map<K, V> merge(Map<K, X> map1, Map<K, Y> map2, BiFunction<X, Y, V> merge) {
if (MapUtil.isEmpty(map1) && MapUtil.isEmpty(map2)) {
return MapUtil.newHashMap();
} else if (MapUtil.isEmpty(map1)) {
map1 = MapUtil.newHashMap();
} else if (MapUtil.isEmpty(map2)) {
map2 = MapUtil.newHashMap();
}
Set<K> key = new HashSet<>();
key.addAll(map1.keySet());
key.addAll(map2.keySet());
Map<K, V> map = new HashMap<>();
for (K t : key) {
X x = map1.get(t);
Y y = map2.get(t);
V z = merge.apply(x, y);
if (z != null) {
map.put(t, z);
}
}
return map;
}
}

346
das/src/main/java/com/das/common/utils/StringUtils.java Normal file
View File

@ -0,0 +1,346 @@
package com.das.common.utils;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.lang.Validator;
import cn.hutool.core.util.StrUtil;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.springframework.util.AntPathMatcher;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 字符串工具类
*
* @author Lion Li
*/
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class StringUtils extends org.apache.commons.lang3.StringUtils {
public static final String SEPARATOR = ",";
/**
* 获取参数不为空值
*
* @param str defaultValue 要判断的value
* @return value 返回值
*/
public static String blankToDefault(String str, String defaultValue) {
return StrUtil.blankToDefault(str, defaultValue);
}
/**
* * 判断一个字符串是否为空串
*
* @param str String
* @return true：为空 false：非空
*/
public static boolean isEmpty(String str) {
return StrUtil.isEmpty(str);
}
/**
* * 判断一个字符串是否为非空串
*
* @param str String
* @return true：非空串 false：空串
*/
public static boolean isNotEmpty(String str) {
return !isEmpty(str);
}
/**
* 去空格
*/
public static String trim(String str) {
return StrUtil.trim(str);
}
/**
* 截取字符串
*
* @param str 字符串
* @param start 开始
* @return 结果
*/
public static String substring(final String str, int start) {
return substring(str, start, str.length());
}
/**
* 截取字符串
*
* @param str 字符串
* @param start 开始
* @param end 结束
* @return 结果
*/
public static String substring(final String str, int start, int end) {
return StrUtil.sub(str, start, end);
}
/**
* 格式化文本, {} 表示占位符<br>
* 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
* 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
* 例：<br>
* 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
* 转义{}： format("this is \\{} for {}", "a", "b") -> this is {} for a<br>
* 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
*
* @param template 文本模板，被替换的部分用 {} 表示
* @param params 参数值
* @return 格式化后的文本
*/
public static String format(String template, Object... params) {
return StrUtil.format(template, params);
}
/**
* 是否为http(s)://开头
*
* @param link 链接
* @return 结果
*/
public static boolean ishttp(String link) {
return Validator.isUrl(link);
}
/**
* 字符串转set
*
* @param str 字符串
* @param sep 分隔符
* @return set集合
*/
public static Set<String> str2Set(String str, String sep) {
return new HashSet<>(str2List(str, sep, true, false));
}
/**
* 字符串转list
*
* @param str 字符串
* @param sep 分隔符
* @param filterBlank 过滤纯空白
* @param trim 去掉首尾空白
* @return list集合
*/
public static List<String> str2List(String str, String sep, boolean filterBlank, boolean trim) {
List<String> list = new ArrayList<>();
if (isEmpty(str)) {
return list;
}
// 过滤空白字符串
if (filterBlank && isBlank(str)) {
return list;
}
String[] split = str.split(sep);
for (String string : split) {
if (filterBlank && isBlank(string)) {
continue;
}
if (trim) {
string = trim(string);
}
list.add(string);
}
return list;
}
/**
* 查找指定字符串是否包含指定字符串列表中的任意一个字符串同时串忽略大小写
*
* @param cs 指定字符串
* @param searchCharSequences 需要检查的字符串数组
* @return 是否包含任意一个字符串
*/
public static boolean containsAnyIgnoreCase(CharSequence cs, CharSequence... searchCharSequences) {
return StrUtil.containsAnyIgnoreCase(cs, searchCharSequences);
}
/**
* 驼峰转下划线命名
*/
public static String toUnderScoreCase(String str) {
return StrUtil.toUnderlineCase(str);
}
/**
* 是否包含字符串
*
* @param str 验证字符串
* @param strs 字符串组
* @return 包含返回true
*/
public static boolean inStringIgnoreCase(String str, String... strs) {
return StrUtil.equalsAnyIgnoreCase(str, strs);
}
/**
* 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld
*
* @param name 转换前的下划线大写方式命名的字符串
* @return 转换后的驼峰式命名的字符串
*/
public static String convertToCamelCase(String name) {
return StrUtil.upperFirst(StrUtil.toCamelCase(name));
}
/**
* 驼峰式命名法 例如：user_name->userName
*/
public static String toCamelCase(String s) {
return StrUtil.toCamelCase(s);
}
/**
* 查找指定字符串是否匹配指定字符串列表中的任意一个字符串
*
* @param str 指定字符串
* @param strs 需要检查的字符串数组
* @return 是否匹配
*/
public static boolean matches(String str, List<String> strs) {
if (isEmpty(str) || CollUtil.isEmpty(strs)) {
return false;
}
for (String pattern : strs) {
if (isMatch(pattern, str)) {
return true;
}
}
return false;
}
/**
* 判断url是否与规则配置:
* ? 表示单个字符;
* * 表示一层路径内的任意字符串，不可跨层级;
* ** 表示任意层路径;
*
* @param pattern 匹配规则
* @param url 需要匹配的url
*/
public static boolean isMatch(String pattern, String url) {
AntPathMatcher matcher = new AntPathMatcher();
return matcher.match(pattern, url);
}
/**
* 数字左边补齐0，使之达到指定长度。注意，如果数字转换为字符串后，长度大于size，则只保留 最后size个字符。
*
* @param num 数字对象
* @param size 字符串指定长度
* @return 返回数字的字符串格式，该字符串为指定长度。
*/
public static String padl(final Number num, final int size) {
return padl(num.toString(), size, '0');
}
/**
* 字符串左补齐。如果原始字符串s长度大于size，则只保留最后size个字符。
*
* @param s 原始字符串
* @param size 字符串指定长度
* @param c 用于补齐的字符
* @return 返回指定长度的字符串，由原字符串左补齐或截取得到。
*/
public static String padl(final String s, final int size, final char c) {
final StringBuilder sb = new StringBuilder(size);
if (s != null) {
final int len = s.length();
if (s.length() <= size) {
for (int i = size - len; i > 0; i--) {
sb.append(c);
}
sb.append(s);
} else {
return s.substring(len - size, len);
}
} else {
for (int i = size; i > 0; i--) {
sb.append(c);
}
}
return sb.toString();
}
/**
* 切分字符串(分隔符默认逗号)
*
* @param str 被切分的字符串
* @return 分割后的数据列表
*/
public static List<String> splitList(String str) {
return splitTo(str, Convert::toStr);
}
/**
* 切分字符串
*
* @param str 被切分的字符串
* @param separator 分隔符
* @return 分割后的数据列表
*/
public static List<String> splitList(String str, String separator) {
return splitTo(str, separator, Convert::toStr);
}
/**
* 切分字符串自定义转换(分隔符默认逗号)
*
* @param str 被切分的字符串
* @param mapper 自定义转换
* @return 分割后的数据列表
*/
public static <T> List<T> splitTo(String str, Function<? super Object, T> mapper) {
return splitTo(str, SEPARATOR, mapper);
}
/**
* 切分字符串自定义转换
*
* @param str 被切分的字符串
* @param separator 分隔符
* @param mapper 自定义转换
* @return 分割后的数据列表
*/
public static <T> List<T> splitTo(String str, String separator, Function<? super Object, T> mapper) {
if (isBlank(str)) {
return new ArrayList<>(0);
}
return StrUtil.split(str, separator)
.stream()
.filter(Objects::nonNull)
.map(mapper)
.collect(Collectors.toList());
}
/*
* 首字母变大写
*
* */
public static String capitalizeFirstLetter(String str) {
char[] chars = str.toCharArray();
chars[0] = toUpperCase(chars[0]);
return String.valueOf(chars);
}
/*
* 字母变大写
*
* */
public static char toUpperCase(char c) {
if (97 <= c && c <= 122) {
c ^= 32;
}
return c;
}
}

20
das/src/main/java/com/das/modules/auth/controller/LoginController.java
View File

@ -6,11 +6,11 @@ import com.das.common.captcha.CaptchaUtils;
import com.das.common.captcha.CaptchaVO;
import com.das.common.result.R;
import com.das.common.utils.AdminRedisTemplate;
import com.das.modules.auth.domain.LoginUserDetails;
import com.das.modules.auth.domain.request.LoginRequest;
import com.das.modules.auth.domain.request.RefreshTokenRequest;
import com.das.modules.auth.domain.vo.LoginVO;
import com.das.modules.auth.service.ILoginService;
import com.das.modules.auth.domain.vo.LoginUserDetailsVo;
import com.das.modules.auth.domain.dto.LoginDto;
import com.das.modules.auth.domain.dto.RefreshTokenDto;
import com.das.modules.auth.domain.vo.LoginVo;
import com.das.modules.auth.service.LoginService;
import com.fasterxml.jackson.core.JsonProcessingException;
import io.micrometer.common.util.StringUtils;
import jakarta.annotation.Resource;
@ -29,7 +29,7 @@ import org.springframework.web.bind.annotation.*;
@RestController
public class LoginController {
@Resource
private ILoginService loginService;
private LoginService loginService;
@Resource
private CaptchaProperties captchaProperties;
@ -41,8 +41,8 @@ public class LoginController {
* @return 退出结果提示信息
*/
@PostMapping("/login")
public R<LoginUserDetails> login(@RequestBody LoginRequest loginRequest, HttpServletRequest request, HttpServletResponse response) throws JsonProcessingException {
LoginUserDetails loginInfo = loginService.login(loginRequest,request, response);
public R<LoginUserDetailsVo> login(@RequestBody LoginDto loginDto, HttpServletRequest request, HttpServletResponse response) throws JsonProcessingException {
LoginUserDetailsVo loginInfo = loginService.login(loginDto,request, response);
if (StringUtils.isNotEmpty(loginInfo.getMsg())){
return R.fail(loginInfo.getMsg());
}
@ -73,8 +73,8 @@ public class LoginController {
}
@PostMapping("/refreshToken")
public R<LoginVO> refreshToken(@RequestBody RefreshTokenRequest refreshToken){
LoginVO loginVO = loginService.refreshToken(refreshToken);
public R<LoginVo> refreshToken(@RequestBody RefreshTokenDto refreshToken){
LoginVo loginVO = loginService.refreshToken(refreshToken);
return R.success(loginVO);
}

62
das/src/main/java/com/das/modules/auth/controller/MenusController.java Normal file
View File

@ -0,0 +1,62 @@
package com.das.modules.auth.controller;
import com.das.common.result.R;
import com.das.common.utils.PageDataInfo;
import com.das.common.utils.PageQuery;
import com.das.modules.auth.domain.dto.DeleteDto;
import com.das.modules.auth.domain.dto.SysMenuDto;
import com.das.modules.auth.domain.dto.SysMenuQueryDto;
import com.das.modules.auth.entity.SysMenu;
import com.das.modules.auth.service.SysMenuService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @author chenhaojie
* @Description 菜单控制层
*/
@Slf4j
@RequestMapping("/api/menus")
@RestController
public class MenusController {
@Autowired
private SysMenuService sysMenuService;
/**
* 新增菜单接口
* @return 结果提示信息
*/
@PostMapping("/add")
public R<?> createMenu(@RequestBody SysMenuDto sysMenuDto) {
return R.success(sysMenuService.createMenu(sysMenuDto));
}
/**
* 修改菜单接口
* @return 结果提示信息
*/
@PostMapping("/update")
public R<?> updateMenu(@RequestBody SysMenuDto sysMenuDto) {
sysMenuService.updateMenu(sysMenuDto);
return R.success();
}
/**
* 删除菜单接口
* @return 结果提示信息
*/
@PostMapping("/delete")
public R<?> deleteMenu(@RequestBody DeleteDto deleteDto) {
sysMenuService.deleteMenu(deleteDto);
return R.success();
}
@PostMapping("/query")
public PageDataInfo<SysMenu> queryMenuList(@RequestBody SysMenuQueryDto categoryBo, PageQuery pageQuery) {
return sysMenuService.queryMenuList(categoryBo, pageQuery);
}
}

60
das/src/main/java/com/das/modules/auth/controller/OrgController.java Normal file
View File

@ -0,0 +1,60 @@
package com.das.modules.auth.controller;
import com.das.common.result.R;
import com.das.common.utils.PageDataInfo;
import com.das.common.utils.PageQuery;
import com.das.modules.auth.domain.dto.*;
import com.das.modules.auth.entity.SysOrg;
import com.das.modules.auth.service.SysOrgService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @author chenhaojie
* @Description 用户控制层
*/
@Slf4j
@RequestMapping("/api/org")
@RestController
public class OrgController {
@Autowired
private SysOrgService sysOrgService;
/**
* 新增菜单接口
* @return 结果提示信息
*/
@PostMapping("/add")
public R<?> createOrg(@RequestBody SysOrgDto sysOrgDto) {
return R.success(sysOrgService.createOrg(sysOrgDto));
}
/**
* 修改菜单接口
* @return 结果提示信息
*/
@PostMapping("/update")
public R<?> updateOrg(@RequestBody SysOrgDto sysOrgDto) {
sysOrgService.updateOrg(sysOrgDto);
return R.success();
}
/**
* 删除菜单接口
* @return 结果提示信息
*/
@PostMapping("/delete")
public R<?> deleteOrg(@RequestBody DeleteDto deleteDto) {
sysOrgService.deleteOrg(deleteDto);
return R.success();
}
@PostMapping("/query")
public PageDataInfo<SysOrg> queryOrgList(@RequestBody SysOrgQueryDto sysOrgQueryDto, PageQuery pageQuery) {
return sysOrgService.queryOrgList(sysOrgQueryDto, pageQuery);
}
}

62
das/src/main/java/com/das/modules/auth/controller/UserController.java Normal file
View File

@ -0,0 +1,62 @@
package com.das.modules.auth.controller;
import com.das.common.result.R;
import com.das.common.utils.PageDataInfo;
import com.das.common.utils.PageQuery;
import com.das.modules.auth.domain.dto.DeleteDto;
import com.das.modules.auth.domain.dto.SysUserDto;
import com.das.modules.auth.domain.dto.SysUserQueryDto;
import com.das.modules.auth.entity.SysUser;
import com.das.modules.auth.service.SysUserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @author chenhaojie
* @Description 用户控制层
*/
@Slf4j
@RequestMapping("/api/user")
@RestController
public class UserController {
@Autowired
private SysUserService sysUserService;
/**
* 新增菜单接口
* @return 结果提示信息
*/
@PostMapping("/add")
public R<?> createUser(@RequestBody SysUserDto sysUserDto) {
return R.success(sysUserService.createUser(sysUserDto));
}
/**
* 修改菜单接口
* @return 结果提示信息
*/
@PostMapping("/update")
public R<?> updateUser(@RequestBody SysUserDto sysUserDto) {
sysUserService.updateUser(sysUserDto);
return R.success();
}
/**
* 删除菜单接口
* @return 结果提示信息
*/
@PostMapping("/delete")
public R<?> deleteUser(@RequestBody DeleteDto deleteDto) {
sysUserService.deleteUser(deleteDto);
return R.success();
}
@PostMapping("/query")
public PageDataInfo<SysUser> queryUserList(@RequestBody SysUserQueryDto sysUserQueryDto, PageQuery pageQuery) {
return sysUserService.queryUserList(sysUserQueryDto, pageQuery);
}
}

11
das/src/main/java/com/das/modules/auth/domain/dto/DeleteDto.java Normal file
View File

@ -0,0 +1,11 @@
package com.das.modules.auth.domain.dto;
import lombok.Data;
import java.io.Serializable;
@Data
public class DeleteDto implements Serializable {
/** ID */
private Long id;
}

4
das/src/main/java/com/das/modules/auth/domain/request/LoginRequest.java → das/src/main/java/com/das/modules/auth/domain/dto/LoginDto.java
View File

@ -1,4 +1,4 @@
package com.das.modules.auth.domain.request;
package com.das.modules.auth.domain.dto;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;
@ -9,7 +9,7 @@ import lombok.Data;
* @Description
*/
@Data
public class LoginRequest {
public class LoginDto {
/**
* * 用户账号

4
das/src/main/java/com/das/modules/auth/domain/request/RefreshTokenRequest.java → das/src/main/java/com/das/modules/auth/domain/dto/RefreshTokenDto.java
View File

@ -1,4 +1,4 @@
package com.das.modules.auth.domain.request;
package com.das.modules.auth.domain.dto;
import jakarta.validation.constraints.NotBlank;
import lombok.Data;
@ -9,7 +9,7 @@ import lombok.Data;
* @Description
*/
@Data
public class RefreshTokenRequest {
public class RefreshTokenDto {
/**
* * 刷新token不允许为空

36
das/src/main/java/com/das/modules/auth/domain/dto/SysMenuDto.java Normal file
View File

@ -0,0 +1,36 @@
package com.das.modules.auth.domain.dto;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
@Data
public class SysMenuDto implements Serializable {
/** 菜单ID */
private Long id ;
/** 菜单名称 */
private String menuName ;
/** 菜单排列顺序 */
private Integer menuOrder ;
/** 菜单图标名称 */
private String menuIcon ;
/** 菜单操作类型 */
private Integer funType ;
/** 菜单操作参数 */
private String funParam ;
/** 权限ID */
private Long authorityId ;
/** 上级菜单ID */
private Long parentMenuId ;
/** 乐观锁 */
private Integer revision ;
/** 创建人 */
private String createdBy ;
/** 创建时间 */
private Date createdTime ;
/** 更新人 */
private String updatedBy ;
/** 更新时间 */
private Date updatedTime ;
}

13
das/src/main/java/com/das/modules/auth/domain/dto/SysMenuQueryDto.java Normal file
View File

@ -0,0 +1,13 @@
package com.das.modules.auth.domain.dto;
import lombok.Data;
import java.io.Serializable;
@Data
public class SysMenuQueryDto implements Serializable {
/** 菜单ID */
private Long id ;
/** 上级菜单ID */
private Long parentMenuId ;
}

39
das/src/main/java/com/das/modules/auth/domain/dto/SysOrgDto.java Normal file
View File

@ -0,0 +1,39 @@
package com.das.modules.auth.domain.dto;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
@Data
public class SysOrgDto implements Serializable {
/** 机构id */
private Long id ;
/** 机构名称 */
private String name ;
/** 机构编码 */
private String mrid ;
/** 省份 */
private String province ;
/** 城市 */
private String city ;
/** 区县 */
private String county ;
/** 具体地址 */
private String address ;
/** 联系电话 */
private String contactPhone ;
/** 备注 */
private String remarks ;
private Long parentOrgId ;
/** 乐观锁 */
private Integer revision ;
/** 创建人 */
private String createdBy ;
/** 创建时间 */
private Date createdTime ;
/** 更新人 */
private String updatedBy ;
/** 更新时间 */
private Date updatedTime ;
}

18
das/src/main/java/com/das/modules/auth/domain/dto/SysOrgQueryDto.java Normal file
View File

@ -0,0 +1,18 @@
package com.das.modules.auth.domain.dto;
import lombok.Data;
import java.io.Serializable;
@Data
public class SysOrgQueryDto implements Serializable {
/** 机构名称 */
private String name ;
/** 省份 */
private String province ;
/** 城市 */
private String city ;
/** 区县 */
private String county ;
private Long parentOrgID ;
}

36
das/src/main/java/com/das/modules/auth/domain/dto/SysUserDto.java Normal file
View File

@ -0,0 +1,36 @@
package com.das.modules.auth.domain.dto;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
@Data
public class SysUserDto implements Serializable {
/** 角色ID */
private Long id ;
/** 账号 */
private String account ;
/** 密码 */
private String password ;
/** 职员名称 */
private String userName ;
/** 职员邮箱 */
private String email ;
/** 手机号 */
private String phone ;
/** 所属机构id */
private Long orgId ;
/** 最后登录时间 */
private Date lastLogin ;
/** 乐观锁 */
private Integer revision ;
/** 创建人 */
private String createdBy ;
/** 创建时间 */
private Date createdTime ;
/** 更新人 */
private String updatedBy ;
/** 更新时间 */
private Date updatedTime ;
}

15
das/src/main/java/com/das/modules/auth/domain/dto/SysUserQueryDto.java Normal file
View File

@ -0,0 +1,15 @@
package com.das.modules.auth.domain.dto;
import lombok.Data;
import java.io.Serializable;
@Data
public class SysUserQueryDto implements Serializable {
/** 职员名称 */
private String userName ;
/** 手机号 */
private String phone ;
/** 组织机构id */
private Long orgId ;
}

7
das/src/main/java/com/das/modules/auth/domain/LoginUserDetails.java → das/src/main/java/com/das/modules/auth/domain/vo/LoginUserDetailsVo.java
View File

@ -1,6 +1,5 @@
package com.das.modules.auth.domain;
package com.das.modules.auth.domain.vo;
import com.das.modules.auth.domain.vo.SysUserVo;
import lombok.Data;
import java.io.Serializable;
@ -10,7 +9,7 @@ import java.io.Serializable;
* @Description
*/
@Data
public class LoginUserDetails implements Serializable {
public class LoginUserDetailsVo implements Serializable {
private static final long serialVersionUID = 1L;
@ -23,7 +22,7 @@ public class LoginUserDetails implements Serializable {
private String token;
public LoginUserDetails() {
public LoginUserDetailsVo() {
}

8
das/src/main/java/com/das/modules/auth/domain/vo/LoginVO.java → das/src/main/java/com/das/modules/auth/domain/vo/LoginVo.java
View File

@ -9,7 +9,7 @@ import java.io.Serializable;
* @Description
*/
@Data
public class LoginVO implements Serializable {
public class LoginVo implements Serializable {
private static final long serialVersionUID = 1L;
@ -31,16 +31,16 @@ public class LoginVO implements Serializable {
*/
private Integer expire;
public LoginVO(){}
public LoginVo(){}
public LoginVO(String accessToken, String refreshToken , Integer expire, String msg){
public LoginVo(String accessToken, String refreshToken , Integer expire, String msg){
this.refreshToken = refreshToken;
this.accessToken = accessToken;
this.expire = expire;
this.msg = msg;
}
public LoginVO(String accessToken, String refreshToken , Integer expire){
public LoginVo(String accessToken, String refreshToken , Integer expire){
this.refreshToken = refreshToken;
this.accessToken = accessToken;
this.expire = expire;

47
das/src/main/java/com/das/modules/auth/entity/SysMenu.java Normal file
View File

@ -0,0 +1,47 @@
package com.das.modules.auth.entity;
import com.baomidou.mybatisplus.annotation.*;
import com.das.common.constant.BaseEntity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@TableName("sys_menu")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class SysMenu extends BaseEntity {
private static final long serialVersionUID = 1L;
/** 菜单ID */
@TableId(value = "id", type = IdType.ASSIGN_ID)
private Long id ;
/** 菜单名称 */
@TableField("menu_name")
private String menuName ;
/** 菜单排列顺序 */
@TableField("menu_order")
private Integer menuOrder ;
/** 菜单图标名称 */
@TableField("menu_icon")
private String menuIcon ;
/** 菜单操作类型 */
@TableField("fun_type")
private Integer funType ;
/** 菜单操作参数 */
@TableField("fun_param")
private String funParam ;
/** 权限ID */
@TableField("authority_id")
private Long authorityId ;
/** 上级菜单ID */
@TableField("parent_menu_id")
private Long parentMenuId ;
/** 乐观锁 */
@Version
@TableField("revision")
private Integer revision ;
}

102
das/src/main/java/com/das/modules/auth/entity/SysOrg.java Normal file
View File

@ -0,0 +1,102 @@
package com.das.modules.auth.entity;
import com.baomidou.mybatisplus.annotation.*;
import com.das.common.constant.BaseEntity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;
/**
* <p>
* 公司机构
* </p>
*
* @author chenhaojie
*/
@TableName("sys_org")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class SysOrg extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 机构ID
*/
@TableId(value = "id", type = IdType.ASSIGN_ID)
private Long id;
/**
* 机构名称
*/
@TableField("name")
private String name;
/**
* 机构编码
*/
@TableField("mrid")
private String mrid;
/**
* 省
*/
@TableField("province")
private String province;
/**
* 城市
*/
@TableField("city")
private String city;
/**
* 区县
*/
@TableField("county")
private String county;
/**
* 详细地址
*/
@TableField("address")
private String address;
/**
* 联系电话
*/
@TableField("contact_phone")
private String contactPhone;
/**
* 备注
*/
@TableField("remarks")
private String remarks;
/**
* 上级机构id
*/
@TableField("parent_org_iD")
private Long parentOrgID;
/**
* 乐观锁
*/
@Version
@TableField("revision")
private Integer revision;
/**
* 别名
*/
@TableField("alias_name")
private String aliasName;
}

2
das/src/main/java/com/das/modules/auth/entity/SysUser.java
View File

@ -76,6 +76,6 @@ public class SysUser extends BaseEntity {
*/
@Version
@TableField("revision")
private int revision;
private Integer revision;
}

198
das/src/main/java/com/das/modules/auth/mapper/BaseMapperPlus.java Normal file
View File

@ -0,0 +1,198 @@
package com.das.modules.auth.mapper;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.ReflectionKit;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.toolkit.Db;
import com.das.common.utils.BeanCopyUtils;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 自定义 Mapper 接口, 实现 自定义扩展
*
* @param <T> table 泛型
* @param <V> vo 泛型
* @author Lion Li
* @since 2021-05-13
*/
@SuppressWarnings("unchecked")
public interface BaseMapperPlus<T, V> extends BaseMapper<T> {
Log log = LogFactory.getLog(BaseMapperPlus.class);
default Class<V> currentVoClass() {
return (Class<V>) ReflectionKit.getSuperClassGenericType(this.getClass(), BaseMapperPlus.class, 1);
}
default Class<T> currentModelClass() {
return (Class<T>) ReflectionKit.getSuperClassGenericType(this.getClass(), BaseMapperPlus.class, 0);
}
default List<T> selectList() {
return this.selectList(new QueryWrapper<>());
}
/**
* 批量插入
*/
default boolean insertBatch(Collection<T> entityList) {
return Db.saveBatch(entityList);
}
/**
* 批量更新
*/
default boolean updateBatchById(Collection<T> entityList) {
return Db.updateBatchById(entityList);
}
/**
* 批量插入或更新
*/
default boolean insertOrUpdateBatch(Collection<T> entityList) {
return Db.saveOrUpdateBatch(entityList);
}
/**
* 批量插入(包含限制条数)
*/
default boolean insertBatch(Collection<T> entityList, int batchSize) {
return Db.saveBatch(entityList, batchSize);
}
/**
* 批量更新(包含限制条数)
*/
default boolean updateBatchById(Collection<T> entityList, int batchSize) {
return Db.updateBatchById(entityList, batchSize);
}
/**
* 批量插入或更新(包含限制条数)
*/
default boolean insertOrUpdateBatch(Collection<T> entityList, int batchSize) {
return Db.saveOrUpdateBatch(entityList, batchSize);
}
/**
* 插入或更新(包含限制条数)
*/
default boolean insertOrUpdate(T entity) {
return Db.saveOrUpdate(entity);
}
default V selectVoById(Serializable id) {
return selectVoById(id, this.currentVoClass());
}
/**
* 根据 ID 查询
*/
default <C> C selectVoById(Serializable id, Class<C> voClass) {
T obj = this.selectById(id);
if (ObjectUtil.isNull(obj)) {
return null;
}
return BeanCopyUtils.copy(obj, voClass);
}
default List<V> selectVoBatchIds(Collection<? extends Serializable> idList) {
return selectVoBatchIds(idList, this.currentVoClass());
}
/**
* 查询（根据ID 批量查询）
*/
default <C> List<C> selectVoBatchIds(Collection<? extends Serializable> idList, Class<C> voClass) {
List<T> list = this.selectBatchIds(idList);
if (CollUtil.isEmpty(list)) {
return CollUtil.newArrayList();
}
return BeanCopyUtils.copyList(list, voClass);
}
default List<V> selectVoByMap(Map<String, Object> map) {
return selectVoByMap(map, this.currentVoClass());
}
/**
* 查询（根据 columnMap 条件）
*/
default <C> List<C> selectVoByMap(Map<String, Object> map, Class<C> voClass) {
List<T> list = this.selectByMap(map);
if (CollUtil.isEmpty(list)) {
return CollUtil.newArrayList();
}
return BeanCopyUtils.copyList(list, voClass);
}
default V selectVoOne(Wrapper<T> wrapper) {
return selectVoOne(wrapper, this.currentVoClass());
}
/**
* 根据 entity 条件，查询一条记录
*/
default <C> C selectVoOne(Wrapper<T> wrapper, Class<C> voClass) {
T obj = this.selectOne(wrapper);
if (ObjectUtil.isNull(obj)) {
return null;
}
return BeanCopyUtils.copy(obj, voClass);
}
default List<V> selectVoList() {
return selectVoList(new QueryWrapper<>(), this.currentVoClass());
}
default List<V> selectVoList(Wrapper<T> wrapper) {
return selectVoList(wrapper, this.currentVoClass());
}
/**
* 根据 entity 条件，查询全部记录
*/
default <C> List<C> selectVoList(Wrapper<T> wrapper, Class<C> voClass) {
List<T> list = this.selectList(wrapper);
if (CollUtil.isEmpty(list)) {
return CollUtil.newArrayList();
}
return BeanCopyUtils.copyList(list, voClass);
}
default <P extends IPage<V>> P selectVoPage(IPage<T> page, Wrapper<T> wrapper) {
return selectVoPage(page, wrapper, this.currentVoClass());
}
/**
* 分页查询VO
*/
default <C, P extends IPage<C>> P selectVoPage(IPage<T> page, Wrapper<T> wrapper, Class<C> voClass) {
IPage<T> pageData = this.selectPage(page, wrapper);
IPage<C> voPage = new Page<>(pageData.getCurrent(), pageData.getSize(), pageData.getTotal());
if (CollUtil.isEmpty(pageData.getRecords())) {
return (P) voPage;
}
voPage.setRecords(BeanCopyUtils.copyList(pageData.getRecords(), voClass));
return (P) voPage;
}
default <C> List<C> selectObjs(Wrapper<T> wrapper, Function<? super Object, C> mapper) {
return this.selectObjs(wrapper).stream().filter(Objects::nonNull).map(mapper).collect(Collectors.toList());
}
}

19
das/src/main/java/com/das/modules/auth/mapper/SysMenuMapper.java Normal file
View File

@ -0,0 +1,19 @@
package com.das.modules.auth.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.das.modules.auth.domain.dto.SysMenuQueryDto;
import com.das.modules.auth.entity.SysMenu;
import org.apache.ibatis.annotations.Param;
/**
* <p>
* 菜单信息 Mapper 接口
* </p>
*
* @author chenhaojie
*/
public interface SysMenuMapper extends BaseMapperPlus<SysMenu, SysMenu> {
IPage<SysMenu> queryMenuList(IPage<SysMenu> page, @Param("sysMenu") SysMenuQueryDto sysMenuQueryDto);
}

20
das/src/main/java/com/das/modules/auth/mapper/SysOrgMapper.java Normal file
View File

@ -0,0 +1,20 @@
package com.das.modules.auth.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.das.modules.auth.domain.dto.SysOrgQueryDto;
import com.das.modules.auth.domain.dto.SysUserQueryDto;
import com.das.modules.auth.entity.SysOrg;
import com.das.modules.auth.entity.SysUser;
import org.apache.ibatis.annotations.Param;
/**
* <p>
* 用户信息 Mapper 接口
* </p>
*
* @author chenhaojie
*/
public interface SysOrgMapper extends BaseMapper<SysOrg> {
IPage<SysOrg> queryOrgList(IPage<SysOrg> page, @Param("sysOrg") SysOrgQueryDto sysOrgQueryDto);
}

7
das/src/main/java/com/das/modules/auth/mapper/SysUserMapper.java
View File

@ -1,7 +1,12 @@
package com.das.modules.auth.mapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.das.modules.auth.domain.dto.SysMenuQueryDto;
import com.das.modules.auth.domain.dto.SysUserQueryDto;
import com.das.modules.auth.entity.SysMenu;
import com.das.modules.auth.entity.SysUser;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
/**
* <p>
@ -11,5 +16,5 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper;
* @author chenhaojie
*/
public interface SysUserMapper extends BaseMapper<SysUser> {
IPage<SysUser> queryUserList(IPage<SysUser> page, @Param("sysUser") SysUserQueryDto sysUserQueryDto);
}

16
das/src/main/java/com/das/modules/auth/service/ILoginService.java → das/src/main/java/com/das/modules/auth/service/LoginService.java
View File

@ -1,10 +1,10 @@
package com.das.modules.auth.service;
import com.das.modules.auth.domain.LoginUserDetails;
import com.das.modules.auth.domain.request.LoginRequest;
import com.das.modules.auth.domain.request.RefreshTokenRequest;
import com.das.modules.auth.domain.vo.LoginVO;
import com.das.modules.auth.domain.vo.LoginUserDetailsVo;
import com.das.modules.auth.domain.dto.LoginDto;
import com.das.modules.auth.domain.dto.RefreshTokenDto;
import com.das.modules.auth.domain.vo.LoginVo;
import com.fasterxml.jackson.core.JsonProcessingException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
@ -14,15 +14,15 @@ import jakarta.servlet.http.HttpServletResponse;
* @author chenhaojie
* @Description
*/
public interface ILoginService {
public interface LoginService {
/**
* 登录接口
*
* @param loginRequest 登录请求
* @param loginDto 登录请求
* @return 登录成功
*/
LoginUserDetails login(LoginRequest loginRequest, HttpServletRequest request, HttpServletResponse response) throws JsonProcessingException;
LoginUserDetailsVo login(LoginDto loginDto, HttpServletRequest request, HttpServletResponse response) throws JsonProcessingException;
/**
* 退出登录
@ -35,5 +35,5 @@ public interface ILoginService {
* @param refreshToken
* @return
*/
LoginVO refreshToken(RefreshTokenRequest refreshToken);
LoginVo refreshToken(RefreshTokenDto refreshToken);
}

19
das/src/main/java/com/das/modules/auth/service/SysMenuService.java Normal file
View File

@ -0,0 +1,19 @@
package com.das.modules.auth.service;
import com.das.common.utils.PageDataInfo;
import com.das.common.utils.PageQuery;
import com.das.modules.auth.domain.dto.DeleteDto;
import com.das.modules.auth.domain.dto.SysMenuDto;
import com.das.modules.auth.domain.dto.SysMenuQueryDto;
import com.das.modules.auth.entity.SysMenu;
public interface SysMenuService {
SysMenu createMenu(SysMenuDto sysMenuDto);
int updateMenu(SysMenuDto sysMenuDto);
int deleteMenu(DeleteDto deleteDto);
PageDataInfo<SysMenu> queryMenuList(SysMenuQueryDto sysMenuQueryDto, PageQuery pageQuery);
}

16
das/src/main/java/com/das/modules/auth/service/SysOrgService.java Normal file
View File

@ -0,0 +1,16 @@
package com.das.modules.auth.service;
import com.das.common.utils.PageDataInfo;
import com.das.common.utils.PageQuery;
import com.das.modules.auth.domain.dto.*;
import com.das.modules.auth.entity.SysOrg;
public interface SysOrgService {
SysOrg createOrg(SysOrgDto sysUserDto);
int updateOrg(SysOrgDto sysUserDto);
int deleteOrg(DeleteDto deleteDto);
PageDataInfo<SysOrg> queryOrgList(SysOrgQueryDto sysOrgQueryDto, PageQuery pageQuery);
}

14
das/src/main/java/com/das/modules/auth/service/SysUserService.java
View File

@ -1,4 +1,18 @@
package com.das.modules.auth.service;
import com.das.common.utils.PageDataInfo;
import com.das.common.utils.PageQuery;
import com.das.modules.auth.domain.dto.DeleteDto;
import com.das.modules.auth.domain.dto.SysUserDto;
import com.das.modules.auth.domain.dto.SysUserQueryDto;
import com.das.modules.auth.entity.SysUser;
public interface SysUserService {
SysUser createUser(SysUserDto sysUserDto);
int updateUser(SysUserDto sysUserDto);
int deleteUser(DeleteDto deleteDto);
PageDataInfo<SysUser> queryUserList(SysUserQueryDto sysUserQueryDto, PageQuery pageQuery);
}

46
das/src/main/java/com/das/modules/auth/service/impl/LoginServiceImpl.java
View File

@ -8,14 +8,14 @@ import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.das.common.captcha.CaptchaUtils;
import com.das.common.config.SaTokenProperties;
import com.das.common.utils.AdminRedisTemplate;
import com.das.modules.auth.domain.LoginUserDetails;
import com.das.modules.auth.domain.request.LoginRequest;
import com.das.modules.auth.domain.request.RefreshTokenRequest;
import com.das.modules.auth.domain.vo.LoginVO;
import com.das.modules.auth.domain.vo.LoginUserDetailsVo;
import com.das.modules.auth.domain.dto.LoginDto;
import com.das.modules.auth.domain.dto.RefreshTokenDto;
import com.das.modules.auth.domain.vo.LoginVo;
import com.das.modules.auth.domain.vo.SysUserVo;
import com.das.modules.auth.entity.SysUser;
import com.das.modules.auth.mapper.SysUserMapper;
import com.das.modules.auth.service.ILoginService;
import com.das.modules.auth.service.LoginService;
import com.fasterxml.jackson.core.JsonProcessingException;
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletRequest;
@ -30,7 +30,7 @@ import java.time.Duration;
* @Description
*/
@Service
public class LoginServiceImpl implements ILoginService {
public class LoginServiceImpl implements LoginService {
@Resource
private SaTokenProperties saTokenProperties;
@ -41,13 +41,13 @@ public class LoginServiceImpl implements ILoginService {
private AdminRedisTemplate adminRedisTemplate;
@Override
public LoginUserDetails login(LoginRequest loginRequest, HttpServletRequest request, HttpServletResponse response) throws JsonProcessingException {
String name = loginRequest.getUsername();
String password = loginRequest.getPassword();
String code = loginRequest.getCode();
String key = loginRequest.getKey();
public LoginUserDetailsVo login(LoginDto loginDto, HttpServletRequest request, HttpServletResponse response){
String name = loginDto.getUsername();
String password = loginDto.getPassword();
String code = loginDto.getCode();
String key = loginDto.getKey();
LoginUserDetails loginInfo = new LoginUserDetails();
LoginUserDetailsVo loginInfo = new LoginUserDetailsVo();
LambdaQueryWrapper<SysUser> wrapper = Wrappers.lambdaQuery();
wrapper.eq(SysUser::getAccount, name);
SysUser sysUser = sysUserMapper.selectOne(wrapper);
@ -94,29 +94,29 @@ public class LoginServiceImpl implements ILoginService {
}
@Override
public LoginVO refreshToken(RefreshTokenRequest refreshToken) {
LoginUserDetails loginUserDetails = adminRedisTemplate.get(refreshToken.getRefreshToken());
LoginVO loginInfo = new LoginVO();
if (loginUserDetails == null) {
public LoginVo refreshToken(RefreshTokenDto refreshToken) {
LoginUserDetailsVo loginUserDetailsVo = adminRedisTemplate.get(refreshToken.getRefreshToken());
LoginVo loginInfo = new LoginVo();
if (loginUserDetailsVo == null) {
loginInfo.setMsg("token过期，请重新登录");
return loginInfo;
}
StpUtil.login(loginUserDetails.getSysUser().getAccount());// 执行登录，这里username为用户唯一标识
StpUtil.login(loginUserDetailsVo.getSysUser().getAccount());// 执行登录，这里username为用户唯一标识
String newToken = StpUtil.getTokenValue().replace("-", "");;
String newRefreshTokenUuid = IdUtil.fastSimpleUUID();
String newRefreshToken = "refresh:" + newRefreshTokenUuid;
loginInfo.setAccessToken(newToken);
loginUserDetails.setToken(newToken);
loginUserDetails.setRefreshToken(newRefreshTokenUuid);
String oldRefreshToken = loginUserDetails.getRefreshToken();
loginUserDetailsVo.setToken(newToken);
loginUserDetailsVo.setRefreshToken(newRefreshTokenUuid);
String oldRefreshToken = loginUserDetailsVo.getRefreshToken();
adminRedisTemplate.setEx(newToken, loginUserDetails, Duration.ofSeconds(saTokenProperties.getExpireTime()));
adminRedisTemplate.setEx(newRefreshToken, loginUserDetails, Duration.ofSeconds(saTokenProperties.getRefreshExpireTime()));
adminRedisTemplate.setEx(newToken, loginUserDetailsVo, Duration.ofSeconds(saTokenProperties.getExpireTime()));
adminRedisTemplate.setEx(newRefreshToken, loginUserDetailsVo, Duration.ofSeconds(saTokenProperties.getRefreshExpireTime()));
// 删除原有刷新token
adminRedisTemplate.del("refresh:" + oldRefreshToken);
return new LoginVO(newToken, newRefreshToken, saTokenProperties.getRefreshExpireTime());
return new LoginVo(newToken, newRefreshToken, saTokenProperties.getRefreshExpireTime());
}

50
das/src/main/java/com/das/modules/auth/service/impl/SysMenuServiceImpl.java Normal file
View File

@ -0,0 +1,50 @@
package com.das.modules.auth.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.das.common.utils.BeanCopyUtils;
import com.das.common.utils.SequenceUtils;
import com.das.common.utils.PageDataInfo;
import com.das.common.utils.PageQuery;
import com.das.modules.auth.domain.dto.DeleteDto;
import com.das.modules.auth.domain.dto.SysMenuDto;
import com.das.modules.auth.domain.dto.SysMenuQueryDto;
import com.das.modules.auth.entity.SysMenu;
import com.das.modules.auth.mapper.SysMenuMapper;
import com.das.modules.auth.service.SysMenuService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class SysMenuServiceImpl implements SysMenuService {
@Autowired
SysMenuMapper sysMenuMapper;
@Override
public SysMenu createMenu(SysMenuDto sysMenuDto) {
SysMenu sysMenu = new SysMenu();
BeanCopyUtils.copy(sysMenuDto,sysMenu);
sysMenu.setId(SequenceUtils.generateId());
sysMenuMapper.insert(sysMenu);
return sysMenu;
}
@Override
public int updateMenu(SysMenuDto sysMenuDto) {
SysMenu sysMenu = new SysMenu();
BeanUtils.copyProperties(sysMenuDto,sysMenu);
return sysMenuMapper.updateById(sysMenu);
}
@Override
public int deleteMenu(DeleteDto deleteDto) {
return sysMenuMapper.deleteById(deleteDto.getId());
}
@Override
public PageDataInfo<SysMenu> queryMenuList(SysMenuQueryDto sysMenuQueryDto, PageQuery pageQuery) {
IPage<SysMenu> iPage = sysMenuMapper.queryMenuList(pageQuery.build(), sysMenuQueryDto);
return PageDataInfo.build(iPage.getRecords(), iPage.getTotal());
}
}

46
das/src/main/java/com/das/modules/auth/service/impl/SysOrgServiceImpl.java Normal file
View File

@ -0,0 +1,46 @@
package com.das.modules.auth.service.impl;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.das.common.utils.SequenceUtils;
import com.das.common.utils.PageDataInfo;
import com.das.common.utils.PageQuery;
import com.das.modules.auth.domain.dto.*;
import com.das.modules.auth.entity.SysOrg;
import com.das.modules.auth.mapper.SysOrgMapper;
import com.das.modules.auth.service.SysOrgService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class SysOrgServiceImpl implements SysOrgService {
@Autowired
SysOrgMapper sysOrgMapper;
@Override
public SysOrg createOrg(SysOrgDto sysOrgDto) {
SysOrg sysOrg = new SysOrg();
BeanUtils.copyProperties(sysOrgDto,sysOrg);
sysOrg.setId(SequenceUtils.generateId());
sysOrgMapper.insert(sysOrg);
return sysOrg;
}
@Override
public int updateOrg(SysOrgDto sysOrgDto) {
SysOrg sysOrg = new SysOrg();
BeanUtils.copyProperties(sysOrgDto,sysOrg);
return sysOrgMapper.updateById(sysOrg);
}
@Override
public int deleteOrg(DeleteDto deleteDto) {
return sysOrgMapper.deleteById(deleteDto.getId());
}
@Override
public PageDataInfo<SysOrg> queryOrgList(SysOrgQueryDto sysOrgQueryDto, PageQuery pageQuery) {
IPage<SysOrg> iPage = sysOrgMapper.queryOrgList(pageQuery.build(), sysOrgQueryDto);
return PageDataInfo.build(iPage.getRecords(), iPage.getTotal());
}
}

46
das/src/main/java/com/das/modules/auth/service/impl/SysUserServiceImpl.java
View File

@ -1,4 +1,48 @@
package com.das.modules.auth.service.impl;
public class SysUserServiceImpl {
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.das.common.utils.SequenceUtils;
import com.das.common.utils.PageDataInfo;
import com.das.common.utils.PageQuery;
import com.das.modules.auth.domain.dto.DeleteDto;
import com.das.modules.auth.domain.dto.SysUserDto;
import com.das.modules.auth.domain.dto.SysUserQueryDto;
import com.das.modules.auth.entity.SysUser;
import com.das.modules.auth.mapper.SysUserMapper;
import com.das.modules.auth.service.SysUserService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class SysUserServiceImpl implements SysUserService {
@Autowired
SysUserMapper sysUserMapper;
@Override
public SysUser createUser(SysUserDto sysUserDto) {
SysUser sysUser = new SysUser();
BeanUtils.copyProperties(sysUserDto,sysUser);
sysUser.setId(SequenceUtils.generateId());
sysUserMapper.insert(sysUser);
return sysUser;
}
@Override
public int updateUser(SysUserDto sysUserDto) {
SysUser sysUser = new SysUser();
BeanUtils.copyProperties(sysUserDto,sysUser);
return sysUserMapper.updateById(sysUser);
}
@Override
public int deleteUser(DeleteDto deleteDto) {
return sysUserMapper.deleteById(deleteDto.getId());
}
@Override
public PageDataInfo<SysUser> queryUserList(SysUserQueryDto sysUserQueryDto, PageQuery pageQuery) {
IPage<SysUser> iPage = sysUserMapper.queryUserList(pageQuery.build(), sysUserQueryDto);
return PageDataInfo.build(iPage.getRecords(), iPage.getTotal());
}
}

33
das/src/main/resources/mapper/SysMenuMapper.xml Normal file
View File

@ -0,0 +1,33 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.das.modules.auth.mapper.SysMenuMapper">
<resultMap type="com.das.modules.auth.entity.SysMenu" id="SysMenuMap">
<result property="id" column="id" jdbcType="BIGINT"/>
<result property="menuName" column="menu_name" jdbcType="VARCHAR"/>
<result property="menuOrder" column="menu_order" jdbcType="VARCHAR"/>
<result property="menuIcon" column="menu_icon" jdbcType="VARCHAR"/>
<result property="funType" column="fun_type" jdbcType="VARCHAR"/>
<result property="funParam" column="fun_param" jdbcType="VARCHAR"/>
<result property="authorityId" column="authority_id" jdbcType="VARCHAR"/>
<result property="parentMenuId" column="parent_menu_id" jdbcType="VARCHAR"/>
<result property="revision" column="revision" jdbcType="VARCHAR"/>
<result property="createdBy" column="created_by" jdbcType="VARCHAR"/>
<result property="createdTime" column="created_time" jdbcType="VARCHAR"/>
<result property="updatedBy" column="updated_by" jdbcType="VARCHAR"/>
<result property="updatedTime" column="updated_time" jdbcType="VARCHAR"/>
</resultMap>
<select id="queryMenuList" resultMap="SysMenuMap">
select * from sys_menu
<where>
<if test="sysMenu.id != null and sysMenu.id != ''">
and id = #{sysMenu.id}
</if>
<if test="sysMenu.parentMenuId != null and sysMenu.parentMenuId != ''">
and parent_menu_id = #{sysMenu.parentMenuId}
</if>
</where>
</select>
</mapper>

44
das/src/main/resources/mapper/SysOrgMapper.xml Normal file
View File

@ -0,0 +1,44 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.das.modules.auth.mapper.SysOrgMapper">
<resultMap type="com.das.modules.auth.entity.SysOrg" id="SysOrgMap">
<result property="id" column="id" jdbcType="BIGINT"/>
<result property="name" column="name" jdbcType="VARCHAR"/>
<result property="mrid" column="mrid" jdbcType="VARCHAR"/>
<result property="province" column="province" jdbcType="VARCHAR"/>
<result property="city" column="city" jdbcType="VARCHAR"/>
<result property="county" column="county" jdbcType="VARCHAR"/>
<result property="address" column="address" jdbcType="VARCHAR"/>
<result property="contactPhone" column="contact_phone" jdbcType="VARCHAR"/>
<result property="remarks" column="remarks" jdbcType="VARCHAR"/>
<result property="parentOrgID" column="parent_org_iD" jdbcType="VARCHAR"/>
<result property="revision" column="revision" jdbcType="VARCHAR"/>
<result property="createdBy" column="created_by" jdbcType="VARCHAR"/>
<result property="createdTime" column="created_time" jdbcType="VARCHAR"/>
<result property="updatedBy" column="updated_by" jdbcType="VARCHAR"/>
<result property="updatedTime" column="updated_time" jdbcType="VARCHAR"/>
</resultMap>
<select id="queryOrgList" resultMap="SysOrgMap">
select * from sys_org
<where>
<if test="sysOrg.name != null and sysOrg.name != ''">
and name like concat('%',#{sysOrg.name},'%')
</if>
<if test="sysOrg.province != null and sysOrg.province != ''">
and province like concat('%',#{sysOrg.province},'%')
</if>
<if test="sysOrg.city != null and sysOrg.city != ''">
and city like concat('%',#{sysOrg.city},'%')
</if>
<if test="sysOrg.county != null and sysOrg.county != ''">
and county like concat('%',#{sysOrg.county},'%')
</if>
<if test="sysOrg.parentOrgID != null and sysOrg.parentOrgID != ''">
and parent_org_iD = #{sysOrg.parentOrgID}
</if>
</where>
</select>
</mapper>

30
das/src/main/resources/mapper/SysUserMapper.xml
View File

@ -2,5 +2,35 @@
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.das.modules.auth.mapper.SysUserMapper">
<resultMap type="com.das.modules.auth.entity.SysUser" id="SysUserMap">
<result property="id" column="id" jdbcType="BIGINT"/>
<result property="account" column="account" jdbcType="VARCHAR"/>
<result property="password" column="password" jdbcType="VARCHAR"/>
<result property="userName" column="user_name" jdbcType="VARCHAR"/>
<result property="email" column="email" jdbcType="VARCHAR"/>
<result property="phone" column="phone" jdbcType="VARCHAR"/>
<result property="orgId" column="org_id" jdbcType="VARCHAR"/>
<result property="lastLogin" column="last_login" jdbcType="VARCHAR"/>
<result property="revision" column="revision" jdbcType="VARCHAR"/>
<result property="createdBy" column="created_by" jdbcType="VARCHAR"/>
<result property="createdTime" column="created_time" jdbcType="VARCHAR"/>
<result property="updatedBy" column="updated_by" jdbcType="VARCHAR"/>
<result property="updatedTime" column="updated_time" jdbcType="VARCHAR"/>
</resultMap>
<select id="queryUserList" resultMap="SysUserMap">
select * from sys_user
<where>
<if test="sysUser.userName != null and sysUser.userName != ''">
and user_name like concat('%',#{sysUser.userName},'%')
</if>
<if test="sysUser.phone != null and sysUser.phone != ''">
and phone like concat('%',#{sysUser.phone},'%')
</if>
<if test="sysUser.orgId != null and sysUser.orgId != ''">
and org_id = #{sysUser.orgId}
</if>
</where>
</select>
</mapper>