feat:1.出入库单位转换 2.仓储/耗材导出字段值优化 3.仓储/耗材库存为0不展示

liding

8 天以前 1fd7a7d67a5df84b57af4fbcc310aa66da3cd8ca

 src/main/java/com/ruoyi/quality/service/impl/RawMaterialServiceImpl.java

@@ -1,31 +1,55 @@
package com.ruoyi.quality.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.collaborativeApproval.dto.DutyPlanDTO;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.deepoove.poi.XWPFTemplate;
import com.deepoove.poi.config.Configure;
import com.ruoyi.approve.service.impl.ApproveProcessServiceImpl;
import com.ruoyi.approve.vo.ApproveProcessVO;
import com.ruoyi.basic.mapper.ProductMapper;
import com.ruoyi.basic.mapper.ProductModelMapper;
import com.ruoyi.basic.pojo.Product;
import com.ruoyi.basic.pojo.ProductModel;
import com.ruoyi.common.enums.RawMaterialCheckResult;
import com.ruoyi.common.enums.RawMaterialCheckType;
import com.ruoyi.common.enums.RawMaterialInspectState;
import com.ruoyi.production.mapper.ProductProcessRouteMapper;
import com.ruoyi.common.utils.HackLoopTableRenderPolicy;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.bean.BeanUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.framework.security.LoginUser;
import com.ruoyi.inspectiontask.mapper.QualityInspectItemMapper;
import com.ruoyi.inspectiontask.pojo.QualityInspectItem;
import com.ruoyi.quality.dto.RawMaterialDto;
import com.ruoyi.quality.mapper.RawMaterialQualityInspectItemMapper;
import com.ruoyi.quality.pojo.RawMaterial;
import com.ruoyi.quality.dto.RawMaterialQualityInspectItemDto;
import com.ruoyi.quality.mapper.QualityUnqualifiedMapper;
import com.ruoyi.quality.mapper.RawMaterialMapper;
import com.ruoyi.quality.pojo.RawMaterialQualityInspectItem;
import com.ruoyi.quality.pojo.*;
import com.ruoyi.quality.service.RawMaterialQualityInspectItemService;
import com.ruoyi.quality.service.RawMaterialService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.AllArgsConstructor;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URLEncoder;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;

import static com.ruoyi.home.service.impl.HomeServiceImpl.formatDate;


