wms / wms_guangxijianyi · Files

package com.huaheng.api.erp.service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.huaheng.api.erp.domain.*;
import com.huaheng.api.wcs.service.WcsService;
import com.huaheng.common.constant.HttpConstant;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.support.Convert;
import com.huaheng.common.utils.DateUtils;
import com.huaheng.common.utils.http.OkHttpUtils;
import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.framework.web.service.ConfigService;
import com.huaheng.pc.check.checkHeader.domain.CheckHeader;
import com.huaheng.pc.config.address.service.AddressService;
import com.huaheng.pc.config.bosAssistantDetail.domain.BosAssistantDetail;
import com.huaheng.pc.config.bosAssistantDetail.service.IBosAssistantDetailService;
import com.huaheng.pc.config.container.domain.Container;
import com.huaheng.pc.config.container.service.ContainerService;
import com.huaheng.pc.config.containerType.domain.ContainerType;
import com.huaheng.pc.config.containerType.service.ContainerTypeService;
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.proPackaging.domain.ProPackaging;
import com.huaheng.pc.config.proPackaging.service.IProPackagingService;
import com.huaheng.pc.inventory.InventoryHistoryDetail.domain.InventoryHistoryDetail;
import com.huaheng.pc.inventory.InventoryHistoryDetail.service.IInventoryHistoryDetailService;
import com.huaheng.pc.inventory.beDamaged.domain.BeDamaged;
import com.huaheng.pc.inventory.beDamaged.service.impl.BeDamagedServiceImpl;
import com.huaheng.pc.inventory.cycleCountDetail.domain.CycleCountDetail;
import com.huaheng.pc.inventory.cycleCountDetail.domain.CycleCountDetailChild;
import com.huaheng.pc.inventory.cycleCountDetail.service.CycleCountDetailChildService;
import com.huaheng.pc.inventory.cycleCountDetail.service.CycleCountDetailService;
import com.huaheng.pc.inventory.inventoryCacheDetail.domain.InventoryCacheDetail;
import com.huaheng.pc.inventory.inventoryCacheDetail.service.InventoryCacheDetailService;
import com.huaheng.pc.inventory.inventoryDetail.domain.InventoryDetail;
import com.huaheng.pc.inventory.inventoryDetail.service.InventoryDetailService;
import com.huaheng.pc.inventory.inventoryHeader.domain.InventoryHeader;
import com.huaheng.pc.inventory.inventoryHeader.service.InventoryHeaderService;
import com.huaheng.pc.inventory.inventoryHistoryHeader.domain.InventoryHistoryHeader;
import com.huaheng.pc.inventory.inventoryHistoryHeader.service.IInventoryHistoryHeaderService;
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.service.ReceiptContainerHeaderService;
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.service.ShipmentContainerHeaderService;
import com.huaheng.pc.shipment.shipmentDetail.domain.ShipmentDetail;
import com.huaheng.pc.shipment.shipmentDetail.service.ShipmentDetailService;
import com.huaheng.pc.shipment.shipmentHeader.domain.ShipmentHeader;
import com.huaheng.pc.shipment.shipmentHeader.service.ShipmentHeaderService;
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.agvTask.domain.AgvTask;
import com.huaheng.pc.task.agvTask.service.AgvTaskService;
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.ReceiptTaskService;
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.math.RoundingMode;
import java.text.MessageFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author 游杰
 */
@Service
public class CodingServiceImpl implements CodingService {

    @Resource
    private IInventoryHistoryDetailService inventoryHistoryDetailService;
    @Resource
    private IInventoryHistoryHeaderService inventoryHistoryHeaderService;
    @Resource
    private CycleCountDetailChildService cycleCountDetailChildService;
    @Resource
    private ShipmentDetailService shipmentDetailService;
    @Resource
    private ContainerService containerService;
    @Resource
    private ContainerTypeService containerTypeService;
    @Resource
    private ReceiptContainerHeaderService receiptContainerHeaderService;
    @Resource
    private ReceiptHeaderService receiptHeaderService;
    @Resource
    private PDAServiceImpl pdaService;
    @Resource
    private MaterialService materialService;
    @Resource
    private ShipmentHeaderService shipmentHeaderService;
    @Resource
    private AddressService addressService;
    @Resource
    private IProPackagingService proPackagingService;
    @Resource
    private ReceiptDetailService receiptDetailService;
    @Resource
    private ReceiptContainerDetailService receiptContainerDetailService;
    @Resource
    private ReceiptTaskService receiptTaskService;
    @Resource
    private AgvTaskService agvTaskService;
    @Resource
    private LocationService locationService;
    @Resource
    private WcsService wcsService;
    @Resource
    private ShipmentContainerHeaderService shipmentContainerHeaderService;
    @Resource
    private IBosAssistantDetailService bosAssistantDetailService;
    @Resource
    private InventoryDetailService inventoryDetailService;
    @Resource
    private BeDamagedServiceImpl beDamagedService;
    @Resource
    private IProPackagingService proPackingService;
    @Resource
    private CycleCountDetailService cycleCountDetailService;
    @Resource
    private InventoryCacheDetailService inventoryCacheDetailService;
    @Resource
    private TaskHeaderService taskHeaderService;
    @Resource
    private TaskDetailService taskDetailService;
    @Resource
    private IDictDataService iDictDataService;
    @Resource
    private InventoryHeaderService inventoryHeaderService;
    @Resource
    private ConfigService configService;

    @Override
    @Transactional(rollbackFor = Exception.class)

