package com.zt.modules.sys.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
|
import com.zt.common.constant.CacheKey;
|
import com.zt.common.constant.Constant;
|
import com.zt.common.exception.ErrorCode;
|
import com.zt.common.exception.RenException;
|
import com.zt.common.service.BaseService;
|
import com.zt.common.utils.CacheUtils;
|
import com.zt.common.utils.CommonUtils;
|
import com.zt.common.utils.TreeUtils;
|
import com.zt.core.context.User;
|
import com.zt.core.context.UserContext;
|
import com.zt.core.dictionary.DictionaryParser;
|
import com.zt.core.shiro.ImportUtil;
|
import com.zt.core.sys.dto.DictDto;
|
import com.zt.core.sys.dto.DictItemDto;
|
import com.zt.core.sys.dto.DictLeafDto;
|
import com.zt.core.sys.service.IDictTypeService;
|
import com.zt.modules.sys.dao.SysDictDataDao;
|
import com.zt.modules.sys.dao.SysDictTypeDao;
|
import com.zt.modules.sys.dto.DictTypeDto;
|
import com.zt.modules.sys.model.SysDictData;
|
import com.zt.modules.sys.model.SysDictType;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
|
import org.apache.poi.ss.usermodel.Row;
|
import org.apache.poi.ss.usermodel.Sheet;
|
import org.apache.poi.ss.usermodel.Workbook;
|
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.multipart.MultipartFile;
|
|
import javax.annotation.Resource;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 数据字典
|
*
|
* @author Mark sunlightcs@gmail.com
|
*/
|
@Service
|
public class SysDictTypeService extends BaseService<SysDictTypeDao, SysDictType> implements IDictTypeService {
|
@Autowired
|
private SysDictDataService sysDictDataService;
|
@Resource
|
private DictionaryParser dictionaryParser;
|
@Autowired
|
private SysDictDataDao sysDictDataDao;
|
|
public List<SysDictType> tree() {
|
User user = UserContext.getUser();
|
if (Constant.Sys.PLATFORM_TENANT_ID.equals(user.getTenantId())) {// 平台的
|
List<SysDictType> dictTypes = baseDao.selectList(new QueryWrapper<SysDictType>().eq(
|
Constant.TableColumn.IS_DELETE, Constant.Bool.NO).eq(Constant.TableColumn.TENANT_ID,
|
Constant.Sys.PLATFORM_TENANT_ID));
|
|
// 这个地方有缓存
|
for (SysDictType dictType : dictTypes) {
|
dictType.getChildren().clear();
|
}
|
return TreeUtils.build(dictTypes);
|
} else {// 租户的
|
// 查询租户和平台的
|
List<SysDictType> list = baseDao.selectList(new QueryWrapper<SysDictType>()
|
.eq(Constant.TableColumn.IS_DELETE, Constant.Bool.NO)
|
.eq("is_can_view", Constant.Bool.YES)
|
/* .in(Constant.TableColumn.TENANT_ID,
|
new Long[] { Constant.Sys.PLATFORM_TENANT_ID, user.getTenantId() })*/
|
.orderByAsc("sort", "dict_type", Constant.TableColumn.TENANT_ID));
|
// 这个地方有缓存
|
for (SysDictType dictType : list) {
|
dictType.getChildren().clear();
|
}
|
final List<SysDictType> tree = TreeUtils.build(list);
|
// 过滤：租户的；平台，不存在租户有相同字典类型的
|
return tree
|
.stream()
|
.filter(type -> !Constant.Sys.PLATFORM_TENANT_ID.equals(type.getTenantId())
|
|| tree.stream()
|
.filter(t -> !t.getId().equals(type.getId())
|
&& t.getDictType().equals(type.getDictType())).count() == 0)
|
.collect(Collectors.toList());
|
}
|
}
|
|
public List<Map<String, Object>> importDataDictExcel(MultipartFile mutFile, String progressId) {
|
int count = 0;
|
Date beginDate = new Date();
|
List<Map<String, Object>> list = new ArrayList<>();//存储所有的导入状态
|
Map<String, Object> map;//存储每一行的状态
|
Integer sum = 0; // 总共的条数
|
Integer suc = 0; // 成功的条数
|
Integer err = 0; // 失败的条数
|
int row1 = 0;
|
Map<String, Object> errMap = new HashMap<>();
|
List<DictTypeDto> batchList = new ArrayList<>();
|
ArrayList<DictTypeDto> batchUpdateList = new ArrayList<>();
|
try {
|
// 获取导入文件的后缀名
|
String fileName = mutFile.getOriginalFilename();
|
Workbook workbook = null;
|
//解决excel版本问题
|
if (fileName != null && fileName.endsWith(".xls")) {
|
workbook = new HSSFWorkbook(mutFile.getInputStream());
|
} else if (fileName != null && fileName.endsWith(".xlsx")) {
|
workbook = new XSSFWorkbook(mutFile.getInputStream());
|
}
|
assert workbook != null; //断言如果[boolean表达式]为true，则程序继续执行。 如果为false，则程序抛出AssertionError，并终止执行。
|
int sheets = workbook.getNumberOfSheets();
|
|
//List<LifeManagement> lifeManagementList = new ArrayList<LifeManagement>();
|
if (sheets == 1) {
|
Map<String, DictTypeDto> maxCodeMap = new HashMap<String, DictTypeDto>();
|
List<DictTypeDto> listMaxCode = baseDao.getMaxSortList2();
|
for (DictTypeDto item : listMaxCode
|
) {
|
String key = item.getDictType();
|
maxCodeMap.put(key, item);
|
}
|
int typeSort = 0;
|
for (int i = 0; i < sheets; i++) {
|
Sheet sheet = workbook.getSheetAt(i);
|
int num = sheet.getLastRowNum(); // 一共有多少行
|
String sheetName = sheet.getSheetName(); //获取当前sheet名称
|
for (int j = 1; j <= num; j++) {
|
CacheUtils.put(progressId, "speed", CommonUtils.getPercent(j, num));
|
CacheUtils.put(progressId, "msg", "共" + num + "行，已完成第" + j + "行");
|
DictTypeDto lifeManagement = new DictTypeDto();
|
boolean isErr = false;
|
row1 = j + 1;
|
String pattern = "yyyy-MM-dd";
|
Row row = sheet.getRow(row1);
|
String dictName = ImportUtil.getCellValue(row, 0, pattern); //字典名称
|
String dictType = ImportUtil.getCellValue(row, 1, pattern); //字典类型
|
String dictLabel = ImportUtil.getCellValue(row, 2, pattern); //字典标签
|
|
if (StringUtils.isEmpty(dictName)) {
|
ImportUtil.updateErrMap(errMap, "没有填写字典名称！", sheetName, row1);
|
continue;
|
}
|
if (StringUtils.isEmpty(dictType)) {
|
ImportUtil.updateErrMap(errMap, "没有填写字典类型！", sheetName, row1);
|
continue;
|
}
|
if (StringUtils.isEmpty(dictLabel)) {
|
ImportUtil.updateErrMap(errMap, "没有填写字典标签！", sheetName, row1);
|
continue;
|
}
|
|
if (maxCodeMap.get(dictType) == null) {
|
SysDictType typeEntity = new SysDictType();
|
typeEntity.setDictType(dictType);
|
typeEntity.setDictName(dictName);
|
typeSort++;
|
typeEntity.setSort(typeSort);
|
typeEntity.setDelete(false);
|
typeEntity.setCanView(true);
|
baseDao.insert(typeEntity);
|
//
|
DictTypeDto dm = new DictTypeDto();
|
dm.setDictName(dictName);
|
dm.setDictType(dictType);
|
dm.setDictTypeId(typeEntity.getId());
|
dm.setSort(0);
|
maxCodeMap.put(dictType, dm);
|
} else {
|
System.out.println("已有数据");
|
}
|
int itemSort = maxCodeMap.get(dictType).getSort() + 1;
|
maxCodeMap.get(dictType).setSort(itemSort);
|
|
SysDictData itemEntity = new SysDictData();
|
itemEntity.setDictTypeId(maxCodeMap.get(dictType).getDictTypeId());
|
itemEntity.setDictLabel(dictLabel);
|
itemEntity.setDictValue(itemSort);
|
itemEntity.setSort(itemSort);
|
itemEntity.setDelete(false);
|
sysDictDataDao.insert(itemEntity);
|
}
|
}
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
ImportUtil.updateErrMap(errMap, "导入异常" + e.getMessage(), "", row1);
|
//err++;
|
}
|
/* if (batchList.size() > 0 && err == 0) {
|
super.insertBatch(batchList, 100);
|
baseDao.updateOldId();
|
}
|
if (batchUpdateList.size() > 0) {
|
super.updateBatch(batchUpdateList, 100);
|
}*/
|
Date nowDate = new Date();
|
String msg = "字典导入时间：" + CommonUtils.getDatePoor(nowDate, beginDate) + "\r\n";
|
System.out.println(msg);
|
suc = sum - err;
|
map = new HashMap<>();
|
map.put("sum", sum + ""); // 所有导入的条数
|
map.put("suc", suc + ""); // 成功的条数
|
map.put("err", err + ""); // 失败的条数
|
list.add(map);
|
list.add(errMap);
|
return list;
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public void insert(SysDictType entity) {
|
// 判断父节点不允许拥有字典列表
|
if (sysDictDataService.getByType(entity.getPid()).size() > 0) {
|
throw new RenException("请先删除父节点字典列表!");
|
}
|
if (entity.getPid() == null) {// 根节点，同一个租户下同一个父类型下不能重复
|
entity.setPid(Constant.Sys.DICT_ROOT);
|
}
|
|
this.validateCode(entity); // code校验
|
|
if (!UserContext.getUser().isPlatform()) {// 租户
|
// 租户新增根类型，判断是否存在平台定义了不能重载的
|
if (Constant.Sys.DICT_ROOT.equals(entity.getPid())) {
|
if (baseDao.selectList(
|
new QueryWrapper<SysDictType>().eq(Constant.TableColumn.IS_DELETE, Constant.Bool.NO)
|
.eq("is_can_view", Constant.Bool.YES).eq("is_can_overload", Constant.Bool.NO).lambda()
|
.eq(SysDictType::getTenantId, Constant.Sys.PLATFORM_TENANT_ID)
|
.eq(SysDictType::getPid, Constant.Sys.DICT_ROOT)
|
.eq(SysDictType::getDictType, entity.getDictType())).size() > 0) {
|
throw new RenException("该字典类型不允许重载");
|
}
|
}
|
entity.setCanView(true);// 租户添加的，设置为可见
|
} else {// 平台
|
if (!entity.isCanView()) {// 租户不可见
|
entity.setCanOverload(false);
|
}
|
}
|
|
super.insert(entity);
|
|
CacheUtils.remove(Constant.Cache.SYS, CacheKey.SYS_DICT);// 清除缓存
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public void update(SysDictType entity) {
|
SysDictType tmp = baseDao.selectById(entity.getId());
|
if (tmp == null) {
|
throw new RenException("查询信息失败");
|
}
|
List<SysDictType> all = baseDao.selectList(new QueryWrapper<SysDictType>().eq(Constant.TableColumn.IS_DELETE,
|
Constant.Bool.NO));
|
TreeUtils.updateValidate(all, entity, tmp);
|
if (!entity.getPid().equals(tmp.getPid())) {
|
// 判断父节点不允许拥有字典列表
|
if (sysDictDataService.getByType(entity.getPid()).size() > 0) {
|
throw new RenException("请先删除父节点字典列表!");
|
}
|
}
|
|
this.validateCode(entity); // code校验
|
|
if (UserContext.getUser().isPlatform() && !entity.isCanView()) {// 平台，租户不可见，设置为不可重载
|
entity.setCanOverload(false);
|
}
|
|
super.update(entity);
|
|
CacheUtils.remove(Constant.Cache.SYS, CacheKey.SYS_DICT);// 清除缓存
|
}
|
|
private void validateCode(SysDictType entity) {
|
if (Constant.Sys.DICT_ROOT.equals(entity.getPid())) {
|
// 同一个租户下同一个父类型下不能重复
|
LambdaQueryWrapper<SysDictType> queryWrapper = new QueryWrapper<SysDictType>()
|
.eq(Constant.TableColumn.IS_DELETE, Constant.Bool.NO).lambda()
|
.eq(SysDictType::getTenantId, UserContext.getUser().getTenantId())
|
.eq(SysDictType::getPid, entity.getPid()).eq(SysDictType::getDictType, entity.getDictType());
|
if (entity.getId() != null && entity.getId() > 0) { // 修改
|
queryWrapper.ne(SysDictType::getId, entity.getId());
|
}
|
if (baseDao.selectList(queryWrapper).size() > 0) {
|
throw new RenException("字典类型重复");
|
}
|
} else {
|
List<SysDictType> tree = this.tree();
|
SysDictType root = TreeUtils.getTreeRoot(TreeUtils.toList(tree), entity.getPid(), Constant.Sys.DICT_ROOT);
|
if (root == null) {
|
throw new RenException("获取字典类型失败");
|
}
|
List<SysDictType> treeList = TreeUtils.toList(tree.stream()
|
.filter(type -> type.getId().equals(root.getId())).collect(Collectors.toList()).get(0));
|
if (treeList
|
.stream()
|
.filter(type -> !type.getId().equals(entity.getId())
|
&& type.getDictType().equals(entity.getDictType())).count() > 0) {
|
throw new RenException("字典类型重复");
|
}
|
}
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
public void delete(Long id) {
|
// 字典类型只支持单个删除
|
if (baseDao.selectList(
|
new QueryWrapper<SysDictType>().eq(Constant.TableColumn.IS_DELETE, Constant.Bool.NO).lambda()
|
.eq(SysDictType::getPid, id)).size() > 0) {
|
throw new RenException("请先删除下级节点!");
|
}
|
super.deleteLogic(id);
|
|
CacheUtils.remove(Constant.Cache.SYS, CacheKey.SYS_DICT);// 清除缓存
|
}
|
|
/**
|
* 用户字典
|
*
|
* @return
|
*/
|
public List<DictDto> getUserDicts() {
|
Map<Long, List<DictDto>> cache = (Map<Long, List<DictDto>>) CacheUtils.get(Constant.Cache.SYS,
|
CacheKey.SYS_DICT);
|
|
Long tenantId = UserContext.getUser().getTenantId();
|
if (cache != null && cache.containsKey(tenantId)) {
|
return cache.get(tenantId);
|
} else {
|
List<DictDto> typeList = new ArrayList<>();
|
typeList.addAll(this.getChildren(this.tree()));
|
typeList.addAll(this.getChildren2(this.tree()));
|
if (cache == null) {
|
cache = new HashMap<>();
|
}
|
cache.put(tenantId, typeList);
|
CacheUtils.put(Constant.Cache.SYS, CacheKey.SYS_DICT, cache);
|
|
return typeList;
|
}
|
}
|
|
private List<DictDto> getChildren2(List<SysDictType> children) {
|
List<DictDto> list = new ArrayList<>();
|
for (SysDictType type1 : children) {
|
if (type1.getChildren().size() > 0) {// 存在子类型
|
for (SysDictType type : type1.getChildren()) {
|
DictDto dto;
|
dto = new DictLeafDto(type.getDictType(), type.getDictName());
|
List<SysDictData> datas = sysDictDataService.getByType(type.getId());
|
if (datas.size() > 0) {
|
for (SysDictData data : datas) {
|
DictItemDto itemDto = new DictItemDto(data.getDictLabel(), String.valueOf(data.getDictValue()), data.getRemark());
|
((DictLeafDto) dto).getDataList().add(itemDto);
|
}
|
list.add(dto);
|
}
|
}
|
}
|
}
|
return list;
|
}
|
|
private List<DictDto> getChildren(List<SysDictType> children) {
|
List<DictDto> list = new ArrayList<>();
|
|
for (SysDictType type : children) {
|
DictDto dto;
|
if (type.getChildren().size() > 0) {// 存在子类型
|
dto = new DictDto(type.getDictType(), type.getDictName());
|
dto.getChildren().addAll(getChildren(type.getChildren()));// 设置子类型
|
} else {// 叶子节点
|
dto = new DictLeafDto(type.getDictType(), type.getDictName());
|
List<SysDictData> datas = sysDictDataService.getByType(type.getId());
|
for (SysDictData data : datas) {
|
DictItemDto itemDto = new DictItemDto(data.getDictLabel(), String.valueOf(data.getDictValue()),data.getRemark());
|
((DictLeafDto) dto).getDataList().add(itemDto);
|
}
|
}
|
list.add(dto);
|
}
|
return list;
|
}
|
|
/**
|
* 获取字段，包括常量字典
|
*
|
* @return
|
*/
|
public List<DictDto> getDicts() {
|
List<DictDto> list = new ArrayList<>();
|
list.addAll(this.getUserDicts());
|
list.addAll(dictionaryParser.getConstantDicts());
|
return list;
|
}
|
|
/**
|
* 租户拷贝
|
*
|
* @param id
|
*/
|
public void copyData(Long id) {
|
SysDictType dictType = this.tree().stream().filter(type -> type.getId().equals(id)).findFirst().get();
|
if (!Constant.Sys.PLATFORM_TENANT_ID.equals(dictType.getTenantId())) {
|
throw new RenException(ErrorCode.DATA_ERROR);
|
}
|
if (!dictType.isCanOverload()) {
|
throw new RenException("该字典类型不能重载");
|
}
|
// 这里不会和自己定义的重复
|
if (baseDao.selectList(
|
new QueryWrapper<SysDictType>().eq(Constant.TableColumn.IS_DELETE, Constant.Bool.NO).lambda()
|
.eq(SysDictType::getTenantId, UserContext.getUser().getTenantId())
|
.eq(SysDictType::getPid, dictType.getPid())
|
.eq(SysDictType::getDictType, dictType.getDictType())).size() > 0) {
|
throw new RenException(ErrorCode.DATA_ERROR);
|
}
|
|
List<SysDictType> list = TreeUtils.toList(dictType);
|
// 1、修改id
|
Map<Long, Long> idMap = new HashMap<>();
|
for (SysDictType type : list) {
|
Long oldId = type.getId();
|
type.setId(IdWorker.getId());// 设置新的id
|
idMap.put(oldId, type.getId());
|
}
|
// 2、修改父Id、租户
|
User user = UserContext.getUser();
|
for (SysDictType type : list) {
|
if (!Constant.Sys.DICT_ROOT.equals(type.getPid())) {
|
Long pid = idMap.get(type.getPid());
|
if (pid == null) {
|
throw new RenException(ErrorCode.DATA_ERROR);
|
}
|
type.setPid(pid);// 设置新的pid
|
}
|
type.setTenantId(user.getTenantId());
|
type.getChildren().clear();
|
}
|
// 3、保存字段类型
|
super.insertBatch(list, 100);
|
|
// 4、拷贝字段值
|
List<SysDictData> datas = sysDictDataService.getByTypes(idMap.keySet());
|
for (SysDictData data : datas) {
|
Long dictTypeId = idMap.get(data.getDictTypeId());
|
if (dictTypeId == null) {
|
throw new RenException(ErrorCode.DATA_ERROR);
|
}
|
data.setId(null);
|
data.setDictTypeId(dictTypeId);// 设置新的id
|
data.setTenantId(user.getTenantId());
|
}
|
sysDictDataService.insertBatch(datas, 100);
|
|
CacheUtils.remove(Constant.Cache.SYS, CacheKey.SYS_DICT);// 清除缓存
|
}
|
|
/**
|
* 获取字典类型
|
*
|
* @param dictType
|
* @return
|
*/
|
@Override
|
public DictDto getByDictType(String dictType) {
|
List<DictDto> list = this.getDicts().stream().filter(dict -> dict.getDictType().equals(dictType))
|
.collect(Collectors.toList());
|
return list.size() > 0 ? list.get(0) : null;
|
}
|
|
/**
|
* 获取字典值
|
*
|
* @param dictType
|
* @return
|
*/
|
@Override
|
public List<DictItemDto> getDictItemsByDictType(String dictType) {
|
List<DictItemDto> list = new ArrayList<>();
|
DictDto dict = this.getByDictType(dictType);
|
if (dict != null) {
|
if (dict instanceof DictLeafDto) {
|
list.addAll(((DictLeafDto) dict).getDataList());
|
} else {
|
List<DictDto> treeList = TreeUtils.toList(dict.getChildren());
|
for (DictDto dto : treeList) {
|
if (dto instanceof DictLeafDto) {
|
list.addAll(((DictLeafDto) dto).getDataList());
|
}
|
}
|
}
|
}
|
return list;
|
}
|
|
public Map<String, String> getMapDict(Boolean idToNme, String dictType) {
|
List<DictItemDto> list = getDictItemsByDictType(dictType);
|
|
Map<String, String> result = new HashMap<>();
|
for (DictItemDto item : list) {
|
if (idToNme)
|
result.put(item.getDictValue().toString(), item.getDictLabel());
|
else
|
result.put(item.getDictLabel(), item.getDictValue().toString());
|
}
|
return result;
|
}
|
|
|
/**
|
* 获取字典（树）的所有字典值
|
*
|
* @param dictTypeId
|
* @return
|
*/
|
public List<DictItemDto> getDictItemsOfDictTree(Long dictTypeId) {
|
SysDictType type = TreeUtils.getTreeRoot(TreeUtils.toList(this.tree()), dictTypeId, Constant.Sys.DICT_ROOT);
|
if (type == null) {
|
throw new RenException("字典类型不存在！");
|
}
|
return this.getDictItemsByDictType(type.getDictType());
|
}
|
}
|
