产品供销存-后端
blame | 历史 | 补丁 | 提交 | 提交对比 | 忽略空白
huminmin
2026-03-16 482033ad6accee24ae2a530ad5fbc42febb0f2f1 
 src/main/java/com/ruoyi/quality/service/impl/RawMaterialServiceImpl.java


@@ -4,6 +4,8 @@


import com.baomidou.mybatisplus.core.metadata.IPage;


import com.baomidou.mybatisplus.extension.plugins.pagination.Page;


import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;


import com.deepoove.poi.XWPFTemplate;


import com.deepoove.poi.config.Configure;


import com.ruoyi.basic.mapper.ProductMapper;


import com.ruoyi.basic.mapper.ProductModelMapper;


import com.ruoyi.basic.pojo.Product;


@@ -11,11 +13,16 @@


import com.ruoyi.common.enums.RawMaterialCheckResult;


import com.ruoyi.common.enums.RawMaterialCheckType;


import com.ruoyi.common.enums.RawMaterialInspectState;


import com.ruoyi.common.utils.HackLoopTableRenderPolicy;


import com.ruoyi.common.utils.bean.BeanUtils;


import com.ruoyi.common.utils.poi.ExcelUtil;


import com.ruoyi.inspectiontask.mapper.QualityInspectItemMapper;


import com.ruoyi.inspectiontask.pojo.QualityInspectItem;


import com.ruoyi.quality.dto.RawMaterialDto;


import com.ruoyi.quality.dto.RawMaterialQualityInspectItemDto;


import com.ruoyi.quality.mapper.RawMaterialMapper;


import com.ruoyi.quality.pojo.QualityInspect;


import com.ruoyi.quality.pojo.QualityInspectParam;


import com.ruoyi.quality.pojo.RawMaterial;


import com.ruoyi.quality.pojo.RawMaterialQualityInspectItem;


import com.ruoyi.quality.service.RawMaterialQualityInspectItemService;


@@ -25,9 +32,11 @@


import org.springframework.stereotype.Service;


import org.springframework.transaction.annotation.Transactional;




import java.util.HashMap;


import java.util.List;


import java.util.Map;


import javax.servlet.http.HttpServletResponse;


import java.io.InputStream;


import java.io.OutputStream;


import java.net.URLEncoder;


import java.util.*;


import java.util.stream.Collectors;






