wms / wms_ningxiangwanrong · Files

package com.huaheng.api.pda.service;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.huaheng.api.U8.service.U8ApiService;
import com.huaheng.api.general.domain.ReceiptDomain;
import com.huaheng.api.general.domain.ShipmentDomain;
import com.huaheng.api.general.service.ReceiptApiService;
import com.huaheng.api.general.service.ShipmentApiService;
import com.huaheng.api.mes.domain.Cartons;
import com.huaheng.api.mes.service.CartonsService;
import com.huaheng.api.pda.domain.ManualPalletizing;
import com.huaheng.api.pda.domain.PdaParameter;
import com.huaheng.api.pda.domain.ReceiptContainer;
import com.huaheng.api.pda.domain.ShipmentContainer;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.datasource.DynamicDataSource;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.pc.U8.domain.U8Inventory;
import com.huaheng.pc.U8.domain.U8ReceiptDetail;
import com.huaheng.pc.U8.domain.U8ReceiptHeader;
import com.huaheng.pc.U8.domain.U8StockTransfe;
import com.huaheng.pc.U8.service.U8InventoryService;
import com.huaheng.pc.U8.service.U8ReceiptDetailService;
import com.huaheng.pc.U8.service.U8ReceiptHeaderService;
import com.huaheng.pc.U8.service.U8StockTransfeService;
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.stacking.domain.Stacking;
import com.huaheng.pc.config.stacking.service.IStackingService;
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.CombinationModel;
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.task.taskDetail.domain.TaskDetail;
import com.huaheng.pc.task.taskDetail.service.TaskDetailService;
import com.huaheng.pc.task.taskHeader.domain.TaskHeader;
import com.huaheng.pc.task.taskHeader.service.ReceiptTaskService;
import com.huaheng.pc.task.taskHeader.service.TaskHeaderService;

/**
 * pda逻辑处理层
 * @author xcq
 */
@Service
public class PdaApiServiceImpl implements PdaApiService {
    @Resource
    private U8ReceiptHeaderService u8ReceiptHeaderService;
    @Resource
    private U8ReceiptDetailService u8ReceiptDetailService;
    @Resource
    private ReceiptApiService receiptApiService;
    @Resource
    private ShipmentApiService shipmentApiService;
    @Resource
    private ReceiptDetailService receiptDetailService;
    @Resource
    private ReceiptHeaderService receiptHeaderService;
    @Resource
    private U8InventoryService u8InventoryService;
    @Resource
    private ShipmentDetailService shipmentDetailService;
    @Resource
    private ShipmentHeaderService shipmentHeaderService;
    @Resource
    private InventoryDetailService inventoryDetailService;
    @Resource
    private ShipmentContainerHeaderService shipmentContainerHeaderService;
    @Resource
    private TaskHeaderService taskHeaderService;
    @Resource
    private U8StockTransfeService u8StockTransfeService;
    @Resource
    private ReceiptTaskService receiptTaskService;

    /**
     * 获取所有材料出库单
     * @return
     */
    @Override
    public AjaxResult getShipmentAllService() {
        LambdaQueryWrapper<ShipmentHeader> query = Wrappers.lambdaQuery();
        query.eq(ShipmentHeader::getShipmentType, QuantityConstant.RAW_MATERIAL).eq(ShipmentHeader::getCreatedBy, QuantityConstant.PLATFORM_MES)
            .le(ShipmentHeader::getLastStatus, QuantityConstant.SHIPMENT_HEADER_COMPLETED)
            .le(ShipmentHeader::getFirstStatus, QuantityConstant.SHIPMENT_HEADER_COMPLETED).orderByDesc(ShipmentHeader::getLastUpdated);
        List<ShipmentHeader> list = shipmentHeaderService.list(query);
        return AjaxResult.success("查询成功！", list);
    }

    /**
     * 获取所有材料入库单
     * @return
     */
    @Override
    public AjaxResult getReceiptAllService() {
        LambdaQueryWrapper<ReceiptHeader> query = Wrappers.lambdaQuery();
        query.eq(ReceiptHeader::getReceiptType, QuantityConstant.PRODUCTION_RETURN_MATERIAL_RECEIPT).eq(ReceiptHeader::getCreatedBy, QuantityConstant.PLATFORM_MES)
            .le(ReceiptHeader::getLastStatus, QuantityConstant.RECEIPT_HEADER_POSTING).le(ReceiptHeader::getFirstStatus, QuantityConstant.RECEIPT_HEADER_POSTING)
            .orderByDesc(ReceiptHeader::getLastUpdated);
        List<ReceiptHeader> list = receiptHeaderService.list(query);
        return AjaxResult.success("查询成功！", list);
    }

