wms / wms_guangxijianyi · Files

package com.huaheng.api.erp.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.huaheng.api.erp.domain.*;
import com.huaheng.api.erp.service.PDAService;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.framework.aspectj.lang.annotation.ApiLogger;
import com.huaheng.framework.aspectj.lang.annotation.Log;
import com.huaheng.framework.aspectj.lang.constant.BusinessType;
import com.huaheng.framework.web.controller.BaseController;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.pc.config.container.domain.Container;
import com.huaheng.pc.config.container.service.ContainerService;
import com.huaheng.pc.config.location.service.LocationService;
import com.huaheng.pc.config.proPackaging.domain.ProPackaging;
import com.huaheng.pc.config.proPackaging.service.IProPackagingService;
import com.huaheng.pc.inventory.InventoryHistoryDetail.domain.InventoryHistoryDetail;
import com.huaheng.pc.inventory.InventoryHistoryDetail.service.impl.InventoryHistoryDetailServiceImpl;
import com.huaheng.pc.inventory.inventoryDetail.domain.InventoryDetail;
import com.huaheng.pc.inventory.inventoryDetail.service.InventoryDetailService;
import com.huaheng.pc.inventory.inventoryHeader.domain.InventoryHeader;
import com.huaheng.pc.inventory.inventoryHeader.service.InventoryHeaderService;
import com.huaheng.pc.inventory.inventoryHistoryHeader.service.impl.InventoryHistoryHeaderServiceImpl;
import com.huaheng.pc.receipt.receiptContainerDetail.domain.ReceiptContainerDetail;
import com.huaheng.pc.receipt.receiptContainerHeader.controller.ReceiptContainerHeaderController;
import com.huaheng.pc.receipt.receiptContainerHeader.domain.ReceiptContainerHeader;
import com.huaheng.pc.receipt.receiptContainerHeader.service.ReceiptContainerHeaderService;
import com.huaheng.pc.receipt.receiptHeader.service.ReceiptHeaderService;
import com.huaheng.pc.shipment.shipmentDetail.service.ShipmentDetailService;
import com.huaheng.pc.shipment.shipmentHeader.service.ShipmentHeaderService;
import io.swagger.annotations.ApiOperation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.beans.Transient;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/API/WMS/v2")
public class PDAController extends BaseController {

    @Resource
    private InventoryDetailService inventoryDetailService;
    @Resource
    private InventoryHeaderService inventoryHeaderService;
    @Resource
    private InventoryHistoryHeaderServiceImpl inventoryHistoryHeaderService;
    @Resource
    private InventoryHistoryDetailServiceImpl inventoryHistoryDetailService;
    @Resource
    private ContainerService containerService;
    @Resource
    private ReceiptContainerHeaderService receiptContainerHeaderService;
    @Resource
    private PDAService pdaService;
    @Resource
    private IProPackagingService proPackingService;

