liding
5 天以前 d1b5cafeaf5d26a762350c04ebb02ea5b3b8ee7c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
package com.ruoyi.business.service.impl;
 
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.business.dto.EquipmentManagementDto;
import com.ruoyi.business.dto.EquipmentUsageDetailDto;
import com.ruoyi.business.entity.EquipmentManagement;
import com.ruoyi.business.entity.EquipmentUsageDetail;
import com.ruoyi.business.entity.EquipmentUsageRecord;
import com.ruoyi.business.mapper.EquipmentManagementMapper;
import com.ruoyi.business.mapper.EquipmentUsageDetailMapper;
import com.ruoyi.business.mapper.EquipmentUsageRecordMapper;
import com.ruoyi.business.service.EquipmentManagementService;
import com.ruoyi.business.service.EquipmentUsageDetailService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.business.service.EquipmentUsageRecordService;
import com.ruoyi.common.exception.base.BaseException;
import com.ruoyi.common.utils.bean.BeanUtils;
import org.springframework.stereotype.Service;
import lombok.RequiredArgsConstructor;
 
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
 
/**
 * <p>
 * 设备使用明细表 服务实现类
 * </p>
 *
 * @author ld
 * @since 2025-07-23
 */
@Service
@RequiredArgsConstructor
public class EquipmentUsageDetailServiceImpl extends ServiceImpl<EquipmentUsageDetailMapper, EquipmentUsageDetail> implements EquipmentUsageDetailService {
 
    private final EquipmentUsageDetailMapper equipmentUsageDetailMapper;
 
    private final EquipmentUsageRecordMapper equipmentUsageRecordMapper;
 
    private final EquipmentManagementMapper equipmentManagementMapper;
 
 
    @Override
    public IPage<EquipmentUsageDetailDto> selectEquipmentUsageDetailList(Page<EquipmentUsageDetail> page,EquipmentUsageDetailDto equipmentUsageDetailDto) {
        // 必须传递usageId参数
        if (equipmentUsageDetailDto.getUsageId() == null) {
            throw new BaseException("请选择使用记录");
        }
        LambdaQueryWrapper<EquipmentUsageDetail> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(EquipmentUsageDetail::getUsageId, equipmentUsageDetailDto.getUsageId());
 
        Page<EquipmentUsageDetail> entityPage = equipmentUsageDetailMapper.selectPage(page, queryWrapper);
        IPage<EquipmentUsageDetailDto> dtoPage = new Page<>();
        BeanUtils.copyProperties(entityPage, dtoPage);
        // 先获取主表记录
        List<Long> usageIds = entityPage.getRecords().stream()
                .map(EquipmentUsageDetail::getUsageId)
                .distinct()
                .collect(Collectors.toList());
 
        if (!usageIds.isEmpty()) {
            // 查询关联的使用记录
            List<EquipmentUsageRecord> usageRecords = equipmentUsageRecordMapper.selectList(
                    new LambdaQueryWrapper<EquipmentUsageRecord>()
                            .in(EquipmentUsageRecord::getId, usageIds)
            );
 
            // 获取所有设备ID
            List<Long> equipmentIds = usageRecords.stream()
                    .map(EquipmentUsageRecord::getEquipmentId)
                    .distinct()
                    .collect(Collectors.toList());
 
            // 查询设备信息
            Map<Long, EquipmentManagement> equipmentMap;
            if (!equipmentIds.isEmpty()) {
                equipmentMap = equipmentManagementMapper.selectList(
                        new LambdaQueryWrapper<EquipmentManagement>()
                                .in(EquipmentManagement::getId, equipmentIds)
                ).stream().collect(Collectors.toMap(EquipmentManagement::getId, Function.identity()));
            } else {
                equipmentMap = new HashMap<>();
            }
 
            // 构建使用记录ID到设备ID的映射
            Map<Long, Long> usageIdToEquipmentIdMap = usageRecords.stream()
                    .collect(Collectors.toMap(EquipmentUsageRecord::getId, EquipmentUsageRecord::getEquipmentId));
 
            // 转换DTO并填充设备信息
            List<EquipmentUsageDetailDto> dtoList = entityPage.getRecords().stream().map(detail -> {
                EquipmentUsageDetailDto detailDto = new EquipmentUsageDetailDto();
                BeanUtils.copyProperties(detail, detailDto);
 
                // 获取关联的设备ID
                Long equipmentId = usageIdToEquipmentIdMap.get(detail.getUsageId());
                if (equipmentId != null && equipmentMap.containsKey(equipmentId)) {
                    EquipmentManagement equipment = equipmentMap.get(equipmentId);
                    detailDto.setEquipmentNo(equipment.getEquipmentNo());
                    detailDto.setEquipmentName(equipment.getEquipmentName());
                    detailDto.setSpecification(equipment.getSpecification());
                }
 
                return detailDto;
            }).collect(Collectors.toList());
 
            dtoPage.setRecords(dtoList);
        } else {
            dtoPage.setRecords(Collections.emptyList());
        }
        return dtoPage;
    }
}