wms / hhwms · Files

package com.huaheng.pc.receipt.receiptDetail.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

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

import com.huaheng.common.constant.QuantityConstant;

import com.huaheng.common.exception.service.ServiceException;

import com.huaheng.common.support.Convert;
import com.huaheng.common.utils.StringUtils;

import com.huaheng.common.utils.Wrappers;

import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.web.domain.AjaxResult;

import com.huaheng.mobile.receipt.ReceiptBill;

import com.huaheng.pc.check.checkHeader.domain.CheckHeader;
import com.huaheng.pc.check.checkHeader.service.CheckHeaderService;

import com.huaheng.pc.config.company.domain.Company;
import com.huaheng.pc.config.company.service.CompanyService;

import com.huaheng.pc.config.configValue.domain.ConfigValue;
import com.huaheng.pc.config.configValue.service.ConfigValueService;

import com.huaheng.pc.config.material.domain.Material;
import com.huaheng.pc.config.material.service.MaterialService;

import com.huaheng.pc.config.materialType.domain.MaterialType;
import com.huaheng.pc.config.materialType.service.MaterialTypeService;
import com.huaheng.pc.config.receiptPreference.domain.ReceiptPreference;
import com.huaheng.pc.config.receiptPreference.service.ReceiptPreferenceService;
import com.huaheng.pc.config.receiptType.domain.ReceiptType;
import com.huaheng.pc.config.receiptType.service.ReceiptTypeService;
import com.huaheng.pc.config.statusFlow.domain.StatusFlowDetail;
import com.huaheng.pc.config.statusFlow.service.StatusFlowDetailService;

import com.huaheng.pc.receipt.receiptDetail.domain.ReceiptDetail;
import com.huaheng.pc.receipt.receiptDetail.mapper.ReceiptDetailMapper;

import com.huaheng.pc.receipt.receiptHeader.domain.ReceiptHeader;
import com.huaheng.pc.receipt.receiptHeader.service.ReceiptHeaderService;

import com.huaheng.pc.system.dict.service.IDictDataService;

import com.huaheng.pc.task.taskDetail.domain.TaskDetail;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

import java.math.BigDecimal;

import java.util.*;
import java.util.stream.Collectors;

@Service

public class ReceiptDetailServiceImpl extends ServiceImpl<ReceiptDetailMapper, ReceiptDetail> implements ReceiptDetailService {

    @Resource
    private MaterialService materialService;

    @Resource
    private ReceiptHeaderService receiptHeaderService;

    @Resource
    private ReceiptTypeService receiptTypeService;
    @Resource
    private StatusFlowDetailService statusFlowDetailService;
    @Resource
    private MaterialTypeService materialTypeService;
    @Resource
    private ReceiptPreferenceService receiptPreferenceService;

    @Resource
    private IDictDataService dictDataService;

    @Resource
    private CheckHeaderService checkHeaderService;

    @Resource
    private ConfigValueService configValueService;

    @Resource
    private ReceiptDetailMapper receiptDetailMapper;

    @Resource
    private CompanyService companyService;

    /**
     * 新增入库明细

     *

     * @param receiptDetail
     * @return
     */

    @Transactional(rollbackFor = Exception.class)

    @Override

