wms / hhwms · Files

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

import com.alibaba.fastjson.JSONException;
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.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.framework.web.service.ConfigService;
import com.huaheng.mobile.receipt.ReceiptBill;
import com.huaheng.pc.config.company.domain.CompanyU8;
import com.huaheng.pc.config.company.service.CompanyU8Service;
import com.huaheng.pc.config.configValue.domain.ConfigValue;
import com.huaheng.pc.config.configValue.mapper.ConfigValueMapper;
import com.huaheng.pc.config.container.domain.Container;
import com.huaheng.pc.config.container.service.ContainerService;
import com.huaheng.pc.config.location.domain.Location;
import com.huaheng.pc.config.location.service.LocationService;
import com.huaheng.pc.config.material.domain.Material;
import com.huaheng.pc.config.material.service.MaterialService;
import com.huaheng.pc.config.receiptPreference.domain.ReceiptPreference;
import com.huaheng.pc.config.receiptPreference.mapper.ReceiptPreferenceMapper;
import com.huaheng.pc.inventory.inventoryDetail.domain.InventoryDetail;
import com.huaheng.pc.inventory.inventoryDetail.service.InventoryDetailService;
import com.huaheng.pc.receipt.receiptContainerDetail.domain.ReceiptContainerDetail;
import com.huaheng.pc.receipt.receiptContainerDetail.service.ReceiptContainerDetailService;
import com.huaheng.pc.receipt.receiptContainerHeader.domain.ReceiptContainerHeader;
import com.huaheng.pc.receipt.receiptContainerHeader.domain.ReceiptContainerView;
import com.huaheng.pc.receipt.receiptContainerHeader.mapper.ReceiptContainerHeaderMapper;
import com.huaheng.pc.receipt.receiptDetail.domain.ReceiptDetail;
import com.huaheng.pc.receipt.receiptDetail.service.ReceiptDetailService;
import com.huaheng.pc.receipt.receiptHeader.domain.ReceiptHeader;
import com.huaheng.pc.receipt.receiptHeader.service.ReceiptHeaderService;
import com.huaheng.pc.shipment.shipmentContainerHeader.domain.ShipmentContainerHeader;
import com.huaheng.pc.shipment.shipmentContainerHeader.service.ShipmentContainerHeaderService;
import com.huaheng.pc.srm.service.FinishedProductService;
import com.huaheng.pc.system.dict.service.IDictDataService;
import com.huaheng.pc.task.taskDetail.domain.TaskDetail;
import com.huaheng.pc.task.taskDetail.service.TaskDetailService;
import com.huaheng.pc.task.taskHeader.domain.TaskHeader;
import com.huaheng.pc.task.taskHeader.service.TaskHeaderService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.text.MessageFormat;
import java.util.*;

/**
 * @author huaheng
 */
@Service
public class ReceiptContainerHeaderServiceImpl extends ServiceImpl<ReceiptContainerHeaderMapper, ReceiptContainerHeader> implements ReceiptContainerHeaderService {

    @Resource
    private TaskHeaderService taskHeaderService;
    @Resource
    private LocationService locationService;
    @Resource
    private ReceiptDetailService receiptDetailService;
    @Resource
    private ReceiptContainerDetailService receiptContainerDetailService;
    @Resource
    private MaterialService materialService;
    @Resource
    private ContainerService containerService;
    @Resource
    private ReceiptHeaderService receiptHeaderService;
    @Resource
    private InventoryDetailService inventoryDetailService;
    @Resource
    private ReceiptPreferenceMapper receiptPreferenceMapper;
    @Resource
    private ConfigValueMapper configValueMapper;
    @Resource
    private ConfigService configService;
    @Resource
    private ShipmentContainerHeaderService shipmentContainerHeaderService;
    @Resource
    private CompanyU8Service companyU8Service;
    @Resource
    private FinishedProductService finishedProductService;
    @Resource
    private IDictDataService dictDataService;
    @Resource
    private TaskDetailService taskDetailService;


    /**
     * 保存入库组盘
     * param receiptCode 入库单编码
     * param containerCode 容器编码
     * param receiptDetailId 入库单详情id
     * param locationCode 库位编码
     * param qty 收货数量
     * param locatingRule 定位规则
     *
     * @return 是否保存成功
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult saveContainer(ReceiptContainerView receivingDamain) {
        String receiptCode = receivingDamain.getReceiptCode();
        String containerCode = receivingDamain.getContainerCode();
        Integer receiptDetailId = receivingDamain.getReceiptDetailId();
        String locationCode = receivingDamain.getLocationCode();
        BigDecimal qty = receivingDamain.getQty();
        String locatingRule = receivingDamain.getLocatingRule();
        ReceiptDetail detail = receiptDetailService.getById(receiptDetailId);

        BigDecimal receiptQty = detail.getQty().subtract(detail.getTaskQty());
        if (receiptQty.compareTo(qty) < 0) {
            return AjaxResult.error("入库明细可用数量" + receiptQty + ",收货数量" + qty + "；不允许超收");
        }

        if (ShiroUtils.getWarehouseCode().equals("KS0001")) {
            if (StringUtils.isEmpty(detail.getUWarehouseCode())) {
                throw new ServiceException("该单据没有关联u8仓库");
            }
        }
        //检查容器编码合法性
        Integer taskType = checkContainer(containerCode, detail.getMaterialCode());
        switch (taskType) {
            case 1:
                //创建临时容器
//            containerCode = createContainer();
//            taskType = QuantityConstant.TASK_TYPE_WHOLERECEIPT;
                throw new ServiceException("没有容器");
            case 2:
                throw new ServiceException("该物料不能放在这个容器上，请检查该物料是否可以混放");
            case 3:
                return AjaxResult.error("该物料不能放在这个容器或货架上，该容器已被其他操作员使用");
            default:
                if (taskType == 0) {
                    throw new ServiceException("容器状态未知");
                }
                break;
        }

        /*if (taskType == 1) {
            throw new ServiceException("没有容器");
        } else if (taskType == 2) {
            throw new ServiceException("该物料不能放在这个容器上，请检查该物料是否可以混放");
        } else {
            if (taskType == 0){ throw new ServiceException("容器状态未知"); }
        }*/

        if (QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT == taskType.intValue()) {
            Container container = containerService.getContainerByCode(containerCode);
            if (StringUtils.isNotNull(container) && StringUtils.isNotEmpty(container.getLocationCode())) {
                locationCode = container.getLocationCode();
            }
        }
        //检查库位编码合法性
        checkLocationCode(locationCode, containerCode, taskType);

