wms / sanyizhongka · Files

package com.huaheng.api.general.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.huaheng.api.general.domain.*;
import com.huaheng.api.wcs.service.taskCancel.TaskCancelService;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.support.Convert;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.framework.web.service.ConfigService;
import com.huaheng.pc.config.address.service.AddressService;
import com.huaheng.pc.config.container.domain.Container;
import com.huaheng.pc.config.container.service.ContainerService;
import com.huaheng.pc.config.location.domain.Location;
import com.huaheng.pc.config.location.service.LocationService;
import com.huaheng.pc.config.material.domain.Material;
import com.huaheng.pc.config.material.service.MaterialService;
import com.huaheng.pc.config.station.domain.StationType;
import com.huaheng.pc.config.station.service.StationService;
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.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.shipmentContainerDetail.domain.ShipmentContainerDetail;
import com.huaheng.pc.shipment.shipmentContainerDetail.service.ShipmentContainerDetailService;
import com.huaheng.pc.shipment.shipmentContainerHeader.domain.ShipmentCombinationModel;
import com.huaheng.pc.shipment.shipmentContainerHeader.domain.ShipmentContainerHeader;
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.model.domain.VehicleDetail;
import com.huaheng.pc.system.model.domain.VehicleHeader;
import com.huaheng.pc.system.model.service.IVehicleDetailService;
import com.huaheng.pc.system.model.service.IVehicleHeaderService;
import com.huaheng.pc.task.taskHeader.domain.ShipmentTaskCreateModel;
import com.huaheng.pc.task.taskHeader.domain.TaskHeader;
import com.huaheng.pc.task.taskHeader.service.ReceiptTaskService;
import com.huaheng.pc.task.taskHeader.service.ShipmentTaskService;
import com.huaheng.pc.task.taskHeader.service.TaskHeaderService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.Transformer;
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.util.*;
import java.util.stream.Collectors;

@Service
@Slf4j
public class TaskServiceImpl implements TaskService {