    public AjaxResult saveReceiptDetaial(ReceiptDetail receiptDetail) {

        /* 判断入库头表状态*/

        LambdaQueryWrapper<ReceiptHeader> lambdaReceiptHeader = Wrappers.lambdaQuery();
        lambdaReceiptHeader.eq(ReceiptHeader::getId, receiptDetail.getReceiptId());
        ReceiptHeader receiptHeader = receiptHeaderService.getOne(lambdaReceiptHeader);

        //判断入库头表状态

        if (receiptHeader == null) {

            throw new ServiceException("找不到主单据");

        } else if (receiptHeader.getFirstStatus() > QuantityConstant.RECEIPT_HEADER_POOL) {

            throw new ServiceException("单据进入订单池后，不允许新增明细");

        } else if (receiptHeader.getFirstStatus() == 20) {

            throw new ServiceException("单据已作废");

        }
        receiptDetail.setReceiptCode(receiptHeader.getCode());

        /* 判断物料编码*/

        LambdaQueryWrapper<Material> lambdaQueryWrapper = Wrappers.lambdaQuery();

        lambdaQueryWrapper.eq(Material::getCode, receiptDetail.getMaterialCode());

        lambdaQueryWrapper.eq(Material::getWarehouseCode, ShiroUtils.getWarehouseCode());

        Material material = materialService.getOne(lambdaQueryWrapper);
        if (material == null) {

            throw new ServiceException("物料不存在");

        }

        receiptDetail.setCompanyCode(receiptHeader.getCompanyCode());

        receiptDetail.setMaterialCode(material.getCode());

        receiptDetail.setMaterialName(material.getName());
        receiptDetail.setMaterialSpec(material.getSpec());
        receiptDetail.setMaterialUnit(material.getUnit());

        receiptDetail.setInventorySts(QuantityConstant.GOOD);

        receiptDetail.setCreatedBy(ShiroUtils.getLoginName());
        receiptDetail.setLastUpdatedBy(ShiroUtils.getLoginName());

        receiptDetail.setWarehouseCode(ShiroUtils.getWarehouseCode());

        receiptDetail.setUWarehouseCode(receiptHeader.getUWarehouseCode());

        //根据流程配置更新入库明细下一流程
        ReceiptDetail receiptDetail1 = queryflow(receiptDetail);

        if (this.save(receiptDetail1)) {

//            receiptHeader.setTotalQty(receiptHeader.getTotalQty().add(receiptDetail1.getTotalQty()));
//            receiptHeader.setTotalLines(receiptHeader.getTotalLines()+1);
//            receiptHeaderService.updateById(receiptHeader);
            updateReceiptHeader(receiptHeader);

            return AjaxResult.success("新增单据明细成功");
        } else {
            return AjaxResult.error("新增单据明细失败！");
        }

    }

    /**
     * 修改入库明细

     *

     * @param receiptDetail
     * @return
     */
    @Override
    @Transactional
    public AjaxResult updateReceiptDetaial(ReceiptDetail receiptDetail) {
        /* 先修改入库头表中的总数量和总行数，再更新记录，完成后更新入库头表中总数量和总行数*/

        //查询原记录

        ReceiptDetail originalReceiptDetail = this.getById(receiptDetail.getId());

        ReceiptHeader receiptHeader = receiptHeaderService.getById(receiptDetail.getReceiptId());

        //判断物料编码是否被修改

        if (!originalReceiptDetail.getMaterialCode().equals(receiptDetail.getMaterialCode())) {

            LambdaQueryWrapper<Material> lambdaMaterial = Wrappers.lambdaQuery();

            lambdaMaterial.eq(Material::getCode, receiptDetail.getMaterialCode());

            Material material = materialService.getOne(lambdaMaterial);

            if (material == null) {
                throw new ServiceException("该物料编码不存在");

            } else {

                receiptDetail.setMaterialName(material.getName());
                receiptDetail.setMaterialSpec(material.getSpec());
                receiptDetail.setMaterialUnit(material.getUnit());

//                receiptDetail.setProcessStamp("0");
//                receiptHeader.setTotalQty(receiptHeader.getTotalQty().subtract(originalReceiptDetail.getTotalQty()));
//                receiptHeader.setTotalLines(receiptHeader.getTotalLines()-1);
//                if ( !receiptHeaderService.updateById(receiptHeader)){
//                    return AjaxResult.error("入库头表更新失败");
//                }

            }

        }

        //如果单据状态为驳回则设置状态为提交审核

//        if ("10".equals(receiptDetail.getProcessStamp())){
//            receiptDetail.setProcessStamp("5");
//        }

        receiptDetail.setLastUpdatedBy(ShiroUtils.getLoginName());

        if (!this.updateById(receiptDetail)) {

            return AjaxResult.error("入库明细更新失败");
        } else {

            updateReceiptHeader(receiptHeader);

            return AjaxResult.success("修改单据明细成功");
        }
    }