    public AjaxResult innerReceipt(String containerCode, String position, String proSchedule, String orderCode, String orderName, List<BoxInfo> boxInfoList,
        int stack, int qc, int orderFinish, BigDecimal weight, int type, String k3Code, String inType, String operatorName, String quantityorName,
        Integer toalCases) {
        String warehouseCode = "CS0001";
        boolean result = false;
        orderFinish = 1;
        Container container = containerService.getContainerByCode(containerCode, warehouseCode);
        if (container == null) {
            return AjaxResult.error("根据托盘号:" + containerCode + "没有找到匹配的容器");
        }
        String locationCode = container.getLocationCode();
        if (StringUtils.isNotEmpty(locationCode)) {
            return AjaxResult.error("这个容器在库位上，不能用来入库, 托盘号:" + containerCode);
        }
        String containerStatus = container.getStatus();
        if (containerStatus.equals(QuantityConstant.STATUS_CONTAINER_LOCK)) {
            return AjaxResult.error("这个容器已经锁定，不能用来入库, 容器号:" + containerCode);
        }
        String containerTypeCode = container.getContainerType();
        if (containerTypeCode == null) {
            return AjaxResult.error("容器类型编码为空");
        }

        ContainerType containerType = containerTypeService.getContainerTypeByCode(containerTypeCode, warehouseCode);
        if (containerType == null) {
            return AjaxResult.error("容器类型为空");
        }
        if (boxInfoList == null || boxInfoList.size() == 0) {
            return AjaxResult.error("箱信息为空");
        }

        List<ReceiptContainerDetail> receiptContainerDetailList = new ArrayList<>();

        LambdaQueryWrapper<ReceiptContainerHeader> receiptContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        receiptContainerHeaderLambdaQueryWrapper.eq(ReceiptContainerHeader::getContainerCode, containerCode).lt(ReceiptContainerHeader::getStatus,
                QuantityConstant.RECEIPT_CONTAINER_FINISHED);
        ReceiptContainerHeader receiptContainerHeader = receiptContainerHeaderService.getOne(receiptContainerHeaderLambdaQueryWrapper);
        if (receiptContainerHeader != null) {
            return AjaxResult.error("容器已经有组盘信息，容器号:" + containerCode);
        }
        ReceiptHeader receiptHeader = null;

        if (type == 0) { // 生产入库
            String receiptCode = receiptHeaderService.createCode(QuantityConstant.RECEIPT_TYPE_PRODUCTON);
            LambdaQueryWrapper<ReceiptHeader> receiptHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();

            receiptHeaderLambdaQueryWrapper.eq(ReceiptHeader::getOrderCode, orderCode).le(ReceiptHeader::getLastStatus, QuantityConstant.RECEIPT_HEADER_POSTING)
                    .eq(ReceiptHeader::getReceiptType, QuantityConstant.RECEIPT_TYPE_PRODUCTON).orderByDesc(ReceiptHeader::getId).last("Limit 1");
            receiptHeader = receiptHeaderService.getOne(receiptHeaderLambdaQueryWrapper);
            // 多个的情况默认最后一个
            if (receiptHeader == null) {
                receiptHeader = new ReceiptHeader();
                receiptHeader.setCode(receiptCode);
                receiptHeader.setOrderCode(orderCode);
                if (position.equals(QuantityConstant.PORTGROUP_P4) || position.equals(QuantityConstant.PORTGROUP_P5)) {
                    receiptHeader.setInPort("一号线");
                } else {
                    receiptHeader.setInPort("二号线");
                }
                receiptHeader.setReceiptType(QuantityConstant.RECEIPT_TYPE_PRODUCTON);
                receiptHeader.setInType(inType);
                receiptHeader.setWarehouseCode(warehouseCode);
                receiptHeader.setCompanyCode(QuantityConstant.DEFAULT_COMPANY);
                receiptHeader.setReferType(QuantityConstant.BILL_TYPE_RECEIPT_SINGLE);
                receiptHeader.setTotalLines(0);
                receiptHeader.setTotalQty(BigDecimal.ZERO);
                receiptHeader.setFirstStatus(200);
                receiptHeader.setLastStatus(200);
                receiptHeader.setToalCases(toalCases);
                receiptHeader.setOrderFinish(false);
                receiptHeader.setCreatedBy(QuantityConstant.PLATFORM_CODING);
                receiptHeader.setLastUpdatedBy(QuantityConstant.PLATFORM_CODING);
                result = receiptHeaderService.save(receiptHeader);
                if (!result) {
                    throw new ServiceException("保存入库单失败");
                }
            }

        } else if (type == 1) { // 退货入库
            LambdaQueryWrapper<ReceiptHeader> receiptHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            receiptHeaderLambdaQueryWrapper.eq(ReceiptHeader::getReferCode, k3Code).le(ReceiptHeader::getLastStatus, QuantityConstant.RECEIPT_HEADER_POSTING)
                    .eq(ReceiptHeader::getReceiptType, QuantityConstant.RECEIPT_BILL_TYPE_SR);
            receiptHeader = receiptHeaderService.getOne(receiptHeaderLambdaQueryWrapper);
            if (receiptHeader == null) {
                throw new ServiceException("没有找到销售退货单");
            }
        } else if (type == 2) {
            String receiptCode = receiptHeaderService.createCode(QuantityConstant.RECEIPT_BILL_TYPE_OR);
            LambdaQueryWrapper<ReceiptHeader> receiptHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            receiptHeaderLambdaQueryWrapper.eq(ReceiptHeader::getOrderCode, orderCode).le(ReceiptHeader::getLastStatus, QuantityConstant.RECEIPT_HEADER_POSTING)
                    .eq(ReceiptHeader::getReceiptType, QuantityConstant.RECEIPT_BILL_TYPE_OR);
            receiptHeader = receiptHeaderService.getOne(receiptHeaderLambdaQueryWrapper);
            if (receiptHeader == null) {
                receiptHeader = new ReceiptHeader();
                receiptHeader.setCode(receiptCode);
                receiptHeader.setOrderCode(orderCode);
                receiptHeader.setReceiptType(QuantityConstant.RECEIPT_BILL_TYPE_OR);
                String defDeptCode = configService.getKey(QuantityConstant.QT_DEF_DEPT);
                receiptHeader.setUserDef1(defDeptCode);
                receiptHeader.setInType(inType);
                receiptHeader.setWarehouseCode(warehouseCode);
                receiptHeader.setCompanyCode(QuantityConstant.DEFAULT_COMPANY);
                // 其他入库单 类型
                receiptHeader.setReferType(QuantityConstant.BILL_TYPE_RECEIPT_OTHER);
                receiptHeader.setTotalLines(0);
                receiptHeader.setTotalQty(BigDecimal.ZERO);
                receiptHeader.setFirstStatus(200);
                receiptHeader.setLastStatus(200);
                receiptHeader.setToalCases(toalCases);
                receiptHeader.setOrderFinish(false);
                receiptHeader.setCreatedBy(QuantityConstant.PLATFORM_CODING);
                receiptHeader.setLastUpdatedBy(QuantityConstant.PLATFORM_CODING);
                result = receiptHeaderService.save(receiptHeader);
                if (!result) {
                    throw new ServiceException("保存入库单失败");
                }
            }
        } else {
            throw new ServiceException("type类型不匹配");
        }
        BigDecimal totalQty = BigDecimal.ZERO;
        String materialCode1 = null, batch1 = null, level1 = null, color1 = null, proPackage1 = null, productSize = null;
        Integer boxQty = 0;// 每箱数量
        Integer box = 0;// 箱数
        BoxInfo boxInfo1 = boxInfoList.get(0);
        for (BoxInfo boxInfo : boxInfoList) {
            materialCode1 = boxInfo.getMaterialCode();
            proPackage1 = boxInfo.getProPackaging();
            level1 = boxInfo.getLevel();
            color1 = boxInfo.getColor();
            productSize = boxInfo.getSize();
            BigDecimal qty = boxInfo.getQty();
            batch1 = boxInfo.getBatch();
            totalQty = totalQty.add(qty);
            if (!boxInfo1.getMaterialCode().equals(materialCode1)) {
                throw new ServiceException("赋码系统给的物料编码不一致:" + boxInfo1.getMaterialCode() + "," + materialCode1);
            }
            if (!boxInfo1.getProPackaging().equals(proPackage1)) {
                throw new ServiceException("赋码系统给的产品包装不一致:" + boxInfo1.getProPackaging() + "," + proPackage1);
            }
            if (!boxInfo1.getLevel().equals(level1)) {
                throw new ServiceException("赋码系统给的等级不一致:" + boxInfo1.getLevel() + "," + level1);
            }
            if (!boxInfo1.getColor().equals(color1)) {
                throw new ServiceException("赋码系统给的色号不一致:" + boxInfo1.getColor() + "," + color1);
            }
            if (!boxInfo1.getBatch().equals(batch1)) {
                throw new ServiceException("赋码系统给的批次不一致:" + boxInfo1.getBatch() + "," + batch1);
            }
        }
        Material material = materialService.getMaterialByCode(materialCode1);
        getBosAssistantNumber(color1, "colour");
        getBosAssistantNumber(level1, "level");

        LambdaQueryWrapper<ReceiptDetail> receiptDetailLambdaQueryWrapper1 = Wrappers.lambdaQuery();
        receiptDetailLambdaQueryWrapper1.eq(ReceiptDetail::getReceiptId, receiptHeader.getId());
        List<ReceiptDetail> details = receiptDetailService.list(receiptDetailLambdaQueryWrapper1);

        BigDecimal sum = new BigDecimal(0);
        ReceiptDetail detail = null;
        for (ReceiptDetail det : details) {
            sum = sum.add(det.getTaskQty());
            detail = det;
        }

        if (type == 1 && sum.add(totalQty).compareTo(receiptHeader.getTotalQty()) == 1) {
            throw new ServiceException("单据数量超出了:");
        }

        ReceiptDetail receiptDetail = new ReceiptDetail();
        receiptDetail.setWarehouseCode(warehouseCode);
        receiptDetail.setCompanyCode(QuantityConstant.DEFAULT_COMPANY);
        receiptDetail.setMaterialCode(materialCode1);
        receiptDetail.setMaterialUnit("1001");
        receiptDetail.setMaterialSpec(material.getSpec());
        if (details.size() > 1) {
            receiptDetail.setFHTZDetail(receiptDetail.getFHTZDetail());
        }
        LambdaQueryWrapper<Material> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(Material::getCode, materialCode1).eq(Material::getWarehouseCode, QuantityConstant.DEFAULT_WAREHOUSE);
        Material material1 = materialService.getOne(queryWrapper);
        if (material1 == null) {
            return AjaxResult.error("没有找到物料信息:" + materialCode1);
        }
        receiptDetail.setMaterialName(material1.getName());
        receiptDetail.setColor(color1);
        receiptDetail.setLevel(level1);
        receiptDetail.setProPackaging(proPackage1);
        receiptDetail.setProductSchedule(proSchedule);
        receiptDetail.setProductSize(productSize);
        receiptDetail.setQty(totalQty);
        receiptDetail.setStatus(QuantityConstant.RECEIPT_HEADER_BUILD);

        LambdaQueryWrapper<ProPackaging> queryWrapper2 = Wrappers.lambdaQuery();
        queryWrapper2.eq(ProPackaging::getNumber, proPackage1);
        ProPackaging proPackaging = proPackagingService.getOne(queryWrapper2);
        if (proPackaging == null) {
            return AjaxResult.error("没有该产品包装");
        }
        // 每箱数量
        int pieceBox = proPackaging.getPieceBox();
        String toPort = null;
        String toLocationCode = null;
        boolean isRedirect = false;
        // 先获取起始库位，获取不到就放到缓存区
        if (qc == 0) {
            toLocationCode=null;
            isRedirect=true;
        }

        // 箱数
        box = totalQty.divide(BigDecimal.valueOf(pieceBox), RoundingMode.DOWN).intValue();
        receiptDetail.setBox(box);
        if (receiptHeader.getReceiptType().equals(QuantityConstant.RECEIPT_BILL_TYPE_SR)) {
            receiptDetail.setTaskQty(totalQty);
        }

        receiptDetail.setBatch(batch1);
        receiptDetail.setProjectNo(orderCode);
        receiptDetail.setReceiptCode(receiptHeader.getCode());
        receiptDetail.setQcCheck(qc + "");// 是否质检
        receiptDetail.setCreatedBy(QuantityConstant.PLATFORM_CODING);
        receiptDetail.setLastUpdatedBy(QuantityConstant.PLATFORM_CODING);
        receiptDetail.setReceiptId(receiptHeader.getId());

        LambdaQueryWrapper<ReceiptDetail> receiptDetailQueryWrapper = new LambdaQueryWrapper<>();
        receiptDetailQueryWrapper.eq(ReceiptDetail::getReceiptId, receiptHeader.getId()).eq(ReceiptDetail::getMaterialCode, materialCode1)
            .eq(ReceiptDetail::getBatch, batch1).eq(ReceiptDetail::getColor, color1).eq(ReceiptDetail::getLevel, level1);
        ReceiptDetail receiptDetail1 = receiptDetailService.getOne(receiptDetailQueryWrapper);
        if (receiptDetail1 != null) {
            receiptDetail = receiptDetail1;
            BigDecimal qty = receiptDetail.getQty();
            BigDecimal taskQty = receiptDetail.getTaskQty();
            qty = qty.add(totalQty);
            taskQty = taskQty.add(totalQty);
            if (receiptHeader.getReceiptType().equals(QuantityConstant.RECEIPT_BILL_TYPE_SR)) {
                receiptDetail.setTaskQty(taskQty);
            } else {
                receiptDetail.setQty(qty);
            }
            receiptDetail1.setBox(receiptHeader.getTotalQty().intValue()/pieceBox);
            result = receiptDetailService.updateById(receiptDetail);
        } else {
            result = receiptDetailService.save(receiptDetail);
        }
        if (!result) {
            throw new ServiceException("保存入库单详情失败");
        }
        receiptHeader.setTotalLines(receiptHeader.getTotalLines() + 1);
        receiptHeader.setTotalQty(receiptHeader.getTotalQty().add(totalQty));
        // 判断是否完成的标志
        boolean result1 = orderFinish == 1;
        receiptHeader.setOrderFinish(result1);// 设值
        if (receiptHeader.getReceiptType().equals(QuantityConstant.RECEIPT_BILL_TYPE_SR)) {
            LambdaQueryWrapper<ReceiptDetail> receiptDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            receiptDetailLambdaQueryWrapper.eq(ReceiptDetail::getReceiptId, receiptHeader.getId());
            List<ReceiptDetail> receiptDetailList = receiptDetailService.list(receiptDetailLambdaQueryWrapper);
            int complete = 1;
            for (ReceiptDetail receiptDetail2 : receiptDetailList) {
                if (receiptDetail2.getQty().compareTo(receiptDetail2.getTaskQty()) > 0) {
                    complete = 0;
                }
            }
            if (complete == 1) {
                if (receiptHeader.getLastStatus().intValue() < QuantityConstant.RECEIPT_HEADER_POSTING) {
                    receiptHeader.setFirstStatus(QuantityConstant.RECEIPT_HEADER_POSTING);
                    receiptHeader.setLastStatus(QuantityConstant.RECEIPT_HEADER_POSTING);
                }
            }
        }
        result = receiptHeaderService.updateById(receiptHeader);
        if (!result) {
            throw new ServiceException("更新入库单失败");
        }
        receiptDetailService.updateReceiptHeader(receiptHeader);
        ReceiptContainerHeader receiptContainerHeader1 = new ReceiptContainerHeader();
        receiptContainerHeader1.setWarehouseCode(warehouseCode);
        receiptContainerHeader1.setCompanyCode(QuantityConstant.DEFAULT_COMPANY);
        receiptContainerHeader1.setContainerCode(containerCode);
        receiptContainerHeader1.setPosition(position);
        receiptContainerHeader1.setPort(toLocationCode);
        receiptContainerHeader1.setOperatorName(operatorName);
        receiptContainerHeader1.setQualityorName(quantityorName);
        receiptContainerHeader1.setBatch(batch1);
        receiptContainerHeader1.setLevel(level1);
        receiptContainerHeader1.setColor(color1);
        receiptContainerHeader1.setProductSize(productSize);
        receiptContainerHeader1.setProPackaging(proPackage1);
        receiptContainerHeader1.setProductSchedule(proSchedule);
        receiptContainerHeader1.setOrderCode(orderCode);// 订单编号
        receiptContainerHeader1.setOrderName(orderName);// 订单名称
        receiptContainerHeader1.setMaterialCode(materialCode1);// 物料编码
        receiptContainerHeader1.setContainerType(containerTypeCode);
        receiptContainerHeader1.setWeight(String.valueOf(weight));
        receiptContainerHeader1.setTaskType(QuantityConstant.TASK_TYPE_WHOLERECEIPT);
        receiptContainerHeader1.setStatus(QuantityConstant.RECEIPT_CONTAINER_BUILD);
        receiptContainerHeader1.setStack(stack);// 设置垛型
        receiptContainerHeader1.setCreatedBy(QuantityConstant.PLATFORM_CODING);
        receiptContainerHeader1.setLastUpdatedBy(QuantityConstant.PLATFORM_CODING);
        receiptContainerHeader1.setQualityorName(quantityorName);
        receiptContainerHeader1.setOperatorName(operatorName);
        result = receiptContainerHeaderService.save(receiptContainerHeader1);
        if (!result) {
            throw new ServiceException("保存入库组盘头失败");
        }
        for (BoxInfo boxInfo : boxInfoList) {
            String boxCode = boxInfo.getBoxCode();
            int boxPosition = boxInfo.getBoxPosition();
            List<ChipInfos> chipInfoList = boxInfo.getChipInfos();
            String level = boxInfo.getLevel();
            String proPackagingStr = boxInfo.getProPackaging();
            String productSize1 = boxInfo.getSize();
            String color = boxInfo.getColor();
            String batch = boxInfo.getBatch();
            for (ChipInfos chipInfos : chipInfoList) {
                ReceiptContainerDetail receiptContainerDetail = new ReceiptContainerDetail();
                String chipCode1 = chipInfos.getChipBarcode1();
                String chipCode2 = chipInfos.getChipBarcode2();
                receiptContainerDetail.setWarehouseCode(warehouseCode);
                receiptContainerDetail.setContainerCode(containerCode);
                receiptContainerDetail.setContainerType(containerTypeCode);
                receiptContainerDetail.setCompanyCode(QuantityConstant.DEFAULT_COMPANY);
                receiptContainerDetail.setTaskType(QuantityConstant.TASK_TYPE_WHOLERECEIPT);
                receiptContainerDetail.setChipCode1(chipCode1);
                receiptContainerDetail.setChipCode2(chipCode2);
                receiptContainerDetail.setMaterialCode(receiptDetail.getMaterialCode());
                receiptContainerDetail.setMaterialName(receiptDetail.getMaterialName());
                receiptContainerDetail.setMaterialSpec(receiptDetail.getMaterialSpec());
                receiptContainerDetail.setMaterialUnit(receiptDetail.getMaterialUnit());
                receiptContainerDetail.setProPackaging(proPackagingStr);// 包装
                receiptContainerDetail.setProductSchedule(proSchedule);// 排产订单
                receiptContainerDetail.setProductSize(productSize1);// 等级
                receiptContainerDetail.setLevel(level);// 等级
                receiptContainerDetail.setColor(color);// 色号
                receiptContainerDetail.setQty(BigDecimal.ONE);
                receiptContainerDetail.setBatch(batch);
                receiptContainerDetail.setReceiptCode(orderCode);
                receiptContainerDetail.setBoxCode(boxCode);
                receiptContainerDetail.setReceiptType("SC");
                receiptContainerDetail.setInventorySts(QuantityConstant.QUALITY_GOOD);
                receiptContainerDetail.setCreatedBy(QuantityConstant.PLATFORM_CODING);
                receiptContainerDetail.setLastUpdatedBy(QuantityConstant.PLATFORM_CODING);
                receiptContainerDetail.setBoxPosition(boxPosition);
                receiptContainerDetail.setReceiptId(receiptHeader.getId());
                receiptContainerDetail.setReceiptDetailId(receiptDetail.getId());
                receiptContainerDetail.setReceiptContainerId(receiptContainerHeader1.getId());
                receiptContainerDetailList.add(receiptContainerDetail);
            }
        }
        result = receiptContainerDetailService.saveBatch(receiptContainerDetailList);
        if (!result) {
            throw new ServiceException("保存入库组盘详情失败");
        }

        if (qc == 1) {
            receiptContainerHeader1.setExceptionCode("需要质检");
            receiptContainerHeaderService.updateById(receiptContainerHeader1);
            toLocationCode = getCacheLocation();
        }


        Location toLocation = locationService.getLocationByCode(toPort, warehouseCode);
        if (toLocation != null) {
            if(com.huaheng.common.utils.StringUtils.isNotEmpty(toLocation.getContainerCode())) {
                return AjaxResult.error("终点位置,有托盘号");
            }
            locationService.updateStatus(toPort, QuantityConstant.STATUS_LOCATION_LOCK, warehouseCode);
        }
        AjaxResult taskFromTo = agvTaskService.sendTaskFromTo(warehouseCode, QuantityConstant.ZONE_LK, containerCode, position, toLocationCode,
                QuantityConstant.PLATFORM_CODING, totalQty.intValue(),isRedirect);

        if (taskFromTo.hasErr()) {
            throw new ServiceException("生成agv任务失败" + taskFromTo.getMsg());
        }
        // 加提示
        return AjaxResult.success();
    }

    @Override
    public AjaxResult findShipmentRecord(String boxCode) {
        // 查询符合条件的历史库存明细
        LambdaQueryWrapper<InventoryHistoryDetail> inventoryHistoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryHistoryDetailLambdaQueryWrapper.eq(InventoryHistoryDetail::getBoxCode, boxCode);
        List<InventoryHistoryDetail> inventoryHistorysDetailList = inventoryHistoryDetailService.list(inventoryHistoryDetailLambdaQueryWrapper);

        LambdaQueryWrapper<InventoryHistoryHeader> inventoryHistoryHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryHistoryHeaderLambdaQueryWrapper.eq(InventoryHistoryHeader::getId, inventoryHistorysDetailList.get(0).getInventoryHistoryHeaderId());
        InventoryHistoryHeader inventoryHistoryHeader = inventoryHistoryHeaderService.getOne(inventoryHistoryHeaderLambdaQueryWrapper);

        List<ShipmentRecord> list = new ArrayList<>();
        for (InventoryHistoryDetail inventoryHistoryDetail : inventoryHistorysDetailList) {
            // 设置shipmentRecord属性，
            ShipmentRecord shipmentRecord = new ShipmentRecord();
            shipmentRecord.setMaterialCode(inventoryHistoryDetail.getMaterialCode());
            shipmentRecord.setMaterialName(inventoryHistoryDetail.getMaterialName());
            shipmentRecord.setColor(inventoryHistoryDetail.getColor());
            shipmentRecord.setBoxCode(boxCode);
            shipmentRecord.setLevel(inventoryHistoryDetail.getLevel());
            shipmentRecord.setBatch(inventoryHistoryDetail.getBatch());
            shipmentRecord.setTime(inventoryHistoryDetail.getCreated());
            shipmentRecord.setChipCode1(inventoryHistoryDetail.getChipCode1());
            shipmentRecord.setOrderCode(inventoryHistoryHeader.getOrderCode());
            shipmentRecord.setOrderName(inventoryHistoryHeader.getOrderName());
            list.add(shipmentRecord);
        }
        return AjaxResult.success().setData(list);

    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult findShipmentRecordByLs(String lsContainer) {
        if (StringUtils.isEmpty(lsContainer)) {
            return AjaxResult.error("请扫标签码");
        }

        LambdaQueryWrapper<Location> locationQuery = Wrappers.lambdaQuery();
        locationQuery.eq(Location::getContainerCode, lsContainer);
        Location location = locationService.getOne(locationQuery);
        ShipmentCheck check = new ShipmentCheck();
        check.setContainerCode(lsContainer);
        if (location == null) {
            // 已经释放，从库存历史表查
            LambdaQueryWrapper<InventoryHistoryHeader> histQuery = Wrappers.lambdaQuery();
            histQuery.eq(InventoryHistoryHeader::getContainerCode, lsContainer);
            InventoryHistoryHeader header = inventoryHistoryHeaderService.getOne(histQuery);
            String shipmentCode = header.getShipmentCode();

            LambdaQueryWrapper<ShipmentHeader> shipHeaderQuery = Wrappers.lambdaQuery();
            shipHeaderQuery.eq(ShipmentHeader::getCode, shipmentCode);
            ShipmentHeader shipmentHeader = shipmentHeaderService.getOne(shipHeaderQuery);

            LambdaQueryWrapper<InventoryHistoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            inventoryDetailLambdaQueryWrapper.eq(InventoryHistoryDetail::getContainerCode, lsContainer);
            List<InventoryHistoryDetail> inventoryDetailList = inventoryHistoryDetailService.list(inventoryDetailLambdaQueryWrapper);
            check.setLocationCode(header.getLocationCode());
            check.setShipmentHeader(shipmentHeader);
            check.setQty(inventoryDetailList.stream().map(InventoryHistoryDetail::getQty).reduce(BigDecimal.ZERO, BigDecimal::add).intValue());
        } else {
            // 还未释放，从库存表查
            String shipmentCode = location.getShipmentCode();

            LambdaQueryWrapper<ShipmentHeader> shipHeaderQuery = Wrappers.lambdaQuery();
            shipHeaderQuery.eq(ShipmentHeader::getCode, shipmentCode);
            ShipmentHeader shipmentHeader = shipmentHeaderService.getOne(shipHeaderQuery);

            LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getContainerCode, lsContainer);
            List<InventoryDetail> inventoryDetailList = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);

            check.setLocationCode(location.getCode());
            check.setShipmentHeader(shipmentHeader);
            check.setQty(inventoryDetailList.stream().map(InventoryDetail::getQty).reduce(BigDecimal.ZERO, BigDecimal::add).intValue());
        }