        int unCompleteCombineNumber = shipmentContainerHeaderService.getUnCompleteCombineNumber(containerCode);
        if (unCompleteCombineNumber > 0) {
            throw new ServiceException("该托盘已经用于出库组盘");
        }
        /* 新建保存组盘头表记录*/
        //根据容器编码查询组盘表头记录
        LambdaQueryWrapper<ReceiptContainerHeader> lambda = Wrappers.lambdaQuery();
        lambda.eq(ReceiptContainerHeader::getContainerCode, containerCode)
                .le(ReceiptContainerHeader::getStatus, QuantityConstant.RECEIPT_CONTAINER_TASK);
        lambda.last("limit 1");
        ReceiptContainerHeader receiptContainerHeader = this.getOne(lambda);

//        ReceiptContainerHeader receiptContainerHeader = new ReceiptContainerHeader();
        //当size大于等于1表示容器已经有组盘了
        if (receiptContainerHeader == null) {
            ReceiptDetail receiptDetail = receiptDetailService.getById(receiptDetailId);
            // 创建组盘头表
            receiptContainerHeader = createReceiptContainerHeader(receiptContainerHeader, containerCode, locationCode, receiptDetail, taskType, locatingRule);
            if (!this.save(receiptContainerHeader)) {
                throw new ServiceException("入库组盘头表保存失败");
            }
        } else {
//            receiptContainerHeader = list.get(0);
            if (receiptContainerHeader.getStatus() > QuantityConstant.RECEIPT_CONTAINER_TASK && receiptContainerHeader.getStatus() < QuantityConstant.RECEIPT_CONTAINER_FINISHED) {
                throw new ServiceException("容器已经生成任务，不能放物料了！");
            }
        }
//        List<ReceiptContainerHeader> receiptContainerHeaders = this.list(lambda);
        /* 更新入库单详情的收货数量*/
        //根据入库单详情id查询入库详情
        ReceiptDetail receiptDetail = receiptDetailService.getById(receiptDetailId);
        receiptDetail.setId(receiptDetailId);
        receiptDetail.setTaskQty(qty.add(receiptDetail.getTaskQty()));
        //更新入库单详情的收货数量
        if (!receiptDetailService.updateById(receiptDetail)) {
            throw new ServiceException("更新入库单详情失败");
        }

