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.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.huaheng.api.U8.domain.U8Data;
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.api.wcs.service.wcsInteract.WcsStackingService;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.utils.DataUtils;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.common.utils.http.HttpUtils;
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.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.stacking.domain.Stacking;
import com.huaheng.pc.config.stacking.service.IStackingService;
import com.huaheng.pc.config.station.domain.Station;
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.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.system.dept.domain.Dept;
import com.huaheng.pc.system.dept.service.IDeptService;
import com.huaheng.pc.system.user.domain.User;
import com.huaheng.pc.system.user.service.IUserService;
import com.huaheng.pc.task.taskDetail.domain.TaskDetail;
import com.huaheng.pc.task.taskDetail.service.TaskDetailService;
import com.huaheng.pc.task.taskHeader.domain.TaskHeader;
import com.huaheng.pc.task.taskHeader.service.ReceiptTaskService;
import com.huaheng.pc.task.taskHeader.service.TaskHeaderService;
import com.huaheng.pc.task.taskHeader.service.WorkTaskService;

;

/**
 * pda逻辑处理层
 * @author xcq
 */
@Service
public class PdaApiServiceImpl implements PdaApiService {

    @Override
    public AjaxResult turnBoxInventoryServer() {
        // 查询周转箱库位
        LambdaQueryWrapper<Location> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(Location::getLocationType, QuantityConstant.RGV_TURNOVER_CONTAINER);
        List<Location> locations = locationService.list(queryWrapper);
        if (locations.isEmpty()) {
            return AjaxResult.success("没有配置可用的周转箱库位！");
        }
        LambdaQueryWrapper<InventoryDetail> query = Wrappers.lambdaQuery();
        query.in(InventoryDetail::getLocationCode, locations.stream().map(Location::getCode).collect(Collectors.toList())).eq(InventoryDetail::getTaskQty,
            BigDecimal.ZERO);
        List<InventoryDetail> inventoryDetails = inventoryDetailService.list(query);
        // 示例返回，根据实际情况修改
        return AjaxResult.success("周转箱库存查询成功！", inventoryDetails);
    }

    @Override
    public Integer getEmptyContainer() {
//        LambdaQueryWrapper<Location> query = Wrappers.lambdaQuery();
//        // 先查询线边库空托盘库位
//        query.eq(Location::getArea, QuantityConstant.RGV_LIBRARY).eq(Location::getStatus, QuantityConstant.STATUS_CONTAINER_EMPTY)
//            .eq(Location::getLocationType, QuantityConstant.RGV_EMPTY_CONTAINER).ne(Location::getContainerCode, "");
//        List<Location> locationList = locationService.list(query);
//        // 获取线边库空托盘数量
//        LambdaQueryWrapper<Container> containerEmptyLambdaQueryWrapper = Wrappers.lambdaQuery();
//        containerEmptyLambdaQueryWrapper.eq(Container::getStatus, QuantityConstant.STATUS_CONTAINER_EMPTY).in(Container::getLocationCode,
//            locationList.stream().map(Location::getCode).toArray());

        LambdaQueryWrapper<Location> query = Wrappers.lambdaQuery();
        query.eq(Location::getArea, QuantityConstant.RGV_LIBRARY).eq(Location::getStatus, QuantityConstant.STATUS_CONTAINER_EMPTY)
            .eq(Location::getLocationType, QuantityConstant.RGV_EMPTY_CONTAINER).ne(Location::getContainerCode, "");
        Integer emptyPalletQty = locationService.count(query);
        return emptyPalletQty;
    }

    @Override
    public Integer getTurnBoxCount() {
        LambdaQueryWrapper<Location> query = Wrappers.lambdaQuery();
        query.eq(Location::getArea, QuantityConstant.RGV_LIBRARY).eq(Location::getStatus, QuantityConstant.STATUS_CONTAINER_EMPTY)
            .eq(Location::getLocationType, QuantityConstant.RGV_TURNOVER_CONTAINER).ne(Location::getContainerCode, "");
        Integer emptyTurnoverQty = locationService.count(query);
        return emptyTurnoverQty;
    }

