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.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.huaheng.api.erp.domain.BoxInfo;
import com.huaheng.api.erp.domain.ChipInfos;
import com.huaheng.api.erp.domain.ShipmentRecord;
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.utils.DateUtils;
import com.huaheng.common.utils.http.OkHttpUtils;
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.InventoryHistoryDetail.domain.InventoryHistoryDetail;
import com.huaheng.pc.inventory.InventoryHistoryDetail.service.IInventoryHistoryDetailService;
import com.huaheng.pc.inventory.cycleCountDetail.domain.CycleCountDetail;
import com.huaheng.pc.inventory.cycleCountDetail.domain.CycleCountDetailChild;
import com.huaheng.pc.inventory.cycleCountDetail.service.CycleCountDetailChildService;
import com.huaheng.pc.inventory.cycleCountDetail.service.CycleCountDetailService;
import com.huaheng.pc.inventory.inventoryCacheDetail.domain.InventoryCacheDetail;
import com.huaheng.pc.inventory.inventoryCacheDetail.service.InventoryCacheDetailService;
import com.huaheng.pc.inventory.inventoryDetail.domain.InventoryDetail;
import com.huaheng.pc.inventory.inventoryDetail.service.InventoryDetailService;
import com.huaheng.pc.inventory.inventoryHeader.domain.InventoryHeader;
import com.huaheng.pc.inventory.inventoryHeader.service.InventoryHeaderService;
import com.huaheng.pc.inventory.inventoryHistoryHeader.domain.InventoryHistoryHeader;
import com.huaheng.pc.inventory.inventoryHistoryHeader.service.IInventoryHistoryHeaderService;
import com.huaheng.pc.receipt.receiptContainerDetail.domain.ReceiptContainerDetail;
import com.huaheng.pc.receipt.receiptContainerDetail.service.ReceiptContainerDetailService;
import com.huaheng.pc.receipt.receiptContainerHeader.domain.ReceiptContainerHeader;
import com.huaheng.pc.receipt.receiptContainerHeader.service.ReceiptContainerHeaderService;
import com.huaheng.pc.receipt.receiptDetail.domain.ReceiptDetail;
import com.huaheng.pc.receipt.receiptDetail.service.ReceiptDetailService;
import com.huaheng.pc.receipt.receiptHeader.domain.ReceiptHeader;
import com.huaheng.pc.receipt.receiptHeader.service.ReceiptHeaderService;
import com.huaheng.pc.shipment.shipmentContainerHeader.service.ShipmentContainerHeaderService;
import com.huaheng.pc.shipment.shipmentDetail.domain.ShipmentDetail;
import com.huaheng.pc.shipment.shipmentDetail.service.ShipmentDetailService;
import com.huaheng.pc.shipment.shipmentHeader.domain.ShipmentHeader;
import com.huaheng.pc.shipment.shipmentHeader.service.ShipmentHeaderService;
import com.huaheng.pc.task.agvTask.domain.AgvTask;
import com.huaheng.pc.task.agvTask.service.AgvTaskService;
import com.huaheng.pc.task.taskDetail.domain.TaskDetail;
import com.huaheng.pc.task.taskDetail.service.TaskDetailService;
import com.huaheng.pc.task.taskHeader.domain.TaskHeader;
import com.huaheng.pc.task.taskHeader.service.ReceiptTaskService;
import com.huaheng.pc.task.taskHeader.service.TaskHeaderService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

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

    @Resource
    private IInventoryHistoryDetailService inventoryHistoryDetailService;
    @Resource
    private IInventoryHistoryHeaderService inventoryHistoryHeaderService;
    @Resource
    private CycleCountDetailChildService cycleCountDetailChildService;
    @Resource
    private ShipmentDetailService shipmentDetailService;
    @Resource
    private ContainerService containerService;
    @Resource
    private ContainerTypeService containerTypeService;
    @Resource
    private ReceiptContainerHeaderService receiptContainerHeaderService;
    @Resource
    private ReceiptHeaderService receiptHeaderService;
    @Resource
    private PDAServiceImpl pdaService;
    @Resource
    private MaterialService materialService;
    @Resource
    private ShipmentHeaderService shipmentHeaderService;
    @Resource
    private AddressService addressService;
    @Resource
    private IProPackagingService proPackagingService;
    @Resource
    private ReceiptDetailService receiptDetailService;
    @Resource
    private ReceiptContainerDetailService receiptContainerDetailService;
    @Resource
    private ReceiptTaskService receiptTaskService;
    @Resource
    private AgvTaskService agvTaskService;
    @Resource
    private LocationService locationService;
    @Resource
    private WcsService wcsService;
    @Resource
    private ShipmentContainerHeaderService shipmentContainerHeaderService;
    @Resource
    private IBosAssistantDetailService bosAssistantDetailService;
    @Resource
    private InventoryDetailService inventoryDetailService;
    @Resource
    private IProPackagingService proPackingService;
    @Resource
    private CycleCountDetailService cycleCountDetailService;
    @Resource
    private InventoryCacheDetailService inventoryCacheDetailService;
    @Resource
    private TaskHeaderService taskHeaderService;
    @Resource
    private TaskDetailService taskDetailService;
    @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);
            receiptHeader = receiptHeaderService.getOne(receiptHeaderLambdaQueryWrapper);
            if (receiptHeader == null) {
                receiptHeader = new ReceiptHeader();
                receiptHeader.setCode(receiptCode);
                receiptHeader.setOrderCode(orderCode);
                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());
            if (det.getMaterialCode().equals(materialCode1)) {
                detail = det;
            }
        }

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

        if (detail == null && details.size() != 0) {
            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(detail.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;
        // 先获取起始库位，获取不到就放到缓存区
        if (qc == 0) {
            AjaxResult ajaxResult = wcsService.getFromPort();
            if (ajaxResult.hasErr()) {
                throw new ServiceException("获取站台点失败");
            }
            JSONArray array = (JSONArray)ajaxResult.getData();

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

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

                LambdaQueryWrapper<AgvTask> agvTaskLambdaQueryWrapper = Wrappers.lambdaQuery();
                agvTaskLambdaQueryWrapper.eq(AgvTask::getToPort, port).ne(AgvTask::getStatus, QuantityConstant.TASK_STATUS_COMPLETED);
                List<AgvTask> list = agvTaskService.list(agvTaskLambdaQueryWrapper);

                toLocationCode = toPort;
                if (list.size() > 0) {
                    toLocationCode = getCacheLocation();
                } else {
                    break;
                }
            }

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

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

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

//        if (details.size()>1&&sum.add(totalQty).compareTo(detail.getQty())==1)
//        {
//            throw new ServiceException("已收数量不能大于单据总数量");
//        }

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

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

        if (qc == 1) {
            receiptContainerHeader1.setExceptionCode("需要质检");
            receiptContainerHeaderService.updateById(receiptContainerHeader1);
            toLocationCode = getCacheLocation();
        } else {
            if (toLocationCode.equals(QuantityConstant.PORT_P1001) || toLocationCode.equals(QuantityConstant.PORT_P1005)) {
                AjaxResult ajaxResult = receiptTaskService.createReceiptTask(id, warehouseCode);
                if (ajaxResult.hasErr()) {
                    throw new ServiceException("生成任务失败" + ajaxResult.getMsg());
                }
                int taskId = (int)ajaxResult.getData();
                TaskHeader taskHeader = taskHeaderService.getById(taskId);
                taskHeader.setUserDef1(operatorName);
                taskHeader.setUserDef2(quantityorName);
                taskHeaderService.updateById(taskHeader);
            }
        }
        if (StringUtils.isEmpty(toLocationCode)) {
            throw new ServiceException("没有找到入库缓存区空闲库位");
        }
        AjaxResult taskFromTo = agvTaskService.sendTaskFromTo(warehouseCode, QuantityConstant.ZONE_LK, containerCode, position, toLocationCode,
            QuantityConstant.PLATFORM_CODING, totalQty.intValue());
        if (taskFromTo.hasErr()) {
            throw new ServiceException("生成agv任务失败" + taskFromTo.getMsg());
        }

        return AjaxResult.success("保存入库组盘信息成功");
    }

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

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

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

    }

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

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

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

        Collections.reverse(inventoryHistorysDetailList);

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

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

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

    /*
     * 从A库
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult requestEmptyContainer(String requestInCode) {
        List<Integer> rows = new ArrayList<>();
        rows.add(1);
        rows.add(2);
        rows.add(3);
        LambdaQueryWrapper<Location> locationLambdaQueryWrapper = Wrappers.lambdaQuery();
        locationLambdaQueryWrapper.eq(Location::getZoneCode, QuantityConstant.ZONE_RECEIPT_MANY_CONTAINER).eq(Location::getStatus,
            QuantityConstant.STATUS_LOCATION_LOCK);
        List<Location> locationList = locationService.list(locationLambdaQueryWrapper);
        if (locationList.size() > 0) {
            List<Integer> rowList = locationList.stream().map(Location::getIRow).collect(Collectors.toList());
            for (Integer row : rowList) {
                rows.remove(row);
            }
        }
        if (rows.size() == 0) {
            return AjaxResult.error("每一行都有AGV任务，暂时没有可用库位, 清过段时间重试");
        }
        locationLambdaQueryWrapper = Wrappers.lambdaQuery();
        locationLambdaQueryWrapper.eq(Location::getZoneCode, QuantityConstant.ZONE_RECEIPT_MANY_CONTAINER)
            .eq(Location::getStatus, QuantityConstant.STATUS_LOCATION_EMPTY).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 (locationList.size() > 0) {
            throw new ServiceException("齐工要求 同时只能有一个agv任务 当前入库缓存区库位有锁定情况 无法生成新的任务");
        }
        if (rows.size() == 0) {
            rows = new ArrayList<>();
            rows.add(1);
            rows.add(2);
            rows.add(3);
        }

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

        // 改写先全取 在本地处理数据 一共18*3个库位 本地处理多个循环也不至于很卡
        locationLambdaQueryWrapper = Wrappers.lambdaQuery();
        locationLambdaQueryWrapper.eq(Location::getZoneCode, QuantityConstant.ZONE_RECEIPT_CACHE).in(Location::getIRow, rows).orderByAsc(Location::getIRow)
            .orderByAsc(Location::getIColumn);

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

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

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

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

        String LocationCode = null;

        // 第一层遍历是行
        for (List<Location> location : locationIRowList) {
            // 第二次遍历是每一行的值 这里用int i可以更好的利用位置取值
            for (int i = 0; i < location.size(); i++) {
                // 查出非空闲或者有容器 如果当前列查了有就在这i的前一个给出去
                if (!location.get(i).getStatus().equals(QuantityConstant.STATUS_CONTAINER_EMPTY) || StringUtils.isNotEmpty(location.get(i).getContainerCode())) {
                    // 如果是第一个就放弃这一行 比如B010101库位前是空的不存在了 这里用行跟来判断
                    if (location.get(i).getIColumn() == 1) {
                        // 当前行的遍历关闭 会到第一层遍历去重新到第二行
                        break;
                    }

                    // 如果不是当前行的第一个库位，就往前取一个，就是i-1，给变量赋值出去 直接退出当前遍历到第一层遍历
                    LocationCode = location.get(i - 1).getCode();
                    break;
                } else {
                    // 如果这一行全不是有货或者锁定的 直接把最后一个当库位返回
                    if (i == location.size() - 1) {
                        LocationCode = location.get(i).getCode();
                        break;
                    }
                }
            }
            // 如果在第二层里面给了库位了 就不需要再继续执行直接关闭当第一层遍历
            if (LocationCode != null) {
                break;
            }
        }

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

    // 1.首先清掉库存、库存缓存、组盘信息
    // 2.如果尾盘还没有推送托盘信息，并且尾盘数量有多,那么尾盘多取一个
    // 3.如果尾盘数量不够，生成内部出库单出库。
    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult brickFalling(String boxCode, String containerCode) {
        String materialCode = null;
        String materialName = null;
        String materialSpec = null;
        String level = null;
        String color = null;
        String proPackaging = null;
        String productSchedule = null;
        String batch = null;
        int size = 0;
        // 查询库存里面还有没有这个值
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getContainerCode, containerCode).eq(InventoryDetail::getBoxCode, boxCode);
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);
        if (inventoryDetails.size() > 0) {
            materialCode = inventoryDetails.get(0).getMaterialCode();
            level = inventoryDetails.get(0).getLevel();
            color = inventoryDetails.get(0).getColor();
            proPackaging = inventoryDetails.get(0).getProPackaging();
            productSchedule = inventoryDetails.get(0).getProductSchedule();
            batch = inventoryDetails.get(0).getBatch();
            materialName = inventoryDetails.get(0).getMaterialName();
            materialSpec = inventoryDetails.get(0).getMaterialSpec();
            List<Integer> inventoryIds = inventoryDetails.stream().map(InventoryDetail::getId).collect(Collectors.toList());
            if (inventoryIds.size() > 0) {
                boolean result = inventoryDetailService.removeByIds(inventoryIds);
                if (!result) {
                    throw new ServiceException("删除库存详情");
                }
            }
        }

        // 查询库存扣减表有没有这个值
        LambdaQueryWrapper<InventoryCacheDetail> inventoryCacheDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryCacheDetailLambdaQueryWrapper.eq(InventoryCacheDetail::getBoxCode, boxCode).eq(InventoryCacheDetail::getContainerCode, containerCode);
        List<InventoryCacheDetail> inventoryCacheDetails = inventoryCacheDetailService.list(inventoryCacheDetailLambdaQueryWrapper);
        // 如果有就删除
        if (inventoryCacheDetails.size() > 0) {
            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);
        List<ReceiptContainerDetail> receiptContainerDetails = receiptContainerDetailService.list(receiptContainerDetailLambdaQueryWrapper);

        boolean isZt = false;
        // 如果有就删除
        if (receiptContainerDetails.size() > 0) {

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

        boolean isPushCoding = false;
        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("任务不存在");
        }
        taskHeader.setBack(0);
        taskHeaderService.updateById(taskHeader);
        if (taskHeader != null) {
            long shipmentOrder = taskHeader.getShipmentOrder();
            int sequenceNumber = taskHeader.getSequenceNumber();
            LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper1 = Wrappers.lambdaQuery();
            taskHeaderLambdaQueryWrapper1.eq(TaskHeader::getShipmentOrder, shipmentOrder).eq(TaskHeader::getSequence, sequenceNumber).eq(TaskHeader::getMaterialCode,
                materialCode);
            TaskHeader taskHeader1 = taskHeaderService.getOne(taskHeaderLambdaQueryWrapper1);

            // 查出明细表包含主表id的所有
            LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper1 = Wrappers.lambdaQuery();
            inventoryDetailLambdaQueryWrapper1.eq(InventoryDetail::getContainerCode, taskHeader1.getContainerCode()).eq(InventoryDetail::getMaterialCode,
                taskHeader1.getMaterialCode());
            List<InventoryDetail> inventoryDetailList = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper1);

            String finalLevel = level;
            String finalMaterialCode = materialCode;
            String finalColor = color;
            String finalBatch = batch;
            String finalProPackaging = proPackaging;
            List<InventoryDetail> details = inventoryDetailList.stream().filter(i -> i.getLevel().equals(finalLevel) && i.getMaterialCode().equals(finalMaterialCode)
                && i.getColor().equals(finalColor) && i.getBatch().equals(finalBatch) && i.getProPackaging().equals(finalProPackaging)).collect(Collectors.toList());

            if (details.size() < 1) {
                taskHeader1 = null;
            }

            if (taskHeader1 != null) {
                int pushCoding = taskHeader1.getPushCoding();
                LambdaQueryWrapper<InventoryHeader> inventoryHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
                inventoryHeaderLambdaQueryWrapper.eq(InventoryHeader::getContainerCode, taskHeader1.getContainerCode());
                InventoryHeader inventoryHeader = inventoryHeaderService.getOne(inventoryHeaderLambdaQueryWrapper);
                int inventoryQty = 0;
                if (inventoryHeader != null) {
                    inventoryQty = inventoryHeader.getBoxQty().intValue();
                }
                int qty = taskHeader1.getQty();
                if (isZt != true) {
                    if (pushCoding == 0) {
                        qty = qty + 1;
                        if (qty <= inventoryQty) {
                            isPushCoding = true;
                            taskHeader1.setQty(qty);
                            taskHeaderService.updateById(taskHeader1);
                        }
                    } else {
                        qty = qty + 1;
                        if (qty > inventoryQty) {
                            isPushCoding = false;
                        }
                    }
                } else {
                    isPushCoding = false;
                }
            }
        }

        LambdaQueryWrapper<ProPackaging> proPackagingLambdaQueryWrapper = Wrappers.lambdaQuery();
        proPackagingLambdaQueryWrapper.eq(ProPackaging::getNumber, proPackaging);
        ProPackaging proPackaging1 = proPackagingService.getOne(proPackagingLambdaQueryWrapper);
        int pieceBox = proPackaging1.getPieceBox();
        if (!isPushCoding) {
            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_BH);
                shipmentHeader = new ShipmentHeader();
                shipmentHeader.setCode(code);
                shipmentHeader.setWarehouseCode(QuantityConstant.DEFAULT_WAREHOUSE);
                shipmentHeader.setCompanyCode(QuantityConstant.DEFAULT_COMPANY);
                shipmentHeader.setShipmentType(QuantityConstant.SHIPMENT_TYPE_BH);
                shipmentHeader.setTotalQty(new BigDecimal(pieceBox));
                shipmentHeader.setTotalWeight(BigDecimal.ZERO);
                shipmentHeader.setTotalLines(1);
                shipmentHeader.setPriority(100);
                shipmentHeader.setFirstStatus(0);
                shipmentHeader.setLastStatus(0);
                shipmentHeader.setCreatedBy("WMS");
                shipmentHeader.setCreated(new Date());
                shipmentHeader.setLastUpdated(new Date());
                boolean result = shipmentHeaderService.save(shipmentHeader);
                if (!result) {
                    throw new ServiceException("补货通知单生成失败");
                }
            }
            if (shipmentHeader != null) {
                LambdaQueryWrapper<ShipmentDetail> shipmentDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
                shipmentDetailLambdaQueryWrapper.eq(ShipmentDetail::getShipmentCode, shipmentHeader.getCode()).eq(ShipmentDetail::getMaterialCode, materialCode)
                    .eq(ShipmentDetail::getProPackaging, proPackaging).eq(ShipmentDetail::getLevel, level).eq(ShipmentDetail::getColor, color)
                    .eq(ShipmentDetail::getProductSchedule, productSchedule);
                ShipmentDetail shipmentDetail = shipmentDetailService.getOne(shipmentDetailLambdaQueryWrapper);
                if (shipmentDetail != null) {
                    BigDecimal qty = shipmentDetail.getQty();
                    qty = qty.add(new BigDecimal(pieceBox));
                    shipmentDetail.setQty(qty);
                    shipmentDetailService.updateById(shipmentDetail);
                } else {
                    shipmentDetail = new ShipmentDetail();
                    shipmentDetail.setShipmentId(shipmentHeader.getId());
                    shipmentDetail.setWarehouseCode(QuantityConstant.DEFAULT_WAREHOUSE);
                    shipmentDetail.setCompanyCode(QuantityConstant.DEFAULT_COMPANY);
                    shipmentDetail.setShipmentCode(shipmentHeader.getCode());
                    shipmentDetail.setMaterialCode(materialCode);
                    shipmentDetail.setMaterialName(materialName);
                    shipmentDetail.setMaterialSpec(materialSpec);
                    shipmentDetail.setMaterialUnit("1001");
                    shipmentDetail.setQty(new BigDecimal(pieceBox));
                    shipmentDetail.setBatch(batch);
                    shipmentDetail.setInventorySts("good");
                    shipmentDetail.setProductSchedule(productSchedule);
                    shipmentDetail.setStatus(0);
                    shipmentDetail.setCreated(DateUtils.getNowDate());
                    shipmentDetail.setProcessStamp(0 + "");
                    shipmentDetail.setProPackaging(proPackaging);
                    shipmentDetail.setColor(color);
                    shipmentDetail.setLevel(level);
                    boolean result = shipmentDetailService.save(shipmentDetail);
                    if (!result) {
                        throw new ServiceException("补货通知单详情生成失败");
                    }
                }
            }

        } else {
            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);
            ShipmentDetail shipmentDetail = shipmentDetailService.getOne(shipmentDetailLambdaQueryWrapper);
            shipmentDetail.setTaskQty(shipmentDetail.getTaskQty().subtract(BigDecimal.valueOf(size)));
            shipmentDetailService.updateById(shipmentDetail);
        }

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

    @Override
    public AjaxResult codeSubstitution(String boxCode, String toBoxCode, String containerCode) {

        // 1.备货区替换 找查备货区库存有没有对应箱码 没有就报错
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getZoneCode, QuantityConstant.ZONE_STOCK_UP).eq(InventoryDetail::getContainerCode, containerCode)
            .eq(InventoryDetail::getBoxCode, boxCode);
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);
        if (inventoryDetails.size() < 1) {
            return AjaxResult.error("条码不存在于备货区 请到wms库存内确定下");
        }
        for (InventoryDetail inventoryDetail : inventoryDetails) {
            inventoryDetail.setBoxCode(toBoxCode);
            inventoryDetailService.updateById(inventoryDetail);
        }

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

    @Override
    public AjaxResult inventory(String boxCode, String containerCode, String 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()) {
                throw new ServiceException("盘盈请手动输入片码");
            }
            for (int i = 0; i < proPackaging.getPieceBox(); i++) {
                inventoryDetail.setId(null);
                inventoryDetail.setBoxCode(boxCode);
                inventoryDetail.setChipCode1(chipCode);
                inventoryDetail.setChipCode2("盘盈片码");
                inventoryDetailService.save(inventoryDetail);
            }
        } else {
            for (TaskDetail taskDetail : taskDetails) {
                taskDetailService.removeById(taskDetail);
            }
        }
        return AjaxResult.success("成功");
    }

    @Override
    public AjaxResult boxCodeInsert(String boxCode, String toBoxCode) {

        // 1.先在平库找到对应库存明细
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getBoxCode, boxCode).eq(InventoryDetail::getZoneCode, QuantityConstant.ZONE_STOCK_UP)
            .eq(InventoryDetail::getUserDef1, "整箱出库");
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);
        if (inventoryDetails.size() < 1) {
            return AjaxResult.error("没在平库找到您对应扫的箱码");
        }

        InventoryDetail inventoryDetail = inventoryDetails.get(0);

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

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

        for (InventoryHistoryDetail inventoryHistoryDetail : inventoryHistoryDetails) {
            inventoryDetail.setId(null);
            inventoryDetail.setBoxCode(inventoryHistoryDetail.getBoxCode());
            inventoryDetail.setChipCode1(inventoryHistoryDetail.getChipCode1());
            inventoryDetail.setMaterialName(inventoryHistoryDetail.getMaterialName());
            inventoryDetail.setMaterialCode(inventoryHistoryDetail.getMaterialCode());
            inventoryDetail.setMaterialSpec(inventoryHistoryDetail.getMaterialSpec());
            inventoryDetail.setMaterialUnit(inventoryHistoryDetail.getMaterialUnit());
            inventoryDetail.setColor(inventoryHistoryDetail.getColor());
            inventoryDetail.setLevel(inventoryHistoryDetail.getLevel());
            inventoryDetail.setBatch(inventoryHistoryDetail.getBatch());
            inventoryDetail.setInventorySts(inventoryHistoryDetail.getInventorySts());
            inventoryDetail.setProPackaging(inventoryHistoryDetail.getProPackaing());
            inventoryDetail.setProductSchedule(inventoryHistoryDetail.getProductSchedule());
            inventoryDetailService.save(inventoryDetail);
        }

        return AjaxResult.success("插入成功");
    }

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

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

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

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

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

        }

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

        // 4.去除主表id 库位 容器 状态 库区保存

        // 5.删除刚刚那个1步查出片码的 写入为第4步的主表
        inventoryDetails.removeIf(inventoryDetail1 -> inventoryDetail1.getId().equals(inventoryDetail.getId()));
        inventoryDetailService.removeById(inventoryDetail.getId());
        for (InventoryDetail inventoryDetail1 : inventoryDetails) {
            inventoryDetail1.setInventoryHeaderId(inventoryHeader.getId());
            inventoryDetail1.setLocationCode(code);
            inventoryDetail1.setContainerCode(code);
            inventoryDetailService.updateById(inventoryDetail1);
        }

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

        // 5.2查询出库单
        LambdaQueryWrapper<ShipmentDetail> shipmentDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        shipmentDetailLambdaQueryWrapper.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);

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

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

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

        int 标识9 = 0;
        for (ShipmentDetail shipment : shipmentDetailList) {
            if (shipment.getQty().compareTo(shipment.getTaskQty()) != 0) {
                标识9 = 1;
            }

        }
        if (标识9 == 0) {
            shipmentHeader.setLastStatus(QuantityConstant.SHIPMENT_HEADER_COMPLETED);
            shipmentHeader.setFirstStatus(QuantityConstant.SHIPMENT_HEADER_COMPLETED);
            shipmentHeaderService.updateById(shipmentHeader);
        }

        // 5.3查询入库单
        LambdaQueryWrapper<ReceiptHeader> receiptHeaderLambda = Wrappers.lambdaQuery();
        receiptHeaderLambda.eq(ReceiptHeader::getShipmentCode, shipmentCode).eq(ReceiptHeader::getReceiptType, QuantityConstant.RECEIPT_TYPE_DIRECT_TRANSGER);
        ReceiptHeader receiptHeader = receiptHeaderService.getOne(receiptHeaderLambda);

        ReceiptDetail receiptDetail = new ReceiptDetail();

        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()).last(" limit 1");
            receiptDetail = receiptDetailService.getOne(receiptDetailLambdaQueryWrapper);

            int 标识2 = 0;
            for (ShipmentDetail shipment : shipmentDetailList) {
                if (shipment.getQty().compareTo(shipment.getTaskQty()) != 0) {
                    标识2 = 1;
                }

            }

            if (标识2 == 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::getMaterialCode, inventoryHeader.getMaterialCode())
                .eq(ReceiptDetail::getMaterialName, inventoryHeader.getMaterialName()).eq(ReceiptDetail::getBatch, inventoryHeader.getBatch())
                .eq(ReceiptDetail::getProPackaging, inventoryHeader.getProPackaging()).eq(ReceiptDetail::getProductSchedule, inventoryHeader.getProductSchedule())
                .eq(ReceiptDetail::getLevel, inventoryHeader.getLevel()).eq(ReceiptDetail::getReceiptId, receiptHeader.getId());
            receiptDetail = receiptDetailService.getOne(receiptDetailLambdaQueryWrapper);

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

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

            int 标识1 = 0;
            for (ReceiptDetail receiptDetail2 : details) {
                if (receiptDetail2.getQty().compareTo(receiptDetail2.getTaskQty()) != 0) {
                    标识1 = 1;
                }
            }
            if (标识1 == 0) {
                if (receiptHeader.getLastStatus().intValue() < QuantityConstant.RECEIPT_HEADER_POSTING) {
                    receiptHeader.setLastStatus(QuantityConstant.RECEIPT_HEADER_POSTING);
                    receiptHeader.setFirstStatus(QuantityConstant.RECEIPT_HEADER_POSTING);
                    receiptHeaderService.updateById(receiptHeader);
                }
            }

        }

        if (receiptHeader.getLastStatus().equals(QuantityConstant.RECEIPT_HEADER_POSTING)) {
            pdaService.createSPShipment(Collections.singletonList(shipmentHeader));
        }
        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());
        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);
        inventoryHistoryDetail.setReceiptDetailId(receiptDetail.getId());
        inventoryHistoryDetail.setUserDef1("退货入库");
        inventoryHistoryDetailService.save(inventoryHistoryDetail);
        return AjaxResult.success("单片出库成功");
    }

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

        // 2.出库缓存表
        LambdaQueryWrapper<InventoryHistoryDetail> inventoryHistoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryHistoryDetailLambdaQueryWrapper.eq(InventoryHistoryDetail::getBoxCode, boxCode);
        List<InventoryHistoryDetail> inventoryHistoryDetails = inventoryHistoryDetailService.list(inventoryHistoryDetailLambdaQueryWrapper);
        if (inventoryHistoryDetails.size() > 0) {
            List<String> ChipS = inventoryHistoryDetails.stream().map(t -> t.getChipCode1()).distinct().collect(Collectors.toList());
            return AjaxResult.success(ChipS);
        }

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

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

//    @Override
//    public AjaxResult generateDoc(String boxCode, String containerCode) {
//        //出砖
//        //1.新建出库单
//
//        ShipmentHeader shipmentHeader=new ShipmentHeader();
//        shipmentHeader.setCompanyCode(QuantityConstant.DEFAULT_COMPANY);
//        shipmentHeader.setShipmentType(QuantityConstant.SHIPMENT_TYPE_BH);
//        shipmentHeader.setWarehouseCode(QuantityConstant.DEFAULT_WAREHOUSE);
//        String code = shipmentHeaderService.createCode(shipmentHeader.getShipmentType());
//        shipmentHeader.setId(null);
//        shipmentHeader.setLastUpdated(null);
//        shipmentHeader.setLastUpdatedBy("WMS");
//        shipmentHeader.setFirstStatus(0);
//        shipmentHeader.setLastStatus(0);
//        shipmentHeader.setCreated(null);
//        shipmentHeader.setCreatedBy("WMS");
//        shipmentHeader.setCode(code);
//        boolean result = shipmentHeaderService.save(shipmentHeader);
//
//        ShipmentDetail shipmentDetail=new ShipmentDetail();
//        shipmentDetail.setId(null);
//        shipmentDetail.setShipmentId(shipmentHeader.getId());
//        shipmentDetail.setWarehouseCode(QuantityConstant.DEFAULT_WAREHOUSE);
//        shipmentDetail.setCompanyCode(QuantityConstant.DEFAULT_COMPANY);
//        shipmentDetail.setShipmentCode(shipmentHeader.getCode());
//        shipmentDetail.setMaterialCode(materialCode);
//        shipmentDetail.setQty(BigDecimal.valueOf(1));
//        shipmentDetail.setBatch(batch);
//        shipmentDetail.setInventorySts(QuantityConstant.QUALITY_GOOD);
//        shipmentDetail.setProPackaging(proPackaging);
//        shipmentDetail.setProductSchedule(productSchedule);
//        shipmentDetail.setLevel(level);
//        shipmentDetail.setColor(color);
//        shipmentDetail.setMaterialSpec(materialSpec);
//        shipmentDetail.setMaterialName(materialName);
//        boolean save = shipmentDetailService.save(shipmentDetail);
//
//
//
//        int lastStatus = shipmentHeader.getLastStatus();
//        if(lastStatus == QuantityConstant.SHIPMENT_HEADER_SHIPPING) {
//            return AjaxResult.error("出库单正在出库中");
//        }
//        LambdaQueryWrapper<ShipmentDetail> shipmentDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
//        shipmentDetailLambdaQueryWrapper.eq(ShipmentDetail::getShipmentId, shipmentHeader.getId());
//        List<ShipmentDetail> shipmentDetailList = shipmentDetailService.list(shipmentDetailLambdaQueryWrapper);
//        if(shipmentDetailList.size() == 0) {
//            return AjaxResult.error("根据出库单，没有找到出库单详情");
//        }
//        AjaxResult ajaxResult = shipmentContainerHeaderService.autoShipmentCombination(shipmentDetailList);
//        if(ajaxResult.hasErr()) {
//            return ajaxResult;
//        }
//
//        List<Integer> list = (List<Integer>)ajaxResult.getData();
//        list = list.stream().distinct().collect(Collectors.toList());
//        if(list.size() == 0) {
//            return AjaxResult.error("出库单已经出库完毕");
//        }
//        long shipmentOrder = System.currentTimeMillis();
//        int sequenceNumber = list.size();
//        int sequence = 0;
//        for(int id : list) {
//            sequence++;
//            ShipmentContainerHeader shipmentContainerHeader = shipmentContainerHeaderService.getById(id);
//            if(shipmentContainerHeader == null) {
//                throw new ServiceException("没有找到出库表头:" + id);
//            }
//            shipmentContainerHeader.setPortGroup(QuantityConstant.PORTGROUP_P10);
//            shipmentContainerHeaderService.updateById(shipmentContainerHeader);
//            AjaxResult ajaxResults = shipmentTaskService.createSortingShipmentTaskFromShipmentContainer(
//                    id, shipmentOrder, sequence, sequenceNumber);
//            if (ajaxResults.hasErr()) {
//                throw new ServiceException("任务生成失败");
//            }
//            Object data = ajaxResults.getData();
//            int i = Integer.parseInt(data.toString());
//            TaskHeader taskHeader = taskHeaderService.getById(Integer.parseInt(data.toString()));
//            taskHeader.setShipmentOrder(taskHeader.getShipmentOrder()-1000000000);
//            taskHeader.setPriority(9999);
//            taskHeaderService.updateById(taskHeader);
//        }
//        shipmentHeader.setFirstStatus(QuantityConstant.SHIPMENT_HEADER_SHIPPING);
//        shipmentHeader.setLastStatus(QuantityConstant.SHIPMENT_HEADER_SHIPPING);
//        shipmentHeaderService.updateById(shipmentHeader);
//
//        return AjaxResult.success("处理成功");
//    }

}