    /**
     * 更新入库单头表状态

     *

     * @param receiptHeader 入库单按头表
     * @return
     */

    @Override

    public AjaxResult updateReceiptHeader(ReceiptHeader receiptHeader) {

        BigDecimal totalQty = new BigDecimal(0);
        int totalLines = 0;
        LambdaQueryWrapper<ReceiptDetail> receiptDetailLambdaQueryWrapper = Wrappers.lambdaQuery();

        receiptDetailLambdaQueryWrapper.eq(ReceiptDetail::getReceiptId, receiptHeader.getId());
        List<ReceiptDetail> receiptDetailList = list(receiptDetailLambdaQueryWrapper);
        for (ReceiptDetail receiptDetail : receiptDetailList) {

            totalLines++;

            totalQty = totalQty.add(receiptDetail.getQty());

        }
        receiptHeader.setTotalQty(totalQty);
        receiptHeader.setTotalLines(totalLines);

        if (!receiptHeaderService.updateById(receiptHeader)) {

            return AjaxResult.error("入库头表更新失败");
        }
        return AjaxResult.success("入库头表更新成功");
    }

    @Override
    public List<ReceiptDetail> findByReceiptId(Integer id) {
        LambdaQueryWrapper<ReceiptDetail> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(ReceiptDetail::getReceiptId, id);
        return list(queryWrapper);
    }

    /**
     * 根据流程配置更新入库明细下一流程

     * 1.先查询入库子表要没有设置入库流程
     * 2.查询入库主表的入库单据流程
     * 3.物料是否有入库流程
     * 4.物料类别是否有入库流程
     * 5.入库首选项的入库流程

     *

     * @param receiptDetail
     * @return
     */

    @Override

    @Transactional(rollbackFor = Exception.class)