    @Resource
    IReturnTaskService returnTaskService;
    @Resource
    private TaskHeaderService taskHeaderService;
    @Resource
    private ConfigService configService;
    @Resource
    private TaskCancelService taskCancelService;
    @Resource
    private ReceiptHeaderService receiptHeaderService;
    @Resource
    private ReceiptDetailService receiptDetailService;
    @Resource
    private ReceiptContainerHeaderService receiptContainerHeaderService;
    @Resource
    private ReceiptTaskService receiptTaskService;
    @Resource
    private InventoryHeaderService inventoryHeaderService;
    @Resource
    private ShipmentHeaderService shipmentHeaderService;
    @Resource
    private ShipmentDetailService shipmentDetailService;
    @Resource
    private ShipmentContainerHeaderService shipmentContainerHeaderService;
    @Resource
    private InventoryDetailService inventoryDetailService;
    @Resource
    private ContainerService containerService;
    @Resource
    private LocationService locationService;
    @Resource
    private MaterialService materialService;
    @Resource
    private IVehicleDetailService iVehicleDetailService;
    @Resource
    private ShipmentTaskService shipmentTaskService;
    @Resource
    private ReturnService returnService;
    @Resource
    private ReceiptContainerDetailService receiptContainerDetailService;
    @Resource
    private ShipmentContainerDetailService shipmentContainerDetailService;
    @Resource
    private StationService stationService;
    @Resource
    private IVehicleHeaderService iVehicleHeaderService;
    @Autowired
    private AddressService addressService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult taskOff(TaskOffDomain taskDomain) {
        AjaxResult ajaxResults;
        LambdaQueryWrapper<TaskHeader> wrapper = Wrappers.lambdaQuery();
        wrapper.eq(TaskHeader::getUserDef3, taskDomain.getTaskNo()).eq(TaskHeader::getContainerCode, taskDomain.getContainerCode());
        TaskHeader taskHeader = taskHeaderService.getOne(wrapper);
        if (taskHeader == null) {
            return AjaxResult.success("任务不存在或者已经取消过了");
        }

        if (taskHeader.getTaskType() == 100) {
            String value = configService.getKey(QuantityConstant.RULE_CONNECT_WCS);
            int connectWCS = Integer.parseInt(value);
            if (connectWCS == QuantityConstant.RULE_WCS_CONNECT) {
                Integer[] idList = Convert.toIntArray("" + taskHeader.getId());
                for (int id : idList) {
                    if (taskHeader.getStatus().intValue() <= QuantityConstant.TASK_STATUS_BUILD) {
                        continue;
                    }
                    AjaxResult ajaxResult = taskCancelService.TaskCance(id);
                    if (ajaxResult.hasErr()) {
                        return ajaxResult;
                    }
                }
            }
            taskHeaderService.cancelTask(Convert.toIntArray("" + taskHeader.getId()));
            LambdaQueryWrapper<ReceiptContainerDetail> receiptContainerDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            receiptContainerDetailLambdaQueryWrapper.eq(ReceiptContainerDetail::getReceiptContainerId, taskHeader.getAllocationHeadId());
            List<ReceiptContainerDetail> list = receiptContainerDetailService.list(receiptContainerDetailLambdaQueryWrapper);

            if (list == null || list.size() < 1) {
                throw new ServiceException("没有到到任务组盘");
            }

            List<Integer> idList = Arrays.asList(Convert.toIntArray("" + list.get(0).getId()));
            receiptContainerDetailService.detailRemove(idList);
            receiptHeaderService.removeById(list.get(0).getReceiptId());
            for (int i = 0; i < list.size(); i++) {
                receiptDetailService.removeById(list.get(i).getReceiptDetailId());
            }
            ajaxResults = AjaxResult.success("取消成功");
        } else {
            String value = configService.getKey(QuantityConstant.RULE_CONNECT_WCS);
            int connectWCS = Integer.parseInt(value);
            if (connectWCS == QuantityConstant.RULE_WCS_CONNECT) {
                if (taskHeader.getStatus().intValue() > QuantityConstant.TASK_STATUS_BUILD) {
                    ajaxResults = taskHeaderService.cancelTask(Convert.toIntArray("" + taskHeader.getId()));
                    if (ajaxResults.getCode() != 200) {
                        throw new ServiceException(ajaxResults.getMessage());
                    }
                    // 取消组盘
                    LambdaQueryWrapper<ShipmentContainerDetail> shipmentContainerDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
                    shipmentContainerDetailLambdaQueryWrapper.eq(ShipmentContainerDetail::getShippingContainerId, taskHeader.getAllocationHeadId());
                    List<ShipmentContainerDetail> list = shipmentContainerDetailService.list(shipmentContainerDetailLambdaQueryWrapper);

                    if (list == null || list.size() < 1) {
                        throw new ServiceException("没有到到任务组盘");
                    }
                    List<Integer> IdList = Arrays.asList(Convert.toIntArray("" + list.get(0).getShippingContainerId()));
                    return shipmentContainerHeaderService.cancelCombination(IdList);
                }
            }
            ajaxResults = taskHeaderService.cancelTask(Convert.toIntArray("" + taskHeader.getId()));
            if (ajaxResults.getCode() != 200) {
                throw new ServiceException(ajaxResults.getMessage());
            }
            // 取消组盘
            LambdaQueryWrapper<ShipmentContainerDetail> shipmentContainerDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            shipmentContainerDetailLambdaQueryWrapper.eq(ShipmentContainerDetail::getShippingContainerId, taskHeader.getAllocationHeadId());
            List<ShipmentContainerDetail> list = shipmentContainerDetailService.list(shipmentContainerDetailLambdaQueryWrapper);
            if (list == null || list.size() < 1) {
                throw new ServiceException("没有到到任务组盘");
            }
            List<Integer> IdList = Arrays.asList(Convert.toIntArray("" + list.get(0).getShippingContainerId()));
            ajaxResults = shipmentContainerHeaderService.cancelCombination(IdList);

        }
        return ajaxResults;

    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult lssueTask(TaskDomain taskDomain) {
        log.info("开始出库，任务ID:{}", taskDomain.getReqID());
        // 1. 前置准备：参数校验 + 提前解析常量（避免重复计算）
        validateTaskDomain(taskDomain);
        List<PalletInfo> originalPalletList = taskDomain.getPalletInfoList();
        int totalPalletCount = originalPalletList.size();
        long[] shipmentOrderHolder = { System.currentTimeMillis() };
        // 提前解析车辆类型（避免重复Integer.parseInt）
        String vehicleType = configService.getKey(QuantityConstant.VEHICLE_TYPE_CONFIG);
        int vehicleTypeInt = Integer.parseInt(vehicleType);

        // -------------------------- 核心优化1：批量查询缓存（减少循环查库）--------------------------
        // 1.1 批量查询：所有TaskHeader（判断任务是否存在）
        List<String> allTaskNos = originalPalletList.stream()
                .map(PalletInfo::getTaskNo)
                .collect(Collectors.toList());
        Map<String, TaskHeader> taskHeaderCache = taskHeaderService.list(
                        new LambdaQueryWrapper<TaskHeader>().in(TaskHeader::getUserDef3, allTaskNos)
                ).stream()
                .collect(Collectors.toMap(TaskHeader::getUserDef3, t -> t, (k1, k2) -> k1)); // 防重复key（取第一个）

        // 1.2 批量查询：所有InventoryDetail（复用：混料检查、库存校验、出库单明细）
        List<String> allContainerCodes = originalPalletList.stream()
                .map(PalletInfo::getContainerCode)
                .collect(Collectors.toList());
        Map<String, List<InventoryDetail>> containerInventoryCache = inventoryDetailService.list(
                        new LambdaQueryWrapper<InventoryDetail>().in(InventoryDetail::getContainerCode, allContainerCodes)
                ).stream()
                .collect(Collectors.groupingBy(InventoryDetail::getContainerCode));

        // 1.3 批量查询：所有InventoryHeader（仅车架用，避免循环查库）
        List<String> frameContainerCodes = originalPalletList.stream()
                .filter(p -> p.getContainerCode().contains("L")) // 仅车架容器
                .map(PalletInfo::getContainerCode)
                .collect(Collectors.toList());
        Map<String, InventoryHeader> frameHeaderCache = new HashMap<>();
        if (!frameContainerCodes.isEmpty()) {
            frameHeaderCache = inventoryHeaderService.list(
                            new LambdaQueryWrapper<InventoryHeader>().in(InventoryHeader::getContainerCode, frameContainerCodes)
                    ).stream()
                    .collect(Collectors.toMap(InventoryHeader::getContainerCode, h -> h));
        }

        // 1.4 批量查询：车型配置（VehicleHeader）- 仅车桥托盘用
        List<String> allVehicleTypes = originalPalletList.stream()
                .filter(p -> p.getContainerCode().contains("M") || p.getContainerCode().contains("D"))
                .map(PalletInfo::getVehicletype)
                .distinct()
                .collect(Collectors.toList());
        Map<String, VehicleHeader> vehicleHeaderCache = new HashMap<>();
        if (!allVehicleTypes.isEmpty()) {
            vehicleHeaderCache = iVehicleHeaderService.list(
                            new LambdaQueryWrapper<VehicleHeader>()
                                    .in(VehicleHeader::getUserDef1, allVehicleTypes)
                                    .eq(VehicleHeader::getEnable, 1)
                    ).stream()
                    .collect(Collectors.toMap(VehicleHeader::getUserDef1, v -> v));
        }

        // -------------------------- 2. 原第一阶段：任务+库存前置校验（复用缓存，无新查库）--------------------------
        for (PalletInfo palletInfo : originalPalletList) {
            String taskNo = palletInfo.getTaskNo();
            String containerCode = palletInfo.getContainerCode();
            List<InventoryDetail> inventoryDetails = containerInventoryCache.getOrDefault(containerCode, new ArrayList<>());

            // 2.1 任务存在性校验（复用taskHeaderCache）
            if (taskHeaderCache.containsKey(taskNo)) {
                throw new ServiceException("任务" + taskNo + "已存在");
            }

            // 2.2 混料校验（复用inventoryDetails）
            if (!inventoryDetails.isEmpty()) {
                long distinctSpecCount = inventoryDetails.stream()
                        .map(InventoryDetail::getMaterialSpec)
                        .distinct()
                        .count();
                if (distinctSpecCount > 1) {
                    throw new ServiceException("数据有问题,不同种类的混料,请维护数据,托盘号：" + containerCode);
                }
            }

            // 2.3 车桥托盘（含M/D）专属校验：车型配置+库存数量
            if (containerCode.contains("M") || containerCode.contains("D")) {
                // 车型配置校验（复用vehicleHeaderCache）
                VehicleHeader vehicleHeader = vehicleHeaderCache.get(palletInfo.getVehicletype());
                if (vehicleHeader == null && vehicleTypeInt == 1) {
                    throw new ServiceException("车型配置或者没启动不存在");
                }

                // 库存校验（复用inventoryDetails，避免重复查库）
                if (CollectionUtils.isEmpty(palletInfo.getInventoryList())) {
                    throw new ServiceException("容器" + containerCode + "无物料信息");
                }
                for (inventory inventoryItem : palletInfo.getInventoryList()) { // 假设InventoryList元素类型是InventoryItem
                    String materialCode = inventoryItem.getMaterialCode();
                    // 库存存在性校验
                    if (CollectionUtils.isEmpty(inventoryDetails)) {
                        throw new ServiceException("容器" + containerCode + "的库存" + materialCode + "不存在");
                    }
                    // 库存数量校验（仅vehicleType=1时）
                    if (vehicleTypeInt == 1) {
                        boolean hasEnoughQty = inventoryDetails.stream()
                                .anyMatch(detail -> detail.getMaterialCode().equals(materialCode)
                                        && detail.getQty().intValue() >= inventoryItem.getQuantity());
                        if (!hasEnoughQty) {
                            throw new ServiceException(materialCode + "数量超出");
                        }
                    }
                }
            }
        }

        // -------------------------- 3. 托盘排序（原逻辑保留，优化循环方式）--------------------------
        List<PalletInfo> sortedPalletList = originalPalletList.stream()
                .sorted((a1, a2) -> {
                    String order1 = a1.getProductOrderSeq();
                    String order2 = a2.getProductOrderSeq();
                    if (StringUtils.isNotEmpty(order1) && StringUtils.isNotEmpty(order2)) {
                        return Integer.parseInt(order1) - Integer.parseInt(order2);
                    }
                    return 0;
                })
                .collect(Collectors.toList());
        taskDomain.setPalletInfoList(sortedPalletList);

        // -------------------------- 4. 核心业务：出库单+组盘+任务创建（复用缓存+优化结构）--------------------------
        List<TaskHeader> taskHeaderList = new ArrayList<>();
        // 优化：用HashMap存出库口-顺序号（替代原ArrayList，查询效率O(1)）
        Map<String, Long> portShipmentOrderMap = new HashMap<>();

        for (int i = 0; i < sortedPalletList.size(); i++) {
            PalletInfo palletInfo = sortedPalletList.get(i);
            String containerCode = palletInfo.getContainerCode();

            // 4.1 创建出库单头
            ShipmentHeader shipmentHeader = new ShipmentHeader();
            shipmentHeader.setCompanyCode("SANY");
            shipmentHeader.setShipmentType("OTF");
            shipmentHeader.setReferCode("");
            shipmentHeader.setReferPlatform("");
            shipmentHeaderService.saveHeader(shipmentHeader);

            // 4.2 校验物料信息（原逻辑保留）
            if (CollectionUtils.isEmpty(palletInfo.getInventoryList())) {
                throw new ServiceException("没有物料信息");
            }

            // 4.3 获取库存明细（复用批量缓存，避免循环查库）
            List<InventoryDetail> inventoryDetails;
            if (containerCode.contains("L")) { // 车架：用提前缓存的InventoryHeader
                InventoryHeader inventoryHeader = frameHeaderCache.get(containerCode);
                if (inventoryHeader == null) {
                    throw new ServiceException(containerCode + "的库存不存在");
                }
                inventoryDetails = inventoryDetailService.list(
                        new LambdaQueryWrapper<InventoryDetail>().eq(InventoryDetail::getInventoryHeaderId, inventoryHeader.getId())
                );
            } else { // 非车架：直接用批量缓存的InventoryDetail
                inventoryDetails = containerInventoryCache.getOrDefault(containerCode, new ArrayList<>());
            }
            if (CollectionUtils.isEmpty(inventoryDetails)) {
                throw new ServiceException(containerCode + "的库存不存在");
            }

            // 4.4 创建出库单明细
            List<ShipmentDetail> shipmentDetails = new ArrayList<>();
            for (InventoryDetail detail : inventoryDetails) {
                // 预执行校验（原逻辑保留）
                if (detail.getTaskQty().intValue() >= 1) {
                    throw new ServiceException("此容器" + detail.getContainerCode() + "上的物料有被预执行的");
                }
                // 组装明细（后续批量插入可进一步优化，此处保留原单条插入逻辑）
                ShipmentDetail shipmentDetail = new ShipmentDetail();
                shipmentDetail.setShipmentId(shipmentHeader.getId());
                shipmentDetail.setCompanyCode("SANY");
                shipmentDetail.setShipmentCode(shipmentHeader.getCode());
                shipmentDetail.setMaterialCode(detail.getMaterialCode());
                shipmentDetail.setShipQty(detail.getQty());
                shipmentDetail.setInventorySts(detail.getInventorySts());
                shipmentDetailService.insertDetail(shipmentDetail);
                shipmentDetails.add(shipmentDetail);
            }

            // 4.5 组盘操作（原逻辑保留，删除无效变量）
            ShipmentTaskCreateModel shipmentTaskTemp = new ShipmentTaskCreateModel();
            Integer shipmentContainerId = null;
            for (int j = 0; j < inventoryDetails.size(); j++) {
                InventoryDetail detail = inventoryDetails.get(j);
                ShipmentDetail shipmentDetail = shipmentDetails.get(j);

                ShipmentCombinationModel combinationModel = new ShipmentCombinationModel();
                combinationModel.setTaskType(0);
                combinationModel.setShipQty(detail.getQty());
                combinationModel.setShipmentDetailId(shipmentDetail.getId());
                combinationModel.setInventoryDetailId(detail.getId());

                ShipmentContainerHeader containerHeader = shipmentContainerHeaderService.combination(combinationModel);
                shipmentContainerId = containerHeader.getId(); // 记录组盘ID（后续用）
                shipmentTaskTemp.setShipmentContainerHeaderIds(shipmentContainerId);
            }

            // 4.6 组盘信息校验（原逻辑保留，简化ID处理）
            if (shipmentContainerId == null) {
                throw new ServiceException(containerCode + "组盘信息创建失败");
            }
            ShipmentContainerHeader containerHeader = shipmentContainerHeaderService.getById(shipmentContainerId);
            if (containerHeader == null || containerHeader.getStatus() != 0) {
                throw new ServiceException(containerCode + "组盘信息不存在或已完成");
            }

            // 4.7 出库口设置（原逻辑保留，复用vehicleTypeInt）
            StationType stationType = new StationType();
            // 托盘类型判断出库口类型
            if ("LS".equals(containerHeader.getContainerType()) || "S".equals(containerHeader.getContainerType())) {
                stationType.setType("2"); // 整出
            } else {
                stationType.setType("3"); // 可入可出
            }
            stationType.setContainerCode(containerCode);
            Map<String, Object> stationMap = stationService.StationFromType(stationType);
            String defaultPort = Objects.toString(stationMap.get("hhh"), "");
            containerHeader.setPort(defaultPort);

            // 车间托盘（LS）强制出库口P2017（原逻辑保留）
            if ("LS".equals(containerHeader.getContainerType())) {
                containerHeader.setPort("P2017");
            }

            // 车型配置覆盖出库口（原逻辑保留，复用缓存）
            if (vehicleTypeInt == 1 || vehicleTypeInt == 2) {
                // 仅车桥托盘（M/D）需处理车型
                if (containerCode.contains("M") || containerCode.contains("D")) {
                    VehicleHeader targetVehicleHeader = null;
                    // 区分车型类型：1=集团WMS，2=本地默认
                    if (vehicleTypeInt == 1) {
                        targetVehicleHeader = vehicleHeaderCache.get(palletInfo.getVehicletype());
                    } else {
                        // 本地默认车型：查默认配置
                        List<VehicleHeader> defaultVehicles = iVehicleHeaderService.list(
                                new LambdaQueryWrapper<VehicleHeader>().eq(VehicleHeader::getDefaultParameters, 1)
                        );
                        if (defaultVehicles.size() > 1) {
                            throw new ServiceException("状态2时默认车型过多请检查");
                        }
                        if (CollectionUtils.isEmpty(defaultVehicles)) {
                            throw new ServiceException("状态2时默认车型不存在请检查");
                        }
                        targetVehicleHeader = defaultVehicles.get(0);
                    }

                    // 查车型对应的物料出库口
                    if (targetVehicleHeader != null) {
                        String materialCode = palletInfo.getInventoryList().get(0).getMaterialCode();
                        VehicleDetail vehicleDetail = iVehicleDetailService.getOne(
                                new LambdaQueryWrapper<VehicleDetail>()
                                        .eq(VehicleDetail::getCode, materialCode)
                                        .eq(VehicleDetail::getVehicleId, targetVehicleHeader.getId())
                        );
                        if (vehicleDetail == null) {
                            throw new ServiceException("状态" + vehicleTypeInt + "时 默认车型配置的物料不存在请检查");
                        }
                        containerHeader.setPort(vehicleDetail.getPort()); // 覆盖出库口
                    }
                }
            }

            // 更新组盘信息（原逻辑保留）
            boolean updateSuccess = shipmentContainerHeaderService.updateById(containerHeader);
            if (!updateSuccess) {
                throw new ServiceException("更新出库配盘头失败");
            }

            // 4.8 校验组盘状态（原逻辑保留，简化ID处理）
            ShipmentContainerHeader checkContainer = shipmentContainerHeaderService.getById(shipmentContainerId);
            if (checkContainer == null) {
                throw new ServiceException("出库货箱id：" + shipmentContainerId + "未找到,操作中止");
            }
            if (checkContainer.getStatus() >= QuantityConstant.TASK_STATUS_RELEASE) {
                throw new ServiceException("出库货箱编码(" + checkContainer.getContainerCode() + ")已经生成任务，请不要重复生成");
            }

            // 4.9 创建出库任务（原逻辑保留，优化顺序号存储）
            shipmentTaskTemp.setShipmentContainerHeaderIds(shipmentContainerId);
            AjaxResult taskCreateResult = shipmentTaskService.createTaskFromShipmentContainers(shipmentTaskTemp);
            if (taskCreateResult.hasErr()) {
                throw new ServiceException(taskCreateResult.getMsg());
            }
            Integer taskId = (Integer) taskCreateResult.getData();
            TaskHeader taskHeader = taskHeaderService.getById(taskId);
            if (taskHeader == null) {
                throw new ServiceException("任务创建后查询失败，任务ID：" + taskId);
            }

            // 4.10 任务信息赋值（优化顺序号逻辑：用HashMap替代原ArrayList遍历）
            taskHeader.setSequence(i + 1); // 临时顺序（后续分组会重设）
            taskHeader.setUserDef2(taskDomain.getReqID());
            taskHeader.setUserDef3(palletInfo.getTaskNo());
            taskHeader.setTaskType(QuantityConstant.TASK_TYPE_WHOLESHIPMENT);
            taskHeader.setCreatedBy("三一集团WMS");
            // 排序值赋值
            if (StringUtils.isNotEmpty(palletInfo.getProductOrderSeq())) {
                taskHeader.setSort(Integer.valueOf(palletInfo.getProductOrderSeq()));
            }

            // 出库顺序号：不存在则新增，存在则复用（HashMap优化核心）
            String taskPort = containerHeader.getPort();
            portShipmentOrderMap.computeIfAbsent(taskPort, k -> shipmentOrderHolder[0]++);
            taskHeader.setShipmentOrder(portShipmentOrderMap.get(taskPort));

            // 更新任务并加入列表
            taskHeaderService.updateById(taskHeader);
            taskHeaderList.add(taskHeader);
        }

        // -------------------------- 5. 任务分组排序（优化分组逻辑，复用HashMap）--------------------------
        // 按出库口分组（直接用portShipmentOrderMap的key，避免原ArrayList遍历）
        Map<String, List<TaskHeader>> portTaskGroup = taskHeaderList.stream()
                .collect(Collectors.groupingBy(TaskHeader::getPort));

        for (Map.Entry<String, List<TaskHeader>> entry : portTaskGroup.entrySet()) {
            List<TaskHeader> portTasks = entry.getValue();
            // 按原Sequence升序排序
            portTasks.sort(Comparator.comparing(TaskHeader::getSequence));
            // 重设顺序号和组内总数
            int groupSize = portTasks.size();
            for (int seq = 0; seq < groupSize; seq++) {
                TaskHeader task = portTasks.get(seq);
                task.setSequence(seq + 1);
                task.setSequenceNumber(groupSize); // 组内总数（原sequenceNumber优化）
                taskHeaderService.updateById(task);
            }
        }

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


    private void validateTaskDomain(TaskDomain taskDomain) {
        if (taskDomain == null) {
            throw new ServiceException("任务参数为空");
        }
        if (taskDomain.getReqID() == null) {
            throw new ServiceException("任务号为空");
        }
        if (taskDomain.getTaskType() == null) {
            throw new ServiceException("任务类型为空");
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult taskAllreceipt(TaskDomain taskDomain) {

        for (int i = 0; i < taskDomain.getPalletInfoList().size(); i++) {
            // 校验任务是否存在
            LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            taskHeaderLambdaQueryWrapper.eq(TaskHeader::getUserDef3, taskDomain.getPalletInfoList().get(i).getTaskNo());
            if (taskHeaderService.getOne(taskHeaderLambdaQueryWrapper) != null) {
                return AjaxResult.success("任务" + taskDomain.getPalletInfoList().get(i).getTaskNo() + "已存在");
            }
            PalletInfo palletInfo = taskDomain.getPalletInfoList().get(i);
            List<inventory> inventoryList = palletInfo.getInventoryList();
            List<String> materialCodes = inventoryList.stream().map(inventory::getMaterialCode).collect(Collectors.toList());
            Set<String> set = new HashSet<>();
            for (String str : materialCodes) {
                set.add(str);
            }
            if (set.size() > 1) {
                throw new ServiceException("入库不能混合物料！" + materialCodes);
            }
            // 校验目标库位和入库物料列表
            List<ReceiptDetail> receiptDetails = new ArrayList<>();
            if (taskDomain.getPalletInfoList().get(i).getInventoryList() == null || taskDomain.getPalletInfoList().get(i).getInventoryList().isEmpty()) {
                if (StringUtils.isEmpty(taskDomain.getPalletInfoList().get(i).getContainerCode())) {
                    throw new ServiceException("容器和目标库位不能有空值！");
                }

                if (taskDomain.getPalletInfoList().get(i).getInventoryList().isEmpty()) {
                    throw new ServiceException("上架托盘入库物料不能为空！");
                }

            }

            LambdaQueryWrapper<InventoryHeader> inventoryHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            inventoryHeaderLambdaQueryWrapper.eq(InventoryHeader::getContainerCode, taskDomain.getPalletInfoList().get(i).getContainerCode());
            InventoryHeader inventoryHeader = inventoryHeaderService.getOne(inventoryHeaderLambdaQueryWrapper);
            if (inventoryHeader != null) {
                throw new ServiceException("库存已存在！");
            }

            // 添加入库头表
            ReceiptHeader receiptHeader = new ReceiptHeader();
            receiptHeader.setCompanyCode("SANY");
            receiptHeader.setReceiptType("CG");// 入库类型
            receiptHeader.setUserDef2(taskDomain.getReqID());// 请求ID
            receiptHeader.setUserDef3(taskDomain.getPalletInfoList().get(i).getTaskNo());// 任务编号
            receiptHeaderService.saveReceiptHeader(receiptHeader);
            // 遍历入库物料详情
            for (int j = 0; j < taskDomain.getPalletInfoList().get(i).getInventoryList().size(); j++) {

                LambdaQueryWrapper<Material> materialLambdaQueryWrapper = Wrappers.lambdaQuery();
                String materialCode = taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getMaterialCode();
                materialLambdaQueryWrapper.eq(Material::getCode, materialCode);
                Material material = materialService.getOne(materialLambdaQueryWrapper);
                if (material == null) {
                    throw new ServiceException("系统没有这个物料:" + materialCode);
                }
                if (!material.getEnable()) {
                    throw new ServiceException("物料已经被禁用了");
                }

                ReceiptDetail receiptDetail = new ReceiptDetail();
                receiptDetail.setReceiptId(receiptHeader.getId());// 入库头ID
                receiptDetail.setCompanyCode("SANY");
                receiptDetail.setReceiptCode(receiptHeader.getCode());// 入库头编码

                receiptDetail.setMaterialCode(taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getMaterialCode());
                receiptDetail.setQcCheck("1");
                BigDecimal nu = new BigDecimal(taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getQuantity());
                receiptDetail.setTotalQty(nu);
                // 状态转换
                if (taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getInventoryStatus() != null) {
                    if (taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getInventoryStatus().equals("合格")) {
                        receiptDetail.setInventorySts("good");
                    } else {
                        receiptDetail.setInventorySts("defective");// 另一种状态
                    }
                } else {
                    throw new ServiceException(taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getMaterialCode() + "的库存状态没给");
                }
                // 保存入库单详情
                receiptDetailService.saveReceiptDetaial(receiptDetail);
                // 设置容器编码
                receiptDetail.setUserDef8(taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getContainerCode());
                receiptDetails.add(receiptDetail);
            }

            for (int s = 0; s < receiptDetails.size(); s++) {
                // 收货
                AjaxResult result = receiptContainerHeaderService.saveContainer(receiptHeader.getCode(), receiptDetails.get(s).getUserDef8(),
                    receiptDetails.get(s).getId(), "", receiptDetails.get(s).getTotalQty(), "");
            }

            for (int s = 0; s < receiptDetails.size(); s++) {

                // 查询状态为0的组盘容器
                LambdaQueryWrapper<ReceiptContainerHeader> receiptContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
                receiptContainerHeaderLambdaQueryWrapper.eq(ReceiptContainerHeader::getContainerCode, receiptDetails.get(s).getUserDef8())
                    .eq(ReceiptContainerHeader::getStatus, 0);
                ReceiptContainerHeader one = receiptContainerHeaderService.getOne(receiptContainerHeaderLambdaQueryWrapper);
                // 没有组盘容器跳过
                if (one == null) {
                    continue;
                }

                List<Integer> idList = Arrays.asList(Convert.toIntArray("" + one.getId()));
                List<Integer> idsList = idList.stream().distinct().collect(Collectors.toList());
                AjaxResult receiptTask = receiptTaskService.createReceiptTask(idsList);
                List<String> ids = (List<String>)receiptTask.getData();
                List<Integer> integerList = new ArrayList<>();
                CollectionUtils.collect(ids, new Transformer() {
                    @Override
                    public Object transform(Object o) {
                        return Integer.parseInt(o.toString());
                    }
                }, integerList);

                TaskHeader byId = taskHeaderService.getById(integerList.toArray(new Integer[0])[0]);
                byId.setUserDef2(taskDomain.getReqID());
                byId.setUserDef3(taskDomain.getPalletInfoList().get(i).getTaskNo());
                byId.setCreatedBy("三一集团WMS");
                taskHeaderService.updateById(byId);
                // taskHeaderService.sendTaskToWcs(integerList.toArray(new Integer[0]));
            }

        }

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

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult airflare(TaskDomain taskDomain) {

        for (int i = 0; i < taskDomain.getPalletInfoList().size(); i++) {

            if (taskDomain.getPalletInfoList().get(i).getContainerCode().contains("S") || taskDomain.getPalletInfoList().get(i).getContainerCode().contains("L")) {
                if (taskDomain.getPalletInfoList().get(i).getInventoryList().size() > 0) {
                    // 不能大于0，不然就是有问题的订单
                    throw new ServiceException(taskDomain.getPalletInfoList().get(i).getTaskNo() + "出问题了,非车桥回盘，不能存在有物料情况");
                }
                // 1.回传结束
                LambdaQueryWrapper<ReturnTask> returnTaskLambdaQueryWrapper = Wrappers.lambdaQuery();
                returnTaskLambdaQueryWrapper.eq(ReturnTask::getTaskNo, taskDomain.getPalletInfoList().get(i).getTaskNo());
                List<ReturnTask> list = returnTaskService.list(returnTaskLambdaQueryWrapper);
                if (list != null && list.size() > 0) {
                    return AjaxResult.success("任务已经存在了");
                }
                ReturnTask returnTaskDomain = new ReturnTask();
                returnTaskDomain.setReqID(taskDomain.getReqID());
                returnTaskDomain.setTaskNo(taskDomain.getPalletInfoList().get(i).getTaskNo());
                returnTaskDomain.setTaskStatus(2);// 1代表开始 出库任务开始
                returnTaskDomain.setSendBack(0); // 0代表没回传
                returnTaskDomain.setContainerCode(taskDomain.getPalletInfoList().get(i).getContainerCode());
                returnTaskService.save(returnTaskDomain);
                return AjaxResult.success("回传请求收到成功,已回传并抛舍报文");
            }

            LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            taskHeaderLambdaQueryWrapper.eq(TaskHeader::getUserDef3, taskDomain.getPalletInfoList().get(i).getTaskNo());
            if (taskHeaderService.getOne(taskHeaderLambdaQueryWrapper) != null) {
                return AjaxResult.success("任务" + taskDomain.getPalletInfoList().get(i).getTaskNo() + "已存在");
            }
            List<ReceiptDetail> receiptDetails = new ArrayList<>();
            if (taskDomain.getPalletInfoList().get(i).getInventoryList() == null || taskDomain.getPalletInfoList().get(i).getInventoryList().size() < 1) {
                AjaxResult emptyIn = inventoryHeaderService.createEmptyIn(taskDomain.getPalletInfoList().get(i).getContainerCode(), "");
                if (emptyIn.hasErr()) {
                    return emptyIn;
                }
                TaskHeader byId = taskHeaderService.getById("" + emptyIn.getData());
                byId.setUserDef2(taskDomain.getReqID());
                byId.setUserDef3(taskDomain.getPalletInfoList().get(i).getTaskNo());
                byId.setFoldFlag(1);
                byId.setCreatedBy("三一集团WMS");
                taskHeaderService.updateById(byId);
                emptyIn.setData("");
                Integer[] a = new Integer[1];
                a[0] = byId.getId();
                // 执行到wcs
//                taskHeaderService.sendTaskToWcs(a);
                continue;
            }
            ReceiptHeader receiptHeader = new ReceiptHeader();
            receiptHeader.setCompanyCode("SANY");
            receiptHeader.setReceiptType("CG");
            receiptHeader.setUserDef2(taskDomain.getReqID());
            receiptHeader.setUserDef3(taskDomain.getPalletInfoList().get(i).getTaskNo());
            receiptHeaderService.saveReceiptHeader(receiptHeader);
            for (int j = 0; j < taskDomain.getPalletInfoList().get(i).getInventoryList().size(); j++) {
                ReceiptDetail receiptDetail = new ReceiptDetail();
                receiptDetail.setReceiptId(receiptHeader.getId());
                receiptDetail.setCompanyCode("SANY");
                receiptDetail.setReceiptCode(receiptHeader.getCode());

                receiptDetail.setMaterialCode(taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getMaterialCode());
                receiptDetail.setQcCheck("1");
                BigDecimal nu = new BigDecimal(taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getQuantity());
                receiptDetail.setTotalQty(nu);
                if (taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getInventoryStatus() != null) {
                    if (taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getInventoryStatus().equals("合格")) {
                        receiptDetail.setInventorySts("good");
                    } else {
                        receiptDetail.setInventorySts("defective");// 另一种状态
                    }
                } else {
                    throw new ServiceException(taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getMaterialCode() + "的库存状态没给");
                }

                receiptDetailService.saveReceiptDetaial(receiptDetail);
                receiptDetail.setUserDef8(taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getContainerCode());
                receiptDetails.add(receiptDetail);
            }

            for (int s = 0; s < receiptDetails.size(); s++) {
                // 收货
                AjaxResult result = receiptContainerHeaderService.saveContainer(receiptHeader.getCode(), receiptDetails.get(s).getUserDef8(),
                    receiptDetails.get(s).getId(), "", receiptDetails.get(s).getTotalQty(), "");
            }
            for (int s = 0; s < receiptDetails.size(); s++) {

                LambdaQueryWrapper<ReceiptContainerHeader> receiptContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
                receiptContainerHeaderLambdaQueryWrapper.eq(ReceiptContainerHeader::getContainerCode, receiptDetails.get(s).getUserDef8())
                    .eq(ReceiptContainerHeader::getStatus, 0);
                ReceiptContainerHeader one = receiptContainerHeaderService.getOne(receiptContainerHeaderLambdaQueryWrapper);

                if (one == null) {
                    continue;
                }
                List<Integer> idList = Arrays.asList(Convert.toIntArray("" + one.getId()));
                List<Integer> idsList = idList.stream().distinct().collect(Collectors.toList());
                AjaxResult receiptTask = receiptTaskService.createReceiptTask(idsList);
                List<String> ids = (List<String>)receiptTask.getData();
                List<Integer> integerList = new ArrayList<>();
                CollectionUtils.collect(ids, new Transformer() {
                    @Override
                    public Object transform(Object o) {
                        return Integer.parseInt(o.toString());
                    }
                }, integerList);

                TaskHeader byId = taskHeaderService.getById(integerList.toArray(new Integer[0])[0]);
                byId.setUserDef2(taskDomain.getReqID());
                byId.setUserDef3(taskDomain.getPalletInfoList().get(i).getTaskNo());
                byId.setCreatedBy("三一集团WMS");

                taskHeaderService.updateById(byId);

//                taskHeaderService.sendTaskToWcs(integerList.toArray(new Integer[0]));

            }
//            taskHeaderService.sendTaskToWcs(integerList.toArray(new Integer[0]));自动执行

        }

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

    /**
     * @param  taskDomain
     * @return
     */
    @Override
    @Transactional
    public AjaxResult noProduction(TaskDomain taskDomain) {
        long shipmentOrder = System.currentTimeMillis();
        int ii = 1;
        String cs = configService.getKey(QuantityConstant.VEHICLE_TYPE_CONFIG);
        if (taskDomain == null) {
            throw new ServiceException("wms下发任务为空");
        }
        // 1、判断必填字段是否满足
        if (taskDomain.getReqID() == null) {
            throw new ServiceException("wms任务号Id为空");
        }
        if (taskDomain.getTaskType() == null) {
            throw new ServiceException("wms任务类型为空");
        }
        for (int i = 0; i < taskDomain.getPalletInfoList().size(); i++) {
            LambdaQueryWrapper<InventoryDetail> wrappers = Wrappers.lambdaQuery();
            wrappers.eq(InventoryDetail::getContainerCode, taskDomain.getPalletInfoList().get(i).getContainerCode());
            List<InventoryDetail> lists = inventoryDetailService.list(wrappers);

            for (int j = 0; j < lists.size(); j++) {
                if (!lists.get(j).getMaterialSpec().equals(lists.get(0).getMaterialSpec())) {
                    throw new ServiceException("数据有问题,不同种类的混料,特殊物料请维护数据,托盘号："+lists.get(0).getContainerCode());
                }
            }
            LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            taskHeaderLambdaQueryWrapper.eq(TaskHeader::getUserDef3, taskDomain.getPalletInfoList().get(i).getTaskNo());
            if (taskHeaderService.getOne(taskHeaderLambdaQueryWrapper) != null) {
                throw new ServiceException("任务" + taskDomain.getPalletInfoList().get(i).getTaskNo() + "已存在");
            }
            if (taskDomain.getPalletInfoList().get(i).getContainerCode().contains("M") || taskDomain.getPalletInfoList().get(i).getContainerCode().contains("D")) {
                LambdaQueryWrapper<VehicleHeader> wrapper1 = Wrappers.lambdaQuery();
                wrapper1.eq(VehicleHeader::getUserDef1, taskDomain.getPalletInfoList().get(i).getVehicletype()).eq(VehicleHeader::getEnable, 1);;
                VehicleHeader one = iVehicleHeaderService.getOne(wrapper1);
                if (one == null && Integer.valueOf(cs) == 1) {
                    throw new ServiceException("车型配置或者没启动不存在");
                }
                for (int j = 0; j < taskDomain.getPalletInfoList().get(i).getInventoryList().size(); j++) {
                    List<InventoryDetail> list = new ArrayList<>();
                    LambdaQueryWrapper<InventoryDetail> wrapper = Wrappers.lambdaQuery();
                    wrapper.eq(InventoryDetail::getContainerCode, taskDomain.getPalletInfoList().get(i).getContainerCode());
                    list = inventoryDetailService.list(wrapper);
                    if (list == null || list.size() < 1) {
                        throw new ServiceException(taskDomain.getPalletInfoList().get(i).getContainerCode() + "容器库存不存在");
                    }
                    LambdaQueryWrapper<InventoryDetail> wrapper3 = Wrappers.lambdaQuery();
                    wrapper3.eq(InventoryDetail::getContainerCode, taskDomain.getPalletInfoList().get(i).getContainerCode())
                        .eq(InventoryDetail::getMaterialCode, taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getMaterialCode())
                        .ge(InventoryDetail::getQty, taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getQuantity());
                    InventoryDetail one2 = inventoryDetailService.getOne(wrapper3);
                    if (one2 == null) {
                        throw new ServiceException(taskDomain.getPalletInfoList().get(i).getContainerCode() + "容器的"
                            + taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getMaterialCode() + "数量超出");
                    }
                    if (Integer.valueOf(cs) == 1) {
                        LambdaQueryWrapper<VehicleDetail> wrapper2 = Wrappers.lambdaQuery();
                        wrapper2.eq(VehicleDetail::getVehicleId, one.getId()).eq(VehicleDetail::getCode,
                            taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getMaterialCode());
                        VehicleDetail one1 = iVehicleDetailService.getOne(wrapper2);
                        if (one1 == null) {
                            throw new ServiceException("此车型给的物料" + taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getMaterialCode() + "存在错误");
                        }
                    }
                }
            }
        }
        for (int i = 0; i < taskDomain.getPalletInfoList().size(); i++) {
            ShipmentHeader shipmentHeader = new ShipmentHeader();
            shipmentHeader.setCompanyCode("SANY");
            shipmentHeader.setShipmentType("OTF");
            shipmentHeader.setReferCode("");
            shipmentHeader.setReferPlatform("");
            shipmentHeaderService.saveHeader(shipmentHeader);
            if (taskDomain.getPalletInfoList().get(i).getInventoryList() == null || taskDomain.getPalletInfoList().get(i).getInventoryList().size() <= 0) {
                throw new ServiceException("没有物料信息");
            }
            List<InventoryDetail> list = new ArrayList<>();
            if (taskDomain.getPalletInfoList().get(i).getContainerCode().contains("L")) {
                // 如果是车架
                LambdaQueryWrapper<InventoryHeader> wrapper1 = Wrappers.lambdaQuery();
                wrapper1.eq(InventoryHeader::getContainerCode, taskDomain.getPalletInfoList().get(i).getContainerCode());
                InventoryHeader one = inventoryHeaderService.getOne(wrapper1);
                if (one == null) {
                    throw new ServiceException(taskDomain.getPalletInfoList().get(i).getContainerCode() + "的库存不存在");
                }
                LambdaQueryWrapper<InventoryDetail> wrapper2 = Wrappers.lambdaQuery();
                wrapper2.eq(InventoryDetail::getInventoryHeaderId, one.getId());
                list = inventoryDetailService.list(wrapper2);
                if (list == null && list.size() < 1) {
                    throw new ServiceException("库存不存在");
                }
            } else {
                // //如果是车桥
                LambdaQueryWrapper<InventoryDetail> wrapper = Wrappers.lambdaQuery();
                wrapper.eq(InventoryDetail::getContainerCode, taskDomain.getPalletInfoList().get(i).getContainerCode());
                list = inventoryDetailService.list(wrapper);
                if (list == null || list.size() < 1) {
                    throw new ServiceException(taskDomain.getPalletInfoList().get(i).getContainerCode() + "的库存不存在");
                }
            }
            for (int j = 0; j < list.size(); j++) {
                ShipmentDetail shipmentDetail = new ShipmentDetail();
                shipmentDetail.setShipmentId(shipmentHeader.getId());
                shipmentDetail.setCompanyCode("SANY");
                shipmentDetail.setShipmentCode(shipmentHeader.getCode());
                shipmentDetail.setMaterialCode(list.get(j).getMaterialCode());
                if (list.get(j).getTaskQty().intValue() >= 1) {
                    throw new ServiceException("此容器" + list.get(j).getContainerCode() + "上的物料有被预执行的");
                }
                shipmentDetail.setShipQty(list.get(j).getQty());
                shipmentDetail.setInventorySts(list.get(j).getInventorySts());
                shipmentDetailService.insertDetail(shipmentDetail);
            }
            LambdaQueryWrapper<ShipmentDetail> shipmentDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            shipmentDetailLambdaQueryWrapper.eq(ShipmentDetail::getShipmentId, shipmentHeader.getId());
            List<ShipmentDetail> list1 = shipmentDetailService.list(shipmentDetailLambdaQueryWrapper);
            for (int j = 0; j < list.size(); j++) {
                ShipmentCombinationModel shipmentCombinationModel = new ShipmentCombinationModel();
                shipmentCombinationModel.setTaskType(0);
                shipmentCombinationModel.setShipQty(list.get(j).getQty());
                shipmentCombinationModel.setShipmentDetailId(list1.get(j).getId());
                shipmentCombinationModel.setInventoryDetailId(list.get(j).getId());
                // 组盘
                ShipmentContainerHeader shipmentContainerHeader = shipmentContainerHeaderService.combination(shipmentCombinationModel);
                ShipmentTaskCreateModel shipmentTask = new ShipmentTaskCreateModel();
                shipmentTask.setShipmentContainerHeaderIds(shipmentContainerHeader.getId());
                shipmentContainerHeader.getId();
            }
            LambdaQueryWrapper<ShipmentContainerHeader> receiptContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            receiptContainerHeaderLambdaQueryWrapper.eq(ShipmentContainerHeader::getStatus, 0).eq(ShipmentContainerHeader::getContainerCode,
                taskDomain.getPalletInfoList().get(i).getContainerCode());
            ShipmentContainerHeader one1 = shipmentContainerHeaderService.getOne(receiptContainerHeaderLambdaQueryWrapper);
            if (one1 == null) {
                throw new ServiceException(taskDomain.getPalletInfoList().get(i).getContainerCode() + "的库存不存在");
            }
            String ids = "" + one1.getId();
            List<Integer> idList = Arrays.asList(Convert.toIntArray(ids));
            List<Integer> idsList = idList.stream().distinct().collect(Collectors.toList());
            for (Integer id : idsList) {
                LambdaQueryWrapper<ShipmentContainerHeader> shipmentContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
                shipmentContainerHeaderLambdaQueryWrapper.eq(ShipmentContainerHeader::getId, id);
                ShipmentContainerHeader shipmentContainerHeader1 = shipmentContainerHeaderService.getOne(shipmentContainerHeaderLambdaQueryWrapper);
                StationType stationType = new StationType();
                stationType.setType("2");
                stationType.setContainerCode("" + taskDomain.getPalletInfoList().get(i).getContainerCode());
                Map<String, Object> map = stationService.StationFromType(stationType);
                Object results = map.get("hhh");
                shipmentContainerHeader1.setPort("" + results);
                if (one1.getContainerType().equals("LS")) {
                    shipmentContainerHeader1.setPort("P2017");
                }
                String model = "系统默认";

                if (Integer.valueOf(cs) == 1) {
                    model = taskDomain.getPalletInfoList().get(i).getVehicletype();
                    if (taskDomain.getPalletInfoList().get(i).getContainerCode().contains("M")
                        || taskDomain.getPalletInfoList().get(i).getContainerCode().contains("D")) {
                        LambdaQueryWrapper<VehicleHeader> wrapper1 = Wrappers.lambdaQuery();
                        wrapper1.eq(VehicleHeader::getUserDef1, taskDomain.getPalletInfoList().get(i).getVehicletype()).eq(VehicleHeader::getEnable, 1);
                        VehicleHeader one = iVehicleHeaderService.getOne(wrapper1);
                        LambdaQueryWrapper<VehicleDetail> wrapper2 = Wrappers.lambdaQuery();
                        wrapper2.eq(VehicleDetail::getCode, taskDomain.getPalletInfoList().get(i).getInventoryList().get(0).getMaterialCode())
                            .eq(VehicleDetail::getVehicleId, one.getId());
                        VehicleDetail vehicleDetail = iVehicleDetailService.getOne(wrapper2);
                        if (vehicleDetail == null) {
                            throw new ServiceException("状态1时 默认车型配置的物料不存在请检查");
                        }
                        shipmentContainerHeader1.setPort(vehicleDetail.getPort());
                    }
                }

                if (Integer.valueOf(cs) == 2) {
                    model = "用户默认";
                    LambdaQueryWrapper<VehicleHeader> wrapper1 = Wrappers.lambdaQuery();
                    wrapper1.eq(VehicleHeader::getDefaultParameters, 1);
                    List<VehicleHeader> headers = iVehicleHeaderService.list(wrapper1);
                    if (headers.size() > 1) {
                        throw new ServiceException("状态2时默认车型过多请检查");
                    }
                    if (headers.size() == 0) {
                        throw new ServiceException("状态2时默认车型不存在请检查");
                    }

                    LambdaQueryWrapper<VehicleDetail> wrapper2 = Wrappers.lambdaQuery();
                    wrapper2.eq(VehicleDetail::getCode, taskDomain.getPalletInfoList().get(i).getInventoryList().get(0).getMaterialCode())
                        .eq(VehicleDetail::getVehicleId, headers.get(0).getId());
                    VehicleDetail vehicleDetail = iVehicleDetailService.getOne(wrapper2);
                    if (vehicleDetail == null) {
                        throw new ServiceException("状态2时 默认车型配置的物料不存在请检查");
                    }
                    shipmentContainerHeader1.setPort(vehicleDetail.getPort());
                }
                shipmentContainerHeaderService.update(shipmentContainerHeader1, shipmentContainerHeaderLambdaQueryWrapper);
            }
            AjaxResult ajaxResult = new AjaxResult();
            Integer[] idList1 = Convert.toIntArray(ids);
            for (Integer id : idList1) {
                // 获取表头
                ShipmentContainerHeader shipmentContainerHeader1 = shipmentContainerHeaderService.getById(id);
                if (shipmentContainerHeader1 == null) {
                    throw new ServiceException("出库货箱id：" + id + "未找到,操作中止");
                }
                if (shipmentContainerHeader1.getStatus() >= QuantityConstant.TASK_STATUS_RELEASE) {
                    throw new ServiceException("出库货箱编码(" + shipmentContainerHeader1.getContainerCode() + ")已经生成任务，请不要重复生成，操作中止");
                }
            }
            ShipmentTaskCreateModel shipmentTask = new ShipmentTaskCreateModel();
            for (Integer id : idList1) {
                shipmentTask.setShipmentContainerHeaderIds(id);
                AjaxResult ajaxResult1 = shipmentTaskService.createTaskFromShipmentContainers(shipmentTask);
                if (ajaxResult1.hasErr()) {
                    throw new ServiceException(ajaxResult1.getMsg());
                }
                Integer integer = (Integer)ajaxResult1.getData();
                TaskHeader byId = taskHeaderService.getById(integer);
                byId.setUserDef2(taskDomain.getReqID());
                byId.setUserDef3(taskDomain.getPalletInfoList().get(i).getTaskNo());
                byId.setTaskType(QuantityConstant.TASK_TYPE_WHOLESHIPMENT);
                byId.setSort(1);
                byId.setPriority(9999);
                int sequenceNumber = taskDomain.getPalletInfoList().size();
                byId.setShipmentOrder(shipmentOrder - 1000000000);
                byId.setSequence(ii++);
                byId.setSequenceNumber(sequenceNumber);
                byId.setCreatedBy("三一集团WMS");
                taskHeaderService.updateById(byId);
                // 回传并执行任务
//                taskHeaderService.sendTaskToWcs(new Integer[]{byId.getId()});
                // 1.回传结束
                LambdaQueryWrapper<ReturnTask> returnTaskLambdaQueryWrapper = Wrappers.lambdaQuery();
                returnTaskLambdaQueryWrapper.eq(ReturnTask::getTaskNo, byId.getUserDef3());
                List<ReturnTask> list2 = returnTaskService.list(returnTaskLambdaQueryWrapper);
                if (list2 != null && list2.size() > 0) {
                    throw new ServiceException("回传任务已经存在了");
                }
                ReturnTask returnTaskDomain = new ReturnTask();
                returnTaskDomain.setReqID(byId.getUserDef2());
                returnTaskDomain.setTaskNo(byId.getUserDef3());
                returnTaskDomain.setTaskStatus(1);// 1代表开始 出库任务开始
                returnTaskDomain.setSendBack(0); // 0代表没回传
                returnTaskDomain.setContainerCode(byId.getContainerCode());
                if (byId.getZoneCode().equals("C")) {
                    returnTaskDomain.setContainerCode(list.get(0).getContainerCode());
                    returnTaskDomain.setVerlocation(taskDomain.getPalletInfoList().get(i).getContainerCode());
                }
                returnTaskService.save(returnTaskDomain);
            }
        }

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

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult WisCallEmptyContainer(TaskOffDomain taskDomain) {
        String reqID = taskDomain.getReqID();
        String taskNo = taskDomain.getTaskNo();
        String containerType = taskDomain.getContainerType();
        String toStnNo = taskDomain.getToStnNo();

        LambdaQueryWrapper<Container> containerLambdaQueryWrapper = Wrappers.lambdaQuery();
        containerLambdaQueryWrapper.eq(Container::getStatus, QuantityConstant.STATUS_CONTAINER_EMPTY).ne(Container::getLocationCode, "")
            .eq(Container::getContainerType, containerType).last(" limit 1");
        Container container = containerService.getOne(containerLambdaQueryWrapper);
        if (container == null) {
            return AjaxResult.error("没有找到容器");
        }
        String locationCode = container.getLocationCode();
        String contaienrCode = container.getCode();
        Location location = locationService.getLocationByCode(locationCode, container.getWarehouseCode());
        if (location == null) {
            return AjaxResult.error("没有找到库位");
        }
        AjaxResult ajaxResult = inventoryHeaderService.createEmptyOut(contaienrCode, locationCode, toStnNo);
        if (ajaxResult.hasErr()) {
            return ajaxResult;
        }
        int taskId = (Integer)ajaxResult.getData();
        TaskHeader taskHeader = taskHeaderService.getById(taskId);
        taskHeader.setUserDef2(reqID);
        taskHeader.setUserDef3(taskNo);
        boolean result = taskHeaderService.updateById(taskHeader);
        if (!result) {
            throw new ServiceException("更新任务失败");
        }
//        taskHeaderService.sendTaskToWcs(new Integer[]{taskId});
        ReturnTask returnTaskDomain = new ReturnTask();
        returnTaskDomain.setReqID(reqID);
        returnTaskDomain.setTaskNo(taskNo);
        returnTaskDomain.setTaskStatus(1);// 1代表开始 出库任务开始
        returnTaskDomain.setSendBack(0); // 0代表没回传
        returnTaskDomain.setContainerCode(contaienrCode);
        returnTaskService.save(returnTaskDomain);
        return AjaxResult.success("生成空托盘出库成功，托盘号为" + contaienrCode).setData(contaienrCode);
    }

    @Override
    public AjaxResult Reorder(TaskHeader task) {
        LambdaQueryWrapper<TaskHeader> wrapper = Wrappers.lambdaQuery();
        wrapper.eq(TaskHeader::getShipmentOrder, task.getShipmentOrder());
        List<TaskHeader> taskHeader = taskHeaderService.list(wrapper);
        // 排序//升序
        taskHeader.sort(Comparator.comparing(TaskHeader::getSequence));
        // taskHeader.sort(Comparator.comparing(TaskHeader::getSequence).reversed());//降序
        int i = 1;
        for (TaskHeader id : taskHeader) {
            id.setSequence(i++);
            id.setSequenceNumber(taskHeader.size());
            taskHeaderService.updateById(id);
        }
        // 重新赋值
        return AjaxResult.success("");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult reverseIssue(TaskDomain taskDomain) {
        long shipmentOrder = System.currentTimeMillis();
        int ii = 1;
        String cs = configService.getKey(QuantityConstant.VEHICLE_TYPE_CONFIG);
        if (taskDomain == null) {
            throw new ServiceException("wms下发任务为空");
        }
        // 1、判断必填字段是否满足
        if (taskDomain.getReqID() == null) {
            throw new ServiceException("wms任务号Id为空");
        }
        if (taskDomain.getTaskType() == null) {
            throw new ServiceException("wms任务类型为空");
        }
        for (int i = 0; i < taskDomain.getPalletInfoList().size(); i++) {
            LambdaQueryWrapper<InventoryDetail> wrappers = Wrappers.lambdaQuery();
            wrappers.eq(InventoryDetail::getContainerCode, taskDomain.getPalletInfoList().get(i).getContainerCode());
            List<InventoryDetail> lists = inventoryDetailService.list(wrappers);

            if (!taskDomain.getPalletInfoList().get(i).getContainerCode().contains("L")) {
                throw new ServiceException("非车架立库不能使用此接口");
            }
            for (int j = 0; j < lists.size(); j++) {
                if (!lists.get(j).getMaterialSpec().equals(lists.get(0).getMaterialSpec())) {
                    throw new ServiceException("数据有问题,不同种类的混料,特殊物料请维护数据,托盘号："+lists.get(0).getContainerCode());
                }
            }
            LambdaQueryWrapper<TaskHeader> taskHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            taskHeaderLambdaQueryWrapper.eq(TaskHeader::getUserDef3, taskDomain.getPalletInfoList().get(i).getTaskNo());
            if (taskHeaderService.getOne(taskHeaderLambdaQueryWrapper) != null) {
                throw new ServiceException("任务" + taskDomain.getPalletInfoList().get(i).getTaskNo() + "已存在");
            }
            if (taskDomain.getPalletInfoList().get(i).getContainerCode().contains("M") || taskDomain.getPalletInfoList().get(i).getContainerCode().contains("D")) {
                LambdaQueryWrapper<VehicleHeader> wrapper1 = Wrappers.lambdaQuery();
                wrapper1.eq(VehicleHeader::getUserDef1, taskDomain.getPalletInfoList().get(i).getVehicletype());
                VehicleHeader one = iVehicleHeaderService.getOne(wrapper1);
                if (one == null && Integer.valueOf(cs) == 1) {
                    throw new ServiceException("车型配置不存在");
                }
                for (int j = 0; j < taskDomain.getPalletInfoList().get(i).getInventoryList().size(); j++) {
                    List<InventoryDetail> list = new ArrayList<>();
                    LambdaQueryWrapper<InventoryDetail> wrapper = Wrappers.lambdaQuery();
                    wrapper.eq(InventoryDetail::getContainerCode, taskDomain.getPalletInfoList().get(i).getContainerCode());
                    list = inventoryDetailService.list(wrapper);
                    if (list == null || list.size() < 1) {
                        throw new ServiceException(taskDomain.getPalletInfoList().get(i).getContainerCode() + "容器库存不存在");
                    }
                    LambdaQueryWrapper<InventoryDetail> wrapper3 = Wrappers.lambdaQuery();
                    wrapper3.eq(InventoryDetail::getContainerCode, taskDomain.getPalletInfoList().get(i).getContainerCode())
                        .eq(InventoryDetail::getMaterialCode, taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getMaterialCode())
                        .ge(InventoryDetail::getQty, taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getQuantity());
                    InventoryDetail one2 = inventoryDetailService.getOne(wrapper3);
                    if (one2 == null) {
                        throw new ServiceException(taskDomain.getPalletInfoList().get(i).getContainerCode() + "容器的"
                            + taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getMaterialCode() + "数量超出");
                    }
                    if (Integer.valueOf(cs) == 1) {
                        LambdaQueryWrapper<VehicleDetail> wrapper2 = Wrappers.lambdaQuery();
                        wrapper2.eq(VehicleDetail::getVehicleId, one.getId()).eq(VehicleDetail::getCode,
                            taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getMaterialCode());
                        VehicleDetail one1 = iVehicleDetailService.getOne(wrapper2);
                        if (one1 == null) {
                            throw new ServiceException("此车型给的物料" + taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getMaterialCode() + "存在错误");
                        }
                    }
                }
            }
        }
        for (int i = 0; i < taskDomain.getPalletInfoList().size(); i++) {
            ShipmentHeader shipmentHeader = new ShipmentHeader();
            shipmentHeader.setCompanyCode("SANY");
            shipmentHeader.setShipmentType("OTF");
            shipmentHeader.setReferCode("");
            shipmentHeader.setReferPlatform("");
            shipmentHeaderService.saveHeader(shipmentHeader);
            if (taskDomain.getPalletInfoList().get(i).getInventoryList() == null || taskDomain.getPalletInfoList().get(i).getInventoryList().size() <= 0) {
                throw new ServiceException("没有物料信息");
            }
            List<InventoryDetail> list = new ArrayList<>();
            if (taskDomain.getPalletInfoList().get(i).getContainerCode().contains("L")) {
                // 如果是车架
                LambdaQueryWrapper<InventoryHeader> wrapper1 = Wrappers.lambdaQuery();
                wrapper1.eq(InventoryHeader::getContainerCode, taskDomain.getPalletInfoList().get(i).getContainerCode());
                InventoryHeader one = inventoryHeaderService.getOne(wrapper1);
                if (one == null) {
                    throw new ServiceException(taskDomain.getPalletInfoList().get(i).getContainerCode() + "的库存不存在");
                }
                LambdaQueryWrapper<InventoryDetail> wrapper2 = Wrappers.lambdaQuery();
                wrapper2.eq(InventoryDetail::getInventoryHeaderId, one.getId());
                list = inventoryDetailService.list(wrapper2);
                if (list == null && list.size() < 1) {
                    throw new ServiceException("库存不存在");
                }
            } else {
                // 如果是车桥
                LambdaQueryWrapper<InventoryDetail> wrapper = Wrappers.lambdaQuery();
                wrapper.eq(InventoryDetail::getContainerCode, taskDomain.getPalletInfoList().get(i).getContainerCode());
                list = inventoryDetailService.list(wrapper);
                if (list == null || list.size() < 1) {
                    throw new ServiceException(taskDomain.getPalletInfoList().get(i).getContainerCode() + "的库存不存在");
                }
            }
            for (int j = 0; j < list.size(); j++) {
                ShipmentDetail shipmentDetail = new ShipmentDetail();
                shipmentDetail.setShipmentId(shipmentHeader.getId());
                shipmentDetail.setCompanyCode("SANY");
                shipmentDetail.setShipmentCode(shipmentHeader.getCode());
                shipmentDetail.setMaterialCode(list.get(j).getMaterialCode());
                if (list.get(j).getTaskQty().intValue() >= 1) {
                    throw new ServiceException("此容器" + list.get(j).getContainerCode() + "上的物料有被预执行的");
                }
                shipmentDetail.setShipQty(list.get(j).getQty());
                shipmentDetail.setInventorySts(list.get(j).getInventorySts());
                shipmentDetailService.insertDetail(shipmentDetail);
            }
            LambdaQueryWrapper<ShipmentDetail> shipmentDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
            shipmentDetailLambdaQueryWrapper.eq(ShipmentDetail::getShipmentId, shipmentHeader.getId());
            List<ShipmentDetail> list1 = shipmentDetailService.list(shipmentDetailLambdaQueryWrapper);
            for (int j = 0; j < list.size(); j++) {
                ShipmentCombinationModel shipmentCombinationModel = new ShipmentCombinationModel();
                shipmentCombinationModel.setTaskType(0);
                shipmentCombinationModel.setShipQty(list.get(j).getQty());
                shipmentCombinationModel.setShipmentDetailId(list1.get(j).getId());
                shipmentCombinationModel.setInventoryDetailId(list.get(j).getId());
                // 组盘
                ShipmentContainerHeader shipmentContainerHeader = shipmentContainerHeaderService.combination(shipmentCombinationModel);
                ShipmentTaskCreateModel shipmentTask = new ShipmentTaskCreateModel();
                shipmentTask.setShipmentContainerHeaderIds(shipmentContainerHeader.getId());
                shipmentContainerHeader.getId();
            }
            LambdaQueryWrapper<ShipmentContainerHeader> receiptContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
            receiptContainerHeaderLambdaQueryWrapper.eq(ShipmentContainerHeader::getStatus, 0).eq(ShipmentContainerHeader::getContainerCode,
                taskDomain.getPalletInfoList().get(i).getContainerCode());
            ShipmentContainerHeader one1 = shipmentContainerHeaderService.getOne(receiptContainerHeaderLambdaQueryWrapper);
            if (one1 == null) {
                throw new ServiceException(taskDomain.getPalletInfoList().get(i).getContainerCode() + "的库存不存在");
            }
            String ids = "" + one1.getId();
            List<Integer> idList = Arrays.asList(Convert.toIntArray(ids));
            List<Integer> idsList = idList.stream().distinct().collect(Collectors.toList());
            for (Integer id : idsList) {
                LambdaQueryWrapper<ShipmentContainerHeader> shipmentContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
                shipmentContainerHeaderLambdaQueryWrapper.eq(ShipmentContainerHeader::getId, id);
                ShipmentContainerHeader shipmentContainerHeader1 = shipmentContainerHeaderService.getOne(shipmentContainerHeaderLambdaQueryWrapper);
                StationType stationType = new StationType();
                stationType.setType("2");
                stationType.setContainerCode("" + taskDomain.getPalletInfoList().get(i).getContainerCode());
                Map<String, Object> map = stationService.StationFromType(stationType);
                Object results = map.get("hhh");
                shipmentContainerHeader1.setPort("" + results);
                if (one1.getContainerType().equals("LS")) {
                    shipmentContainerHeader1.setPort(taskDomain.getPort());
                }
                if (Integer.valueOf(cs) == 1
                    && (shipmentContainerHeader1.getContainerType().equals("M") || shipmentContainerHeader1.getContainerType().equals("D"))) {
                    LambdaQueryWrapper<VehicleDetail> wrapper2 = Wrappers.lambdaQuery();
                    wrapper2.eq(VehicleDetail::getCode, taskDomain.getPalletInfoList().get(i).getInventoryList().get(0).getMaterialCode());
                    VehicleDetail one = iVehicleDetailService.getOne(wrapper2);
                    shipmentContainerHeader1.setPort(one.getPort());
                }
                shipmentContainerHeaderService.update(shipmentContainerHeader1, shipmentContainerHeaderLambdaQueryWrapper);
            }
            AjaxResult ajaxResult = new AjaxResult();
            Integer[] idList1 = Convert.toIntArray(ids);
            for (Integer id : idList1) {
                // 获取表头
                ShipmentContainerHeader shipmentContainerHeader1 = shipmentContainerHeaderService.getById(id);
                if (shipmentContainerHeader1 == null) {
                    throw new ServiceException("出库货箱id：" + id + "未找到,操作中止");
                }
                if (shipmentContainerHeader1.getStatus() >= QuantityConstant.TASK_STATUS_RELEASE) {
                    throw new ServiceException("出库货箱编码(" + shipmentContainerHeader1.getContainerCode() + ")已经生成任务，请不要重复生成，操作中止");
                }
            }
            ShipmentTaskCreateModel shipmentTask = new ShipmentTaskCreateModel();
            for (Integer id : idList1) {
                shipmentTask.setShipmentContainerHeaderIds(id);
                AjaxResult ajaxResult1 = shipmentTaskService.createTaskFromShipmentContainers(shipmentTask);
                if (ajaxResult1.hasErr()) {
                    throw new ServiceException(ajaxResult1.getMsg());
                }
                Integer integer = (Integer)ajaxResult1.getData();
                TaskHeader byId = taskHeaderService.getById(integer);
                byId.setUserDef2(taskDomain.getReqID());
                byId.setUserDef3(taskDomain.getPalletInfoList().get(i).getTaskNo());
                byId.setTaskType(QuantityConstant.TASK_TYPE_WHOLESHIPMENT);
                byId.setSort(1);
                byId.setPriority(9999);
                int sequenceNumber = taskDomain.getPalletInfoList().size();
                byId.setShipmentOrder(shipmentOrder - 1000000000);
                byId.setSequence(ii++);
                byId.setSequenceNumber(sequenceNumber);
                byId.setCreatedBy("三一集团WMS");
                taskHeaderService.updateById(byId);
                LambdaQueryWrapper<ReturnTask> returnTaskLambdaQueryWrapper = Wrappers.lambdaQuery();
                returnTaskLambdaQueryWrapper.eq(ReturnTask::getTaskNo, byId.getUserDef3());
                List<ReturnTask> list2 = returnTaskService.list(returnTaskLambdaQueryWrapper);
                if (list2 != null && list2.size() > 0) {
                    throw new ServiceException("回传任务已经存在了");
                }
                ReturnTask returnTaskDomain = new ReturnTask();
                returnTaskDomain.setReqID(byId.getUserDef2());
                returnTaskDomain.setTaskNo(byId.getUserDef3());
                // 1代表开始 出库任务开始
                returnTaskDomain.setTaskStatus(1);
                // 0代表没回传
                returnTaskDomain.setSendBack(0);
                returnTaskDomain.setContainerCode(byId.getContainerCode());
                if (byId.getZoneCode().equals("C")) {
                    returnTaskDomain.setContainerCode(list.get(0).getContainerCode());
                    returnTaskDomain.setVerlocation(taskDomain.getPalletInfoList().get(i).getContainerCode());
                }
                returnTaskService.save(returnTaskDomain);
            }
        }
        return AjaxResult.success("成功");
    }

    @Override
    public AjaxResult stationChangeTask(String port, String containerCode) {

        return inventoryHeaderService.Changetask(containerCode, port);
    }
}