    @Override
    public AjaxResult turnBoxReceiptServer(PdaParameter parameter) {
        if (parameter == null) {
            return AjaxResult.error("请勿提交空数据！");
        }
        // 物料编码、入库数量和托盘编码不能为空
        if (StringUtils.isBlank(parameter.getMaterialCode()) || parameter.getQty() == null || StringUtils.isBlank(parameter.getContainerCode())) {
            return AjaxResult.error("物料编码、入库数量或托盘编码不能为空！");
        }
        // 根据托盘编码查询库存
        LambdaQueryWrapper<InventoryHeader> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(InventoryHeader::getContainerCode, parameter.getContainerCode());
        InventoryHeader inventoryHeader = inventoryHeaderService.getOne(queryWrapper);
        if (inventoryHeader != null) {
            return AjaxResult.error("当前托盘码" + parameter.getContainerCode() + "已经在库内，请检查托盘码是否重复！");
        }
        // 创建入库单头
        ReceiptHeader receiptHeader = new ReceiptHeader();
        receiptHeader.setCompanyCode(QuantityConstant.COMPANYCODE);
        receiptHeader.setReceiptType(QuantityConstant.FAST_RECEIPT);
        receiptHeader.setWarehouseCode(QuantityConstant.WAREHOUSECODE);
        receiptHeader.setCreatedBy(ShiroUtils.getLoginName());
        // 创建入库单详情
        ReceiptDetail receiptDetail = new ReceiptDetail();
        receiptDetail.setMaterialCode(parameter.getMaterialCode());
        receiptDetail.setQty(parameter.getQty());
        receiptDetail.setCompanyCode(QuantityConstant.COMPANYCODE);
        receiptDetail.setWarehouseCode(QuantityConstant.WAREHOUSECODE);
        receiptDetail.setCreatedBy(receiptHeader.getCreatedBy());
        receiptDetail.setBatch(parameter.getLot());
        // 调用入库接口
        ReceiptDomain receiptDomain = new ReceiptDomain();
        receiptDomain.setReceiptHeader(receiptHeader);
        receiptDomain.setReceiptDetails(new ArrayList<>());
        receiptDomain.getReceiptDetails().add(receiptDetail);
        AjaxResult ajaxResult = receiptApiService.receipt(receiptDomain);
        if (ajaxResult.hasErr()) {
            throw new ServiceException(ajaxResult.getMsg());
        }
        // 获取周转箱入库库位
        LambdaQueryWrapper<Location> query = Wrappers.lambdaQuery();
        query.eq(Location::getLocationType, QuantityConstant.RGV_TURNOVER_CONTAINER).eq(Location::getArea, QuantityConstant.RGV_LIBRARY)
            .eq(Location::getStatus, QuantityConstant.STATUS_CONTAINER_EMPTY).eq(Location::getContainerCode, "").last("limit 1");
        Location location = locationService.getOne(query);
        if (location == null) {
            throw new ServiceException("当前没有空闲周转箱库位！");
        }
        // 入库组盘
        ajaxResult = receiptContainerHeaderService.saveContainer(receiptDomain.getReceiptHeader().getCode(), parameter.getContainerCode(), receiptDetail.getId(),
            location.getCode(), receiptDetail.getQty(), null);
        if (ajaxResult.hasErr()) {
            throw new ServiceException(ajaxResult.getMsg());
        }
        // 入库组盘ID
        List<Integer> ids = new ArrayList<>();
        ids.add(Integer.valueOf(ajaxResult.getData().toString()));
        // 下发入库任务
        ajaxResult = receiptTaskService.createReceiptTask(ids.stream().distinct().collect(Collectors.toList()));
        if (ajaxResult.hasErr()) {
            throw new ServiceException(ajaxResult.getMsg());
        }
        return AjaxResult.success("周转箱入库任务下发成功，请及时将托盘运送至入库站台");
    }

