资产管理-仓库管理接口 资产管理-资产类型接口

mitao

2 天以前 6bdff06fadea15ab3b4e70c25a7cb4c73e5a64fc

 ruoyi-system/src/main/java/com/ruoyi/system/service/impl/AssetTypeServiceImpl.java

@@ -1,10 +1,26 @@
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 java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * <p>
@@ -15,6 +31,179 @@
 * @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("该资产类型存在子类型，不能删除");
        }

        // 校验是否有关联的资产记录
        LambdaQueryWrapper<AssetMain> assetMainQueryWrapper = new LambdaQueryWrapper<>();
        assetMainQueryWrapper.eq(AssetMain::getAssetTypeId, id);
        long assetMainCount = assetMainService.count(assetMainQueryWrapper);
        if (assetMainCount > 0) {
            throw new ServiceException("该资产类型已关联资产记录，不能删除");
        }

        // 删除资产类型
        this.removeById(id);
    }

}