资产管理-资产入库列表详情、撤销接口

mitao

昨天 7c3331d7be7c10059cc82586852d562f566a5087

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

@@ -3,6 +3,7 @@
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.SecurityUtils;
@@ -15,11 +16,13 @@
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.Set;
import java.util.stream.Collectors;

/**
@@ -52,10 +55,31 @@
        // 转换为VO对象
        List<AssetTypeTreeVO> assetTypeVOs = BeanUtil.copyToList(allAssetTypes, AssetTypeTreeVO.class);
        
        // 预查询：找出存在资产关联的资产类型ID集合（去重）
        List<Integer> allTypeIds = allAssetTypes.stream().map(AssetType::getId).collect(Collectors.toList());
        QueryWrapper<AssetMain> usedTypeQuery = new QueryWrapper<>();
        usedTypeQuery.select("distinct asset_type_id").in("asset_type_id", allTypeIds);
        List<AssetMain> usedTypeRows = assetMainService.list(usedTypeQuery);
        Set<Integer> usedTypeIdSet = usedTypeRows.stream()
                .map(AssetMain::getAssetTypeId)
                .filter(Objects::nonNull)
                .collect(Collectors.toSet());

        // 按父级ID分组
        Map<Integer, List<AssetTypeTreeVO>> parentIdMap = assetTypeVOs.stream()
                .collect(Collectors.groupingBy(AssetTypeTreeVO::getParentId));
        
        // 计算可删除标记：一级仅判断是否有子分类；二级仅判断是否有关联资产
        for (AssetTypeTreeVO vo : assetTypeVOs) {
            if (Objects.equals(vo.getLevel(), 1)) {
                boolean hasChildren = parentIdMap.containsKey(vo.getId()) && CollUtil.isNotEmpty(parentIdMap.get(vo.getId()));
                vo.setCanDelete(!hasChildren);
            } else {
                boolean hasAssets = usedTypeIdSet.contains(vo.getId());
                vo.setCanDelete(!hasAssets);
            }
        }

        // 构建树形结构
        List<AssetTypeTreeVO> rootNodes = parentIdMap.get(0);
        if (CollUtil.isEmpty(rootNodes)) {
@@ -191,7 +215,7 @@
        childQueryWrapper.eq(AssetType::getParentId, id);
        long childCount = this.count(childQueryWrapper);
        if (childCount > 0) {
            throw new ServiceException("该资产类型存在子类型，不能删除");
            throw new ServiceException(String.format("【%s】存在子类型，不能删除", existingAssetType.getTypeName()));
        }

        // 校验是否有关联的资产记录
@@ -199,11 +223,67 @@
        assetMainQueryWrapper.eq(AssetMain::getAssetTypeId, id);
        long assetMainCount = assetMainService.count(assetMainQueryWrapper);
        if (assetMainCount > 0) {
            throw new ServiceException("该资产类型已关联资产记录，不能删除");
            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));
        }
    }

    @Override
    public String getAssetCodePrefix(Integer assetTypeId) {
        if (assetTypeId == null) {
            throw new ServiceException("资产类型ID不能为空");
        }

        // 查询当前资产类型
        AssetType currentAssetType = this.getById(assetTypeId);
        if (currentAssetType == null) {
            throw new ServiceException("资产类型不存在");
        }

        String parentTypeCode = "";
        String subTypeCode = currentAssetType.getTypeCode();

        // 如果是二级分类，需要获取父级分类的简写
        if (currentAssetType.getLevel() == 2 && currentAssetType.getParentId() != null && currentAssetType.getParentId() != 0) {
            AssetType parentAssetType = this.getById(currentAssetType.getParentId());
            if (parentAssetType != null) {
                parentTypeCode = parentAssetType.getTypeCode();
            }
        } else if (currentAssetType.getLevel() == 1) {
            // 如果是一级分类，父级简写为空，子类简写就是当前类型简写
            parentTypeCode = currentAssetType.getTypeCode();
            subTypeCode = "";
        }

        return parentTypeCode + subTypeCode;
    }

}