代码提交

无关风月

1 天以前 6999d4114eb6d64d0775e2f9ff00572b0e60ee31

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

@@ -3,24 +3,39 @@
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.basic.PageInfo;
import com.ruoyi.common.core.domain.entity.TDept;
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.AssetInventoryRecord;
import com.ruoyi.system.model.AssetMain;
import com.ruoyi.system.model.AssetType;
import com.ruoyi.system.query.AssetInventoryListQuery;
import com.ruoyi.system.query.AssetStatisticsListDetailQuery;
import com.ruoyi.system.query.AssetStatisticsListQuery;
import com.ruoyi.system.service.AssetInventoryRecordService;
import com.ruoyi.system.service.AssetMainService;
import com.ruoyi.system.service.AssetTypeService;
import com.ruoyi.system.vo.AssetInventoryVO;
import com.ruoyi.system.vo.AssetStatisticsDetailVO;
import com.ruoyi.system.vo.AssetStatisticsVO;
import com.ruoyi.system.vo.asset.AssetTypeTreeVO;
import com.ruoyi.system.vo.system.NotificationVO;
import io.swagger.annotations.ApiModelProperty;
import io.swagger.models.auth.In;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.stream.Collectors;

/**
@@ -32,10 +47,12 @@
 * @since 2025-09-15
 */
@Service
@RequiredArgsConstructor
@RequiredArgsConstructor(onConstructor_ = {@Lazy})
public class AssetTypeServiceImpl extends ServiceImpl<AssetTypeMapper, AssetType> implements AssetTypeService {

    private final AssetMainService assetMainService;
    private final AssetTypeService assetTypeService;
    private final AssetInventoryRecordService assetInventoryRecordService;