        return AjaxResult.success().setData(check);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult findShipmentRecord(String boxCode, String chipCode) {
        // 查询符合条件的历史库存明细
        LambdaQueryWrapper<InventoryHistoryDetail> inventoryHistoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        if (StringUtils.isNotEmpty(boxCode)) {
            inventoryHistoryDetailLambdaQueryWrapper.eq(InventoryHistoryDetail::getBoxCode, boxCode);
        }

        if (StringUtils.isNotEmpty(chipCode)) {
            inventoryHistoryDetailLambdaQueryWrapper.eq(InventoryHistoryDetail::getChipCode1, chipCode);
        }

        List<InventoryHistoryDetail> inventoryHistorysDetailList = inventoryHistoryDetailService.list(inventoryHistoryDetailLambdaQueryWrapper);

        Collections.reverse(inventoryHistorysDetailList);

        List<ShipmentRecord> list = new ArrayList<>();
        for (InventoryHistoryDetail inventoryHistoryDetail : inventoryHistorysDetailList) {
            LambdaQueryWrapper<InventoryHistoryHeader> inventoryHistoryHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            inventoryHistoryHeaderLambdaQueryWrapper.eq(InventoryHistoryHeader::getId, inventoryHistoryDetail.getInventoryHistoryHeaderId());
            InventoryHistoryHeader inventoryHistoryHeader = inventoryHistoryHeaderService.getOne(inventoryHistoryHeaderLambdaQueryWrapper);
            // 设置shipmentRecord属性，
            ShipmentRecord shipmentRecord = new ShipmentRecord();
            shipmentRecord.setMaterialCode(inventoryHistoryDetail.getMaterialCode());
            shipmentRecord.setMaterialName(inventoryHistoryDetail.getMaterialName());
            shipmentRecord.setLocationCode(inventoryHistoryDetail.getLocationCode());
            shipmentRecord.setProductSchedule(inventoryHistoryDetail.getProductSchedule());
            shipmentRecord.setColor(inventoryHistoryDetail.getColor());
            if (StringUtils.isNotEmpty(boxCode)) {
                shipmentRecord.setBoxCode(boxCode);
            } else if (StringUtils.isNotEmpty(chipCode)) {
                shipmentRecord.setBoxCode(inventoryHistorysDetailList.get(0).getBoxCode());
            }
            shipmentRecord.setLevel(inventoryHistoryDetail.getLevel());
            shipmentRecord.setBatch(inventoryHistoryDetail.getBatch());
            shipmentRecord.setTime(inventoryHistoryDetail.getCreated());
            shipmentRecord.setChipCode1(inventoryHistoryDetail.getChipCode1());
            if (inventoryHistoryHeader != null) {
                shipmentRecord.setOrderCode(inventoryHistoryHeader.getOrderCode());
                shipmentRecord.setOrderName(inventoryHistoryHeader.getOrderName());
                shipmentRecord.setShipmentCode(inventoryHistoryHeader.getShipmentCode());
                shipmentRecord.setReceiptCode(inventoryHistoryHeader.getReceiptCode());
            }
            list.add(shipmentRecord);
        }
        return AjaxResult.success().setData(list);
    }

    private Boolean agvTaskAndReceiptQcStream(String position, ReceiptHeader receiptHeader, String warehouseCode, int totalQty) {
        // 生成AGV取放货任务
        AgvTask agvTask = new AgvTask();
        agvTask.setTaskType(QuantityConstant.AGV_TYPE_TAKE_AND_RELEASE);
        agvTask.setStatus(QuantityConstant.AGV_TASK_STATUS_BUILD);
        agvTask.setWarehouseCode(warehouseCode);
        agvTask.setPriority(10);
        agvTask.setFromPort(position);
        agvTask.setToPort("质检点位");
        agvTask.setQty(totalQty);
        agvTask.setCreatedBy("质检点位");
        Boolean result = agvTaskService.save(agvTask);
        if (!result) {
            throw new ServiceException("生成AGV任务失败");
        }
        // 生成入库质检单
        receiptHeaderService.check(receiptHeader.getId());
        return Boolean.TRUE;
    }

    private String getBosAssistantNumber(String number1, String id) {
        LambdaQueryWrapper<BosAssistantDetail> bosAssistantDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        bosAssistantDetailLambdaQueryWrapper.eq(BosAssistantDetail::getId, id).eq(BosAssistantDetail::getNumber, number1);
        BosAssistantDetail bosAssistantDetail = bosAssistantDetailService.getOne(bosAssistantDetailLambdaQueryWrapper);
        if (bosAssistantDetail == null) {
            throw new ServiceException("没有找到对应详情:" + number1);
        }
        String number = bosAssistantDetail.getNumber();
        return number;
    }