    @Override
    public AjaxResult turnBoxReceiptServer(String containerCode) {
        if (StringUtils.isBlank(containerCode)) {
            return AjaxResult.error("托盘编码不能为空！");
        }
        // 根据托盘编码查询库存
        LambdaQueryWrapper<InventoryHeader> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(InventoryHeader::getContainerCode, containerCode);
        InventoryHeader inventoryHeader = inventoryHeaderService.getOne(queryWrapper);
        if (inventoryHeader != null) {
            return AjaxResult.error("当前托盘码" + containerCode + "已经在库内，请检查托盘码是否重复！");
        }
        // 根据托盘编码查询托盘信息
        LambdaQueryWrapper<Container> query = Wrappers.lambdaQuery();
        query.eq(Container::getCode, containerCode);
        Container container = containerService.getOne(query);
        if (container == null) {
            return AjaxResult.error("当前托盘码" + containerCode + "不存在，请检查托盘码是否正确！");
        }
        // 判断托盘是否为空闲
        if (!container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_EMPTY)) {
            return AjaxResult.error("当前托盘码" + containerCode + "不是空闲状态，请检查托盘状态！");
        }
        // 判断托盘是否已经绑定了库位
        if (StringUtils.isNotEmpty(container.getLocationCode())) {
            return AjaxResult.error("当前托盘码" + containerCode + "已经绑定了库位，请检查托盘绑定状态！");
        }
        // 获取周转箱空闲库位
        LambdaQueryWrapper<Location> loLambdaQueryWrapper = Wrappers.lambdaQuery();
        loLambdaQueryWrapper.eq(Location::getLocationType, QuantityConstant.RGV_TURNOVER_CONTAINER).eq(Location::getArea, QuantityConstant.RGV_LIBRARY)
            .eq(Location::getStatus, QuantityConstant.STATUS_CONTAINER_EMPTY).eq(Location::getContainerCode, "").last("limit 1");
        Location location = locationService.getOne(loLambdaQueryWrapper);
        if (location == null) {
            return AjaxResult.error("当前没有空闲周转箱库位！");
        }
        // 创建空托入库任务并指定库位
        return inventoryHeaderService.createEmptyIn(containerCode, location.getCode());
    }

    @Resource
    private WcsStackingService wcsStackingService;

    @Override
    public AjaxResult turnBoxShipmentServer(String port) {
        if (StringUtils.isBlank(port)) {
            return AjaxResult.error("请选择要出库的站台！");
        }
        // 查询周转箱库位的空托盘
        LambdaQueryWrapper<Location> query = Wrappers.lambdaQuery();
        query.eq(Location::getLocationType, QuantityConstant.RGV_TURNOVER_CONTAINER).eq(Location::getArea, QuantityConstant.RGV_LIBRARY)
            .eq(Location::getStatus, QuantityConstant.STATUS_CONTAINER_EMPTY).ne(Location::getContainerCode, "").last("limit 1");
        Location location = locationService.getOne(query);
        if (location == null) {
            return AjaxResult.error("当前库位没有周转箱！");
        }
        // 创建空托出库任务
        AjaxResult result = inventoryHeaderService.createEmptyOut(location.getContainerCode(), null, port, QuantityConstant.WAREHOUSECODE);
        // 获取周转箱数量
        Integer turnBoxQty = this.getTurnBoxCount();
        // 周转箱数量为0通知wcs报警
        if (!result.hasErr() && turnBoxQty == 0) {
            try {
                wcsStackingService.sendAlarmToWcs();
            } catch (Exception e) {
                return AjaxResult.success("周转箱出库任务下发成功，通知WCS预警失败！");
            }
        }
        return result;
    }

    @Override
    @Transactional
    public AjaxResult turnBoxShipmentServer(PdaParameter parameter) {
        if (parameter == null) {
            return AjaxResult.error("请勿提交空数据！");
        }
        // 出库站台和托盘编码不能为空
        if (StringUtils.isEmpty(parameter.getPort()) || StringUtils.isEmpty(parameter.getContainerCode())) {
            return AjaxResult.error("出库站台或托盘编码不能为空！");
        }
        // 校验托盘是否在库内
        LambdaQueryWrapper<InventoryDetail> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(InventoryDetail::getContainerCode, parameter.getContainerCode()).last("limit 1");
        InventoryDetail inventoryDetail = inventoryDetailService.getOne(queryWrapper);
        if (inventoryDetail == null) {
            return AjaxResult.error("当前托盘码" + parameter.getContainerCode() + "不在库内，请检查托盘码是否正确！");
        }
        if (inventoryDetail.getTaskQty().compareTo(BigDecimal.ONE) > 0) {
            return AjaxResult.error("当前托盘码" + parameter.getContainerCode() + "正在执行出库任务，请勿重复下发！");
        }
        // 查询出库站台
        LambdaQueryWrapper<Station> query = Wrappers.lambdaQuery();
        query.eq(Station::getCode, parameter.getPort());
        Station station = stationService.getOne(query);
        if (station == null) {
            return AjaxResult.error("当前站台编码" + parameter.getPort() + "不存在，请检查站台编码是否正确！");
        }
        // 判断站台是否为RGV库区
        if (!station.getArea().equals(QuantityConstant.RGV_LIBRARY)) {
            return AjaxResult.error("当前站台编码" + parameter.getPort() + "不是RGV库区，请检查站台编码是否正确！");
        }
        // 创建出库单
        ShipmentHeader shipmentHeader = new ShipmentHeader();
        shipmentHeader.setCompanyCode(QuantityConstant.COMPANYCODE);
        shipmentHeader.setWarehouseCode(QuantityConstant.WAREHOUSECODE);
        shipmentHeader.setShipmentType(QuantityConstant.FAST_SHIPMENT);
        shipmentHeader.setCreatedBy(ShiroUtils.getLoginName());
        ShipmentDetail shipmentDetail = new ShipmentDetail();
        shipmentDetail.setMaterialCode(inventoryDetail.getMaterialCode());
        shipmentDetail.setQty(inventoryDetail.getQty());
        shipmentDetail.setCompanyCode(QuantityConstant.COMPANYCODE);
        shipmentDetail.setWarehouseCode(QuantityConstant.WAREHOUSECODE);
        shipmentDetail.setCreatedBy(shipmentHeader.getCreatedBy());
        ShipmentDomain shipmentDomain = new ShipmentDomain();
        shipmentDomain.setShipmentHeader(shipmentHeader);
        shipmentDomain.setShipmentDetails(new ArrayList<>());
        shipmentDomain.getShipmentDetails().add(shipmentDetail);
        AjaxResult ajaxResult = shipmentApiService.shipment(shipmentDomain);
        if (ajaxResult.hasErr()) {
            throw new ServiceException(ajaxResult.getMsg());
        }
        // 进行出库组盘
        CombinationModel combinationModel = new CombinationModel();
        // 出库数量
        combinationModel.setShipQty(shipmentDetail.getQty());
        // 出库单详情
        combinationModel.setShipmentDetail(shipmentDetail);
        // 库存详情
        combinationModel.setInventoryDetail(inventoryDetail);
        ajaxResult = shipmentContainerHeaderService.combination(combinationModel);
        if (ajaxResult.hasErr()) {
            throw new ServiceException(ajaxResult.getMsg());
        }
        ShipmentContainerHeader shipmentContainerHeader = (ShipmentContainerHeader)ajaxResult.getData();
        // 创建出库任务
        List<Integer> ids = new ArrayList<>();
        ids.add(shipmentContainerHeader.getId());
        ajaxResult = shipmentContainerHeaderService.createTask(ids);
        if (ajaxResult.hasErr()) {
            return ajaxResult;
        }
        return AjaxResult.success(" 出库任务下发成功!");
    }

    @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;
    @Resource
    private StationService stationService;

    /**
     * 获取所有材料出库单
     * @return
     */
    @Override
    public AjaxResult getShipmentAllService() {
        LambdaQueryWrapper<ShipmentHeader> query = Wrappers.lambdaQuery();
        query.eq(ShipmentHeader::getShipmentType, QuantityConstant.SHIPMENT_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);
        List<ShipmentDomain> shipmentDomains = new ArrayList<>();
        if (list != null && list.size() > 0) {
            // 根据头表id查询详情
            LambdaQueryWrapper<ShipmentDetail> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.in(ShipmentDetail::getShipmentId, list.stream().map(ShipmentHeader::getId).collect(Collectors.toList()));
            List<ShipmentDetail> shipmentDetailList = shipmentDetailService.list(queryWrapper);
            Map<String, List<ShipmentDetail>> map = new HashMap<>();
            shipmentDetailList.forEach(item -> {
                String key = item.getShipmentCode();
                if (map.containsKey(key)) {
                    map.get(key).add(item);
                } else {
                    List<ShipmentDetail> temp = new ArrayList<>();
                    temp.add(item);
                    map.put(key, temp);
                }
            });
            for (ShipmentHeader header : list) {
                String key = header.getCode();
                ShipmentDomain shipmentDomain = new ShipmentDomain();
                shipmentDomain.setShipmentHeader(header);
                shipmentDomain.setShipmentDetails(map.get(key));
                shipmentDomains.add(shipmentDomain);
            }
        }
        return AjaxResult.success("查询成功！", shipmentDomains);
    }

    /**
     * 获取所有材料入库单
     * @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);
        List<ReceiptDomain> receiptDomains = new ArrayList<>();
        if (list != null && list.size() > 0) {
            // 根据头表id查询详情
            LambdaQueryWrapper<ReceiptDetail> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.in(ReceiptDetail::getReceiptId, list.stream().map(ReceiptHeader::getId).collect(Collectors.toList()));
            List<ReceiptDetail> shipmentDetailList = receiptDetailService.list(queryWrapper);
            Map<String, List<ReceiptDetail>> map = new HashMap<>();
            shipmentDetailList.forEach(item -> {
                String key = item.getReceiptCode();
                if (map.containsKey(key)) {
                    map.get(key).add(item);
                } else {
                    List<ReceiptDetail> temp = new ArrayList<>();
                    temp.add(item);
                    map.put(key, temp);
                }
            });
            for (ReceiptHeader header : list) {
                String key = header.getCode();
                ReceiptDomain receiptDomain = new ReceiptDomain();
                receiptDomain.setReceiptHeader(header);
                receiptDomain.setReceiptDetails(map.get(key));
                receiptDomains.add(receiptDomain);
            }
        }
        return AjaxResult.success("查询成功！", receiptDomains);
    }

    /**
     * 通过送货单号创建出库单
     * @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不能不能为空值！");
        }

        String code = parameter.getCode();
        String batch = parameter.getLot();
        String materialCode = parameter.getMaterialCode();;
        // 过滤采购订单空格
        code = code.replaceAll(" ", "");
        // 过滤物料编码空格
        materialCode = materialCode.replaceAll(" ", "");
        // 过滤批次空格
        batch = batch.replaceAll(" ", "");
        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, 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.setShipmentType(QuantityConstant.RETURN_RAW_MATERIALS);
            // 存储采购订单号
            header.setUserDef1(code);
            // 设置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());
            String finalCode = code;
            String finalBatch = batch;
            u8ReceiptDetails.forEach(item -> {
                ShipmentDetail shipmentDetail = new ShipmentDetail();
                // 数量
                shipmentDetail.setQty(item.getTaskQty());
                // 物料编码
                shipmentDetail.setMaterialCode(item.getMaterialCode());
                // 货主
                shipmentDetail.setCompanyCode(QuantityConstant.COMPANYCODE);
                // 仓库编码
                shipmentDetail.setWarehouseCode(QuantityConstant.WAREHOUSECODE);
                // 制单人
                shipmentDetail.setCreatedBy(ShiroUtils.getUser().getUserName());
                // 采购单号
                shipmentDetail.setUserDef1(finalCode);
                // 批次
                shipmentDetail.setBatch(finalBatch);
                // 采购订单子单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;
    }

    @Override
    public List<ReceiptDetail> checkReceiptHeaderServer(String code, String materialCode, String batch) {
        // 查询到货单是否已经存在
        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);
            }
        }
        return temp;
    }

    /**
     * 通过送货单号创建入库
     * @param  parameter
     * @return
     */
    @Override
    public synchronized 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("到货单号、批次或物料编号不能为空！");
        }
        // 过滤采购订单空格
        code = code.replaceAll(" ", "");
        // 过滤物料编码空格
        materialCode = materialCode.replaceAll(" ", "");
        // 过滤批次空格
        batch = batch.replaceAll(" ", "");
        // 查询到货单是否已经存在
        List<ReceiptDetail> temp = checkReceiptHeaderServer(code, materialCode, batch);
        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()));
            String finalCode = code;
            String finalBatch = batch;
            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(finalCode);
                // 批次
                receiptDetail.setBatch(finalBatch);
                // 采购订单子单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;

    @Resource
    private IUserService userService;
    @Resource
    private IDeptService deptService;
    @Resource
    private AddressService addressService;

    @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 checkReceiptServer(ReceiptContainer receiptContainer) {
        if (receiptContainer == null) {
            return AjaxResult.error("请勿提交空数据！");
        }
        if (receiptContainer.getQty() == null || receiptContainer.getQty().compareTo(BigDecimal.ZERO) == 0) {
            return AjaxResult.error("入库数量不能为空！");
        }
        if (receiptContainer.getReceiptCode() == null || receiptContainer.getReceiptDetailId() == null) {
            return AjaxResult.error("入库单号或入库单详情ID不能为空！");
        }
        LambdaQueryWrapper<ReceiptHeader> query = Wrappers.lambdaQuery();
        query.eq(ReceiptHeader::getCode, receiptContainer.getReceiptCode());
        ReceiptHeader receiptHeader = receiptHeaderService.getOne(query);
        if (receiptHeader == null) {
            return AjaxResult.error("未查询到该入库单头！");
        }
        ReceiptDetail receiptDetail = receiptDetailService.getById(receiptContainer.getReceiptDetailId());
        if (receiptDetail == null) {
            return AjaxResult.error("通过入库单详情ID:" + receiptContainer.getReceiptDetailId() + "未查询到该入库单明细！");
        }
        User user = userService.selectmen(receiptDetail.getCreatedBy());
        if (user == null) {
            return AjaxResult.error("查询制单人失败！");
        }
        Dept dept = deptService.selectDeptById(user.getDeptId());
        if (dept == null) {
            return AjaxResult.error("查询制单人部门失败！");
        }
        U8Data data = new U8Data();
        // 设置订单号
        data.setCrdcode(receiptHeader.getReferCode());
        // 设置日期
        data.setDDate(DataUtils.getDataString());
        // u8仓库
        data.setCWhCode(receiptHeader.getUserDef2());
        // 部门编码
        data.setCDepCode(dept.getCode());
        // 采购入库单号
        data.setCdefine10(receiptHeader.getCode());
        // 供应商编码
        data.setCVenCode(receiptHeader.getSupplierCode());
        // 入库类别(收发类别)
        data.setCrdcode("101");
        // 业务员编码
        data.setCpersoncode(receiptHeader.getCreatedBy());
        // 采购订单号
        data.setCordercode(receiptHeader.getUserDef1());
        // 采购订单主表id
        data.setIpurorderid(receiptHeader.getReferId());
        // 制单人
        data.setCMaker(user.getUserName());
        List<Map> maps = new ArrayList<>();
        String cpoid = receiptHeader.getUserDef1();
        Map body = new HashMap<>();
        body.put("cinvcode", receiptDetail.getMaterialCode());
        body.put("Iquantity", receiptContainer.getQty());
        // 采购订单子表标识
        body.put("Iposid", receiptDetail.getUserDef2());
        // 采购订单号
        body.put("cpoid", cpoid);
        body.put("cbatch", receiptDetail.getBatch());
        body.put("cdefine33", receiptDetail.getBatch());
        maps.add(body);
        data.setBody(maps);
        String url = addressService.selectAddress(QuantityConstant.U8_CHECK_QTY_API);
        String json = JSONObject.toJSONString(data);
        String result = HttpUtils.bodypost(url, json, QuantityConstant.WAREHOUSECODE);
        JSONObject object = JSONObject.parseObject(result);
        if (object == null) {
            return AjaxResult.error("数据发送失败，请检查url地址是否正确！");
        }
        JSONObject responseException;
        if (object.containsKey("isError")) {
            responseException = object.getJSONObject("responseException");
            String exceptionMessage = responseException.getString("exceptionMessage");
            return AjaxResult.error(exceptionMessage);
        }
        return AjaxResult.success("采购入库单数量校验通过允许入库！");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public AjaxResult delReceiptService(ReceiptContainer receiptContainer) {
        ReceiptDetail receiptDetail = receiptDetailService.getById(receiptContainer.getReceiptDetailId());
        if (receiptDetail == null) {
            return AjaxResult.error("通过入库单ID:" + receiptContainer.getReceiptDetailId() + "未查询到该入库单明细！");
        }
        ReceiptHeader receiptHeader = receiptHeaderService.getById(receiptDetail.getReceiptId());
        if (receiptHeader == null) {
            return AjaxResult.error("通过入库单ID:" + receiptDetail.getReceiptId() + "未查询到该入库单！");
        }
        receiptDetailService.removeById(receiptDetail.getId());
        receiptHeaderService.removeById(receiptHeader.getId());
        return AjaxResult.success("入库单删除成功！");
    }

    @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);
        AjaxResult result = stackingService.initStacking(cartonsList.get(0).getStackingPort());
        if (result.hasErr()) {
            return result;
        }
        // 创建入库单
        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()));
    }

    /**
     * 通过托盘查询入库单详情
     * @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);
    }

    /**
     * 根据纸箱编码查询纸箱数据
     * @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 (StringUtils.isNotEmpty(shipmentHeader.getStation())) {
                item.setStation(shipmentHeader.getStation());
            }
            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;
    }

    @Override
    @Transactional
    public AjaxResult fastShipmentService(List<PdaParameter> pdaParameters) {
        if (pdaParameters == null || pdaParameters.size() == 0) {
            return AjaxResult.error("请勿提交空数据！");
        }
        ShipmentDomain shipmentDomain = new ShipmentDomain();
        ShipmentHeader header = new ShipmentHeader();
        header.setShipmentType(QuantityConstant.FAST_SHIPMENT);
        header.setWarehouseCode(QuantityConstant.WAREHOUSECODE);
        header.setCreatedBy(ShiroUtils.getLoginName());
        header.setCompanyCode(QuantityConstant.COMPANYCODE);
        List<ShipmentDetail> shipmentDetailList = new ArrayList<>();
        for (PdaParameter parameter : pdaParameters) {
            ShipmentDetail shipmentDetail = new ShipmentDetail();
            shipmentDetail.setMaterialCode(parameter.getMaterialCode());
            shipmentDetail.setCreatedBy(ShiroUtils.getLoginName());
            shipmentDetail.setQty(parameter.getQty());
            shipmentDetail.setInventorySts(QuantityConstant.GOOD);
            shipmentDetail.setWarehouseCode(QuantityConstant.WAREHOUSECODE);
            shipmentDetail.setCompanyCode(QuantityConstant.COMPANYCODE);
            shipmentDetail.setInventorySts(QuantityConstant.GOOD);
            shipmentDetail.setInventoryDetailId(parameter.getInventoryDetailId());
            shipmentDetail.setTaskQty(BigDecimal.ZERO);
            shipmentDetailList.add(shipmentDetail);
        }
        shipmentDomain.setShipmentHeader(header);
        shipmentDomain.setShipmentDetails(shipmentDetailList);
        // 创建出库单
        AjaxResult result = shipmentApiService.shipment(shipmentDomain);
        if (result.hasErr()) {
            return result;
        }
        List<Integer> idList = new ArrayList<>();
        // 进行出库组盘
        for (ShipmentDetail detail : shipmentDetailList) {
            CombinationModel combinationModel = new CombinationModel();
            // 组盘明细id
            combinationModel.setShipmentDetail(detail);
            // 组盘时选择的库存
            combinationModel.setInventoryDetail(inventoryDetailService.getById(detail.getInventoryDetailId()));
            // 组盘数量
            combinationModel.setShipQty(detail.getQty());
            result = shipmentContainerHeaderService.combination(combinationModel);
            if (result.hasErr()) {
                throw new ServiceException(result.getMsg());
            }
            ShipmentContainerHeader shipmentContainerHeader = (ShipmentContainerHeader)result.getData();
            idList.add(shipmentContainerHeader.getId());
        }
        // 生成出库任务
        result = shipmentContainerHeaderService.createTask(idList.stream().distinct().collect(Collectors.toList()));
        if (result.hasErr()) {
            throw new ServiceException(result.getMsg());
        }
        idList = (List<Integer>)result.getData();
        Integer[] temp = new Integer[idList.size()];
        for (int i = 0; i < idList.size(); i++) {
            temp[i] = Integer.valueOf(idList.get(i));
        }
        // 完成出库任务
        result = taskHeaderService.completeTaskByWMS(temp, null);
        if (result.hasErr()) {
            throw new ServiceException(result.getMsg());
        }
        return result;
    }

    @Override
    public AjaxResult findInventoryService(PdaParameter parameter) {
        List<String> zoneCodes = new ArrayList<>();
        zoneCodes.add(QuantityConstant.FLAT_LOCATION_CODE);
        zoneCodes.add(QuantityConstant.VIRTUAL_LOCATION_CODE);
        LambdaQueryWrapper<InventoryDetail> query = Wrappers.lambdaQuery();
        query.in(InventoryDetail::getZoneCode, zoneCodes)
            .likeRight(StringUtils.isNotEmpty(parameter.getMaterialCode()), InventoryDetail::getMaterialCode, parameter.getMaterialCode())
            .likeRight(StringUtils.isNotEmpty(parameter.getContainerCode()), InventoryDetail::getContainerCode, parameter.getContainerCode())
            .likeRight(StringUtils.isNotEmpty(parameter.getLocationCode()), InventoryDetail::getLocationCode, parameter.getLocationCode());
        List<InventoryDetail> list = inventoryDetailService.list(query);
        AjaxResult ajaxResult = AjaxResult.success("库存查询成功！");
        ajaxResult.setData(list);
        return ajaxResult;
    }

    @Override
    @Transactional
    public AjaxResult fastReceiptService(List<PdaParameter> pdaParameters) {
        if (pdaParameters == null || pdaParameters.size() == 0) {
            return AjaxResult.error("请勿提交空数据！");
        }
        // 查询库存
        List<String> stringList = pdaParameters.stream().map(PdaParameter::getLocationCode).collect(Collectors.toList());
        LambdaQueryWrapper<InventoryDetail> query = Wrappers.lambdaQuery();
        query.in(InventoryDetail::getLocationCode, stringList).ne(InventoryDetail::getZoneCode, QuantityConstant.FLAT_LOCATION_CODE);
        List<InventoryDetail> inventoryDetailList = inventoryDetailService.list(query);
        for (InventoryDetail inventoryDetail : inventoryDetailList) {
            if (!inventoryDetail.getZoneCode().equals(QuantityConstant.FLAT_LOCATION_CODE)) {
                return AjaxResult.error("库位编码：" + inventoryDetail.getLocationCode() + "不在平库区，不允许使用该库位进行快速入库！");
            }
        }
        query = Wrappers.lambdaQuery();
        stringList = pdaParameters.stream().map(PdaParameter::getContainerCode).collect(Collectors.toList());
        query.in(InventoryDetail::getContainerCode, stringList).ne(InventoryDetail::getZoneCode, QuantityConstant.FLAT_LOCATION_CODE);
        inventoryDetailList = inventoryDetailService.list(query);
        for (InventoryDetail inventoryDetail : inventoryDetailList) {
            if (!inventoryDetail.getZoneCode().equals(QuantityConstant.FLAT_LOCATION_CODE)) {
                return AjaxResult.error("容器编码：" + inventoryDetail.getContainerCode() + "不在平库区，不允许使用该容器进行快速入库！");
            }
        }
        ReceiptDomain receiptDomain = new ReceiptDomain();
        ReceiptHeader receiptHeader = new ReceiptHeader();
        receiptHeader.setReceiptType(QuantityConstant.FAST_RECEIPT);
        receiptHeader.setCompanyCode(QuantityConstant.COMPANYCODE);
        receiptHeader.setWarehouseCode(QuantityConstant.WAREHOUSECODE);
        List<ReceiptDetail> receiptDetailList = new ArrayList<>();
        for (PdaParameter parameter : pdaParameters) {
            // 创建入库组盘明细
            ReceiptDetail receiptDetail = new ReceiptDetail();
            receiptDetail.setMaterialCode(parameter.getMaterialCode());
            receiptDetail.setQty(parameter.getQty());
            receiptDetail.setInventorySts(QuantityConstant.GOOD);
            receiptDetail.setWarehouseCode(QuantityConstant.WAREHOUSECODE);
            receiptDetail.setCompanyCode(QuantityConstant.COMPANYCODE);
            receiptDetail.setCreatedBy(ShiroUtils.getLoginName());
            receiptDetail.setLocationCode(parameter.getLocationCode());
            receiptDetail.setContainerCode(parameter.getContainerCode());
            receiptDetail.setBatch(parameter.getLot());
            receiptDetailList.add(receiptDetail);
        }
        receiptDomain.setReceiptHeader(receiptHeader);
        receiptDomain.setReceiptDetails(receiptDetailList);
        AjaxResult result = receiptApiService.receipt(receiptDomain);
        if (result.hasErr()) {
            return result;
        }
        List<Integer> ids = new ArrayList<>();
        // 进行入库组盘
        for (ReceiptDetail receiptDetail : receiptDetailList) {
            result = receiptContainerHeaderService.saveContainer(receiptHeader.getCode(), receiptDetail.getContainerCode(), receiptDetail.getId(),
                receiptDetail.getLocationCode(), receiptDetail.getQty(), null);
            if (result.hasErr()) {
                throw new ServiceException(result.getMsg());
            }
            ids.add(Integer.valueOf(result.getData().toString()));
        }
        // 批量生成入库任务
        result = receiptTaskService.createReceiptTask(ids.stream().distinct().collect(Collectors.toList()));
        if (result.hasErr()) {
            throw new ServiceException(result.getMsg());
        }
        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));
        }
        // 批量入库任务完成
        result = taskHeaderService.completeTaskByWMS(temp, null);
        if (result.hasErr()) {
            throw new ServiceException(result.getMsg());
        }
        return result;
    }

    @Override
    public AjaxResult rgvEmptyReceiptServer(String containerCode) {
        if (StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("托盘编码不能为空！");
        }
        // 判断当前托盘码是否正确
        LambdaQueryWrapper<Container> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(Container::getCode, containerCode);
        Container container = containerService.getOne(queryWrapper);
        if (container == null) {
            return AjaxResult.error("该托盘码：" + containerCode + "不存在！");
        }
        // 判断当前托盘是否已经入库
        if (StringUtils.isNotEmpty(container.getLocationCode())) {
            return AjaxResult.error("该托盘码：" + containerCode + "已经入库！");
        }
        // 判断当前托盘是否为空托盘
        if (!container.getStatus().equals(QuantityConstant.STATUS_CONTAINER_EMPTY)) {
            return AjaxResult.error("该托盘码：" + containerCode + "不是空托盘！");
        }
        // 获取空闲的RGV库库位
        LambdaQueryWrapper<Location> query = Wrappers.lambdaQuery();
        query.eq(Location::getLocationType, QuantityConstant.RGV_EMPTY_CONTAINER).eq(Location::getStatus, QuantityConstant.STATUS_CONTAINER_EMPTY)
            .eq(Location::getContainerCode, "").last(" limit 1");
        Location location = locationService.getOne(query);
        if (location == null) {
            return AjaxResult.error("未查询到空闲的RGV空托盘库位！");

        }
        // 调用创建空托盘入库接口并指定库位
        return inventoryHeaderService.createEmptyIn(containerCode, location.getCode());
    }

    @Resource
    private WorkTaskService workTaskService;

    @Override
    public AjaxResult emptyShipmentServer(String portCode) {
        if (StringUtils.isEmpty(portCode)) {
            return AjaxResult.error("站台编码不能为空！");
        }
        // 查询站台
        LambdaQueryWrapper<Station> stationLambdaQueryWrapper = Wrappers.lambdaQuery();
        stationLambdaQueryWrapper.eq(Station::getCode, portCode);
        Station station = stationService.getOne(stationLambdaQueryWrapper);
        if (station == null) {
            return AjaxResult.error("未查询到站台！");
        }
        Integer area = station.getArea();
        String zoneCode = null;
        // 查询可以出库的空托盘
        LambdaQueryWrapper<Container> containerLambdaQueryWrapper = Wrappers.lambdaQuery();
        switch (area) {
            case QuantityConstant.RGV_LIBRARY:
                zoneCode = QuantityConstant.RGV_LOCATION_CODE;
                containerLambdaQueryWrapper.eq(Container::getStatus, QuantityConstant.STATUS_CONTAINER_EMPTY).likeRight(Container::getLocationCode, zoneCode);
                List<Container> containers = containerService.list(containerLambdaQueryWrapper);
                if (containers == null || containers.size() == 0) {
                    return AjaxResult.error("当前RGK库区空托盘数量为0！");
                }
                // 获取空托盘中所有库位编码
                List<String> locationCodes = containers.stream().map(Container::getLocationCode).collect(Collectors.toList());
                // 查询所有库位忽略周转箱库位类型且库位状态为空闲的库位
                LambdaQueryWrapper<Location> locationLambdaQueryWrapper = Wrappers.lambdaQuery();
                locationLambdaQueryWrapper.in(Location::getCode, locationCodes).ne(Location::getLocationType, QuantityConstant.RGV_TURNOVER_CONTAINER)
                    .eq(Location::getStatus, QuantityConstant.STATUS_CONTAINER_EMPTY).last(" limit 1");
                Location location = locationService.getOne(locationLambdaQueryWrapper);
                if (location == null) {
                    return AjaxResult.error("未查询到空闲的空托盘！");
                }
                // 调用空托出库接口
                AjaxResult result = inventoryHeaderService.createEmptyOut(location.getContainerCode(), null, portCode, QuantityConstant.WAREHOUSECODE);
                // 获取线边库空托盘数量
                Integer emptyPalletQty = this.getEmptyContainer();
                // 如果没有空托盘，则通知wcs预警
                if (!result.hasErr() && emptyPalletQty == 0) {
                    // 通知wcs预警
                    try {
                        wcsStackingService.sendAlarmToWcs();
                    } catch (Exception e) {
                        return AjaxResult.success("任务下发成功,通知wcs预警失败！");
                    }
                }
                return result;
            case QuantityConstant.LIBRARY:
                zoneCode = QuantityConstant.STEREOLIB_LOCATION_CODE;
                containerLambdaQueryWrapper.eq(Container::getStatus, QuantityConstant.STATUS_CONTAINER_MANY).likeRight(Container::getLocationCode, zoneCode)
                    .last(" limit 1");
                Container container = containerService.getOne(containerLambdaQueryWrapper);
                if (container == null) {
                    return AjaxResult.error("当前立库库区空托盘数量为0！");
                }
                return workTaskService.createManyEmptyOut(container.getCode(), QuantityConstant.WAREHOUSECODE, portCode);
            default:
                return AjaxResult.error(portCode + "不是立库或RGV库区站台，请检查站台参数是否正确！");
        }
    }

}