package com.gkhy.exam.system.service.impl;
|
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.gkhy.exam.common.api.CommonPage;
|
import com.gkhy.exam.common.constant.UserConstant;
|
import com.gkhy.exam.common.domain.entity.SysDictData;
|
import com.gkhy.exam.common.domain.entity.SysDictType;
|
import com.gkhy.exam.common.exception.ApiException;
|
import com.gkhy.exam.common.utils.DictUtils;
|
import com.gkhy.exam.common.utils.PageUtils;
|
import com.gkhy.exam.common.utils.SecurityUtils;
|
import com.gkhy.exam.system.mapper.SysDictDataMapper;
|
import com.gkhy.exam.system.mapper.SysDictTypeMapper;
|
import com.gkhy.exam.system.service.SysDictTypeService;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import javax.annotation.PostConstruct;
|
import java.util.Comparator;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.stream.Collectors;
|
|
/**
|
* <p>
|
* 字典类型表 服务实现类
|
* </p>
|
*
|
* @author kzy
|
* @since 2023-11-01 15:37:51
|
*/
|
@Service
|
public class SysDictTypeServiceImpl extends ServiceImpl<SysDictTypeMapper, SysDictType> implements SysDictTypeService {
|
@Autowired
|
private SysDictDataMapper dictDataMapper;
|
|
@PostConstruct
|
public void init(){
|
loadingDictCache();
|
}
|
|
@Override
|
public CommonPage<SysDictType> selectDictTypeList(SysDictType dict) {
|
PageUtils.startPage();
|
List<SysDictType> dictTypeList= baseMapper.selectDictTypeList(dict);
|
return CommonPage.restPage(dictTypeList);
|
}
|
|
@Override
|
public List<SysDictType> selectDictTypeAll() {
|
return list();
|
}
|
|
@Override
|
public List<SysDictData> selectDictDataByType(String dictType) {
|
List<SysDictData> dictDatas= DictUtils.getDictCache(dictType);
|
if(!Objects.isNull(dictDatas)&&dictDatas.size()>0){
|
return dictDatas;
|
}
|
dictDatas=dictDataMapper.selectDictDataByType(dictType);
|
if(!Objects.isNull(dictDatas)){
|
DictUtils.setDictCache(dictType,dictDatas);
|
return dictDatas;
|
}
|
return null;
|
}
|
|
@Override
|
public SysDictType selectDictTypeById(Long dictId) {
|
return getById(dictId);
|
}
|
|
@Override
|
public SysDictType selectDictTypeByType(String dictType) {
|
return baseMapper.selectDictTypeByType(dictType);
|
}
|
|
@Override
|
public void deleteDictTypeByIds(Long[] dictIds) {
|
for (Long dictId : dictIds)
|
{
|
SysDictType dictType = selectDictTypeById(dictId);
|
if (dictDataMapper.countDictDataByType(dictType.getDictType()) > 0)
|
{
|
throw new ApiException(String.format("%1$s已分配,不能删除", dictType.getName()));
|
}
|
removeById(dictId);
|
DictUtils.removeDictCache(dictType.getDictType());
|
}
|
}
|
|
@Override
|
public void loadingDictCache() {
|
SysDictData dictData = new SysDictData();
|
dictData.setStatus(0);
|
List<SysDictData> sysDictDataList = dictDataMapper.selectDictDataList(dictData);
|
Map<String, List<SysDictData>> dictDataMap = sysDictDataList.stream().collect(Collectors.groupingBy(SysDictData::getDictType));
|
for (Map.Entry<String, List<SysDictData>> entry : dictDataMap.entrySet())
|
{
|
DictUtils.setDictCache(entry.getKey(), entry.getValue().stream().sorted(Comparator.comparing(SysDictData::getSort)).collect(Collectors.toList()));
|
}
|
}
|
|
@Override
|
public void clearDictCache() {
|
DictUtils.clearDictCache();
|
}
|
|
@Override
|
public void resetDictCache() {
|
clearDictCache();
|
loadingDictCache();
|
}
|
|
@Override
|
public int insertDictType(SysDictType dict) {
|
if(!checkDictTypeUnique(dict)){
|
throw new ApiException("新增字典类型已存在");
|
}
|
dict.setCreateBy(SecurityUtils.getUsername());
|
int row = baseMapper.insert(dict);
|
if (row > 0)
|
{
|
DictUtils.setDictCache(dict.getDictType(), null);
|
}
|
return row;
|
}
|
|
@Override
|
public int updateDictType(SysDictType dict) {
|
if(!checkDictTypeUnique(dict)){
|
throw new ApiException("新增字典类型已存在");
|
}
|
SysDictType oldDict = selectDictTypeById(dict.getId());
|
dictDataMapper.updateDictDataType(oldDict.getDictType(), dict.getDictType());
|
dict.setUpdateBy(SecurityUtils.getUsername());
|
int row = baseMapper.updateById(dict);
|
if (row > 0)
|
{
|
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dict.getDictType());
|
DictUtils.setDictCache(dict.getDictType(), dictDatas);
|
}
|
return row;
|
}
|
|
@Override
|
public boolean checkDictTypeUnique(SysDictType dict) {
|
Long dictId =dict.getId()==null ? -1L : dict.getId();
|
SysDictType dictType = baseMapper.checkDictTypeUnique(dict.getDictType());
|
if (!Objects.isNull(dictType) && dictType.getId().longValue() != dictId.longValue())
|
{
|
return UserConstant.NOT_UNIQUE;
|
}
|
return UserConstant.UNIQUE;
|
}
|
}
|