    /*
     * 从A库
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult requestEmptyContainer(String requestInCode) {
        List<Integer> rows = new ArrayList<>();
        rows.add(1);
        rows.add(2);
        rows.add(3);
        LambdaQueryWrapper<Location> locationLambdaQueryWrapper = Wrappers.lambdaQuery();
        locationLambdaQueryWrapper.eq(Location::getZoneCode, QuantityConstant.ZONE_RECEIPT_MANY_CONTAINER).eq(Location::getStatus,
            QuantityConstant.STATUS_LOCATION_LOCK);
        List<Location> locationList = locationService.list(locationLambdaQueryWrapper);
        if (locationList.size() > 0) {
            List<Integer> rowList = locationList.stream().map(Location::getIRow).collect(Collectors.toList());
            for (Integer row : rowList) {
                rows.remove(row);
            }
        }
        if (rows.size() == 0) {
            return AjaxResult.error("每一行都有AGV任务，暂时没有可用库位, 清过段时间重试");
        }
        locationLambdaQueryWrapper = Wrappers.lambdaQuery();
        locationLambdaQueryWrapper.eq(Location::getZoneCode, QuantityConstant.ZONE_RECEIPT_MANY_CONTAINER)
            .eq(Location::getStatus, QuantityConstant.STATUS_LOCATION_EMPTY)
                .eq(Location::getILayer,1).in(Location::getIRow, rows).ne(Location::getContainerCode, "")
            .orderByAsc(Location::getIColumn).orderByDesc(Location::getILayer).last(" limit 1");
        Location location = locationService.getOne(locationLambdaQueryWrapper);

        if (location == null) {
            return AjaxResult.error("没有找到可出库位");
        }

        LambdaQueryWrapper<AgvTask> agvTaskLambdaQueryWrapper = Wrappers.lambdaQuery();
        agvTaskLambdaQueryWrapper.eq(AgvTask::getToPort, requestInCode).lt(AgvTask::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);
        List<AgvTask> agvTaskList = agvTaskService.list(agvTaskLambdaQueryWrapper);
        if (agvTaskList.size() > 0) {
            return AjaxResult.error(requestInCode + "位置已经有AGV搬运任务");
        }

        String containerCode = location.getContainerCode();
        String warehouseCode = location.getWarehouseCode();
        String locationCode = location.getCode();
        String zoneCode = location.getZoneCode();
        Container container = containerService.getContainerByCode(containerCode, warehouseCode);
        if (container != null) {
            String status = container.getStatus();
            if (status.equals(QuantityConstant.STATUS_CONTAINER_MANY)) {
                AjaxResult ajaxResult =
                    agvTaskService.sendTaskFromTo(warehouseCode, zoneCode, containerCode, locationCode, requestInCode, QuantityConstant.PLATFORM_CODING, 0);
                return ajaxResult;
            }
        }

        return AjaxResult.error("没有可用于出库的库位");
    }

    // 获取空闲的入库缓存库位
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String getCacheLocation() {
        List<Integer> rows = new ArrayList<>();
        rows.add(1);
        rows.add(2);
        rows.add(3);
        LambdaQueryWrapper<Location> locationLambdaQueryWrapper = Wrappers.lambdaQuery();
        locationLambdaQueryWrapper.eq(Location::getZoneCode, QuantityConstant.ZONE_RECEIPT_CACHE).eq(Location::getStatus, QuantityConstant.STATUS_LOCATION_LOCK);
        List<Location> locationList = locationService.list(locationLambdaQueryWrapper);
        // 原代码是如果第一行有任务 就暂时不分配了，现在客户要求同时只能有一个agv任务(默认锁定就是有任务)
        if (locationList.size() > 0) {
            List<Integer> rowList = locationList.stream().map(Location::getIRow).collect(Collectors.toList());
            for (Integer row : rowList) {
                rows.remove(row);
            }
        }

//        if (rows.size() == 0) {
//            throw new ServiceException("齐工要求 同时同一行只能有一个agv任务 当前入库缓存区库位有锁定情况 无法生成新的任务");
//        }

        // 之前代码按顺序查询的 默认取第一个 会造成后面的释放了分配到后面去，逻辑存在问题 先注释
//        locationLambdaQueryWrapper = Wrappers.lambdaQuery();
//        locationLambdaQueryWrapper.eq(Location::getZoneCode, QuantityConstant.ZONE_RECEIPT_CACHE)
//                .eq(Location::getStatus, QuantityConstant.STATUS_LOCATION_EMPTY)
//                .eq(Location::getContainerCode, "")
//                .in(Location::getIRow, rows)
//                .orderByDesc(Location::getIColumn)
//                .orderByAsc(Location::getILayer)
//                .last(" limit 1");

        // 改写先全取 在本地处理数据 一共18*3个库位 本地处理多个循环也不至于很卡
        locationLambdaQueryWrapper = Wrappers.lambdaQuery();

        locationLambdaQueryWrapper.eq(Location::getZoneCode, QuantityConstant.ZONE_RECEIPT_CACHE).in(Location::getIRow, rows).orderByAsc(Location::getIRow)
            .orderByAsc(Location::getIColumn);

        List<Location> locations = locationService.list(locationLambdaQueryWrapper);

        // 按 IRow 分组

        Map<Integer, List<Location>> locationMap = locations.stream().collect(Collectors.groupingBy(Location::getIRow));

        // 按空闲数量从多到少排序
        Comparator<List<Location>> byIdleCount = Comparator.comparingInt(list -> {

            long idleCount = list.stream()
                .filter(location -> QuantityConstant.STATUS_CONTAINER_EMPTY.equals(location.getStatus()) && !StringUtils.isNotEmpty(location.getContainerCode()))
                .count();
            return -(int)idleCount; // 按空闲数量从多到少排序
        });

        // 每一行都分成一个list内，方便进行循环遍历
        List<List<Location>> locationIRowList = new ArrayList<>(locationMap.values());
        locationIRowList.sort(byIdleCount);

        String LocationCode = null;

        // 第一层遍历是行
        for (List<Location> location : locationIRowList) {
            // 第二次遍历是每一行的值 这里用int i可以更好的利用位置取值
            for (int i = 0; i < location.size(); i++) {
                // 查出非空闲或者有容器 如果当前列查了有就在这i的前一个给出去
                if (!location.get(i).getStatus().equals(QuantityConstant.STATUS_CONTAINER_EMPTY) || StringUtils.isNotEmpty(location.get(i).getContainerCode())) {
                    // 如果是第一个就放弃这一行 比如B010101库位前是空的不存在了 这里用行跟来判断
                    if (location.get(i).getIColumn() == 1) {
                        // 当前行的遍历关闭 会到第一层遍历去重新到第二行
                        break;
                    }
                    // 如果不是当前行的第一个库位，就往前取一个，就是i-1，给变量赋值出去 直接退出当前遍历到第一层遍历
                    LocationCode = location.get(i - 1).getCode();
                    break;
                } else {
                    // 如果这一行全不是有货或者锁定的 直接把最后一个当库位返回
                    if (i == location.size() - 1) {
                        LocationCode = location.get(i).getCode();
                        break;
                    }
                }
            }
            // 如果在第二层里面给了库位了 就不需要再继续执行直接关闭当第一层遍历
            if (LocationCode != null) {
                break;
            }
        }

        // TODO 如果三个都满了 默认返回是null 这里先保留 看看到时候要不要直接抛异常回滚报错为无库位
        return LocationCode;
    }

    // 1.首先清掉库存、库存缓存、组盘信息 加入组盘表
    // 2.如果尾盘还没有推送托盘信息，并且尾盘数量有多,那么尾盘多取一个
    // 3.如果尾盘数量不够，生成内部出库单出库。
    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult brickFalling(String boxCode, String containerCode,String chipCode) {
        String materialCode = null;
        String materialName = null;
        String materialSpec = null;
        String level = null;
        String color = null;
        String proPackaging = null;
        String productSchedule = null;
        String batch = null;
        int size = 0;
        // 查询库存里面还有没有这个值
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getBoxCode, boxCode)
                .eq(StringUtils.isNotEmpty(chipCode),InventoryDetail::getChipCode1,chipCode);
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);
        if (inventoryDetails.size() > 0) {
            List<BeDamaged> beDamageds = inventoryDetails.stream().map(inventoryDetail -> {
                BeDamaged beDamaged = new BeDamaged();
                beDamaged.setId(inventoryDetail.getId());
                beDamaged.setBatch(inventoryDetail.getBatch());
                beDamaged.setInventorySts(inventoryDetail.getInventorySts());
                beDamaged.setChipCode1(inventoryDetail.getChipCode1());
                beDamaged.setColor(inventoryDetail.getColor());
                beDamaged.setBoxCode(inventoryDetail.getBoxCode());
                beDamaged.setChipCode1(inventoryDetail.getChipCode1());
                beDamaged.setMaterialCode(inventoryDetail.getMaterialCode());
                beDamaged.setLevel(inventoryDetail.getLevel());
                beDamaged.setMaterialSpec(inventoryDetail.getMaterialSpec());
                beDamaged.setMaterialUnit(inventoryDetail.getMaterialUnit());
                beDamaged.setMaterialName(inventoryDetail.getMaterialName());
                beDamaged.setProductSchedule(inventoryDetail.getProductSchedule());
                beDamaged.setProPackaging(inventoryDetail.getProPackaging());
                beDamaged.setProductSize(inventoryDetail.getProductSize());
                beDamaged.setReason("掉砖破损");
                return beDamaged;
            }).collect(Collectors.toList());
            if (!beDamagedService.saveBatch(beDamageds)) {
                throw new ServiceException("保存数据到破损表失败");
            }
            materialCode = inventoryDetails.get(0).getMaterialCode();
            level = inventoryDetails.get(0).getLevel();
            color = inventoryDetails.get(0).getColor();
            proPackaging = inventoryDetails.get(0).getProPackaging();
            productSchedule = inventoryDetails.get(0).getProductSchedule();
            batch = inventoryDetails.get(0).getBatch();
            materialName = inventoryDetails.get(0).getMaterialName();
            materialSpec = inventoryDetails.get(0).getMaterialSpec();
            List<Integer> inventoryIds = inventoryDetails.stream().map(InventoryDetail::getId).collect(Collectors.toList());
            if (inventoryIds.size() > 0) {
                boolean result = inventoryDetailService.removeByIds(inventoryIds);
                if (!result) {
                    throw new ServiceException("删除库存详情");
                }
            }
        }

        // 查询库存扣减表有没有这个值
        LambdaQueryWrapper<InventoryCacheDetail> inventoryCacheDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryCacheDetailLambdaQueryWrapper.eq(InventoryCacheDetail::getBoxCode, boxCode)
                .eq(StringUtils.isNotEmpty(chipCode),InventoryCacheDetail::getChipCode1,chipCode);
        List<InventoryCacheDetail> inventoryCacheDetails = inventoryCacheDetailService.list(inventoryCacheDetailLambdaQueryWrapper);
        // 如果有就删除
        if (inventoryCacheDetails.size() > 0) {
            List<BeDamaged> beDamageds = inventoryCacheDetails.stream().map(inventoryCacheDetail -> {
                BeDamaged beDamaged = new BeDamaged();
                beDamaged.setId(inventoryCacheDetail.getId());
                beDamaged.setBatch(inventoryCacheDetail.getBatch());
                beDamaged.setInventorySts(inventoryCacheDetail.getInventorySts());
                beDamaged.setChipCode1(inventoryCacheDetail.getChipCode1());
                beDamaged.setColor(inventoryCacheDetail.getColor());
                beDamaged.setBoxCode(inventoryCacheDetail.getBoxCode());
                beDamaged.setChipCode1(inventoryCacheDetail.getChipCode1());
                beDamaged.setLevel(inventoryCacheDetail.getLevel());
                beDamaged.setMaterialSpec(inventoryCacheDetail.getMaterialSpec());
                beDamaged.setMaterialUnit(inventoryCacheDetail.getMaterialUnit());
                beDamaged.setMaterialCode(inventoryCacheDetail.getMaterialCode());
                beDamaged.setMaterialName(inventoryCacheDetail.getMaterialName());
                beDamaged.setProductSchedule(inventoryCacheDetail.getProductSchedule());
                beDamaged.setProPackaging(inventoryCacheDetail.getProPackaging());
                beDamaged.setProductSize(inventoryCacheDetail.getProductSize());
                beDamaged.setReason("掉砖破损");
                return beDamaged;
            }).collect(Collectors.toList());
            if (!beDamagedService.saveBatch(beDamageds)) {
                throw new ServiceException("保存数据到破损表失败");
            }

            materialCode = inventoryCacheDetails.get(0).getMaterialCode();
            level = inventoryCacheDetails.get(0).getLevel();
            color = inventoryCacheDetails.get(0).getColor();
            proPackaging = inventoryCacheDetails.get(0).getProPackaging();
            productSchedule = inventoryCacheDetails.get(0).getProductSchedule();
            batch = inventoryCacheDetails.get(0).getBatch();
            materialName = inventoryCacheDetails.get(0).getMaterialName();
            materialSpec = inventoryCacheDetails.get(0).getMaterialSpec();
            List<Integer> inventoryCacheIds = inventoryCacheDetails.stream().map(InventoryCacheDetail::getId).collect(Collectors.toList());
            if (inventoryCacheIds.size() > 0) {
                size = inventoryCacheIds.size();
                boolean result = inventoryCacheDetailService.removeByIds(inventoryCacheIds);
                if (!result) {
                    throw new ServiceException("删除缓存库存详情");
                }
            }

        }

        // 查询有没有组托
        LambdaQueryWrapper<ReceiptContainerDetail> receiptContainerDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        receiptContainerDetailLambdaQueryWrapper.eq(ReceiptContainerDetail::getBoxCode, boxCode).ne(ReceiptContainerDetail::getStatus,
            QuantityConstant.INVENTORY_TRANSACTION_SHIPMENT)
                .eq(StringUtils.isNotEmpty(chipCode),ReceiptContainerDetail::getChipCode1,chipCode);
        List<ReceiptContainerDetail> receiptContainerDetails = receiptContainerDetailService.list(receiptContainerDetailLambdaQueryWrapper);

        boolean isZt = false;

        // 如果有就删除
        if (receiptContainerDetails.size() > 0) {
            List<BeDamaged> beDamageds = receiptContainerDetails.stream().map(receiptContainerDetail -> {
                BeDamaged beDamaged = new BeDamaged();
                beDamaged.setId(receiptContainerDetail.getId());
                beDamaged.setBatch(receiptContainerDetail.getBatch());
                beDamaged.setInventorySts(receiptContainerDetail.getInventorySts());
                beDamaged.setChipCode1(receiptContainerDetail.getChipCode1());
                beDamaged.setColor(receiptContainerDetail.getColor());
                beDamaged.setBoxCode(receiptContainerDetail.getBoxCode());
                beDamaged.setChipCode1(receiptContainerDetail.getChipCode1());
                beDamaged.setMaterialCode(receiptContainerDetail.getMaterialCode());
                beDamaged.setLevel(receiptContainerDetail.getLevel());
                beDamaged.setMaterialSpec(receiptContainerDetail.getMaterialSpec());
                beDamaged.setMaterialUnit(receiptContainerDetail.getMaterialUnit());
                beDamaged.setMaterialName(receiptContainerDetail.getMaterialName());
                beDamaged.setProductSchedule(receiptContainerDetail.getProductSchedule());
                beDamaged.setProPackaging(receiptContainerDetail.getProPackaging());
                beDamaged.setProductSize(receiptContainerDetail.getProductSize());
                beDamaged.setReason("掉砖破损");
                return beDamaged;
            }).collect(Collectors.toList());
            if (!beDamagedService.saveBatch(beDamageds)) {
                throw new ServiceException("保存数据到破损表失败");
            }

            LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            taskHeaderLambdaQueryWrapper.eq(TaskHeader::getContainerCode, receiptContainerDetails.get(0).getContainerCode())
                .ne(TaskHeader::getPortGroup, QuantityConstant.PORTGROUP_P30).eq(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_OVER_STATION);
            TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
            if (taskHeader == null) {
                throw new ServiceException("入库组盘明细对应换站任务不存在");
            }
            taskHeader.setBadQty(taskHeader.getBadQty() + receiptContainerDetails.size());
            taskHeaderService.updateById(taskHeader);
            materialCode = receiptContainerDetails.get(0).getMaterialCode();
            level = receiptContainerDetails.get(0).getLevel();
            color = receiptContainerDetails.get(0).getColor();
            proPackaging = receiptContainerDetails.get(0).getProPackaging();
            productSchedule = receiptContainerDetails.get(0).getProductSchedule();
            batch = receiptContainerDetails.get(0).getBatch();
            materialName = receiptContainerDetails.get(0).getMaterialName();
            materialSpec = receiptContainerDetails.get(0).getMaterialSpec();
            List<Integer> receiptContainerDetailIds = receiptContainerDetails.stream().map(ReceiptContainerDetail::getId).collect(Collectors.toList());
            if (receiptContainerDetailIds.size() > 0) {
                boolean result = receiptContainerDetailService.removeByIds(receiptContainerDetailIds);
                if (!result) {
                    throw new ServiceException("删除入库组盘详情详情");
                }
            }
            isZt = true;
        }

        LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        taskHeaderLambdaQueryWrapper.eq(TaskHeader::getContainerCode, containerCode).eq(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_ARRIVED_STATION);
        TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
        if (taskHeader == null) {
            throw new ServiceException("任务不存在");
        }

        LambdaQueryWrapper<ProPackaging> proPackagingLambdaQueryWrapper = Wrappers.lambdaQuery();
        proPackagingLambdaQueryWrapper.eq(ProPackaging::getNumber, proPackaging);
        ProPackaging proPackaging1 = proPackagingService.getOne(proPackagingLambdaQueryWrapper);
        if (proPackaging1 == null) {
            throw new ServiceException("包装获取失败 请检查数据源 是不是扫了不属于库存 任务 任务组盘里面的托盘");
        }
        int pieceBox = proPackaging1.getPieceBox();

        String shipmentCode = taskHeader.getShipmentCode();
        LambdaQueryWrapper<ShipmentHeader> shipmentLambdaQueryWrapper = Wrappers.lambdaQuery();
        shipmentLambdaQueryWrapper.eq(ShipmentHeader::getUserDef3, shipmentCode).eq(ShipmentHeader::getShipmentType, QuantityConstant.SHIPMENT_TYPE_BH)
            .eq(ShipmentHeader::getLastStatus, QuantityConstant.SHIPMENT_HEADER_BUILD);
        ShipmentHeader shipmentHeader = shipmentHeaderService.getOne(shipmentLambdaQueryWrapper);
        if (shipmentHeader == null) {
            String code = shipmentHeaderService.createCode(QuantityConstant.SHIPMENT_TYPE_OTHER);
            shipmentHeader = new ShipmentHeader();
            shipmentHeader.setCode(code);
            shipmentHeader.setWarehouseCode(QuantityConstant.DEFAULT_WAREHOUSE);
            shipmentHeader.setCompanyCode(QuantityConstant.DEFAULT_COMPANY);
            shipmentHeader.setShipmentType(QuantityConstant.SHIPMENT_TYPE_OTHER);
            shipmentHeader.setQtcklx("001");
            shipmentHeader.setTotalQty(new BigDecimal(pieceBox));
            shipmentHeader.setTotalWeight(BigDecimal.ZERO);
            shipmentHeader.setTotalLines(1);
            shipmentHeader.setPriority(100);
            shipmentHeader.setFirstStatus(0);
            shipmentHeader.setLastStatus(0);
            shipmentHeader.setRelaNoticeCode(taskHeader.getShipmentCode());
            shipmentHeader.setCreatedBy("WMS");
//                shipmentHeader.setCreated(new Date());
            shipmentHeader.setLastUpdated(new Date());
            boolean result = shipmentHeaderService.save(shipmentHeader);
            if (!result) {
                throw new ServiceException("补货通知单生成失败");
            }
        }
        if (shipmentHeader != null) {
            LambdaQueryWrapper<ShipmentDetail> shipmentDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            shipmentDetailLambdaQueryWrapper.eq(ShipmentDetail::getShipmentCode, shipmentHeader.getCode()).eq(ShipmentDetail::getMaterialCode, materialCode)
                .eq(ShipmentDetail::getProPackaging, proPackaging).eq(ShipmentDetail::getLevel, level).eq(ShipmentDetail::getColor, color)
                .eq(ShipmentDetail::getProductSchedule, productSchedule);
            ShipmentDetail shipmentDetail = shipmentDetailService.getOne(shipmentDetailLambdaQueryWrapper);
            if (shipmentDetail != null) {
                BigDecimal qty = shipmentDetail.getQty();
                qty = qty.add(new BigDecimal(pieceBox));
                shipmentDetail.setQty(qty);
                shipmentDetailService.updateById(shipmentDetail);
            } else {
                shipmentDetail = new ShipmentDetail();
                shipmentDetail.setShipmentId(shipmentHeader.getId());
                shipmentDetail.setWarehouseCode(QuantityConstant.DEFAULT_WAREHOUSE);
                shipmentDetail.setCompanyCode(QuantityConstant.DEFAULT_COMPANY);
                shipmentDetail.setShipmentCode(shipmentHeader.getCode());
                shipmentDetail.setMaterialCode(materialCode);
                shipmentDetail.setMaterialName(materialName);
                shipmentDetail.setMaterialSpec(materialSpec);
                shipmentDetail.setMaterialUnit("1001");
                shipmentDetail.setQty(new BigDecimal(pieceBox));
                shipmentDetail.setBatch(batch);
                shipmentDetail.setInventorySts("good");
                shipmentDetail.setProductSchedule(productSchedule);
                shipmentDetail.setStatus(0);
                shipmentDetail.setCreated(DateUtils.getNowDate());
                shipmentDetail.setProcessStamp(0 + "");
                shipmentDetail.setProPackaging(proPackaging);
                shipmentDetail.setColor(color);
                shipmentDetail.setLevel(level);
                boolean result = shipmentDetailService.save(shipmentDetail);
                if (!result) {
                    throw new ServiceException("补货通知单详情生成失败");
                }
            }
        }

        // 掉砖以后更新单据
        LambdaQueryWrapper<ShipmentHeader> shipmentHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        shipmentHeaderLambdaQueryWrapper.eq(ShipmentHeader::getCode, shipmentCode);
        shipmentHeader = shipmentHeaderService.getOne(shipmentHeaderLambdaQueryWrapper);
        ShipmentHeader shipmentHeader1 = new ShipmentHeader();
        shipmentHeader1.setId(shipmentHeader.getId());
        shipmentHeader1.setDamage(1);
        if (!shipmentHeaderService.updateById(shipmentHeader1)) {
            throw new ServiceException("更新出库单头失败");
        }
        LambdaQueryWrapper<ShipmentDetail> shipmentDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        shipmentDetailLambdaQueryWrapper.eq(ShipmentDetail::getShipmentCode, taskHeader.getShipmentCode()).eq(ShipmentDetail::getMaterialCode, materialCode)
            .eq(ShipmentDetail::getLevel, level).eq(ShipmentDetail::getColor, color).eq(ShipmentDetail::getBatch, batch)
            .eq(ShipmentDetail::getProductSchedule, productSchedule).eq(ShipmentDetail::getProPackaging, proPackaging);
        List<ShipmentDetail> shipmentDetailList = shipmentDetailService.list(shipmentDetailLambdaQueryWrapper);
        if (shipmentDetailList.size() < 1) {
            throw new ServiceException("没有找到出库详情。出库单号" + taskHeader.getShipmentCode() + "物料" + materialCode + "排产订单" + productSchedule);
        }
        ShipmentDetail shipmentDetail = new ShipmentDetail();
        for (ShipmentDetail Detail : shipmentDetailList) {
            if (Detail.getQty().compareTo(Detail.getTaskQty()) > 0) {
                shipmentDetail = Detail;
                break;
            }
        }
        ShipmentDetail shipmentDetail1 = new ShipmentDetail();
        shipmentDetail1.setId(shipmentDetail.getId());
        shipmentDetail1.setDamageQty(shipmentDetail.getDamageQty().add(BigDecimal.valueOf(inventoryDetails.size())));
        shipmentDetailService.updateById(shipmentDetail1);
        return AjaxResult.success("成功");
    }

    @Override
    public AjaxResult codeSubstitution(String boxCode, String toBoxCode,String chipCode1,String chipCode2,String containerCode) {
        // 1.备货区替换 找查备货区库存有没有对应箱码 没有就报错
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.ne(InventoryDetail::getZoneCode, QuantityConstant.ZONE_LK).eq(InventoryDetail::getContainerCode, containerCode)
            .eq(InventoryDetail::getBoxCode, boxCode).eq(StringUtils.isNotEmpty(chipCode1),InventoryDetail::getChipCode1,chipCode1);
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);
        if (inventoryDetails.isEmpty())
        {
            return AjaxResult.error("没有找到对应原有的库存");
        }
        //防止重复片码报错
        InventoryDetail inventoryDetail=inventoryDetails.get(0);
        BeDamaged beDamaged = new BeDamaged();
        beDamaged.setId(inventoryDetail.getId());
        beDamaged.setBatch(inventoryDetail.getBatch());
        beDamaged.setInventorySts(inventoryDetail.getInventorySts());
        beDamaged.setChipCode1(inventoryDetail.getChipCode1());
        beDamaged.setColor(inventoryDetail.getColor());
        beDamaged.setBoxCode(inventoryDetail.getBoxCode());
        beDamaged.setChipCode1(inventoryDetail.getChipCode1());
        beDamaged.setMaterialCode(inventoryDetail.getMaterialCode());
        beDamaged.setLevel(inventoryDetail.getLevel());
        beDamaged.setMaterialSpec(inventoryDetail.getMaterialSpec());
        beDamaged.setMaterialUnit(inventoryDetail.getMaterialUnit());
        beDamaged.setMaterialName(inventoryDetail.getMaterialName());
        beDamaged.setProductSchedule(inventoryDetail.getProductSchedule());
        beDamaged.setProPackaging(inventoryDetail.getProPackaging());
        beDamaged.setProductSize(inventoryDetail.getProductSize());
        beDamaged.setBoxCode1(toBoxCode);
        beDamaged.setChipCode2(chipCode2);
        beDamaged.setReason("箱码替换");


        LambdaQueryWrapper<BeDamaged> beDamagedLambdaQueryWrapper = Wrappers.lambdaQuery();
        beDamagedLambdaQueryWrapper.eq(BeDamaged::getReason,"箱码替换")
                .eq(BeDamaged::getBoxCode1,toBoxCode)
                .eq(StringUtils.isNotEmpty(chipCode2),BeDamaged::getChipCode2,chipCode2)
                .eq(BeDamaged::getBoxCode,inventoryDetail.getBoxCode())
                .eq(StringUtils.isNotEmpty(chipCode1),BeDamaged::getChipCode1,inventoryDetail.getChipCode1())
                .eq(BeDamaged::getMaterialName,inventoryDetail.getMaterialName());

        List<BeDamaged> beDamageds = beDamagedService.list(beDamagedLambdaQueryWrapper);
        if (!beDamageds.isEmpty())
        {
            return AjaxResult.error("已存在替换记录");
        }

        if (!beDamagedService.save(beDamaged)) {
            throw new ServiceException("保存数据到替换表失败");
        }

        return AjaxResult.success("保存替换成功");
    }

    @Override
    public AjaxResult inventory(String boxCode, String containerCode, String chipCode) {

        String[] chipCodes = Convert.toStrArray(chipCode);
        // 先判断有没有这个对应的出库任务主表
        LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        taskHeaderLambdaQueryWrapper.eq(TaskHeader::getContainerCode, containerCode).eq(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_CYCLECOUNT)
            .ne(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);
        TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
        if (taskHeader == null) {
            return AjaxResult.error("任务不存在");
        }

        // 如果没有就是新增的 库存添加
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getContainerCode, taskHeader.getContainerCode());
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);

        int 标识 = 0;
        for (InventoryDetail inventoryDetail : inventoryDetails) {
            if (inventoryDetail.getBoxCode().equals(boxCode)) {
                标识 = 1;
            }
        }

        InventoryDetail inventoryDetail = inventoryDetails.get(0);

        LambdaQueryWrapper<ProPackaging> proPackagingLambdaQueryWrapper = Wrappers.lambdaQuery();
        proPackagingLambdaQueryWrapper.eq(ProPackaging::getNumber, inventoryDetail.getProPackaging());
        ProPackaging proPackaging = proPackagingService.getOne(proPackagingLambdaQueryWrapper);

        // 1.判断明细有没有对应的
        LambdaQueryWrapper<TaskDetail> taskDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        taskDetailLambdaQueryWrapper.eq(TaskDetail::getTaskId, taskHeader.getId()).eq(TaskDetail::getBoxCode, boxCode);
        List<TaskDetail> taskDetails = taskDetailService.list(taskDetailLambdaQueryWrapper);

        if (taskDetails.size() < 1) {
            if (标识 == 1) {
                throw new ServiceException("请勿重复扫");
            }

            if (chipCode.isEmpty()) {
                AjaxResult ajaxResult=new AjaxResult();
                ajaxResult.setMsg(proPackaging.getPieceBox() + ",盘盈请手动输入片码");
                ajaxResult.setCode(400);
                return ajaxResult;
            }
            for (int i = 0; i < proPackaging.getPieceBox(); i++) {
                inventoryDetail.setId(null);
                inventoryDetail.setBoxCode(boxCode);
                inventoryDetail.setChipCode1(chipCodes[i]);
                inventoryDetail.setChipCode2("盘盈片码");
                inventoryDetailService.save(inventoryDetail);
            }
        } else {
            for (TaskDetail taskDetail : taskDetails) {
                taskDetailService.removeById(taskDetail);
            }
        }
        return AjaxResult.success("成功");
    }

    @Override
    @Transactional
    public AjaxResult boxCodeInsert(String containerCode, String toBoxCode) {
        // 1.先在平库找到对应库存明细
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getContainerCode, containerCode).eq(InventoryDetail::getZoneCode, QuantityConstant.ZONE_STOCK_UP);
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);
        if (inventoryDetails.size() < 1) {
            return AjaxResult.error("没在平库找到您对应扫的箱码");
        }

        InventoryDetail inventoryDetail = inventoryDetails.get(0);
        // 查出这一箱是多少片 防止这一箱码反复出库找错
        LambdaQueryWrapper<ProPackaging> proPackagingLambdaQueryWrapper = Wrappers.lambdaQuery();
        proPackagingLambdaQueryWrapper.eq(ProPackaging::getNumber, inventoryDetail.getProPackaging());
        ProPackaging proPackaging = proPackingService.getOne(proPackagingLambdaQueryWrapper);
        if (proPackaging == null) {
            return AjaxResult.error("没有包装信息");
        }
        int pieceBox = proPackaging.getPieceBox();

        LambdaQueryWrapper<InventoryHistoryDetail> inventoryHistoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryHistoryDetailLambdaQueryWrapper.eq(InventoryHistoryDetail::getBoxCode, toBoxCode).orderByDesc(InventoryHistoryDetail::getId)
            .last(" limit " + pieceBox);
        List<InventoryHistoryDetail> inventoryHistoryDetails = inventoryHistoryDetailService.list(inventoryHistoryDetailLambdaQueryWrapper);

        for (InventoryHistoryDetail inventoryHistoryDetail : inventoryHistoryDetails) {
            inventoryDetail.setId(null);
            inventoryDetail.setBoxCode(inventoryHistoryDetail.getBoxCode());
            inventoryDetail.setChipCode1(inventoryHistoryDetail.getChipCode1());
            inventoryDetail.setMaterialName(inventoryHistoryDetail.getMaterialName());
            inventoryDetail.setMaterialCode(inventoryHistoryDetail.getMaterialCode());
            inventoryDetail.setMaterialSpec(inventoryHistoryDetail.getMaterialSpec());
            inventoryDetail.setMaterialUnit(inventoryHistoryDetail.getMaterialUnit());
            inventoryDetail.setColor(inventoryHistoryDetail.getColor());
            inventoryDetail.setLevel(inventoryHistoryDetail.getLevel());
            inventoryDetail.setBatch(inventoryHistoryDetail.getBatch());
            inventoryDetail.setInventorySts(inventoryHistoryDetail.getInventorySts());
            inventoryDetail.setProPackaging(inventoryHistoryDetail.getProPackaing());
            inventoryDetail.setProductSchedule(inventoryHistoryDetail.getProductSchedule());
            inventoryDetailService.save(inventoryDetail);
        }
        InventoryHeader inventoryHeader = inventoryHeaderService.getById(inventoryDetails.get(0).getInventoryHeaderId());
        if (!inventoryHeaderService.lambdaUpdate()
                .set(InventoryHeader::getTotalQty, inventoryHeader.getTotalQty().add(BigDecimal.valueOf(inventoryHistoryDetails.size())))
                .set(InventoryHeader::getBoxQty, inventoryHeader.getBoxQty().add(BigDecimal.valueOf(inventoryHistoryDetails.size()/pieceBox)))
                .eq(InventoryHeader::getId, inventoryDetails.get(0).getInventoryHeaderId())
                .update())
        {
            throw new ServiceException("修改库存头数量失败");
        }

        LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        taskHeaderLambdaQueryWrapper.eq(TaskHeader::getContainerCode,containerCode)
                .ne(TaskHeader::getPortGroup,QuantityConstant.PORTGROUP_P30);
        TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
        taskHeader.setTaskQty(taskHeader.getTaskQty()+inventoryHistoryDetails.size()/pieceBox);
        taskHeaderService.updateById(taskHeader);

        //要判断全部明细已收==总数 就要先全部查出来减少数据库查询次数 这里不能加条件
        LambdaQueryWrapper<ShipmentDetail> shipmentDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        shipmentDetailLambdaQueryWrapper.eq(ShipmentDetail::getShipmentCode,taskHeader.getShipmentCode());
        List<ShipmentDetail> shipmentDetails = shipmentDetailService.list(shipmentDetailLambdaQueryWrapper);

        List<ShipmentDetail> detailList = shipmentDetails.stream()
                .filter(detail -> detail.getLevel().equals(inventoryDetail.getLevel()))
                .filter(detail -> detail.getColor().equals(inventoryDetail.getColor()))
                .filter(detail -> detail.getProPackaging().equals(inventoryDetail.getProPackaging()))
                .filter(detail -> detail.getProductSchedule().equals(inventoryDetail.getProductSchedule()))
                .filter(detail -> detail.getMaterialCode().equals(inventoryDetail.getMaterialCode()))
                .filter(detail -> detail.getTaskQty().compareTo(detail.getQty()) < 0)
                .collect(Collectors.toList());

        if (detailList.size()<1)
        {
            throw new ServiceException("没有找到对应的出库明细绑定");
        }else
        {
            List<ShipmentDetail> details = detailList.stream()
                    .filter(detail -> detail.getTaskQty().compareTo(detail.getQty()) < 0)
                    .collect(Collectors.toList());
            if (details.size()>0)
            {
                shipmentDetails.remove(details.get(0));
                details.get(0).setTaskQty(details.get(0).getTaskQty().add(BigDecimal.valueOf(inventoryHistoryDetails.size())));
                shipmentDetailService.updateById(details.get(0));
                shipmentDetails.add(details.get(0));
            }
        }

        if (shipmentDetails.stream()
                .filter(detail -> detail.getTaskQty().compareTo(detail.getQty()) != 0).collect(Collectors.toList()).size()<1)
        {
            //改主订单数量
            ShipmentHeader shipmentHeader = shipmentHeaderService.getById(shipmentDetails.get(0).getShipmentId());
            shipmentHeader.setLastStatus(QuantityConstant.SHIPMENT_HEADER_COMPLETED);
            shipmentHeader.setFirstStatus(QuantityConstant.SHIPMENT_HEADER_COMPLETED);
            shipmentHeaderService.updateById(shipmentHeader);
        }

        LambdaQueryWrapper<ReceiptHeader> receiptHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        receiptHeaderLambdaQueryWrapper.eq(ReceiptHeader::getShipmentCode,taskHeader.getShipmentCode())
                .eq(ReceiptHeader::getReceiptType,QuantityConstant.RECEIPT_TYPE_DIRECT_TRANSGER);

        //改主订单数量
        ReceiptHeader receiptHeader = receiptHeaderService.getOne(receiptHeaderLambdaQueryWrapper);

        //要判断全部明细已收==总数 就要先全部查出来减少数据库查询次数 这里不能加条件
        LambdaQueryWrapper<ReceiptDetail> receiptDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        receiptDetailLambdaQueryWrapper.eq(ReceiptDetail::getReceiptId,receiptHeader.getId());
        List<ReceiptDetail> receiptDetails = receiptDetailService.list(receiptDetailLambdaQueryWrapper);

        List<ReceiptDetail> receiptDetailList = receiptDetails.stream()
                .filter(detail -> detail.getLevel().equals(inventoryDetail.getLevel()))
                .filter(detail -> detail.getColor().equals(inventoryDetail.getColor()))
                .filter(detail -> detail.getProPackaging().equals(inventoryDetail.getProPackaging()))
                .filter(detail -> detail.getProductSchedule().equals(inventoryDetail.getProductSchedule()))
                .filter(detail -> detail.getMaterialCode().equals(inventoryDetail.getMaterialCode()))
                .filter(detail -> detail.getTaskQty().compareTo(detail.getQty()) < 0)
                .collect(Collectors.toList());

        if (receiptDetailList.size()<1)
        {
            throw new ServiceException("没有找到对应的出库明细绑定");
        }else
        {
            List<ReceiptDetail> details = receiptDetailList.stream()
                    .filter(detail -> detail.getTaskQty().compareTo(detail.getQty()) < 0)
                    .collect(Collectors.toList());
            if (details.size()>0)
            {
                receiptDetails.remove(details.get(0));
                details.get(0).setTaskQty(receiptDetailList.get(0).getTaskQty().add(BigDecimal.valueOf(inventoryHistoryDetails.size())));
                receiptDetailService.updateById(details.get(0));
                receiptDetails.add(details.get(0));
            }
        }

        if (receiptDetails.stream()
                .filter(detail -> detail.getTaskQty().compareTo(detail.getQty()) != 0).collect(Collectors.toList()).size()<1)
        {
            receiptHeader.setFirstStatus(QuantityConstant.RECEIPT_HEADER_POSTING);
            receiptHeader.setLastStatus(QuantityConstant.RECEIPT_HEADER_POSTING);
            receiptHeaderService.updateById(receiptHeader);
        }
        return AjaxResult.success("插入成功");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult bulkDelivery(String chipCode, String boxCode, String shipmentCode,String shipmentDetailId) {
        // 根据库存明细找查 条件片码跟容器号 要防止有重复片码情况（补码跟退货入库不对可能造成 前端入库没验证要防止前端重复片码）
        // 1.查询片码是否存在这个托盘,必须要存在才执行
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.ne(InventoryDetail::getZoneCode,QuantityConstant.ZONE_STOCK_UP).eq(InventoryDetail::getBoxCode, boxCode).eq(InventoryDetail::getChipCode1, chipCode).last("limit 1");
        InventoryDetail inventoryDetail = inventoryDetailService.getOne(inventoryDetailLambdaQueryWrapper);
        if (inventoryDetail == null) {
            return AjaxResult.error("库存明细里面没有这个对应的片码箱码");
        }

        // 2.根据明细找到主表 主表数量减去箱数
        InventoryHeader inventoryHeader = inventoryHeaderService.getById(inventoryDetail.getInventoryHeaderId());
        if (inventoryHeader == null) {
            return AjaxResult.error("库存头不存在");
        }

        // 5.1先查到任务 根据任务找到出库单
        LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        taskHeaderLambdaQueryWrapper.eq(TaskHeader::getShipmentCode, shipmentCode).ne(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED).last("limit 1");
        TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);

        LambdaQueryWrapper<ProPackaging> proPackagingLambdaQueryWrapper = Wrappers.lambdaQuery();
        proPackagingLambdaQueryWrapper.eq(ProPackaging::getNumber, inventoryHeader.getProPackaging());
        ProPackaging proPackaging = proPackingService.getOne(proPackagingLambdaQueryWrapper);
        if (proPackaging == null) {
            return AjaxResult.error("没有包装信息");
        }
        int pieceBox = proPackaging.getPieceBox();
        inventoryHeader.setBoxQty(inventoryHeader.getBoxQty().subtract(BigDecimal.valueOf(1)));
        inventoryHeader.setTotalQty(inventoryHeader.getTotalQty().subtract(BigDecimal.valueOf(pieceBox)));
        inventoryHeader.setTotalLines(inventoryHeader.getTotalLines() - pieceBox);
        String code = MessageFormat.format("{0}{1}", "LS", String.format("%d", Calendar.getInstance().getTimeInMillis()));

        int inventoryid = inventoryHeader.getId();

        if (inventoryHeader.getTotalQty().compareTo(new BigDecimal("-1")) == 0) {
            inventoryHeaderService.removeById(inventoryHeader);
        } else {
            inventoryHeaderService.updateById(inventoryHeader);
            inventoryHeader.setId(null);
            inventoryHeader.setContainerCode(code);
            inventoryHeader.setLocationCode(code);
            inventoryHeader.setZoneCode(QuantityConstant.ZONE_E);
            inventoryHeader.setBoxQty(BigDecimal.valueOf(0));
            inventoryHeader.setTotalQty(BigDecimal.valueOf(pieceBox - 1));
            inventoryHeader.setTotalLines(1);
            inventoryHeader.setRoadWays("0");
            inventoryHeader.setContainerStatus(QuantityConstant.STATUS_CONTAINER_SOME);
            inventoryHeaderService.save(inventoryHeader);

        }

        // 3.根据主表找查明细
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper1 = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper1.eq(InventoryDetail::getInventoryHeaderId, inventoryid).eq(InventoryDetail::getBoxCode, inventoryDetail.getBoxCode());
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper1);

        // 4.去除主表id 库位 容器 状态 库区保存
        // 5.删除刚刚那个1步查出片码的 写入为第4步的主表
        inventoryDetails.removeIf(inventoryDetail1 -> inventoryDetail1.getId().equals(inventoryDetail.getId()));

        for (InventoryDetail inventoryDetail1 : inventoryDetails) {
            inventoryDetail1.setInventoryHeaderId(inventoryHeader.getId());
            inventoryDetail1.setLocationCode(code);
            inventoryDetail1.setContainerCode(code);
            inventoryDetailService.updateById(inventoryDetail1);
        }

        code = MessageFormat.format("{0}{1}", "LS", String.format("%d", Calendar.getInstance().getTimeInMillis()));
        // 复制一个头
        inventoryHeader.setId(null);
        inventoryHeader.setContainerCode(code);
        inventoryHeader.setLocationCode(code);
        inventoryHeader.setZoneCode(QuantityConstant.ZONE_STOCK_UP);
        inventoryHeader.setBoxQty(BigDecimal.valueOf(0));
        inventoryHeader.setTotalQty(BigDecimal.valueOf(pieceBox - 1));
        inventoryHeader.setTotalLines(1);
        inventoryHeader.setRoadWays("0");
        inventoryHeader.setContainerStatus(QuantityConstant.STATUS_CONTAINER_SOME);
        inventoryHeaderService.save(inventoryHeader);

        // 找到一个库位？？？写上去
        Location location = new Location();
        location.setWarehouseCode(inventoryHeader.getWarehouseCode());
        location.setContainerCode(code);
        location.setCode(code);
        location.setStatus(QuantityConstant.STATUS_LOCATION_EMPTY);
        location.setShipmentCode(shipmentCode);
        locationService.save(location);

        Container container = new Container();
        container.setCode(code);
        container.setWarehouseCode(QuantityConstant.ryTask_warehouse_code);
        container.setContainerType("LS");
        container.setLocationCode(code);
        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("新增容器失败");
        }

        // 库存明细的头id 库位 容器 进行修改
        inventoryDetail.setInventoryHeaderId(inventoryHeader.getId());
        inventoryDetail.setLocationCode(code);
        inventoryDetail.setZoneCode(QuantityConstant.ZONE_STOCK_UP);

        // 5.出库单 调拨单数量+1 修改状态

        // 5.2查询出库单
        LambdaQueryWrapper<ShipmentDetail> shipmentDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        shipmentDetailLambdaQueryWrapper.eq(ShipmentDetail::getId,shipmentDetailId)
                .eq(ShipmentDetail::getShipmentCode, shipmentCode).eq(ShipmentDetail::getMaterialCode, inventoryHeader.getMaterialCode())
            .eq(ShipmentDetail::getMaterialName, inventoryHeader.getMaterialName()).eq(ShipmentDetail::getBatch, inventoryHeader.getBatch())
            .eq(ShipmentDetail::getProPackaging, inventoryHeader.getProPackaging()).eq(ShipmentDetail::getProductSchedule, inventoryHeader.getProductSchedule())
            .eq(ShipmentDetail::getLevel, inventoryHeader.getLevel()).eq(ShipmentDetail::getColor, inventoryHeader.getColor());
        ShipmentDetail shipmentDetail =  shipmentDetailService.getOne(shipmentDetailLambdaQueryWrapper);

        if (shipmentDetail.getTaskQty().compareTo(shipmentDetail.getQty()) == 0)
        {
            throw new ServiceException("当面订单明细没有足够数量给予组托");
        }


        // 判断 必须是需求数量有奇数，已收数量没有奇数，并且要已收数量要下与需求数量才行
        if (!(shipmentDetail.getQty().intValue() % 2 == 1 && shipmentDetail.getTaskQty().compareTo(shipmentDetail.getQty()) < 0
                && shipmentDetail.getTaskQty().intValue() % 2 != 1)) {

            throw new ServiceException("必须是需求数量有奇数，已收数量没有奇数，并且要已收数量要下与需求数量才行");
        }
        if (shipmentDetail.getTaskQty() == null) {
            throw new ServiceException("shipmentDetail已收数量不存在");
        }

        shipmentDetail.setTaskQty(shipmentDetail.getTaskQty().add(BigDecimal.valueOf(1)));
        shipmentDetailService.updateById(shipmentDetail);
        ShipmentHeader shipmentHeader = shipmentHeaderService.getById(shipmentDetail.getShipmentId());


        if (shipmentHeader.getLastStatus() >= QuantityConstant.RECEIPT_HEADER_POSTING) {
            throw new ServiceException("当前订单状态不可出散片");
        }

        LambdaQueryWrapper<ShipmentDetail> shipmentDetailLambdaQueryWrapper1 = Wrappers.lambdaQuery();
        shipmentDetailLambdaQueryWrapper1.eq(ShipmentDetail::getShipmentCode, shipmentCode);
        List<ShipmentDetail> shipmentDetailList = shipmentDetailService.list(shipmentDetailLambdaQueryWrapper1);

        if (shipmentDetailList.stream().allMatch(shipment -> shipment.getQty().compareTo(shipment.getTaskQty()) == 0)) {
            shipmentHeader.setLastStatus(QuantityConstant.SHIPMENT_HEADER_COMPLETED);
            shipmentHeader.setFirstStatus(QuantityConstant.SHIPMENT_HEADER_COMPLETED);
            shipmentHeaderService.updateById(shipmentHeader);
        }

        ReceiptHeader receiptHeader = new ReceiptHeader();
        ReceiptDetail receiptDetail = new ReceiptDetail();
        if (!shipmentHeader.getShipmentType().equals(QuantityConstant.SHIPMENT_BILL_TYPE_OS)) {
            // 看看是不是其他出库单，不是就查询入库单
            LambdaQueryWrapper<ReceiptHeader> receiptHeaderLambda = Wrappers.lambdaQuery();
            receiptHeaderLambda.eq(ReceiptHeader::getShipmentCode, shipmentCode).eq(ReceiptHeader::getReceiptType, QuantityConstant.RECEIPT_TYPE_DIRECT_TRANSGER);
            receiptHeader = receiptHeaderService.getOne(receiptHeaderLambda);

            if (receiptHeader == null && inventoryDetail.getQty().intValue() == 1) {
                AjaxResult result = receiptHeaderService.createDirectTransferReceipt(shipmentHeader);
                ReceiptHeader receiptHeader1 = receiptHeaderService.getById((int) result.getData());
                receiptHeader = receiptHeader1;
                LambdaQueryWrapper<ReceiptDetail> receiptDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
                receiptDetailLambdaQueryWrapper.eq(ReceiptDetail::getReceiptId, receiptHeader1.getId())
                        .eq(ReceiptDetail::getSoEntryId, shipmentDetail.getSoEntryId());
                receiptDetail = receiptDetailService.getOne(receiptDetailLambdaQueryWrapper);

                //实在没有对应的小单号就随机选一个了
                if (receiptDetail == null)
                {
                    receiptDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
                    receiptDetailLambdaQueryWrapper.eq(ReceiptDetail::getReceiptId, receiptHeader1.getId()).last(" limit 1");
                    receiptDetail = receiptDetailService.getOne(receiptDetailLambdaQueryWrapper);
                }

                if (shipmentDetailList.stream().allMatch(shipment -> shipment.getQty().compareTo(shipment.getTaskQty()) == 0)) {
                    if (receiptHeader1.getLastStatus().intValue() < QuantityConstant.RECEIPT_HEADER_POSTING) {
                        receiptHeader1.setLastStatus(QuantityConstant.RECEIPT_HEADER_POSTING);
                        receiptHeader1.setFirstStatus(QuantityConstant.RECEIPT_HEADER_POSTING);
                        receiptHeaderService.updateById(receiptHeader1);
                    }
                }

            } else {
                LambdaQueryWrapper<ReceiptDetail> receiptDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
                receiptDetailLambdaQueryWrapper.eq(ReceiptDetail::getSoEntryId,shipmentDetail.getSoEntryId());
                receiptDetail = receiptDetailService.getOne(receiptDetailLambdaQueryWrapper);


                if (receiptDetail.getTaskQty().compareTo(receiptDetail.getQty()) == 0) {
                    throw new ServiceException("当面订单明细没有足够数量给予组托");
                }

                    if (!(receiptDetail.getQty().intValue() % 2 == 1 && receiptDetail.getTaskQty().compareTo(receiptDetail.getQty()) < 0 && receiptDetail.getTaskQty().intValue() % 2 != 1)) {
                        throw new ServiceException("数据异常 这个是散片吗 没听过校验"+receiptDetail.getId());
                    }
                // 之前已经去掉了已完成的，直接get0就是能用的
                if (receiptDetail.getTaskQty() == null) {
                    throw new ServiceException("receiptDetail.getTaskQty()不能为空");
                }

                receiptDetail.setTaskQty(receiptDetail.getTaskQty().add(BigDecimal.valueOf(1)));
                receiptDetailService.updateById(receiptDetail);

                LambdaQueryWrapper<ReceiptDetail> receiptDetailLambdaQueryWrapper1 = Wrappers.lambdaQuery();
                receiptDetailLambdaQueryWrapper1.eq(ReceiptDetail::getReceiptId, receiptHeader.getId());
                List<ReceiptDetail> details = receiptDetailService.list(receiptDetailLambdaQueryWrapper1);

                if (details.stream().allMatch(receiptDetail1 -> receiptDetail1.getQty().compareTo(receiptDetail1.getTaskQty()) == 0)) {
                    if (receiptHeader.getLastStatus().intValue() < QuantityConstant.RECEIPT_HEADER_POSTING) {
                        receiptHeader.setLastStatus(QuantityConstant.RECEIPT_HEADER_POSTING);
                        receiptHeader.setFirstStatus(QuantityConstant.RECEIPT_HEADER_POSTING);
                        receiptHeaderService.updateById(receiptHeader);
                    }
                }
            }
        }
        inventoryDetail.setReceiptCode(receiptHeader.getCode());
        inventoryDetail.setReceiptDetailId(receiptDetail!=null?receiptDetail.getId():0);
        inventoryDetail.setContainerCode(code);
        inventoryDetailService.updateById(inventoryDetail);

        InventoryHistoryHeader inventoryHistoryHandler = new InventoryHistoryHeader();
        inventoryHistoryHandler.setId(inventoryHeader.getId());
        inventoryHistoryHandler.setContainerCode(inventoryHeader.getContainerCode());
        inventoryHistoryHandler.setWarehouseCode(inventoryHeader.getWarehouseCode());
        inventoryHistoryHandler.setLocationCode(inventoryHeader.getLocationCode());
        inventoryHistoryHandler.setZoneCode(inventoryHeader.getZoneCode());
        inventoryHistoryHandler.setContainerStatus(inventoryHeader.getContainerStatus());
        inventoryHistoryHandler.setCompanyCode(inventoryHeader.getCompanyCode());
        inventoryHistoryHandler.setStack(inventoryHeader.getStack());
        inventoryHistoryHandler.setMaterialCode(inventoryHeader.getMaterialCode());
        inventoryHistoryHandler.setMaterialName(inventoryHeader.getMaterialName());
        inventoryHistoryHandler.setMaterialSpec(inventoryHeader.getMaterialSpec());
        inventoryHistoryHandler.setMaterialUnit(inventoryHeader.getMaterialUnit());
        inventoryHistoryHandler.setLevel(inventoryHeader.getLevel());
        inventoryHistoryHandler.setColor(inventoryHeader.getColor());
        inventoryHistoryHandler.setProPackaging(inventoryHeader.getProPackaging());
        inventoryHistoryHandler.setProductSchedule(inventoryHeader.getProductSchedule());
        inventoryHistoryHandler.setBatch(inventoryHeader.getBatch());
        // receiptHeader这个永远不为空 因为赋值了这里不会报错
        inventoryHistoryHandler.setReceiptCode(receiptHeader.getCode());
        inventoryHistoryHandler.setShipmentCode(shipmentHeader.getCode());
        inventoryHistoryHandler.setOrderCode(shipmentHeader.getReferCode());
        inventoryHistoryHandler.setOrderName(shipmentHeader.getCustomerName());
        inventoryHistoryHandler.setTotalQty(BigDecimal.ZERO);
        inventoryHistoryHandler.setTotalLines(0);
        inventoryHistoryHandler.setUserDef1("销售出库");
        inventoryHistoryHeaderService.save(inventoryHistoryHandler);

        // 6.出库的单片插入到追溯表
        InventoryHistoryDetail inventoryHistoryDetail = new InventoryHistoryDetail();
        inventoryHistoryDetail.setInventoryHistoryHeaderId(inventoryHistoryHandler.getId());
        inventoryHistoryDetail.setWarehouseCode("CS0001");
        inventoryHistoryDetail.setZoneCode("D");
        inventoryHistoryDetail.setContainerCode(inventoryDetail.getContainerCode());

        if (taskHeader != null) {
            inventoryHistoryDetail.setLocationCode(taskHeader.getFromLocation());
        } else {
            inventoryHistoryDetail.setLocationCode("散片区E");
        }
        inventoryHistoryDetail.setCompanyCode(QuantityConstant.DEFAULT_COMPANY);
        inventoryHistoryDetail.setChipCode1(inventoryDetail.getChipCode1());
        inventoryHistoryDetail.setMaterialCode(inventoryDetail.getMaterialCode());
        inventoryHistoryDetail.setMaterialName(inventoryDetail.getMaterialName());
        inventoryHistoryDetail.setMaterialSpec(inventoryDetail.getMaterialSpec());
        inventoryHistoryDetail.setMaterialUnit(inventoryDetail.getMaterialUnit());
        inventoryHistoryDetail.setProPackaing(inventoryDetail.getProPackaging());
        inventoryHistoryDetail.setProductSchedule(inventoryDetail.getProductSchedule());// 排产订单
        inventoryHistoryDetail.setProductSize(inventoryDetail.getProductSize());// 产品规格
        inventoryHistoryDetail.setLevel(inventoryDetail.getLevel());// 等级
        inventoryHistoryDetail.setColor(inventoryDetail.getColor());// 色号
        inventoryHistoryDetail.setQty(BigDecimal.ONE);
        inventoryHistoryDetail.setTaskQty(BigDecimal.ZERO);
        inventoryHistoryDetail.setBatch(inventoryDetail.getBatch());
        inventoryHistoryDetail.setReceiptCode(inventoryDetail.getReceiptCode());
        inventoryHistoryDetail.setBoxCode(inventoryDetail.getBoxCode());
        inventoryHistoryDetail.setInventorySts(QuantityConstant.QUALITY_GOOD);
        inventoryHistoryDetail.setCreatedBy(QuantityConstant.PLATFORM_WMS);
        inventoryHistoryDetail.setLastUpdatedBy(QuantityConstant.PLATFORM_WMS);
        // receiptDetail可能是空的 并且数据库要改这个ReceiptDetailId字段不是必填才行
        if (receiptDetail != null) {
            inventoryHistoryDetail.setReceiptDetailId(receiptDetail.getId());
        }
        inventoryHistoryDetail.setUserDef1("退货入库");
        inventoryHistoryDetailService.save(inventoryHistoryDetail);
        return AjaxResult.success("单片出库成功");
    }

    @Override
    public AjaxResult chipCode(String boxCode) {
        // 1.立库 或 平库
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getBoxCode, boxCode);
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);
        if (inventoryDetails.size() > 0) {
            List<String> ChipS = inventoryDetails.stream().map(t -> t.getChipCode1()).distinct().collect(Collectors.toList());
            return AjaxResult.success(ChipS);
        }

        // 2.出库缓存表
        LambdaQueryWrapper<InventoryHistoryDetail> inventoryHistoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryHistoryDetailLambdaQueryWrapper.eq(InventoryHistoryDetail::getBoxCode, boxCode);
        List<InventoryHistoryDetail> inventoryHistoryDetails = inventoryHistoryDetailService.list(inventoryHistoryDetailLambdaQueryWrapper);

        if (inventoryHistoryDetails.size() > 0) {
            List<String> ChipS = inventoryHistoryDetails.stream().map(t -> t.getChipCode1()).distinct().collect(Collectors.toList());
            return AjaxResult.success(ChipS);
        }

        return AjaxResult.error("没有查到对应片码");
    }

    @Override
    public AjaxResult goOnline(String port, String barcode) {
        Map<String, Object> paramMap = new HashMap();
        paramMap.put("port", port);
        paramMap.put("barcode", barcode);
        String jsonParam = JSON.toJSONString(paramMap);
        String url = addressService.selectAddress(QuantityConstant.WCS_PUSH_ARTIFICIAL);
        String result = OkHttpUtils.bodypost(url, jsonParam);
        if (com.huaheng.common.utils.StringUtils.isEmpty(result)) {
            throw new ServiceException("接口地址错误或返回为空");
        }
        AjaxResult ajaxResult = JSON.parseObject(result, AjaxResult.class);
        if (ajaxResult.getCode() != HttpConstant.OK) {
            return AjaxResult.error(ajaxResult.getMsg());
        }
        return AjaxResult.success("请求wcs成功");
    }

    @Override
    @Transactional
    public AjaxResult loosePieceInventory(String chipCode, String boxCode) {
        // 该功能是把散片 补充到散片库存
        // 散片是线体坏了,只有一片破损，另一片要入回散片区域的。 这里就分为多种情况 库内掉了 扣库存掉落 组托后掉了
        /*
         * 这里要考虑如果一箱不是2片怎么办(目前是2片 以后换包装可能不会) 假如一箱3片只坏了1片 2片入为散片 扫两次 那就不能直接删除库存 添加散片
         * 库内掉了思路 先删除库存表这一箱的 单独把传过来这片作为散片 这里行不通 如上假如三片情况第二次扫库存就查不到了
         * 扣库存后掉了 跟组托后掉了 用了掉砖接口后 库内已经没有任何数据了 要想办法得 估计只能在掉砖接口时候加到某个破损表 搜日志表不现实而且会清理
         */
        // 1.新增一个破损表 记录箱码片码 物料的各种属性。添加业务层代码
        // 2.优化掉砖pda接口 扫了后把当前这片插入到破损表
        // 3.散片补充功能先搜索库存表 如果有删除并且插入破损表 添加当前这片。如果没有就去查破损表进行添加散片。如果都没有就报错。

