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

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.huaheng.common.exception.BusinessException;
import com.huaheng.common.utils.Wrappers;
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.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.receiptContainerDetail.domain.ReceiptContainerDetail;
import com.huaheng.pc.receipt.receiptHeader.domain.ReceiptHeader;
import com.huaheng.pc.receipt.receiptHeader.service.ReceiptHeaderService;
import com.huaheng.pc.system.config.domain.Config;
import com.huaheng.pc.system.dict.domain.DictData;
import com.huaheng.pc.system.dict.service.IDictDataService;
import com.huaheng.pc.task.taskDetail.domain.TaskDetail;
import io.swagger.models.auth.In;
import org.aspectj.weaver.loadtime.Aj;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.huaheng.pc.receipt.receiptDetail.domain.ReceiptDetail;
import com.huaheng.pc.receipt.receiptDetail.mapper.ReceiptDetailMapper;
import com.huaheng.pc.receipt.receiptDetail.service.ReceiptDetailService;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@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 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;
    }

    /**
     * @description 更新头表尾状态
     * 每次明细表更新后调用该方法
     * 当所有明细表到达该状态时，更新头表状态
     * @param id 头表id
     */
    @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("更新状态失败");
        }
    }
    /**
     * @description 更新头表尾状态
     * 每次明细表更新后调用该方法
     * 当所有明细表到达该状态时，更新头表状态
     * @param receiptHeaderIdSet 头表id
     */
    @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);
            lambdaDetails.last("limit 1");
            List<ReceiptDetail> receiptDetails = this.list(lambdaDetails);
            //查询出头表信息
            ReceiptHeader receiptHeader = receiptHeaderService.getById(id);
            int minStatus=0;
            int maxStatus=0;
            if(receiptDetails!=null&&receiptDetails.size()>0){
                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 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
    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.setReceiptId(receiptHeader.getId());
            receiptDetail.setReceiptCode(receiptHeader.getCode());
            receiptDetail.setMaterialCode(receiptBill.getMaterialCode());
            receiptDetail.setMaterialName(receiptBill.getMaterialName());
            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("导入数据不能为空！");
        }
        //新增入库头表
        ReceiptHeader receiptHeader=createHeader(operName,list);
        int successNum = 0;
        int failureNum = 0;
        StringBuilder successMsg = new StringBuilder();
        StringBuilder failureMsg = new StringBuilder();
        for (ReceiptDetail importData : list) {
            /*if(StringUtils.isEmpty(importData.getWarehouseCode())){
                failureNum++;
                String msg = "<br/>" + failureNum + "、仓库编码为空 导入失败：";
                failureMsg.append(msg );
                continue;
            }
            if(StringUtils.isEmpty(importData.getCompanyCode())){
                failureNum++;
                String msg = "<br/>" + failureNum + "、货主编码为空 导入失败：";
                failureMsg.append(msg );
                continue;
            }*/
            if(StringUtils.isNull(importData.getQty())){
                failureNum++;
                String msg = "<br/>" + failureNum + "、数量为空 导入失败：";
                failureMsg.append(msg );
                continue;
            }
            try {
                importData.setReceiptId(receiptHeader.getId());
                importData.setReceiptCode(receiptHeader.getCode());
                Material material = materialService.getMaterialByCode(importData.getMaterialCode());
                importData.setMaterialName(material.getName());
                importData.setMaterialSpec(material.getSpec());
                importData.setMaterialUnit(material.getUnit());
                importData.setWarehouseCode(ShiroUtils.getWarehouseCode());
                importData.setCompanyCode(QuantityConstant.COMPANY_CS);
                importData.setInventorySts(QuantityConstant.GOOD);
                this.save(importData);
                successNum++;
                successMsg.append("<br/>" + successNum + "、数据 " + importData.getMaterialCode() + " 导入成功");

            } catch (Exception e) {
                failureNum++;
                String msg = "<br/>" + failureNum + "、物料编码 " + importData.getMaterialCode() + " 导入失败：";
                failureMsg.append(msg + e.getMessage());
            }
        }
        if (failureNum > 0) {
            failureMsg.insert(0, "很抱歉，导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
            throw new ServiceException(failureMsg.toString());
        } else {
            successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
        }
        return successMsg.toString();
    }

    public ReceiptHeader createHeader(String operName,List<ReceiptDetail> list){
        ReceiptHeader receiptHeader=new ReceiptHeader();
        receiptHeader.setWarehouseCode(ShiroUtils.getWarehouseCode());
        String code =receiptHeaderService.createCode(QuantityConstant.RECEIPT_TYPE_PPI,receiptHeader.getWarehouseCode());
        receiptHeader.setId(null);
        receiptHeader.setLastUpdated(null);
        receiptHeader.setLastUpdatedBy(operName);
        receiptHeader.setCreated(null);
        receiptHeader.setCreatedBy(operName);

        receiptHeader.setCompanyCode(QuantityConstant.COMPANY_CS);
        receiptHeader.setCode(code);
        receiptHeader.setReceiptType(QuantityConstant.RECEIPT_TYPE_PPI);
        receiptHeader.setTotalLines(list.size());
        receiptHeader.setFirstStatus(QuantityConstant.RECEIPT_HEADER_BUILD);
        receiptHeader.setLastStatus(QuantityConstant.RECEIPT_HEADER_BUILD);
        BigDecimal bigDecimal = list.stream().map(ReceiptDetail::getQty).reduce(BigDecimal::add).orElse(BigDecimal.ZERO);
        receiptHeader.setTotalQty(bigDecimal);
        if (!receiptHeaderService.save(receiptHeader)) {
            throw new ServiceException("导入失败,添加入库单头表失败");
        }
        return receiptHeader;
    }

    @Override
    public String getWorkNo(Integer id) {
        LambdaQueryWrapper<ReceiptDetail> detailLambda = Wrappers.lambdaQuery();
        detailLambda.eq(ReceiptDetail::getId, id);
        detailLambda.last("limit 1");
        ReceiptDetail receiptDetail= this.getOne(detailLambda);
        if(receiptDetail!=null){
            return receiptDetail.getMoCode();
        }
        return null;
    }

    @Override
    public List<ReceiptDetail> getByHeaderCode(String code){
        LambdaQueryWrapper<ReceiptDetail> detailLambda = Wrappers.lambdaQuery();
        detailLambda.eq(ReceiptDetail::getReceiptCode,code);
        List<ReceiptDetail> list=this.list(detailLambda);
        return list;
    }
    @Override
    public List<ReceiptDetail> selectListEntityByLike(ReceiptDetail receiptDetail){
        LambdaQueryWrapper<ReceiptDetail> detailLambda = Wrappers.lambdaQuery();
        detailLambda.eq(StringUtils.isNotEmpty(receiptDetail.getReceiptCode()),ReceiptDetail::getReceiptCode,receiptDetail.getReceiptCode());
        detailLambda.eq(StringUtils.isNotNull(receiptDetail.getReceiptId()),ReceiptDetail::getReceiptId,receiptDetail.getReceiptId());
        detailLambda.eq(ReceiptDetail::getDeleted,false);

        List<ReceiptDetail> list=this.list(detailLambda);
        return list;
    }
    @Override
    public ReceiptDetail selectFirstEntity(ReceiptDetail receiptDetail){
        LambdaQueryWrapper<ReceiptDetail> detailLambda = Wrappers.lambdaQuery();
        detailLambda.eq(StringUtils.isNotNull(receiptDetail.getId()),ReceiptDetail::getReceiptCode,receiptDetail.getReceiptCode());
        detailLambda.eq(ReceiptDetail::getDeleted,false);
        detailLambda.last("limit 1");
        return this.getOne(detailLambda);
    }
    @Override
    public List<Map<String, Object>> selectList(String code, String goodsShelfNo) {
        String warehouseCode=ShiroUtils.getWarehouseCode();
        String shelfNo=goodsShelfNo.substring(1,5);
        return receiptDetailMapper.selectLists(code,shelfNo,warehouseCode);
    }
}