        receiptDetail = receiptDetailService.getById(receiptDetailId);
        //save组盘明细
        receiptContainerDetailAdd(receiptContainerHeader, receiptDetail, qty, containerCode, locationCode);
        //如果单据数量等于已收数量，更新入库详情状态和入库单状态
        if (receiptDetail.getQty().compareTo(receiptDetail.getTaskQty()) == 0) {
            if (StringUtils.isNotEmpty(locationCode)) {
                receiptDetail.setProcessStamp(QuantityConstant.RECEIPT_HEADER_POSITION.toString());
            } else {
                receiptDetail.setProcessStamp(QuantityConstant.RECEIPT_HEADER_RECEIVING.toString());
            }
            if (!receiptDetailService.updateById(receiptDetail)) {
                throw new ServiceException("更新入库详情处理标记失败");
            }

            ReceiptDetail receiptDetail1 = receiptDetailService.queryflow(receiptDetail);
            if (!receiptDetailService.updateById(receiptDetail1)) {
                throw new ServiceException("更新入库详情下一流程失败");
            }
        }
        receiptDetailService.updateReceiptHeaderLastStatus(receiptDetail.getReceiptId());
        return AjaxResult.success("组盘成功");
    }

    public ReceiptContainerHeader createReceiptContainerHeader(ReceiptContainerHeader receiptContainerHeader
            , String containerCode, String locationCode, ReceiptDetail receiptDetail, Integer taskType, String locatingRule) {
        Container container = containerService.getContainerByCode(containerCode);
        if (ShiroUtils.getWarehouseCode().equals("KS0001")) {
            if (!container.getCompanyCode().equals(receiptDetail.getCompanyCode())) {
                throw new ServiceException("容器货主属性和单据不一致,请换容器");
            }
            if (StringUtils.isNotEmpty(receiptDetail.getUWarehouseCode()) && StringUtils.isNotEmpty(container.getUWarehouseCode())) {
                if (!container.getUWarehouseCode().equals(receiptDetail.getUWarehouseCode())) {
                    throw new ServiceException("容器仓库属性和单据不一致,请换容器");
                }
            }
        }
        receiptContainerHeader = new ReceiptContainerHeader();
        receiptContainerHeader.setWarehouseCode(ShiroUtils.getWarehouseCode());
        receiptContainerHeader.setCompanyCode(receiptDetail.getCompanyCode());
        receiptContainerHeader.setContainerCode(containerCode);

        receiptContainerHeader.setContainerType(container.getContainerType());
        receiptContainerHeader.setTaskType(taskType);
        //判断地面托盘
        if ("D".equals(container.getContainerType())) {
            receiptContainerHeader.setToLocation(container.getLocationCode());
            receiptContainerHeader.setFromLocation(container.getLocationCode());
            taskType = QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT;
        }
        if (ShiroUtils.getWarehouseCode().equals(QuantityConstant.WAREHOUSE_KS)) {
            //U8工单领料齐套验证
            ksCheckMesReceipt(receiptDetail);
        }

        if (taskType.equals(QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT)) {
            receiptContainerHeader.setFromLocation(container.getLocationCode());
            Location location = locationService.getLocationByCode(container.getLocationCode());
            String value = dictDataService.getDictValueByLabel(QuantityConstant.RULE_TASK_LOCATION, location.getZoneCode(), ShiroUtils.getWarehouseCode());
            int taskLocationRule = Integer.parseInt(value);
            if (taskLocationRule == QuantityConstant.RULE_TASK_SET_LOCATION) {
                receiptContainerHeader.setToLocation(container.getLocationCode());
            }
        } else {
//            receiptContainerHeader.setPort("P1004");
            receiptContainerHeader.setToLocation(locationCode);
        }
        receiptContainerHeader.setProjectNo(receiptDetail.getProjectNo());
        receiptContainerHeader.setCreatedBy(ShiroUtils.getLoginName());
        receiptContainerHeader.setLastUpdatedBy(ShiroUtils.getLoginName());
        receiptContainerHeader.setLocatingRule(locatingRule);
        return receiptContainerHeader;
    }

    //U8工单领料齐套验证
    public void ksCheckMesReceipt(ReceiptDetail receiptDetail) {
        ReceiptHeader receiptHeader = receiptHeaderService.getById(receiptDetail.getReceiptId());
        if (receiptHeader.getReceiptType().equals("SI") && StringUtils.isNotEmpty(receiptDetail.getReferLineNum())) {
            CompanyU8 companyWu = new CompanyU8();
            companyWu.setCompanyCode(receiptHeader.getCompanyCode());
            companyWu = companyU8Service.getByCode(companyWu);
            if (companyWu == null) {
                throw new ServiceException("入库单对应的U8账套不存在");
            }
            Map detailMap = new HashMap();
            detailMap.put("MODID", receiptDetail.getReferLineNum());
            detailMap.put("iQuantity", receiptDetail.getQty().subtract(receiptDetail.getTaskQty()));
            detailMap.put("itemcode", receiptDetail.getMaterialCode());

            List<Map> maps = new ArrayList<>();
            maps.add(detailMap);

            Map<String, Object> map = new HashMap();
            map.put("CompanyCode", companyWu.getUCompanyCode());
            map.put("details", maps);
            AjaxResult ajaxResult = finishedProductService.checkMesReceipt(map);
            if (ajaxResult.hasErr()) {
                throw new ServiceException(ajaxResult.getMsg());
            }
        }
    }

    /**
     * 超收检查
     *
     * @param detail
     * @param qty
     */
    private void checkOverReceiving(ReceiptDetail detail, BigDecimal qty) {
        BigDecimal _total = detail.getTaskQty().add(qty);
        if (_total.compareTo(detail.getQty()) <= 0) {
            //收货量<=明细总量
            return;
        }

        ConfigValue configValue = configValueMapper.getConfigValue(ShiroUtils.getWarehouseCode(), "receipt");
        ReceiptPreference preference = receiptPreferenceMapper.getReceiptPreference(ShiroUtils.getWarehouseCode(), configValue.getValue());
        if (!preference.getAllowOverReceiving()) {
            //入库首选项配置为不允许超收
            throw new ServiceException(String.format("不允许超收"));
        }

        //超收比例
        BigDecimal _over_rate = new BigDecimal(String.valueOf(1 + preference.getAllowOverReceivingQty() / 100.0));
        //超收量上限
        BigDecimal _total_over = detail.getQty().multiply(_over_rate);
        if (_total_over.compareTo(_total) >= 0) {
            //在入库首选项的超收范围内
            return;
        }

        //超过了入库首选项配置的超收比例
        throw new ServiceException(String.format("超收上限是: %s％",
                _over_rate.multiply(new BigDecimal(100))));
    }

    /**
     * 批量撤销入库组盘
     *
     * @param ids 容器头表标识列表
     * @return true 全部取消成功
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean cancelByIds(List<Integer> ids) {
        for (Integer id : ids) {
            //如果已生成任务则不允许取消组盘
            if (this.getById(id).getStatus() < QuantityConstant.RECEIPT_CONTAINER_TASK) {
                //根据组盘头表id查询组盘明细表
                LambdaQueryWrapper<ReceiptContainerDetail> containerDetailLambda = Wrappers.lambdaQuery();
                containerDetailLambda.eq(ReceiptContainerDetail::getReceiptContainerId, id);
                List<ReceiptContainerDetail> receiptContainerDetails = receiptContainerDetailService.list(containerDetailLambda);

                //查询入库单明细,减去已收数量，更新单据
                for (ReceiptContainerDetail receiptContainerDetail : receiptContainerDetails) {
                    ReceiptDetail receiptDetail = receiptDetailService.getById(receiptContainerDetail.getReceiptDetailId());
                    receiptDetail.setTaskQty(receiptDetail.getTaskQty().subtract(receiptContainerDetail.getQty()));
                    if (!receiptDetailService.updateById(receiptDetail)) {
                        throw new ServiceException("回滚入库明细失败");
                    }

                    containerDetailLambda = Wrappers.lambdaQuery();
                    containerDetailLambda.eq(ReceiptContainerDetail::getReceiptId, receiptContainerDetail.getReceiptId());
                    List<ReceiptContainerDetail> containerDetailList = receiptContainerDetailService.list(containerDetailLambda);

                    //如果是临时容器，取消组盘时删除容器表
                    containerService.removeContainer(receiptContainerDetail.getContainerType(), receiptContainerDetail.getContainerCode());

                    //如果入库组盘没有该入库单的组盘信息，回滚入库单状态
                    if (containerDetailList == null) {
                        ReceiptHeader receiptHeader = new ReceiptHeader();
                        receiptHeader.setId(receiptContainerDetail.getReceiptId());
                        receiptHeader.setFirstStatus(QuantityConstant.RECEIPT_HEADER_RECEIVING);
                        receiptHeader.setLastStatus(QuantityConstant.RECEIPT_HEADER_RECEIVING);
                        receiptHeader.setLastUpdatedBy(ShiroUtils.getLoginName());

                        if (!receiptHeaderService.updateById(receiptHeader)) {
                            throw new ServiceException("回滚头表状态失败");
                        }
                    }

                    if (!receiptContainerDetailService.removeById(receiptContainerDetail.getId())) {
                        throw new ServiceException("删除入库组盘明细表失败，id是" + receiptContainerDetail.getId());
                    }
                }
                //删除入库组盘头表
                if (!this.removeById(id)) {
                    throw new ServiceException("删除入库组盘头表失败");
                }
            } else {
                throw new ServiceException("已生成任务不允许取消");
            }
        }
        return true;
    }

    /**
     * 检查容器状态
     *
     * @param record 容器实列
     * @return 成功 ；可以使用容器
     */
    @Override
    public AjaxResult checkContainer(ReceiptContainerView record) {
        //容器都是单据SN码，每个入库单都是新增容器

        if (com.huaheng.common.utils.StringUtils.isEmpty(record.getContainerCode())) {
            throw new ServiceException("容器不能为空");
        }

        if (taskHeaderService.UncompleteCount(record.getContainerCode()).intValue() > 0) {
            throw new ServiceException("容器已经存在任务，请更换容器");
        }
        return AjaxResult.success("");
    }


    @Override
    public AjaxResult batchSave(List<ReceiptContainerView> list) {
        if (list.size() < 1) {
            throw new ServiceException("收货明细是空！");
        }
        checkContainer(list.get(0));

        AjaxResult ajaxResult = null;
        for (ReceiptContainerView receiptContainerView : list) {
           /* ReceivingDamain receivingDamain=new ReceivingDamain();
            com.huaheng.common.utils.bean.BeanUtils.copyBeanProp(receivingDamain, receiptContainerView);
            receivingDamain.setContainerCode(receiptContainerView.getReceiptContainerCode());*/

            ajaxResult = saveContainer(receiptContainerView);
        }
        return ajaxResult;
    }

    @Override
    public AjaxResult PDAbatchSave(List<ReceiptContainerView> list) {
        if (list.size() < 1) {
            throw new ServiceException("收货明细是空！");
        }
        checkContainer(list.get(0));

        AjaxResult ajaxResult = null;
        for (ReceiptContainerView receiptContainerView : list) {
           /* ReceivingDamain receivingDamain=new ReceivingDamain();
            com.huaheng.common.utils.bean.BeanUtils.copyBeanProp(receivingDamain, receiptContainerView);
            receivingDamain.setContainerCode(receiptContainerView.getReceiptContainerCode());*/

            ajaxResult = PDAsaveContainer(receiptContainerView);
        }
        return ajaxResult;
    }

    /**
     * 移动端校验库位
     *
     * @param record
     * @return
     */
    @Override
    public Boolean mobileCheckLocationCode(ReceiptContainerView record) {
        return checkLocationCode(record.getLocationCode(), record.getContainerCode(), Integer.valueOf(record.getTaskType()));
    }

    /**
     * 检查容器编码合法性
     *
     * @param containerCode 容器编码
     * @param materialCode  物料编码
     * @return 返回容器状态，如果需自动生成容器编码返回1
     */
    @Transactional
    public Integer checkContainer(String containerCode, String materialCode) {
        Material material = materialService.getMaterialByCode(materialCode);
        if (StringUtils.isEmpty(containerCode)) {
            if (material.getAutoGenSerialNum() == 0) {
                return 1;
                //需自动生成容器编码
            } else {
                throw new ServiceException("容器不能为空");
            }
        }
        /**
         * 判断物料是否可以放在当前容器
         */
        if (!material.getIsMix()) {
            LambdaQueryWrapper<InventoryDetail> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.eq(InventoryDetail::getContainerCode, containerCode);
            /* 该容器已存物料数*/
            int inventoryDetailCount = inventoryDetailService.count(queryWrapper);
            LambdaQueryWrapper<InventoryDetail> lambdaQueryWrapper = Wrappers.lambdaQuery();
            lambdaQueryWrapper.eq(InventoryDetail::getContainerCode, containerCode)
                    .eq(InventoryDetail::getMaterialCode, materialCode);
            /* 该容器存放该物料的记录数*/
            int inventoryDetailMaterialCount = inventoryDetailService.count(lambdaQueryWrapper);
            /* 存放多种物料时返回*/
            if (inventoryDetailCount != inventoryDetailMaterialCount) {
                return 2;
            }
        }
        LambdaQueryWrapper<Container> lambda = Wrappers.lambdaQuery();
        lambda.eq(Container::getCode, containerCode);
        lambda.eq(Container::getWarehouseCode, ShiroUtils.getWarehouseCode());
        Container container = containerService.getOne(lambda);
        if (container == null) {
            throw new ServiceException("该容器编号不存在");
        }
        if (ShiroUtils.getWarehouseCode().equals("KS0001")) {
            if (!ShiroUtils.getCompanyCodeList().contains(container.getCompanyCode())) {
                throw new ServiceException("该操作员没有此容器的操作权限");
            }
            if (StringUtils.isEmpty(container.getUWarehouseCode())) {
                throw new ServiceException("该容器没有关联u8仓库");
            }
        }
        if (container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_LOCK)) {
//            throw new ServiceException("容器已经锁定，不能再组盘");
        }
        //检查该容器编码是否已存任务
        LambdaQueryWrapper<TaskHeader> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(TaskHeader::getContainerCode, containerCode)
                .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED)
                .ge(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_RELEASE)
                .eq(TaskHeader::getWarehouseCode, ShiroUtils.getWarehouseCode());
        if (taskHeaderService.count(lambdaQueryWrapper) > 0) {
            throw new ServiceException("容器已经存在任务，请更换容器");
        }
        //昆山检查该容器或者货架编码是否已存任务
        checkKSContainerORShelf(container);

        if (StringUtils.isEmpty(container.getLocationCode())) {
            return QuantityConstant.TASK_TYPE_WHOLERECEIPT;
        } else if (StringUtils.isNotEmpty(container.getStatus())
                && (container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_EMPTY)
                || container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_SOME))) {
            return QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT;
        } else if (QuantityConstant.STATUS_CONTAINER_FULL.equals(container.getStatus())) {
            throw new ServiceException("该容器已满，请更换容器");
        } else if (StringUtils.isNotEmpty(container.getStatus())
                && container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_LOCK)) {
            //当容器锁住时，同一个用户可以再次组盘
            LambdaQueryWrapper<TaskHeader> lambdaQuery = Wrappers.lambdaQuery();
            lambdaQuery.lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);
            lambdaQuery.eq(TaskHeader::getInternalTaskType, 100);
            lambdaQuery.eq(TaskHeader::getContainerCode, containerCode);
            if (ShiroUtils.getWarehouseCode().equals("KS0001")) {
                lambdaQuery.eq(TaskHeader::getCreatedBy, ShiroUtils.getUserName());
            }
            lambdaQuery.last("limit 1");
            lambdaQuery.orderByDesc(TaskHeader::getId);
            TaskHeader taskHeader = taskHeaderService.getOne(lambdaQuery);
            if (taskHeader != null) {
                return taskHeader.getTaskType();
            }
            return 3;
        }
        return 0;
    }


    public void checkKSContainerORShelf(Container container) {
        if (StringUtils.isNotEmpty(ShiroUtils.getWarehouseCode())
                && ShiroUtils.getWarehouseCode().equals(QuantityConstant.WAREHOUSE_KS)) {
            LambdaQueryWrapper<TaskHeader> lambdaQueryWrapper1 = Wrappers.lambdaQuery();
            if (container.getZoneCode().equals("AGV")) {
                if (StringUtils.isEmpty(container.getGoodsShelfNo())) {
                    throw new ServiceException("该容器没有绑定货架");
                }
                lambdaQueryWrapper1.eq(TaskHeader::getGoodsShelfNo, container.getGoodsShelfNo());
            } else {
                lambdaQueryWrapper1.eq(TaskHeader::getContainerCode, container.getCode());
            }
            lambdaQueryWrapper1.eq(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_BUILD);
            lambdaQueryWrapper1.eq(TaskHeader::getWarehouseCode, ShiroUtils.getWarehouseCode());
            lambdaQueryWrapper1.last("limit 1");
            TaskHeader task = taskHeaderService.getOne(lambdaQueryWrapper1);
            if (task != null) {
                if (task.getCreatedBy().equals(ShiroUtils.getUserName())) {
                } else {
                    throw new ServiceException("容器或货架已经存在任务，请更换容器");
                }
            }
        }
    }

    /**
     * 检查库位是否合法
     *
     * @param locationCode  库位编码
     * @param containerCode 容器编码
     * @param taskType      任务类型
     * @return
     */
    @Transactional
    Boolean checkLocationCode(String locationCode, String containerCode, Integer taskType) {
        //如果选了库位，就要校验库位和已经组盘的库位是否一致，避免重入库
        if (StringUtils.isEmpty(locationCode)) {
            if (QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT == taskType.intValue()) {
                throw new ServiceException("补充入库，必须填写库位");
            } else {
                return true;
            }
        }

        Location location = locationService.getLocationByCode(locationCode, ShiroUtils.getWarehouseCode());
        if (location == null) {
            throw new ServiceException("库位不存在！");
        }
        if (!QuantityConstant.STATUS_LOCATION_EMPTY.equals(location.getStatus())) {
//            throw new ServiceException("库位不是空闲状态！");
        }
        if (QuantityConstant.TASK_TYPE_WHOLERECEIPT == taskType.intValue()) {
            if (StringUtils.isNotEmpty(location.getContainerCode())) {
                throw new ServiceException("库位(" + locationCode + ")有容器(" + location.getContainerCode() + ")，不能整盘入库！");
            }
        }
        if (QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT == taskType.intValue()) {
            if (StringUtils.isEmpty(location.getContainerCode())) {
                throw new ServiceException("库位(" + locationCode + ")没有容器，不能补充入库！");
            } else if (!location.getContainerCode().equals(containerCode)) {
                throw new ServiceException("库位(" + containerCode + ")对应的容器是：" + location.getContainerCode() + "，请重选库位！");
            }
        }
        return true;
    }

    /**
     * 增加组盘明细记录
     *
     * @param
     * @param receiptDetail 入库详情
     * @param qty           收货数量
     * @param containerCode 容器编码
     */
    @Transactional
    public void receiptContainerDetailAdd(ReceiptContainerHeader receiptContainerHeader, ReceiptDetail receiptDetail, BigDecimal qty, String containerCode, String locationCode) {
        int receiptContainerHeaderId = receiptContainerHeader.getId();
        LambdaQueryWrapper<ReceiptContainerDetail> lambda = Wrappers.lambdaQuery();
        lambda.eq(ReceiptContainerDetail::getReceiptContainerId, receiptContainerHeaderId)
                .eq(ReceiptContainerDetail::getReceiptId, receiptDetail.getReceiptId())
                .eq(ReceiptContainerDetail::getReceiptDetailId, receiptDetail.getId())
                .last("Limit 1");
        ReceiptContainerDetail receiptContainerDetail = receiptContainerDetailService.getOne(lambda);
        //查询容器
        LambdaQueryWrapper<Container> containerLambda = Wrappers.lambdaQuery();
        containerLambda.eq(Container::getCode, containerCode)
                .eq(Container::getWarehouseCode, ShiroUtils.getWarehouseCode());
        Container container = containerService.getOne(containerLambda);
        if (receiptContainerDetail == null) {
            //查询入库头表
            LambdaQueryWrapper<ReceiptHeader> receiptHeaderLambda = Wrappers.lambdaQuery();
            receiptHeaderLambda.eq(ReceiptHeader::getId, receiptDetail.getReceiptId())
                    .eq(ReceiptHeader::getCode, receiptDetail.getReceiptCode());
            ReceiptHeader receiptHeader = receiptHeaderService.getOne(receiptHeaderLambda);


            receiptContainerDetail = new ReceiptContainerDetail();
            receiptContainerDetail.setReceiptContainerId(receiptContainerHeaderId);
            receiptContainerDetail.setWarehouseCode(ShiroUtils.getWarehouseCode());
            receiptContainerDetail.setUWarehouseCode(receiptHeader.getUWarehouseCode());
            receiptContainerDetail.setReceiptId(receiptDetail.getReceiptId());
            receiptContainerDetail.setReceiptDetailId(receiptDetail.getId());
            receiptContainerDetail.setTaskType(receiptContainerHeader.getTaskType());
            receiptContainerDetail.setReceiptCode(receiptDetail.getReceiptCode());
            receiptContainerDetail.setReceiptType(receiptHeader.getReceiptType());
            receiptContainerDetail.setLocationCode(locationCode);
            receiptContainerDetail.setContainerCode(container.getCode());
            receiptContainerDetail.setContainerType(container.getContainerType());
            receiptContainerDetail.setCompanyCode(receiptDetail.getCompanyCode());
            receiptContainerDetail.setMaterialCode(receiptDetail.getMaterialCode());
            receiptContainerDetail.setMaterialName(receiptDetail.getMaterialName());
            receiptContainerDetail.setMaterialSpec(receiptDetail.getMaterialSpec());
            receiptContainerDetail.setMaterialUnit(receiptDetail.getMaterialUnit());
            receiptContainerDetail.setQty(qty);
            receiptContainerDetail.setSupplierCode(receiptDetail.getSupplierCode());
            receiptContainerDetail.setBatch(receiptDetail.getBatch());
            receiptContainerDetail.setLot(receiptDetail.getLot());
            receiptContainerDetail.setProjectNo(receiptDetail.getProjectNo());
            receiptContainerDetail.setManufactureDate(receiptDetail.getManufactureDate());
            receiptContainerDetail.setExpirationDate(receiptDetail.getExpirationDate());
            receiptContainerDetail.setAgingDate(receiptDetail.getAgingDate());
            receiptContainerDetail.setInventorySts(receiptDetail.getInventorySts());
            receiptContainerDetail.setCreatedBy(ShiroUtils.getLoginName());
            receiptContainerDetail.setLastUpdatedBy(ShiroUtils.getLoginName());
            receiptContainerDetail.setSyncMms(0);
            receiptContainerDetail.setZoneCode(container.getZoneCode());
            receiptContainerDetail.setColor(receiptDetail.getColor());
            if (!receiptContainerDetailService.save(receiptContainerDetail)) {
                throw new ServiceException("保存入库组盘详情失败");
            }
        } else {
            receiptContainerDetail.setQty(receiptContainerDetail.getQty().add(qty));
            receiptContainerDetail.setZoneCode(container.getZoneCode());
            if (!receiptContainerDetailService.updateById(receiptContainerDetail)) {
                throw new ServiceException("更新入库组盘详情失败");
            }
        }

    }


    /**
     * 自动生成容器编码
     *
     * @return 容器编码
     */
    @Transactional
    public String createContainer() {
        String code = MessageFormat.format("{0}{1}",
                "LS",
                String.format("%d", Calendar.getInstance().getTimeInMillis()));
        Container container = new Container();
        container.setCode(code);
        container.setWarehouseCode(ShiroUtils.getWarehouseCode());
        container.setCompanyCode(ShiroUtils.getCompanyCodeList().get(0));
        container.setContainerType("LS");
        container.setCreatedBy(ShiroUtils.getLoginName());
        container.setLastUpdated(new Date());
        container.setLastUpdatedBy(ShiroUtils.getLoginName());
        container.setEnable(true);
        container.setStatus(QuantityConstant.STATUS_CONTAINER_EMPTY);
        if (!containerService.save(container)) {
            throw new ServiceException("新增容器失败");
        }
        return code;
    }

    @Override
    @Transactional
    public int insertTodayReceiptContainerHeader(ReceiptBill receiptBill, String receiptCode) {
        String receiptContainerCode = receiptBill.getReceiptContainerCode();
        String locationCode = receiptBill.getLocationCode();
        String companyCode = receiptBill.getCompanyCode();
        ReceiptContainerHeader recorder = new ReceiptContainerHeader();
        recorder.setContainerCode(receiptContainerCode);
        recorder.setToLocation(locationCode);
        recorder.setWarehouseCode(ShiroUtils.getWarehouseCode());
        recorder.setCompanyCode(companyCode);
        recorder.setTaskType(QuantityConstant.TASK_TYPE_WHOLERECEIPT);
        recorder.setStatus(QuantityConstant.RECEIPT_CONTAINER_BUILD);
        recorder.setCreatedBy(ShiroUtils.getLoginName());
        recorder.setLastUpdatedBy(ShiroUtils.getLoginName());

        LambdaQueryWrapper<ReceiptContainerHeader> receiptContainerHeaderLambada = Wrappers.lambdaQuery();
        receiptContainerHeaderLambada.eq(ReceiptContainerHeader::getContainerCode, receiptContainerCode)
                .eq(ReceiptContainerHeader::getCompanyCode, companyCode)
                .eq(ReceiptContainerHeader::getTaskType, String.valueOf(QuantityConstant.TASK_TYPE_WHOLERECEIPT))
                .eq(ReceiptContainerHeader::getStatus, 0);

        ReceiptContainerHeader receiptContainerHeader = getOne(receiptContainerHeaderLambada);
        if (receiptContainerHeader == null) {
            save(recorder);
        } else {
            return receiptContainerHeader.getId();
        }

        locationService.updateStatus(locationCode, QuantityConstant.STATUS_LOCATION_LOCK);
        containerService.updateLocationCodeAndStatus(receiptContainerCode,
                locationCode, QuantityConstant.STATUS_CONTAINER_SOME);
        return recorder.getId();
    }

    /**
     * 取消入库任务
     *
     * @param id 入库组盘头id
     * @return
     */
    @Override
    @Transactional
    public AjaxResult cancelReceipt(Integer id) {
        /**
         * 回滚组盘主表状态
         */
        ReceiptContainerHeader receiptContainerHeader = new ReceiptContainerHeader();
        receiptContainerHeader.setStatus(QuantityConstant.RECEIPT_CONTAINER_BUILD);
        receiptContainerHeader.setId(id);
        if (!updateById(receiptContainerHeader)) {
            throw new ServiceException("回滚入库组盘头表失败");
        }

        /**
         * 回滚组盘明细状态
         */
        LambdaQueryWrapper<ReceiptContainerDetail> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(ReceiptContainerDetail::getReceiptContainerId, id);
        List<ReceiptContainerDetail> containerDetailList = receiptContainerDetailService.list(lambdaQueryWrapper);
        for (ReceiptContainerDetail containerDetail : containerDetailList) {
            containerDetail.setStatus(QuantityConstant.RECEIPT_CONTAINER_BUILD);
        }
        if (containerDetailList != null && containerDetailList.size() > 0 && !receiptContainerDetailService.updateBatchById(containerDetailList)) {
            throw new ServiceException("回滚入库组盘明细失败");
        }

        /**
         * 回滚入库单头表、入库单明细状态
         */
        for (ReceiptContainerDetail containerDetail : containerDetailList) {
            ReceiptHeader receiptHeader = receiptHeaderService.getById(containerDetail.getReceiptId());
            receiptHeader.setLastStatus(QuantityConstant.RECEIPT_HEADER_WAIT);
            ReceiptDetail receiptDetail = receiptDetailService.getById(containerDetail.getReceiptDetailId());
            receiptDetail.setProcessStamp(String.valueOf(QuantityConstant.RECEIPT_HEADER_WAIT));
            if (!receiptHeaderService.updateById(receiptHeader)) {
                throw new ServiceException("回滚入库单头表失败");
            }
            if (!receiptDetailService.updateById(receiptDetail)) {
                throw new ServiceException("回滚入库单明细失败");
            }
        }
        return AjaxResult.success("成功");
    }

    @Override
    public int getUnCompleteCombineNumber(String containerCode) {
        LambdaQueryWrapper<ReceiptContainerHeader> receiptContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        receiptContainerHeaderLambdaQueryWrapper.eq(ReceiptContainerHeader::getContainerCode, containerCode)
                .lt(ReceiptContainerHeader::getStatus, QuantityConstant.RECEIPT_CONTAINER_FINISHED);
        int number = 0;
        List<ReceiptContainerHeader> receiptContainerHeaderList = list(receiptContainerHeaderLambdaQueryWrapper);
        if (receiptContainerHeaderList != null && receiptContainerHeaderList.size() > 0) {
            number = receiptContainerHeaderList.size();
        }
        return number;
    }

    @Override
    public List<ReceiptContainerHeader> getUnCompleteCombineList() {
        LambdaQueryWrapper<ReceiptContainerHeader> receiptContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        receiptContainerHeaderLambdaQueryWrapper
                .lt(ReceiptContainerHeader::getStatus, QuantityConstant.RECEIPT_CONTAINER_FINISHED);
        List<ReceiptContainerHeader> receiptContainerHeaderList = list(receiptContainerHeaderLambdaQueryWrapper);
        return receiptContainerHeaderList;
    }

    @Override
    public ReceiptContainerHeader selectFirstEntity(ReceiptContainerHeader query) {
        LambdaQueryWrapper<ReceiptContainerHeader> lamb = Wrappers.lambdaQuery();
        lamb.eq(StringUtils.isNotNull(query.getStatus()), ReceiptContainerHeader::getStatus, query.getStatus());
        lamb.eq(StringUtils.isNotEmpty(query.getContainerCode()), ReceiptContainerHeader::getContainerCode, query.getContainerCode());
        lamb.eq(StringUtils.isNotEmpty(query.getWarehouseCode()), ReceiptContainerHeader::getWarehouseCode, query.getWarehouseCode());
        lamb.last("limit 1");
        return this.getOne(lamb);
    }

    @Override
    public List<ReceiptContainerHeader> selectFirstEntityList(ReceiptContainerHeader query) {
        LambdaQueryWrapper<ReceiptContainerHeader> lamb = Wrappers.lambdaQuery();
        lamb.eq(StringUtils.isNotNull(query.getStatus()), ReceiptContainerHeader::getStatus, query.getStatus());
        lamb.eq(StringUtils.isNotEmpty(query.getContainerCode()), ReceiptContainerHeader::getContainerCode, query.getContainerCode());
        lamb.eq(StringUtils.isNotEmpty(query.getWarehouseCode()), ReceiptContainerHeader::getWarehouseCode, query.getWarehouseCode());
        return this.list(lamb);
    }

    @Override
    public AjaxResult clearContainerHeader() {
        LambdaQueryWrapper<ReceiptContainerHeader> receiptContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        receiptContainerHeaderLambdaQueryWrapper.eq(ReceiptContainerHeader::getStatus,
                QuantityConstant.RECEIPT_CONTAINER_BUILD);
        List<ReceiptContainerHeader> receiptContainerHeaderList =
                this.list(receiptContainerHeaderLambdaQueryWrapper);
        for (ReceiptContainerHeader receiptContainerHeader : receiptContainerHeaderList) {
            Date date = receiptContainerHeader.getCreated();
            Date now = new Date();
            int fore = date.getDay();
            int day = now.getDay();
            if (fore != day) {
                this.removeById(receiptContainerHeader);
            }
        }

        LambdaQueryWrapper<ReceiptContainerHeader> receiptContainerHeaderLambdaQueryWrapper1 = Wrappers.lambdaQuery();
        receiptContainerHeaderLambdaQueryWrapper1.eq(ReceiptContainerHeader::getStatus,
                QuantityConstant.RECEIPT_CONTAINER_TASK);
        List<ReceiptContainerHeader> receiptContainerHeaderList1 =
                this.list(receiptContainerHeaderLambdaQueryWrapper1);
        for (ReceiptContainerHeader receiptContainerHeader : receiptContainerHeaderList1) {
            String containerCode = receiptContainerHeader.getContainerCode();
            LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            taskHeaderLambdaQueryWrapper.lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED)
                    .in(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_WHOLERECEIPT,
                            QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT)
                    .eq(TaskHeader::getContainerCode, containerCode);
            List<TaskHeader> taskHeaderList = taskHeaderService.list(taskHeaderLambdaQueryWrapper);
            if (taskHeaderList.size() == 0) {
                receiptContainerHeader.setStatus(QuantityConstant.RECEIPT_CONTAINER_FINISHED);
                this.updateById(receiptContainerHeader);
            }
        }

        LambdaQueryWrapper<ShipmentContainerHeader> shipmentContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        shipmentContainerHeaderLambdaQueryWrapper.eq(ShipmentContainerHeader::getStatus,
                QuantityConstant.SHIPMENT_CONTAINER_BUILD);
        List<ShipmentContainerHeader> shipmentContainerHeaderList =
                shipmentContainerHeaderService.list(shipmentContainerHeaderLambdaQueryWrapper);
        for (ShipmentContainerHeader shipmentContainerHeader : shipmentContainerHeaderList) {
            Date date = shipmentContainerHeader.getCreated();
            Date now = new Date();
            int fore = date.getDay();
            int day = now.getDay();
            if (fore != day) {
                shipmentContainerHeaderService.removeById(shipmentContainerHeader);
            }
        }

        LambdaQueryWrapper<ShipmentContainerHeader> shipmentContainerHeaderLambdaQueryWrapper1 = Wrappers.lambdaQuery();
        shipmentContainerHeaderLambdaQueryWrapper1.eq(ShipmentContainerHeader::getStatus,
                QuantityConstant.SHIPMENT_CONTAINER_TASK);
        List<ShipmentContainerHeader> shipmentContainerHeaderList1 =
                shipmentContainerHeaderService.list(shipmentContainerHeaderLambdaQueryWrapper1);
        for (ShipmentContainerHeader shipmentContainerHeader : shipmentContainerHeaderList1) {
            String containerCode = shipmentContainerHeader.getContainerCode();
            LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            taskHeaderLambdaQueryWrapper.lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED)
                    .in(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_WHOLESHIPMENT,
                            QuantityConstant.TASK_TYPE_SORTINGSHIPMENT)
                    .eq(TaskHeader::getContainerCode, containerCode);
            List<TaskHeader> taskHeaderList = taskHeaderService.list(taskHeaderLambdaQueryWrapper);
            if (taskHeaderList.size() == 0) {
                shipmentContainerHeader.setStatus(QuantityConstant.SHIPMENT_CONTAINER_FINISHED);
                shipmentContainerHeaderService.updateById(shipmentContainerHeader);
            }
        }
        return AjaxResult.success();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult quickNoListReceipt(List<ReceiptBill> receiptBills) {
        if (receiptBills == null || receiptBills.size() <= 0) {
            throw new JSONException("没有收货信息");
        }
        boolean flag = true;
        String containerCode = receiptBills.get(0).getReceiptContainerCode();
        String locationCode = receiptBills.get(0).getLocationCode();
        Container container = new Container();
        container.setCode(containerCode);
        container.setWarehouseCode(ShiroUtils.getWarehouseCode());
        container = containerService.selectFirstEntity(container);
        if (container == null) {
            throw new JSONException("不存在这个托盘");
        }
        if (locationCode != null && locationCode.equals(container.getLocationCode())) {
            //查询未完成的入库任务
            List<TaskHeader> tasks = taskHeaderService.selectNofinishReceiptTaskBycontainer(container.getCode());
            TaskHeader task = tasks.get(0);
            if (tasks == null && tasks.size() < 1) {
                throw new JSONException("没有找到托盘对应的任务");
            }
            int receiptHeaderId = receiptHeaderService.createTodayHeader(receiptBills.get(0).getCompanyCode(), container.getUWarehouseCode());
            ReceiptHeader receiptHeader = receiptHeaderService.getById(receiptHeaderId);
            List<Integer> receiptDetailIds = receiptDetailService.insertTodayReceiptDetail(receiptHeaderId,
                    receiptBills, false, receiptBills.get(0).getCompanyCode());
            ReceiptContainerHeader receiptContainerHeader = new ReceiptContainerHeader();
            receiptContainerHeader.setContainerCode(containerCode);
            receiptContainerHeader.setWarehouseCode(ShiroUtils.getWarehouseCode());
            receiptContainerHeader.setTaskType(200);
            receiptContainerHeader.setCompanyCode(receiptBills.get(0).getCompanyCode());
            receiptContainerHeader.setFromLocation(container.getLocationCode());
            receiptContainerHeader.setCreatedBy(ShiroUtils.getLoginName());
            receiptContainerHeader.setStatus(10);
            if (!this.save(receiptContainerHeader)) {
                throw new ServiceException("入库组盘头表保存失败");
            }
            receiptHeader.setFirstStatus(200);
            receiptHeader.setLastStatus(200);
            receiptHeaderService.updateById(receiptHeader);
            task.setAllocationHeadId(receiptContainerHeader.getId());
            taskHeaderService.updateById(task);
            List<Integer> receiptContainerDetailIds = new ArrayList<>();
            receiptDetailIds.forEach(id -> {
                ReceiptDetail receiptDetail = receiptDetailService.getById(id);
                ReceiptContainerDetail receiptContainerDetail = new ReceiptContainerDetail();
                receiptContainerDetail.setReceiptContainerId(receiptContainerHeader.getId());
                receiptContainerDetail.setReceiptId(receiptHeader.getId());
                receiptContainerDetail.setReceiptDetailId(receiptDetail.getId());
                receiptContainerDetail.setReceiptCode(receiptHeader.getCode());

                Material material = materialService.getMaterialByCode(receiptDetail.getMaterialCode(), ShiroUtils.getWarehouseCode());

                receiptContainerDetail.setMaterialCode(material.getCode());
                receiptContainerDetail.setMaterialName(material.getName());
                receiptContainerDetail.setMaterialSpec(material.getSpec());
                receiptContainerDetail.setQty(receiptDetail.getQty());
                receiptContainerDetail.setCreatedBy(ShiroUtils.getLoginName());
                receiptContainerDetailService.save(receiptContainerDetail);
                receiptContainerDetailIds.add(receiptContainerDetail.getId());
            });


            receiptContainerDetailIds.forEach(id -> {
                ReceiptContainerDetail receiptContainerDetail = receiptContainerDetailService.getById(id);
                TaskDetail taskDetail = new TaskDetail();
                taskDetail.setTaskId(task.getId());
                taskDetail.setTaskType(QuantityConstant.TASK_TYPE_SUPPLEMENTRECEIPT);
                taskDetail.setInternalTaskType(QuantityConstant.TASK_INTENERTYPE_RECEIPT);
                taskDetail.setContainerCode(containerCode);
                taskDetail.setWarehouseCode(ShiroUtils.getWarehouseCode());
                taskDetail.setCompanyCode(receiptBills.get(0).getCompanyCode());
                taskDetail.setMaterialCode(receiptContainerDetail.getMaterialCode());
                taskDetail.setMaterialName(receiptContainerDetail.getMaterialName());
                taskDetail.setBillId(receiptHeader.getId());
                taskDetail.setBillCode(receiptHeader.getCode());
                taskDetail.setBillDetailId(receiptContainerDetail.getReceiptDetailId());
                taskDetail.setQty(receiptContainerDetail.getQty());
                taskDetail.setFromLocation(task.getFromLocation());
                taskDetail.setAllocationId(receiptContainerDetail.getId());
                taskDetail.setFromZone("LK");
                taskDetail.setToZone("LK");
                taskDetail.setCompanyCode(task.getCompanyCode());
                taskDetailService.save(taskDetail);
            });
        }
        return AjaxResult.success("收货成功");
    }


    //这个方法主要用agv库的补充入，不校验托盘情况
    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult PDAsaveContainer(ReceiptContainerView receivingDamain) {
        String receiptCode = receivingDamain.getReceiptCode();
        String containerCode = receivingDamain.getContainerCode();
        Integer receiptDetailId = receivingDamain.getReceiptDetailId();
        String locationCode = receivingDamain.getLocationCode();
        BigDecimal qty = receivingDamain.getQty();
        String locatingRule = receivingDamain.getLocatingRule();
        ReceiptDetail detail = receiptDetailService.getById(receiptDetailId);

        BigDecimal receiptQty = detail.getQty().subtract(detail.getTaskQty());
        if (receiptQty.compareTo(qty) < 0) {
            return AjaxResult.error("入库明细可用数量" + receiptQty + ",收货数量" + qty + "；不允许超收");
        }

        //检查容器编码合法性

        Container container = containerService.getContainerByCode(containerCode);
        if (StringUtils.isNotNull(container) && StringUtils.isNotEmpty(container.getLocationCode())) {
            locationCode = container.getLocationCode();
        }

        //检查库位编码合法性

        int unCompleteCombineNumber = shipmentContainerHeaderService.getUnCompleteCombineNumber(containerCode);
        if (unCompleteCombineNumber > 0) {
            throw new ServiceException("该托盘已经用于出库组盘");
        }
        /* 新建保存组盘头表记录*/
        //根据容器编码查询组盘表头记录
        LambdaQueryWrapper<ReceiptContainerHeader> lambda = Wrappers.lambdaQuery();
        lambda.eq(ReceiptContainerHeader::getContainerCode, containerCode)
                .le(ReceiptContainerHeader::getStatus, QuantityConstant.RECEIPT_CONTAINER_TASK);
        lambda.last("limit 1");
        ReceiptContainerHeader receiptContainerHeader = this.getOne(lambda);

//        ReceiptContainerHeader receiptContainerHeader = new ReceiptContainerHeader();
        //当size大于等于1表示容器已经有组盘了
        if (receiptContainerHeader == null) {
            ReceiptDetail receiptDetail = receiptDetailService.getById(receiptDetailId);
            // 创建组盘头表
            receiptContainerHeader = createReceiptContainerHeader(receiptContainerHeader, containerCode, locationCode, receiptDetail, 200, locatingRule);
            if (!this.save(receiptContainerHeader)) {
                throw new ServiceException("入库组盘头表保存失败");
            }
        } else {
//            receiptContainerHeader = list.get(0);
            if (receiptContainerHeader.getStatus() > QuantityConstant.RECEIPT_CONTAINER_TASK && receiptContainerHeader.getStatus() < QuantityConstant.RECEIPT_CONTAINER_FINISHED) {
                throw new ServiceException("容器已经生成任务，不能放物料了！");
            }
        }
//        List<ReceiptContainerHeader> receiptContainerHeaders = this.list(lambda);
        /* 更新入库单详情的收货数量*/
        //根据入库单详情id查询入库详情
        ReceiptDetail receiptDetail = receiptDetailService.getById(receiptDetailId);
        receiptDetail.setId(receiptDetailId);
        receiptDetail.setTaskQty(qty.add(receiptDetail.getTaskQty()));
        //更新入库单详情的收货数量
        if (!receiptDetailService.updateById(receiptDetail)) {
            throw new ServiceException("更新入库单详情失败");
        }

        receiptDetail = receiptDetailService.getById(receiptDetailId);
        //save组盘明细
        receiptContainerDetailAdd(receiptContainerHeader, receiptDetail, qty, containerCode, locationCode);
        //如果单据数量等于已收数量，更新入库详情状态和入库单状态
        if (receiptDetail.getQty().compareTo(receiptDetail.getTaskQty()) == 0) {
            if (StringUtils.isNotEmpty(locationCode)) {
                receiptDetail.setProcessStamp(QuantityConstant.RECEIPT_HEADER_POSITION.toString());
            } else {
                receiptDetail.setProcessStamp(QuantityConstant.RECEIPT_HEADER_RECEIVING.toString());
            }
            if (!receiptDetailService.updateById(receiptDetail)) {
                throw new ServiceException("更新入库详情处理标记失败");
            }

            ReceiptDetail receiptDetail1 = receiptDetailService.queryflow(receiptDetail);
            if (!receiptDetailService.updateById(receiptDetail1)) {
                throw new ServiceException("更新入库详情下一流程失败");
            }
        }
        receiptDetailService.updateReceiptHeaderLastStatus(receiptDetail.getReceiptId());
        return AjaxResult.success("组盘成功");
    }
}