    public ReceiptDetail queryflow(ReceiptDetail receiptDetail) {

        //当单据状态为驳回或作废时不更新状态

        if (QuantityConstant.RECEIPT_HEADER_REJECTED.toString().equals(receiptDetail.getProcessStamp()) || QuantityConstant.RECEIPT_HEADER_OBSOLETE.toString().equals(receiptDetail.getProcessStamp())) {

            return receiptDetail;
        }

        //如果入库明细绑定了入库流程则从入库明细中选择流程

        if (StringUtils.isNotEmpty(receiptDetail.getStatusFlowCode())) {

            List<StatusFlowDetail> statusFlowDetails = statusFlowDetailService.queryStatusFlowDetail(receiptDetail.getStatusFlowCode());
            String status = nextStatusFlow(statusFlowDetails, receiptDetail.getProcessStamp());
            //在状态到达时候是判断是否要质检

            if (QuantityConstant.RECEIPT_HEADER_RECEIVING.toString().equals(status) && inspection(receiptDetail)) {

                receiptDetail.setProcessStamp(QuantityConstant.RECEIPT_HEADER_CHECK.toString());

            } else {
                receiptDetail.setProcessStamp(status);
            }
            return receiptDetail;
        }

        //查询头表信息
        LambdaQueryWrapper<ReceiptHeader> lambdaReceiptHeader = Wrappers.lambdaQuery();
        lambdaReceiptHeader.eq(ReceiptHeader::getCode, receiptDetail.getReceiptCode());

        lambdaReceiptHeader.last("limit 1");

        ReceiptHeader receiptHeader = receiptHeaderService.getOne(lambdaReceiptHeader);

        //查询明细表中入库物料信息
        LambdaQueryWrapper<Material> lambdaMaterial = Wrappers.lambdaQuery();
        lambdaMaterial.eq(Material::getCode, receiptDetail.getMaterialCode());

        lambdaMaterial.eq(Material::getWarehouseCode, ShiroUtils.getWarehouseCode());

        lambdaMaterial.last("limit 1");

        Material material = materialService.getOne(lambdaMaterial);

        //查询头表中绑定的入库类型中的入库流程
        LambdaQueryWrapper<ReceiptType> lambdaReceiptType = Wrappers.lambdaQuery();

        lambdaReceiptType.eq(ReceiptType::getCode, receiptHeader.getReceiptType())
                .eq(ReceiptType::getWarehouseCode, ShiroUtils.getWarehouseCode());

//                .eq(ReceiptType::getCompanyCode, receiptDetail.getCompanyCode());

        lambdaReceiptType.last("limit 1");

        ReceiptType receiptType = receiptTypeService.getOne(lambdaReceiptType);

        if (receiptType.getReceiptFlow() != null) {

            //物料是否有入库流程
            List<StatusFlowDetail> statusFlowDetails = statusFlowDetailService.queryStatusFlowDetail(receiptType.getReceiptFlow());

            String status = nextStatusFlow(statusFlowDetails, receiptDetail.getProcessStamp());

            //在状态到达时候是判断是否要质检

            if (QuantityConstant.RECEIPT_HEADER_RECEIVING.toString().equals(status) && inspection(receiptDetail)) {

                receiptDetail.setProcessStamp(QuantityConstant.RECEIPT_HEADER_CHECK.toString());

            } else {
                receiptDetail.setProcessStamp(status);
            }

            return receiptDetail;

        } else if (material.getReceivingFlow() != null) {

            //物料是否有入库流程
            List<StatusFlowDetail> statusFlowDetails = statusFlowDetailService.queryStatusFlowDetail(material.getReceivingFlow());

            String status = nextStatusFlow(statusFlowDetails, receiptDetail.getProcessStamp());

            //在状态到达时候是判断是否要质检

            if (QuantityConstant.RECEIPT_HEADER_RECEIVING.toString().equals(status) && inspection(receiptDetail)) {

                receiptDetail.setProcessStamp(QuantityConstant.RECEIPT_HEADER_CHECK.toString());

            } else {
                receiptDetail.setProcessStamp(status);
            }

            return receiptDetail;
        } else {
            //该物料类别是否有入库流程
            LambdaQueryWrapper<MaterialType> lambdaMaterialType = Wrappers.lambdaQuery();
            lambdaMaterialType.eq(MaterialType::getCode, material.getType());
            MaterialType materialType = materialTypeService.getOne(lambdaMaterialType);
            if (materialType.getReceivingFlow() != null) {
                List<StatusFlowDetail> statusFlowDetails = statusFlowDetailService.queryStatusFlowDetail(materialType.getReceivingFlow());

                String status = nextStatusFlow(statusFlowDetails, receiptDetail.getProcessStamp());

                //在状态到达时候是判断是否要质检

                if (QuantityConstant.RECEIPT_HEADER_RECEIVING.toString().equals(status) && inspection(receiptDetail)) {

                    receiptDetail.setProcessStamp(QuantityConstant.RECEIPT_HEADER_CHECK.toString());

                } else {
                    receiptDetail.setProcessStamp(status);
                }

                return receiptDetail;
            } else {

                //以上都没有的情况下查询入库首选项中的入库流程

                LambdaQueryWrapper<ConfigValue> lambdaQueryWrapper = Wrappers.lambdaQuery();
                lambdaQueryWrapper.eq(ConfigValue::getModuleType, "receipt");
                ConfigValue configValue = configValueService.getOne(lambdaQueryWrapper);

                LambdaQueryWrapper<ReceiptPreference> lambda = Wrappers.lambdaQuery();

                lambda.eq(ReceiptPreference::getCode, configValue.getValue());

                ReceiptPreference receiptPreference = receiptPreferenceService.getOne(lambda);
                List<StatusFlowDetail> statusFlowDetails = statusFlowDetailService.queryStatusFlowDetail(receiptPreference.getReceivingFlow());

                String status = nextStatusFlow(statusFlowDetails, receiptDetail.getProcessStamp());

                //在状态到达时候是判断是否要质检

                if (QuantityConstant.RECEIPT_HEADER_RECEIVING.toString().equals(status) && inspection(receiptDetail)) {

                    receiptDetail.setProcessStamp(QuantityConstant.RECEIPT_HEADER_CHECK.toString());

                } else {
                    receiptDetail.setProcessStamp(status);
                }

                return receiptDetail;
            }
        }
    }