    /**
     * 通过送货单号创建出库单
     * @param  parameter
     * @return
     */
    @Override
    public AjaxResult createShipmentService(PdaParameter parameter) {
        if (parameter == null) {
            return AjaxResult.error("请勿发送空数据！");
        }
        if (StringUtils.isEmpty(parameter.getCode()) || StringUtils.isEmpty(parameter.getMaterialCode()) || StringUtils.isEmpty(parameter.getLot())
            || StringUtils.isEmpty(parameter.getQualityTestingCode()) || parameter.getQty() == null || parameter.getInventoryDetailId() == null) {
            return AjaxResult.error("采购订单号、物料编号、厂家批次号、质检单号、出库数量、库存id不能不能为空值！");
        }
        ShipmentDomain shipmentDomain = new ShipmentDomain();
        // 查询采购订单是否已经存在
        InventoryDetail inventoryDetail = inventoryDetailService.getById(parameter.getInventoryDetailId());
        if (inventoryDetail == null) {
            return AjaxResult.error("库存查询失败！");
        }
        // 判断库存数量是否大于出库数量
        if (inventoryDetail.getQty().compareTo(parameter.getQty()) == -1) {
            return AjaxResult.error("库存数量小于出库数量！");
        }
        // 创建入库单头表
        ShipmentHeader header = new ShipmentHeader();
        // 创建出库单详情
        List<ShipmentDetail> shipmentDetails = new ArrayList<>();
        try {
            // 切换至从库
            DynamicDataSource.slave();
            // 查询物料默认仓库
            LambdaQueryWrapper<U8Inventory> u8InventoryLambdaQueryWrapper = Wrappers.lambdaQuery();
            u8InventoryLambdaQueryWrapper.eq(U8Inventory::getCode, parameter.getMaterialCode());
            U8Inventory u8Inventory = u8InventoryService.getOne(u8InventoryLambdaQueryWrapper);
            if (u8Inventory == null) {
                return AjaxResult.error("该物料编码:" + parameter.getMaterialCode() + "在U8系统中查询失败！");
            }
            // 判断U8物料编码是否存在仓库字段
            String cWhCode;
            if (StringUtils.isEmpty(u8Inventory.getU8Warehouse())) {
                cWhCode = QuantityConstant.U8_GENERAL_MATERIAL_WAREHOUSE;
            } else {
                cWhCode = u8Inventory.getU8Warehouse();
            }
            // 通过erp数据查询到货单
            LambdaQueryWrapper<U8ReceiptHeader> lambda = Wrappers.lambdaQuery();
            lambda.eq(U8ReceiptHeader::getReferCode, parameter.getCode());
            U8ReceiptHeader u8ReceiptHeader = u8ReceiptHeaderService.getOne(lambda);
            if (u8ReceiptHeader == null) {
                return AjaxResult.error("采购订单查询失败！");
            }
            // 通过到货单号和物料编号查询到货单详情
            LambdaQueryWrapper<U8ReceiptDetail> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.eq(U8ReceiptDetail::getReferCode, parameter.getCode()).eq(U8ReceiptDetail::getMaterialCode, parameter.getMaterialCode());
            List<U8ReceiptDetail> u8ReceiptDetails = u8ReceiptDetailService.list(queryWrapper);
            if (u8ReceiptDetails.size() == 0) {
                return AjaxResult.error("查询采购订单号详情失败！");
            }
            // 设置单据类型为采购退货单
            header.setShipmentType(QuantityConstant.RETURN_RAW_MATERIALS);
            // 存储采购订单号
            header.setUserDef1(parameter.getCode());
            // 设置U8仓库编号
            header.setUserDef2(cWhCode);
            // 设置货主
            header.setCompanyCode(QuantityConstant.COMPANYCODE);
            // 设置仓库
            header.setWarehouseCode(QuantityConstant.WAREHOUSECODE);
            // 出库头表保存批次号
            header.setUserDef3(parameter.getLot());
            // 采购订单主表id
            header.setReferId(Integer.valueOf(u8ReceiptHeader.getReferId()));
            // 质检单号
            header.setShipmentNote(parameter.getQualityTestingCode());
            // 供应商编码
            header.setCarrierServer(u8ReceiptHeader.getSupplierCode());
            u8ReceiptDetails.forEach(item -> {
                ShipmentDetail shipmentDetail = new ShipmentDetail();
                // 数量
                shipmentDetail.setQty(parameter.getQty());
                // 物料编码
                shipmentDetail.setMaterialCode(item.getMaterialCode());
                // 货主
                shipmentDetail.setCompanyCode(QuantityConstant.COMPANYCODE);
                // 仓库编码
                shipmentDetail.setWarehouseCode(QuantityConstant.WAREHOUSECODE);
                // 制单人
                shipmentDetail.setCreatedBy(ShiroUtils.getUser().getUserName());
                // 采购单号
                shipmentDetail.setUserDef1(parameter.getCode());
                // 批次
                shipmentDetail.setBatch(parameter.getLot());
                // 采购订单子单id
                shipmentDetail.setUserDef2(item.getAutoId());
                // 库存状态
                shipmentDetail.setInventorySts(QuantityConstant.GOOD);
                // 装箱数量
                shipmentDetail.setAttribute4(u8Inventory.getPackingQty());
                shipmentDetails.add(shipmentDetail);
            });
        } catch (Exception e) {
            e.printStackTrace();
            return AjaxResult.error(e.getMessage());
        } finally {
            // 切换至主库
            DynamicDataSource.master();
        }
        shipmentDomain.setShipmentHeader(header);
        shipmentDomain.setShipmentDetails(shipmentDetails);
        AjaxResult result = shipmentApiService.shipment(shipmentDomain);
        if (result.hasErr()) {
            return result;
        }
        result = shipmentHeaderService.autoCompleteShipmentTasks(shipmentDomain, parameter);
        return result;
    }

