package com.ruoyi.system.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.common.constant.CacheConstants;
|
import com.ruoyi.common.constant.ResultConstants;
|
import com.ruoyi.common.constant.UserConstants;
|
import com.ruoyi.common.core.redis.RedisCache;
|
import com.ruoyi.common.enums.coalmineEnums.DeleteStatusEnum;
|
import com.ruoyi.common.exception.BusinessException;
|
import com.ruoyi.common.exception.ServiceException;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.common.utils.spring.SpringUtils;
|
import com.ruoyi.system.domain.SysOperateType;
|
import com.ruoyi.system.domain.bo.SysOperateTypeWholeNameBO;
|
import com.ruoyi.system.domain.req.OperateTypeEditReqDTO;
|
import com.ruoyi.system.domain.req.OperateTypeListReqDTO;
|
import com.ruoyi.system.domain.req.OperateTypeAddReqDTO;
|
import com.ruoyi.system.mapper.SysOperateTypeMapper;
|
import com.ruoyi.system.mapper.SysRoleMapper;
|
import com.ruoyi.system.service.SysOperateTypeService;
|
import org.apache.ibatis.logging.Log;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.CollectionUtils;
|
|
import javax.annotation.PostConstruct;
|
import javax.annotation.Resource;
|
import java.time.LocalDateTime;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
/**
|
* @author hz
|
* @since 2023-09-07 17:10:10
|
*/
|
@Service("sysOperateTypeService")
|
public class SysOperateTypeServiceImpl extends ServiceImpl<SysOperateTypeMapper, SysOperateType> implements SysOperateTypeService {
|
|
@Autowired
|
private SysOperateTypeMapper operateTypeMapper;
|
|
@Autowired
|
private SysRoleMapper roleMapper;
|
|
@Resource
|
private RedisCache redisCache;
|
|
|
@PostConstruct
|
public void init()
|
{
|
loadingOperateTypeCache();
|
|
}
|
|
@Override
|
public void loadingOperateTypeCache() {
|
LambdaQueryWrapper<SysOperateType> wrapper = new LambdaQueryWrapper<>();
|
wrapper.eq(SysOperateType::getDelFlag, DeleteStatusEnum.NO.getStatus());
|
List<SysOperateType> sysOperateTypes = operateTypeMapper.selectList(wrapper);
|
if (!CollectionUtils.isEmpty(sysOperateTypes)){
|
Map<Long, SysOperateTypeWholeNameBO> map = new HashMap<>();
|
for (SysOperateType sysOperateType : sysOperateTypes) {
|
SysOperateTypeWholeNameBO nameBO = this.operateTypeWholeNameCacheById(sysOperateType.getId());
|
map.put(sysOperateType.getId(),nameBO);
|
}
|
SpringUtils.getBean(RedisCache.class).setCacheObject(CacheConstants.SYS_OPERATE_TYPE_NAME_KEY, map);
|
}
|
}
|
|
@Override
|
public void clearOperateTypeCache() {
|
if (SpringUtils.getBean(RedisCache.class).hasKey(CacheConstants.SYS_OPERATE_TYPE_NAME_KEY)){
|
SpringUtils.getBean(RedisCache.class).deleteObject(CacheConstants.SYS_OPERATE_TYPE_NAME_KEY);
|
}
|
}
|
|
@Override
|
public void resetOperateTypeCache() {
|
clearOperateTypeCache();
|
loadingOperateTypeCache();
|
}
|
|
/**
|
* 查询作业类型管理数据
|
*/
|
@Override
|
public List<SysOperateType> selectOperateTypeList(OperateTypeListReqDTO reqDTO) {
|
LambdaQueryWrapper<SysOperateType> wrapper = new LambdaQueryWrapper<>();
|
wrapper.eq(SysOperateType::getDelFlag, DeleteStatusEnum.NO.getStatus());
|
if (reqDTO != null && !StringUtils.isBlank(reqDTO.getName())){
|
wrapper.eq(SysOperateType::getName,reqDTO.getName());
|
}
|
return operateTypeMapper.selectList(wrapper);
|
}
|
|
///**
|
// * 查询作业类型树结构信息
|
// */
|
//@Override
|
//public List<TreeSelect> selectDeptTreeList(SysDept dept)
|
//{
|
// List<SysDept> depts = SpringUtils.getAopProxy(this).selectDeptList(dept);
|
// return buildDeptTreeSelect(depts);
|
//}
|
//
|
///**
|
// * 构建前端所需要树结构
|
// */
|
//@Override
|
//public List<SysDept> buildDeptTree(List<SysDept> depts)
|
//{
|
// List<SysDept> returnList = new ArrayList<SysDept>();
|
// List<Long> tempList = depts.stream().map(SysDept::getDeptId).collect(Collectors.toList());
|
// for (SysDept dept : depts)
|
// {
|
// // 如果是顶级节点, 遍历该父节点的所有子节点
|
// if (!tempList.contains(dept.getParentId()))
|
// {
|
// recursionFn(depts, dept);
|
// returnList.add(dept);
|
// }
|
// }
|
// if (returnList.isEmpty())
|
// {
|
// returnList = depts;
|
// }
|
// return returnList;
|
//}
|
//
|
///**
|
// * 构建前端所需要下拉树结构
|
// */
|
//@Override
|
//public List<TreeSelect> buildDeptTreeSelect(List<SysDept> depts)
|
//{
|
// List<SysDept> deptTrees = buildDeptTree(depts);
|
// return deptTrees.stream().map(TreeSelect::new).collect(Collectors.toList());
|
//}
|
//
|
///**
|
// * 根据角色ID查询作业类型树信息
|
// */
|
//@Override
|
//public List<Long> selectDeptListByRoleId(Long roleId)
|
//{
|
// SysRole role = roleMapper.selectRoleById(roleId);
|
// return operateTypeMapper.selectDeptListByRoleId(roleId, role.isDeptCheckStrictly());
|
//}
|
//
|
/**
|
* 根据作业类型ID查询信息
|
*/
|
@Override
|
public SysOperateType selectOperateTypeById(Long operateTypeId) {
|
if (operateTypeId == null)
|
throw new BusinessException(this.getClass(), ResultConstants.PARAM_ERROR);
|
return operateTypeMapper.selectOperateTypeById(operateTypeId);
|
}
|
//
|
///**
|
// * 根据ID查询所有子作业类型（正常状态）
|
// */
|
//@Override
|
//public int selectNormalChildrenDeptById(Long deptId)
|
//{
|
// return operateTypeMapper.selectNormalChildrenDeptById(deptId);
|
//}
|
//
|
/**
|
* 是否存在子节点
|
*/
|
@Override
|
public boolean hasChildByOperateTypeId(Long id)
|
{
|
int result = operateTypeMapper.hasChildByOperateTypeId(id);
|
return result > 0;
|
}
|
//
|
///**
|
// * 查询作业类型是否存在用户
|
// */
|
//@Override
|
//public boolean checkDeptExistUser(Long deptId)
|
//{
|
// int result = operateTypeMapper.checkDeptExistUser(deptId);
|
// return result > 0;
|
//}
|
//
|
/**
|
* 校验作业类型名称是否唯一
|
*/
|
@Override
|
public boolean checkOperateTypeNameUnique(String name,Long parentId) {
|
if (StringUtils.isBlank(name) || StringUtils.isNull(parentId))
|
throw new BusinessException(this.getClass(),ResultConstants.PARAM_ERROR);
|
LambdaQueryWrapper<SysOperateType> wrapper = new LambdaQueryWrapper<>();
|
wrapper.eq(SysOperateType::getDelFlag,DeleteStatusEnum.NO.getStatus())
|
.eq(SysOperateType::getName,name)
|
.eq(SysOperateType::getParentId,parentId)
|
.last(" limit 1");
|
SysOperateType sysOperateType = operateTypeMapper.selectOne(wrapper);
|
if (StringUtils.isNotNull(sysOperateType))
|
{
|
return UserConstants.NOT_UNIQUE;
|
}
|
return UserConstants.UNIQUE;
|
}
|
|
/**
|
* 新增保存作业类型信息
|
*/
|
@Override
|
public int insertOperateType(OperateTypeAddReqDTO type) {
|
SysOperateType operateType = new SysOperateType();
|
BeanUtils.copyProperties(type,operateType);
|
if (type.getParentId() != 0) {
|
SysOperateType info = operateTypeMapper.selectOperateTypeById(type.getParentId());
|
// 如果父节点不为正常状态,则不允许新增子节点
|
if (info == null) {
|
throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL, "作业类型不存在，不允许新增");
|
}
|
operateType.setAncestors(info.getAncestors() + "," + type.getParentId());
|
int length = getOperateTypeValue(operateType.getAncestors()).length;
|
operateType.setType(length);
|
}else {
|
operateType.setAncestors("0");
|
operateType.setType(1);
|
}
|
resetOperateTypeCache();
|
return operateTypeMapper.insert(operateType);
|
}
|
|
private String[] getOperateTypeValue(String ancestors) {
|
String[] arr = ancestors.split(",");
|
return arr;
|
}
|
|
/**
|
* 修改保存作业类型信息
|
*/
|
@Override
|
public int updateOperateType(OperateTypeEditReqDTO reqDTO)
|
{
|
SysOperateType newParentOperateType = operateTypeMapper.selectOperateTypeById(reqDTO.getParentId());
|
SysOperateType oldOperateType = operateTypeMapper.selectOperateTypeById(reqDTO.getId());
|
if ((StringUtils.isNotNull(newParentOperateType) || reqDTO.getParentId() == 0) && StringUtils.isNotNull(oldOperateType))
|
{
|
String newAncestors;
|
if (reqDTO.getParentId() == 0){
|
newAncestors = "0";
|
}else {
|
newAncestors = newParentOperateType.getAncestors() + "," + newParentOperateType.getId();
|
}
|
String oldAncestors = oldOperateType.getAncestors();
|
BeanUtils.copyProperties(reqDTO,oldOperateType);
|
oldOperateType.setAncestors(newAncestors);
|
updateOperateTypeChildren(reqDTO.getId(), newAncestors, oldAncestors);
|
}
|
int result = operateTypeMapper.updateById(oldOperateType);
|
resetOperateTypeCache();
|
return result;
|
}
|
//
|
///**
|
// * 修改该作业类型的父级作业类型状态
|
// *
|
// * @param dept 当前作业类型
|
// */
|
//private void updateParentDeptStatusNormal(SysDept dept)
|
//{
|
// String ancestors = dept.getAncestors();
|
// Long[] deptIds = Convert.toLongArray(ancestors);
|
// operateTypeMapper.updateDeptStatusNormal(deptIds);
|
//}
|
//
|
/**
|
* 修改子元素关系
|
*/
|
public void updateOperateTypeChildren(Long OperateTypeId, String newAncestors, String oldAncestors)
|
{
|
List<SysOperateType> children = operateTypeMapper.selectChildrenOperateTypeById(OperateTypeId);
|
for (SysOperateType child : children)
|
{
|
child.setAncestors(child.getAncestors().replaceFirst(oldAncestors, newAncestors));
|
}
|
if (children.size() > 0)
|
{
|
operateTypeMapper.updateOperateTypeChildren(children);
|
}
|
}
|
|
/**
|
* 删除作业类型管理信息
|
*/
|
@Override
|
public int deleteOperateTypeById(Long id)
|
{
|
SysOperateType sysOperateType = operateTypeMapper.selectOperateTypeById(id);
|
if (sysOperateType == null)
|
return 1;
|
sysOperateType.setDelFlag(DeleteStatusEnum.YES.getStatus());
|
resetOperateTypeCache();
|
return this.operateTypeMapper.updateById(sysOperateType);
|
}
|
|
private SysOperateTypeWholeNameBO operateTypeWholeNameCacheById(Long id){
|
SysOperateType sysOperateType = operateTypeMapper.selectOperateTypeById(id);
|
if (sysOperateType == null)
|
return null;
|
Integer type = sysOperateType.getType();
|
SysOperateTypeWholeNameBO bo = new SysOperateTypeWholeNameBO();
|
bo.setType(sysOperateType.getType());
|
if (type == 1) {
|
bo.setQualificationType(sysOperateType.getName());
|
return bo;
|
}
|
String[] value = getOperateTypeValue(sysOperateType.getAncestors());
|
List<Long> list = new ArrayList<>();
|
for (int i = 0; i < value.length; i++) {
|
if (i>0){
|
list.add(Long.valueOf(value[i]));
|
}
|
}
|
list.add(id);
|
List<SysOperateType> sysOperateTypes = operateTypeMapper.selectOperateTypeByIds(list);
|
for (SysOperateType operateType : sysOperateTypes) {
|
if (operateType.getType() == 1)
|
bo.setQualificationType(operateType.getName());
|
if (operateType.getType() == 2)
|
bo.setJobCategory(operateType.getName());
|
if (operateType.getType() == 3)
|
bo.setOperationItems(operateType.getName());
|
}
|
return bo;
|
}
|
|
@Override
|
public SysOperateTypeWholeNameBO getOperateTypeWholeNameById(Long id) {
|
Map<Long, SysOperateTypeWholeNameBO> map = redisCache.getCacheObject(CacheConstants.SYS_OPERATE_TYPE_NAME_KEY);
|
if (map != null){
|
return map.get(id);
|
}
|
return null;
|
}
|
//
|
///**
|
// * 递归列表
|
// */
|
//private void recursionFn(List<SysDept> list, SysDept t)
|
//{
|
// // 得到子节点列表
|
// List<SysDept> childList = getChildList(list, t);
|
// t.setChildren(childList);
|
// for (SysDept tChild : childList)
|
// {
|
// if (hasChild(list, tChild))
|
// {
|
// recursionFn(list, tChild);
|
// }
|
// }
|
//}
|
//
|
///**
|
// * 得到子节点列表
|
// */
|
//private List<SysDept> getChildList(List<SysDept> list, SysDept t)
|
//{
|
// List<SysDept> tlist = new ArrayList<SysDept>();
|
// Iterator<SysDept> it = list.iterator();
|
// while (it.hasNext())
|
// {
|
// SysDept n = (SysDept) it.next();
|
// if (StringUtils.isNotNull(n.getParentId()) && n.getParentId().longValue() == t.getDeptId().longValue())
|
// {
|
// tlist.add(n);
|
// }
|
// }
|
// return tlist;
|
//}
|
//
|
///**
|
// * 判断是否有子节点
|
// */
|
//private boolean hasChild(List<SysDept> list, SysDept t)
|
//{
|
// return getChildList(list, t).size() > 0;
|
//}
|
|
}
|