        LambdaQueryWrapper<BeDamaged> beDamagedLambdaQueryWrapper = Wrappers.lambdaQuery();
        beDamagedLambdaQueryWrapper.eq(BeDamaged::getChipCode1, chipCode).eq(BeDamaged::getBoxCode, boxCode)
                .eq(BeDamaged::getReason,"掉砖破损");
        // 防止赋码系统重复片码 用list查询 getone容易报错
        List<BeDamaged> beDamagedList = beDamagedService.list(beDamagedLambdaQueryWrapper);
        if (beDamagedList.size() < 1) {
            throw new ServiceException("保存数据到破损表失败");
        }

        String code = MessageFormat.format("{0}{1}", "LS", String.format("%d", Calendar.getInstance().getTimeInMillis()));

        BeDamaged damaged = beDamagedList.get(0);
        InventoryHeader inventoryHeader = new InventoryHeader();
        inventoryHeader.setWarehouseCode(QuantityConstant.DEFAULT_WAREHOUSE);
        inventoryHeader.setZoneCode(QuantityConstant.ZONE_E);
        inventoryHeader.setLocationCode(code);
        inventoryHeader.setContainerCode(code);
        inventoryHeader.setContainerStatus("some");
        inventoryHeader.setCompanyCode(QuantityConstant.DEFAULT_COMPANY);
        inventoryHeader.setTotalWeight(String.valueOf(0));
        inventoryHeader.setTotalQty(BigDecimal.valueOf(1));
        inventoryHeader.setTotalLines(1);
        inventoryHeader.setLocking(1);
        inventoryHeader.setEnable(1);
        inventoryHeader.setStack(0);
        inventoryHeader.setMaterialCode(damaged.getMaterialCode());
        inventoryHeader.setMaterialName(damaged.getMaterialName());
        inventoryHeader.setMaterialSpec(damaged.getMaterialSpec());
        inventoryHeader.setMaterialUnit(damaged.getMaterialUnit());
        inventoryHeader.setLevel(damaged.getLevel());
        inventoryHeader.setColor(damaged.getColor());
        inventoryHeader.setProPackaging(damaged.getProPackaging());
        inventoryHeader.setProductSchedule(damaged.getProductSchedule());
        inventoryHeader.setBatch(damaged.getBatch());
        inventoryHeader.setBoxQty(BigDecimal.valueOf(0));
        inventoryHeader.setProductSize(damaged.getProductSize());
        inventoryHeader.setCreatedBy("PDA补充");
        inventoryHeader.setLastUpdatedBy("PDA补充");
        inventoryHeaderService.save(inventoryHeader);