    /**
     * 通过送货单号创建入库
     * @param  parameter
     * @return
     */
    @Override
    public AjaxResult createReceiptService(PdaParameter parameter) {
        if (parameter == null) {
            return AjaxResult.error("请勿发送空数据！");
        }
        String code = parameter.getCode();
        String batch = parameter.getLot();
        String materialCode = parameter.getMaterialCode();;
        ReceiptDomain receiptDomain = new ReceiptDomain();
        if (StringUtils.isEmpty(code) || StringUtils.isEmpty(batch) || StringUtils.isEmpty(materialCode)) {
            return AjaxResult.error("到货单号、批次或物料编号不能为空！");
        }
        // 查询到货单是否已经存在
        LambdaQueryWrapper<ReceiptDetail> lambdaQuery = Wrappers.lambdaQuery();
        lambdaQuery.eq(ReceiptDetail::getUserDef1, code).eq(ReceiptDetail::getBatch, batch).eq(ReceiptDetail::getMaterialCode, materialCode);
        List<ReceiptDetail> receiptDetails = receiptDetailService.list(lambdaQuery);
        List<ReceiptDetail> temp = new ArrayList<>();
        for (ReceiptDetail receiptDetail : receiptDetails) {
            if (!QuantityConstant.RECEIPT_HEADER_RETURN.equals(receiptDetail.getStatus())) {
                temp.add(receiptDetail);
            }
        }
        if (temp.size() > 0) {
            LambdaQueryWrapper<ReceiptHeader> headerLambdaQueryWrapper = Wrappers.lambdaQuery();
            headerLambdaQueryWrapper.eq(ReceiptHeader::getCode, temp.get(0).getReceiptCode());
            ReceiptHeader receiptHeader = receiptHeaderService.getOne(headerLambdaQueryWrapper);
            receiptDomain.setReceiptHeader(receiptHeader);
            receiptDomain.setReceiptDetails(temp);
            AjaxResult result = AjaxResult.success("入库单已存在！");
            result.setData(receiptDomain);
            return result;
        }
        // 创建入库单头表
        ReceiptHeader header = new ReceiptHeader();
        // 创建入库单详情
        List<ReceiptDetail> receiptDetailList = new ArrayList<>();
        try {
            // 切换至从库
            DynamicDataSource.slave();
            // 查询物料默认仓库
            LambdaQueryWrapper<U8Inventory> u8InventoryLambdaQueryWrapper = Wrappers.lambdaQuery();
            u8InventoryLambdaQueryWrapper.eq(U8Inventory::getCode, materialCode);
            U8Inventory u8Inventory = u8InventoryService.getOne(u8InventoryLambdaQueryWrapper);
            if (u8Inventory == null) {
                return AjaxResult.error("该物料编码:" + materialCode + "在U8系统中查询失败！");
            }
            // 判断U8物料编码是否存在仓库字段
            String cWhCode;
            if (StringUtils.isEmpty(u8Inventory.getU8Warehouse())) {
                cWhCode = QuantityConstant.U8_GENERAL_MATERIAL_WAREHOUSE;
            } else {
                cWhCode = u8Inventory.getU8Warehouse();
            }
            // 通过erp数据查询到货单
            LambdaQueryWrapper<U8ReceiptHeader> lambda = Wrappers.lambdaQuery();
            lambda.eq(U8ReceiptHeader::getReferCode, code);
            U8ReceiptHeader u8ReceiptHeader = u8ReceiptHeaderService.getOne(lambda);
            if (u8ReceiptHeader == null) {
                return AjaxResult.error("采购订单查询失败！");
            }
            // 通过到货单号和物料编号查询到货单详情
            LambdaQueryWrapper<U8ReceiptDetail> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.eq(U8ReceiptDetail::getReferCode, code).eq(U8ReceiptDetail::getMaterialCode, materialCode);
            List<U8ReceiptDetail> u8ReceiptDetails = u8ReceiptDetailService.list(queryWrapper);
            if (u8ReceiptDetails.size() == 0) {
                return AjaxResult.error("查询采购订单号详情失败！");
            }
            // 设置单据类型为采购入库单
            header.setReceiptType(QuantityConstant.PURCHASE_RECEIPT_DOC);
            // 存储采购订单号
            header.setUserDef1(code);
            // 设置U8仓库编号
            header.setUserDef2(cWhCode);
            // 设置货主
            header.setCompanyCode(QuantityConstant.COMPANYCODE);
            // 设置仓库
            header.setWarehouseCode(QuantityConstant.WAREHOUSECODE);
            // 供应商编码
            header.setSupplierCode(u8ReceiptHeader.getSupplierCode());
            // 入库头表保存批次号
            header.setUserDef3(batch);
            // 采购订单主表id
            header.setReferId(Integer.valueOf(u8ReceiptHeader.getReferId()));
            u8ReceiptDetails.forEach(item -> {
                ReceiptDetail receiptDetail = new ReceiptDetail();
                // 数量
                if (item.getQty().compareTo(item.getTaskQty()) <= 0) {
                    receiptDetail.setQty(BigDecimal.ONE);
                } else {
                    receiptDetail.setQty(item.getQty().subtract(item.getTaskQty()));
                }
                // 物料编码
                receiptDetail.setMaterialCode(item.getMaterialCode());
                // 货主
                receiptDetail.setCompanyCode(QuantityConstant.COMPANYCODE);
                // 仓库编码
                receiptDetail.setWarehouseCode(QuantityConstant.WAREHOUSECODE);
                // 制单人
                receiptDetail.setCreatedBy(ShiroUtils.getUser().getUserName());
                // 采购单号
                receiptDetail.setUserDef1(code);
                // 批次
                receiptDetail.setBatch(batch);
                // 采购订单子单id
                receiptDetail.setUserDef2(item.getAutoId());
                // 库存状态
                receiptDetail.setInventorySts(QuantityConstant.GOOD);
                // 装箱数量
                receiptDetail.setAttribute4(u8Inventory.getPackingQty());
                receiptDetailList.add(receiptDetail);
            });
        } catch (Exception e) {
            e.printStackTrace();
            return AjaxResult.error(e.getMessage());
        } finally {
            // 切换至主库
            DynamicDataSource.master();
        }
        receiptDomain.setReceiptHeader(header);
        receiptDomain.setReceiptDetails(receiptDetailList);
        AjaxResult result = receiptApiService.receipt(receiptDomain);
        if (result.hasErr()) {
            return result;
        }
        result.setData(receiptDomain);
        return result;
    }

    @Resource
    private LocationService locationService;
    @Resource
    private ContainerService containerService;

