package com.ruoyi.system.service.impl;
|
|
import cn.hutool.core.bean.BeanUtil;
|
import cn.hutool.core.collection.CollUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.common.exception.ServiceException;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.system.dto.asset.AssetTypeDTO;
|
import com.ruoyi.system.mapper.AssetTypeMapper;
|
import com.ruoyi.system.model.AssetMain;
|
import com.ruoyi.system.model.AssetType;
|
import com.ruoyi.system.service.AssetMainService;
|
import com.ruoyi.system.service.AssetTypeService;
|
import com.ruoyi.system.vo.asset.AssetTypeTreeVO;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.stream.Collectors;
|
|
/**
|
* <p>
|
* 资产类型表 服务实现类
|
* </p>
|
*
|
* @author WuGuanFengYue
|
* @since 2025-09-15
|
*/
|
@Service
|
@RequiredArgsConstructor
|
public class AssetTypeServiceImpl extends ServiceImpl<AssetTypeMapper, AssetType> implements AssetTypeService {
|
|
private final AssetMainService assetMainService;
|
|
@Override
|
public List<AssetTypeTreeVO> getAssetTypeTree() {
|
// 查询所有未删除的资产类型数据
|
LambdaQueryWrapper<AssetType> queryWrapper = new LambdaQueryWrapper<>();
|
queryWrapper.orderByAsc(AssetType::getLevel)
|
.orderByAsc(AssetType::getId);
|
|
List<AssetType> allAssetTypes = this.list(queryWrapper);
|
|
if (CollUtil.isEmpty(allAssetTypes)) {
|
return new ArrayList<>();
|
}
|
|
// 转换为VO对象
|
List<AssetTypeTreeVO> assetTypeVOs = BeanUtil.copyToList(allAssetTypes, AssetTypeTreeVO.class);
|
|
// 按父级ID分组
|
Map<Integer, List<AssetTypeTreeVO>> parentIdMap = assetTypeVOs.stream()
|
.collect(Collectors.groupingBy(AssetTypeTreeVO::getParentId));
|
|
// 构建树形结构
|
List<AssetTypeTreeVO> rootNodes = parentIdMap.get(0);
|
if (CollUtil.isEmpty(rootNodes)) {
|
return new ArrayList<>();
|
}
|
|
// 为每个根节点设置子节点
|
for (AssetTypeTreeVO rootNode : rootNodes) {
|
List<AssetTypeTreeVO> children = parentIdMap.get(rootNode.getId());
|
rootNode.setChildren(children != null ? children : new ArrayList<>());
|
}
|
|
return rootNodes;
|
}
|
|
@Override
|
public void addAssetType(AssetTypeDTO dto) {
|
// 校验资产类型名称是否重复
|
LambdaQueryWrapper<AssetType> nameQueryWrapper = new LambdaQueryWrapper<>();
|
nameQueryWrapper.eq(AssetType::getTypeName, dto.getTypeName());
|
AssetType existingByName = this.getOne(nameQueryWrapper);
|
if (Objects.nonNull(existingByName)) {
|
throw new ServiceException("资产类型名称已存在");
|
}
|
|
// 校验资产简写是否重复
|
LambdaQueryWrapper<AssetType> codeQueryWrapper = new LambdaQueryWrapper<>();
|
codeQueryWrapper.eq(AssetType::getTypeCode, dto.getTypeCode());
|
AssetType existingByCode = this.getOne(codeQueryWrapper);
|
if (Objects.nonNull(existingByCode)) {
|
throw new ServiceException("资产类型简写已存在");
|
}
|
|
// 创建资产类型对象
|
AssetType assetType = new AssetType();
|
assetType.setTypeName(dto.getTypeName());
|
assetType.setTypeCode(dto.getTypeCode());
|
|
// 处理层级逻辑
|
if (Objects.isNull(dto.getParentId()) || dto.getParentId().equals(0)) {
|
// 添加一级资产类型
|
assetType.setParentId(0);
|
assetType.setLevel(1);
|
} else {
|
// 添加二级资产类型，先校验父级是否存在
|
AssetType parentAssetType = this.getById(dto.getParentId());
|
if (Objects.isNull(parentAssetType)) {
|
throw new ServiceException("父级资产类型不存在");
|
}
|
if (!parentAssetType.getLevel().equals(1)) {
|
throw new ServiceException("只能在一级资产类型下添加二级资产类型");
|
}
|
assetType.setParentId(dto.getParentId());
|
assetType.setLevel(2);
|
}
|
|
// 设置创建信息
|
String username = SecurityUtils.getUsername();
|
assetType.setCreateBy(username);
|
|
// 保存资产类型
|
this.save(assetType);
|
}
|
|
@Override
|
public void editAssetType(AssetTypeDTO dto) {
|
// 校验资产类型ID是否为空
|
if (Objects.isNull(dto.getId())) {
|
throw new ServiceException("资产类型ID不能为空");
|
}
|
|
// 校验资产类型是否存在
|
AssetType existingAssetType = this.getById(dto.getId());
|
if (Objects.isNull(existingAssetType)) {
|
throw new ServiceException("资产类型不存在");
|
}
|
|
// 校验是否有关联的资产记录
|
LambdaQueryWrapper<AssetMain> assetMainQueryWrapper = new LambdaQueryWrapper<>();
|
assetMainQueryWrapper.eq(AssetMain::getAssetTypeId, dto.getId());
|
long assetMainCount = assetMainService.count(assetMainQueryWrapper);
|
if (assetMainCount > 0) {
|
throw new ServiceException("该资产类型已关联资产记录，不能编辑");
|
}
|
|
// 校验资产类型名称是否重复（排除自身）
|
LambdaQueryWrapper<AssetType> nameQueryWrapper = new LambdaQueryWrapper<>();
|
nameQueryWrapper.eq(AssetType::getTypeName, dto.getTypeName())
|
.ne(AssetType::getId, dto.getId());
|
AssetType existingByName = this.getOne(nameQueryWrapper);
|
if (Objects.nonNull(existingByName)) {
|
throw new ServiceException("资产类型名称已存在");
|
}
|
|
// 校验资产简写是否重复（排除自身）
|
LambdaQueryWrapper<AssetType> codeQueryWrapper = new LambdaQueryWrapper<>();
|
codeQueryWrapper.eq(AssetType::getTypeCode, dto.getTypeCode())
|
.ne(AssetType::getId, dto.getId());
|
AssetType existingByCode = this.getOne(codeQueryWrapper);
|
if (Objects.nonNull(existingByCode)) {
|
throw new ServiceException("资产简写已存在");
|
}
|
|
// 更新资产类型信息
|
AssetType assetType = new AssetType();
|
assetType.setId(dto.getId());
|
assetType.setTypeName(dto.getTypeName());
|
assetType.setTypeCode(dto.getTypeCode());
|
|
// 设置更新信息
|
String username = SecurityUtils.getUsername();
|
assetType.setUpdateBy(username);
|
|
// 更新资产类型
|
this.updateById(assetType);
|
}
|
|
@Override
|
public void deleteAssetType(Integer id) {
|
// 校验资产类型ID是否为空
|
if (Objects.isNull(id)) {
|
throw new ServiceException("资产类型ID不能为空");
|
}
|
|
// 校验资产类型是否存在
|
AssetType existingAssetType = this.getById(id);
|
if (Objects.isNull(existingAssetType)) {
|
throw new ServiceException("资产类型不存在");
|
}
|
|
// 校验是否有子类型
|
LambdaQueryWrapper<AssetType> childQueryWrapper = new LambdaQueryWrapper<>();
|
childQueryWrapper.eq(AssetType::getParentId, id);
|
long childCount = this.count(childQueryWrapper);
|
if (childCount > 0) {
|
throw new ServiceException(String.format("【%s】存在子类型，不能删除", existingAssetType.getTypeName()));
|
}
|
|
// 校验是否有关联的资产记录
|
LambdaQueryWrapper<AssetMain> assetMainQueryWrapper = new LambdaQueryWrapper<>();
|
assetMainQueryWrapper.eq(AssetMain::getAssetTypeId, id);
|
long assetMainCount = assetMainService.count(assetMainQueryWrapper);
|
if (assetMainCount > 0) {
|
throw new ServiceException(String.format("【%s】已关联资产记录，不能删除", existingAssetType.getTypeName()));
|
}
|
|
// 删除资产类型
|
this.removeById(id);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void batchDeleteAssetType(List<Integer> ids) {
|
// 校验ID列表是否为空
|
if (CollUtil.isEmpty(ids)) {
|
throw new ServiceException("删除的资产类型ID列表不能为空");
|
}
|
|
// 收集删除失败的信息
|
List<String> failedMessages = new ArrayList<>();
|
|
// 逐个删除资产类型
|
for (Integer id : ids) {
|
try {
|
this.deleteAssetType(id);
|
} catch (ServiceException e) {
|
failedMessages.add(e.getMessage());
|
}
|
}
|
|
// 如果有删除失败的情况，抛出异常
|
if (CollUtil.isNotEmpty(failedMessages)) {
|
throw new ServiceException("批量删除失败：" + String.join("；", failedMessages));
|
}
|
}
|
|
}
|