        InventoryDetail inventoryDetail = new InventoryDetail();
        inventoryDetail.setWarehouseCode(inventoryHeader.getWarehouseCode());
        inventoryDetail.setZoneCode(inventoryHeader.getZoneCode());
        inventoryDetail.setCompanyCode(inventoryHeader.getCompanyCode());
        inventoryDetail.setBoxCode(damaged.getBoxCode());
        inventoryDetail.setChipCode1(damaged.getChipCode1());
        inventoryDetail.setMaterialName(damaged.getMaterialName());
        inventoryDetail.setMaterialCode(damaged.getMaterialCode());
        inventoryDetail.setMaterialSpec(damaged.getMaterialSpec());
        inventoryDetail.setMaterialUnit(damaged.getMaterialUnit());
        inventoryDetail.setQty(BigDecimal.valueOf(1));
        inventoryDetail.setTaskQty(BigDecimal.valueOf(0));
//        inventoryDetail.setReceiptCode();
        inventoryDetail.setReceiptDetailId(0);
        inventoryDetail.setInventorySts(QuantityConstant.QUALITY_GOOD);
        inventoryDetail.setBatch(damaged.getBatch());
        inventoryDetail.setProjectNo(damaged.getProductSchedule());
//        inventoryDetail.setQcCheck();
        inventoryDetail.setLevel(damaged.getLevel());
        inventoryDetail.setColor(damaged.getColor());
        inventoryDetail.setProPackaging(damaged.getProPackaging());
        inventoryDetail.setProductSchedule(damaged.getProductSchedule());
        inventoryDetail.setProductSize(damaged.getProductSize());
        inventoryDetail.setShipmentOrder(0);

