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());
        // 校验参数
        validateTaskDomain(taskDomain);

        // 初始化变量
        List<TaskHeader> taskHeaderList = new ArrayList<>();
        int sequenceNumber = taskDomain.getPalletInfoList().size(); //明细列表数量
        long shipmentOrder = System.currentTimeMillis();//时间戳

        //如果是车架，根据巷道去重新分配托盘，如果在库存内有两个或超过两个巷道都有这个物料的话，根据上一个巷道，轮询分配1、2、3巷道出库，如果该物料只有某个巷道有，那就下一个物料继续轮询，巷道分配记录单独存放一个表
        //或者每次请求明细多的话，可以只在订单内分配，订单内5个要出库，巷道顺序就是1、2、3、1、2，如果某一个物料没有其他巷道，就分配当前巷道，下一个物料继续按顺序执行

        // 获取车辆类型配置：0表示默认按分区，1表示开启集团WMS车型对接，2表示本地车型
        String vehicleType = configService.getKey(QuantityConstant.VEHICLE_TYPE_CONFIG);

        // 遍历任务对象中的托盘信息列表
        for (int i = 0; i < taskDomain.getPalletInfoList().size(); i++) {
            // 上游任务号
            TaskHeader taskHeader = taskHeaderService.getOne(new LambdaQueryWrapper<TaskHeader>()
                    .eq(TaskHeader::getUserDef3, taskDomain.getPalletInfoList().get(i).getTaskNo()));

            // 如果任务已经存在，抛出异常
            if (taskHeader != null) {
                throw new ServiceException("任务" + taskDomain.getPalletInfoList().get(i).getTaskNo() + "已存在");
            }

            // 根据容器代码查询库存明细
            List<InventoryDetail> inventoryDetailList = inventoryDetailService.list(new LambdaQueryWrapper<InventoryDetail>().eq(InventoryDetail::getContainerCode, taskDomain.getPalletInfoList().get(i).getContainerCode()));

            // 检查容器中的库存物料是否是相同规格
            for (int j = 0; j < inventoryDetailList.size(); j++) {
                if (!inventoryDetailList.get(j).getMaterialSpec().equals(inventoryDetailList.get(0).getMaterialSpec())) {
                    throw new ServiceException("数据有问题,不同种类的混料,请维护数据,托盘号：" + inventoryDetailList.get(0).getContainerCode());
                }
            }

            // 检查托盘号是否包含“M”或“D”（车桥托盘）
            if (taskDomain.getPalletInfoList().get(i).getContainerCode().contains("M") || taskDomain.getPalletInfoList().get(i).getContainerCode().contains("D")) {
                // 查询对应的车型配置信息
                VehicleHeader vehicleHeader = iVehicleHeaderService.getOne(new LambdaQueryWrapper<VehicleHeader>()
                        .eq(VehicleHeader::getUserDef1, taskDomain.getPalletInfoList().get(i).getVehicletype())
                        .eq(VehicleHeader::getEnable, 1));

                // 如果车型配置不存在并且车辆类型为1，抛出异常
                if (vehicleHeader == null && Integer.parseInt(vehicleType) == 1) {
                    throw new ServiceException("车型配置或者没启动不存在");
                }

                // 校验库存是否满足任务需求
                for (int j = 0; j < taskDomain.getPalletInfoList().get(i).getInventoryList().size(); j++) {
                    List<InventoryDetail>  list = inventoryDetailService.list(new LambdaQueryWrapper<InventoryDetail>().eq(InventoryDetail::getContainerCode, taskDomain.getPalletInfoList().get(i).getContainerCode()));

                    // 如果库存不存在或为空，抛出异常
                    if (list == null || list.isEmpty()) {
                        throw new ServiceException("容器" + taskDomain.getPalletInfoList().get(i).getContainerCode() + "的库存"
                                + taskDomain.getPalletInfoList().get(i).getInventoryList().get(j).getMaterialCode() + "不存在");
                    }

                    // 如果车辆类型为1，进一步校验库存数量是否足够
                    if (Integer.parseInt(vehicleType) == 1) {
                        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).getInventoryList().get(j).getMaterialCode() + "数量超出");
                        }
                    }
                }
            }
        }




        //根据投产订单顺序排序
        List<palletInfo> palletInfoList = taskDomain.getPalletInfoList();//托盘明细列表
        palletInfoList = palletInfoList.stream().sorted((a1, a2) -> {
            String order1 = a1.getProductOrderSeq();//投产订单顺序
            String order2 = a2.getProductOrderSeq();
            if (StringUtils.isNotEmpty(order1) && StringUtils.isNotEmpty(order2)) {
                int inta1 = Integer.parseInt(order1);
                int inta2 = Integer.parseInt(order2);
                return inta1 - inta2;
            }
            return 0;
        }).collect(Collectors.toList());
        taskDomain.setPalletInfoList(palletInfoList);


        //托盘明细列表
        for (int i = 0; i < palletInfoList.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;

            // 如果是车架
            if (taskDomain.getPalletInfoList().get(i).getContainerCode().contains("L")) {
                InventoryHeader inventoryHeader = inventoryHeaderService.getOne(new LambdaQueryWrapper<InventoryHeader>().eq(InventoryHeader::getContainerCode, taskDomain.getPalletInfoList().get(i).getContainerCode()));
                if (inventoryHeader == null) {
                    throw new ServiceException(taskDomain.getPalletInfoList().get(i).getContainerCode() + "的库存不存在");
                }
                LambdaQueryWrapper<InventoryDetail> wrapper2 = Wrappers.lambdaQuery();
                wrapper2.eq(InventoryDetail::getInventoryHeaderId, inventoryHeader.getId());
                list = inventoryDetailService.list(wrapper2);
                if (list.isEmpty()) {
                    throw new ServiceException("库存不存在！");
                }
            } else { //如果是车桥
                LambdaQueryWrapper<InventoryDetail> wrapper = Wrappers.lambdaQuery();
                wrapper.eq(InventoryDetail::getContainerCode, taskDomain.getPalletInfoList().get(i).getContainerCode());
                list = inventoryDetailService.list(wrapper);
                if (list.isEmpty()) {
                    throw new ServiceException(taskDomain.getPalletInfoList().get(i).getContainerCode() + "的库存不存在");
                }
            }

            //出库单明细
            for (InventoryDetail inventoryDetail : list) {
                ShipmentDetail shipmentDetail = new ShipmentDetail();
                shipmentDetail.setShipmentId(shipmentHeader.getId());
                shipmentDetail.setCompanyCode("SANY");
                shipmentDetail.setShipmentCode(shipmentHeader.getCode());
                shipmentDetail.setMaterialCode(inventoryDetail.getMaterialCode());
                if (inventoryDetail.getTaskQty().intValue() >= 1) {
                    throw new ServiceException("此容器" + inventoryDetail.getContainerCode() + "上的物料有被预执行的");
                }
                shipmentDetail.setShipQty(inventoryDetail.getQty());
                shipmentDetail.setInventorySts(inventoryDetail.getInventorySts());
                shipmentDetailService.insertDetail(shipmentDetail);
            }


            List<ShipmentDetail> shipmentDetails = shipmentDetailService.list(new LambdaQueryWrapper<ShipmentDetail>().eq(ShipmentDetail::getShipmentId, shipmentHeader.getId()));
            for (int j = 0; j < list.size(); j++) {
                ShipmentCombinationModel shipmentCombinationModel = new ShipmentCombinationModel();
                shipmentCombinationModel.setTaskType(0);
                shipmentCombinationModel.setShipQty(list.get(j).getQty());
                shipmentCombinationModel.setShipmentDetailId(shipmentDetails.get(j).getId());
                shipmentCombinationModel.setInventoryDetailId(list.get(j).getId());
                // 组盘
                ShipmentContainerHeader shipmentContainerHeader = shipmentContainerHeaderService.combination(shipmentCombinationModel);
                ShipmentTaskCreateModel shipmentTask = new ShipmentTaskCreateModel();
                shipmentTask.setShipmentContainerHeaderIds(shipmentContainerHeader.getId());
                shipmentContainerHeader.getId();

            }
            // 根据托盘查询未完成的组盘信息
            ShipmentContainerHeader shipmentContainerHeader = shipmentContainerHeaderService.getOne(new LambdaQueryWrapper<ShipmentContainerHeader>()
                            .eq(ShipmentContainerHeader::getStatus, 0).eq(ShipmentContainerHeader::getContainerCode, taskDomain.getPalletInfoList().get(i).getContainerCode()));
            if (shipmentContainerHeader == null) {
                throw new ServiceException(taskDomain.getPalletInfoList().get(i).getContainerCode() + "组盘信息不存在");
            }

            // 获取组盘的ID，并去重
            String ids = "" + shipmentContainerHeader.getId();
            List<Integer> idList = Arrays.asList(Convert.toIntArray(ids));
            List<Integer> idsList = idList.stream().distinct().collect(Collectors.toList());

            for (Integer id : idsList) {
                // 创建查询条件，根据ID查询组盘头信息
                LambdaQueryWrapper<ShipmentContainerHeader> shipmentContainerHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
                shipmentContainerHeaderLambdaQueryWrapper.eq(ShipmentContainerHeader::getId, id);
                ShipmentContainerHeader shipmentContainerHeader1 = shipmentContainerHeaderService.getOne(shipmentContainerHeaderLambdaQueryWrapper);

                // 创建StationType对象用于查询出库口
                StationType stationType = new StationType(); // 出库口类型
                // 根据托盘类型判断出库口类型 //LS是车间托盘2，S是发动机托盘
                if (shipmentContainerHeader1.getContainerType().equals("LS") || shipmentContainerHeader1.getContainerType().equals("S")) {
                    stationType.setType("2"); // "2"表示整出
                } else {
                    stationType.setType("3"); // "3"表示可入可出
                }

                // 设置托盘编码，用于查询出库口
                stationType.setContainerCode("" + taskDomain.getPalletInfoList().get(i).getContainerCode());
                // 查询出库口信息
                Map<String, Object> map = stationService.StationFromType(stationType);
                Object results = map.get("hhh"); // 获取查询结果中的出库口代码
                shipmentContainerHeader1.setPort("" + results);

                // 如果是车间托盘（类型为LS），默认出库口为P2017
                if (shipmentContainerHeader.getContainerType().equals("LS")) {
                    shipmentContainerHeader1.setPort("P2017");
                }

                // 默认车型
                // 判断车型类型，若为1表示系统默认车型
                if (Integer.parseInt(vehicleType) == 1) {
                    // 如果托盘编码中包含"M"或"D"，则需要进一步验证车型配置
                    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);

                        // 查询车辆详细信息，根据物料编码和车辆ID
                        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()); // 设置出库口
                    }
                }

                // 如果车型类型为2，表示用户默认车型
                if (Integer.parseInt(vehicleType) == 2) {
                    // 查询用户默认车型的车辆头信息
                    LambdaQueryWrapper<VehicleHeader> wrapper1 = Wrappers.lambdaQuery();
                    wrapper1.eq(VehicleHeader::getDefaultParameters, 1);
                    List<VehicleHeader> headers = iVehicleHeaderService.list(wrapper1);

                    // 如果用户默认车型超过1个或不存在，抛出异常
                    if (headers.size() > 1) {
                        throw new ServiceException("状态2时默认车型过多请检查");
                    }
                    if (headers.isEmpty()) {
                        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()); // 设置出库口
                }

                // 更新组盘头信息，若更新失败抛出异常
                if (!shipmentContainerHeaderService.update(shipmentContainerHeader1, shipmentContainerHeaderLambdaQueryWrapper)) {
                    throw new ServiceException("状态2时 更新出库配盘头失败");
                }
            }

            // 转换并获取ID列表
            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() + ")已经生成任务，请不要重复生成，操作中止");
                }
            }

            List grouPing = new ArrayList();// 初始化分组信息的列表
            // 创建出库任务
            ShipmentTaskCreateModel shipmentTask = new ShipmentTaskCreateModel();
            for (Integer id : idList1) {
                // 设置当前出库任务对应的表头ID
                shipmentTask.setShipmentContainerHeaderIds(id);

                // 调用服务创建任务并返回结果
                AjaxResult ajaxResult1 = shipmentTaskService.createTaskFromShipmentContainers(shipmentTask);
                if (ajaxResult1.hasErr()) {
                    // 如果创建任务时出现错误，抛出异常并终止操作
                    throw new ServiceException(ajaxResult1.getMsg());
                }
                // 获取创建任务返回的任务ID
                Integer taskId = (Integer) ajaxResult1.getData();
                // 根据任务ID查询任务头信息
                TaskHeader taskHeader = taskHeaderService.getById(taskId);
                // 设置任务的顺序号，`i`为当前出库明细索引
                taskHeader.setSequence(i + 1);
                // 设置任务所属组内的任务数量
                taskHeader.setSequenceNumber(sequenceNumber);
                int sum = 0;
                int s = 0;

                // 遍历 `grouPing` 列表，检查当前任务的出库口是否已存在
                for (; s < grouPing.size(); s = s + 2) {
                    // 如果任务的出库口与 `grouPing` 中已有记录匹配
                    if (taskHeader.getPort().equals(grouPing.get(s))) {// 如果寻找全部list不存在,新增
                        sum++;
                        // 设置任务的出库顺序号
                        taskHeader.setShipmentOrder((Long) grouPing.get(s + 1));
                    }
                }

                // 如果 `grouPing` 中不存在当前任务的出库口
                if (sum == 0) {
                    // 将出库口添加到 `grouPing` 列表
                    grouPing.add(taskHeader.getPort());
                    // 将新的出库顺序号添加到 `grouPing` 列表
                    grouPing.add(shipmentOrder);
                    // 设置任务的出库顺序号为新增的出库顺序号
                    taskHeader.setShipmentOrder((Long) grouPing.get(grouPing.size() - 1));
                    // 更新出库顺序号，准备为下一个新的出库口使用
                    shipmentOrder++;
                }

                // 设置任务的关联请求ID
                taskHeader.setUserDef2(taskDomain.getReqID());
                // 设置任务的关联任务号
                taskHeader.setUserDef3(taskDomain.getPalletInfoList().get(i).getTaskNo());
                // 设置任务类型为整托出库
                taskHeader.setTaskType(QuantityConstant.TASK_TYPE_WHOLESHIPMENT);
                taskHeader.setCreatedBy("三一集团WMS");
                // 如果托盘的产品订单序列存在，则设置排序值
                if (StringUtils.isNotEmpty(taskDomain.getPalletInfoList().get(i).getProductOrderSeq())) {
                    taskHeader.setSort(Integer.valueOf(taskDomain.getPalletInfoList().get(i).getProductOrderSeq()));
                }
                // 更新任务头信息到数据库
                taskHeaderService.updateById(taskHeader);
                // 将当前任务头添加到任务头列表中
                taskHeaderList.add(taskHeader);
            }

            // 遍历 `grouPing` 列表，对任务头信息进行分组和排序
            for (int s = 0; s < grouPing.size(); s = s + 2) {
                // 创建一个新的任务头列表，用于存储当前出库口的任务
                List<TaskHeader> taskHeaderList1 = new ArrayList<>();
                // 遍历任务头列表，将与当前出库口匹配的任务头加入新列表
                for (TaskHeader header : taskHeaderList) {
                    if (grouPing.get(s).equals(header.getPort())) {
                        taskHeaderList1.add(header);
                    }
                }

                // 对新列表中的任务头按 `Sequence` 字段升序排序
                taskHeaderList1.sort(Comparator.comparing(TaskHeader::getSequence));
                // 重新设置任务头的顺序号
                int sequence = 1;
                for (TaskHeader header : taskHeaderList1) {
                    // 设置任务的顺序号
                    header.setSequence(sequence++);
                    // 设置当前分组任务的总数
                    header.setSequenceNumber(taskHeaderList1.size());
                    // 更新任务头信息到数据库
                    taskHeaderService.updateById(header);
                }
            }
        }
            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);
    }
}