    @Override
    public List<AssetTypeTreeVO> getAssetTypeTree() {
@@ -53,10 +70,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)) {
@@ -263,4 +301,194 @@
        return parentTypeCode + subTypeCode;
    }

    @Override
    public PageInfo<AssetStatisticsVO> pageList(AssetStatisticsListQuery query) {
        if (StringUtils.hasLength(query.getNameOrCode())){
            // 查询出资产名称或者资产编号符合条件的code
            List<Integer> assetTypeIds = assetMainService.lambdaQuery().like(AssetMain::getAssetName, query.getNameOrCode())
                    .or()
                    .like(AssetMain::getAssetCode, query.getNameOrCode())
                    .list()
                    .stream()
                    .map(AssetMain::getAssetTypeId)
                    .collect(Collectors.toList());
            query.setAssetMainIds(assetTypeIds);
            if (assetTypeIds.isEmpty()){
                return new PageInfo<>();
            }
        }
        PageInfo<AssetStatisticsVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
        List<AssetStatisticsVO> list = this.baseMapper.pageList(query,pageInfo);
        List<AssetStatisticsVO> listNoLimit = this.baseMapper.pageListNoLimit(query);
        List<Integer> assetTypeIds = listNoLimit.stream().map(AssetStatisticsVO::getAssetTypeIdSecond).collect(Collectors.toList());
        if (assetTypeIds.isEmpty()){
            return new PageInfo<>();
        }
        Map<Integer, List<AssetMain>> assetMainMap = assetMainService.lambdaQuery()
                .in(!query.getDeptIds().isEmpty(),AssetMain::getOwnershipDeptId, query.getDeptIds())
                .in(AssetMain::getAssetTypeId, assetTypeIds).list()
                .stream()
                .collect(Collectors.groupingBy(AssetMain::getAssetTypeId));
        for (AssetStatisticsVO asset : list) {
            Integer totalCount= 0;
            Integer idleCount= 0;
            Integer useCount= 0;
            Integer disposeCount= 0;
            Integer otherCount= 0;
            BigDecimal totalValue = new BigDecimal("0");
            List<AssetMain> assetMains = assetMainMap.get(asset.getAssetTypeIdSecond());
            if (!assetMains.isEmpty()){
                for (AssetMain assetMain : assetMains) {
                    if (assetMain.getAssetStatus().contains("闲置")){
                        idleCount += assetMain.getQuantity();
                    }else if (assetMain.getAssetStatus().contains("使用中")){
                        useCount += assetMain.getQuantity();
                    }else if (assetMain.getAssetStatus().contains("损坏") || assetMain.getAssetStatus().contains("报废")){
                        disposeCount += assetMain.getQuantity();
                    }else{
                        otherCount += assetMain.getQuantity();
                    }
                    totalCount+= assetMain.getQuantity();
                    totalValue = totalValue.add(new BigDecimal(assetMain.getQuantity())
                            .multiply(assetMain.getUnitPrice()).setScale(2, RoundingMode.HALF_DOWN));
                }
            }
            asset.setIdleCount(idleCount);
            asset.setUseCount(useCount);
            asset.setDisposeCount(disposeCount);
            asset.setOtherCount(otherCount);
            asset.setTotalCount(totalCount);
            asset.setTotalValue(totalValue);
        }
        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public PageInfo<AssetStatisticsDetailVO> pageListDetail(AssetStatisticsListDetailQuery query) {
        String assetTypeName = null;
        AssetType assetType = assetTypeService.getById(query.getAssetTypeIdSecond());
        if (assetType!=null){
            AssetType assetTypeParent = assetTypeService.getById(assetType.getParentId());
            if (assetTypeParent!=null){
                assetTypeName = assetTypeParent.getTypeName()+">"+assetType.getTypeName();
            }
        }

        if (StringUtils.hasLength(query.getNameOrCode())){
            // 查询出资产名称或者资产编号符合条件的code
            List<Integer> assetTypeIds = assetMainService.lambdaQuery().like(AssetMain::getAssetName, query.getNameOrCode())
                    .or()
                    .like(AssetMain::getAssetCode, query.getNameOrCode())
                    .list()
                    .stream()
                    .map(AssetMain::getAssetTypeId)
                    .collect(Collectors.toList());
            query.setAssetMainIds(assetTypeIds);
            if (assetTypeIds.isEmpty()){
                return new PageInfo<>();
            }
        }
        PageInfo<AssetStatisticsDetailVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
        List<AssetStatisticsDetailVO> list = this.baseMapper.pageListDetail(query,pageInfo);
        for (AssetStatisticsDetailVO assetStatisticsDetailVO : list) {
            assetStatisticsDetailVO.setAssetTypeName(assetTypeName);
        }
        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public PageInfo<AssetInventoryVO> pageListInventory(AssetInventoryListQuery query) {
        AssetType assetType = this.baseMapper.selectById(query.getAssetTypeId());
        if (assetType.getParentId()==0){
            List<Integer> assetTypeChild = this.baseMapper.selectList(new LambdaQueryWrapper<AssetType>()
                            .eq(AssetType::getParentId, assetType.getId())).stream().map(AssetType::getId)
                    .collect(Collectors.toList());
            List<Integer> list = new ArrayList<>(assetTypeChild);
            list.add(assetType.getId());
            query.setAssetTypeIds( list);
        }else{
            query.setAssetTypeIds(Collections.singletonList(assetType.getId()));
        }
        PageInfo<AssetInventoryVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
        List<AssetInventoryVO> list = this.baseMapper.pageListInventory(query,pageInfo);
        Map<Integer, List<AssetMain>> assetMainMap = assetMainService.lambdaQuery().in(AssetMain::getId, query.getAssetMainIds()).list()
                .stream().collect(Collectors.groupingBy(AssetMain::getAssetTypeId));
        List<AssetInventoryRecord> assetInventoryRecords = assetInventoryRecordService.lambdaQuery().in(AssetInventoryRecord::getAssetMainId, query.getAssetMainIds()).list();
        for (AssetInventoryVO assetInventoryVO : list) {
            int inCount = 0;
            int outCount = 0;
            int inStockCount = 0;

            BigDecimal inStockMoney = new BigDecimal("0");
            BigDecimal inMoney = new BigDecimal("0");
            BigDecimal outMoney = new BigDecimal("0");
            List<AssetMain> assetMains = assetMainMap.get(assetInventoryVO.getAssetTypeIdSecond());
            for (AssetInventoryRecord assetInventoryRecord : assetInventoryRecords) {
                if (assetInventoryRecord.getType()==0){
                    AssetMain assetMain = assetMains.stream().filter(e -> e.getId().equals(assetInventoryRecord.getAssetMainId()))
                            .findFirst().orElse(null);
                    if (assetMain!=null){
                        inCount+=assetMain.getQuantity();
                        inMoney = inMoney.add(new BigDecimal(assetMain.getQuantity())
                                .multiply(assetMain.getUnitPrice()).setScale(2, RoundingMode.HALF_DOWN));
                    }
                }else{
                    AssetMain assetMain = assetMains.stream().filter(e -> e.getId().equals(assetInventoryRecord.getAssetMainId()))
                            .findFirst().orElse(null);
                    if (assetMain!=null){
                        outCount+=assetMain.getQuantity();
                        outMoney = outMoney.add(new BigDecimal(assetMain.getQuantity())
                                .multiply(assetMain.getUnitPrice()).setScale(2, RoundingMode.HALF_DOWN));
                    }
                }
            }
            assetInventoryVO.setInCount(inCount);
            assetInventoryVO.setOutCount(outCount);
            assetInventoryVO.setInMoney(inMoney);
            assetInventoryVO.setOutMoney(outMoney);
            List<AssetMain> inStorage = assetMains.stream().filter(e -> e.getDisposed() == 0 && e.getInUse() == 0 && e.getBorrowed() == 0).collect(Collectors.toList());
            for (AssetMain assetMain : inStorage) {
                inStockCount+=assetMain.getQuantity();
                inStockMoney = inStockMoney.add(new BigDecimal(assetMain.getQuantity())
                        .multiply(assetMain.getUnitPrice()).setScale(2, RoundingMode.HALF_DOWN));
            }
            assetInventoryVO.setInStockCount(inStockCount);
            assetInventoryVO.setInStockMoney(inStockMoney);
        }
        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public PageInfo<AssetStatisticsDetailVO> pageListInventoryDetail(AssetStatisticsListDetailQuery query) {
        PageInfo<AssetStatisticsDetailVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
        List<AssetStatisticsDetailVO> list = this.baseMapper.pageListInventoryDetail(query,pageInfo);
        List<AssetType> assetTypes = assetTypeService.list();
        for (AssetStatisticsDetailVO assetStatisticsDetailVO : list) {
            Integer type = assetStatisticsDetailVO.getType();
            if (type==0){
                String typeName = "入库";

                AssetType assetType = assetTypes.stream().filter(e -> e.getId().equals(assetStatisticsDetailVO.getAssetTypeId()))
                        .findFirst().orElse(null);
                if (assetType!=null){
                    typeName =typeName+"("+assetType.getTypeName()+")";
                }
                assetStatisticsDetailVO.setTypeName(typeName);
            }else{
                String typeName = "出库";
                AssetType assetType = assetTypes.stream().filter(e -> e.getId().equals(assetStatisticsDetailVO.getAssetTypeId()))
                        .findFirst().orElse(null);
                if (assetType!=null){
                    typeName =typeName+"("+assetType.getTypeName()+")";
                }
                assetStatisticsDetailVO.setTypeName(typeName);
            }
        }
        pageInfo.setRecords(list);
        return pageInfo;
    }

}