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.Wrappers;
import com.huaheng.api.erp.domain.*;
import com.huaheng.api.erp.domain.tracedBack.*;
import com.huaheng.pc.reservationSubmission.domain.ReservationSubmission;
import com.huaheng.pc.tool.mapper.LogisticsDomMapper;
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.StringUtils;
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.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.InventoryConfirmed.domain.InventoryConfirmed;
import com.huaheng.pc.inventory.InventoryConfirmed.service.IInventoryConfirmedService;
import com.huaheng.pc.inventory.InventoryHistoryDetail.domain.InventoryHistoryDetail;
import com.huaheng.pc.inventory.beDamaged.domain.BeDamaged;
import com.huaheng.pc.inventory.beDamaged.service.impl.BeDamagedServiceImpl;
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.inventory.inventoryTransaction.domain.InventoryTransaction;
import com.huaheng.pc.inventory.inventoryTransaction.service.InventoryTransactionService;
import com.huaheng.pc.inventory.loadingConfirmed.domain.loadingConfirmed;
import com.huaheng.pc.inventory.loadingConfirmed.service.loadingConfirmedService;
import com.huaheng.pc.receipt.receiptContainerDetail.domain.ReceiptContainerDetail;
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.reservationSubmission.service.IReservationSubmissionService;
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.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 com.huaheng.pc.tool.ChooseWrapperService;
import org.springframework.beans.factory.annotation.Autowired;
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;
import java.util.stream.Stream;

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

    @Resource
    private IInventoryHistoryHeaderService inventoryHistoryHeaderService;
    @Resource
    private ChooseWrapperService chooseWrapper;
    @Resource
    private ShipmentDetailService shipmentDetailService;
    @Resource
    private ContainerService containerService;
    @Resource
    private ContainerTypeService containerTypeService;
    @Resource
    private ChooseWrapperService chooseWrapperService;
    @Resource
    private InventoryTransactionService inventoryTransactionService;
    @Resource
    private ReceiptContainerHeaderService receiptContainerHeaderService;
    @Resource
    private ReceiptHeaderService receiptHeaderService;
    @Resource
    private PDAServiceImpl pdaService;
    @Resource
    private MaterialService materialService;
    @Resource
    private ShipmentHeaderService shipmentHeaderService;
    @Resource
    private loadingConfirmedService loadingConfirmedService;
    @Resource
    private IInventoryConfirmedService inventoryConfirmedService;
    @Resource
    private AddressService addressService;
    @Resource
    private IProPackagingService proPackagingService;
    @Resource
    private ReceiptDetailService receiptDetailService;
    @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 IReservationSubmissionService reservationSubmissionService;
    @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)
                .eq(ReceiptDetail::getProPackaging, proPackage1)
                .eq(ReceiptDetail::getProductSize, productSize);
        ReceiptDetail receiptDetail1 = receiptDetailService.getOne(receiptDetailQueryWrapper);
        if (receiptDetail1 != null) {
            receiptDetail = receiptDetail1;
            ReceiptDetail receiptDetailCop=new ReceiptDetail();
            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)) {
                receiptDetailCop.setTaskQty(taskQty);
            } else {
                receiptDetailCop.setQty(qty);
            }
            receiptDetail1.setBox(receiptHeader.getTotalQty().intValue() / pieceBox);
            receiptDetailCop.setId(receiptDetail.getId());
            result = receiptDetailService.updateById(receiptDetailCop);
        } 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 = chooseWrapper.receiptContainerDetailServiceSaveBatch(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());
        }
        // 加提示



        String  a="";
        if (receiptDetail1 != null) {
            a="老明细总数量"+receiptDetail1.getQty()+"老明细已收数量"+receiptDetail1.getTaskQty();
        } else {
            a="新明细总数量"+receiptDetail.getQty()+"新明细已收数量"+receiptDetail.getTaskQty();
        }

        LambdaQueryWrapper<ReceiptContainerDetail> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ReceiptContainerDetail::getReceiptId,receiptHeader.getId());
        BigDecimal count = BigDecimal.valueOf(chooseWrapperService.receiptContainerDetailServiceCount(wrapper));

        return AjaxResult.success("入库单号"+receiptHeader.getCode()+"入库单头数量"+receiptHeader.getTotalQty()+a+"新增组盘明细"+receiptContainerDetailList.size()+"总盘点明细数量"+count);
    }




    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult findShipmentRecordByLs(String boxCode,String shipmentCode1,String operator) {

        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper1 = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper1.eq(InventoryDetail::getBoxCode,boxCode);
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper1);
        if (inventoryDetails.isEmpty())
        {
            return AjaxResult.error("库存不存在");
        }

        String lsContainer=inventoryDetails.get(0).getContainerCode();

        if (StringUtils.isEmpty(lsContainer)) {
            return AjaxResult.error("请扫标签码");
        }
        if (StringUtils.isEmpty(shipmentCode1)) {
            return AjaxResult.error("请传出库单号");
        }
        LambdaQueryWrapper<Location> locationQuery = Wrappers.lambdaQuery();
        locationQuery.eq(Location::getContainerCode, lsContainer)
                .eq(Location::getShipmentCode,shipmentCode1);
        Location location = locationService.getOne(locationQuery);


        LambdaQueryWrapper<Container> containerLambdaQueryWrapper = Wrappers.lambdaQuery();
        containerLambdaQueryWrapper.eq(Container::getCode, lsContainer);
        Container container = containerService.getOne(containerLambdaQueryWrapper);


        ShipmentCheck check = new ShipmentCheck();
        check.setContainerCode(lsContainer);

        String code="";

        if (location == null&&container==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);
            code=shipmentHeader.getCode();
            LambdaQueryWrapper<InventoryHistoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            inventoryDetailLambdaQueryWrapper.eq(InventoryHistoryDetail::getContainerCode, lsContainer);
            List<InventoryHistoryDetail> inventoryDetailList = chooseWrapperService.inventoryHistoryDetailServiceList(inventoryDetailLambdaQueryWrapper);
            check.setLocationCode(header.getLocationCode());
            check.setShipmentHeader(shipmentHeader);
            check.setQty(inventoryDetailList.stream().map(InventoryHistoryDetail::getQty).reduce(BigDecimal.ZERO, BigDecimal::add).intValue());
        } else{
            TaskHeader taskHeader=new TaskHeader();
            if (location==null)
            {
                LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
                taskHeaderLambdaQueryWrapper.eq(TaskHeader::getContainerCode, lsContainer).ne(TaskHeader::getPortGroup,"P30");
                taskHeader=taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
            }
            String shipmentCode="";
            // 还未释放，从库存表查
            if (location==null)
            {
                if (taskHeader==null)
                {
                    LambdaQueryWrapper<InventoryHeader> inventoryHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
                    inventoryHeaderLambdaQueryWrapper.eq(InventoryHeader::getContainerCode, lsContainer).last(" limit 1");
                    InventoryHeader inventoryTest =inventoryHeaderService.getOne(inventoryHeaderLambdaQueryWrapper);
                    Location code1 = locationService.getLocationByCode(inventoryTest.getLocationCode());
                    shipmentCode=code1.getShipmentCode();
                }else
                {
                    shipmentCode=taskHeader.getShipmentCode();
                }

            }else
            {
               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(container.getLocationCode());
            check.setShipmentHeader(shipmentHeader);
            check.setQty(inventoryDetailList.stream().map(InventoryDetail::getQty).reduce(BigDecimal.ZERO, BigDecimal::add).intValue());
            code=shipmentHeader.getCode();
        }

        AjaxResult ajaxResult=AjaxResult.success();

        LambdaQueryWrapper<ShipmentHeader> shipHeaderQuery1 = Wrappers.lambdaQuery();
        shipHeaderQuery1.eq(ShipmentHeader::getCode, shipmentCode1);

        ShipmentHeader targetShipmentHeader = shipmentHeaderService.getOne(shipHeaderQuery1);

        if (targetShipmentHeader==null)
        {
            throw new ServiceException("根据条件"+shipmentCode1+"查询到出库单不存在 请检查数据");
        }
        if (!code.equals(shipmentCode1))
        {
            check.setState(400);
            // 如果不匹配，将扫码得到的单号存到msg中
            ajaxResult.setMsg(check.getShipmentHeader().getReferCode() + "," + check.getShipmentHeader().getCode());
        }else
        {
            check.setState(200);
            ajaxResult.setMsg("匹配成功");
        }

        loadingConfirmed loadingConfirmed=new loadingConfirmed();
        loadingConfirmed.setMsg(ajaxResult.getMsg());
        loadingConfirmed.setState(check.getState());
        loadingConfirmed.setLocationCode(check.getLocationCode());
        loadingConfirmed.setContainerCode(check.getContainerCode());
        loadingConfirmed.setShipmentHeaderCode(shipmentCode1);
        loadingConfirmed.setReferCode(targetShipmentHeader.getReferCode());
        loadingConfirmed.setShipmentHeaderId(targetShipmentHeader.getId());
        loadingConfirmed.setOperator(operator);
        loadingConfirmed.setOperatingTime(new Date());
        loadingConfirmed.setQty(check.getQty());
        if (!loadingConfirmedService.save(loadingConfirmed))
        {
            throw new ServiceException("保存历史记录失败");
        }
        return ajaxResult.setData(check);
    }


    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();

        if (rows.size() == 0) {
            throw new ServiceException("没有可入库巷道");
        }
        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 :lty 如果三个都满了 默认返回是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[] NoChipCodes= new String[]{""};
        String productSchedule = null;
        String batch = null;
        int size = 0;
        String[] chipCodes = Convert.toStrArray(chipCode);
        // 查询库存里面还有没有这个值
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getBoxCode, boxCode);
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);






        if (!inventoryDetails.isEmpty()) {
            // 找出不匹配的 chipCodes
            List<String> noMatchedChipCodes = inventoryDetails.stream()
                    .map(InventoryDetail::getChipCode1)
                    .filter(code -> StringUtils.isNotEmpty(chipCode) && !Arrays.asList(chipCodes).contains(code))
                    .collect(Collectors.toList());

            // 将不匹配的 chipCodes 转为数组
            NoChipCodes = noMatchedChipCodes.toArray(new String[0]);

            // 使用 Java 8 Stream 进行筛选，只保留包含在 chipCodes 中的数据
            inventoryDetails = inventoryDetails.stream()
                    .filter(detail -> StringUtils.isNotEmpty(detail.getChipCode1()) && Arrays.asList(chipCodes).contains(detail.getChipCode1()))
                    .collect(Collectors.toList());

            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);
        List<InventoryCacheDetail> inventoryCacheDetails = inventoryCacheDetailService.list(inventoryCacheDetailLambdaQueryWrapper);
        // 如果有就删除
        if (!inventoryCacheDetails.isEmpty()) {
            // 找出不匹配的 chipCodes
            List<String> noMatchedChipCodes = inventoryCacheDetails.stream()
                    .map(InventoryCacheDetail::getChipCode1)
                    .filter(code -> StringUtils.isNotEmpty(chipCode) && !Arrays.asList(chipCodes).contains(code))
                    .collect(Collectors.toList());

            // 将不匹配的 chipCodes 转为数组
            NoChipCodes = noMatchedChipCodes.toArray(new String[0]);

            // 使用 Java 8 Stream 进行筛选，只保留包含在 chipCodes 中的数据
            inventoryCacheDetails = inventoryCacheDetails.stream()
                    .filter(detail -> StringUtils.isNotEmpty(detail.getChipCode1()) && Arrays.asList(chipCodes).contains(detail.getChipCode1()))
                    .collect(Collectors.toList());

            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 = chooseWrapper.receiptContainerDetailService(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 = chooseWrapper.receiptContainerDetailServiceTool(-1).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();


        //查询库存头
        InventoryHeader inventoryHeader = inventoryHeaderService.getById(inventoryDetails.get(0).getInventoryHeaderId());

        //查询InventoryDetail里面主表id是inventoryHeader1.getId()的数量
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper1 = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper1.eq(InventoryDetail::getInventoryHeaderId, inventoryHeader.getId());
        int count = inventoryDetailService.count(inventoryDetailLambdaQueryWrapper1);

        inventoryHeader.setBoxQty(BigDecimal.valueOf(count / pieceBox));
        inventoryHeader.setTotalQty(BigDecimal.valueOf(count));
        if (count / pieceBox == 0) {
            inventoryHeaderService.removeById(inventoryHeader);
        } else {
            inventoryHeaderService.updateById(inventoryHeader);
        }

        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(BigDecimal.valueOf(chipCodes.length));
            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) {
                ShipmentDetail shipmentDetailCop=new ShipmentDetail();
                BigDecimal qty = shipmentDetail.getQty();
                qty = qty.add(new BigDecimal(pieceBox));
                shipmentDetailCop.setId(shipmentDetail.getId());
                shipmentDetailCop.setQty(qty);
                shipmentDetailService.updateById(shipmentDetailCop);
            } 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(BigDecimal.valueOf(chipCodes.length));
                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);

        for (String codes:NoChipCodes)
        {
            loosePieceInventory(codes,boxCode,null,null,null);
        }
        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)
                .in(InventoryDetail::getZoneCode, QuantityConstant.ZONE_PINGKU,QuantityConstant.ZONE_STOCK_UP);
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);
        if (inventoryDetails.size() < 1) {
            return AjaxResult.error("没在平库找到您对应扫的箱码");
        }
        System.out.println();
        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 = chooseWrapperService.inventoryHistoryDetailServiceList(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())));
                if (!receiptDetailService.updateById(details.get(0))){
                    throw new ServiceException("入库单明细更新失败");
                }
                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("库存明细里面没有这个对应的片码箱码");
        }
        String containerCode=inventoryDetail.getContainerCode();

        // 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() - 1);
        String code = MessageFormat.format("{0}{1}", QuantityConstant.VIRTUAL_PALLET_TYPE, String.format("%d", Calendar.getInstance().getTimeInMillis()));

        int inventoryid = inventoryHeader.getId();

        if (inventoryHeader.getTotalQty().compareTo(new BigDecimal("-1")) == 0||inventoryHeader.getTotalQty().compareTo(new BigDecimal("0")) == 0) {
            inventoryHeaderService.removeById(inventoryHeader);
        } else {
            inventoryHeaderService.updateById(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()));

        code = MessageFormat.format("{0}{1}", QuantityConstant.VIRTUAL_PALLET_TYPE, 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.setZoneCode(QuantityConstant.ZONE_STOCK_UP);
        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(QuantityConstant.VIRTUAL_PALLET_TYPE);
        container.setLocationCode(code);
        container.setZoneCode(QuantityConstant.ZONE_STOCK_UP);
        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);


        // 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 == null) {
            throw new ServiceException("匹配明细不正确");
        }

        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已收数量不存在");
        }

        try {
            // 乐观锁条件
            LambdaUpdateWrapper<ShipmentDetail> updateWrapper = new LambdaUpdateWrapper<ShipmentDetail>()
                    .eq(ShipmentDetail::getId, shipmentDetail.getId())
                    .eq(ShipmentDetail::getTaskQty, shipmentDetail.getTaskQty())
                    .setSql("taskQty = taskQty + 1"); // 你的更新逻辑

            // 执行更新
            boolean updateResult = shipmentDetailService.update(updateWrapper);

            // 判断更新是否成功
            if (!updateResult) {
                throw new ServiceException("更新出库单明细失败，可能是乐观锁条件不满足");
            }
        } catch (Exception e) {
            throw new ServiceException("更新出库单明细失败");
        }

        shipmentDetail.setTaskQty(shipmentDetail.getTaskQty().add(BigDecimal.valueOf(1)));

        ShipmentHeader shipmentHeader = shipmentHeaderService.getById(shipmentDetail.getShipmentId());

        if (shipmentDetail.getQty().intValue()!=1&&shipmentHeader.getLastStatus()<QuantityConstant.SHIPMENT_HEADER_PREPARE) {
            if (shipmentHeader.getCode().contains("OS")||shipmentDetail.getQty().subtract(shipmentDetail.getTaskQty()).compareTo(new BigDecimal("1")) != 0)
            {
                if (!shipmentHeader.getLastStatus().equals(QuantityConstant.SHIPMENT_HEADER_SHIPPING))
                {
                    if (!inventoryDetail.getZoneCode().equals(QuantityConstant.ZONE_E))
                    {
                        if (shipmentDetail.getQty().compareTo(shipmentDetail.getTaskQty())!=0)
                        {
                            throw new ServiceException("当前订单状态不满足出库条件 :订单明细数量不为1 or 订单状态不是审核成功 还没审核出来任务" +"当前任务数量是"+shipmentDetail.getQty()+"当前订单状态是"+shipmentHeader.getLastStatus()
                                    +"小于450为未审核出任务");
                        }
                    }
                }
            }
        }

        inventoryDetail.setZoneCode(QuantityConstant.ZONE_STOCK_UP);
        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);
            shipmentHeader.setStockId("CK003");
            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())
                        .eq(ReceiptDetail::getQty, shipmentDetail.getQty())
                        .eq(StringUtils.isNotEmpty(shipmentDetail.getFHTZDetail()), ReceiptDetail::getFHTZDetail, shipmentDetail.getFHTZDetail());
                List<ReceiptDetail> receiptDetails = receiptDetailService.list(receiptDetailLambdaQueryWrapper);
                List<ReceiptDetail> filteredReceiptDetails = receiptDetails.stream()
                        .filter(r -> r.getQty().intValue() % pieceBox != 0)
                        .collect(Collectors.toList());

                if (!filteredReceiptDetails.isEmpty()) {
                    receiptDetail = filteredReceiptDetails.get(0);
                }

                //实在没有对应的小单号就随机选一个了
                if (receiptDetail == null) {
                    receiptDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
                    receiptDetailLambdaQueryWrapper
                            .eq(ReceiptDetail::getQty, shipmentDetail.getQty())
                            .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::getQty,shipmentDetail.getQty())
                        //.eq(shipmentDetail.getSoEntryId() != null, ReceiptDetail::getSoEntryId, shipmentDetail.getSoEntryId())
                        .eq(ReceiptDetail::getReceiptId, receiptHeader.getId());
                List<ReceiptDetail> receiptDetails = receiptDetailService.list(receiptDetailLambdaQueryWrapper);



                receiptDetails= receiptDetails.stream().filter(r -> r.getMaterialCode().equals(shipmentDetail.getMaterialCode()) &&
                                r.getMaterialName().equals(shipmentDetail.getMaterialName())
                                        &&
                                r.getBatch().equals(shipmentDetail.getBatch()) &&
                                r.getProPackaging().equals(shipmentDetail.getProPackaging()) &&
                                r.getProductSchedule().equals(shipmentDetail.getProductSchedule()) &&
                                r.getLevel().equals(shipmentDetail.getLevel()) &&
                                r.getColor().equals(shipmentDetail.getColor())
                                        //&&
                                //r.getFHTZDetail().equals(shipmentDetail.getFHTZDetail())
                        )
                        .collect(Collectors.toList());

                List<ReceiptDetail> receiptDetailList  = receiptDetails.stream()
                        .filter(r -> r.getQty().equals(shipmentDetail.getQty()) &&
                                (shipmentDetail.getSoEntryId() == null || Objects.equals(r.getSoEntryId(), shipmentDetail.getSoEntryId())))
                        .collect(Collectors.toList());
                receiptDetails.removeAll(receiptDetailList);
                receiptDetail = receiptDetailList.get(0);

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

                if (!(receiptDetail.getQty().intValue() % proPackaging.getPieceBox() == 1 &&
                        receiptDetail.getTaskQty().compareTo(receiptDetail.getQty()) < 0 &&
                        receiptDetail.getTaskQty().intValue() % proPackaging.getPieceBox() != 1)) {
//                    if (receiptDetail.getQty().subtract(receiptDetail.getTaskQty()).compareTo(new BigDecimal("1")) != 0)
//                    {
//                        throw new ServiceException("数据异常 这个是散片吗 " + receiptDetail.getId());
//                    }
                }

                receiptDetail.setTaskQty(receiptDetail.getTaskQty().add(BigDecimal.valueOf(1)));
                if (!receiptDetailService.updateById(receiptDetail)){
                    throw new ServiceException("入库单明细更新失败");
                }
                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.getId() != 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("退货入库");
        chooseWrapperService.inventoryHistoryDetailServiceTool(-1).save(inventoryHistoryDetail);


        for (InventoryDetail inventoryDetail1 : inventoryDetails) {
            inventoryDetail1.setInventoryHeaderId(inventoryHeader.getId());
            inventoryDetail1.setLocationCode(code);
            inventoryDetail1.setContainerCode(code);
            inventoryDetailService.updateById(inventoryDetail1);
        }
        //把inventoryDetails里面的片码做成一个List<String>集合返回出去
        List<String> chipCodes = inventoryDetails.stream().map(InventoryDetail::getChipCode1).collect(Collectors.toList());

        for (InventoryDetail inventoryDetail1 : inventoryDetails) {
            inventoryDetailService.removeById(inventoryDetail1);
        }
        String codeA="";
        for (String chipCode1 : chipCodes) {
            codeA=loosePieceInventory(chipCode1, boxCode,null,null,null).getMsg();
        }

        LambdaQueryWrapper<InventoryDetail> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(InventoryDetail::getContainerCode,containerCode);
        List<InventoryDetail> inventoryDetails2 = inventoryDetailService.list(lambdaQueryWrapper);
        if (inventoryDetails2.isEmpty()) {
            if (containerCode.contains("LS"))
            {
                LambdaQueryWrapper<Container> containerLambdaQueryWrapper = Wrappers.lambdaQuery();
                containerLambdaQueryWrapper.eq(Container::getCode,containerCode);
                containerService.remove(containerLambdaQueryWrapper);
            }else
            {
                containerService.updateLocationCodeAndStatus(containerCode, "", QuantityConstant.STATUS_CONTAINER_EMPTY);
            }
        }

        LambdaQueryWrapper<InventoryDetail> lambdaQueryWrapper1 = Wrappers.lambdaQuery();
        lambdaQueryWrapper1.eq(InventoryDetail::getContainerCode,codeA);
        List<InventoryDetail> inventoryDetails1 = inventoryDetailService.list(lambdaQueryWrapper1);
        if (inventoryDetails1.isEmpty()) {
            LambdaQueryWrapper<Container> containerLambdaQueryWrapper = Wrappers.lambdaQuery();
            containerLambdaQueryWrapper.eq(Container::getCode,codeA)
                    .like(Container::getCode,"LS");
            containerService.remove(containerLambdaQueryWrapper);
        }

        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 = chooseWrapperService.inventoryHistoryDetailServiceList(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 chipCodes, String boxCode, String locationCode,String receiptCode,String receiptDetailId) {
        if (StringUtils.isNotEmpty(receiptCode)&&StringUtils.isNotEmpty(receiptDetailId))
        {
            ReceiptDetail receiptDetail = receiptDetailService.getById(receiptDetailId);
            if (!receiptDetailService.lambdaUpdate()
                    .eq(ReceiptDetail::getId, receiptDetailId)
                    .set(ReceiptDetail::getTaskQty, receiptDetail.getTaskQty().add(new BigDecimal(1))).update()) {
                throw new ServiceException("修改明细数量失败");
            }

            LambdaQueryWrapper<ReceiptDetail> receiptDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            receiptDetailLambdaQueryWrapper.eq(ReceiptDetail::getReceiptId,receiptDetail.getReceiptId());
            List<ReceiptDetail> receiptDetails = receiptDetailService.list(receiptDetailLambdaQueryWrapper);
            boolean allEqual = receiptDetails.stream().allMatch(detail -> detail.getQty().equals(detail.getTaskQty()));

            if (allEqual) {
                if (!receiptHeaderService.lambdaUpdate()
                        .eq(ReceiptHeader::getCode, receiptCode)
                        .set(ReceiptHeader::getFirstStatus, QuantityConstant.RECEIPT_HEADER_POSTING)
                        .set(ReceiptHeader::getLastStatus,QuantityConstant.RECEIPT_HEADER_POSTING)
                        .update()) {
                    throw new ServiceException("修改单据头状态失败");
                }

            }

        }

        String containerCode ="";
        String[] chipCode = Convert.toStrArray(chipCodes);
        if (StringUtils.isEmpty(locationCode)) {
            //如果是空的给一个虚拟的
            String code = containerService.createContainer("5", "E");
            containerCode=code;
            Location location = new Location();
            location.setId(null);
            location.setCode(code);
            location.setZoneCode(QuantityConstant.ZONE_STOCK_UP);
            location.setWarehouseCode(QuantityConstant.DEFAULT_WAREHOUSE);
            location.setContainerCode(code);
            if (!locationService.save(location)) {
                throw new ServiceException("更新库位失败");
            }
            locationCode = location.getCode();
        }
        //1.还在库存的 直接找出对应库存然后格外创建头跟修改明细的主表id
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(StringUtils.isNotEmpty(boxCode), InventoryDetail::getBoxCode, boxCode).in(InventoryDetail::getChipCode1, chipCode);
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);

        if (!inventoryDetails.isEmpty() && inventoryDetails.size() == chipCode.length) {
            //查询库存头
            InventoryHeader inventoryHeader1 = inventoryHeaderService.getById(inventoryDetails.get(0).getInventoryHeaderId());

            LambdaQueryWrapper<ProPackaging> proPackagingLambdaQueryWrapper = Wrappers.lambdaQuery();
            proPackagingLambdaQueryWrapper.eq(ProPackaging::getNumber, inventoryHeader1.getProPackaging());
            ProPackaging proPackaging = proPackingService.getOne(proPackagingLambdaQueryWrapper);
            if (proPackaging == null) {
                return AjaxResult.error("没有包装信息");
            }
            int pieceBox = proPackaging.getPieceBox();

            //查询InventoryDetail里面主表id是inventoryHeader1.getId()的数量
            LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper1 = Wrappers.lambdaQuery();
            inventoryDetailLambdaQueryWrapper1.eq(InventoryDetail::getInventoryHeaderId, inventoryHeader1.getId());
            int count = inventoryDetailService.count(inventoryDetailLambdaQueryWrapper1);

            inventoryHeader1.setTotalQty(BigDecimal.valueOf(count - inventoryDetails.size()));
            //箱码等除pieceBox的余数
            inventoryHeader1.setBoxQty(BigDecimal.valueOf((count - inventoryDetails.size()) / pieceBox));
            if (count - inventoryDetails.size() == 0) {
                inventoryHeaderService.removeById(inventoryHeader1);
            } else {
                inventoryHeaderService.updateById(inventoryHeader1);
            }


            //循环inventoryDetails
            for (InventoryDetail inventoryDetail : inventoryDetails) {
                String code = MessageFormat.format("{0}{1}", QuantityConstant.VIRTUAL_PALLET_TYPE, String.format("%d", Calendar.getInstance().getTimeInMillis()));
                Container container = new Container();
                container.setCode(code);
                container.setWarehouseCode(QuantityConstant.ryTask_warehouse_code);
                container.setContainerType(QuantityConstant.VIRTUAL_PALLET_TYPE);
                container.setLocationCode(locationCode);
                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("新增容器失败");
                }
                inventoryHeader1.setId(null);
                inventoryHeader1.setLocationCode(locationCode);
                inventoryHeader1.setContainerCode(code);
                inventoryHeader1.setZoneCode(QuantityConstant.ZONE_E);
                inventoryHeader1.setContainerStatus(QuantityConstant.STATUS_CONTAINER_SOME);
                inventoryHeader1.setTotalQty(BigDecimal.valueOf(1));
                inventoryHeader1.setCreatedBy("PDA散片入库");
                inventoryHeader1.setLastUpdatedBy("PDA散片入库");
                inventoryHeader1.setBoxQty(BigDecimal.ZERO);
                inventoryHeaderService.save(inventoryHeader1);
                inventoryDetail.setContainerCode(code);
                inventoryDetail.setLocationCode(locationCode);
                inventoryDetail.setZoneCode(QuantityConstant.ZONE_E);
                inventoryDetail.setInventoryHeaderId(inventoryHeader1.getId());
            }

            //用LambdaUpdateWrapper修改Location里面code=locationCode的setContainerCode为code
            LambdaUpdateWrapper<Location> locationLambdaUpdateWrapper = Wrappers.lambdaUpdate();
            locationLambdaUpdateWrapper.eq(Location::getCode, locationCode).set(Location::getContainerCode, inventoryDetails.get(0).getContainerCode());
            if (!locationService.update(locationLambdaUpdateWrapper)) {
                throw new ServiceException("修改库位失败");
            }

            if (inventoryDetailService.updateBatchById(inventoryDetails)) {
                return AjaxResult.success();
            }
        }


        //2.在入库缓存区找
        LambdaQueryWrapper<ReceiptContainerDetail> receiptContainerDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        receiptContainerDetailLambdaQueryWrapper.in(StringUtils.isNotEmpty(chipCodes), ReceiptContainerDetail::getChipCode1, chipCode).eq(StringUtils.isNotEmpty(boxCode), ReceiptContainerDetail::getBoxCode, boxCode).last("limit 1");
        ReceiptContainerDetail receiptContainerDetail = (ReceiptContainerDetail) chooseWrapper.receiptContainerDetailServiceGetOne(receiptContainerDetailLambdaQueryWrapper);

        //1.还在库存的 直接找出对应库存然后格外创建头跟修改明细的主表id
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper1 = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper1.eq(StringUtils.isNotEmpty(boxCode), InventoryDetail::getBoxCode, boxCode)
                .last(" limit 1");
        InventoryDetail inventoryDetail1 = inventoryDetailService.getOne(inventoryDetailLambdaQueryWrapper1);


        //循环chipCode
        for (String s : chipCode) {
            String code = MessageFormat.format("{0}{1}", QuantityConstant.VIRTUAL_PALLET_TYPE, String.format("%d", Calendar.getInstance().getTimeInMillis()));
            Container container = new Container();
            container.setCode(code);
            container.setWarehouseCode(QuantityConstant.ryTask_warehouse_code);
            container.setContainerType(QuantityConstant.VIRTUAL_PALLET_TYPE);
            container.setLocationCode(locationCode);
            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("新增容器失败");
            }

            //用LambdaUpdateWrapper修改Location里面code=locationCode的setContainerCode为code
            LambdaUpdateWrapper<Location> locationLambdaUpdateWrapper = Wrappers.lambdaUpdate();
            locationLambdaUpdateWrapper.eq(Location::getCode, locationCode).set(Location::getContainerCode, code);
            if (!locationService.update(locationLambdaUpdateWrapper)) {
                throw new ServiceException("修改库位失败");
            }
            InventoryHeader inventoryHeader = new InventoryHeader();
            inventoryHeader.setWarehouseCode(QuantityConstant.DEFAULT_WAREHOUSE);
            inventoryHeader.setZoneCode(QuantityConstant.ZONE_E);
            inventoryHeader.setLocationCode(locationCode);
            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);
            if (receiptContainerDetail==null)
            {
                inventoryHeader.setMaterialCode(inventoryDetail1.getMaterialCode());
                inventoryHeader.setMaterialName(inventoryDetail1.getMaterialName());
                inventoryHeader.setMaterialSpec(inventoryDetail1.getMaterialSpec());
                inventoryHeader.setMaterialUnit(inventoryDetail1.getMaterialUnit());
                inventoryHeader.setLevel(inventoryDetail1.getLevel());
                inventoryHeader.setColor(inventoryDetail1.getColor());
                inventoryHeader.setProPackaging(inventoryDetail1.getProPackaging());
                inventoryHeader.setProductSchedule(inventoryDetail1.getProductSchedule());
                inventoryHeader.setBatch(inventoryDetail1.getBatch());
                inventoryHeader.setProductSize(inventoryDetail1.getProductSize());
            }else
            {
                inventoryHeader.setMaterialCode(receiptContainerDetail.getMaterialCode());
                inventoryHeader.setMaterialName(receiptContainerDetail.getMaterialName());
                inventoryHeader.setMaterialSpec(receiptContainerDetail.getMaterialSpec());
                inventoryHeader.setMaterialUnit(receiptContainerDetail.getMaterialUnit());
                inventoryHeader.setLevel(receiptContainerDetail.getLevel());
                inventoryHeader.setColor(receiptContainerDetail.getColor());
                inventoryHeader.setProPackaging(receiptContainerDetail.getProPackaging());
                inventoryHeader.setProductSchedule(receiptContainerDetail.getProductSchedule());
                inventoryHeader.setBatch(receiptContainerDetail.getBatch());
                inventoryHeader.setProductSize(receiptContainerDetail.getProductSize());
            }
            inventoryHeader.setBoxQty(BigDecimal.valueOf(0));
            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.setChipCode1(s);
            if (receiptContainerDetail==null)
            {
                inventoryDetail.setBoxCode(inventoryDetail1.getBoxCode());
                inventoryDetail.setMaterialName(inventoryDetail1.getMaterialName());
                inventoryDetail.setMaterialCode(inventoryDetail1.getMaterialCode());
                inventoryDetail.setMaterialSpec(inventoryDetail1.getMaterialSpec());
                inventoryDetail.setMaterialUnit(inventoryDetail1.getMaterialUnit());
                inventoryDetail.setBatch(inventoryDetail1.getBatch());
                inventoryDetail.setProjectNo(inventoryDetail1.getProductSchedule());
                inventoryDetail.setLevel(inventoryDetail1.getLevel());
                inventoryDetail.setColor(inventoryDetail1.getColor());
                inventoryDetail.setProPackaging(inventoryDetail1.getProPackaging());
                inventoryDetail.setProductSchedule(inventoryDetail1.getProductSchedule());
                inventoryDetail.setProductSize(inventoryDetail1.getProductSize());
            }else {
                inventoryDetail.setBoxCode(receiptContainerDetail.getBoxCode());
                inventoryDetail.setMaterialName(receiptContainerDetail.getMaterialName());
                inventoryDetail.setMaterialCode(receiptContainerDetail.getMaterialCode());
                inventoryDetail.setMaterialSpec(receiptContainerDetail.getMaterialSpec());
                inventoryDetail.setMaterialUnit(receiptContainerDetail.getMaterialUnit());
                inventoryDetail.setBatch(receiptContainerDetail.getBatch());
                inventoryDetail.setProjectNo(receiptContainerDetail.getProductSchedule());
                inventoryDetail.setLevel(receiptContainerDetail.getLevel());
                inventoryDetail.setColor(receiptContainerDetail.getColor());
                inventoryDetail.setProPackaging(receiptContainerDetail.getProPackaging());
                inventoryDetail.setProductSchedule(receiptContainerDetail.getProductSchedule());
                inventoryDetail.setProductSize(receiptContainerDetail.getProductSize());
            }
            inventoryDetail.setQty(BigDecimal.valueOf(1));
            inventoryDetail.setTaskQty(BigDecimal.valueOf(0));
            inventoryDetail.setReceiptDetailId(0);
            inventoryDetail.setInventorySts(QuantityConstant.QUALITY_GOOD);
            inventoryDetail.setShipmentOrder(0);

            LambdaQueryWrapper<InventoryDetail> queryWrapper = new LambdaQueryWrapper<>(inventoryDetail);
            List<InventoryDetail> inventoryDetailList = inventoryDetailService.list(queryWrapper);
            if (!inventoryDetailList.isEmpty()) {
                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(containerCode);
    }

    @Override
    @Transactional
    public AjaxResult flatLibraryBinding(String containerCode, String shipmentDetailId) {

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


        //根据托盘查出明细 不能有重复的
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getContainerCode, containerCode);
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);

        //inventoryDetails的属性要对于shipmentDetail属性,如果有不等于的就要报错
        List<InventoryDetail> inventoryDetails1 = inventoryDetails.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 (inventoryDetails1.size() !=inventoryDetails.size()) {
            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<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        taskHeaderLambdaQueryWrapper.eq(TaskHeader::getPortGroup,"P30")
                .eq(TaskHeader::getContainerCode,containerCode);
        TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);


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

        if (location == null) {
            //还有一种情况就是库位绑定了其他容器
            return AjaxResult.error("平库没有找到对应库存");
        }


        LambdaQueryWrapper<ShipmentHeader> shipmentHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        if (taskHeader!=null)
        {
            shipmentHeaderLambdaQueryWrapper.eq(ShipmentHeader::getCode, taskHeader.getShipmentCode());
        }else
        {
            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());
        if (taskHeader!=null)
        {
            shipmentHeader.setUserDef3(taskHeader.getShipmentCode());
        }
        else
        {
            shipmentHeader.setUserDef3(location.getShipmentCode());
        }

        shipmentHeader.setFSrcStockId(header.getFSrcStockId());
        shipmentHeader.setLastWaveId(header.getId());


        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) {
            throw new ServiceException("单据不匹配 请检查属性");
        }
        LambdaQueryWrapper<InventoryHeader> inventoryHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryHeaderLambdaQueryWrapper.eq(InventoryHeader::getContainerCode, container.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) {
            throw new ServiceException("单据跟库存不匹配 请检查属性");
        }

        if (inventoryHeaders.size() == 1) {

            LambdaQueryWrapper<InventoryHeader> inventoryHeaderLambdaQueryWrapper11 = Wrappers.lambdaQuery();
            inventoryHeaderLambdaQueryWrapper11.eq(InventoryHeader::getLocationCode, location.getCode());
            List<InventoryHeader> inventoryHeaderList = inventoryHeaderService.list(inventoryHeaderLambdaQueryWrapper11);

            if (inventoryHeaderList.size()==1)
            {
                location.setShipmentCode("");
                location.setContainerCode("");
                if (!locationService.updateById(location)) {
                    throw new ServiceException("更新库位失败");
                }
            }else
            {
                if (location.getContainerCode().equals(container.getCode()))
                {
                    // 在 inventoryHeaderList 中找到一个 containerCode 与 container.getCode() 不同的值
                    String newContainerCode = inventoryHeaderList.stream()
                            .map(InventoryHeader::getContainerCode) // 提取 containerCode
                            .filter(code -> !code.equals(container.getCode())) // 过滤掉与 container.getCode() 相同的值
                            .findFirst() // 找到第一个匹配的值
                            .orElseThrow(() -> new ServiceException("没有找到与当前 containerCode 不匹配的记录")); // 如果没有找到，抛出异常

                    // 设置新的 containerCode
                    location.setContainerCode(newContainerCode);

                    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(QuantityConstant.VIRTUAL_PALLET_TYPE)).collect(Collectors.toList());
        if (headers1.size() > 0) {
            throw new ServiceException("当前库存已经绑定过了");
        }

        location.setId(null);
        location.setShipmentCode(shipmentDetail.getShipmentCode());
        String code = MessageFormat.format("{0}{1}", QuantityConstant.VIRTUAL_PALLET_TYPE, String.format("%d", Calendar.getInstance().getTimeInMillis()));
        location.setCode(location.getCode() + code);
        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()));
        shipmentDetail1.setUserDef1(containerCode);
        if (!shipmentDetailService.updateById(shipmentDetail1)) {
            throw new ServiceException("批量保存失败");
        }

        AjaxResult ajaxResult = receiptHeaderService.createDirectTransferReceipt(shipmentHeader);
        int receiptId = (int) ajaxResult.getData();
        //ReceiptHeader receiptHeader = receiptHeaderService.getById(receiptId);
        LambdaQueryWrapper<ReceiptDetail> receiptDetailLambdaQueryWrapper=new LambdaQueryWrapper<>();
        receiptDetailLambdaQueryWrapper.eq(ReceiptDetail::getReceiptId,receiptId)
                .eq(ReceiptDetail::getMaterialCode,inventoryHeader.getMaterialCode())
                .eq(ReceiptDetail::getLevel,inventoryHeader.getLevel())
                .eq(ReceiptDetail::getBatch,inventoryHeader.getBatch())
                .eq(ReceiptDetail::getProductSchedule,inventoryHeader.getProductSchedule())
                .eq(ReceiptDetail::getProPackaging,inventoryHeader.getProPackaging())
                .eq(shipmentDetail.getSoEntryId()!=null,ReceiptDetail::getSoEntryId,shipmentDetail.getSoEntryId());
        ReceiptDetail receiptDetail = receiptDetailService.getOne(receiptDetailLambdaQueryWrapper);
        inventoryDetailService.lambdaUpdate()
                .set(InventoryDetail::getReceiptDetailId, receiptDetail.getId())
                .set(InventoryDetail::getReceiptCode, receiptDetail.getReceiptCode())
                .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("修改直接调拨单状态失败");
                }
            }
            if (shipmentHeader.getShipmentType().equals("OS"))
            {
                if (inventoryHeader.getZoneCode().equals("D"))
                {
                    shipmentHeader.setFSrcStockId("10237102");
                }else {
                    shipmentHeader.setFSrcStockId("10843929");
                }
            }
            shipmentHeaderService.updateById(shipmentHeader);
        }
        String msg="绑定成功,根据传来的 被绑定的出库单号是"+shipmentDetail.getShipmentCode()
                +"查出的出库单id是"+shipmentHeader.getId()+"跟"+shipmentHeader.getCode();

        return AjaxResult.success(msg);
    }

    @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 = (ReceiptContainerDetail) chooseWrapper.receiptContainerDetailServiceGetOne(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);
            }
            List<InventoryDetail> details = inventoryDetails.stream().filter(i -> i.getZoneCode().equals("E")).collect(Collectors.toList());
            if (details.size() == 1) {
                List<String> ChipS = details.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 List<MaterialInformation> PDACheck(String boxCode, String containerCode, String chipCode) {
        List<MaterialInformation> materialInformationList = new ArrayList<>();

        //优先查库存有没有
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(StringUtils.isNotEmpty(boxCode), InventoryDetail::getBoxCode, boxCode)
                .eq(StringUtils.isNotEmpty(containerCode), InventoryDetail::getContainerCode, containerCode)
                .eq(StringUtils.isNotEmpty(chipCode), InventoryDetail::getChipCode1, chipCode).last("LIMIT 1");
        InventoryDetail inventoryDetail = inventoryDetailService.getOne(inventoryDetailLambdaQueryWrapper);

        if (inventoryDetail != null) {

            LambdaQueryWrapper<InventoryHeader> inventoryHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            inventoryHeaderLambdaQueryWrapper.eq(InventoryHeader::getMaterialCode, inventoryDetail.getMaterialCode())
                    .eq(InventoryHeader::getMaterialName, inventoryDetail.getMaterialName())
                    .eq(InventoryHeader::getColor, inventoryDetail.getColor())
                    .eq(InventoryHeader::getBatch, inventoryDetail.getBatch())
                    .eq(InventoryHeader::getLevel, inventoryDetail.getLevel())
                    .eq(InventoryHeader::getProductSchedule, inventoryDetail.getProductSchedule())
                    .eq(InventoryHeader::getProPackaging, inventoryDetail.getProPackaging());

            List<InventoryHeader> inventoryHeaders = inventoryHeaderService.list(inventoryHeaderLambdaQueryWrapper);

            //根据in的集合查询一下库存头列表
            for (InventoryHeader inventoryHeader : inventoryHeaders) {
                MaterialInformation materialInformation = new MaterialInformation();
                materialInformation.setBatch(inventoryHeader.getBatch());
                materialInformation.setQty(inventoryHeader.getTotalQty());
                materialInformation.setLevel(inventoryHeader.getLevel());
                materialInformation.setController(inventoryHeader.getContainerCode());
                materialInformation.setColor(inventoryHeader.getColor());
                materialInformation.setMaterialCode(inventoryHeader.getMaterialCode());
                materialInformation.setMaterialName(inventoryHeader.getMaterialName());
                materialInformation.setMaterialUnit(inventoryHeader.getMaterialUnit());
                materialInformation.setMaterialSpec(inventoryHeader.getMaterialSpec());
                materialInformation.setProductSchedule(inventoryHeader.getProductSchedule());
                materialInformation.setLocationCode(inventoryHeader.getLocationCode());
                materialInformation.setProPackaging(inventoryHeader.getProPackaging());
                materialInformationList.add(materialInformation);
            }
        }


        //查入库缓存区
        //先查询入库阻组盘
        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)
                .like(ReceiptContainerDetail::getContainerCode, "J")
                .ne(ReceiptContainerDetail::getStatus, QuantityConstant.RECEIPT_CONTAINER_FINISHED)
                .last("LIMIT 1");
        ReceiptContainerDetail receiptContainerDetail = (ReceiptContainerDetail) chooseWrapper.receiptContainerDetailServiceGetOne(receiptContainerDetailLambdaQueryWrapper);
        if (receiptContainerDetail != null) {
            LambdaQueryWrapper<ReceiptContainerHeader> receiptContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            receiptContainerHeaderLambdaQueryWrapper.eq(ReceiptContainerHeader::getMaterialCode, receiptContainerDetail.getMaterialCode())
                    .eq(ReceiptContainerHeader::getLevel, receiptContainerDetail.getLevel())
                    .eq(ReceiptContainerHeader::getColor, receiptContainerDetail.getColor())
                    .eq(ReceiptContainerHeader::getBatch, receiptContainerDetail.getBatch())
                    .eq(ReceiptContainerHeader::getProductSchedule, receiptContainerDetail.getProductSchedule())
                    .eq(ReceiptContainerHeader::getProPackaging, receiptContainerDetail.getProPackaging());
            List<ReceiptContainerHeader> receiptContainerHeaders = receiptContainerHeaderService.list(receiptContainerHeaderLambdaQueryWrapper);

            List<String> Containers = receiptContainerHeaders.stream()
                    .map(ReceiptContainerHeader::getContainerCode)  // 将TaskDetail对象转换为ReceiptId
                    .distinct()                  // 去除重复的ReceiptId
                    .collect(Collectors.toList());// 收集到List中
            LambdaQueryWrapper<Location> locationLambdaQueryWrapper = Wrappers.lambdaQuery();
            locationLambdaQueryWrapper.in(Location::getContainerCode, Containers);
            List<Location> locations = locationService.list(locationLambdaQueryWrapper);


            for (ReceiptContainerHeader receiptContainerHeader : receiptContainerHeaders) {
                if (receiptContainerHeader.getStatus().equals(QuantityConstant.RECEIPT_CONTAINER_FINISHED)) {
                    continue;
                }

                List<Location> locationList = locations.stream().filter(l -> l.getContainerCode().equals(receiptContainerHeader.getContainerCode())).collect(Collectors.toList());
                LambdaQueryWrapper<ReceiptContainerDetail> receiptContainerDetailLambdaQueryWrapper1 = Wrappers.lambdaQuery();
                receiptContainerDetailLambdaQueryWrapper1.in(ReceiptContainerDetail::getReceiptContainerId, receiptContainerHeader.getId());
                List<ReceiptContainerDetail> receiptContainerDetails1 = chooseWrapper.receiptContainerDetailService(receiptContainerDetailLambdaQueryWrapper1);

                //匹配库存头列表得到唯一值
                MaterialInformation materialInformation = new MaterialInformation();
                materialInformation.setBatch(receiptContainerHeader.getBatch());
                materialInformation.setQty(BigDecimal.valueOf(receiptContainerDetails1.size()));
                materialInformation.setLevel(receiptContainerHeader.getLevel());
                materialInformation.setController(receiptContainerHeader.getContainerCode());
                materialInformation.setColor(receiptContainerHeader.getColor());
                materialInformation.setMaterialCode(receiptContainerHeader.getMaterialCode());
                materialInformation.setMaterialName(receiptContainerDetails1.get(0).getMaterialName());
                materialInformation.setMaterialUnit(receiptContainerDetails1.get(0).getMaterialUnit());
                materialInformation.setMaterialSpec(receiptContainerDetails1.get(0).getMaterialSpec());
                materialInformation.setProductSchedule(receiptContainerHeader.getProductSchedule());
                if (locationList.isEmpty()) {
                    materialInformation.setLocationCode("暂未到实际库位");
                } else {
                    materialInformation.setLocationCode(locationList.get(0).getCode());
                }
                materialInformation.setProPackaging(receiptContainerHeader.getProPackaging());
                materialInformationList.add(materialInformation);
            }

        }

        return materialInformationList;
    }

    @Override
    @Transactional
    public AjaxResult agvGetLocation(String containerCode, String taskNo, String zoneCode) {

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

        if (zoneCode.equals(QuantityConstant.ZONE_RECEIPT_CACHE)) {
            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) {

                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;
                }
                return AjaxResult.success("agv重复请求 任务已存在").setData(p);
            }
            //根据托盘号查入库组盘表
            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("当前入库任务组盘不存在");
            }


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

            StringBuilder AgvTaskId = new StringBuilder();
            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;
                receiptContainerHeader.setExceptionCode("");
                if (!list.isEmpty()) {
                    for (AgvTask s : list) {
                        AgvTaskId.append(s.getId()).append("。");
                    }
                    toLocationCode = getCacheLocation();
                    receiptContainerHeader.setExceptionCode("当前两个站台都存在任务,agv任务id如下" + AgvTaskId);
                } else {
                    break;
                }
            }

            if (array.size() == 0) {
                toLocationCode = getCacheLocation();
                receiptContainerHeader.setExceptionCode("向WCS申请的可用站台为空 当前没有可以入的站台");
            }


            //更新异常信息
            LambdaUpdateWrapper<ReceiptContainerHeader> receiptContainerHeaderLambdaUpdateWrapper = Wrappers.lambdaUpdate();
            receiptContainerHeaderLambdaUpdateWrapper.eq(ReceiptContainerHeader::getId, receiptContainerHeader.getId())
                    .set(ReceiptContainerHeader::getExceptionCode, receiptContainerHeader.getExceptionCode());
            receiptContainerHeaderService.update(receiptContainerHeaderLambdaUpdateWrapper);
            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;
        } else if (zoneCode.equals(QuantityConstant.ZONE_STOCK_UP)) {
            if (StringUtils.isNotEmpty(agvTask.getToPort())) {
                return AjaxResult.success("agv重复请求 任务已存在").setData(agvTask.getToPort());
            }

            LambdaQueryWrapper<AgvTask> agvTaskLambdaQueryWrapper = Wrappers.lambdaQuery();
            agvTaskLambdaQueryWrapper.eq(AgvTask::getZoneCode, QuantityConstant.ZONE_STOCK_UP)
                    .eq(AgvTask::getContainerCode, containerCode);
            List<AgvTask> agvTasks = agvTaskService.list(agvTaskLambdaQueryWrapper);
            if (agvTasks.size() > 1) {
                return AjaxResult.error("数据异常 有重复任务 请人工介入检车" + containerCode + "是否重复，处理后再继续，否则会造成数据异常");
            }

            LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            taskHeaderLambdaQueryWrapper.eq(TaskHeader::getAgvTaskId, agvTask.getId())
                    .eq(TaskHeader::getContainerCode, containerCode);
            TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
            String shipmentCode = taskHeader.getShipmentCode();
            int containerSpec = taskHeader.getContainerSpec();

            Location location = getBestLocationFromStack(containerSpec, shipmentCode);
            String toPort = location.getCode();

            agvTask.setStack(taskHeader.getStack());
            agvTask.setToPort(toPort);
            agvTask.setContainerSpec(taskHeader.getContainerSpec());
            if (!agvTaskService.updateById(agvTask)) {
                throw new ServiceException("更新AGV任务失败");
            }
            location.setStack(taskHeader.getStack());
            location.setContainerSpec(taskHeader.getContainerSpec());
            location.setStatus(QuantityConstant.STATUS_LOCATION_LOCK);
            locationService.updateById(location);
            taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            taskHeaderLambdaQueryWrapper.eq(TaskHeader::getContainerCode, containerCode).eq(TaskHeader::getTaskType, QuantityConstant.TASK_TYPE_WHOLERECEIPT)
                    .lt(TaskHeader::getStatus, QuantityConstant.TASK_STATUS_COMPLETED).last(" limit 1");
            TaskHeader receiptTaskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
            if (receiptTaskHeader == null) {
                throw new ServiceException("没有找到匹配任务");
            }
            receiptTaskHeader.setToLocation(toPort);
            receiptTaskHeader.setAgvTaskId(agvTask.getId());

            if (!taskHeaderService.updateById(receiptTaskHeader)) {
                throw new ServiceException("更新换站任务到出库口失败");
            }
            return AjaxResult.success("分配成功").setData(agvTask.getToPort());

        }

        return AjaxResult.error("库区不对");
    }

    // 根据垛型 分配最合适的库位
    public Location getBestLocationFromStack(int containerSpec, String shipmentCode) {
        LambdaQueryWrapper<Location> locationLambdaQueryWrapper = Wrappers.lambdaQuery();
        locationLambdaQueryWrapper.eq(Location::getZoneCode, QuantityConstant.ZONE_STOCK_UP).eq(Location::getContainerCode, "")
                .eq(Location::getStatus, QuantityConstant.STATUS_LOCATION_EMPTY).eq(Location::getShipmentCode, shipmentCode)
                .orderByAsc(Location::getIColumn).orderByAsc(Location::getILayer);
        List<Location> locationList = locationService.list(locationLambdaQueryWrapper);
        Location location = null;
        for (Location location1 : locationList) {
            int layer = location1.getILayer();
            if (layer == 2) {
                // 如果是第二层，那么不允许放不同规格的托盘

                LambdaQueryWrapper<Location> locationLambdaQueryWrapper2 = Wrappers.lambdaQuery();
                locationLambdaQueryWrapper2.eq(Location::getZoneCode, location1.getZoneCode()).eq(Location::getIRow, location1.getIRow())
                        .eq(Location::getIColumn, location1.getIColumn()).eq(Location::getILayer, 1);
                Location location2 = locationService.getOne(locationLambdaQueryWrapper2);
                if (location2 != null) {
                    int containerSpec1 = location2.getContainerSpec(); // 第一层的托盘规格
                    if (containerSpec1 != containerSpec) { // 托盘规格不同 不能叠着放
                        continue;
                    }
                    int stack1 = location2.getStack(); // 第一层的垛型
                    if (stack1 != QuantityConstant.STACK_HUI_ZI) { // 垛型不是回字型
                        continue;
                    }
                }
            }
            // 如果是前面一列有托盘，那么不允许放
            Location location3 = getLocation(location1.getZoneCode(), location1.getIRow(), location1.getIColumn() + 1, layer);
            if (location3 != null) {
                continue;
            }
            location = location1;
            break;
        }
        return location;
    }

    private Location getLocation(String zoneCode, int row, int column, int layer) {
        LambdaQueryWrapper<Location> locationLambdaQueryWrapper = Wrappers.lambdaQuery();
        locationLambdaQueryWrapper.eq(Location::getZoneCode, zoneCode).ne(Location::getContainerCode, "").eq(Location::getIRow, row).eq(Location::getIColumn, column)
                .eq(Location::getILayer, layer);
        Location location = locationService.getOne(locationLambdaQueryWrapper);
        return location;
    }

    @Override
    public AjaxResult flatLibraryChipCode(String boxCode) {
        // 1.平库
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getBoxCode, boxCode)
                .eq(InventoryDetail::getZoneCode, QuantityConstant.ZONE_PINGKU);
        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);
        }
        return AjaxResult.error("没有查到对应片码");
    }


    /* 查询产品信息
     */
    @Override
    public List<MaterialDom> productInformation(String boxCode, String chipCode, String isDepth) {
        //位置入库：组盘明细(调拨入库去平库的)
        //条件：容器是LS的
        //注意事项 ： 可能存在多次出库记录 所以产品信息是个List 优先显示一下最近一条排序
        //扩展查询 ：  如果isDepth是 进行深度查询

        /*
        物料编码  组盘明细表取
        物料名称  组盘明细表取
        物料垛型  根据该托盘号查询换站任务 LS托盘号 非P30任务查出垛型跟  *工作任务 数量
        是否拼托  根据当前明细上游号 拿到工作任务数量 小于*工作任务数量就是存在拼托
         */

        List<MaterialDom> materialDoms = new ArrayList<>();
            //普通表进行查询
            LambdaQueryWrapper<ReceiptContainerDetail> receiptContainerDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            receiptContainerDetailLambdaQueryWrapper.like(ReceiptContainerDetail::getContainerCode, QuantityConstant.VIRTUAL_PALLET_TYPE)
                    .eq(StringUtils.isNotEmpty(boxCode), ReceiptContainerDetail::getBoxCode, boxCode)
                    .eq(StringUtils.isNotEmpty(chipCode), ReceiptContainerDetail::getChipCode1, chipCode);
            //查出该明细的记录
            List<ReceiptContainerDetail> receiptContainerDetails = chooseWrapper.receiptContainerDetailService(receiptContainerDetailLambdaQueryWrapper);
            LambdaQueryWrapper<InventoryHistoryDetail> inventoryHistoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            if (receiptContainerDetails.isEmpty()) {
                inventoryHistoryDetailLambdaQueryWrapper.eq(StringUtils.isNotEmpty(boxCode), InventoryHistoryDetail::getBoxCode, boxCode)
                        .eq(StringUtils.isNotEmpty(chipCode), InventoryHistoryDetail::getChipCode1, chipCode).eq(InventoryHistoryDetail::getUserDef1, "整箱出库");
            } else {
                inventoryHistoryDetailLambdaQueryWrapper.eq(StringUtils.isNotEmpty(boxCode), InventoryHistoryDetail::getBoxCode, boxCode)
                        .eq(StringUtils.isNotEmpty(chipCode), InventoryHistoryDetail::getChipCode1, chipCode).eq(InventoryHistoryDetail::getReceiptDetailId, receiptContainerDetails.get(0).getReceiptDetailId());
            }
            List<InventoryHistoryDetail> inventoryHistoryDetails = chooseWrapperService.inventoryHistoryDetailServiceList(inventoryHistoryDetailLambdaQueryWrapper);
            List<InventoryTransaction> inventoryTransactions = new ArrayList<>();
            if (!inventoryHistoryDetails.isEmpty()) {
                MaterialDom Dom = new MaterialDom();
                Dom.setName(inventoryHistoryDetails.get(0).getMaterialName());
                Dom.setBracketType("整箱出库");
                Dom.setCode(inventoryHistoryDetails.get(0).getMaterialCode());
                Dom.setPuzzle("否");
                Dom.setContainerCode(inventoryHistoryDetails.get(0).getContainerCode());
                Dom.setMaterialQty(inventoryHistoryDetails.size());
                Dom.setTotalQty(0);
                Dom.setTimeToComplete(inventoryHistoryDetails.get(0).getLastUpdated());
                materialDoms.add(Dom);
            } else {
                LambdaQueryWrapper<InventoryTransaction> inventoryTransactionLambdaQueryWrapper = Wrappers.lambdaQuery();
                inventoryTransactionLambdaQueryWrapper
                        .eq(StringUtils.isNotEmpty(boxCode), InventoryTransaction::getBoxCode, boxCode)
                        .eq(StringUtils.isNotEmpty(chipCode), InventoryTransaction::getChipCode1, chipCode);
                //查出该明细的记录
                inventoryTransactions = inventoryTransactionService.list(inventoryTransactionLambdaQueryWrapper);
                if (!inventoryTransactions.isEmpty()) {
                    MaterialDom Dom = new MaterialDom();
                    Dom.setName(inventoryTransactions.get(0).getMaterialName());
                    Dom.setBracketType("整箱出库");
                    Dom.setCode(inventoryTransactions.get(0).getMaterialCode());
                    Dom.setPuzzle("否");
                    Dom.setContainerCode(inventoryTransactions.get(0).getContainerCode());
                    Dom.setMaterialQty(inventoryTransactions.size());
                    Dom.setTotalQty(0);
                    Dom.setTimeToComplete(inventoryTransactions.get(0).getCreated());
                    materialDoms.add(Dom);
                }
            }

            if (receiptContainerDetails.isEmpty() && inventoryHistoryDetails.isEmpty() && inventoryTransactions.isEmpty()) {
                throw new ServiceException("数据缺失 请尝试深度查询");
            } else if (receiptContainerDetails.isEmpty()) {
                return materialDoms;
            }

            List<String> containerCodes = receiptContainerDetails.stream()
                    .map(ReceiptContainerDetail::getContainerCode)
                    .collect(Collectors.toList());


            //普通任务表进行查询
            LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            taskHeaderLambdaQueryWrapper.ne(TaskHeader::getPortGroup, QuantityConstant.PORTGROUP_P30)
                    .in(TaskHeader::getContainerCode, containerCodes);
            List<TaskHeader> taskHeaders = taskHeaderService.list(taskHeaderLambdaQueryWrapper);
            if (taskHeaders.isEmpty()) {
                throw new ServiceException("数据缺失 请尝试深度查询");
            }

            for (TaskHeader task : taskHeaders) {
                MaterialDom materialDom = new MaterialDom();
                List<ReceiptContainerDetail> detailList = receiptContainerDetails.stream()
                        .filter(r -> r.getContainerCode().equals(task.getContainerCode())).collect(Collectors.toList());

                int receiptId = detailList.get(0).getReceiptId();

                LambdaQueryWrapper<ReceiptContainerDetail> receiptContainerDetailLambdaQueryWrapper1 = Wrappers.lambdaQuery();
                receiptContainerDetailLambdaQueryWrapper1.eq(ReceiptContainerDetail::getReceiptId, receiptId)
                        .eq(ReceiptContainerDetail::getContainerCode, task.getContainerCode());
                int i = chooseWrapper.receiptContainerDetailServiceCount(receiptContainerDetailLambdaQueryWrapper1);
                if (i == 0) {
                    throw new ServiceException("数据缺失 请尝试深度查询");
                }
                String stack = "";
                switch (task.getStack()) {
                    case QuantityConstant.STACK_HUI_ZI://回字型
                        stack = "回字型";
                        break;
                    case QuantityConstant.STACK_GONG_ZI: //工子型
                        stack = "工子型";
                        break;
                    case QuantityConstant.STACK_PING_FANG:  //平放托
                        stack = "平放托";
                        break;
                    case QuantityConstant.STACK_SHU_FANG:  //竖放托
                        stack = "竖放托";
                        break;
                    default:
                        stack = "未知托型";
                        break;
                }
                materialDom.setName(detailList.get(0).getMaterialName());
                materialDom.setBracketType(stack);
                materialDom.setCode(detailList.get(0).getMaterialCode());
                materialDom.setPuzzle(i % task.getTaskQty() != 0 ? "是" : "否");
                materialDom.setContainerCode(task.getContainerCode());
                materialDom.setMaterialQty(i);
                materialDom.setTotalQty(task.getTaskQty());
                materialDom.setTimeToComplete(task.getLastUpdated());
                materialDoms.add(materialDom);
            }

        return materialDoms;
    }

    @Override
    public ProduceDom productionInformation(String boxCode, String chipCode, String isDepth) {

        //根据箱码或者片码查询到组盘明细

        //组盘明细查询组盘头

        ProduceDom produceDom = new ProduceDom();

        if ("0".equals(isDepth)) {

            LambdaQueryWrapper<ReceiptContainerDetail> receiptContainerDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            receiptContainerDetailLambdaQueryWrapper.like(ReceiptContainerDetail::getContainerCode, "J")
                    .eq(StringUtils.isNotEmpty(boxCode), ReceiptContainerDetail::getBoxCode, boxCode)
                    .eq(StringUtils.isNotEmpty(chipCode), ReceiptContainerDetail::getChipCode1, chipCode).last(" limit 1");

            //查出该明细的记录
            ReceiptContainerDetail receiptContainerDetail = (ReceiptContainerDetail) chooseWrapper.receiptContainerDetailServiceGetOne(receiptContainerDetailLambdaQueryWrapper);
            if (receiptContainerDetail == null) {
                throw new ServiceException("数据缺失 请尝试深度查询");
            }

            ReceiptContainerHeader receiptContainerHeader = receiptContainerHeaderService.getById(receiptContainerDetail.getReceiptContainerId());
            if (receiptContainerHeader == null) {
                throw new ServiceException("数据缺失 请尝试深度查询");
            }

            ReceiptHeader receiptHeader = receiptHeaderService.getById(receiptContainerDetail.getReceiptId());
            if (receiptHeader == null) {
                throw new ServiceException("数据缺失 请尝试深度查询");
            }

            produceDom.setCode(receiptHeader.getReferCode());
            produceDom.setLevel(receiptContainerDetail.getLevel());
            produceDom.setOperator(receiptContainerHeader.getOperatorName());
            produceDom.setQcCheck(receiptContainerHeader.getQualityorName());
            produceDom.setProPackaging(receiptContainerHeader.getProPackaging());
            produceDom.setBatch(receiptContainerHeader.getBatch());
            produceDom.setProductSchedule(receiptContainerHeader.getProductSchedule());
            produceDom.setPackagingLine(receiptHeader.getInPort());
            produceDom.setProductionTime(receiptHeader.getCreated());
            produceDom.setColor(receiptContainerHeader.getColor());
        } else {
            //TODO :lty 待分表后进行完善
            throw new ServiceException("数据异常 查询失败");
        }
        return produceDom;
    }

    @Override
    public List<StorageDom> inboundInformation(String boxCode, String chipCode, String isDepth) {
        //定义需要回传list
        List<StorageDom> storageDoms = new ArrayList<>();

            //如果不深度查询就去当前任务表 匹配规则
            LambdaQueryWrapper<TaskDetail> taskDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            taskDetailLambdaQueryWrapper.eq(StringUtils.isNotEmpty(boxCode), TaskDetail::getBoxCode, boxCode)
                    .eq(StringUtils.isNotEmpty(chipCode), TaskDetail::getChipCode1, chipCode)
                    .eq(TaskDetail::getTaskType, QuantityConstant.TASK_TYPE_WHOLERECEIPT);
            List<TaskDetail> taskDetails = taskDetailService.list(taskDetailLambdaQueryWrapper);
            if (taskDetails.isEmpty()) {
                throw new ServiceException("数据缺失 请尝试深度查询");
            }

            //拿到任务明细的主单局id 去重一下 因为按箱码查会有多条
            List<Integer> integerList = taskDetails.stream()
                    .map(TaskDetail::getTaskId)  // 将TaskDetail对象转换为taskId
                    .distinct()                  // 去除重复的taskId
                    .collect(Collectors.toList());// 收集到List中

            //查出所有任务头
            LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            taskHeaderLambdaQueryWrapper.in(TaskHeader::getId, integerList).orderByAsc(TaskHeader::getCreated);
            List<TaskHeader> taskHeaders = taskHeaderService.list(taskHeaderLambdaQueryWrapper);

            if (taskHeaders.isEmpty()) {
                throw new ServiceException("数据缺失 请尝试深度查询");
            }
            //拿出任务头的容器号 方便in查询入库阻盘表拿到入库单号
            List<String> containerCodes = taskHeaders.stream()
                    .map(TaskHeader::getContainerCode)
                    .collect(Collectors.toList());

            //拿到入库单号
            LambdaQueryWrapper<ReceiptContainerDetail> receiptContainerDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            receiptContainerDetailLambdaQueryWrapper.in(ReceiptContainerDetail::getContainerCode, containerCodes)
                    .eq(StringUtils.isNotEmpty(boxCode), ReceiptContainerDetail::getBoxCode, boxCode)
                    .eq(StringUtils.isNotEmpty(chipCode), ReceiptContainerDetail::getChipCode1, chipCode);
            List<ReceiptContainerDetail> receiptContainerDetails = chooseWrapper.receiptContainerDetailService(receiptContainerDetailLambdaQueryWrapper);

            if (receiptContainerDetails.isEmpty()) {
                throw new ServiceException("数据缺失 请尝试深度查询");
            }
            //拿到入库单的主单局id 去重一下 因为按箱码查会有多条
            List<Integer> integers = receiptContainerDetails.stream()
                    .map(ReceiptContainerDetail::getReceiptId)  // 将TaskDetail对象转换为ReceiptId
                    .distinct()                  // 去除重复的ReceiptId
                    .collect(Collectors.toList());// 收集到List中

            LambdaQueryWrapper<ReceiptHeader> receiptHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            receiptHeaderLambdaQueryWrapper.in(ReceiptHeader::getId, integers);
            List<ReceiptHeader> receiptHeaders = receiptHeaderService.list(receiptHeaderLambdaQueryWrapper);
            if (receiptHeaders.isEmpty()) {
                throw new ServiceException("数据缺失 请尝试深度查询");
            }

            //便利进行赋值
            for (TaskHeader taskHeader : taskHeaders) {
                List<ReceiptContainerDetail> list = receiptContainerDetails.stream().filter(r -> r.getContainerCode().equals(taskHeader.getContainerCode())).collect(Collectors.toList());
                List<ReceiptHeader> receiptHeaderList = receiptHeaders.stream().filter(r -> r.getId().equals(list.get(0).getReceiptId())).collect(Collectors.toList());
                StorageDom storageDom = new StorageDom();
                storageDom.setContainerCode(taskHeader.getContainerCode());
                storageDom.setLocationCode(taskHeader.getToLocation());
                storageDom.setReceiptCode(!receiptHeaderList.isEmpty() ? receiptHeaderList.get(0).getCode() : taskHeader.getContainerCode().contains(QuantityConstant.VIRTUAL_PALLET_TYPE) ? "调拨入库单" : "单据丢失");
                storageDom.setInboundTime(taskHeader.getCreated());
                storageDoms.add(storageDom);
            }

        return storageDoms;
    }

    @Autowired
    private LogisticsDomMapper logisticsDomMapper;
    @Override
    public List<LogisticsDom> itemInformation(String boxCode, String chipCode, String isDepth) {
        List<LogisticsDom> logisticsDomList = new ArrayList<>();

        //先查询破损表 如果有就先替换下
        LambdaQueryWrapper<BeDamaged> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.eq(BeDamaged::getBoxCode1, boxCode)
                .eq(StringUtils.isNotEmpty(chipCode), BeDamaged::getChipCode2, chipCode)
                .last(" limit 1");
        BeDamaged beDamaged = beDamagedService.getOne(lambdaQueryWrapper);
        if (beDamaged != null) {
            boxCode = beDamaged.getBoxCode();
            if (StringUtils.isNotEmpty(beDamaged.getChipCode2()))
            {
                chipCode = beDamaged.getChipCode1();
            }
        }

        // 使用自定义SQL查询
        List<LogisticsDom> logisticsDoms = logisticsDomMapper.selectCustomQuery(boxCode, chipCode);
        logisticsDoms=logisticsDoms.stream().distinct().collect(Collectors.toList());




            //拿到入库单号
            LambdaQueryWrapper<ReceiptContainerDetail> receiptContainerDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            receiptContainerDetailLambdaQueryWrapper.eq(StringUtils.isNotEmpty(boxCode), ReceiptContainerDetail::getBoxCode, boxCode)
                    .eq(StringUtils.isNotEmpty(chipCode), ReceiptContainerDetail::getChipCode1, chipCode)
                    .like(ReceiptContainerDetail::getContainerCode, "LS");
            List<ReceiptContainerDetail> receiptContainerDetails = chooseWrapper.receiptContainerDetailService(receiptContainerDetailLambdaQueryWrapper);
            if (receiptContainerDetails.isEmpty()) {
                //没有入库组盘就任务里面找
                LambdaQueryWrapper<TaskDetail> taskDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
                taskDetailLambdaQueryWrapper.eq(StringUtils.isNotEmpty(boxCode),TaskDetail::getBoxCode, boxCode)
                        .eq(StringUtils.isNotEmpty(chipCode),TaskDetail::getChipCode1, chipCode)
                        .eq(TaskDetail::getTaskType, 400)
                        .eq(TaskDetail::getInternalTaskType,200)
                        .last(" limit 1");
                TaskDetail taskDetail = taskDetailService.getOne(taskDetailLambdaQueryWrapper);
                LambdaQueryWrapper<ShipmentHeader> shipmentHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
                if (taskDetail==null)
                {
                    //全没有就得去历史表找
                    LambdaQueryWrapper<InventoryHistoryDetail> inventoryHistoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
                    inventoryHistoryDetailLambdaQueryWrapper.eq(InventoryHistoryDetail::getBoxCode, boxCode);
                    List<InventoryHistoryDetail> inventoryHistoryDetails = chooseWrapperService.inventoryHistoryDetailServiceList(inventoryHistoryDetailLambdaQueryWrapper);
                    if (inventoryHistoryDetails.isEmpty())
                    {
                        throw new ServiceException("数据缺失 请尝试深度查询");
                    }
                    //拿到入库单的主单局id 去重一下 因为按箱码查会有多条
                    List<Integer> integers = inventoryHistoryDetails.stream()
                            .map(InventoryHistoryDetail::getInventoryHistoryHeaderId)  // 将TaskDetail对象转换为ReceiptId
                            .distinct()                  // 去除重复的ReceiptId
                            .collect(Collectors.toList());// 收集到List中

                    LambdaQueryWrapper<InventoryHistoryHeader> inventoryHistoryHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
                    inventoryHistoryHeaderLambdaQueryWrapper.in(InventoryHistoryHeader::getId, integers);
                    List<InventoryHistoryHeader> inventoryHistoryHeaders = inventoryHistoryHeaderService.list(inventoryHistoryHeaderLambdaQueryWrapper);
                    if (inventoryHistoryHeaders.isEmpty())
                    {
                        throw new ServiceException("数据缺失 请尝试深度查询");
                    }

                    //拿到入库单的主单局id 去重一下 因为按箱码查会有多条
                    List<String> stringList = inventoryHistoryHeaders.stream()
                            .map(InventoryHistoryHeader::getShipmentCode)  // 将TaskDetail对象转换为ReceiptId
                            .distinct()                  // 去除重复的ReceiptId
                            .collect(Collectors.toList());// 收集到List中

                    shipmentHeaderLambdaQueryWrapper.in(ShipmentHeader::getCode,stringList);
                }else
                {
                    shipmentHeaderLambdaQueryWrapper.eq(ShipmentHeader::getId,taskDetail.getUserDef3());
                }
                List<ShipmentHeader> shipmentHeaders = shipmentHeaderService.list(shipmentHeaderLambdaQueryWrapper);
                if (shipmentHeaders==null)
                {
                    throw new ServiceException("数据缺失 可能是老数据");
                }
                for (ShipmentHeader shipmentHeader:shipmentHeaders)
                {
                    LambdaQueryWrapper<ReservationSubmission> reservationSubmissionLambdaQueryWrapper = Wrappers.lambdaQuery();
                    List<ReservationSubmission> reservationSubmissions = new ArrayList<>();

                    reservationSubmissionLambdaQueryWrapper.in(ReservationSubmission::getOrderNumber, shipmentHeader.getReferCode());
                    reservationSubmissions = reservationSubmissionService.list(reservationSubmissionLambdaQueryWrapper);
                    if (reservationSubmissions.isEmpty()) {
                        throw new ServiceException("数据缺失 请尝试深度查询");
                    }
                    List<ReservationSubmission> submissions = reservationSubmissions.stream().filter(r -> r.getOrderNumber().equals(shipmentHeader.getReferCode())).collect(Collectors.toList());
                    LogisticsDom logisticsDom = getLogisticsDom(shipmentHeader, submissions);
                    logisticsDomList.add(logisticsDom);
                }
                Map<String, LogisticsDom> logisticsDomMap = Stream.concat(
                                logisticsDoms.stream().filter(Objects::nonNull), // 过滤掉 null 元素
                                logisticsDomList.stream().filter(Objects::nonNull) // 过滤掉 null 元素
                        )
                        .collect(Collectors.toMap(
                                LogisticsDom::getInvoiceNumber, // 使用 invoiceNumber 作为 Map 的 key
                                logisticsDom -> logisticsDom,  // 使用 LogisticsDom 对象作为 Map 的 value
                                (existing, replacement) -> existing // 在 key 冲突时保留已有的对象
                        ));

                List<LogisticsDom> combinedList = new ArrayList<>(logisticsDomMap.values());
                for (LogisticsDom logisticsDom : combinedList) {
                    if (logisticsDom != null) {
                        logisticsDom.setShipmentType("发货通知单");
                    }
                }

                return combinedList;


            }
            //拿到入库单的主单局id 去重一下 因为按箱码查会有多条
            List<String> integers = receiptContainerDetails.stream()
                    .map(ReceiptContainerDetail::getContainerCode)  // 将TaskDetail对象转换为ReceiptId
                    .distinct()                  // 去除重复的ReceiptId
                    .collect(Collectors.toList());// 收集到List中

        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(StringUtils.isNotEmpty(boxCode),InventoryDetail::getBoxCode,boxCode)
                .eq(StringUtils.isNotEmpty(chipCode),InventoryDetail::getChipCode1,chipCode).last(" limit 1");
        InventoryDetail inventoryDetail = inventoryDetailService.getOne(inventoryDetailLambdaQueryWrapper);

        if (inventoryDetail!=null)
        {
            integers= Collections.singletonList(inventoryDetail.getContainerCode());
        }
        LambdaQueryWrapper<InventoryHistoryHeader> integerList = Wrappers.lambdaQuery();
        integerList.in(InventoryHistoryHeader::getContainerCode,integers);
        List<InventoryHistoryHeader> inventoryHistoryHeaders = inventoryHistoryHeaderService.list(integerList);
        LambdaQueryWrapper<ShipmentHeader> shipmentHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        LambdaQueryWrapper<ShipmentHeader> shipmentHeaderLambdaQueryWrapper1 = Wrappers.lambdaQuery();

        if (inventoryHistoryHeaders.size()!=integers.size()) {

            //查出所有任务头
            LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            taskHeaderLambdaQueryWrapper.in(TaskHeader::getContainerCode, integers).orderByAsc(TaskHeader::getCreated);
            List<TaskHeader> taskHeaders = taskHeaderService.list(taskHeaderLambdaQueryWrapper);
            if (taskHeaders.isEmpty()) {
                throw new ServiceException("任务不存，请检查是否还在库内"+integers);
            }

            // 使用 Stream API 来遍历 inventoryDetails 列表，并提取 InventoryHeaderId 字段，并去重
            List<String> ShipmentCodes = taskHeaders.stream()
                    .map(TaskHeader::getShipmentCode) // 提取 InventoryHeaderId 字段
                    .distinct() // 去重
                    .collect(Collectors.toList()); // 将结果收集到列表中
            shipmentHeaderLambdaQueryWrapper1.in(ShipmentHeader::getUserDef3,ShipmentCodes)
                    .like(ShipmentHeader::getCode,QuantityConstant.SHIPMENT_TYPE_DELIVERY);
            shipmentHeaderLambdaQueryWrapper.in(ShipmentHeader::getCode,ShipmentCodes);

        }else
        {
            List<String> shipmentCode = inventoryHistoryHeaders.stream()
                    .map(InventoryHistoryHeader::getShipmentCode)  // 将TaskDetail对象转换为ReceiptId
                    .distinct()                  // 去除重复的ReceiptId
                    .collect(Collectors.toList());// 收集到List中

            shipmentHeaderLambdaQueryWrapper.in(ShipmentHeader::getCode, shipmentCode);
        }


            List<ShipmentHeader> shipmentHeaders = shipmentHeaderService.list(shipmentHeaderLambdaQueryWrapper);
            if (shipmentHeaders.isEmpty()) {
                throw new ServiceException("数据缺失 请尝试深度查询");
            }

            //拿到入库单的主单局id 去重一下 因为按箱码查会有多条




        List<String> ReferCodes = shipmentHeaders.stream()
                .map(ShipmentHeader::getReferCode)  // 将TaskDetail对象转换为ReceiptId
                .distinct()                  // 去除重复的ReceiptId
                .collect(Collectors.toList());// 收集到List中



        LambdaQueryWrapper<ReservationSubmission> reservationSubmissionLambdaQueryWrapper = Wrappers.lambdaQuery();
        List<ReservationSubmission> reservationSubmissions = new ArrayList<>();
        reservationSubmissionLambdaQueryWrapper.in(ReservationSubmission::getOrderNumber, ReferCodes);
        reservationSubmissions = reservationSubmissionService.list(reservationSubmissionLambdaQueryWrapper);
        if (reservationSubmissions.isEmpty()) {
            List<ShipmentHeader> shipmentHeaderList = shipmentHeaderService.list(shipmentHeaderLambdaQueryWrapper1);
            if (shipmentHeaderList.isEmpty()) {

                //如果不深度查询就去当前任务表 匹配规则
                LambdaQueryWrapper<TaskDetail> taskDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
                taskDetailLambdaQueryWrapper.eq(StringUtils.isNotEmpty(boxCode), TaskDetail::getBoxCode, boxCode)
                        .eq(StringUtils.isNotEmpty(chipCode), TaskDetail::getChipCode1, chipCode)
                        .eq(TaskDetail::getTaskType, QuantityConstant.TASK_TYPE_WHOLERECEIPT);
                List<TaskDetail> taskDetails = taskDetailService.list(taskDetailLambdaQueryWrapper);
                if (taskDetails.isEmpty()) {
                    throw new ServiceException("数据缺失 请尝试深度查询");
                }

                //拿到任务明细的主单局id 去重一下 因为按箱码查会有多条
                List<Integer> integerList11 = taskDetails.stream()
                        .map(TaskDetail::getTaskId)  // 将TaskDetail对象转换为taskId
                        .distinct()                  // 去除重复的taskId
                        .collect(Collectors.toList());// 收集到List中

                //查出所有任务头
                LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
                taskHeaderLambdaQueryWrapper.in(TaskHeader::getId, integerList11)
                        .like(TaskHeader::getContainerCode,"LS").orderByAsc(TaskHeader::getCreated).last(" limit 1");
                TaskHeader taskHeader = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
                if (taskHeader==null)
                {
                    throw new ServiceException("数据缺失 请尝试深度查询");
                }
                LambdaQueryWrapper<ShipmentDetail> shipmentDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
                shipmentDetailLambdaQueryWrapper.eq(ShipmentDetail::getUserDef1,taskHeader.getContainerCode());
                ShipmentDetail shipmentDetail = shipmentDetailService.getOne(shipmentDetailLambdaQueryWrapper);

                if (shipmentDetail==null)
                {
                    throw new ServiceException("数据缺失 请尝试深度查询");
                }
                ShipmentHeader shipmentHeader = shipmentHeaderService.getById(shipmentDetail.getShipmentId());
                shipmentHeaderList.add(shipmentHeader);

            }
            ReferCodes = shipmentHeaderList.stream()
                    .map(ShipmentHeader::getReferCode)  // 将TaskDetail对象转换为ReceiptId
                    .distinct()                  // 去除重复的ReceiptId
                    .collect(Collectors.toList());// 收集到List中
            LambdaQueryWrapper<ReservationSubmission> reservationSubmissionLambdaQueryWrapper1 = Wrappers.lambdaQuery();
            reservationSubmissionLambdaQueryWrapper1.in(ReservationSubmission::getOrderNumber, ReferCodes);
            reservationSubmissions = reservationSubmissionService.list(reservationSubmissionLambdaQueryWrapper1);
            if (reservationSubmissions.isEmpty()) {
                throw new ServiceException("数据缺失 请尝试深度查询");
            }
            for (ShipmentHeader shipmentHeader : shipmentHeaderList) {
                List<ReservationSubmission> submissions = reservationSubmissions.stream().filter(r -> r.getOrderNumber().equals(shipmentHeader.getReferCode())).collect(Collectors.toList());
                LogisticsDom logisticsDom = getLogisticsDom(shipmentHeader, submissions);
                logisticsDomList.add(logisticsDom);
            }
            Map<String, LogisticsDom> logisticsDomMap = Stream.concat(
                            logisticsDoms.stream().filter(Objects::nonNull), // 过滤掉 null 元素
                            logisticsDomList.stream().filter(Objects::nonNull) // 过滤掉 null 元素
                    )
                    .collect(Collectors.toMap(
                            LogisticsDom::getInvoiceNumber, // 使用 invoiceNumber 作为 Map 的 key
                            logisticsDom -> logisticsDom,  // 使用 LogisticsDom 对象作为 Map 的 value
                            (existing, replacement) -> existing // 在 key 冲突时保留已有的对象
                    ));

            List<LogisticsDom> combinedList = new ArrayList<>(logisticsDomMap.values());
            for (LogisticsDom logisticsDom : combinedList) {
                if (logisticsDom != null) {
                    logisticsDom.setShipmentType("发货通知单");
                }
            }
            return combinedList;
        }


        for (ShipmentHeader shipmentHeader : shipmentHeaders) {
            List<ReservationSubmission> submissions = reservationSubmissions.stream().filter(r -> r.getOrderNumber().equals(shipmentHeader.getReferCode())).collect(Collectors.toList());
            LogisticsDom logisticsDom = getLogisticsDom(shipmentHeader, submissions);
            logisticsDomList.add(logisticsDom);
        }
        Map<String, LogisticsDom> logisticsDomMap = Stream.concat(
                        logisticsDoms.stream().filter(Objects::nonNull), // 过滤掉 null 元素
                        logisticsDomList.stream().filter(Objects::nonNull) // 过滤掉 null 元素
                )
                .collect(Collectors.toMap(
                        LogisticsDom::getInvoiceNumber, // 使用 invoiceNumber 作为 Map 的 key
                        logisticsDom -> logisticsDom,  // 使用 LogisticsDom 对象作为 Map 的 value
                        (existing, replacement) -> existing // 在 key 冲突时保留已有的对象
                ));

        List<LogisticsDom> combinedList = new ArrayList<>(logisticsDomMap.values());

        for (LogisticsDom logisticsDom : combinedList) {
            if (logisticsDom != null) {
                logisticsDom.setShipmentType("发货通知单");
            }
        }
        return combinedList;
    }






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


        LambdaQueryWrapper<Container> containerLambdaQueryWrapper = Wrappers.lambdaQuery();
        containerLambdaQueryWrapper.eq(Container::getCode, lsContainer);
        Container container = containerService.getOne(containerLambdaQueryWrapper);


        ShipmentCheck check = new ShipmentCheck();
        check.setContainerCode(lsContainer);

        if (location == null&&container==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 = chooseWrapperService.inventoryHistoryDetailServiceList(inventoryDetailLambdaQueryWrapper);
            check.setLocationCode(header.getLocationCode());
            check.setShipmentHeader(shipmentHeader);
            check.setQty(inventoryDetailList.stream().map(InventoryHistoryDetail::getQty).reduce(BigDecimal.ZERO, BigDecimal::add).intValue());
        } else{

            TaskHeader taskHeader=new TaskHeader();
            if (location==null)
            {
                LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
                taskHeaderLambdaQueryWrapper.eq(TaskHeader::getContainerCode, lsContainer).ne(TaskHeader::getPortGroup,"P30");
                taskHeader=taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
            }
            String shipmentCode="";
            // 还未释放，从库存表查
            if (location==null)
            {
                shipmentCode=taskHeader.getShipmentCode();
            }else
            {
                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(container.getLocationCode());
            check.setShipmentHeader(shipmentHeader);
            check.setQty(inventoryDetailList.stream().map(InventoryDetail::getQty).reduce(BigDecimal.ZERO, BigDecimal::add).intValue());
        }

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








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

        if (StringUtils.isNotEmpty(containerCode))
        {
            Container containerByCode = containerService.getContainerByCode(containerCode);

            if (containerByCode.getLocationCode().isEmpty())
            {
                return  AjaxResult.error("无库位绑定信息 请检查");
            }
        }


        //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 = chooseWrapper.receiptContainerDetailService(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
    public List PDALoading(String locationCode, String containerCode, String shipmentHeaderCode, String referCode, String operator, String history) {
        if (StringUtils.isNotEmpty(history)&&history.equals("盘点"))
        {
            LambdaQueryWrapper<InventoryConfirmed> inventoryConfirmedLambdaQueryWrapper = Wrappers.lambdaQuery();
            inventoryConfirmedLambdaQueryWrapper.eq(StringUtils.isNotEmpty(locationCode), InventoryConfirmed::getLocationCode, locationCode)
                    .eq(StringUtils.isNotEmpty(containerCode), InventoryConfirmed::getContainerCode, containerCode)
                    .eq(StringUtils.isNotEmpty(shipmentHeaderCode), InventoryConfirmed::getShipmentHeaderCode, shipmentHeaderCode)
                    .eq(StringUtils.isNotEmpty(referCode), InventoryConfirmed::getReferCode, referCode)
                    .eq(StringUtils.isNotEmpty(operator), InventoryConfirmed::getOperator, operator)
                    .orderByDesc(InventoryConfirmed::getOperatingTime);
            return inventoryConfirmedService.list(inventoryConfirmedLambdaQueryWrapper);
        }else {
            LambdaQueryWrapper<loadingConfirmed> loadingConfirmedLambdaQueryWrapper = Wrappers.lambdaQuery();
            loadingConfirmedLambdaQueryWrapper.eq(StringUtils.isNotEmpty(locationCode), loadingConfirmed::getLocationCode, locationCode)
                    .eq(StringUtils.isNotEmpty(containerCode), loadingConfirmed::getContainerCode, containerCode)
                    .eq(StringUtils.isNotEmpty(shipmentHeaderCode), loadingConfirmed::getShipmentHeaderCode, shipmentHeaderCode)
                    .eq(StringUtils.isNotEmpty(referCode), loadingConfirmed::getReferCode, referCode)
                    .eq(StringUtils.isNotEmpty(operator), loadingConfirmed::getOperator, operator)
                    .orderByDesc(loadingConfirmed::getOperatingTime);
            return loadingConfirmedService.list(loadingConfirmedLambdaQueryWrapper);
        }
    }

    @Override
    public AjaxResult Stocktaking(String lsContainer, String boxCode, String shipmentCode1, String operator) {
        if (StringUtils.isEmpty(lsContainer)) {
            return AjaxResult.error("请扫标签码");
        }
        if (StringUtils.isEmpty(shipmentCode1)) {
            return AjaxResult.error("请传出库单号");
        }
        LambdaQueryWrapper<Location> locationQuery = Wrappers.lambdaQuery();
        locationQuery.eq(Location::getContainerCode, lsContainer)
                .eq(Location::getShipmentCode,shipmentCode1);
        Location location = locationService.getOne(locationQuery);


        LambdaQueryWrapper<Container> containerLambdaQueryWrapper = Wrappers.lambdaQuery();
        containerLambdaQueryWrapper.eq(Container::getCode, lsContainer);
        Container container = containerService.getOne(containerLambdaQueryWrapper);


        ShipmentCheck check = new ShipmentCheck();
        check.setContainerCode(lsContainer);

        String code="";

        if (location == null&&container==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);
            code=shipmentHeader.getCode();
            LambdaQueryWrapper<InventoryHistoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            inventoryDetailLambdaQueryWrapper.eq(InventoryHistoryDetail::getContainerCode, lsContainer);
            List<InventoryHistoryDetail> inventoryDetailList = chooseWrapperService.inventoryHistoryDetailServiceList(inventoryDetailLambdaQueryWrapper);
            check.setLocationCode(header.getLocationCode());
            check.setShipmentHeader(shipmentHeader);
            check.setQty(inventoryDetailList.stream().map(InventoryHistoryDetail::getQty).reduce(BigDecimal.ZERO, BigDecimal::add).intValue());
        } else{
            TaskHeader taskHeader=new TaskHeader();
            if (location==null)
            {
                LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
                taskHeaderLambdaQueryWrapper.eq(TaskHeader::getContainerCode, lsContainer).ne(TaskHeader::getPortGroup,"P30");
                taskHeader=taskHeaderService.getOne(taskHeaderLambdaQueryWrapper);
            }
            String shipmentCode="";

            if (taskHeader==null&&location==null)
            {
                //查询库存明细表，拿到入库单号
                LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
                inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getContainerCode,container.getCode())
                        .eq(InventoryDetail::getLocationCode,container.getLocationCode()).last(" limit 1");
                InventoryDetail inventoryDetail = inventoryDetailService.getOne(inventoryDetailLambdaQueryWrapper);

                //查询入库单号 里面拿到关联的出库单
                LambdaQueryWrapper<ReceiptHeader> receiptHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
                receiptHeaderLambdaQueryWrapper.eq(ReceiptHeader::getCode,inventoryDetail.getReceiptCode());

                ReceiptHeader receiptHeader = receiptHeaderService.getOne(receiptHeaderLambdaQueryWrapper);
                if (receiptHeader==null)
                {
                    throw new ServiceException("查询关联出库单失败");
                }
                shipmentCode=receiptHeader.getShipmentCode();

            }else if (location==null)
            {
                shipmentCode=taskHeader.getShipmentCode();
            }else
            {
                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(container.getLocationCode());
            check.setShipmentHeader(shipmentHeader);
            check.setQty(inventoryDetailList.stream().map(InventoryDetail::getQty).reduce(BigDecimal.ZERO, BigDecimal::add).intValue());
            code=shipmentHeader.getCode();
        }

        AjaxResult ajaxResult=AjaxResult.success();

        LambdaQueryWrapper<ShipmentHeader> shipHeaderQuery1 = Wrappers.lambdaQuery();
        shipHeaderQuery1.eq(ShipmentHeader::getCode, shipmentCode1);

        ShipmentHeader targetShipmentHeader = shipmentHeaderService.getOne(shipHeaderQuery1);

        if (!code.equals(shipmentCode1))
        {
            check.setState(400);
            // 如果不匹配，将扫码得到的单号存到msg中
            ajaxResult.setMsg(check.getShipmentHeader().getReferCode() + "," + check.getShipmentHeader().getCode());
        }else
        {
            check.setState(200);
            ajaxResult.setMsg("匹配成功");
        }

        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getContainerCode,lsContainer)
                .eq(InventoryDetail::getBoxCode,boxCode);
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);
        if (inventoryDetails.isEmpty())
        {
            check.setState(400);
            ajaxResult.setMsg(check.getShipmentHeader().getReferCode() + "," + check.getShipmentHeader().getCode()+","+boxCode);
        }


        InventoryConfirmed inventoryConfirmed=new InventoryConfirmed();
        inventoryConfirmed.setMsg(ajaxResult.getMsg());
        inventoryConfirmed.setState(check.getState());
        inventoryConfirmed.setLocationCode(check.getLocationCode());
        inventoryConfirmed.setContainerCode(check.getContainerCode());
        inventoryConfirmed.setShipmentHeaderCode(shipmentCode1);
        inventoryConfirmed.setReferCode(targetShipmentHeader.getReferCode());
        inventoryConfirmed.setShipmentHeaderId(targetShipmentHeader.getId());
        inventoryConfirmed.setOperator(operator);
        inventoryConfirmed.setOperatingTime(new Date());
        inventoryConfirmed.setQty(check.getQty());
        if (!inventoryConfirmedService.save(inventoryConfirmed))
        {
            throw new ServiceException("保存历史记录失败");
        }
        return ajaxResult.setData(check);
    }

    @Override
    @Transactional
    public AjaxResult PingKuFit(String boxCode, String containerCode) {
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = new LambdaQueryWrapper<>();
        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getBoxCode, boxCode)
                .in(InventoryDetail::getZoneCode, QuantityConstant.ZONE_PINGKU,QuantityConstant.ZONE_STOCK_UP);
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);

        if (inventoryDetails.isEmpty()) {
            return AjaxResult.error("没有这个库存明细，请检查");
        }
        List<InventoryDetail> inventoryDetailDelete=new ArrayList<>();
        for (InventoryDetail inventoryDetail:inventoryDetails)
        {
            if (inventoryDetail.getContainerCode().equals(containerCode)) {
                inventoryDetailDelete.add(inventoryDetail);
            }
        }
        if (inventoryDetailDelete.size()==inventoryDetails.size())
        {
            return AjaxResult.error("所有箱码片码都属于同一个订单，无需再合盘请检查");
        }

        inventoryDetails.removeAll(inventoryDetailDelete);
        // 使用 Stream API 来遍历 inventoryDetails 列表，并提取 InventoryHeaderId 字段，并去重
        List<Integer> uniqueInventoryHeaderIds = inventoryDetails.stream()
                .map(InventoryDetail::getInventoryHeaderId) // 提取 InventoryHeaderId 字段
                .distinct() // 去重
                .collect(Collectors.toList()); // 将结果收集到列表中


        LambdaQueryWrapper<InventoryHeader> inventoryHeaderLambdaQueryWrapper = new LambdaQueryWrapper<>();
        inventoryHeaderLambdaQueryWrapper.in(InventoryHeader::getId,uniqueInventoryHeaderIds);
        // 这个是原箱码所在的库存主表
        List<InventoryHeader> inventoryHeaders = inventoryHeaderService.list(inventoryHeaderLambdaQueryWrapper);
        if (inventoryHeaders.isEmpty()) {
            return AjaxResult.error("不存在原箱码数据，请检查数据，看看是不是扫错了或者前端给的码不对");
        }
        LambdaQueryWrapper<ProPackaging> proPackagingLambdaQueryWrapper = Wrappers.lambdaQuery();
        proPackagingLambdaQueryWrapper.eq(ProPackaging::getNumber, inventoryDetails.get(0).getProPackaging());
        ProPackaging proPackaging = proPackagingService.getOne(proPackagingLambdaQueryWrapper);
        int pieceBox = proPackaging.getPieceBox();

        LambdaQueryWrapper<InventoryHeader> inventoryHeaderLambdaQueryWrapper1 = new LambdaQueryWrapper<>();
        inventoryHeaderLambdaQueryWrapper1.eq(InventoryHeader::getContainerCode, containerCode)
                .in(InventoryHeader::getZoneCode, QuantityConstant.ZONE_PINGKU,QuantityConstant.ZONE_STOCK_UP);

        // 这个是要补充进去的库存
        InventoryHeader inventoryHeader1 = inventoryHeaderService.getOne(inventoryHeaderLambdaQueryWrapper1);

        if (inventoryHeader1 == null) {
            return AjaxResult.error("不存待补充托盘数据，请检查数据，看看是不是扫错了或者前端给的码不对");
        }
        Location location2 = locationService.getLocationByCode(inventoryHeader1.getLocationCode());

        List<InventoryHeader> inventoryHeaderAll =new ArrayList<>();
        for (InventoryHeader inventoryHeader:inventoryHeaders)
        {
            Location location1 = locationService.getLocationByCode(inventoryHeader.getLocationCode());
            if (!location1.getShipmentCode().equals(location2.getShipmentCode()))
            {
                //不是同一个订单的不能合盘
                inventoryHeaderAll.add(inventoryHeader);
            }
        }

        if (inventoryHeaderAll.size()==inventoryHeaders.size())
        {
            return AjaxResult.error("不是同一个订单的不能合盘");
        }

        inventoryHeaders.removeAll(inventoryHeaderAll);

        // 使用 Stream API 来遍历 inventoryDetails 列表，并提取 InventoryHeaderId 字段，并去重
        List<Integer> InventoryHeaderIds = inventoryHeaders.stream()
                .map(InventoryHeader::getId) // 提取 InventoryHeaderId 字段
                .distinct() // 去重
                .collect(Collectors.toList()); // 将结果收集到列表中


        // 使用 Stream API 来遍历 inventoryDetails 列表，并提取 InventoryHeaderId 字段，并去重
        List<Integer> inventoryHeaderIds = inventoryDetails.stream()
                .map(InventoryDetail::getInventoryHeaderId) // 提取 InventoryHeaderId 字段
                .distinct() // 去重
                .collect(Collectors.toList()); // 将结果收集到列表中


        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper1 = new LambdaQueryWrapper<>();
        inventoryDetailLambdaQueryWrapper1.in(InventoryDetail::getInventoryHeaderId, inventoryHeaderIds);
        inventoryDetails=inventoryDetailService.list(inventoryDetailLambdaQueryWrapper1);

        for (InventoryDetail inventoryDetail : inventoryDetails) {
            // 检查 InventoryHeaderIds 是否包含当前 inventoryDetail 的 inventoryHeaderId
            if (InventoryHeaderIds.contains(inventoryDetail.getInventoryHeaderId())) {
                inventoryDetail.setContainerCode(containerCode);
                inventoryDetail.setLocationCode(inventoryHeader1.getLocationCode());
                inventoryDetail.setInventoryHeaderId(inventoryHeader1.getId());
                inventoryDetailService.updateById(inventoryDetail);
            }
        }

        inventoryHeader1.setTotalQty(inventoryHeader1.getTotalQty().add(BigDecimal.valueOf(inventoryDetails.size())));
        inventoryHeader1.setBoxQty(inventoryHeader1.getTotalQty().divide(BigDecimal.valueOf(pieceBox)));
        inventoryHeaderService.updateById(inventoryHeader1);

        for (InventoryHeader inventoryHeader:inventoryHeaders)
        {
            LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQuery = new LambdaQueryWrapper<>();
            inventoryDetailLambdaQuery.eq(InventoryDetail::getInventoryHeaderId, inventoryHeader.getId())
                    .in(InventoryDetail::getZoneCode, QuantityConstant.ZONE_PINGKU,QuantityConstant.ZONE_STOCK_UP).ne(InventoryDetail::getStatus, QuantityConstant.STATUS_LOCATION_LOCK);
            List<InventoryDetail> inventoryDetails1 = inventoryDetailService.list(inventoryDetailLambdaQuery);
            // 更新 inventoryHeader 的总数量
            inventoryHeader.setTotalQty(BigDecimal.valueOf(inventoryDetails1.size()));
            inventoryHeader.setBoxQty(inventoryHeader.getTotalQty().divide(BigDecimal.valueOf(pieceBox)));
            inventoryHeaderService.updateById(inventoryHeader);

            if (inventoryDetails1.isEmpty()) {

                Container container = containerService.getContainerByCode(inventoryHeader.getContainerCode());
                if (container!=null)
                {
                    if (container.getCode().contains("LS")){
                        containerService.removeById(container.getId());
                    }
                    else
                    {
                        containerService.updateLocationCodeAndStatus(containerCode, "", QuantityConstant.STATUS_CONTAINER_EMPTY);
                    }
                }
                if (!inventoryHeaderService.removeById(inventoryHeader.getId()))
                {
                    throw new ServiceException("删除原单据失败");
                }
                Location location1 = locationService.getLocationByCode(inventoryHeader.getLocationCode());
                LambdaQueryWrapper<InventoryHeader> inventoryHeaderLambdaQueryWrapper2 = new LambdaQueryWrapper<>();
                inventoryHeaderLambdaQueryWrapper2.eq(InventoryHeader::getLocationCode,location1.getCode());
                List<InventoryHeader> inventoryHeaders1 = inventoryHeaderService.list(inventoryHeaderLambdaQueryWrapper2);
                if (inventoryHeaders1.isEmpty())
                {
                    if (location1.getCode().contains("LS")){
                        locationService.removeById(location1.getId());
                    }
                    else
                    {
                        locationService.updateContainerCodeAndStatus(location1.getCode(), "",
                                QuantityConstant.STATUS_LOCATION_EMPTY);
                    }
                }


            }
        }
        return AjaxResult.success("转移成功");
    }

    @Override
    public AjaxResult dataReview(String boxCode, String containerCode) {
        //首先这个任务要不是完成状态，完成就得报错 查询任务表
        LambdaQueryWrapper<TaskDetail> taskDetailLambdaQueryWrapper = new LambdaQueryWrapper<>();
        taskDetailLambdaQueryWrapper.eq(TaskDetail::getContainerCode,containerCode)
                .eq(TaskDetail::getTaskType,QuantityConstant.TASK_TYPE_WHOLERECEIPT)
                .lt(TaskDetail::getStatus,QuantityConstant.TASK_STATUS_COMPLETED)
                .eq(TaskDetail::getBoxCode,boxCode).last(" limit 1");
        TaskDetail taskDetail = taskDetailService.getOne(taskDetailLambdaQueryWrapper);
        if (taskDetail==null)
        {
            return AjaxResult.error("复核失败 不允许通过，请检查标签是否与砖块内容一致");
        }


        return AjaxResult.success("复核通过");
    }

    private static LogisticsDom getLogisticsDom(ShipmentHeader shipmentHeader, List<ReservationSubmission> submissions) {
        LogisticsDom logisticsDom = new LogisticsDom();
        logisticsDom.setCustomerCode(shipmentHeader.getCustomerCode());

        logisticsDom.setShipmentType(shipmentHeader.getShipmentType());
        logisticsDom.setCustomerName(shipmentHeader.getCustomerName());
        logisticsDom.setInvoiceNumber(shipmentHeader.getReferCode());
        if (!submissions.isEmpty()) {
            logisticsDom.setConfirmedArrivalTime(submissions.get(0).getAppointmentTime());
            String driverInformation =shipmentHeader.getDriverName() + "/" +submissions.get(0).getCarNumber() + "/" + submissions.get(0).getDriverName() + "/" + submissions.get(0).getIdentityCard() + "/" + submissions.get(0).getPhoneNumber();
            logisticsDom.setDriverInformation(driverInformation);
        }

        logisticsDom.setShipmentNote(shipmentHeader.getShipmentNote());
        return logisticsDom;
    }
}