    /**
     * pda获取容器编码
     * @param  locationCode 库位编码
     * @return
     */
    @Override
    public AjaxResult getContainerCodeService(String locationCode) {
        if (StringUtils.isEmpty(locationCode)) {
            return AjaxResult.error("库位编码不能为空！");
        }
        // 查询平库库位编码
        LambdaQueryWrapper<Location> lambdaQuery = Wrappers.lambdaQuery();
        lambdaQuery.eq(Location::getCode, locationCode).eq(Location::getZoneCode, QuantityConstant.FLAT_LOCATION_CODE);
        Location location = locationService.getOne(lambdaQuery);
        if (location == null) {
            return AjaxResult.error("库位查询失败！,请检查库位编码是否正确！");
        }
        // 通过库位查询托盘
        LambdaQueryWrapper<Container> containerLambdaQueryWrapper = Wrappers.lambdaQuery();
        containerLambdaQueryWrapper.eq(Container::getCode, location.getContainerCode());
        Container container = containerService.getOne(containerLambdaQueryWrapper);
        AjaxResult result = AjaxResult.success("容器分配成功！");
        if (container == null) {
            // 托盘不存在系统自动分配托盘
            LambdaQueryWrapper<Container> wrapper = Wrappers.lambdaQuery();
            wrapper.eq(Container::getStatus, QuantityConstant.STATUS_CONTAINER_EMPTY).isNull(Container::getLocationCode)
                .eq(Container::getContainerType, QuantityConstant.VIRTUAL_CONTAINER).last(" limit 1");
            container = containerService.getOne(wrapper);
        }
        if (container == null) {
            LambdaQueryWrapper<Container> wrapper = Wrappers.lambdaQuery();
            wrapper.eq(Container::getStatus, QuantityConstant.STATUS_CONTAINER_EMPTY).eq(Container::getLocationCode, "")
                .eq(Container::getContainerType, QuantityConstant.VIRTUAL_CONTAINER).last(" limit 1");
            container = containerService.getOne(wrapper);
        }
        result.setData(container);
        return result;
    }

    @Resource
    private U8ApiService u8ApiService;

    @Override
    public AjaxResult receiptEchoServer(ReceiptHeader receiptHeader) {
        if (receiptHeader == null) {
            return AjaxResult.error("请勿提交空数据！");
        }
        if (receiptHeader.getId() == null) {
            return AjaxResult.error("头表id不能为空！");
        }
        return u8ApiService.sendPurchaseWarehousingList(receiptHeader);
    }

    @Override
    public AjaxResult shipmentEchoServer(ShipmentHeader shipmentHeader) {
        if (shipmentHeader == null) {
            return AjaxResult.error("请勿提交空数据！");
        }
        if (shipmentHeader.getId() == null) {
            return AjaxResult.error("头表id不能为空！");
        }
        return u8ApiService.sendPurchaseShipmentWarehousingList(shipmentHeader);
    }

    /**
     * pda调拨出库实现方法
     * @param  code
     * @return
     */
    @Override
    public AjaxResult stockTransferShipmentServer(String code) {
        if (StringUtils.isEmpty(code)) {
            return AjaxResult.error("调拨单号不能为空值！");
        }
        List<U8StockTransfe> u8StockTransfes = new ArrayList<>();
        // 查询erp调拨单
        try {
            // 切换至从库
            DynamicDataSource.slave();
            LambdaQueryWrapper<U8StockTransfe> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.eq(U8StockTransfe::getCode, code);
            u8StockTransfes = u8StockTransfeService.list(queryWrapper);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 切换至主库
            DynamicDataSource.master();
        }
        if (u8StockTransfes.size() == 0) {
            return AjaxResult.error("查询调拨单号失败！");
        }
        // 查询调拨单号是否已经存在
        LambdaQueryWrapper<ShipmentHeader> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(ShipmentHeader::getReferCode, code);
        ShipmentHeader header = shipmentHeaderService.getOne(queryWrapper);
        AjaxResult result = new AjaxResult();
        if (header != null) {
            result = AjaxResult.success("调拨单已存在");
            LambdaQueryWrapper<ShipmentDetail> query = Wrappers.lambdaQuery();
            query.eq(ShipmentDetail::getShipmentCode, header.getCode());
            List<ShipmentDetail> list = shipmentDetailService.list(query);
            ShipmentDomain domain = new ShipmentDomain();
            domain.setShipmentHeader(header);
            domain.setShipmentDetails(list);
            result.setData(domain);
            return result;
        }
        return shipmentHeaderService.createStockTransferShipment(u8StockTransfes, code);
    }

    @Resource
    private TaskDetailService taskDetailService;
    @Resource
    private InventoryHeaderService inventoryHeaderService;
    @Resource
    private ReceiptContainerDetailService receiptContainerDetailService;
    @Resource
    private ReceiptContainerHeaderService receiptContainerHeaderService;