/**
 * <p>
 *  服务实现类
 * 服务实现类
 * </p>
 *
 * @author 芯导软件（江苏）有限公司
@@ -38,33 +62,304 @@

    private RawMaterialQualityInspectItemService rawMaterialQualityInspectItemService;

    private QualityInspectItemMapper qualityInspectItemMapper;

    private ProductModelMapper productModelMapper;

    private ProductMapper productMapper;

    private QualityUnqualifiedMapper qualityUnqualifiedMapper;

    @Autowired
    private  ApproveProcessServiceImpl approveProcessService;

    @Override
    public IPage<RawMaterialDto> listPage(Page page, RawMaterialDto rawMaterialDto) {
        IPage<RawMaterialDto> rawMaterials = rawMaterialMapper.listPage(page, rawMaterialDto);
        for (RawMaterialDto rawMaterial : rawMaterials.getRecords()) {
            rawMaterial.setCheckTypeText(RawMaterialCheckType.fromValue(rawMaterial.getCheckType()).getValue());
            rawMaterial.setCheckResultText(RawMaterialCheckResult.fromValue(rawMaterial.getCheckResult()).getValue());
            rawMaterial.setInspectStateText(RawMaterialInspectState.fromValue(rawMaterial.getInspectState()).getValue());
        IPage<RawMaterialDto> pageRes = rawMaterialMapper.listPage(page, rawMaterialDto);
        List<RawMaterialDto> rawMaterials = pageRes.getRecords();
        Map<Long, ProductModel> productModelMap = new HashMap<>();
        Map<Long, Product> productMap = new HashMap<>();
        if (CollectionUtils.isNotEmpty(rawMaterials)) {
            List<Long> productModelIds = rawMaterials.stream().map(RawMaterialDto::getProductModelId).collect(Collectors.toList());
            List<ProductModel> productModels = productModelMapper.selectList(new LambdaQueryWrapper<ProductModel>()
                    .in(ProductModel::getId, productModelIds));
            productModelMap = productModels.stream().collect(Collectors.toMap(ProductModel::getId, productModel -> productModel));
            List<Long> productIds = productModels.stream().map(ProductModel::getProductId).collect(Collectors.toList());
            List<Product> products = productMapper.selectList(new LambdaQueryWrapper<Product>()
                    .in(Product::getId, productIds));
            productMap = products.stream().collect(Collectors.toMap(Product::getId, product -> product));
        }
        return rawMaterials;

        for (RawMaterialDto rawMaterial : pageRes.getRecords()) {
            rawMaterial.setCheckTypeText(RawMaterialCheckType.fromValue(rawMaterial.getCheckType()) == null ? "" : RawMaterialCheckType.fromValue(rawMaterial.getCheckType()).getValue());
            rawMaterial.setCheckResultText(RawMaterialCheckResult.fromValue(rawMaterial.getCheckResult()) == null ? "" : RawMaterialCheckResult.fromValue(rawMaterial.getCheckResult()).getValue());
            rawMaterial.setInspectStateText(RawMaterialInspectState.fromValue(rawMaterial.getInspectState()) == null ? "" : RawMaterialInspectState.fromValue(rawMaterial.getInspectState()).getValue());
            rawMaterial.setProductName(productMap.get(productModelMap.get(rawMaterial.getProductModelId()).getProductId()).getProductName());
            rawMaterial.setModel(productModelMap.get(rawMaterial.getProductModelId()).getModel());
            rawMaterial.setProductId(productModelMap.get(rawMaterial.getProductModelId()).getProductId());
        }
        return pageRes;
    }

    @Override
    public RawMaterialDto detail(Long id) {
        RawMaterial rawMaterial = rawMaterialMapper.selectById(id);
        RawMaterialDto rawMaterialDto = new RawMaterialDto();
        if (rawMaterial == null) {
            return rawMaterialDto;
        }
        BeanUtils.copyBeanProp(rawMaterialDto, rawMaterial);
        // 获取检测项关联关系
        List<RawMaterialQualityInspectItem> rawQualityList = rawMaterialQualityInspectItemService.list(new LambdaQueryWrapper<RawMaterialQualityInspectItem>()
                .eq(RawMaterialQualityInspectItem::getRawMaterialId, id));
        Map<Long, RawMaterialQualityInspectItem> map = rawQualityList.stream().collect(Collectors.toMap(RawMaterialQualityInspectItem::getQualityInspectItemId, qualityInspectItem -> qualityInspectItem));
        // 获取检验项目
        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());
        });
        rawMaterialDto.setQualityInspectItem(qualityInspectItems);

        // 查询产品id
        ProductModel productModel = productModelMapper.selectById(rawMaterialDto.getProductModelId());
        Product product = productMapper.selectById(productModel.getProductId());
        rawMaterialDto.setProductId(productModel.getProductId());
        rawMaterialDto.setProductName(product.getProductName());
        rawMaterialDto.setModel(productModel.getModel());
        rawMaterialDto.setUnit(productModel.getUnit());
        rawMaterialDto.setCheckResultText(RawMaterialCheckResult.fromValue(rawMaterial.getCheckResult()) == null ? "" : RawMaterialCheckResult.fromValue(rawMaterial.getCheckResult()).getValue());
        rawMaterialDto.setCheckTypeText(RawMaterialCheckType.fromValue(rawMaterial.getCheckType()) == null ? "" : RawMaterialCheckType.fromValue(rawMaterial.getCheckType()).getValue());
        return rawMaterialDto;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean submit(Long id) {
        RawMaterial rawMaterial = rawMaterialMapper.selectById(id);
        if (rawMaterial.getCheckResult() == null) {
            throw new RuntimeException("请先判断是否合格");
        }

        // 不合格：生成不合格记录
        if (rawMaterial.getCheckResult().equals(RawMaterialCheckResult.RawMaterialCheckResultUnqualified.getCode())) {
            QualityUnqualified qualityUnqualified = new QualityUnqualified();
            qualityUnqualified.setInspectId(rawMaterial.getId());//检验id
            qualityUnqualified.setCheckType(rawMaterial.getCheckType());//检验类型
            qualityUnqualified.setInspectState(0);//待处理
            qualityUnqualified.setCheckName(rawMaterial.getCheckUserName());//检验员名称
            qualityUnqualified.setCheckTime(rawMaterial.getCheckTime());//检验日期
            ProductModel productModel = productModelMapper.selectById(rawMaterial.getProductModelId());
            Product product = productMapper.selectById(productModel.getProductId());
            qualityUnqualified.setProductId(productModel.getProductId());//产品id
            qualityUnqualified.setProductName(product.getProductName());//产品名称
            qualityUnqualified.setModel(productModel.getModel());//规格型号
            qualityUnqualified.setUnit(productModel.getUnit());//单位
            List<RawMaterialQualityInspectItem> inspectParams = rawMaterialQualityInspectItemService.list(Wrappers.<RawMaterialQualityInspectItem>lambdaQuery().eq(RawMaterialQualityInspectItem::getRawMaterialId, rawMaterial.getId()));
            // 获取关联的QualityInspectItem项目名
            String text = inspectParams.stream().map(item -> {
                QualityInspectItem qualityInspectItem = qualityInspectItemMapper.selectById(item.getQualityInspectItemId());
                return qualityInspectItem != null ? qualityInspectItem.getName() : "";
            }).collect(Collectors.joining(","));
            qualityUnqualified.setDefectivePhenomena(text + "这些项目中存在不合格");//不合格现象
            qualityUnqualifiedMapper.insert(qualityUnqualified);
        } else {
            //合格: 产生原料审核记录
            LoginUser loginUser = SecurityUtils.getLoginUser();
            ApproveProcessVO approveProcessVO = new ApproveProcessVO();
            approveProcessVO.setApproveType(9);
            approveProcessVO.setApproveRecordId(rawMaterial.getId());
            approveProcessVO.setApproveDeptId(loginUser.getCurrentDeptId());
            approveProcessVO.setApproveReason( "原料审核批号："+rawMaterial.getBatchNo());
            Long adminUserId = 1L; // todo 假设第一个管理员的ID为1
            approveProcessVO.setApproveUserIds(String.valueOf(adminUserId));
            approveProcessVO.setApproveUser(loginUser.getUserId());
            approveProcessVO.setApproveTime(LocalDate.now().toString());
            try {
                approveProcessService.addApprove(approveProcessVO);
            }catch (Exception e){
                log.error("RawMaterialServiceImpl error:{}", e);
                throw new RuntimeException("审批失败");
            }
        }

        rawMaterial.setInspectState(RawMaterialInspectState.RawMaterialInspectStateSubmitted.getCode());
        return rawMaterialMapper.updateById(rawMaterial) > 0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean add(RawMaterialDto rawMaterialDto) {
        rawMaterialDto.setInspectState(RawMaterialInspectState.RawMaterialInspectStateUnsubmitted.getCode());
        // 新增原料
        int i = rawMaterialMapper.insert(rawMaterialDto);
        // 新增检测项关联关系
        if (rawMaterialDto.getQualityInspectItemIds() != null && !rawMaterialDto.getQualityInspectItemIds().isEmpty()) {
            List<RawMaterialQualityInspectItem> rawMaterialQualityInspectItems = rawMaterialDto.getQualityInspectItemIds().stream()
                    .map(id -> {
        if (CollectionUtils.isNotEmpty(rawMaterialDto.getQualityInspectItem())) {
            List<RawMaterialQualityInspectItem> rawMaterialQualityInspectItems = rawMaterialDto.getQualityInspectItem().stream()
                    .map(qualityInspectItem -> {
                        RawMaterialQualityInspectItem item = new RawMaterialQualityInspectItem();
                        item.setRawMaterialId(rawMaterialDto.getId());
                        item.setQualityInspectItemId(id);
                        item.setQualityInspectItemId(qualityInspectItem.getId());
                        item.setTestValue(qualityInspectItem.getTestValue());
                        return item;
                    })
                    .collect(Collectors.toList());
            rawMaterialQualityInspectItemService.saveBatch(rawMaterialQualityInspectItems);
        }
        // 新增原料
        return rawMaterialMapper.insert(rawMaterialDto) > 0;
        return i > 0;
    }
}

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean update(RawMaterialDto rawMaterialDto) {
        // 更新原料
        if (rawMaterialMapper.updateById(rawMaterialDto) <= 0) {
            return false;
        }

        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());
        inspect.setCheckTimeText(formatDate(rawMaterial.getCheckTime()));

        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("导出失败");
        }
    }
}