    /**
     * 获取配置流程中下一状态

     *

     * @param statusFlowDetails 流程列表

     * @param status            当前状态

     */

    public String nextStatusFlow(List<StatusFlowDetail> statusFlowDetails, String status) {

        //判断当前状态是否为最后状态，若为最后状态返回当前状态

        if (StringUtils.isEmpty(status)) {

            status = "0";
        }

        if (status.equals(statusFlowDetails.get(statusFlowDetails.size() - 1).getFlowCode())) {

            return status;
        } else {

            for (int i = 0; i < statusFlowDetails.size(); i++) {
                if (Integer.parseInt(statusFlowDetails.get(i).getFlowCode()) > Integer.parseInt(status)) {

                    return statusFlowDetails.get(i).getFlowCode();
                }
            }
            return status;
        }
    }

    @Override

    public List<StatusFlowDetail> queryflow() {

        LambdaQueryWrapper<ConfigValue> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(ConfigValue::getModuleType, "receipt");
        ConfigValue configValue = configValueService.getOne(lambdaQueryWrapper);

        LambdaQueryWrapper<ReceiptPreference> lambda = Wrappers.lambdaQuery();
        lambda.eq(ReceiptPreference::getCode, configValue.getValue());
        ReceiptPreference receiptPreference = receiptPreferenceService.getOne(lambda);
        List<StatusFlowDetail> statusFlowDetails = statusFlowDetailService.queryStatusFlowDetail(receiptPreference.getReceivingFlow());
        return statusFlowDetails;
    }

    /**

     * @param id 头表id

     * @description 更新头表尾状态
     * 每次明细表更新后调用该方法
     * 当所有明细表到达该状态时，更新头表状态
     */

    @Override

    public void updateReceiptHeaderLastStatus(Integer id) {

        LambdaQueryWrapper<ReceiptDetail> lambdaDetails = Wrappers.lambdaQuery();
        lambdaDetails.eq(ReceiptDetail::getReceiptId, id);
        List<ReceiptDetail> receiptDetails = this.list(lambdaDetails);
        //查询出头表信息
        ReceiptHeader receiptHeader = receiptHeaderService.getById(id);

        int minStatus;
        int maxStatus;
        // 判断入库明细是否为空, 为空时入库单头表状态为新建

        if (receiptDetails.isEmpty()) {

            minStatus = 0;
            maxStatus = 0;
        } else {
            minStatus = Integer.parseInt(receiptDetails.get(0).getProcessStamp());
            maxStatus = Integer.parseInt(receiptDetails.get(0).getProcessStamp());
            //遍历明细状态得出最小状态值

            for (int i = 1; i < receiptDetails.size(); i++) {
                if (minStatus > Integer.parseInt(receiptDetails.get(i).getProcessStamp())) {

                    minStatus = Integer.parseInt(receiptDetails.get(i).getProcessStamp());
                }

                if (maxStatus < Integer.parseInt(receiptDetails.get(i).getProcessStamp())) {

                    maxStatus = Integer.parseInt(receiptDetails.get(i).getProcessStamp());
                }

            }
        }
        //若更新状态值小于头状态，更新尾状态否则更新头尾状态

        receiptHeader.setFirstStatus(maxStatus);
        receiptHeader.setLastStatus(minStatus);
        if (!receiptHeaderService.updateById(receiptHeader)) {
            throw new ServiceException("更新状态失败");

        }
    }