        LambdaQueryWrapper<InventoryDetail> queryWrapper = new LambdaQueryWrapper<>(inventoryDetail);
        List<InventoryDetail> inventoryDetailList = inventoryDetailService.list(queryWrapper);
        if (inventoryDetailList.size() > 0) {
            throw new ServiceException("该箱码已存在");
        }
        inventoryDetail.setInventoryHeaderId(inventoryHeader.getId());
        inventoryDetail.setLocationCode(inventoryHeader.getLocationCode());
        inventoryDetail.setContainerCode(inventoryHeader.getContainerCode());
        if (!inventoryDetailService.save(inventoryDetail)) {
            throw new ServiceException("增加散片明细失败");
        }

        return AjaxResult.success();
    }

    @Override
    @Transactional
    public AjaxResult flatLibraryBinding(String containerCode, String shipmentDetailId) {
        // 1.首先明细状态要没有组盘，并且状态为新建
        ShipmentDetail shipmentDetail = shipmentDetailService.getById(shipmentDetailId);
        if (shipmentDetail == null) {
            return AjaxResult.error("单据明细不存在");
        }

        // 这个出库单是新建立的
        ShipmentHeader shipmentHeader = shipmentHeaderService.getById(shipmentDetail.getShipmentId());

        if (!shipmentHeader.getLastStatus().equals(QuantityConstant.SHIPMENT_HEADER_RESERVATION)) {
            return AjaxResult.error("发货单据不是预约状态");
        }

        Container container = containerService.getContainerByCode(containerCode, QuantityConstant.DEFAULT_WAREHOUSE);
        if (container == null) {
            return AjaxResult.error("没有找到容器数据:" + containerCode);
        }

        // 库位里面查容器 并且拿到出库单号查下明细是不是有一样的，没有报错
        LambdaQueryWrapper<Location> locaLambdaQueryWrapper = Wrappers.lambdaQuery();
        locaLambdaQueryWrapper.eq(Location::getCode, container.getLocationCode()).eq(Location::getZoneCode, QuantityConstant.ZONE_PINGKU);
        Location location = locationService.getOne(locaLambdaQueryWrapper);

        if (location == null) {
            return AjaxResult.error("平库没有找到对应库存");
        }

        LambdaQueryWrapper<ShipmentHeader> shipmentHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        shipmentHeaderLambdaQueryWrapper.eq(ShipmentHeader::getCode, location.getShipmentCode());
        // 这个是伪发货单的
        ShipmentHeader header = shipmentHeaderService.getOne(shipmentHeaderLambdaQueryWrapper);

        if (header == null) {
            return AjaxResult.error("原伪发货单库存不存在");
        }
        if (!header.getPseudoShipment()) {
            return AjaxResult.error("请绑定伪发货单出库的货物");
        }
        shipmentHeader.setDestStockId(header.getDestStockId());
        shipmentHeader.setFSrcStockId(header.getFSrcStockId());

        LambdaQueryWrapper<ShipmentDetail> shipmentDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        shipmentDetailLambdaQueryWrapper.eq(ShipmentDetail::getShipmentId, shipmentDetail.getShipmentId());
        List<ShipmentDetail> shipmentDetailList = shipmentDetailService.list(shipmentDetailLambdaQueryWrapper);

        List<ShipmentDetail> shipmentDetails = shipmentDetailList.stream()
            .filter(s -> s.getLevel().equals(shipmentDetail.getLevel()) && s.getColor().equals(shipmentDetail.getColor())
                && s.getProductSchedule().equals(shipmentDetail.getProductSchedule()) && s.getProPackaging().equals(shipmentDetail.getProPackaging())
                && s.getMaterialCode().equals(shipmentDetail.getMaterialCode()))
            .collect(Collectors.toList());

        if (shipmentDetails.size() < 1) {
            return AjaxResult.error("单据不匹配 请检查属性");
        }
        LambdaQueryWrapper<InventoryHeader> inventoryHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryHeaderLambdaQueryWrapper.eq(InventoryHeader::getLocationCode, location.getCode());
        List<InventoryHeader> inventoryHeaders = inventoryHeaderService.list(inventoryHeaderLambdaQueryWrapper);
        if (inventoryHeaders.size() < 1) {
            throw new ServiceException("根据库位没找到对应库存");
        }
        List<InventoryHeader> inventoryHeaders1 = inventoryHeaders.stream()
            .filter(s -> s.getLevel().equals(shipmentDetail.getLevel()) && s.getColor().equals(shipmentDetail.getColor())
                && s.getProPackaging().equals(shipmentDetail.getProPackaging()) && s.getMaterialCode().equals(shipmentDetail.getMaterialCode())
                    && s.getProductSchedule().equals(shipmentDetail.getProductSchedule()))
            .collect(Collectors.toList());

        if (inventoryHeaders1.size() < 1) {
            return AjaxResult.error("单据跟库存不匹配 请检查属性");
        }

        if (inventoryHeaders.size() == 1) {
            location.setShipmentCode("");
            location.setContainerCode("");
            if (!locationService.updateById(location)) {
                throw new ServiceException("更新库位失败");
            }
        }

        List<InventoryHeader> headers = inventoryHeaderService.list(inventoryHeaderLambdaQueryWrapper.eq(InventoryHeader::getContainerCode, containerCode));
        if (headers.size() < 1) {
            throw new ServiceException("根据容器没找到对应库存");
        }

        List<InventoryHeader> headers1 = headers.stream().filter(h -> h.getLocationCode().contains("LS")).collect(Collectors.toList());
        if (headers1.size() > 0) {
            throw new ServiceException("当前库存已经绑定过了");
        }

        location.setId(null);
        location.setShipmentCode(shipmentDetail.getShipmentCode());
        location.setCode(containerService.createContainer("5", QuantityConstant.ZONE_PINGKU));
        location.setContainerCode(containerCode);
        if (!locationService.save(location)) {
            throw new ServiceException("更新库位失败");
        }

        container.setLocationCode(location.getCode());
        if (!containerService.updateById(container)) {
            throw new ServiceException("更新容器失败");
        }

        InventoryHeader inventoryHeader = headers.get(0);
        inventoryHeader.setLocationCode(location.getCode());
        inventoryHeader.setContainerCode(container.getCode());
        inventoryHeaderService.updateById(inventoryHeader);

        if (shipmentDetail.getTaskQty().add(inventoryHeader.getTotalQty()).compareTo(shipmentDetail.getQty()) > 0) {
            throw new ServiceException("数量超出");
        }
        ShipmentDetail shipmentDetail1 = new ShipmentDetail();
        shipmentDetail1.setId(shipmentDetail.getId());
        shipmentDetail1.setTaskQty(shipmentDetail.getTaskQty().add(inventoryHeader.getTotalQty()));
        if (!shipmentDetailService.updateById(shipmentDetail1)) {
            throw new ServiceException("批量保存失败");
        }

        AjaxResult ajaxResult = receiptHeaderService.createDirectTransferReceipt(shipmentHeader);
        int receiptId = (int)ajaxResult.getData();
        ReceiptHeader receiptHeader = receiptHeaderService.getById(receiptId);
        inventoryDetailService.lambdaUpdate()
                .set(InventoryDetail::getReceiptDetailId, receiptId)
                .set(InventoryDetail::getReceiptCode, receiptHeader.getCode())
                .set(InventoryDetail::getContainerCode, container.getCode()).set(InventoryDetail::getLocationCode, location.getCode())
                .set(InventoryDetail::getZoneCode, inventoryHeader.getZoneCode())
                .eq(InventoryDetail::getInventoryHeaderId, inventoryHeader.getId()).update();


        if (shipmentDetail.getQty().compareTo(shipmentDetail.getTaskQty().add(inventoryHeader.getTotalQty())) == 0) {
            shipmentDetailList.removeIf(x -> x.getId().equals(shipmentDetail.getId()));

            if (shipmentDetailList.size() > 0 && shipmentDetailList.stream().allMatch(detail -> detail.getTaskQty().compareTo(detail.getQty()) == 0)) {
                shipmentHeader.setLastStatus(QuantityConstant.SHIPMENT_HEADER_COMPLETED);
                shipmentHeader.setFirstStatus(QuantityConstant.SHIPMENT_HEADER_COMPLETED);
                if (!receiptHeaderService.update(new LambdaUpdateWrapper<ReceiptHeader>().set(ReceiptHeader::getLastStatus, QuantityConstant.RECEIPT_HEADER_POSTING)
                    .set(ReceiptHeader::getFirstStatus, QuantityConstant.RECEIPT_HEADER_POSTING).eq(ReceiptHeader::getId, receiptId))) {
                    throw new ServiceException("修改直接调拨单状态失败");
                }
            } else if (shipmentDetailList.size() == 0) {
                shipmentHeader.setLastStatus(QuantityConstant.SHIPMENT_HEADER_COMPLETED);
                shipmentHeader.setFirstStatus(QuantityConstant.SHIPMENT_HEADER_COMPLETED);
                if (!receiptHeaderService.update(new LambdaUpdateWrapper<ReceiptHeader>().set(ReceiptHeader::getLastStatus, QuantityConstant.RECEIPT_HEADER_POSTING)
                    .set(ReceiptHeader::getFirstStatus, QuantityConstant.RECEIPT_HEADER_POSTING).eq(ReceiptHeader::getId, receiptId))) {
                    throw new ServiceException("修改直接调拨单状态失败");
                }
            }
            shipmentHeaderService.updateById(shipmentHeader);
        }

        return AjaxResult.success("绑定成功");
    }

    @Override
    public AjaxResult labelPrinting(String containerCode,String boxCode) {

        if (StringUtils.isEmpty(containerCode))
        {
            LambdaQueryWrapper<ReceiptContainerDetail> receiptContainerDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            receiptContainerDetailLambdaQueryWrapper.eq(ReceiptContainerDetail::getBoxCode, boxCode)
                    .eq(ReceiptContainerDetail::getReceiptType, QuantityConstant.RECEIPT_BILL_TYPE_SC).orderByDesc(ReceiptContainerDetail::getId).last("LIMIT 1");
            ReceiptContainerDetail receiptContainerDetail = receiptContainerDetailService.getOne(receiptContainerDetailLambdaQueryWrapper);
            containerCode=receiptContainerDetail.getContainerCode();
        }

        Config config1 = new Config();
        config1.setConfigKey(QuantityConstant.LABEL_SCANNING);
        Config config = configService.selectConfigList(config1).get(0);
        config.setConfigValue(containerCode);
        configService.updateConfig(config);
        return AjaxResult.success("成功");
    }

    @Override
    public AjaxResult scatteredFilmChip(String boxCode) {
        // 1.立库 或 平库
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getBoxCode, boxCode).ne(InventoryDetail::getZoneCode,QuantityConstant.ZONE_STOCK_UP);
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);
        if (inventoryDetails.size() > 0) {
            /*
             * 解释一下代码：
             * 调用stream()方法将List转化为Stream；
             * 调用map()方法将Stream中的每一个InventoryDetail对象映射成其locationCode；
             * 调用distinct()方法去重，只保留不同的locationCode；
             * 调用count()方法统计不同的locationCode数量；
             * 判断不同的locationCode数量是否等于1，如果等于1则说明所有的locationCode都相等，返回true；否则返回false。
             * 使用这种方式可以快速判断inventoryDetails里面所有值的locationCode是不是相等的。
             */
            if (inventoryDetails.stream().map(InventoryDetail::getLocationCode).distinct().count() == 1) {
                List<String> ChipS = inventoryDetails.stream().map(t -> t.getChipCode1()).distinct().collect(Collectors.toList());
                return AjaxResult.success(ChipS);
            }
            return AjaxResult.error("当前根据箱码 查出来的片码出现在不同的库位 这是一个错误的流程");
        }
        return AjaxResult.error("没有查到对应片码");
    }

    @Override
    @Transactional
    public AjaxResult freeFromInventory(String containerCode) {
        // 先判断有没有这个对应的出库任务主表
        LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        taskHeaderLambdaQueryWrapper.eq(TaskHeader::getContainerCode, containerCode).eq(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_CYCLECOUNT)
                .ne(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);
        TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
        if (taskHeader == null) {
            return AjaxResult.error("任务不存在");
        }
        LambdaQueryWrapper<TaskDetail> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(TaskDetail::getTaskId, taskHeader.getId());
        if (!taskDetailService.remove(queryWrapper))
        {
            throw new ServiceException("免盘失败");
        }
        return AjaxResult.success("成功");
    }


    @Override
    public AjaxResult PDACheck(String boxCode, String containerCode, String chipCode) {

        //PDA增加扫托盘号或箱码或片码查库存物料属性和垛箱片数据功能，查询库存范围包括立库、平库、平库备货区、散片区、入库
        PDACheck pdaCheck=new PDACheck();
        List<MaterialInformation> materialInformationList=new ArrayList<>();
        //主要查入库组盘表 把物料信息给出去
        if (StringUtils.isNotEmpty(containerCode))
        {
            LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            taskHeaderLambdaQueryWrapper.eq(TaskHeader::getContainerCode,containerCode)
                    .orderByDesc(TaskHeader::getId).last(" limit 1");
            TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
            if (taskHeader!=null)
            {
                String taskType = iDictDataService.selectDictLabel("taskType", taskHeader.getTaskType() + "");
                pdaCheck.setCribType(taskHeader.getStack()+"");
                pdaCheck.setInformation(taskType);
            }
        }



        //优先查库存 库存没有再从入库组盘里面查
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(StringUtils.isNotEmpty(containerCode),InventoryDetail::getContainerCode,containerCode)
                .eq(StringUtils.isNotEmpty(boxCode),InventoryDetail::getBoxCode,boxCode)
                .eq(StringUtils.isNotEmpty(chipCode),InventoryDetail::getChipCode1,chipCode)
                .orderByDesc(InventoryDetail::getId);
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);

        if (inventoryDetails.size()>0)
        {
            LambdaQueryWrapper<BeDamaged> lambdaQueryWrapper = Wrappers.lambdaQuery();
            lambdaQueryWrapper.in(BeDamaged::getBoxCode, inventoryDetails.stream().map(InventoryDetail::getBoxCode).collect(Collectors.toList()))
                    .eq(BeDamaged::getReason,"箱码替换");
            List<BeDamaged> beDamageds = beDamagedService.list(lambdaQueryWrapper);
            beDamageds.forEach(beDamaged -> inventoryDetails.stream()
                    .filter(inventoryDetail -> inventoryDetail.getBoxCode().equals(beDamaged.getBoxCode()))
                    .findFirst()
                    .ifPresent(inventoryDetail ->{ inventoryDetail.setBoxCode(beDamaged.getBoxCode1());
                        inventoryDetail.setChipCode1(beDamaged.getChipCode2());
                        inventoryDetail.setMaterialCode(beDamaged.getMaterialCode());
                        inventoryDetail.setMaterialName(beDamaged.getMaterialName());
                        inventoryDetail.setMaterialSpec(beDamaged.getMaterialSpec());
                        inventoryDetail.setMaterialUnit(beDamaged.getMaterialUnit());
                        inventoryDetail.setLevel(beDamaged.getLevel());
                        inventoryDetail.setColor(beDamaged.getColor());
                        inventoryDetail.setProPackaging(beDamaged.getProPackaging());
                        inventoryDetail.setProductSchedule(beDamaged.getProductSchedule());
                        inventoryDetail.setBatch(beDamaged.getBatch());
                        inventoryDetail.setInventorySts(beDamaged.getInventorySts());
                    }));

            materialInformationList = inventoryDetails.stream()
                    .map(detail -> {
                        MaterialInformation materialInfo = new MaterialInformation();
                        // 将ReceiptContainerDetail的属性值赋给MaterialInformation对应的属性
                        materialInfo.setMaterialCode(detail.getMaterialCode());
                        materialInfo.setMaterialName(detail.getMaterialName());
                        materialInfo.setMaterialSpec(detail.getMaterialSpec());
                        materialInfo.setMaterialUnit(detail.getMaterialUnit());
                        materialInfo.setBatch(detail.getBatch());
                        materialInfo.setBoxCode(detail.getBoxCode());
                        materialInfo.setChipCode1(detail.getChipCode1());
                        materialInfo.setLevel(detail.getLevel());
                        materialInfo.setColor(detail.getColor());
                        materialInfo.setProPackaging(detail.getProPackaging());
                        materialInfo.setProductSchedule(detail.getProductSchedule());
                        return materialInfo;
                    })
                    .collect(Collectors.toList());
        }
        else
        {
            //1.先任务下发表
            LambdaQueryWrapper<ReceiptContainerDetail> receiptContainerDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            receiptContainerDetailLambdaQueryWrapper.eq(StringUtils.isNotEmpty(containerCode),ReceiptContainerDetail::getContainerCode,containerCode)
                    .eq(StringUtils.isNotEmpty(boxCode),ReceiptContainerDetail::getBoxCode,boxCode)
                    .eq(StringUtils.isNotEmpty(chipCode),ReceiptContainerDetail::getChipCode1,chipCode)
                    .orderByDesc(ReceiptContainerDetail::getId);
            List<ReceiptContainerDetail> receiptContainerDetailList = receiptContainerDetailService.list(receiptContainerDetailLambdaQueryWrapper);
            List<ReceiptContainerDetail> containerDetailList = receiptContainerDetailList.stream().filter(r -> r.getReceiptContainerId().equals(receiptContainerDetailList.get(0).getReceiptContainerId())).collect(Collectors.toList());
            if (containerDetailList.size()<1)
            {
                return AjaxResult.error("错误 找不到");
            }
            LambdaQueryWrapper<BeDamaged> lambdaQueryWrapper = Wrappers.lambdaQuery();
            lambdaQueryWrapper.in(BeDamaged::getBoxCode, containerDetailList.stream().map(ReceiptContainerDetail::getBoxCode).collect(Collectors.toList()))
                    .eq(BeDamaged::getReason,"箱码替换");
            List<BeDamaged> beDamageds = beDamagedService.list(lambdaQueryWrapper);
            beDamageds.forEach(beDamaged -> containerDetailList.stream()
                    .filter(receiptContainerDetail -> receiptContainerDetail.getBoxCode().equals(beDamaged.getBoxCode()))
                    .findFirst()
                    .ifPresent(receiptContainerDetail ->{ receiptContainerDetail.setBoxCode(beDamaged.getBoxCode1());
                        receiptContainerDetail.setChipCode1(beDamaged.getChipCode2());
                        receiptContainerDetail.setMaterialCode(beDamaged.getMaterialCode());
                        receiptContainerDetail.setMaterialName(beDamaged.getMaterialName());
                        receiptContainerDetail.setMaterialSpec(beDamaged.getMaterialSpec());
                        receiptContainerDetail.setMaterialUnit(beDamaged.getMaterialUnit());
                        receiptContainerDetail.setLevel(beDamaged.getLevel());
                        receiptContainerDetail.setColor(beDamaged.getColor());
                        receiptContainerDetail.setProPackaging(beDamaged.getProPackaging());
                        receiptContainerDetail.setProductSchedule(beDamaged.getProductSchedule());
                        receiptContainerDetail.setBatch(beDamaged.getBatch());
                        receiptContainerDetail.setInventorySts(beDamaged.getInventorySts());
                    }));
            materialInformationList = containerDetailList.stream()
                    .map(detail -> {
                        MaterialInformation materialInfo = new MaterialInformation();
                        // 将ReceiptContainerDetail的属性值赋给MaterialInformation对应的属性
                        materialInfo.setMaterialCode(detail.getMaterialCode());
                        materialInfo.setMaterialName(detail.getMaterialName());
                        materialInfo.setMaterialSpec(detail.getMaterialSpec());
                        materialInfo.setMaterialUnit(detail.getMaterialUnit());
                        materialInfo.setBatch(detail.getBatch());
                        materialInfo.setBoxCode(detail.getBoxCode());
                        materialInfo.setChipCode1(detail.getChipCode1());
                        materialInfo.setLevel(detail.getLevel());
                        materialInfo.setColor(detail.getColor());
                        materialInfo.setProPackaging(detail.getProPackaging());
                        materialInfo.setProductSchedule(detail.getProductSchedule());
                        return materialInfo;
                    })
                    .collect(Collectors.toList());
        }
        pdaCheck.setMaterialInformationList(materialInformationList);
        pdaCheck.setBoxCodeQty(materialInformationList.size()/2);
        pdaCheck.setChipCodeQty(materialInformationList.size());
        return AjaxResult.success(pdaCheck);
    }

    @Override
    @Transactional
    public AjaxResult agvGetLocation(String containerCode,String taskNo) {
        LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        taskHeaderLambdaQueryWrapper.eq(TaskHeader::getTaskType,QuantityConstant.TASK_TYPE_WHOLERECEIPT)
                .ne(TaskHeader::getStatus,QuantityConstant.TASK_STATUS_COMPLETED)
                .eq(TaskHeader::getContainerCode,containerCode);
        List<TaskHeader> taskHeaders = taskHeaderService.list(taskHeaderLambdaQueryWrapper);
        String p=null;
        if (taskHeaders.size()>0)
        {
            AjaxResult result=new AjaxResult();
            result=AjaxResult.success("agv重复请求 任务已存在");
            if (taskHeaders.get(0).getFromPort().equals(QuantityConstant.PORT_P1005)) {
                p = QuantityConstant.PORT_P1004;
            }

            if (taskHeaders.get(0).getFromPort().equals(QuantityConstant.PORT_P1001)) {
                p = QuantityConstant.PORT_P1000;
            }
            result.setData(p);
            return result;
        }

        //根据托盘号查入库组盘表
        LambdaQueryWrapper<ReceiptContainerHeader> receiptContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        receiptContainerHeaderLambdaQueryWrapper.eq(ReceiptContainerHeader::getContainerCode,containerCode)
                .eq(ReceiptContainerHeader::getStatus,QuantityConstant.RECEIPT_CONTAINER_BUILD);
        ReceiptContainerHeader receiptContainerHeader = receiptContainerHeaderService.getOne(receiptContainerHeaderLambdaQueryWrapper);
        if (receiptContainerHeader==null)
        {
            return AjaxResult.error("当前入库任务组盘不存在");
        }

        AgvTask agvTask = agvTaskService.getById(taskNo);
        if (agvTask==null)
        {
            return AjaxResult.error("agv任务不存在");
        }
        if (!agvTask.getContainerCode().equals(containerCode))
        {
            return AjaxResult.error("任务号查到的agv任务托盘，与传值过来的托盘不符合");
        }

        String toPort = null;
        String toLocationCode = null;
        AjaxResult ajaxResult = wcsService.getFromPort();
        if (ajaxResult.hasErr()) {
            throw new ServiceException("获取站台点失败");
        }
        JSONArray array = (JSONArray)ajaxResult.getData();

        for (int i = 0; i < array.size(); i++) {
            toPort = (String)array.get(i);
            String port = null;
            if (toPort.equals(QuantityConstant.PORT_P1005)) {
                port = QuantityConstant.PORT_P1004;
            }

            if (toPort.equals(QuantityConstant.PORT_P1001)) {
                port = QuantityConstant.PORT_P1000;
            }

            LambdaQueryWrapper<AgvTask> agvTaskLambdaQueryWrapper = Wrappers.lambdaQuery();
            agvTaskLambdaQueryWrapper.eq(AgvTask::getToPort, port).ne(AgvTask::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);
            List<AgvTask> list = agvTaskService.list(agvTaskLambdaQueryWrapper);
            toLocationCode = toPort;
            if (list.size() > 0) {
                toLocationCode = getCacheLocation();
            } else {
                break;
            }
        }

        if (array.size() == 0) {
            toLocationCode = getCacheLocation();
        }

        if (StringUtils.isEmpty(toLocationCode)) {
            throw new ServiceException("没有找到入库缓存区空闲库位");
        }

        if (toLocationCode.equals(QuantityConstant.PORT_P1001) || toLocationCode.equals(QuantityConstant.PORT_P1005)) {
            AjaxResult Result = receiptTaskService.createReceiptTask(receiptContainerHeader.getId(), QuantityConstant.DEFAULT_WAREHOUSE);
            if (Result.hasErr()) {
                throw new ServiceException("生成任务失败" + ajaxResult.getMsg());
            }
            int taskId = (int)Result.getData();
            TaskHeader taskHeader = taskHeaderService.getById(taskId);
            taskHeader.setFromPort(toLocationCode);
            taskHeader.setUserDef1(receiptContainerHeader.getOperatorName());
            taskHeader.setUserDef2(receiptContainerHeader.getQualityorName());
            taskHeaderService.updateById(taskHeader);
        }

        if (toLocationCode.equals(QuantityConstant.PORT_P1005)) {
            toLocationCode = QuantityConstant.PORT_P1004;
        }

        if (toLocationCode.equals(QuantityConstant.PORT_P1001)) {
            toLocationCode = QuantityConstant.PORT_P1000;
        }

        agvTask.setToPort(toLocationCode);
        if (!agvTaskService.updateById(agvTask))
        {
            throw new ServiceException("更新agv任务失败");
        }

        Location toLocation = locationService.getLocationByCode(toLocationCode, QuantityConstant.DEFAULT_WAREHOUSE);
        if (toLocation != null) {
            if(com.huaheng.common.utils.StringUtils.isNotEmpty(toLocation.getContainerCode())) {
                return AjaxResult.error("终点位置,有托盘号");
            }
            if (!agvTaskService.updateById(agvTask))
            {
                throw new ServiceException("更新agv任务失败");
            }
            locationService.updateStatus(toLocationCode, QuantityConstant.STATUS_LOCATION_LOCK, QuantityConstant.DEFAULT_WAREHOUSE);
        }

        AjaxResult result=new AjaxResult();
        result=AjaxResult.success("分配成功");
        result.setData(toLocationCode);
        return result;
    }

}