@@ -90,8 +99,12 @@


                .eq(RawMaterialQualityInspectItem::getRawMaterialId, id));


        Map<Long, RawMaterialQualityInspectItem> map = rawQualityList.stream().collect(Collectors.toMap(RawMaterialQualityInspectItem::getQualityInspectItemId, qualityInspectItem -> qualityInspectItem));


        // 获取检验项目


        List<QualityInspectItem> qualityInspectItems = qualityInspectItemMapper.selectList(new LambdaQueryWrapper<QualityInspectItem>()


                .in(QualityInspectItem::getId, rawQualityList.stream().map(RawMaterialQualityInspectItem::getQualityInspectItemId).collect(Collectors.toList())));


        List<QualityInspectItem> qualityInspectItems = new ArrayList<>();


        if (CollectionUtils.isNotEmpty(rawQualityList)) {


            List<Long> qualityInspectItemIds = rawQualityList.stream().map(RawMaterialQualityInspectItem::getQualityInspectItemId).collect(Collectors.toList());


            qualityInspectItems = qualityInspectItemMapper.selectList(new LambdaQueryWrapper<QualityInspectItem>()


                    .in(QualityInspectItem::getId, qualityInspectItemIds));


        }


        // 替换化验值


        qualityInspectItems.forEach(qualityInspectItem -> {


            qualityInspectItem.setTestValue(map.get(qualityInspectItem.getId()).getTestValue());


@@ -128,24 +141,150 @@


    }




    @Override


    @Transactional(rollbackFor = Exception.class)


    public boolean update(RawMaterialDto rawMaterialDto) {


        // 删除所有关联项目重新加载


        rawMaterialQualityInspectItemService.remove(new LambdaQueryWrapper<RawMaterialQualityInspectItem>()


                .eq(RawMaterialQualityInspectItem::getRawMaterialId, rawMaterialDto.getId()));


        int i = rawMaterialMapper.updateById(rawMaterialDto);


        // 新增检测项关联关系


        if (CollectionUtils.isNotEmpty(rawMaterialDto.getQualityInspectItem())) {


            List<RawMaterialQualityInspectItem> rawMaterialQualityInspectItems = rawMaterialDto.getQualityInspectItem().stream()


                    .map(qualityInspectItem -> {


                        RawMaterialQualityInspectItem item = new RawMaterialQualityInspectItem();


                        item.setRawMaterialId(rawMaterialDto.getId());


                        item.setQualityInspectItemId(qualityInspectItem.getId());


                        item.setTestValue(qualityInspectItem.getTestValue());


                        return item;


                    })


                    .collect(Collectors.toList());


            rawMaterialQualityInspectItemService.saveBatch(rawMaterialQualityInspectItems);


        // 更新原料


        if (rawMaterialMapper.updateById(rawMaterialDto) <= 0) {


            return false;


        }


        return i > 0;




        Long rawMaterialId = rawMaterialDto.getId();


        List<QualityInspectItem> newQualityInspectItems = rawMaterialDto.getQualityInspectItem();




        // 获取现有检验项关联记录


        List<RawMaterialQualityInspectItem> existingItems = rawMaterialQualityInspectItemService.list(


                new LambdaQueryWrapper<RawMaterialQualityInspectItem>()


                        .eq(RawMaterialQualityInspectItem::getRawMaterialId, rawMaterialId)


        );




        // 删除不存在的关联记录


        if (CollectionUtils.isEmpty(newQualityInspectItems)) {


            // 如果没有检验项，删除所有现有关联记录


            if (CollectionUtils.isNotEmpty(existingItems)) {


                List<Long> existingIds = existingItems.stream()


                        .map(RawMaterialQualityInspectItem::getId)


                        .collect(Collectors.toList());


                rawMaterialQualityInspectItemService.removeByIds(existingIds);


            }


            return true;


        }




        // 获取新检验项的ID集合和测试值映射


        Set<Long> newItemIds = newQualityInspectItems.stream()


                .map(QualityInspectItem::getId)


                .collect(Collectors.toSet());




        Map<Long, String> testValueMap = newQualityInspectItems.stream()


                .collect(Collectors.toMap(QualityInspectItem::getId, QualityInspectItem::getTestValue));




        // 删除不存在的关联记录


        List<Long> toDelete = existingItems.stream()


                .filter(item -> !newItemIds.contains(item.getQualityInspectItemId()))


                .map(RawMaterialQualityInspectItem::getId)


                .collect(Collectors.toList());




        if (CollectionUtils.isNotEmpty(toDelete)) {


            rawMaterialQualityInspectItemService.removeByIds(toDelete);


        }




        // 处理更新数据


        List<RawMaterialQualityInspectItem> toUpdate = existingItems.stream()


                .filter(item -> newItemIds.contains(item.getQualityInspectItemId()))


                .peek(item -> item.setTestValue(testValueMap.get(item.getQualityInspectItemId())))


                .collect(Collectors.toList());




        if (CollectionUtils.isNotEmpty(toUpdate)) {


            rawMaterialQualityInspectItemService.updateBatchById(toUpdate);


        }




        // 处理新增数据


        Set<Long> existingItemIds = existingItems.stream()


                .map(RawMaterialQualityInspectItem::getQualityInspectItemId)


                .collect(Collectors.toSet());




        List<RawMaterialQualityInspectItem> toCreate = newQualityInspectItems.stream()


                .filter(item -> !existingItemIds.contains(item.getId()))


                .map(item -> {


                    RawMaterialQualityInspectItem newItem = new RawMaterialQualityInspectItem();


                    newItem.setRawMaterialId(rawMaterialId);


                    newItem.setQualityInspectItemId(item.getId());


                    newItem.setTestValue(item.getTestValue());


                    return newItem;


                })


                .collect(Collectors.toList());




        if (CollectionUtils.isNotEmpty(toCreate)) {


            rawMaterialQualityInspectItemService.saveBatch(toCreate);


        }




        return true;


    }


}




    @Override


    public void export(HttpServletResponse response, RawMaterialDto rawMaterialDto) {


        List<RawMaterialDto> rawMaterials = rawMaterialMapper.listPage(new Page<>(1, Integer.MAX_VALUE), rawMaterialDto).getRecords();


        ExcelUtil<RawMaterialDto> util = new ExcelUtil<RawMaterialDto>(RawMaterialDto.class);


        util.exportExcel(response, rawMaterials, "原料检验导出");


    }




    @Override


    public void down(HttpServletResponse response, RawMaterialDto rawMaterialDto) {


        RawMaterial rawMaterial = rawMaterialMapper.selectById(rawMaterialDto.getId());


        // 获取产品型号信息


        ProductModel productModel = productModelMapper.selectById(rawMaterial.getProductModelId());


        Product product = productMapper.selectById(productModel.getProductId());


        RawMaterialDto inspect = new RawMaterialDto();


        BeanUtils.copyProperties(rawMaterial, inspect);


        inspect.setModel(productModel.getModel());


        inspect.setProductName(product.getProductName());


        inspect.setCheckTypeText(RawMaterialCheckType.fromValue(rawMaterial.getCheckType()) == null ? "" : RawMaterialCheckType.fromValue(rawMaterial.getCheckType()).getValue());


        inspect.setCheckResultText(RawMaterialCheckResult.fromValue(rawMaterial.getCheckResult()) == null ? "" : RawMaterialCheckResult.fromValue(rawMaterial.getCheckResult()).getValue());




        List<RawMaterialQualityInspectItem> paramList = rawMaterialQualityInspectItemService.list(


                new LambdaQueryWrapper<RawMaterialQualityInspectItem>()


                        .eq(RawMaterialQualityInspectItem::getRawMaterialId, rawMaterialDto.getId())


        );


        List<RawMaterialQualityInspectItemDto> inspectItems = new ArrayList<>();




        int index = 1;


        for (RawMaterialQualityInspectItem item : paramList) {


            RawMaterialQualityInspectItemDto dto = new RawMaterialQualityInspectItemDto();


            BeanUtils.copyProperties(item, dto);


            QualityInspectItem qualityInspectItem = qualityInspectItemMapper.selectById(item.getQualityInspectItemId());


            dto.setName(qualityInspectItem.getName());


            dto.setUnit(qualityInspectItem.getUnit());


            dto.setStandardValue(qualityInspectItem.getStandardValue());


            dto.setInternalControl(qualityInspectItem.getInternalControl());


            dto.setIndex(index);


            inspectItems.add(dto);


            index++;


        }




        InputStream inputStream = this.getClass().getResourceAsStream("/static/report-template.docx");


        Configure configure = Configure.builder()


                .bind("paramList", new HackLoopTableRenderPolicy())


                .build();


        XWPFTemplate template = XWPFTemplate.compile(inputStream, configure).render(


                new HashMap<String, Object>() {{


                    put("inspect", inspect);


                    put("paramList", inspectItems);


                }});




        try {


            response.setContentType("application/msword");


            String fileName = URLEncoder.encode(


                    "检验报告", "UTF-8");


            response.setHeader("Access-Control-Expose-Headers", "Content-Disposition");


            response.setHeader("Content-disposition",


                    "attachment;filename=" + fileName + ".docx");


            OutputStream os = response.getOutputStream();


            template.write(os);


            os.flush();


            os.close();


            inputStream.close();


        } catch (Exception e) {


            e.printStackTrace();


            throw new RuntimeException("导出失败");


        }


    }


}