    /**

     * @param receiptHeaderIdSet 头表id

     * @description 更新头表尾状态
     * 每次明细表更新后调用该方法
     * 当所有明细表到达该状态时，更新头表状态
     */
    @Override

    public void updateReceiptHeaderLastStatusV2(Set<Integer> receiptHeaderIdSet) {
        for (Integer id : receiptHeaderIdSet) {

            LambdaQueryWrapper<ReceiptDetail> lambdaDetails = Wrappers.lambdaQuery();
            lambdaDetails.eq(ReceiptDetail::getReceiptId, id);
            lambdaDetails.orderByDesc(ReceiptDetail::getProcessStamp);
            List<ReceiptDetail> receiptDetails = this.list(lambdaDetails);
            //查询出头表信息
            ReceiptHeader receiptHeader = receiptHeaderService.getById(id);

            int minStatus = 0;
            int maxStatus = 0;
            if (receiptDetails != null && receiptDetails.size() > 0) {

                receiptDetails = receiptDetails.stream().sorted(Comparator.comparing(ReceiptDetail::getProcessStamp)).collect(Collectors.toList());

                minStatus = Integer.valueOf(receiptDetails.get(0).getProcessStamp());
                maxStatus = Integer.valueOf(receiptDetails.get(receiptDetails.size() - 1).getProcessStamp());

            }
            //若更新状态值小于头状态，更新尾状态否则更新头尾状态
            receiptHeader.setFirstStatus(maxStatus);
            receiptHeader.setLastStatus(minStatus);
            if (!receiptHeaderService.updateById(receiptHeader)) {
                throw new ServiceException("更新状态失败");
            }
        }
    }

    /**
     * 入库单审核

     *

     * @param ids
     * @param approval
     * @return
     */

    @Override
    public AjaxResult approval(String ids, Integer approval) {
        ReceiptHeader receiptHeader = new ReceiptHeader();

        if (StringUtils.isEmpty(ids)) {

            return AjaxResult.error("id不能为空");
        }
        Integer[] idArray = Convert.toIntArray(ids);

        for (Integer id : idArray) {

            receiptHeader.setId(id);
            receiptHeader.setLastStatus(approval);
            receiptHeader.setFirstStatus(approval);
            receiptHeader.setLastUpdatedBy(ShiroUtils.getLoginName());

            if (!receiptHeaderService.updateById(receiptHeader)) {

                throw new ServiceException("更新头表失败");
            } else {
                LambdaQueryWrapper<ReceiptDetail> lambda = Wrappers.lambdaQuery();
                lambda.eq(ReceiptDetail::getReceiptId, id);
                List<ReceiptDetail> receiptDetails = this.list(lambda);

                for (ReceiptDetail receiptDetail : receiptDetails) {

                    receiptDetail.setProcessStamp(QuantityConstant.RECEIPT_HEADER_POOL.toString());

                    receiptDetail = this.queryflow(receiptDetail);

                    if (!this.updateById(receiptDetail)) {

                        throw new ServiceException("更新入库明细表失败");
                    }
                }
            }

            this.updateReceiptHeaderLastStatus(id);

        }
        return AjaxResult.success("审核完成");
    }

    @Override

    public List<TaskDetail> getReceiptQtyLast7Days() {

        return receiptDetailMapper.getReceiptQtyLast7Days();
    }

    @Override

    public List<TaskDetail> getWarehouseReceipt() {

        return receiptDetailMapper.getWarehouseReceipt();
    }

    @Override

    public List<TaskDetail> getCompanyReceipt() {

        return receiptDetailMapper.getCompanyReceipt();
    }

    /**
     * 判断明细中是否质检
     */

    public boolean inspection(ReceiptDetail receiptDetail) {

        //如果明细中需要质检，则判断是否已经生成质检单

        if ("0".equals(receiptDetail.getQcCheck())) {

            LambdaQueryWrapper<CheckHeader> lambda = Wrappers.lambdaQuery();

            lambda.eq(CheckHeader::getCode, receiptDetail.getReceiptCode());

            CheckHeader checkHeader = checkHeaderService.getOne(lambda);

            if (checkHeader == null) {

                return true;
            }
        }
        return false;
    }