    @PostMapping("/lockInventory")
    @ApiOperation("锁定库存")
    @ResponseBody
    @ApiLogger(apiName = "锁定库存", from="PDA")
    public AjaxResult lockInventory(@RequestBody PDAInventory pdaInventory) {
        String locationCode = pdaInventory.getLocationCode();
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getLocationCode, locationCode);
        List<InventoryDetail> inventoryDetailList =
                inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);
        if(inventoryDetailService == null) {
            throw new ServiceException("");
        }
        return null;
    }


    @PostMapping("/complement")
    @ApiOperation("补充条码")
    @ResponseBody
    @ApiLogger(apiName = "补充条码", from="PDA")
    public AjaxResult complement(@RequestBody Map<String,String> map) {
        String warehouseCode = QuantityConstant.DEFAULT_WAREHOUSE;
        String containerCode = map.get("containerCode");
        String boxCode = map.get("boxCode");
        if(StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("没有容器号");
        }
        Container containerByCode = containerService.getContainerByCode(containerCode);
        if (containerByCode==null)
        {
            return AjaxResult.error("容器号不存在");
        }
        AjaxResult ajaxResult = handleMultiProcess("complement", new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.complement(warehouseCode, containerCode,boxCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }




    @PostMapping("/clearInventory")
    @ApiOperation("释放库存")
    @ResponseBody
    @ApiLogger(apiName = "释放库存", from="PDA")
    public AjaxResult clearInventory(@RequestBody Map<String,String> map) {
        String warehouseCode = QuantityConstant.DEFAULT_WAREHOUSE;
        String contaienrCode = map.get("containerCode");
        if(StringUtils.isEmpty(contaienrCode)) {
            return AjaxResult.error("没有容器号");
        }
        AjaxResult ajaxResult = handleMultiProcess("clearInventory", new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.clearInventory(warehouseCode, contaienrCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }


    @PostMapping("/orderStatus")
    @ApiOperation("查询订单状态")
    @ResponseBody
    @ApiLogger(apiName = "查询订单状态", from="PDA")
    public AjaxResult orderStatus(@RequestBody Map<String,String> map) {
        String warehouseCode = QuantityConstant.DEFAULT_WAREHOUSE;
        String orderCode = map.get("orderCode");
        String containerCode = map.get("containerCode");
        String billType = map.get("billType");


        AjaxResult ajaxResult = handleMultiProcess("clearInventory", new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.orderStatus(warehouseCode, containerCode,orderCode,billType);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }

    @PostMapping("/binding")
    @ApiOperation("绑定库存")
    @ResponseBody
    @ApiLogger(apiName = "绑定库存", from="PDA")
    public AjaxResult binding(@RequestBody Map<String,String> map) {
        //3为纸皮
        //4为滑块
        String model = map.get("model");
        String locationCode = map.get("locationCode");
        if(StringUtils.isEmpty(locationCode)) {
            return AjaxResult.error("没有库位号");
        }
        if(StringUtils.isEmpty(model)) {
            return AjaxResult.error("没有型号");
        }
        AjaxResult ajaxResult = handleMultiProcess("clearInventory", new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.binding(model, locationCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }



    @PostMapping("/bufferStorage")
    @ApiOperation("入库缓存区入库")
    @ResponseBody
    @ApiLogger(apiName = "入库缓存区入库", from="PDA")
    public AjaxResult bufferStorage(@RequestBody Map<String,String> map) {
        String containerCode = map.get("containerCode");
        LambdaQueryWrapper<Container> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(Container::getCode, containerCode);
        Container container = containerService.getOne(queryWrapper);
        String location=container.getLocationCode();

        if (StringUtils.isEmpty(location))
        {
            return AjaxResult.error("这个容器没有库位，出问题了");
        }

        if(container == null) {
            return AjaxResult.error("没有这个容器");
        }
        AjaxResult ajaxResult = handleMultiProcess("innerReceipt", new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.bufferStorage(containerCode,location);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }


    @PostMapping("/shipmentDetails")
    @ApiOperation("扫箱码显示对应货通知单明细信息")
    @ResponseBody
    @ApiLogger(apiName = "缓存区异常信息扫码反馈显示出来", from="PDA")
    public AjaxResult shipmentDetails(@RequestBody Map<String,String> map) {
        String boxCode = map.get("boxCode");
        AjaxResult ajaxResult = handleMultiProcess("abnormalFeedback",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.shipmentDetails(boxCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }



    @PostMapping("/abnormalFeedback")
    @ApiOperation("缓存区异常信息扫码反馈显示出来")
    @ResponseBody
    @ApiLogger(apiName = "缓存区异常信息扫码反馈显示出来", from="PDA")
    public AjaxResult abnormalFeedback(@RequestBody Map<String,String> map) {
        String containerCode = map.get("containerCode");
        LambdaQueryWrapper<Container> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(Container::getCode, containerCode);
        Container container = containerService.getOne(queryWrapper);
        if(container == null) {
            return AjaxResult.error("没有这个容器");
        }
        AjaxResult ajaxResult = handleMultiProcess("abnormalFeedback",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.abnormalFeedback(containerCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }


    @PostMapping("/storageWriteWeight")
    @ApiOperation("入库口写入库重量(单片)")
    @ResponseBody
    @ApiLogger(apiName = "入库口写入库重量(单片)", from="PDA")
    public AjaxResult writeWeight(@RequestBody Map<String,String> map) {
        String containerCode = map.get("containerCode");
        String weight = map.get("weight");
        if (!receiptContainerHeaderService.lambdaUpdate()
                .eq(ReceiptContainerHeader::getContainerCode, containerCode)
                .set(ReceiptContainerHeader::getWeight, weight)
                .eq(ReceiptContainerHeader::getStatus,QuantityConstant.RECEIPT_CONTAINER_TASK).update())
        {
            throw new ServiceException("修改重量失败");
        }
        return AjaxResult.success("成功");
    }


    @PostMapping("/deleteReceiptDetails")
    @ApiOperation("入库任务删除明细")
    @ResponseBody
    @ApiLogger(apiName = "入库任务删除明细", from="PDA")
    public AjaxResult deleteReceiptDetails(@RequestBody Map<String,String> map) {
        String containerCode = map.get("containerCode");
        String boxCode = map.get("boxCode");
        if (StringUtils.isEmpty(containerCode)&&StringUtils.isEmpty(boxCode))
        {
            return AjaxResult.error("容器跟箱码。必填项不能为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("deleteReceiptDetails",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.deleteReceiptDetails(boxCode, containerCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }



    @PostMapping("/supplementaryWarehousingOrder")
    @ApiOperation("入库任务补充明细")
    @ResponseBody
    @ApiLogger(apiName = "入库任务补充明细", from="PDA")
    public AjaxResult supplementaryWarehousingOrder(@RequestBody Map<String,String> map) {
        String containerCode = map.get("containerCode");
        String boxCode = map.get("boxCode");
        String chipBarcode1 = map.get("chipBarcode1");
        if (StringUtils.isEmpty(containerCode)&&StringUtils.isEmpty(boxCode)&&StringUtils.isEmpty(chipBarcode1))
        {
            return AjaxResult.error("容器跟箱码。必填项不能为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("supplementaryWarehousingOrder",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.supplementaryWarehousingOrder(boxCode, containerCode,chipBarcode1);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }




    @PostMapping("/compositePatching")
    @ApiOperation("合盘补入箱码")
    @ResponseBody
    @ApiLogger(apiName = "合盘补入箱码", from="PDA")
    public AjaxResult compositePatching(@RequestBody Map<String, String> param) {
        String boxCode = param.get("boxCode");
        String containerCode= param.get("containerCode");
        AjaxResult ajaxResult = handleMultiProcess("compositePatching",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.compositePatching(boxCode, containerCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }


    @PostMapping("/queryContainer")
    @ApiOperation("根据箱码查虚拟容器号")
    @ResponseBody
    @ApiLogger(apiName = "根据箱码查虚拟容器号", from="PDA")
    public AjaxResult queryContainer(@RequestBody Map<String, String> param) {
        String boxCode = param.get("boxCode");
        AjaxResult ajaxResult = handleMultiProcess("queryContainer",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.queryContainer(boxCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }

    @PostMapping("/checkTracing")
    @ApiOperation("追溯-根据箱码或者片码进行追溯")
    @ResponseBody
    @ApiLogger(apiName = "根据箱码或者片码进行追溯", from="PDA")
    public AjaxResult checkTracing(@RequestBody Map<String, String> param) {
        //箱码
        String boxCode = param.get("boxCode");
        //片码
        String chipCode =  param.get("chipCode");

        if (StringUtils.isEmpty(boxCode)&&StringUtils.isEmpty(chipCode))
        {
            return AjaxResult.error("箱码或者片码必须传一个");
        }
        AjaxResult ajaxResult = handleMultiProcess("informationTracing",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.checkTracing(boxCode,chipCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }

    @PostMapping("/createShipment")
    @ApiOperation("创建销售出库单")
    @ResponseBody
    @ApiLogger(apiName = "创建销售出库单", from="PDA")
    public AjaxResult createShipment(@RequestBody PDAInventory pdaInventory) {
        String platformCode = pdaInventory.getPlatformCode();
        List<String> refereCodeList = pdaInventory.getReferCodeList();
        if(StringUtils.isEmpty(platformCode)) {
            return AjaxResult.error("没有月台号");
        }
        if (!(refereCodeList != null && refereCodeList.size() > 0)){
            return AjaxResult.error("没有订单");
        }
        AjaxResult ajaxResult = handleMultiProcess("createShipment",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.createShipment(platformCode, refereCodeList);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }

    @PostMapping("/getBoxInfoFromBoxCode")
    @ApiOperation("根据箱码获取整箱信息")
    @ResponseBody
    @ApiLogger(apiName = "根据箱码获取整箱信息", from="PDA")
    public AjaxResult getBoxInfoFromBoxCode(@RequestBody Map<String, String> param) {
        String boxCode = param.get("boxCode");
        if (StringUtils.isEmpty(boxCode)) {
            return AjaxResult.error("根据箱码获取整箱信息, 没有箱号");
        }
        LambdaQueryWrapper<InventoryHistoryDetail> inventoryHistoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryHistoryDetailLambdaQueryWrapper.eq(InventoryHistoryDetail::getBoxCode, boxCode);
        List<InventoryHistoryDetail> inventoryHistoryDetailList =
                inventoryHistoryDetailService.list(inventoryHistoryDetailLambdaQueryWrapper);
        if(inventoryHistoryDetailList.size() == 0) {
            return AjaxResult.error("根据箱码没有找到整箱信息");
        }
        InventoryHistoryDetail inventoryHistoryDetail = inventoryHistoryDetailList.get(0);
        String proPackagingStr = inventoryHistoryDetail.getProPackaing();
        if(StringUtils.isEmpty(proPackagingStr)) {
            return AjaxResult.error("没有包装字段");
        }
        LambdaQueryWrapper<ProPackaging> proPackagingLambdaQueryWrapper = Wrappers.lambdaQuery();
        proPackagingLambdaQueryWrapper.eq(ProPackaging::getNumber, proPackagingStr);
        ProPackaging proPackaging = proPackingService.getOne(proPackagingLambdaQueryWrapper);
        if(proPackaging == null) {
            return AjaxResult.error("没有包装信息");
        }
        int pieceBox = proPackaging.getPieceBox();
        List<InventoryHistoryDetail> subinventoryHistoryDetailList = inventoryHistoryDetailList.subList(0, pieceBox);
        return AjaxResult.success(subinventoryHistoryDetailList);
    }



    @PostMapping("/getContainerFullContainer")
    @ApiOperation("根据容器编码获取整箱信息")
    @ResponseBody
    @ApiLogger(apiName = "根据容器编码获取整箱信息", from="PDA")
    public AjaxResult getContainerFullContainer(@RequestBody Map<String, String> param) {
        String containerCode = param.get("containerCode");
        if (StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("根据箱码获取整箱信息, 没有容器号");
        }
        LambdaQueryWrapper<InventoryHistoryDetail> inventoryHistoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryHistoryDetailLambdaQueryWrapper.eq(InventoryHistoryDetail::getContainerCode, containerCode)
                .eq(InventoryHistoryDetail::getUserDef1,"销售出库");
        List<InventoryHistoryDetail> inventoryHistoryDetailList =
                inventoryHistoryDetailService.list(inventoryHistoryDetailLambdaQueryWrapper);
        if(inventoryHistoryDetailList.size() == 0) {
            return AjaxResult.error("根据箱码没有找到整箱信息");
        }
        return AjaxResult.success(inventoryHistoryDetailList);
    }

    @PostMapping("/getPingKuBoxCode")
    @ApiOperation("从平库或者备货区查询箱码")
    @ResponseBody
    @ApiLogger(apiName = "从平库或者备货区查询箱码", from="PDA")
    public AjaxResult getPingKuBoxCode(@RequestBody Map<String, String> param) {
        String boxCode = param.get("boxCode");
        if (StringUtils.isEmpty(boxCode)) {
            return AjaxResult.error("根据箱码获取整箱信息, 没有箱号");
        }
        LambdaQueryWrapper<InventoryDetail> inventoryDetailLambdaQueryWrapper = Wrappers.lambdaQuery();
        inventoryDetailLambdaQueryWrapper.eq(InventoryDetail::getBoxCode, boxCode)
                .ne(InventoryDetail::getZoneCode,QuantityConstant.ZONE_LK);
        List<InventoryDetail> inventoryDetailList =
                inventoryDetailService.list(inventoryDetailLambdaQueryWrapper);
        if(inventoryDetailList.size() == 0) {
            return AjaxResult.error("根据箱码没有找到整箱信息");
        }
        InventoryDetail inventoryDetail = inventoryDetailList.get(0);
        String proPackagingStr = inventoryDetail.getProPackaging();
        if(StringUtils.isEmpty(proPackagingStr)) {
            return AjaxResult.error("没有包装字段");
        }
        LambdaQueryWrapper<ProPackaging> proPackagingLambdaQueryWrapper = Wrappers.lambdaQuery();
        proPackagingLambdaQueryWrapper.eq(ProPackaging::getNumber, proPackagingStr);
        ProPackaging proPackaging = proPackingService.getOne(proPackagingLambdaQueryWrapper);
        if(proPackaging == null) {
            return AjaxResult.error("没有包装信息");
        }
        int pieceBox = proPackaging.getPieceBox();
        List<InventoryDetail> subinventoryHistoryDetailList = inventoryDetailList.subList(0, pieceBox);
        return AjaxResult.success(subinventoryHistoryDetailList);
    }


    @PostMapping("/flatLibraryAdjustment")
    @ApiOperation("平库调整")
    @ResponseBody
    @ApiLogger(apiName = "平库调整", from="PDA")
    public AjaxResult flatLibraryAdjustment(@RequestBody Map<String, String> param) {
        String boxCode = param.get("boxCode");
        String chipCode =  param.get("chipCode");
        String containerCode = param.get("containerCode");
        //0是增加库存  1是删除库存
        String remove = param.get("remove");
        if (StringUtils.isEmpty(boxCode)) {
            return AjaxResult.error("调整库存, 没有箱号");
        }
        if (StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("调整库存, 没有木托盘标签码");
        }
        if (StringUtils.isEmpty(remove)) {
            return AjaxResult.error("没有标识判断是删除库存还是添加库存");
        }
        AjaxResult ajaxResult = handleMultiProcess("createShipment",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.flatLibraryAdjustment(boxCode, containerCode,remove,chipCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }


    @PostMapping("/returnOfGoodsReceipt")
    @ApiOperation("销售退货通知单入库")
    @ResponseBody
    @ApiLogger(apiName = "销售退货通知单入库", from="PDA")
    @Transactional
    public AjaxResult returnOfGoodsReceipt(@RequestBody ReturnOfGoods returnOfGoods) {
        String containerCode = returnOfGoods.getContainerCode();
        List<BoxInfo> listBoxInfos = returnOfGoods.getListBoxInfo();
        String receiptCode = returnOfGoods.getReceiptCode();
        String receiptDetailId=returnOfGoods.getReceiptDetailId();
        if (StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("退货通知单入库, 没有托盘号");
        }
        if (StringUtils.isEmpty(receiptCode)) {
            return AjaxResult.error("退货通知单入库, 没有入库单号");
        }
        if (!(listBoxInfos != null && listBoxInfos.size() > 0)) {
            return AjaxResult.error("退货通知单入库, 没有箱码信息");
        }
        AjaxResult ajaxResult = handleMultiProcess("returnOfGoodsReceipt",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.returnOfGoodsReceipt(containerCode,
                        receiptCode, listBoxInfos,receiptDetailId);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }



    @PostMapping("/returnToFlatWarehouse")
    @ApiOperation("退货入平库")
    @ResponseBody
    @ApiLogger(apiName = "退货入平库", from="PDA")
    @Transactional
    public AjaxResult returnToFlatWarehouse(@RequestBody ReturnOfGoods returnOfGoods) {
        String containerCode =containerService.createContainer("5","D");
        String locationCode = returnOfGoods.getLocationCode();
        List<BoxInfo> listBoxInfos = returnOfGoods.getListBoxInfo();
        String receiptCode = returnOfGoods.getReceiptCode();
        String receiptDetailId=returnOfGoods.getReceiptDetailId();
        if (StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("退货通知单入库, 没有托盘号");
        }
        if (StringUtils.isEmpty(receiptCode)) {
            return AjaxResult.error("退货通知单入库, 没有入库单号");
        }
        if (!(listBoxInfos != null && listBoxInfos.size() > 0)) {
            return AjaxResult.error("退货通知单入库, 没有箱码信息");
        }
        AjaxResult ajaxResult = handleMultiProcess("returnOfGoodsReceipt",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.returnToFlatWarehouse(containerCode,locationCode,
                        receiptCode, listBoxInfos,receiptDetailId);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }




    @PostMapping("/qualityInspectionReceipt")
    @ApiOperation("质检其他入库单重新入库")
    @ResponseBody
    @ApiLogger(apiName = "质检其他入库单重新入库", from="PDA")
    @Transactional
    public AjaxResult qualityInspectionReceipt(@RequestBody ReturnOfGoods returnOfGoods) {
        String containerCode = returnOfGoods.getContainerCode();
        List<BoxInfo> listBoxInfos = returnOfGoods.getListBoxInfo();
        String receiptCode = returnOfGoods.getReceiptCode();
        String receiptDetailId=returnOfGoods.getReceiptDetailId();
        String orderCode = returnOfGoods.getOrderCode();
        if (StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("质检重新入库, 没有托盘号");
        }
        if (StringUtils.isEmpty(receiptCode)) {
            return AjaxResult.error("质检重新入库, 没有入库单号");
        }
        if (!(listBoxInfos != null && listBoxInfos.size() > 0)) {
            return AjaxResult.error("质检重新入库, 没有箱码信息");
        }
        AjaxResult ajaxResult = handleMultiProcess("returnOfGoodsReceipt",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.qualityInspectionReceipt(containerCode,
                        receiptCode, listBoxInfos, orderCode,receiptDetailId);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }

    @PostMapping("/restockingOfFlatWarehouse")
    @ApiOperation("平库或者备货区重新入库")
    @ResponseBody
    @ApiLogger(apiName = "平库或者备货区重新入库", from="PDA")
    @Transactional
    public AjaxResult restockingOfFlatWarehouse(@RequestBody ReturnOfGoods returnOfGoods) {
        String containerCode = returnOfGoods.getContainerCode();
        List<BoxInfo> listBoxInfos = returnOfGoods.getListBoxInfo();
        String receiptCode = returnOfGoods.getReceiptCode();
        String receiptDetailId=returnOfGoods.getReceiptDetailId();
        String orderCode = returnOfGoods.getOrderCode();
        if (StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("平库或者备货区重新入库, 没有托盘号");
        }
        if (StringUtils.isEmpty(receiptCode)) {
            return AjaxResult.error("平库或者备货区重新入库, 没有入库单号");
        }
        if (!(listBoxInfos != null && listBoxInfos.size() > 0)) {
            return AjaxResult.error("平库或者备货区重新入库, 没有箱码信息");
        }
        AjaxResult ajaxResult = handleMultiProcess("returnOfGoodsReceipt",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.restockingOfFlatWarehouse(containerCode,
                        receiptCode, listBoxInfos, orderCode,receiptDetailId);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }


    @PostMapping("/supplementaryWarehousing")
    @ApiOperation("销售尾托补充入库")
    @ResponseBody
    @ApiLogger(apiName = "销售尾托补充入库", from="PDA")
    public AjaxResult supplementaryWarehousing(@RequestBody ReturnOfGoods returnOfGoods) {
        String containerCode = returnOfGoods.getContainerCode();
        List<BoxInfo> listBoxInfos = returnOfGoods.getListBoxInfo();
        String receiptCode = returnOfGoods.getReceiptCode();
        String receiptDetailId=returnOfGoods.getReceiptDetailId();
        String orderCode = returnOfGoods.getOrderCode();
        String orderName = returnOfGoods.getOrderCode();
        if (StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("退货通知单入库, 没有托盘号");
        }
        if (StringUtils.isEmpty(receiptCode)) {
            return AjaxResult.error("退货通知单入库, 没有入库单号");
        }
        if (StringUtils.isEmpty(orderCode)) {
            return AjaxResult.error("退货通知单入库, 没有订单号");
        }
        if (StringUtils.isEmpty(orderName)) {
            return AjaxResult.error("退货通知单入库, 没有订单名称");
        }
        if (!(listBoxInfos != null && listBoxInfos.size() > 0)) {
            return AjaxResult.error("退货通知单入库, 没有箱码信息");
        }
        AjaxResult ajaxResult = handleMultiProcess("supplementaryWarehousing",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.supplementaryWarehousing(containerCode,
                        receiptCode, listBoxInfos, orderCode, orderName,receiptDetailId);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }





    @PostMapping("/containerQuery")
    @ApiOperation("查询同型号的托盘")
    @ResponseBody
    @ApiLogger(apiName = "查询同型号的托盘", from="PDA")
    public AjaxResult containerQuery(@RequestBody Map<String,String> map) {
        String materialCode = map.get("materialCode");
        String level = map.get("level");
        String color = map.get("color");
        String proPackaging = map.get("proPackaging");
        String productSchedule = map.get("productSchedule");
        String batch = map.get("batch");
        String boxQty =map.get("boxQty");

        if (StringUtils.isEmpty(materialCode)||StringUtils.isEmpty(materialCode)&&
        StringUtils.isEmpty(level)||
        StringUtils.isEmpty(color)||
        StringUtils.isEmpty(proPackaging)||
        StringUtils.isEmpty(productSchedule)||
        StringUtils.isEmpty(batch)||
                StringUtils.isEmpty(boxQty))
        {
            return AjaxResult.error("各项参数不能为空");
        }

        AjaxResult ajaxResult = handleMultiProcess("containerQuery",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.containerQuery(materialCode,
                        level, color, proPackaging, productSchedule,batch,Integer.valueOf(boxQty));
                return ajaxResult;
            }
        });
        return ajaxResult;
    }



    @PostMapping("/shipmentContainer")
    @ApiOperation("整托出库")
    @ResponseBody
    @ApiLogger(apiName = "整托出库", from="PDA")
    public AjaxResult shipmentContainer(@RequestBody BoxDomain boxDomain) {
        String containerCode = boxDomain.getContainerCode();
        if(StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("整托出库, 托盘号为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("shipmentContainer",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.shipmentContainer(containerCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }


    @PostMapping("/releaseInventory")
    @ApiOperation("质检区释放")
    @ResponseBody
    @ApiLogger(apiName = "质检区释放", from="PDA")
    public AjaxResult releaseInventory(@RequestBody BoxDomain boxDomain) {
        String containerCode = boxDomain.getContainerCode();
        if(StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("质检区释放为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("releaseInventory",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.releaseInventory(containerCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }




    @PostMapping("/shipmentBox")
    @ApiOperation("整箱出库")
    @ResponseBody
    @ApiLogger(apiName = "整箱出库", from="PDA")
    public AjaxResult shipmentBox(@RequestBody BoxDomain boxDomain) {
        String containerCode = boxDomain.getContainerCode();
        String boxCode = boxDomain.getBoxCode();
        if(StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("整箱出库, 托盘号为空");
        }
        if(StringUtils.isEmpty(boxCode)) {
            return AjaxResult.error("整箱出库, 箱码为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("shipmentBox", new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.shipmentBox(containerCode, boxCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }



    /**
     * 异常口发货到备货区
     */
    @PostMapping("/PSTStockingArea")
    @ApiOperation("异常口发货到备货区")
    @ResponseBody
    @ApiLogger(apiName = "异常口发货到备货区", from="异常口发货到备货区")
    public AjaxResult PSTStockingArea(@RequestBody AbnormalPortShipment abnormalPortShipment) {
        String containerCode = abnormalPortShipment.getContainerCode();
        List<String> boxCodes = abnormalPortShipment.getBoxCodes();
        AjaxResult ajaxResult = handleMultiProcess("bulkDelivery",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.PSTStockingArea(containerCode,boxCodes);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }

    @PostMapping("/bulkTransfer")
    @ApiOperation("平库批量移库")
    @ResponseBody
    @ApiLogger(apiName = "平库批量移库", from="PDA")
    public AjaxResult bulkTransfer(@RequestBody BulkTransferDomain bulkTransferDomain) {
        String containerCode = bulkTransferDomain.getContainerCode();
        String locationCode = bulkTransferDomain.getLocationCode();
        if(StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("平库托盘号为空");
        }
        if(StringUtils.isEmpty(locationCode)) {
            return AjaxResult.error("平库库位号为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("bulkTransfer(", new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = pdaService.bulkTransfer(containerCode, locationCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }
}