Skip to content

B
basic-api-boot
提交 77515b59 作者: 方治民
操作

Merge branch 'dev_tzl' of https://gitlab.yiring.com/chemical-kesai/kshg-api into merge_dev 

 Conflicts:
	app/build.gradle
上级 f490012a c7db2617
正在显示 包含 2893 行增加 和 18 行删除
app/src/main/java/com/yiring/app/domain/car/Car.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.domain.car;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.yiring.common.annotation.Excel;
import java.io.Serializable;
import java.time.LocalDateTime;
import javax.persistence.*;
import lombok.*;
import lombok.experimental.FieldDefaults;
import lombok.experimental.FieldNameConstants;
import org.hibernate.annotaions.Comment;
import org.hibernate.annotations.GenericGenerator;
import org.hibernate.snowflake.SnowflakeId;
/**
* @author tzl
* 2022/4/11 13:38
*/
@Getter
@Setter
@ToString
@Builder
@NoArgsConstructor
@AllArgsConstructor
@FieldNameConstants
@FieldDefaults(level = AccessLevel.PRIVATE)
@Entity
@Table(name = "BS_CAR")
@Comment("车辆")
public class Car implements Serializable {
@Id
@Comment("主键id")
@GeneratedValue(generator = SnowflakeId.GENERATOR)
@GenericGenerator(name = SnowflakeId.GENERATOR, strategy = SnowflakeId.Strategy.LONG)
Long id;
@Comment("车牌号")
@Excel(name = "车牌", sort = 1)
String carNum;
@Comment("车辆类型")
@Excel(name = "车辆类型", sort = 2, dictType = "car_type")
String carType;
@Comment("司机名称")
@Excel(name = "司机", sort = 3)
String driverName;
@Comment("司机电话")
@Excel(name = "联系电话", sort = 4)
String driverMobile;
@Comment("标签卡")
@Excel(name = "标签卡", sort = 9)
String labelCard;
@Comment("标签卡状态")
@Excel(name = "标签卡状态", sort = 10, dictType = "car_label_status")
String labelCardStatus;
@Comment("所属单位id")
@Excel(name = "所属单位", sort = 5)
String orgId;
@Comment("被访人id")
@Excel(name = "被访人", sort = 7)
String intervieweeId;
@Comment("来访原因")
@Excel(name = "来访原因", sort = 6)
String reason;
@Comment("收卡时间")
@Excel(name = "收卡时间", sort = 11, dateFormat = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
LocalDateTime cardRecTime;
@Comment("创建时间")
@Excel(name = "到访时间", sort = 8, dateFormat = "yyyy-MM-dd HH:mm:ss")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
LocalDateTime createTime;
@Comment("发卡时间")
LocalDateTime cardSendTime;
@Comment("备用字段")
String reserve4;
}
app/src/main/java/com/yiring/app/domain/car/CarRepository.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.domain.car;
import java.io.Serializable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.stereotype.Repository;
/**
* @author tzl
* 2022/4/11 13:42
*/
@Repository
public interface CarRepository extends JpaRepository<Car, Serializable>, JpaSpecificationExecutor<Car> {
// /**
// * 检查是否存在相同车牌号登记
// *
// * @param param String 车牌号码
// * @return 是否存在
// */
// @Query("SELECT COUNT(c.id) FROM bs_car c where car_num=?1 and label_card_status <>'已收卡'")
// boolean hasCarInfoByCarNum(String param);
//
// /**
// * 检查是否存在相同手机号码登记
// *
// * @param param String 手机号码
// * @return 是否存在
// */
// @Query("SELECT COUNT(c.id) FROM bs_car c where driver_mobile=?1 and label_card_status <>'已收卡'")
// boolean hasCarInfoByMobile(String param);
}
app/src/main/java/com/yiring/app/domain/video/Video.java
......@@ -46,27 +46,33 @@ public class Video implements Serializable {
@Comment("坐标点信息")
Point point;
@Comment("分类")
String type;
@Comment("标识")
String uuid;
/**
* rtsp 地址
*/
@Comment("rtsp 媒体地址")
String rtsp;
@Comment("m3u8 地址")
String m3u8;
@Comment("备注")
String remark;
@Comment("创建时间")
LocalDateTime createTime;
@Comment("状态")
String status;
@Comment("摄像头名称")
String videoName;
@Comment("分类")
String type;
@Comment("rtsp 媒体地址")
String rtsp;
@Comment("是否在线")
Boolean online;
@Comment("是否启用")
Boolean enable;
@Comment("创建时间")
LocalDateTime createTime;
}
app/src/main/java/com/yiring/app/domain/video/VideoRepository.java
......@@ -3,6 +3,7 @@ package com.yiring.app.domain.video;
import java.io.Serializable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.stereotype.Repository;
/**
......@@ -12,4 +13,4 @@ import org.springframework.stereotype.Repository;
*/
@Repository
public interface VideoRepository extends JpaRepository<Video, Serializable> {}
public interface VideoRepository extends JpaRepository<Video, Serializable>, JpaSpecificationExecutor<Video> {}
app/src/main/java/com/yiring/app/param/car/CarParam.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.param.car;
import com.yiring.common.constant.RegEx;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.Pattern;
import javax.validation.constraints.Size;
import lombok.*;
import lombok.experimental.FieldDefaults;
/**
* @author tzl
* 2022/4/11 14:00
*/
@ApiModel("CarParam")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@FieldDefaults(level = AccessLevel.PRIVATE)
public class CarParam {
@ApiModelProperty(value = "车牌号码", example = "湘A99999", required = true)
@NotEmpty(message = "车牌号码不能为空")
@Pattern(regexp = RegEx.CARNUM, message = "车牌号码格式不正确")
String carNum;
@ApiModelProperty(value = "车辆类型", example = "1")
String carType;
@ApiModelProperty(value = "司机名称", example = "张三", required = true)
@NotEmpty(message = "司机名称不能为空")
String driverName;
@ApiModelProperty(value = "司机电话", example = "17688888888", required = true)
@NotEmpty(message = "司机电话不能为空")
@Pattern(regexp = RegEx.MOBILE, message = "手机号码格式不正确")
String driverMobile;
// @ApiModelProperty(value = "标签卡", example = "DW24515512")
// String labelCard;
//
// @ApiModelProperty(value = "标签卡状态", example = "使用中")
// String labelCardStatus;
@ApiModelProperty(value = "所属单位id", example = "1", required = true)
@NotEmpty(message = "所属单位id不能为空")
String orgId;
@ApiModelProperty(value = "被访人id", example = "1", required = true)
@NotEmpty(message = "被访人id不能为空")
String intervieweeId;
@ApiModelProperty(value = "来访原因", example = "视察", required = true)
@NotEmpty(message = "来访原因不能为空")
@Size(min = 1, max = 20, message = "来访原因超出范围")
String reason;
// @ApiModelProperty(value = "收卡时间", example = "2022-04-11 17:25:33")
// LocalDateTime cardRecTime;
//
// @ApiModelProperty(value = "发卡时间", example = "2022-04-11 17:25:33")
// LocalDateTime cardSendTime;
// @ApiModelProperty(value = "创建时间", example = "")
// LocalDateTime createTime;
}
app/src/main/java/com/yiring/app/param/car/CarQueryParam.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.param.car;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.time.LocalDateTime;
import lombok.*;
import lombok.experimental.FieldDefaults;
/**
* @author tzl
* 2022/4/12 11:11
*/
@ApiModel("CarQueryParam")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@FieldDefaults(level = AccessLevel.PRIVATE)
public class CarQueryParam {
@ApiModelProperty(value = "每页记录数", example = "10")
// @DecimalMin(value = "1", message = "分页条数不能小于1")
Integer pageSize;
@ApiModelProperty(value = "页码", example = "1")
// @DecimalMin(value = "1", message = "页码不能小于1")
Integer pageNo;
@ApiModelProperty(value = "车牌号码", example = "湘A12345")
String carNum;
@ApiModelProperty(value = "车辆类型", example = "轿车")
String carType;
@ApiModelProperty(value = "司机名称", example = "张三")
String driverName;
@ApiModelProperty(value = "司机电话", example = "17688888888")
String driverMobile;
@ApiModelProperty(value = "标签卡", example = "DW24515512")
String labelCard;
@ApiModelProperty(value = "标签卡状态", example = "2")
String labelCardStatus;
@ApiModelProperty(value = "所属单位id", example = "1")
String orgId;
@ApiModelProperty(value = "被访人id", example = "1")
String intervieweeId;
@ApiModelProperty(value = "来访原因", example = "视察")
String reason;
@ApiModelProperty(value = "收卡时间(开始)", example = "2022-04-11 17:25:33")
LocalDateTime cardRecTimeStart;
@ApiModelProperty(value = "收卡时间(结束)", example = "2022-04-11 17:26:33")
LocalDateTime cardRecTimeEnd;
@ApiModelProperty(value = "来访时间(开始)", example = "2022-04-11 17:25:33")
LocalDateTime createTimeStart;
@ApiModelProperty(value = "来访时间(结束)", example = "2022-04-11 17:26:33")
LocalDateTime createTimeEnd;
}
app/src/main/java/com/yiring/app/param/dict/DictParam.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.param.dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import javax.validation.constraints.NotEmpty;
import lombok.*;
import lombok.experimental.FieldDefaults;
/**
* @author tzl
* 2022/4/13 15:51
*/
@ApiModel("DictParam")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@FieldDefaults(level = AccessLevel.PRIVATE)
public class DictParam {
@ApiModelProperty(value = "排序", example = "1", required = true)
Integer dictSort;
@ApiModelProperty(value = "字典标签", example = "男", required = true)
@NotEmpty(message = "字典标签不能为空")
String dictLabel;
@ApiModelProperty(value = "字典值", example = "1", required = true)
@NotEmpty(message = "字典值不能为空")
String dictValue;
@ApiModelProperty(value = "字典类型", example = "user_sex", required = true)
@NotEmpty(message = "字典类型不能为空")
String dictType;
@ApiModelProperty(value = "是否启用", example = "1", required = true)
@NotEmpty(message = "是否启用必填")
String status;
@ApiModelProperty(value = "备注", example = "性别")
String remark;
}
app/src/main/java/com/yiring/app/param/dict/DictQueryParam.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.param.dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;
import lombok.experimental.FieldDefaults;
/**
* @author tzl
* 2022/4/13 16:06
*/
@ApiModel("DictQueryParam")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@FieldDefaults(level = AccessLevel.PRIVATE)
public class DictQueryParam {
@ApiModelProperty(value = "字典标签", example = "男")
String dictLabel;
@ApiModelProperty(value = "字典类型", example = "user_sex")
String dictType;
}
app/src/main/java/com/yiring/app/param/dict/DictTypeParam.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.param.dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import javax.validation.constraints.NotEmpty;
import lombok.*;
import lombok.experimental.FieldDefaults;
/**
* @author tzl
* 2022/4/13 15:51
*/
@ApiModel("DictParam")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@FieldDefaults(level = AccessLevel.PRIVATE)
public class DictTypeParam {
@ApiModelProperty(value = "字典名称", example = "性别", required = true)
@NotEmpty(message = "字典名称不能为空")
String dictName;
@ApiModelProperty(value = "字典类型", example = "user_sex", required = true)
@NotEmpty(message = "字典类型不能为空")
String dictType;
@ApiModelProperty(value = "是否启用", example = "1", required = true)
@NotEmpty(message = "是否启用必填")
String status;
}
app/src/main/java/com/yiring/app/param/dict/DictTypeQueryParam.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.param.dict;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;
import lombok.experimental.FieldDefaults;
/**
* @author tzl
* 2022/4/13 16:06
*/
@ApiModel("DictQueryParam")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@FieldDefaults(level = AccessLevel.PRIVATE)
public class DictTypeQueryParam {
@ApiModelProperty(value = "字典名称", example = "性别")
String dictName;
}
app/src/main/java/com/yiring/app/param/video/VideoParam.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.param.video;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.Size;
import lombok.*;
import lombok.experimental.FieldDefaults;
/**
* 监控视频入参类
*
* @author tzl
* 2022/4/8 16:07
*/
@ApiModel("VideoParam")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@FieldDefaults(level = AccessLevel.PRIVATE)
public class VideoParam implements Serializable {
@ApiModelProperty(value = "编号", example = "88888888", required = true)
@NotEmpty(message = "标识不能为空")
String uuid;
@ApiModelProperty(value = "m3u8 媒体地址", example = "", required = true)
@NotEmpty(message = "m3u8 媒体地址不能为空")
String m3u8;
@ApiModelProperty(value = "摄像头名称", example = "摄像头1", required = true)
@NotEmpty(message = "摄像头名称不能为空")
String videoName;
@ApiModelProperty(value = "经度", example = "1", required = true)
@NotEmpty(message = "经度")
double lon;
@ApiModelProperty(value = "纬度", example = "1", required = true)
@NotEmpty(message = "纬度")
double lat;
@ApiModelProperty(value = "备注", example = "厂区摄像头")
@Size(max = 100, message = "备注不能超过100字")
String remark;
// @ApiModelProperty(value = "m3u8 地址", example = "")
// @NotEmpty(message = "m3u8 地址不能为空")
// String m3u8;
// Point point;
// @ApiModelProperty(value = "分类", example = "")
// String type;
// @ApiModelProperty(value = "是否在线", example = "")
// Boolean online;
// @ApiModelProperty(value = "是否启用", example = "")
// Boolean enable;
}
app/src/main/java/com/yiring/app/param/video/VideoQueryParam.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.param.video;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
import lombok.*;
import lombok.experimental.FieldDefaults;
/**
* 监控视频入参类
*
* @author tzl
* 2022/4/8 16:07
*/
@ApiModel("VideoQueryParam")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@FieldDefaults(level = AccessLevel.PRIVATE)
public class VideoQueryParam implements Serializable {
@ApiModelProperty(value = "编号", example = "88888888")
String uuid;
@ApiModelProperty(value = "摄像头名称", example = "摄像头1")
String videoName;
@ApiModelProperty(value = "状态", example = "1")
String status;
// @ApiModelProperty(value = "m3u8 地址", example = "")
// @NotEmpty(message = "m3u8 地址不能为空")
// String m3u8;
// Point point;
// @ApiModelProperty(value = "分类", example = "")
// String type;
// @ApiModelProperty(value = "是否在线", example = "")
// Boolean online;
// @ApiModelProperty(value = "是否启用", example = "")
// Boolean enable;
}
app/src/main/java/com/yiring/app/service/car/CarService.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.service.car;
import com.yiring.app.domain.car.Car;
import com.yiring.app.param.car.CarParam;
import com.yiring.app.param.car.CarQueryParam;
import com.yiring.app.vo.car.CarVo;
import com.yiring.common.core.Result;
import com.yiring.common.param.IdParam;
import com.yiring.common.vo.PageVo;
import java.util.List;
import org.springframework.data.jpa.domain.Specification;
/**
* @author tzl
* 2022/4/11 13:57
*/
public interface CarService {
/**
* 添加车辆来访信息
*
* @param carParam CarParam
* @return 车辆来访信息id
*/
Result<Long> saveCarInfo(CarParam carParam);
/**
* 修改车辆来访信息
*
* @param carParam CarParam
* @return 修改的车辆来访信息id
*/
Result<Long> updateCarInfo(CarParam carParam, IdParam idParam);
/**
* 收卡
*
* @param idParam IdParam
* @return 收卡信息id
*/
Result<Long> cardRec(IdParam idParam);
/**
* 发卡
*
* @param idParam IdParam
* @return 发卡信息id
*/
Result<Long> cardSend(IdParam idParam, String labelCard);
/**
* 删除车辆来访信息
*
* @param idParam IdParam
* @return String
*/
Result<String> deleteCarInfo(IdParam idParam);
/**
* 查询车辆来访信息详情
*
* @param idParam IdParam
* @return 车辆来访信息
*/
Result<CarVo> getCarInfo(IdParam idParam);
/**
* 查询车辆来访信息(分页)
*
* @param carParam CarParam
* @return 车辆来访信息分页数据
*/
Result<PageVo<CarVo>> pageCarInfo(CarQueryParam carParam);
/**
* 导出excel
*/
List<Car> export(CarQueryParam carParam);
/**
* 检查是否存在相同车牌号登记
*
* @param param String 车牌号码
* @return 是否存在
*/
boolean hasCarInfoByCarNum(String param);
/**
* 检查是否存在相同手机号码登记
*
* @param param String 手机号码
* @return 是否存在
*/
boolean hasCarInfoByMobile(String param);
/**
* @param carParam CarQueryParam
* @return Specification
*/
Specification<Car> condition(CarQueryParam carParam);
}
app/src/main/java/com/yiring/app/service/dict/DictService.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.service.dict;
import com.yiring.app.param.dict.DictParam;
import com.yiring.app.param.dict.DictQueryParam;
import com.yiring.common.core.Result;
import com.yiring.common.dict.Dict;
import com.yiring.common.param.IdParam;
import com.yiring.common.param.PageParam;
import com.yiring.common.vo.PageVo;
import java.util.ArrayList;
/**
* 字典
*
* @author tzl
* 2022/4/13 15:36
*/
public interface DictService {
/**
* 根据条件分页查询字典数据
*
* @param dictQueryParam DictQueryParam
* @return 字典数据集合信息
*/
Result<PageVo<Dict>> pageDictInfo(DictQueryParam dictQueryParam, PageParam param);
/**
* 根据字典类型和字典键值查询字典数据信息
*
* @param dictType String
* @param dictValue String
* @return 字典标签
*/
Result<String> selectDictLabel(String dictType, String dictValue);
/**
* 从缓存中获取字典
*
* @param dictType 字典类型
* @return 字典数据集合
*/
Result<ArrayList<Dict>> selectDict(String dictType);
/**
* 根据字典数据ID查询信息
*
* @param id Long
* @return 字典数据
*/
Result<Dict> getDictInfo(Long id);
/**
* 删除字典数据信息
*
* @param idParam 主键id
*/
Result<String> deleteDictById(IdParam idParam);
/**
* 新增字典数据信息
*
* @param dictParam 字典数据信息入参
* @return 结果
*/
Result<String> saveDictInfo(DictParam dictParam);
/**
* 修改字典数据信息
*
* @param idParam 主键id
* @param dictParam 字典数据信息入参
* @return 结果
*/
Result<String> updateDictInfo(DictParam dictParam, IdParam idParam);
/**
* 是否已有该字典标签
*
* @param param String
* @return 是否存在
*/
boolean has(String param);
/**
* 是否该类型字典已有该字典值
*
* @param dictType String
* @param dictValue String
* @return 是否存在
*/
boolean hasValue(String dictType, String dictValue);
/**
* 加载字典缓存
*/
void loadingDictCache();
}
app/src/main/java/com/yiring/app/service/dict/DictTypeService.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.service.dict;
/**
* @author tzl
* 2022/4/14 14:10
*/
public interface DictTypeService {
// /**
// * 根据条件分页查询字典类型
// *
// * @param dictTypeQueryParam DictTypeQueryParam
// * @return 字典类型分页信息
// */
// Result<PageVo<DictType>> pageDictTypeInfo(DictTypeQueryParam dictTypeQueryParam, PageParam param);
//
// Result<DictType> getDictTypeInfo(Long id);
//
// Result<String> delecteById(Long id);
//
// Result<String> saveDictTypeInfo(DictTypeParam dictTypeParam);
//
// Result<String> updateDictTypeInfo(DictTypeParam dictTypeParam, IdParam idParam);
//
// boolean has(String param);
}
app/src/main/java/com/yiring/app/service/dict/impl/DictServiceImpl.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.service.dict.impl;
import com.yiring.app.param.dict.DictParam;
import com.yiring.app.param.dict.DictQueryParam;
import com.yiring.app.service.dict.DictService;
import com.yiring.common.core.Result;
import com.yiring.common.core.Status;
import com.yiring.common.dict.Dict;
import com.yiring.common.dict.DictRepository;
import com.yiring.common.param.IdParam;
import com.yiring.common.param.PageParam;
import com.yiring.common.util.DictUtils;
import com.yiring.common.util.StrUtils;
import com.yiring.common.vo.PageVo;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import javax.persistence.criteria.Predicate;
import org.springframework.beans.BeanUtils;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.Page;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
/**
* 字典
*
* @author tzl
* 2022/4/13 15:37
*/
@Service
public class DictServiceImpl implements DictService {
@Resource
DictRepository dictRepository;
/**
* 项目启动时，初始化字典到缓存
*/
@PostConstruct
public void init() {
loadingDictCache();
}
/**
* 加载字典缓存数据
*/
@Override
public void loadingDictCache() {
Dict dict = Dict.builder().status("1").build();
Map<String, List<Dict>> dictDataMap = dictRepository
.findAll(Example.of(dict))
.stream()
.collect(Collectors.groupingBy(Dict::getDictType));
for (Map.Entry<String, List<Dict>> entry : dictDataMap.entrySet()) {
DictUtils.setDictCache(
entry.getKey(),
entry.getValue().stream().sorted(Comparator.comparing(Dict::getDictSort)).collect(Collectors.toList())
);
}
}
@Override
public Result<PageVo<Dict>> pageDictInfo(DictQueryParam dictQueryParam, PageParam param) {
Page<Dict> all = dictRepository.findAll(condition(dictQueryParam), PageParam.toPageable(param));
List<Dict> data = all
.get()
.map(car -> {
Dict vo = new Dict();
BeanUtils.copyProperties(car, vo);
return vo;
})
.collect(Collectors.toList());
PageVo<Dict> vo = PageVo.build(data, all.getTotalElements());
return Result.ok(vo);
}
@Override
public Result<String> selectDictLabel(String dictType, String dictValue) {
return Result.ok(dictRepository.findDictLabel(dictType, dictValue));
}
@Override
public Result<ArrayList<Dict>> selectDict(String dictType) {
List<Dict> dictCache1 = DictUtils.getDictCache(dictType);
ArrayList<Dict> dictCache = new ArrayList<>();
if (dictCache1 != null) {
dictCache = new ArrayList<>(dictCache1);
}
return Result.ok(dictCache);
}
@Override
public Result<Dict> getDictInfo(Long dictCode) {
return Result.ok(dictRepository.getById(dictCode));
}
@Override
public Result<String> deleteDictById(IdParam idParam) {
Optional<Dict> optional = dictRepository.findById(idParam.getId());
if (optional.isEmpty()) {
return Result.no(Status.NOT_FOUND);
}
Dict entity = optional.get();
dictRepository.delete(entity);
//刷新缓存
List<Dict> byDictType = dictRepository.findByDictType(entity.getDictType());
DictUtils.setDictCache(entity.getDictType(), byDictType);
return Result.ok();
}
@Override
public Result<String> saveDictInfo(DictParam dictParam) {
if (has(dictParam.getDictLabel())) {
return Result.no(Status.BAD_REQUEST, "标签已存在");
}
if (hasValue(dictParam.getDictType(), dictParam.getDictValue())) {
return Result.no(Status.BAD_REQUEST, "该类型,字典值已存在");
}
Dict dict = new Dict();
dict.setCreateTime(LocalDateTime.now());
BeanUtils.copyProperties(dictParam, dict);
dictRepository.saveAndFlush(dict);
//刷新缓存
List<Dict> byDictType = dictRepository.findByDictType(dict.getDictType());
DictUtils.setDictCache(dict.getDictType(), byDictType);
return Result.ok();
}
@Override
public Result<String> updateDictInfo(DictParam dictParam, IdParam idParam) {
Optional<Dict> optional = dictRepository.findById(idParam.getId());
if (optional.isEmpty()) {
return Result.no(Status.NOT_FOUND);
}
Dict entity = optional.get();
if (!entity.getDictLabel().equals(dictParam.getDictLabel())) {
if (has(dictParam.getDictLabel())) {
//当修改了字典标签时
return Result.no(Status.BAD_REQUEST, "标签已存在");
}
}
if (
!entity.getDictValue().equals(dictParam.getDictValue()) ||
!entity.getDictType().equals(dictParam.getDictType())
) {
//当修改了字典类型或字典值时
if (hasValue(dictParam.getDictType(), dictParam.getDictValue())) {
return Result.no(Status.BAD_REQUEST, "该类型,字典值已存在");
}
}
BeanUtils.copyProperties(dictParam, entity);
Dict dict = dictRepository.saveAndFlush(entity);
List<Dict> byDictType = dictRepository.findByDictType(dict.getDictType());
DictUtils.setDictCache(dict.getDictType(), byDictType);
return Result.ok();
}
public Specification<Dict> condition(DictQueryParam dictQueryParam) {
return (root, query, criteriaBuilder) -> {
List<Predicate> list = new ArrayList<>();
if (StrUtils.isNotBlank(dictQueryParam.getDictType())) {
list.add(
criteriaBuilder.like(
root.get("dictType").as(String.class),
"%" + dictQueryParam.getDictType() + "%"
)
);
}
if (StrUtils.isNotBlank(dictQueryParam.getDictLabel())) {
list.add(
criteriaBuilder.like(
root.get("dictLabel").as(String.class),
"%" + dictQueryParam.getDictLabel() + "%"
)
);
}
Predicate[] predicates = new Predicate[list.size()];
query.where(list.toArray(predicates));
return criteriaBuilder.and(list.toArray(predicates));
};
}
@Override
public boolean has(String param) {
Dict entity = Dict.builder().dictLabel(param).build();
long count = dictRepository.count(Example.of(entity));
return count > 0;
}
@Override
public boolean hasValue(String dictType, String dictValue) {
Dict entity = Dict.builder().dictType(dictType).dictValue(dictValue).build();
long count = dictRepository.count(Example.of(entity));
return count > 0;
}
}
app/src/main/java/com/yiring/app/service/dict/impl/DictTypeServiceImpl.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.service.dict.impl;
import com.yiring.app.service.dict.DictTypeService;
import java.util.*;
import org.springframework.stereotype.Service;
/**
* 字典类型
*
* @author tzl
* 2022/4/14 14:23
*/
@Service
public class DictTypeServiceImpl implements DictTypeService {
//
// @Resource
// DictTypeRepository dictTypeRepository;
//
// @Resource
// DictRepository dictRepository;
//
// @Override
// public Result<PageVo<DictType>> pageDictTypeInfo(DictTypeQueryParam dictTypeQueryParam, PageParam param) {
// Page<DictType> all = dictTypeRepository.findAll(condition(dictTypeQueryParam), PageParam.toPageable(param));
// List<DictType> data = all
// .get()
// .map(car -> {
// DictType vo = new DictType();
// BeanUtils.copyProperties(car, vo);
// return vo;
// })
// .collect(Collectors.toList());
// PageVo<DictType> vo = PageVo.build(data, all.getTotalElements());
// return Result.ok(vo);
// }
//
// @Override
// public Result<DictType> getDictTypeInfo(Long id) {
// return Result.ok(dictTypeRepository.getById(id));
// }
//
// @Override
// public Result<String> delecteById(Long id) {
// Optional<DictType> optional = dictTypeRepository.findById(id);
// if (optional.isEmpty()) {
// return Result.no(Status.NOT_FOUND);
// }
// DictType entity = optional.get();
// List<Dict> byDictType1 = dictRepository.findByDictType(entity.getDictType());
// if (byDictType1.size() > 0) {
// return Result.no(Status.BAD_REQUEST, "该类型下有字典数据,无法删除");
// }
//
// dictTypeRepository.delete(entity);
// //移除该类型缓存
// DictUtils.removeDictCache(entity.getDictType());
// return Result.ok();
// }
//
// @Override
// public Result<String> saveDictTypeInfo(DictTypeParam dictTypeParam) {
// if (has(dictTypeParam.getDictType())) {
// return Result.no(Status.BAD_REQUEST, "字典类型已存在");
// }
// DictType dictType = DictType.builder().createTime(LocalDateTime.now()).build();
// BeanUtils.copyProperties(dictTypeParam, dictType);
// dictTypeRepository.saveAndFlush(dictType);
// //添加空缓存
// DictUtils.setDictCache(dictType.getDictType(), null);
// return Result.ok();
// }
//
// @Override
// public Result<String> updateDictTypeInfo(DictTypeParam dictTypeParam, IdParam idParam) {
// Optional<DictType> optional = dictTypeRepository.findById(idParam.getId());
// if (optional.isEmpty()) {
// return Result.no(Status.NOT_FOUND);
// }
// DictType dictType = optional.get();
// if (!dictType.getDictType().equals(dictTypeParam.getDictType())) {
// //在修改字典类型时
// if (has(dictTypeParam.getDictType())) {
// return Result.no(Status.BAD_REQUEST, "字典类型已存在");
// }
// //将该字典类型下的字典数据一并修改
// dictRepository.updateDictType(dictTypeParam.getDictType(), dictType.getDictType());
// //移除之前的缓存
// DictUtils.removeDictCache(dictType.getDictType());
// }
// BeanUtils.copyProperties(dictTypeParam, dictType);
// dictTypeRepository.saveAndFlush(dictType);
// //查询该字典类型下的字典值数据
// List<Dict> byDictType = dictRepository.findByDictType(dictType.getDictType());
// //添加新缓存
// DictUtils.setDictCache(dictType.getDictType(), byDictType);
// return Result.ok();
// }
//
// @Override
// public boolean has(String param) {
// DictType dictType = DictType.builder().dictType(param).build();
// return dictTypeRepository.count(Example.of(dictType)) > 0;
// }
//
// public Specification<DictType> condition(DictTypeQueryParam dictTypeQueryParam) {
// return (root, query, criteriaBuilder) -> {
// List<Predicate> list = new ArrayList<>();
// if (StrUtils.isNotBlank(dictTypeQueryParam.getDictName())) {
// list.add(
// criteriaBuilder.like(
// root.get("dictType").as(String.class),
// "%" + dictTypeQueryParam.getDictName() + "%"
// )
// );
// }
// Predicate[] predicates = new Predicate[list.size()];
// query.where(list.toArray(predicates));
// return criteriaBuilder.and(list.toArray(predicates));
// };
// }
}
app/src/main/java/com/yiring/app/service/video/VideoService.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.service.video;
import com.yiring.app.param.video.VideoParam;
import com.yiring.app.param.video.VideoQueryParam;
import com.yiring.app.vo.video.VideoVo;
import com.yiring.common.core.Result;
import com.yiring.common.param.IdParam;
import com.yiring.common.param.PageParam;
import com.yiring.common.vo.PageVo;
import java.awt.*;
import org.locationtech.jts.geom.Point;
/**
* @author tzl
* 2022/4/8 15:28
*/
public interface VideoService {
/**
* 监控视频点位添加
*
* @param videoParam VideoParam
* @return Result<String>
* @author tzl
* @date 2022/4/8 16:23
*/
Result<String> saveVideo(VideoParam videoParam);
/**
* 删除监控点位信息
* @param idParam 主键id
* @return Result<String>
* @author tzl
* @date 2022/4/15 10:16
*/
Result<String> deleteVideo(IdParam idParam);
/**
* 修改监控点位信息
* @param videoParam 修改的参数
* @param idParam 主键id
* @return Result<String>
* @author tzl
* @date 2022/4/15 10:19
*/
Result<String> updateVideo(VideoParam videoParam, IdParam idParam);
/**
* 查询监控点坐标
* @param idParam 主键id
* @return Result<Point> 坐标信息
* @author tzl
* @date 2022/4/15 14:15
*/
Result<Point> selectPoint(IdParam idParam);
/**
* 分页查询
* @param videoQueryParam 筛选条件
* @param param 分页参数
* @return Result<PageVo<VideoVo>> 分页结果集
* @author tzl
* @date 2022/4/15 14:35
*/
Result<PageVo<VideoVo>> pageVideo(VideoQueryParam videoQueryParam, PageParam param);
}
app/src/main/java/com/yiring/app/service/video/impl/VideoServiceImpl.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.service.video.impl;
import com.yiring.app.domain.video.Video;
import com.yiring.app.domain.video.VideoRepository;
import com.yiring.app.param.video.VideoParam;
import com.yiring.app.param.video.VideoQueryParam;
import com.yiring.app.service.video.VideoService;
import com.yiring.app.util.GeoUtils;
import com.yiring.app.vo.video.VideoVo;
import com.yiring.common.core.Result;
import com.yiring.common.core.Status;
import com.yiring.common.param.IdParam;
import com.yiring.common.param.PageParam;
import com.yiring.common.util.StrUtils;
import com.yiring.common.vo.PageVo;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import javax.persistence.criteria.Predicate;
import org.locationtech.jts.geom.Point;
import org.springframework.beans.BeanUtils;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.Page;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
/**
* @author tzl
* 2022/4/8 15:28
*/
@Service
public class VideoServiceImpl implements VideoService {
@Resource
VideoRepository videoRepository;
@Override
public Result<String> saveVideo(VideoParam videoParam) {
if (has(videoParam.getUuid())) {
return Result.no(Status.BAD_REQUEST, "您输入的编号已存在");
}
Video video = Video
.builder()
.createTime(LocalDateTime.now())
// .enable(videoParam.getEnable())
// .m3u8(videoParam.getM3u8())
// .point(videoParam.getPoint())
.m3u8(videoParam.getM3u8())
.point(GeoUtils.createPoint(videoParam.getLon(), videoParam.getLat()))
// .online(videoParam.getOnline())
// .type(videoParam.getType())
//默认正常
.videoName(videoParam.getVideoName())
.status("1")
.remark(videoParam.getRemark())
.uuid(videoParam.getUuid())
.build();
videoRepository.saveAndFlush(video);
//还需要同步添加国标28181中对应的摄像头信息
//标识uuid对应流id,m3u8对应拉流地址,如m3u8中有标注 则将类型切换为FFmpeg,摄像头名称videoName对应名称,流名称默认"stream",超时时间默认60
return Result.ok();
}
@Override
public Result<String> deleteVideo(IdParam idParam) {
Optional<Video> optional = videoRepository.findById(idParam.getId());
if (optional.isEmpty()) {
return Result.no(Status.NOT_FOUND);
}
Video video = optional.get();
videoRepository.delete(video);
//还需要同步删除国标28181中对应的摄像头信息
return Result.ok();
}
@Override
public Result<String> updateVideo(VideoParam videoParam, IdParam idParam) {
Optional<Video> optional = videoRepository.findById(idParam.getId());
if (optional.isEmpty()) {
return Result.no(Status.NOT_FOUND);
}
Video video = optional.get();
if (!video.getUuid().equals(videoParam.getUuid())) {
//当修改编号时
if (has(videoParam.getUuid())) {
return Result.no(Status.BAD_REQUEST, "您输入的编号已存在");
}
}
BeanUtils.copyProperties(videoParam, video);
videoRepository.saveAndFlush(video);
//还需要同步修改国标28181中对应的摄像头信息
return Result.ok();
}
@Override
public Result<Point> selectPoint(IdParam idParam) {
Optional<Video> optional = videoRepository.findById(idParam.getId());
if (optional.isEmpty()) {
return Result.no(Status.NOT_FOUND);
}
Video video = optional.get();
return Result.ok(video.getPoint());
}
@Override
public Result<PageVo<VideoVo>> pageVideo(VideoQueryParam videoQueryParam, PageParam param) {
Page<Video> all = videoRepository.findAll(condition(videoQueryParam), PageParam.toPageable(param));
List<VideoVo> data = all
.get()
.map(video -> {
VideoVo vo = new VideoVo();
BeanUtils.copyProperties(video, vo);
return vo;
})
.collect(Collectors.toList());
PageVo<VideoVo> vo = PageVo.build(data, all.getTotalElements());
return Result.ok(vo);
}
/**
* 条件查询
* @param videoQueryParam 筛选条件
* @return Specification
*/
public Specification<Video> condition(VideoQueryParam videoQueryParam) {
return (root, query, criteriaBuilder) -> {
List<Predicate> list = new ArrayList<>();
if (StrUtils.isNotBlank(videoQueryParam.getVideoName())) {
list.add(
criteriaBuilder.like(
root.get("videoName").as(String.class),
"%" + videoQueryParam.getVideoName() + "%"
)
);
}
if (StrUtils.isNotBlank(videoQueryParam.getUuid())) {
list.add(
criteriaBuilder.like(root.get("uuid").as(String.class), "%" + videoQueryParam.getUuid() + "%")
);
}
if (StrUtils.isNotBlank(videoQueryParam.getStatus())) {
list.add(criteriaBuilder.equal(root.get("uuid").as(String.class), videoQueryParam.getStatus()));
}
Predicate[] predicates = new Predicate[list.size()];
query.where(list.toArray(predicates));
return criteriaBuilder.and(list.toArray(predicates));
};
}
boolean has(String uuid) {
Video video = Video.builder().uuid(uuid).build();
return videoRepository.count(Example.of(video)) > 0;
}
}
app/src/main/java/com/yiring/app/vo/car/CarVo.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.vo.car;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.yiring.common.util.DictUtils;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
import java.time.LocalDateTime;
import lombok.*;
import lombok.experimental.FieldDefaults;
import org.apache.commons.lang3.StringUtils;
/**
* @author tzl
* 2022/4/11 14:52
*/
@ApiModel("CarVo")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@FieldDefaults(level = AccessLevel.PRIVATE)
public class CarVo implements Serializable {
@JsonSerialize(using = ToStringSerializer.class)
@ApiModelProperty(value = "主键id", example = "1458555485552")
Long id;
@ApiModelProperty(value = "车牌号码", example = "湘A99999")
String carNum;
@ApiModelProperty(value = "车辆类型", example = "1")
String carType;
/**
* 车辆类型翻译
*/
@ApiModelProperty(value = "车辆类型(字典翻译)", example = "货车")
String carTypeName;
public String getCarTypeName() {
if (StringUtils.isNotBlank(carType)) {
return DictUtils.getDictLabel("car_type", carType);
}
return null;
}
@ApiModelProperty(value = "司机名称", example = "张三")
String driverName;
@ApiModelProperty(value = "司机电话", example = "17688888888")
String driverMobile;
@ApiModelProperty(value = "标签卡", example = "DT8875666")
String labelCard;
@ApiModelProperty(value = "标签卡状态", example = "1")
String labelCardStatus;
/**
* 车辆类型翻译
*/
@ApiModelProperty(value = "标签卡状态", example = "未发卡")
String labelCardStatusName;
public String getLabelCardStatusName() {
if (StringUtils.isNotBlank(carType)) {
return DictUtils.getDictLabel("car_label_status", labelCardStatus);
}
return null;
}
@ApiModelProperty(value = "单位id", example = "湖南壹润科技")
String orgId;
@ApiModelProperty(value = "被访人id", example = "1")
String intervieweeId;
@ApiModelProperty(value = "来访原因", example = "装货")
String reason;
@ApiModelProperty(value = "收卡时间", example = "2022-04-11 17:25:33")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
LocalDateTime cardRecTime;
@ApiModelProperty(value = "创建时间", example = "2022-04-11 17:25:33")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
LocalDateTime createTime;
@ApiModelProperty(value = "发卡时间", example = "2022-04-11 17:25:33")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
LocalDateTime cardSendTime;
}
app/src/main/java/com/yiring/app/vo/video/VideoVo.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.vo.video;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
import lombok.*;
import lombok.experimental.FieldDefaults;
import org.locationtech.jts.geom.Point;
/**
* @author tzl
* 2022/4/15 10:48
*/
@ApiModel("VideoVo")
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@FieldDefaults(level = AccessLevel.PRIVATE)
public class VideoVo implements Serializable {
@ApiModelProperty(value = "坐标点信息", example = "")
Point point;
@ApiModelProperty(value = "编号", example = "88888888")
String uuid;
@ApiModelProperty(value = "m3u8地址", example = "")
String m3u8;
@ApiModelProperty(value = "备注", example = "摄像头")
String remark;
@ApiModelProperty(value = "摄像头名称", example = "摄像头1")
String videoName;
@ApiModelProperty(value = "状态", example = "正常")
String status;
}
app/src/main/java/com/yiring/app/web/car/CarController.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.web.car;
import com.yiring.app.domain.car.Car;
import com.yiring.app.param.car.CarParam;
import com.yiring.app.param.car.CarQueryParam;
import com.yiring.app.service.car.CarService;
import com.yiring.app.vo.car.CarVo;
import com.yiring.common.core.Result;
import com.yiring.common.param.IdParam;
import com.yiring.common.util.poi.ExcelUtils;
import com.yiring.common.vo.PageVo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import java.util.List;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import javax.validation.Valid;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
/**
* 车辆来访信息控制器
*
* @author tzl
* 2022/4/11 17:02
*/
@Slf4j
@Api(tags = "Car")
@Validated
@RestController
@RequestMapping("/Car/")
public class CarController {
@Resource
CarService carService;
@ApiOperation(value = "新增车辆来访信息")
@PostMapping("saveCarInfo")
public Result<Long> saveCarInfo(@Valid CarParam carParam) {
return carService.saveCarInfo(carParam);
}
@ApiOperation(value = "修改车辆来访信息")
@PostMapping("updateCarInfo")
public Result<Long> updateCarInfo(@Valid CarParam carParam, @Valid IdParam idParam) {
return carService.updateCarInfo(carParam, idParam);
}
@ApiOperation(value = "收卡")
@PostMapping("cardRec")
public Result<Long> cardRec(@Valid IdParam idParam) {
return carService.cardRec(idParam);
}
@ApiOperation(value = "发卡")
@ApiImplicitParam(value = "标签卡", example = "DW8544568", required = true, name = "labelCard")
@PostMapping("cardSend")
public Result<Long> cardSend(@Valid IdParam idParam, String labelCard) {
return carService.cardSend(idParam, labelCard);
}
@ApiOperation(value = "删除车辆来访信息")
@PostMapping("deleteCarInfo")
public Result<String> deleteCarInfo(@Valid IdParam idParam) {
return carService.deleteCarInfo(idParam);
}
@ApiOperation(value = "查看车辆来访信息详情")
@GetMapping("getCarInfo")
public Result<CarVo> getCarInfo(@Valid IdParam idParam) {
return carService.getCarInfo(idParam);
}
@ApiOperation(value = "查看车辆来访信息(分页)")
@GetMapping("pageCarInfo")
public Result<PageVo<CarVo>> pageCarInfo(@Valid CarQueryParam carParam) {
return carService.pageCarInfo(carParam);
}
@ApiOperation(value = "导出车辆来访信息")
@PostMapping("exportCarInfo")
public void exportCarInfo(HttpServletResponse response, @Valid CarQueryParam carParam) {
List<Car> export = carService.export(carParam);
ExcelUtils<Car> util = new ExcelUtils<>(Car.class);
// String fileName = URLEncoder.encode("车辆来访信息.xlsx", StandardCharsets.UTF_8);
response.setContentType("application/octet-stream");
// response.setHeader("Content-Disposition", "attachment;filename=" + fileName);
// response.setCharacterEncoding("utf-8");
util.exportExcel(response, export, "车辆来访信息");
}
}
app/src/main/java/com/yiring/app/web/dict/DictController.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.web.dict;
import com.yiring.app.param.dict.DictParam;
import com.yiring.app.param.dict.DictQueryParam;
import com.yiring.app.service.dict.DictService;
import com.yiring.common.core.Result;
import com.yiring.common.dict.Dict;
import com.yiring.common.param.IdParam;
import com.yiring.common.param.PageParam;
import com.yiring.common.vo.PageVo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import java.util.ArrayList;
import javax.annotation.Resource;
import javax.validation.Valid;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 字典数据控制器
*
* @author tzl
* 2022/4/13 17:10
*/
@Slf4j
@Validated
@Api(tags = "Dict")
@RestController
@RequestMapping("/Dict/")
public class DictController {
@Resource
DictService dictService;
@ApiOperation(value = "新增字典信息")
@PostMapping("saveDictInfo")
public Result<String> saveDictInfo(@Valid DictParam dictParam) {
return dictService.saveDictInfo(dictParam);
}
@ApiOperation(value = "修改字典信息")
@PostMapping("updateDictInfo")
public Result<String> updateDictInfo(@Valid DictParam dictParam, @Valid IdParam idParam) {
return dictService.updateDictInfo(dictParam, idParam);
}
@ApiOperation(value = "删除字典信息")
@PostMapping("deleteDictById")
public Result<String> deleteDictById(@Valid IdParam idParam) {
return dictService.deleteDictById(idParam);
}
@ApiOperation(value = "查看字典信息(分页)")
@GetMapping("pageDictInfo")
public Result<PageVo<Dict>> pageDictInfo(@Valid DictQueryParam queryParam, @Valid PageParam param) {
return dictService.pageDictInfo(queryParam, param);
}
@ApiOperation(value = "查看字典信息详情")
@GetMapping("getDictInfo")
public Result<Dict> getDictInfo(@Valid IdParam idParam) {
return dictService.getDictInfo(idParam.getId());
}
@ApiOperation(value = "根据类型获取字典信息详情")
@ApiImplicitParam(value = "字典类型", example = "user_sex", required = true, name = "dictType")
@GetMapping("selectDict")
public Result<ArrayList<Dict>> selectDict(String dictType) {
return dictService.selectDict(dictType);
}
}
app/src/main/java/com/yiring/app/web/dict/DictTypeController.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.web.dict;
import io.swagger.annotations.Api;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 字典类型控制器
*
* @author tzl
* 2022/4/14 15:14
*/
@Slf4j
@Validated
@Api(tags = "DictType")
@RestController
@RequestMapping("/DictType/")
public class DictTypeController {
//
// @Resource
// DictTypeService dictTypeService;
//
// @ApiOperation(value = "新增字典类型信息")
// @PostMapping("saveDictTypeInfo")
// public Result<String> saveDictTypeInfo(@Valid DictTypeParam dictTypeParam) {
// return dictTypeService.saveDictTypeInfo(dictTypeParam);
// }
//
// @ApiOperation(value = "修改字典类型信息")
// @PostMapping("updateDictTypeInfo")
// public Result<String> updateDictTypeInfo(@Valid DictTypeParam dictTypeParam, @Valid IdParam idParam) {
// return dictTypeService.updateDictTypeInfo(dictTypeParam, idParam);
// }
//
// @ApiOperation(value = "删除字典类型信息")
// @PostMapping("delecteById")
// public Result<String> delecteById(@Valid IdParam idParam) {
// return dictTypeService.delecteById(idParam.getId());
// }
//
// @ApiOperation(value = "查看字典类型信息(分页)")
// @GetMapping("pageDictTypeInfo")
// public Result<PageVo<DictType>> pageDictInfo(@Valid DictTypeQueryParam queryParam, @Valid PageParam param) {
// return dictTypeService.pageDictTypeInfo(queryParam, param);
// }
//
// @ApiOperation(value = "查看字典类型信息详情")
// @GetMapping("getDictTypeInfo")
// public Result<DictType> getDictTypeInfo(@Valid IdParam idParam) {
// return dictTypeService.getDictTypeInfo(idParam.getId());
// }
}
app/src/main/java/com/yiring/app/web/video/VideoController.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.app.web.video;
import com.yiring.app.param.video.VideoParam;
import com.yiring.app.param.video.VideoQueryParam;
import com.yiring.app.service.video.VideoService;
import com.yiring.app.vo.video.VideoVo;
import com.yiring.common.core.Result;
import com.yiring.common.param.IdParam;
import com.yiring.common.param.PageParam;
import com.yiring.common.vo.PageVo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import javax.annotation.Resource;
import javax.validation.Valid;
import lombok.extern.slf4j.Slf4j;
import org.locationtech.jts.geom.Point;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 监控点位控制器
* @author tzl
* 2022/4/8 16:51
*/
@Slf4j
@Validated
@Api(tags = "Video")
@RestController
@RequestMapping("/video/")
public class VideoController {
@Resource
VideoService videoService;
@ApiOperation(value = "新增监控点位信息")
@PostMapping("saveVideo")
public Result<String> findLatest(@Valid VideoParam videoParam) {
return videoService.saveVideo(videoParam);
}
@ApiOperation(value = "删除监控点位信息")
@PostMapping("deleteVideo")
public Result<String> deleteVideo(@Valid IdParam idParam) {
return videoService.deleteVideo(idParam);
}
@ApiOperation(value = "修改监控点位信息")
@PostMapping("updateVideo")
public Result<String> updateVideo(@Valid VideoParam videoParam, @Valid IdParam idParam) {
return videoService.updateVideo(videoParam, idParam);
}
@ApiOperation(value = "查看监控点位位置")
@PostMapping("selectPoint")
public Result<Point> selectPoint(@Valid IdParam idParam) {
return videoService.selectPoint(idParam);
}
@ApiOperation(value = "分页查询监控点位信息")
@PostMapping("pageVideo")
public Result<PageVo<VideoVo>> pageVideo(@Valid VideoQueryParam videoQueryParam, @Valid PageParam param) {
return videoService.pageVideo(videoQueryParam, param);
}
}
basic-common/core/build.gradle
dependencies {
implementation project(":basic-common:util")
// implementation project(":basic-common:util")
implementation 'org.springframework.boot:spring-boot-starter-aop'
implementation 'org.springframework.boot:spring-boot-starter-web'
......@@ -12,11 +12,9 @@ dependencies {
// swagger annotations
implementation "io.swagger:swagger-annotations:${swaggerAnnotationsVersion}"
// hutool-extra
implementation "cn.hutool:hutool-extra:${hutoolVersion}"
implementation "cn.dev33:sa-token-dao-redis-jackson:${saTokenVersion}"
// fastjson
implementation "com.alibaba:fastjson:${fastJsonVersion}"
implementation fileTree(dir: project.rootDir.getPath() + '\\libs', includes: ['*jar'])
// JTS 几何对象操作库
implementation "org.locationtech.jts:jts-core:${jtsVersion}"
......
basic-common/core/src/main/java/com/yiring/common/config/CorsConfig.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.common.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
/**
* 跨域设置
* @author tzl
* 2022/4/18 10:29
*/
@Configuration
public class CorsConfig {
@Bean
public CorsFilter corsFilter() {
final UrlBasedCorsConfigurationSource urlBasedCorsConfigurationSource = new UrlBasedCorsConfigurationSource();
final CorsConfiguration corsConfiguration = new CorsConfiguration();
// corsConfiguration.setAllowCredentials(true);
corsConfiguration.addAllowedOrigin("*");
corsConfiguration.addAllowedHeader("*");
corsConfiguration.addAllowedMethod("*");
urlBasedCorsConfigurationSource.registerCorsConfiguration("/**", corsConfiguration);
return new CorsFilter(urlBasedCorsConfigurationSource);
}
}
basic-common/core/src/main/java/com/yiring/common/constant/RegEx.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.common.constant;
/**
* 常用相关验证正则表达式
* @author tzl
* 2022/4/12 12:00
*/
public class RegEx {
//车牌号码验证
public static final String CARNUM =
"([京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼]" +
"{1}(([A-HJ-Z]{1}[A-HJ-NP-Z0-9]{5})|([A-HJ-Z]{1}(([DF]{1}[A-HJ-NP-Z0-9]{1}[0-9]{4})|([0-9]{5}[DF]" +
"{1})))|([A-HJ-Z]{1}[A-D0-9]{1}[0-9]{3}警)))|([0-9]{6}使)|((([沪粤川云桂鄂陕蒙藏黑辽渝]{1}A)|鲁B|闽D|蒙E|蒙H)[0-9]{4}领)" +
"|(WJ[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼·•]{1}[0-9]{4}[TDSHBXJ0-9]{1})" +
"|([VKHBSLJNGCE]{1}[A-DJ-PR-TVY]{1}[0-9]{5})";
//手机号码验证
public static final String MOBILE =
"^((13[0-9])|(14[5,7,9])|(15([0-3]|[5-9]))|(16[5,6])|(17[0-8])|(18[0-9])|(19[1、5、8、9]))\\d{8}$";
}
basic-common/core/src/main/java/com/yiring/common/core/redis/RedisCache.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.common.core.redis;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
/**
* redis缓存 工具类
*
* @author tzl
* 2022/4/13 15:36
*/
@Component
public class RedisCache {
@Autowired
public RedisTemplate redisTemplate;
/**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
*/
public <T> void setCacheObject(final String key, final T value) {
redisTemplate.opsForValue().set(key, value);
}
/**
* 缓存基本的对象，Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
* @param timeout 时间
* @param timeUnit 时间颗粒度
*/
public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @return true=设置成功；false=设置失败
*/
public boolean expire(final String key, final long timeout) {
return expire(key, timeout, TimeUnit.SECONDS);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @param unit 时间单位
* @return true=设置成功；false=设置失败
*/
public boolean expire(final String key, final long timeout, final TimeUnit unit) {
return Boolean.TRUE.equals(redisTemplate.expire(key, timeout, unit));
}
/**
* 获得缓存的基本对象。
*
* @param key 缓存键值
* @return 缓存键值对应的数据
*/
public <T> T getCacheObject(final String key) {
ValueOperations<String, T> operation = redisTemplate.opsForValue();
return operation.get(key);
}
/**
* 删除单个对象
*
* @param key
*/
public boolean deleteObject(final String key) {
return Boolean.TRUE.equals(redisTemplate.delete(key));
}
/**
* 删除集合对象
*
* @param collection 多个对象
* @return
*/
public long deleteObject(final Collection collection) {
return redisTemplate.delete(collection);
}
/**
* 缓存List数据
*
* @param key 缓存的键值
* @param dataList 待缓存的List数据
* @return 缓存的对象
*/
public <T> long setCacheList(final String key, final List<T> dataList) {
Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
return count == null ? 0 : count;
}
/**
* 获得缓存的list对象
*
* @param key 缓存的键值
* @return 缓存键值对应的数据
*/
public <T> List<T> getCacheList(final String key) {
return redisTemplate.opsForList().range(key, 0, -1);
}
/**
* 缓存Set
*
* @param key 缓存键值
* @param dataSet 缓存的数据
* @return 缓存数据的对象
*/
public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet) {
BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
for (T t : dataSet) {
setOperation.add(t);
}
return setOperation;
}
/**
* 获得缓存的set
*
* @param key String
* @return
*/
public <T> Set<T> getCacheSet(final String key) {
return redisTemplate.opsForSet().members(key);
}
/**
* 缓存Map
*
* @param key
* @param dataMap
*/
public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
if (dataMap != null) {
redisTemplate.opsForHash().putAll(key, dataMap);
}
}
/**
* 获得缓存的Map
*
* @param key
* @return
*/
public <T> Map<String, T> getCacheMap(final String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* 往Hash中存入数据
*
* @param key Redis键
* @param hKey Hash键
* @param value 值
*/
public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
redisTemplate.opsForHash().put(key, hKey, value);
}
/**
* 获取Hash中的数据
*
* @param key Redis键
* @param hKey Hash键
* @return Hash中的对象
*/
public <T> T getCacheMapValue(final String key, final String hKey) {
HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
return opsForHash.get(key, hKey);
}
/**
* 删除Hash中的数据
*
* @param key
* @param hKey
*/
public void delCacheMapValue(final String key, final String hKey) {
HashOperations hashOperations = redisTemplate.opsForHash();
hashOperations.delete(key, hKey);
}
/**
* 获取多个Hash中的数据
*
* @param key Redis键
* @param hKeys Hash键集合
* @return Hash对象集合
*/
public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
return redisTemplate.opsForHash().multiGet(key, hKeys);
}
/**
* 获得缓存的基本对象列表
*
* @param pattern 字符串前缀
* @return 对象列表
*/
public Collection<String> keys(final String pattern) {
return redisTemplate.keys(pattern);
}
}
basic-common/core/src/main/java/com/yiring/common/dict/Dict.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.common.dict;
import java.io.Serializable;
import java.time.LocalDateTime;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import lombok.*;
import lombok.experimental.FieldDefaults;
import lombok.experimental.FieldNameConstants;
import org.hibernate.annotaions.Comment;
import org.hibernate.annotations.GenericGenerator;
import org.hibernate.snowflake.SnowflakeId;
/**
* 字典表
*
* @author tzl
* 2022/4/13 15:36
*/
@Getter
@Setter
@ToString
@Builder
@NoArgsConstructor
@AllArgsConstructor
@FieldNameConstants
@FieldDefaults(level = AccessLevel.PRIVATE)
@Entity
@Table(name = "SYS_DICT")
@Comment("字典")
public class Dict implements Serializable {
@Id
@Comment("主键id")
@GeneratedValue(generator = SnowflakeId.GENERATOR)
@GenericGenerator(name = SnowflakeId.GENERATOR, strategy = SnowflakeId.Strategy.LONG)
Long id;
@Comment("字典排序")
Integer dictSort;
@Comment("字典标签")
String dictLabel;
@Comment("字典键值")
String dictValue;
@Comment("字典类型")
String dictType;
@Comment("状态（0正常 1停用）")
String status;
@Comment("备注")
String remark;
@Comment("创建时间")
LocalDateTime createTime;
}
basic-common/core/src/main/java/com/yiring/common/dict/DictRepository.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.common.dict;
import java.io.Serializable;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.transaction.annotation.Transactional;
/**
* @author tzl
* 2022/4/13 15:32
*/
public interface DictRepository extends JpaRepository<Dict, Serializable>, JpaSpecificationExecutor<Dict> {
/**
* 根据字典类型和字典键值查询字典数据信息
*
* @param dictType String
* @param dictValue String
* @return 字典标签
*/
@Query("select dictLabel from Dict where dictType = ?1 and dictValue = ?2")
String findDictLabel(String dictType, String dictValue);
/**
* 根据字典类型查询所有启用的字典数据
*
* @param dictType 字典类型
* @return 字典数据集合
*/
@Query("select d from Dict d where d.dictType = ?1")
List<Dict> findByDictType(String dictType);
@Modifying
@Transactional
@Query("update Dict set dictType=?1 where dictType=?2")
boolean updateDictType(String param, String dictType);
}
basic-common/core/src/main/java/com/yiring/common/dict/DictType.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.common.dict;
import java.io.Serializable;
import java.time.LocalDateTime;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import lombok.*;
import lombok.experimental.FieldDefaults;
import lombok.experimental.FieldNameConstants;
import org.hibernate.annotaions.Comment;
import org.hibernate.annotations.GenericGenerator;
import org.hibernate.snowflake.SnowflakeId;
/**
* @author tzl
* 2022/4/14 14:07
*/
@Getter
@Setter
@ToString
@Builder
@NoArgsConstructor
@AllArgsConstructor
@FieldNameConstants
@FieldDefaults(level = AccessLevel.PRIVATE)
@Entity
@Table(name = "SYS_DICT_TYPE")
@Comment("字典类型")
public class DictType implements Serializable {
@Id
@Comment("主键id")
@GeneratedValue(generator = SnowflakeId.GENERATOR)
@GenericGenerator(name = SnowflakeId.GENERATOR, strategy = SnowflakeId.Strategy.LONG)
Long id;
@Comment("字典名称")
String dictName;
@Comment("字典类型")
String dictType;
@Comment("状态（0正常 1停用）")
String status;
@Comment("创建时间")
LocalDateTime createTime;
}
basic-common/core/src/main/java/com/yiring/common/dict/DictTypeRepository.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.common.dict;
import java.io.Serializable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
/**
* @author tzl
* 2022/4/13 15:32
*/
public interface DictTypeRepository extends JpaRepository<DictType, Serializable>, JpaSpecificationExecutor<DictType> {}
basic-common/util/build.gradle
dependencies {
implementation project(":basic-common:core")
implementation 'org.springframework.boot:spring-boot-starter-web'
implementation 'org.springframework.boot:spring-boot-starter-aop'
// hutool-extra
implementation "cn.hutool:hutool-extra:${hutoolVersion}"
// fastjson
implementation "com.alibaba:fastjson:${fastJsonVersion}"
}
basic-common/util/src/main/java/com/yiring/common/annotation/Excel.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.common.annotation;
import com.yiring.common.util.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数据注解
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Excel {
/**
* 导出时在excel中排序
*/
int sort() default Integer.MAX_VALUE;
/**
* 导出到Excel中的名字.
*/
String name() default "";
/**
* 日期格式, 如: yyyy-MM-dd
*/
String dateFormat() default "";
/**
* 如果是字典类型，请设置字典的type值 (如: user_sex)
*/
String dictType() default "";
/**
* 读取内容转表达式 (如: 0=男,1=女,2=未知)
*/
String readConverterExp() default "";
/**
* 分隔符，读取字符串组内容
*/
String separator() default ",";
/**
* BigDecimal 精度 默认:-1(默认不开启BigDecimal格式化)
*/
int scale() default -1;
/**
* BigDecimal 舍入规则 默认:BigDecimal.ROUND_HALF_EVEN
*/
int roundingMode() default BigDecimal.ROUND_HALF_EVEN;
/**
* 导出类型（0数字 1字符串）
*/
ColumnType cellType() default ColumnType.STRING;
/**
* 导出时在excel中每个列的高度 单位为字符
*/
double height() default 14;
/**
* 导出时在excel中每个列的宽 单位为字符
*/
double width() default 16;
/**
* 文字后缀,如% 90 变成90%
*/
String suffix() default "";
/**
* 当值为空时,字段的默认值
*/
String defaultValue() default "";
/**
* 提示信息
*/
String prompt() default "";
/**
* 设置只能选择不能输入的列内容.
*/
String[] combo() default {};
/**
* 是否导出数据,应对需求:有时我们需要导出一份模板,这是标题需要但内容需要用户手工填写.
*/
boolean isExport() default true;
/**
* 另一个类中的属性名称,支持多级获取,以小数点隔开
*/
String targetAttr() default "";
/**
* 是否自动统计数据,在最后追加一行统计数据总和
*/
boolean isStatistics() default false;
/**
* 导出字段对齐方式（0：默认；1：靠左；2：居中；3：靠右）
*/
Align align() default Align.AUTO;
/**
* 自定义数据处理器
*/
Class<?> handler() default ExcelHandlerAdapter.class;
/**
* 自定义数据处理器参数
*/
String[] args() default {};
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;
enum Type {
ALL(0),
EXPORT(1),
IMPORT(2);
private final int value;
Type(int value) {
this.value = value;
}
int value() {
return this.value;
}
}
enum ColumnType {
NUMERIC(0),
STRING(1),
IMAGE(2);
private final int value;
ColumnType(int value) {
this.value = value;
}
int value() {
return this.value;
}
}
}
basic-common/util/src/main/java/com/yiring/common/annotation/Excels.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.common.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Excel注解集
*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Excels {
Excel[] value();
}
basic-common/util/src/main/java/com/yiring/common/util/DictUtils.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.common.util;
import com.yiring.common.core.redis.RedisCache;
import com.yiring.common.dict.Dict;
import com.yiring.common.util.spring.SpringUtil;
import java.util.Collection;
import java.util.List;
/**
* 字典工具类
*
* @author tzl
*/
public class DictUtils {
/**
* 分隔符
*/
public static final String SEPARATOR = ",";
/**
* 设置字典缓存
*
* @param key 参数键
* @param dictDatas 字典数据列表
*/
public static void setDictCache(String key, List<Dict> dictDatas) {
SpringUtil.getBean(RedisCache.class).setCacheObject(getCacheKey(key), dictDatas);
}
/**
* 获取字典缓存
*
* @param key 参数键
* @return dictDatas 字典数据列表
*/
public static List<Dict> getDictCache(String key) {
Object cacheObj = SpringUtil.getBean(RedisCache.class).getCacheObject(getCacheKey(key));
if (StrUtils.isNotNull(cacheObj)) {
return StrUtils.cast(cacheObj);
}
return null;
}
/**
* 根据字典类型和字典值获取字典标签
*
* @param dictType 字典类型
* @param dictValue 字典值
* @return 字典标签
*/
public static String getDictLabel(String dictType, String dictValue) {
return getDictLabel(dictType, dictValue, SEPARATOR);
}
/**
* 根据字典类型和字典标签获取字典值
*
* @param dictType 字典类型
* @param dictLabel 字典标签
* @return 字典值
*/
public static String getDictValue(String dictType, String dictLabel) {
return getDictValue(dictType, dictLabel, SEPARATOR);
}
/**
* 根据字典类型和字典值获取字典标签
*
* @param dictType 字典类型
* @param dictValue 字典值
* @param separator 分隔符
* @return 字典标签
*/
public static String getDictLabel(String dictType, String dictValue, String separator) {
StringBuilder propertyString = new StringBuilder();
List<Dict> datas = getDictCache(dictType);
if (StrUtils.containsAny(separator, dictValue) && StrUtils.isNotEmpty(datas)) {
if (datas != null) {
for (Dict dict : datas) {
for (String value : dictValue.split(separator)) {
if (value.equals(dict.getDictValue())) {
propertyString.append(dict.getDictLabel()).append(separator);
break;
}
}
}
}
} else {
if (datas != null) {
for (Dict dict : datas) {
if (dictValue.equals(dict.getDictValue())) {
return dict.getDictLabel();
}
}
}
}
return StrUtils.stripEnd(propertyString.toString(), separator);
}
/**
* 根据字典类型和字典标签获取字典值
*
* @param dictType 字典类型
* @param dictLabel 字典标签
* @param separator 分隔符
* @return 字典值
*/
public static String getDictValue(String dictType, String dictLabel, String separator) {
StringBuilder propertyString = new StringBuilder();
List<Dict> datas = getDictCache(dictType);
if (StrUtils.containsAny(separator, dictLabel) && StrUtils.isNotEmpty(datas)) {
if (datas != null) {
for (Dict dict : datas) {
for (String label : dictLabel.split(separator)) {
if (label.equals(dict.getDictLabel())) {
propertyString.append(dict.getDictValue()).append(separator);
break;
}
}
}
}
} else {
if (datas != null) {
for (Dict dict : datas) {
if (dictLabel.equals(dict.getDictLabel())) {
return dict.getDictValue();
}
}
}
}
return StrUtils.stripEnd(propertyString.toString(), separator);
}
/**
* 删除指定字典缓存
*
* @param key 字典键
*/
public static void removeDictCache(String key) {
SpringUtil.getBean(RedisCache.class).deleteObject(getCacheKey(key));
}
/**
* 清空字典缓存
*/
public static void clearDictCache() {
Collection<String> keys = SpringUtil.getBean(RedisCache.class).keys("sys_dict:*");
SpringUtil.getBean(RedisCache.class).deleteObject(keys);
}
/**
* 设置cache key
*
* @param configKey 参数键
* @return 缓存键key
*/
public static String getCacheKey(String configKey) {
return "sys_dict:" + configKey;
}
}
basic-common/util/src/main/java/com/yiring/common/util/date/DateUtils.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.common.util.date;
import java.lang.management.ManagementFactory;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.util.Date;
import org.apache.commons.lang3.time.DateFormatUtils;
/**
* 时间工具类
*/
public class DateUtils extends org.apache.commons.lang3.time.DateUtils {
public static String YYYY = "yyyy";
public static String YYYY_MM = "yyyy-MM";
public static String YYYY_MM_DD = "yyyy-MM-dd";
public static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
public static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
private static final String[] parsePatterns = {
"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",
"yyyy.MM.dd",
"yyyy.MM.dd HH:mm:ss",
"yyyy.MM.dd HH:mm",
"yyyy.MM",
};
/**
* 获取当前Date型日期
*
* @return Date() 当前日期
*/
public static Date getNowDate() {
return new Date();
}
/**
* 获取当前日期, 默认格式为yyyy-MM-dd
*
* @return String
*/
public static String getDate() {
return dateTimeNow(YYYY_MM_DD);
}
public static String getTime() {
return dateTimeNow(YYYY_MM_DD_HH_MM_SS);
}
public static String dateTimeNow() {
return dateTimeNow(YYYYMMDDHHMMSS);
}
public static String dateTimeNow(final String format) {
return parseDateToStr(format, new Date());
}
public static String dateTime(final Date date) {
return parseDateToStr(YYYY_MM_DD, date);
}
public static String parseDateToStr(final String format, final Date date) {
return new SimpleDateFormat(format).format(date);
}
public static 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 String datePath() {
Date now = new Date();
return DateFormatUtils.format(now, "yyyy/MM/dd");
}
/**
* 日期路径 即年/月/日 如20180808
*/
public static String dateTime() {
Date now = new Date();
return DateFormatUtils.format(now, "yyyyMMdd");
}
/**
* 日期型字符串转化为日期 格式
*/
public static Date parseDate(Object str) {
if (str == 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 String getDatePoor(Date endDate, Date nowDate) {
long nd = 1000 * 24 * 60 * 60;
long nh = 1000 * 60 * 60;
long nm = 1000 * 60;
// long ns = 1000;
// 获得两个时间的毫秒时间差异
long diff = endDate.getTime() - nowDate.getTime();
// 计算差多少天
long day = diff / nd;
// 计算差多少小时
long hour = diff % nd / nh;
// 计算差多少分钟
long min = diff % nd % nh / nm;
// 计算差多少秒//输出结果
// long sec = diff % nd % nh % nm / ns;
return day + "天" + hour + "小时" + min + "分钟";
}
/**
* 增加 LocalDateTime ==> Date
*/
public static Date toDate(LocalDateTime temporalAccessor) {
ZonedDateTime zdt = temporalAccessor.atZone(ZoneId.systemDefault());
return Date.from(zdt.toInstant());
}
/**
* 增加 LocalDate ==> Date
*/
public static Date toDate(LocalDate temporalAccessor) {
LocalDateTime localDateTime = LocalDateTime.of(temporalAccessor, LocalTime.of(0, 0, 0));
ZonedDateTime zdt = localDateTime.atZone(ZoneId.systemDefault());
return Date.from(zdt.toInstant());
}
}
basic-common/util/src/main/java/com/yiring/common/util/file/FileTypeUtils.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.common.util.file;
import java.io.File;
import org.apache.commons.lang3.StringUtils;
/**
* 文件类型工具类
*/
public class FileTypeUtils {
/**
* 获取文件类型
* <p>
* 例如: ruoyi.txt, 返回: txt
*
* @param file 文件名
* @return 后缀（不含".")
*/
public static String getFileType(File file) {
if (null == file) {
return StringUtils.EMPTY;
}
return getFileType(file.getName());
}
/**
* 获取文件类型
* <p>
* 例如: ruoyi.txt, 返回: txt
*
* @param fileName 文件名
* @return 后缀（不含".")
*/
public static String getFileType(String fileName) {
int separatorIndex = fileName.lastIndexOf(".");
if (separatorIndex < 0) {
return "";
}
return fileName.substring(separatorIndex + 1).toLowerCase();
}
/**
* 获取文件类型
*
* @param photoByte 文件字节码
* @return 后缀（不含".")
*/
public static String getFileExtendName(byte[] photoByte) {
String strFileExtendName = "JPG";
if (
(photoByte[0] == 71) &&
(photoByte[1] == 73) &&
(photoByte[2] == 70) &&
(photoByte[3] == 56) &&
((photoByte[4] == 55) || (photoByte[4] == 57)) &&
(photoByte[5] == 97)
) {
strFileExtendName = "GIF";
} else if ((photoByte[6] == 74) && (photoByte[7] == 70) && (photoByte[8] == 73) && (photoByte[9] == 70)) {
strFileExtendName = "JPG";
} else if ((photoByte[0] == 66) && (photoByte[1] == 77)) {
strFileExtendName = "BMP";
} else if ((photoByte[1] == 80) && (photoByte[2] == 78) && (photoByte[3] == 71)) {
strFileExtendName = "PNG";
}
return strFileExtendName;
}
}
basic-common/util/src/main/java/com/yiring/common/util/file/ImageUtils.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.common.util.file;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.Arrays;
import org.apache.poi.util.IOUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 图片处理工具类
*/
public class ImageUtils {
private static final Logger log = LoggerFactory.getLogger(ImageUtils.class);
public static byte[] getImage(String imagePath) {
InputStream is = getFile(imagePath);
try {
return IOUtils.toByteArray(is);
} catch (Exception e) {
log.error("图片加载异常 {}", e);
return null;
} finally {
IOUtils.closeQuietly(is);
}
}
public static InputStream getFile(String imagePath) {
try {
byte[] result = readFile(imagePath);
result = Arrays.copyOf(result, result.length);
return new ByteArrayInputStream(result);
} catch (Exception e) {
log.error("获取图片异常 {}", e);
}
return null;
}
/**
* 读取文件为字节数据
*
* @param url 地址
* @return 字节数据
*/
public static byte[] readFile(String url) {
InputStream in = null;
try {
// 网络地址
URL urlObj = new URL(url);
URLConnection urlConnection = urlObj.openConnection();
urlConnection.setConnectTimeout(30 * 1000);
urlConnection.setReadTimeout(60 * 1000);
urlConnection.setDoInput(true);
in = urlConnection.getInputStream();
return IOUtils.toByteArray(in);
} catch (Exception e) {
log.error("访问文件异常 {}", e);
return null;
} finally {
IOUtils.closeQuietly(in);
}
}
}
basic-common/util/src/main/java/com/yiring/common/util/poi/ExcelHandlerAdapter.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.common.util.poi;
/**
* Excel数据格式处理适配器
*/
public interface ExcelHandlerAdapter {
/**
* 格式化
*
* @param value 单元格数据值
* @param args excel注解args参数组
* @return 处理后的值
*/
Object format(Object value, String[] args);
}
basic-common/util/src/main/java/com/yiring/common/util/spring/SpringUtil.java 0 → 100644
/* (C) 2022 YiRing, Inc. */
package com.yiring.common.util.spring;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
/**
* spring工具类 方便在非spring管理环境中获取bean
*
* @author ruoyi
*/
@Component
public final class SpringUtil implements BeanFactoryPostProcessor, ApplicationContextAware {
/** Spring应用上下文环境 */
private static ConfigurableListableBeanFactory beanFactory;
private static ApplicationContext applicationContext;
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
SpringUtil.beanFactory = beanFactory;
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
SpringUtil.applicationContext = applicationContext;
}
/**
* 获取类型为requiredType的对象
*
* @param clz Class
* @return T
*
*/
public static <T> T getBean(Class<T> clz) throws BeansException {
return (T) beanFactory.getBean(clz);
}
}
build.gradle
......@@ -73,6 +73,9 @@ subprojects {
compileOnly 'org.projectlombok:lombok'
annotationProcessor 'org.projectlombok:lombok'
annotationProcessor 'org.springframework.boot:spring-boot-configuration-processor'
implementation group: 'org.apache.poi', name: 'poi', version: '5.0.0'
implementation group: 'org.apache.poi', name: 'poi-ooxml', version: '5.0.0'
implementation group: 'org.apache.commons', name: 'commons-lang3', version: '3.12.0'
}
[compileJava,compileTestJava,javadoc]*.options*.encoding ='UTF-8'
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论