    /**

     * //     * 移动端收货
     * //     *
     * //     * @param code
     * //     * @return
     * //
     */

    @Override
    public AjaxResult scanReceiptCode(String code, String type, String companyCode) {
        LambdaQueryWrapper<ReceiptHeader> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(ReceiptHeader::getReferCode, code)
                .eq(ReceiptHeader::getReceiptType, type);
        ReceiptHeader receiptHeader = receiptHeaderService.getOne(lambdaQueryWrapper);
        if (receiptHeader == null) {
            LambdaQueryWrapper<Company> companyLambdaQueryWrapper = Wrappers.lambdaQuery();

            companyLambdaQueryWrapper.eq(Company::getCode, companyCode);

            Company company = companyService.getOne(companyLambdaQueryWrapper);
            return AjaxResult.success("");

            //    return receiptHeaderService.findErpReceipt(String.valueOf(company.getId()), receiptHeader.getReferType(), receiptHeader.getReferCode());

        } else {
            LambdaQueryWrapper<ReceiptDetail> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.eq(ReceiptDetail::getReceiptCode, receiptHeader.getCode());
            List<ReceiptDetail> receiptDetailList = list(queryWrapper);
            return AjaxResult.success(receiptDetailList);
        }

    }

    @Override

    @Transactional(rollbackFor = Exception.class)

    public List<Integer> insertTodayReceiptDetail(int headerId, List<ReceiptBill> receiptBills, boolean isCompletedQty, String companyCode) {
        List<Integer> mReceiptDetailIds = new ArrayList<>();
        ReceiptHeader receiptHeader = receiptHeaderService.getById(headerId);

        for (ReceiptBill receiptBill : receiptBills) {

            ReceiptDetail receiptDetail = new ReceiptDetail();
            receiptDetail.setId(null);
            receiptDetail.setWarehouseCode(ShiroUtils.getWarehouseCode());

            receiptDetail.setCompanyCode(companyCode);

            receiptDetail.setUWarehouseCode(receiptHeader.getUWarehouseCode());

            receiptDetail.setReceiptId(receiptHeader.getId());
            receiptDetail.setReceiptCode(receiptHeader.getCode());
            receiptDetail.setMaterialCode(receiptBill.getMaterialCode());

            receiptDetail.setMaterialName(receiptBill.getMaterialName());

            Material material = materialService.getMaterialByCode(receiptBill.getMaterialCode(), ShiroUtils.getWarehouseCode());
            if (material != null) {

                receiptDetail.setMaterialName(material.getName());
                receiptDetail.setMaterialUnit(material.getUnit());
                receiptDetail.setMaterialSpec(material.getSpec());
            }

            receiptDetail.setInventorySts("good");

            receiptDetail.setQty(receiptBill.getQty());

            if (isCompletedQty) {

                receiptDetail.setTaskQty(receiptBill.getQty());

            }
            receiptDetail.setCreatedBy(ShiroUtils.getLoginName());
            receiptDetail.setLastUpdatedBy(ShiroUtils.getLoginName());
            receiptDetail.setDeleted(false);
            receiptDetail.setBatch(receiptBill.getBatch());
            save(receiptDetail);
            mReceiptDetailIds.add(receiptDetail.getId());
        }
        return mReceiptDetailIds;
    }

    @Override

    @Transactional(rollbackFor = Exception.class)

    public String insertExcelData(List<ReceiptDetail> list, boolean updateSupport, String operName) {
        if (StringUtils.isNull(list) || list.size() == 0) {

            throw new ServiceException("导入数据不能为空！");

        }

        //过滤物料为空的数据
        list = list.stream().filter(e -> StringUtils.isNotEmpty(e.getMaterialCode())).collect(Collectors.toList());