package com.ruoyi.project.system.dict.service;
|
|
import java.util.ArrayList;
|
import java.util.List;
|
import javax.annotation.PostConstruct;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import com.ruoyi.common.constant.UserConstants;
|
import com.ruoyi.common.exception.BusinessException;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.common.utils.security.ShiroUtils;
|
import com.ruoyi.common.utils.text.Convert;
|
import com.ruoyi.framework.web.domain.Ztree;
|
import com.ruoyi.project.system.dict.domain.DictData;
|
import com.ruoyi.project.system.dict.domain.DictType;
|
import com.ruoyi.project.system.dict.mapper.DictDataMapper;
|
import com.ruoyi.project.system.dict.mapper.DictTypeMapper;
|
import com.ruoyi.project.system.dict.utils.DictUtils;
|
|
/**
|
* 字典 业务层处理
|
*
|
* @author ruoyi
|
*/
|
@Service
|
public class DictTypeServiceImpl implements IDictTypeService
|
{
|
@Autowired
|
private DictTypeMapper dictTypeMapper;
|
|
@Autowired
|
private DictDataMapper dictDataMapper;
|
|
/**
|
* 项目启动时，初始化字典到缓存
|
*/
|
@PostConstruct
|
public void init()
|
{
|
List<DictType> dictTypeList = dictTypeMapper.selectDictTypeAll();
|
for (DictType dictType : dictTypeList)
|
{
|
List<DictData> dictDatas = dictDataMapper.selectDictDataByType(dictType.getDictType());
|
DictUtils.setDictCache(dictType.getDictType(), dictDatas);
|
}
|
}
|
|
/**
|
* 根据条件分页查询字典类型
|
*
|
* @param dictType 字典类型信息
|
* @return 字典类型集合信息
|
*/
|
@Override
|
public List<DictType> selectDictTypeList(DictType dictType)
|
{
|
return dictTypeMapper.selectDictTypeList(dictType);
|
}
|
|
/**
|
* 根据所有字典类型
|
*
|
* @return 字典类型集合信息
|
*/
|
@Override
|
public List<DictType> selectDictTypeAll()
|
{
|
return dictTypeMapper.selectDictTypeAll();
|
}
|
|
/**
|
* 根据字典类型查询字典数据
|
*
|
* @param dictType 字典类型
|
* @return 字典数据集合信息
|
*/
|
@Override
|
public List<DictData> selectDictDataByType(String dictType)
|
{
|
List<DictData> dictDatas = DictUtils.getDictCache(dictType);
|
if (StringUtils.isNotNull(dictDatas))
|
{
|
return dictDatas;
|
}
|
dictDatas = dictDataMapper.selectDictDataByType(dictType);
|
if (StringUtils.isNotNull(dictDatas))
|
{
|
DictUtils.setDictCache(dictType, dictDatas);
|
return dictDatas;
|
}
|
return null;
|
}
|
|
/**
|
* 根据字典类型ID查询信息
|
*
|
* @param dictId 字典类型ID
|
* @return 字典类型
|
*/
|
@Override
|
public DictType selectDictTypeById(Long dictId)
|
{
|
return dictTypeMapper.selectDictTypeById(dictId);
|
}
|
|
/**
|
* 根据字典类型查询信息
|
*
|
* @param dictType 字典类型
|
* @return 字典类型
|
*/
|
@Override
|
public DictType selectDictTypeByType(String dictType)
|
{
|
return dictTypeMapper.selectDictTypeByType(dictType);
|
}
|
|
/**
|
* 批量删除字典类型
|
*
|
* @param ids 需要删除的数据
|
* @return 结果
|
*/
|
@Override
|
public int deleteDictTypeByIds(String ids)
|
{
|
Long[] dictIds = Convert.toLongArray(ids);
|
for (Long dictId : dictIds)
|
{
|
DictType dictType = selectDictTypeById(dictId);
|
if (dictDataMapper.countDictDataByType(dictType.getDictType()) > 0)
|
{
|
throw new BusinessException(String.format("%1$s已分配,不能删除", dictType.getDictName()));
|
}
|
}
|
int count = dictTypeMapper.deleteDictTypeByIds(dictIds);
|
if (count > 0)
|
{
|
DictUtils.clearDictCache();
|
}
|
return count;
|
}
|
|
/**
|
* 清空缓存数据
|
*/
|
@Override
|
public void clearCache()
|
{
|
DictUtils.clearDictCache();
|
}
|
|
/**
|
* 新增保存字典类型信息
|
*
|
* @param dictType 字典类型信息
|
* @return 结果
|
*/
|
@Override
|
public int insertDictType(DictType dictType)
|
{
|
dictType.setCreateBy(ShiroUtils.getLoginName());
|
int row = dictTypeMapper.insertDictType(dictType);
|
if (row > 0)
|
{
|
DictUtils.clearDictCache();
|
}
|
return row;
|
}
|
|
/**
|
* 修改保存字典类型信息
|
*
|
* @param dictType 字典类型信息
|
* @return 结果
|
*/
|
@Override
|
@Transactional
|
public int updateDictType(DictType dictType)
|
{
|
dictType.setUpdateBy(ShiroUtils.getLoginName());
|
DictType oldDict = dictTypeMapper.selectDictTypeById(dictType.getDictId());
|
dictDataMapper.updateDictDataType(oldDict.getDictType(), dictType.getDictType());
|
int row = dictTypeMapper.updateDictType(dictType);
|
if (row > 0)
|
{
|
DictUtils.clearDictCache();
|
}
|
return row;
|
}
|
|
/**
|
* 校验字典类型称是否唯一
|
*
|
* @param dict 字典类型
|
* @return 结果
|
*/
|
@Override
|
public String checkDictTypeUnique(DictType dict)
|
{
|
Long dictId = StringUtils.isNull(dict.getDictId()) ? -1L : dict.getDictId();
|
DictType dictType = dictTypeMapper.checkDictTypeUnique(dict.getDictType());
|
if (StringUtils.isNotNull(dictType) && dictType.getDictId().longValue() != dictId.longValue())
|
{
|
return UserConstants.DICT_TYPE_NOT_UNIQUE;
|
}
|
return UserConstants.DICT_TYPE_UNIQUE;
|
}
|
|
/**
|
* 查询字典类型树
|
*
|
* @param dictType 字典类型
|
* @return 所有字典类型
|
*/
|
@Override
|
public List<Ztree> selectDictTree(DictType dictType)
|
{
|
List<Ztree> ztrees = new ArrayList<Ztree>();
|
List<DictType> dictList = dictTypeMapper.selectDictTypeList(dictType);
|
for (DictType dict : dictList)
|
{
|
if (UserConstants.DICT_NORMAL.equals(dict.getStatus()))
|
{
|
Ztree ztree = new Ztree();
|
ztree.setId(dict.getDictId());
|
ztree.setName(transDictName(dict));
|
ztree.setTitle(dict.getDictType());
|
ztrees.add(ztree);
|
}
|
}
|
return ztrees;
|
}
|
|
public String transDictName(DictType dictType)
|
{
|
StringBuffer sb = new StringBuffer();
|
sb.append("(" + dictType.getDictName() + ")");
|
sb.append(" " + dictType.getDictType());
|
return sb.toString();
|
}
|
}
|