    /**
     * pda完成入库任务
     * @param  taskHeader
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult completeReceiptTaskServer(TaskHeader taskHeader) {
        if (taskHeader == null) {
            return AjaxResult.error("请勿提交空数据！");
        }
        String containerCode = taskHeader.getContainerCode();
        if (taskHeader.getId() == null || StringUtils.isEmpty(containerCode) || StringUtils.isEmpty(taskHeader.getToLocation())) {
            return AjaxResult.error("任务id或容器编码或库位编码不能为空值！");
        }
        LambdaQueryWrapper<TaskHeader> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(TaskHeader::getId, taskHeader.getId()).eq(TaskHeader::getContainerCode, taskHeader.getContainerCode());
        TaskHeader task = taskHeaderService.getOne(queryWrapper);
        if (task == null) {
            return AjaxResult.error("请确定容器编码:" + containerCode + "和任务id:" + taskHeader.getId() + "是否匹配!");
        }
        // 查询库位编码是否存在
        LambdaQueryWrapper<Location> query = Wrappers.lambdaQuery();
        query.eq(Location::getCode, taskHeader.getToLocation());
        Location location = locationService.getOne(query);
        if (location == null) {
            return AjaxResult.error("库位编码：" + taskHeader.getToLocation() + "不存在！");
        }
        if (!QuantityConstant.FLAT_LOCATION_CODE.equals(location.getZoneCode())) {
            return AjaxResult.error("只允许使用平库库位！");
        }
        // 查询托盘库存是否已经存在
        LambdaQueryWrapper<InventoryHeader> headerLambdaQueryWrapper = Wrappers.lambdaQuery();
        headerLambdaQueryWrapper.eq(InventoryHeader::getContainerCode, containerCode);
        InventoryHeader inventoryHeader = inventoryHeaderService.getOne(headerLambdaQueryWrapper);
        if (inventoryHeader != null) {
            return AjaxResult.error("托盘编码：" + containerCode + "已入库，不允许重复入库！");
        }

        task.setToLocation(taskHeader.getToLocation());
        task.setZoneCode(QuantityConstant.FLAT_LOCATION_CODE);
        task.setPreTaskNo(0);
        // 修改库位
        taskHeaderService.updateById(task);
        // 修改任务详情
        LambdaQueryWrapper<TaskDetail> lambdaQuery = Wrappers.lambdaQuery();
        lambdaQuery.eq(TaskDetail::getTaskId, task.getId());
        List<TaskDetail> taskDetailList = taskDetailService.list(lambdaQuery);
        if (taskDetailList.size() == 0) {
            return AjaxResult.error("查询入库任务详情失败！");
        }
        taskDetailList.forEach(item -> {
            item.setToLocation(taskHeader.getToLocation());
        });
        taskDetailService.updateBatchById(taskDetailList);
        /* 循环查询入库组盘明细 */
        List<ReceiptContainerDetail> receiptContainerDetailList = new ArrayList<>();
        for (TaskDetail taskDetail : taskDetailList) {
            ReceiptContainerDetail receiptContainerDetail = receiptContainerDetailService.getById(taskDetail.getAllocationId());
            if (receiptContainerDetail != null) {
                receiptContainerDetailList.add(receiptContainerDetail);
            }
        }
        // 把库位编码赋到该入库组盘头表下的所有明细
        if (receiptContainerDetailList != null && receiptContainerDetailList.size() > 0) {
            receiptContainerDetailList.forEach(item -> {
                item.setLocationCode(taskHeader.getToLocation());
            });
            receiptContainerDetailService.updateBatchById(receiptContainerDetailList);
            // 更新库位编码到组盘头表
            ReceiptContainerHeader receiptContainerHeader = receiptContainerHeaderService.getById(receiptContainerDetailList.get(0).getReceiptContainerId());
            if (receiptContainerHeader != null) {
                receiptContainerHeader.setToLocation(taskHeader.getToLocation());
                receiptContainerHeaderService.updateById(receiptContainerHeader);
            }
        }
        // 完成入库任务
        Integer[] ids = new Integer[1];
        ids[0] = task.getId();
        return taskHeaderService.completeTaskByWMS(ids, null);
    }

    /**
     * 创建销售退货单实现层
     * @param  receiptDomain
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult createSalesReturnNoteServer(ReceiptDomain receiptDomain) {
        if (receiptDomain == null) {
            return AjaxResult.error("请勿提交空数据！");
        }
        String containerCode = receiptDomain.getContainerCode();
        ReceiptHeader receiptHeader = receiptDomain.getReceiptHeader();
        // 单据类型
        receiptHeader.setReceiptType(QuantityConstant.SALES_RETURN_NOTE);
        receiptHeader.setWarehouseCode(QuantityConstant.WAREHOUSECODE);
        receiptHeader.setCompanyCode(QuantityConstant.COMPANYCODE);
        List<ReceiptDetail> receiptDetails = receiptDomain.getReceiptDetails();
        for (ReceiptDetail receiptDetail : receiptDetails) {
            if (StringUtils.isEmpty(receiptDetail.getMaterialCode())) {
                return AjaxResult.error("物料编码不能为空！");
            }
            if (BigDecimal.ZERO.compareTo(receiptDetail.getQty()) == 0) {
                return AjaxResult.error("单据数量不能为0");
            }
            receiptDetail.setWarehouseCode(QuantityConstant.WAREHOUSECODE);
            receiptDetail.setCompanyCode(QuantityConstant.COMPANYCODE);
        }
        // 创建入库单
        receiptDomain.setReceiptHeader(receiptHeader);
        receiptDomain.setReceiptDetails(receiptDetails);
        AjaxResult ajaxResult = receiptApiService.receipt(receiptDomain);
        if (ajaxResult.hasErr()) {
            return ajaxResult;
        }
        // 进行入库组盘
        List<Integer> receiptContainerHeaderIds = new ArrayList<>();
        for (ReceiptDetail receiptDetail : receiptDomain.getReceiptDetails()) {
            ajaxResult = receiptContainerHeaderService.saveContainer(receiptDomain.getReceiptHeader().getCode(), containerCode, receiptDetail.getId(), null,
                receiptDetail.getQty(), null);
            if (ajaxResult.hasErr()) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return ajaxResult;
            }
            Integer receiptContainerHeaderId = (Integer)ajaxResult.getData();
            receiptContainerHeaderIds.add(receiptContainerHeaderId);
        }
        // 批量创建入库任务
        ajaxResult = receiptTaskService.createReceiptTask(receiptContainerHeaderIds.stream().distinct().collect(Collectors.toList()));
        if (ajaxResult.hasErr()) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return ajaxResult;
        }
        return AjaxResult.success("入库单创建成功！");
    }

    @Resource
    private CartonsService cartonsService;
    @Resource
    private IStackingService stackingService;

    /**
     * pda人工码垛接口
     * @param  pdaParameter
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult manualPalletizingServer(PdaParameter pdaParameter) {
        if (pdaParameter == null) {
            return AjaxResult.error("请勿提交空数据！");
        }
        List<ManualPalletizing> parameter = pdaParameter.getManualPalletizings();
        String containerCode = pdaParameter.getContainerCode();
        if (StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("托盘码不能为空！");
        }
        // 根据托盘查询入库任务是否已经存在
        if (taskHeaderService.UncompleteCount(containerCode) > 0) {
            return AjaxResult.error("该托盘码：" + containerCode + "入库任务已存在，请勿重复创建！");
        }
        List<Cartons> cartonsList = new ArrayList<>();
        for (ManualPalletizing item : parameter) {
            if (StringUtils.isEmpty(item.getBoxCode())) {
                return AjaxResult.error("纸箱编码不能为空！");
            }
            LambdaQueryWrapper<Cartons> query = Wrappers.lambdaQuery();
            query.eq(Cartons::getCode, item.getBoxCode());
            Cartons cartons = cartonsService.getOne(query);
            if (cartons == null) {
                return AjaxResult.error("该纸箱唯一码:" + item.getBoxCode() + "不存在！");
            }
            cartons.setQty(item.getQty());
            // 修改状态为码垛成功
            cartons.setState(QuantityConstant.CARTONS_RECEIPT_SUCCESS);
            cartonsList.add(cartons);
        }
        // 修改纸箱数量
        cartonsService.updateBatchById(cartonsList);
        // 查询码垛数据
        LambdaQueryWrapper<Stacking> stackingLambdaQuery = Wrappers.lambdaQuery();
        stackingLambdaQuery.eq(Stacking::getPort, cartonsList.get(0).getStackingPort());
        Stacking stacking = stackingService.getOne(stackingLambdaQuery);
        // 修改码垛数据
        if (stacking != null) {
            stacking.setOrderCode("");
            // 最大码垛数量初始化
            stacking.setMaxQty(0);
            // 将当前码垛数量清零
            stacking.setCurrentQty(0);
            // 清空当前托盘编码
            stacking.setContainerCode("");
            // 当前物料编码清空
            stacking.setMaterialCode("");
            stackingService.updateById(stacking);
        }

        // 创建入库单
        AjaxResult result = stackingService.createReceipt(cartonsList, containerCode, cartonsList.get(0).getOrderCode());
        if (result.hasErr()) {
            return result;
        }
        ReceiptDomain receiptDomain = (ReceiptDomain)result.getData();
        BigDecimal qty = receiptDomain.getReceiptHeader().getTotalQty();
        // 生成入库组盘
        result = receiptContainerHeaderService.saveContainer(receiptDomain.getReceiptHeader().getCode(), containerCode,
            receiptDomain.getReceiptDetails().get(0).getId(), "", qty, "");
        if (result.hasErr()) {
            return result;
        }
        List<Integer> ids = new ArrayList<>();
        ids.add(Integer.valueOf(result.getData().toString()));
        // 生成任务
        return receiptTaskService.createReceiptTask(ids.stream().distinct().collect(Collectors.toList()));

//        if (boxCodes != null && boxCodes.size() > 0 && StringUtils.isNotEmpty(containerCode)){
//            // 去重后在进行查询
//            boxCodes = boxCodes.stream().distinct().collect(Collectors.toList());
//            // 查询所有纸箱数据
//            LambdaQueryWrapper<Cartons> query = Wrappers.lambdaQuery();
//            query.in(Cartons::getCode, boxCodes);
//            List<Cartons> cartonsList = cartonsService.list(query);
//            if (cartonsList.size() == 0){
//                throw new SecurityException("查询码垛纸箱失败！");
//            }
//            if (cartonsList.size() != boxCodes.size()){
//                return AjaxResult.error("部分纸箱数据查询失败，请检查mes是否有部分纸箱数据未推送！");
//            }
//        }
//        return AjaxResult.error("请勿提交空数据！");
    }

    /**
     * 通过托盘查询入库单详情
     * @param  containerCode
     * @return
     */
    @Override
    public AjaxResult getReceiptServer(String containerCode) {
        if (StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("托盘码不能为空值！");
        }
        LambdaQueryWrapper<ReceiptDetail> query = Wrappers.lambdaQuery();
        query.eq(ReceiptDetail::getUserDef3, containerCode);
        List<ReceiptDetail> receiptDetailList = receiptDetailService.list(query);
        if (receiptDetailList.size() == 0) {
            return AjaxResult.error("通过托盘码查询入库单失败！");
        }
        // 查询入库单主表
        LambdaQueryWrapper<ReceiptHeader> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(ReceiptHeader::getId, receiptDetailList.get(0).getReceiptId());
        ReceiptHeader receiptHeader = receiptHeaderService.getOne(queryWrapper);
        ReceiptDomain receiptDomain = new ReceiptDomain();
        receiptDomain.setReceiptDetails(receiptDetailList);
        receiptDomain.setReceiptHeader(receiptHeader);
        AjaxResult result = AjaxResult.success("入库单查询成功！");
        result.setData(receiptDomain);
        return result;
    }

    /**
     * 查询库存
     * @param  locationCode 地码
     * @return
     */
    @Override
    public AjaxResult selectInventoryServer(String locationCode) {
        LambdaQueryWrapper<InventoryDetail> query = Wrappers.lambdaQuery();
        if (StringUtils.isEmpty(locationCode)) {
            query.eq(InventoryDetail::getZoneCode, QuantityConstant.FLAT_LOCATION_CODE);
        } else {
            query.eq(InventoryDetail::getLocationCode, locationCode);
        }
        List<InventoryDetail> inventoryDetailList = inventoryDetailService.list(query);
        AjaxResult result = AjaxResult.success();
        result.setData(inventoryDetailList);
        return result;
    }

    /**
     * pda入库组盘
     * @param  receiptContainerList
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult createReceiptContainerServer(List<ReceiptContainer> receiptContainerList) {
        if (receiptContainerList.size() == 0) {
            return AjaxResult.error("入库组盘数据不能为空！");
        }
        AjaxResult result = new AjaxResult();
        List<ReceiptDetail> receiptDetailList = new ArrayList<>();
        List<Integer> receiptDetailIds = new ArrayList<>();
        List<Integer> ids = new ArrayList<>();
        for (ReceiptContainer receiptContainer : receiptContainerList) {
            String receiptCode = receiptContainer.getReceiptCode();
            if (StringUtils.isEmpty(receiptCode)) {
                return AjaxResult.error("入库单编码不能为空！");
            }
            Integer receiptDetailId = receiptContainer.getReceiptDetailId();
            if (receiptDetailId == null) {
                return AjaxResult.error("入库单详情id不能为空！");
            }
            receiptDetailIds.add(receiptDetailId);
            String locationCode = receiptContainer.getLocationCode();
            if (StringUtils.isEmpty(locationCode)) {
                return AjaxResult.error("库位编码不能为空！");
            }
            result = this.getContainerCodeService(locationCode);
            if (result.hasErr()) {
                return result;
            }
            Container container = (Container)result.getData();
            BigDecimal qty = receiptContainer.getQty();
            // 入库组盘
            result = receiptContainerHeaderService.saveContainer(receiptCode, container.getCode(), receiptDetailId, locationCode, qty, null);
            if (result.hasErr()) {
                return result;
            }
            ids.add(Integer.valueOf(result.getData().toString()));
        }
        // 批量生成入库任务
        result = receiptTaskService.createReceiptTask(ids.stream().distinct().collect(Collectors.toList()));
        if (result.hasErr()) {
            return result;
        }
        List<String> taskIds = (List<String>)result.getData();
        Integer[] temp = new Integer[taskIds.size()];
        for (int i = 0; i < taskIds.size(); i++) {
            temp[i] = Integer.valueOf(taskIds.get(i));
        }
        // 批量入库任务完成
        return taskHeaderService.completeTaskByWMS(temp, null);
//
//        if (result.hasErr()) {
//            return result;
//        }
//        // 查询入库单详情是否完成
//        LambdaQueryWrapper<ReceiptDetail> query = Wrappers.lambdaQuery();
//        query.in(ReceiptDetail::getId, receiptDetailIds);
//        receiptDetailList = receiptDetailService.list(query);
//        if (receiptContainerList.size() == 0) {
//            return AjaxResult.error("入库单查询失败！");
//        }
//        // 批量修改入库单详情
//        receiptDetailList.forEach(item -> {
//            if (item.getQty().compareTo(item.getTaskQty()) == 0) {
//                // 将托盘码从入库单详情中删除
//                item.setUserDef3("");
//            }
//        });
//        receiptDetailService.updateBatchById(receiptDetailList);
//        result.setMsg("入库任务完成！");
//        return result;
    }

    /**
     * 根据纸箱编码查询纸箱数据
     * @param  code
     * @return
     */
    @Override
    public AjaxResult findCartonsServer(String code) {
        if (StringUtils.isEmpty(code)) {
            return AjaxResult.error("纸箱编码不能为空！");
        }
        Cartons cartons = new Cartons();
        cartons.setCode(code);
        cartons = cartonsService.selectByCartons(cartons);
        if (cartons == null) {
            return AjaxResult.error("该纸箱数据不存在！");
        }
        if (QuantityConstant.CARTONS_PALLETIZING_SUCCESS.equals(cartons.getState())) {
            return AjaxResult.success("纸箱数据推送成功！", cartons);
        }
        if (QuantityConstant.CARTONS_RECEIPT_SUCCESS.equals(cartons.getState())) {
            return AjaxResult.error("该纸箱编码：" + cartons.getCode() + "已经创建入库任务，请勿重复扫码！");
        }
        // 修改纸箱状态
        cartons.setState(QuantityConstant.CARTONS_PALLETIZING_SUCCESS);
        cartonsService.updateById(cartons);
        // 查询码垛位
        LambdaQueryWrapper<Stacking> stackingLambdaQuery = Wrappers.lambdaQuery();
        stackingLambdaQuery.eq(Stacking::getPort, cartons.getStackingPort());
        Stacking stacking = stackingService.getOne(stackingLambdaQuery);
        // 修改码垛数量，只能修改人工码垛位置
        if (stacking != null && (QuantityConstant.ABNORMAL_PALLETIZING_POSITION1.equals(stacking.getPort())
            || QuantityConstant.ABNORMAL_PALLETIZING_POSITION2.equals(stacking.getPort()))) {
            stacking.setCurrentQty(stacking.getCurrentQty() == 0 ? 1 : stacking.getCurrentQty() + 1);
            stackingService.updateById(stacking);
        }
        return AjaxResult.success("纸箱数据推送成功！", cartons);
    }

    /**
     * 原材料出库实现方法
     * @param  shipmentContainer
     * @return
     */
    @Override
    @Transactional(rollbackFor = SecurityException.class)
    public AjaxResult rawMaterialShipmentServer(ShipmentContainer shipmentContainer) {
        if (shipmentContainer == null) {
            return AjaxResult.error("出库参数不能为空！");
        }

        // 查询出库单详情
        ShipmentDetail shipmentDetail = shipmentDetailService.getById(shipmentContainer.getShipmentDetailId());
        if (shipmentDetail == null) {
            return AjaxResult.error("查询出库单详情失败！");
        }
        // 查询库存详情
        InventoryDetail inventoryDetail = inventoryDetailService.getById(shipmentContainer.getInventoryDelId());
        if (inventoryDetail == null) {
            return AjaxResult.error("查询库存详情失败！");
        }
        // 进行出库组盘
        CombinationModel combinationModel = new CombinationModel();
        // 出库数量
        combinationModel.setShipQty(shipmentContainer.getQty());
        // 出库单详情
        combinationModel.setShipmentDetail(shipmentDetail);
        // 库存详情
        combinationModel.setInventoryDetail(inventoryDetail);
        AjaxResult ajaxResult = shipmentContainerHeaderService.combination(combinationModel);
        if (ajaxResult.hasErr()) {
            return ajaxResult;
        }
        ShipmentContainerHeader shipmentContainerHeader = (ShipmentContainerHeader)ajaxResult.getData();
        // 创建出库任务
        List<Integer> ids = new ArrayList<>();
        ids.add(shipmentContainerHeader.getId());
        AjaxResult result = shipmentContainerHeaderService.createTask(ids);
        if (result.hasErr()) {
            return result;
        }
        // 完成出库任务
        ids = (List<Integer>)result.getData();
        Integer[] temp = new Integer[ids.size()];
        for (int i = 0; i < ids.size(); i++) {
            temp[i] = Integer.valueOf(ids.get(i));
        }
        // 完成出库任务
        result = taskHeaderService.completeTaskByWMS(temp, null);
        return result;
    }

    /**
     * 材料出库完成
     * @param  code
     * @return
     */
    @Override
    public AjaxResult rawMaterialShipmentCompleteServer(String code) {
        // 根据出库单编码查询出库单详情和出库单
        if (StringUtils.isEmpty(code)) {
            return AjaxResult.error("出库单编码不能为空！");
        }
        LambdaQueryWrapper<ShipmentHeader> query = Wrappers.lambdaQuery();
        query.eq(ShipmentHeader::getCode, code);
        ShipmentHeader shipmentHeader = shipmentHeaderService.getOne(query);
        if (shipmentHeader == null) {
            return AjaxResult.error("根据编码查询出库单失败！");
        }
        if (QuantityConstant.SHIPMENT_HEADER_RETURN.equals(shipmentHeader.getFirstStatus())
            && QuantityConstant.SHIPMENT_HEADER_RETURN.equals(shipmentHeader.getLastStatus())) {
            return AjaxResult.success("回传成功！");
        }
        LambdaQueryWrapper<ShipmentDetail> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(ShipmentDetail::getShipmentCode, code);
        // 根据仓库进行分类查询
        List<ShipmentDetail> shipmentDetailList = shipmentDetailService.getByU8WarehouseShipment(shipmentHeader.getId());
        if (shipmentDetailList.size() == 0) {
            return AjaxResult.error("根据出库单编码查询出库单详情失败！");
        }
        // 单据回传给erp
        Map<String, List<ShipmentDetail>> u8WarehouseMap = new HashMap<>();
        for (ShipmentDetail item : shipmentDetailList) {
            String key = item.getU8Warehouse();
            if (item.getTaskQty().compareTo(BigDecimal.ZERO) == 0) {
                continue;
            }
            if (u8WarehouseMap.containsKey(key)) {
                u8WarehouseMap.get(key).add(item);
            } else {
                List<ShipmentDetail> list = new ArrayList<>();
                list.add(item);
                u8WarehouseMap.put(key, list);
            }
        }
        AjaxResult ajaxResult = AjaxResult.success("单据回传成功！");
        if (u8WarehouseMap.size() > 0 && StringUtils.isNotEmpty(shipmentHeader.getStation())
            && shipmentHeader.getStation().length() > QuantityConstant.STATION_STRING_LENGTH) {
            // 发送xml格式数据
            ajaxResult = u8ApiService.sendMaterialShipment(shipmentHeader, u8WarehouseMap);
        }
        return ajaxResult;
    }

    @Override
    public AjaxResult rawMaterialReceiptCompleteServer(String code) {
        if (StringUtils.isEmpty(code)) {
            return AjaxResult.error("人库单编码不能为空！");
        }
        // 根据编码查询入库单
        LambdaQueryWrapper<ReceiptHeader> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(ReceiptHeader::getCode, code);
        ReceiptHeader receiptHeader = receiptHeaderService.getOne(queryWrapper);
        if (receiptHeader == null) {
            return AjaxResult.error("查询入库单失败！");
        }
        // 根据仓库进行分类查询
        List<ReceiptDetail> receiptDetailList = receiptDetailService.getByU8WarehouseReceipt(receiptHeader.getId());
        if (receiptDetailList.size() == 0) {
            return AjaxResult.error("查询入库单详情失败！");
        }
        Map<String, List<ReceiptDetail>> u8WarehouseMap = new HashMap<>();
        receiptDetailList.forEach(item -> {
            String key = item.getU8Warehouse();
            if (u8WarehouseMap.containsKey(key)) {
                u8WarehouseMap.get(key).add(item);
            } else {
                List<ReceiptDetail> list = new ArrayList<>();
                list.add(item);
                u8WarehouseMap.put(key, list);
            }
        });
        AjaxResult ajaxResult = AjaxResult.success("单据回传成功！");
        if (u8WarehouseMap.size() > 0 && StringUtils.isNotEmpty(receiptHeader.getStation())
            && receiptHeader.getStation().length() > QuantityConstant.STATION_STRING_LENGTH) {
            // 发送xml格式数据
            ajaxResult = u8ApiService.sendMaterialReceipt(receiptHeader, u8WarehouseMap);
        }
        return ajaxResult;
    }

}