package com.huaheng.api.erp.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONException;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.huaheng.api.erp.domain.*;
import com.huaheng.api.erp.domain.tracedBack.*;
import com.huaheng.api.erp.service.CodingService;
import com.huaheng.api.wcs.service.WcsService;
import com.huaheng.common.constant.QuantityConstant;
import com.huaheng.common.exception.service.ServiceException;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.common.utils.http.OkHttpUtils;
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.framework.web.page.PageDomain;
import com.huaheng.framework.web.page.TableDataInfo;
import com.huaheng.framework.web.page.TableSupport;
import com.huaheng.pc.config.location.domain.Location;
import com.huaheng.pc.config.proPackaging.domain.ProPackaging;
import com.huaheng.pc.config.proPackaging.service.IProPackagingService;
import com.huaheng.pc.config.proPackaging.service.impl.ProPackagingServiceImpl;
import com.huaheng.pc.inventory.inventoryHeader.service.InventoryHeaderService;
import com.huaheng.pc.inventory.loadingConfirmed.domain.loadingConfirmed;
import com.huaheng.pc.shipment.shipmentHeader.domain.ShipmentHeader;
import com.huaheng.pc.shipment.shipmentHeader.service.ShipmentHeaderService;
import com.huaheng.pc.task.agvTask.domain.AgvTask;
import com.huaheng.pc.task.agvTask.service.AgvTaskService;
import com.huaheng.pc.task.taskHeader.domain.TaskHeader;
import io.swagger.annotations.ApiOperation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

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

/**
WMS和赋码系统交互
 * @author 游杰
 */
@RestController
@RequestMapping("/API/WMS/v2")
public class CodingController extends BaseController {

    @Resource
    private CodingService codingService;
    @Resource
    private IProPackagingService proPackagingService;
    @Resource
    private ShipmentHeaderService shipmentHeaderService;


    @PostMapping("/receipt")
    @ApiOperation("入库组盘信息")
    @ResponseBody
    @ApiLogger(apiName = "入库组盘信息", from="码垛系统")
    public AjaxResult receipt(@RequestBody ERPReceipt erpReceipt) {
        if(erpReceipt == null) {
            return AjaxResult.error("入库组盘信息为空");
        }
        String Pack="";
        Integer so = 0;
        List<String> Box=new ArrayList<>();
        for(int i = 0;i<erpReceipt.getListBoxInfo().size();i++)
        {
            if(Box.contains(erpReceipt.getListBoxInfo().get(i).getBoxCode()))
            {
                return AjaxResult.error("箱码不能重复!!"+erpReceipt.getListBoxInfo().get(i).getBoxCode());
            }
            Box.add(erpReceipt.getListBoxInfo().get(i).getBoxCode());

            if (Pack.equals(erpReceipt.getListBoxInfo().get(i).getProPackaging())==false)
            {
                if (StringUtils.isNotEmpty(erpReceipt.getListBoxInfo().get(i).getProPackaging())){
                    Pack=erpReceipt.getListBoxInfo().get(i).getProPackaging();
                }
                LambdaQueryWrapper<ProPackaging> proPackagingLambdaQueryWrapper = Wrappers.lambdaQuery();
                proPackagingLambdaQueryWrapper.eq(ProPackaging::getName,Pack);
                ProPackaging packagingServiceOne = proPackagingService.getOne(proPackagingLambdaQueryWrapper);
                if (packagingServiceOne != null){
                    so=packagingServiceOne.getPieceBox();
                }

            }
            Integer integer = Integer.valueOf(String.valueOf(erpReceipt.getListBoxInfo().get(i).getQty()));


            if (erpReceipt.getTotalBoxes()==0)
            {
                return AjaxResult.error("箱数错误，不该为0");
            }

            if (erpReceipt.getTotalChips()==0)
            {
                return AjaxResult.error("片数错误，不该为0");
            }

            if (!Integer.valueOf(String.valueOf(erpReceipt.getListBoxInfo().get(i).getQty())).equals(so))
            {
                return AjaxResult.error("片数给的与发来的不对");
            }

            if (erpReceipt.getListBoxInfo().get(i).getChipInfos().size()!=so)
            {
                return AjaxResult.error("箱码"+erpReceipt.getListBoxInfo().get(i).getBoxCode()+"所对应的片码不相符合");
            }


        }

        String containerCode = erpReceipt.getContainerCode();
        String receiptCode = erpReceipt.getReceiptCode();
        String position = erpReceipt.getRequestInCode();
        String orderCode = erpReceipt.getOrderCode();
        String orderName = erpReceipt.getOrderName();
        Integer toalCases= erpReceipt.getTotalChips();
        BigDecimal weight = erpReceipt.getPieceWeight();
        List<BoxInfo> boxInfoList = erpReceipt.getListBoxInfo();
        int stack = erpReceipt.getStack();
        int qc = erpReceipt.getQc();
        int orderFinish = erpReceipt.getOrderFinish();
        int type = erpReceipt.getType();
        String k3Code = erpReceipt.getK3Code();
        String inType = erpReceipt.getInType();
        String operatorName = erpReceipt.getOperatorName();
        String qualityorName = erpReceipt.getQualityorName();

        if (!k3Code.equals(orderCode)||!k3Code.equals(receiptCode))
        {
            return AjaxResult.error("k3Code,orderCode,receiptCode三个字段是否不一致?");
        }
        if(toalCases==0) {
            return AjaxResult.error("入库组盘信息,总箱数为空");
        }

        if(StringUtils.isEmpty(receiptCode)) {
            return AjaxResult.error("入库组盘信息,排产订单编码为空");
        }
        if(StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("入库组盘信息,托盘号为空");
        }
        if(StringUtils.isEmpty(position)) {
            return AjaxResult.error("入库组盘信息,码垛站台位置为空");
        }
        if(StringUtils.isEmpty(orderCode)) {
            return AjaxResult.error("入库组盘信息,订单信息为空");
        }
        if(StringUtils.isEmpty(orderName)) {
            return AjaxResult.error("入库组盘信息,订单名称为空");
        }
        if(boxInfoList == null) {
            return AjaxResult.error("入库组盘信息,箱信息为空");
        }

        AjaxResult ajaxResult = handleMultiProcess("innerReceipt",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = codingService.innerReceipt(containerCode,
                        position, receiptCode, orderCode, orderName, boxInfoList,
                        stack, qc, orderFinish,weight, type, k3Code, inType, operatorName, qualityorName,toalCases);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }


    @PostMapping("/inventoryCheck")
    @ApiOperation("库存查看接口")
    @ResponseBody
    @ApiLogger(apiName = "库存查看接口", from="库存查看接口")
    public AjaxResult inventoryCheck(@RequestBody Map<String,String> map) {
        String boxCode =  map.get("boxCode");
        String containerCode =  map.get("containerCode");
        //片码
        String chipCode =  map.get("chipCode");
        AjaxResult ajaxResult = handleMultiProcess("brickFalling",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = codingService.inventoryCheck(boxCode,containerCode,chipCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }



    //查立库存在的系统库存位置
    @PostMapping("/PDACheck")
    @ApiOperation("PDA查看接口")
    @ResponseBody
    @ApiLogger(apiName = "PDA查看接口", from="PDA查看接口")
    public AjaxResult PDACheck(@RequestBody Map<String,String> map) {
        String boxCode =  map.get("boxCode");
        String containerCode =  map.get("containerCode");
        //片码
        String chipCode =  map.get("chipCode");
        List<MaterialInformation> materialInformationList= codingService.PDACheck(boxCode,containerCode,chipCode);
        if (materialInformationList.isEmpty())
        {
            return AjaxResult.error("数据为空");
        }
        return AjaxResult.success(materialInformationList);
    }

    @Resource
    private AgvTaskService agvTaskService;
    @Resource
    private WcsService wcsService;
    @Resource
    private InventoryHeaderService inventoryService;

    @PostMapping("/createEmpty")
    @ApiOperation("入库口空托入库+agv一条龙")
    @Log(title = "移动端空托入库", action = BusinessType.OTHER)
    @Transactional
    public AjaxResult createEmpty(@RequestBody Map<String, String> param) {
        String containerCode = param.get("containerCode");
        String fromPort = param.get("fromPort");
        String sTPoint = param.get("sTPoint");

        String toPort="";
        if (fromPort.equals(QuantityConstant.PORT_P1005)) {
            toPort = QuantityConstant.PORT_P1004;
        }

        if (fromPort.equals(QuantityConstant.PORT_P1001)) {
            toPort = QuantityConstant.PORT_P1000;
        }


        AjaxResult taskFromTo = agvTaskService.start("CS0001", QuantityConstant.ZONE_LK, containerCode,
                sTPoint,toPort, QuantityConstant.PLATFORM_CODING, 0);
        if (taskFromTo.hasErr()) {
            throw new ServiceException("生成agv任务失败"+taskFromTo.getMsg());
        }

        return  inventoryService.createEmptyIn(containerCode, "",fromPort);
    }



    //查立库存在的系统库存位置
    @PostMapping("/PDALoading")
    @ApiOperation("PDA查看装车历史")
    @ResponseBody
    @ApiLogger(apiName = "装车历史查看", from="装车历史查看")
    public AjaxResult PDALoading(@RequestBody Map<String,String> map) {
        String locationCode =  map.get("locationCode");
        String containerCode =  map.get("containerCode");
        String shipmentHeaderCode =  map.get("shipmentHeaderCode");
        String referCode =  map.get("referCode");
        String operator =  map.get("operator");

        List<loadingConfirmed> loadingConfirmedList= codingService.PDALoading(locationCode,containerCode,shipmentHeaderCode,referCode,operator);
        return AjaxResult.success(loadingConfirmedList);
    }

    @PostMapping("/agvGetLocation")
    @ApiOperation("agv重新获取库位")
    @ApiLogger(apiName = "agv重新获取库位", from="agv")
    public AjaxResult agvGetLocation(@RequestBody Map<String, String> param) {
        String containerCode =  param.get("containerCode");
        String taskNo =  param.get("taskNo");
        String zoneCode =  param.get("zoneCode");
        if (StringUtils.isEmpty(containerCode)||StringUtils.isEmpty(taskNo))
        {
            return AjaxResult.error("有请求参数为空");
        }
        AjaxResult ajaxResult = handleQuest("agvGetLocation",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = codingService.agvGetLocation(containerCode,taskNo,zoneCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }




    @PostMapping("/brickFalling")
    @ApiOperation("掉砖pda接口")
    @ResponseBody
    @ApiLogger(apiName = "掉砖pda接口", from="掉砖pda接口")
    public AjaxResult brickFalling(@RequestBody Map<String,String> map) {
        String boxCode =  map.get("boxCode");
        String containerCode =  map.get("containerCode");
        String chipCode =  map.get("chipCode");
        if(StringUtils.isEmpty(boxCode)) {
            return AjaxResult.error("箱码不为空");
        }
        if(StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("托盘号不为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("brickFalling",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = codingService.brickFalling(boxCode,containerCode,chipCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }


    @PostMapping("/labelPrinting")
    @ApiOperation("pda补标签功能")
    @ResponseBody
    @ApiLogger(apiName = "pda补标签功能", from="pda补标签功能")
    public AjaxResult labelPrinting(@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("brickFalling",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = codingService.labelPrinting(containerCode,boxCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }



    /**
     * 替换备货区的 其他地方不能替换 而且在追溯里面也一并替换
     */
    @PostMapping("/codeSubstitution")
    @ApiOperation("备货区箱码替换")
    @ResponseBody
    @ApiLogger(apiName = "备货区箱码替换", from="备货区箱码替换")
    public AjaxResult codeSubstitution(@RequestBody Map<String,String> map) {
        //要被替换掉的初始箱码
        String boxCode = map.get("boxCode");
        //要替换的箱码
        String toBoxCode = map.get("toBoxCode");

        String chipCode1 = map.get("chipCode1");
        //新片码
        String chipCode2 = map.get("chipCode2");


        //容器号
        String containerCode =  map.get("containerCode");
        if(StringUtils.isEmpty(boxCode)) {
            return AjaxResult.error("待箱码不为空");
        }
        if(StringUtils.isEmpty(toBoxCode)) {
            return AjaxResult.error("箱码不为空");
        }
        if(StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("托盘号不为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("codeSubstitution",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = codingService.codeSubstitution(boxCode,toBoxCode,chipCode1,chipCode2,containerCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }



    /**
     * 备货区插入
     */
    @PostMapping("/boxCodeInsert")
    @ApiOperation("备货区插入")
    @ResponseBody
    @Transactional
    @ApiLogger(apiName = "备货区插入", from="备货区插入")
    public AjaxResult boxCodeInsert(@RequestBody Map<String,String> map) {
        //备货区要插那一箱的箱码 根据箱码找组织
        String containerCode =  map.get("boxCode");
        //库里面出来的箱码
        String toBoxCode =  map.get("toBoxCode");
        if(StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("托盘号不能为空");
        }
        if(StringUtils.isEmpty(toBoxCode)) {
            return AjaxResult.error("库里面出来的箱码不为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("codeSubstitution",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = codingService.boxCodeInsert(containerCode,toBoxCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }


    /**
     * PDA散片出库功能
     */
    @PostMapping("/bulkDelivery")
    @ApiOperation("PDA散片出库功能")
    @ResponseBody
    @ApiLogger(apiName = "PDA散片出库功能", from="PDA散片出库功能")
    public AjaxResult bulkDelivery(@RequestBody Map<String,String> map) {
        //片码
        String chipCode =  map.get("chipCode");
        //箱码
        String boxCode =  map.get("boxCode");
        //
        String shipmentCode =  map.get("shipmentCode");

        //出库单明细
        String shipmentDetailId =  map.get("shipmentDetailId");

        if(StringUtils.isEmpty(boxCode)) {
            return AjaxResult.error("箱码不能为空");
        }
        if(StringUtils.isEmpty(chipCode)) {
            return AjaxResult.error("片码不能为空");
        }
        if(StringUtils.isEmpty(shipmentCode)) {
            return AjaxResult.error("容器号不能为空");
        }
        if (StringUtils.isEmpty(shipmentDetailId))
        {
            return  AjaxResult.error("明细id不能为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("bulkDelivery",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = codingService.bulkDelivery(chipCode,boxCode,shipmentCode,shipmentDetailId);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }

    /**
     * 发货单据绑定功能
     */
    @PostMapping("/flatLibraryBinding")
    @ApiOperation("平库-发货单据绑定功能")
    @ResponseBody
    @Transactional
    @Log(title = "平库-发货单据绑定功能", operating = "平库-发货单据绑定功能", action = BusinessType.INSERT)
    public AjaxResult flatLibraryBinding(@RequestBody Map<String,String> map) {
        String containerCode =  map.get("containerCode");

        String shipmentDetailId =  map.get("shipmentDetailId");

        if(StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("托盘号不为空");
        }
        if(StringUtils.isEmpty(shipmentDetailId)) {
            return AjaxResult.error("出库单号不能为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("bulkDelivery",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = codingService.flatLibraryBinding(containerCode,shipmentDetailId);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }

    /**
     * PDA补充到散片库存功能
     */
    @PostMapping("/loosePieceInventory")
    @ApiOperation("补充到散片库存功能")
    @ResponseBody
    @ApiLogger(apiName = "补充到散片库存功能", from="PDA")
    public AjaxResult loosePieceInventory(@RequestBody Map<String,String> map) {
        //片码
        String chipCodes =  map.get("chipCodes");
        //箱码 非必填
        String boxCode =  map.get("boxCode");
        //库位
        String locationCode =  map.get("locationCode");

        if(StringUtils.isEmpty(chipCodes)) {
            return AjaxResult.error("片码不能为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("bulkDelivery",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = codingService.loosePieceInventory(chipCodes,boxCode,locationCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }






    /**
     * 散片示订单列表
     */
    @PostMapping("/orderList")
    @ApiOperation("散片示订单列表")
    @ResponseBody
    public TableDataInfo orderList(ShipmentHeader shipmentHeader) {
        PageDomain pageDomain = TableSupport.buildPageRequest();
        Integer pageNum = pageDomain.getPageNum();
        Integer pageSize = pageDomain.getPageSize();


        LambdaQueryWrapper<ShipmentHeader> shipmentHeaderLambdaQueryWrapper = Wrappers.lambdaQuery();
        shipmentHeaderLambdaQueryWrapper.and(q->
                q.eq(ShipmentHeader::getShipmentType, QuantityConstant.SHIPMENT_TYPE_DELIVERY)
                        .or().eq(ShipmentHeader::getShipmentType, QuantityConstant.SHIPMENT_TYPE_OTHER))
                .and(w->w.like(ShipmentHeader::getCode,shipmentHeader.getCode())
                        .or()
                        .like(ShipmentHeader::getReferCode, shipmentHeader.getReferCode()))
                .orderByDesc(ShipmentHeader::getCreated);

        if (com.huaheng.common.utils.StringUtils.isNotNull(pageNum) && com.huaheng.common.utils.StringUtils.isNotNull(pageSize)){

            Page<ShipmentHeader> page = new Page<>(pageNum, pageSize);
            IPage<ShipmentHeader> iPage = shipmentHeaderService.page(page, shipmentHeaderLambdaQueryWrapper);
            List<ShipmentHeader> iPages = iPage.getRecords();
            return getMpDataTable(iPages, iPage.getTotal());
        }else
        {
            List<ShipmentHeader> shipmentHeaders= shipmentHeaderService.list(shipmentHeaderLambdaQueryWrapper);
            return getDataTable(shipmentHeaders);
        }

    }



    @PostMapping("/inventory")
    @ApiOperation("盘点接口")
    @ResponseBody
    @ApiLogger(apiName = "盘点接口", from="盘点接口")
    public AjaxResult inventory(@RequestBody Map<String,String> map) {
        String boxCode =  map.get("boxCode");
        String containerCode =  map.get("containerCode");
        String chipCode =  map.get("chipCode");
        if(StringUtils.isEmpty(boxCode)) {
            return AjaxResult.error("箱码不为空");
        }
        if(StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("托盘号不为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("inventory",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = codingService.inventory(boxCode,containerCode,chipCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }

    @PostMapping("/freeFromInventory")
    @ApiOperation("直接回库-免盘点")
    @ResponseBody
    @ApiLogger(apiName = "盘点接口", from="盘点接口")
    public AjaxResult freeFromInventory(@RequestBody Map<String,String> map) {
        String containerCode =  map.get("containerCode");
        if(StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("托盘号不为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("inventory",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = codingService.freeFromInventory(containerCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }




    @PostMapping("/goOnline")
    @ApiOperation("人工位上线通知wcs")
    @ResponseBody
    @ApiLogger(apiName = "人工位上线通知wcs", from="人工位上线通知wcs")
    public AjaxResult goOnline(@RequestBody Map<String,String> map) {
        String port =  map.get("port");
        String barcode =  map.get("barcode");
        if(StringUtils.isEmpty(port)) {
            return AjaxResult.error("站台");
        }
        if(StringUtils.isEmpty(barcode)) {
            return AjaxResult.error("托盘号不为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("inventory",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = codingService.goOnline(port,barcode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }






    @PostMapping("/chipCode")
    @ApiOperation("根据箱码查询片码")
    @ResponseBody
    @ApiLogger(apiName = "根据箱码查询片码", from="根据箱码查询片码")
    public AjaxResult chipCode(@RequestBody Map<String,String> map) {
        String boxCode =  map.get("boxCode");
        if(StringUtils.isEmpty(boxCode)) {
            return AjaxResult.error("箱码不为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("inventory",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = codingService.chipCode(boxCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }


    @PostMapping("/flatLibraryChipCode")
    @ApiOperation("平库库存根据箱码查询片码")
    @ResponseBody
    @ApiLogger(apiName = "平库库存根据箱码查询片码", from="平库库存根据箱码查询片码")
    public AjaxResult flatLibraryChipCode(@RequestBody Map<String,String> map) {
        String boxCode =  map.get("boxCode");
        if(StringUtils.isEmpty(boxCode)) {
            return AjaxResult.error("箱码不为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("inventory",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = codingService.flatLibraryChipCode(boxCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }


    @PostMapping("/scatteredFilmChip")
    @ApiOperation("散片出库根据箱码查询片码")
    @ResponseBody
    @ApiLogger(apiName = "散片出库根据箱码查询片码", from="散片出库根据箱码查询片码")
    public AjaxResult scatteredFilmChip(@RequestBody Map<String,String> map) {
        String boxCode =  map.get("boxCode");
        if(StringUtils.isEmpty(boxCode)) {
            return AjaxResult.error("箱码不为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("inventory",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = codingService.scatteredFilmChip(boxCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }



    @PostMapping("/productInformation")
    @ApiOperation("查询产品信息")
    @ResponseBody
    @ApiLogger(apiName = "查询产品信息(打托后)", from="查询产品信息")
    public AjaxResult<List<MaterialDom>>  productInformation(@RequestBody Map<String,String> map) {
        String boxCode =  map.get("boxCode");
        String chipCode =  map.get("chipCode");
        String isDepth =  map.get("isDepth");
        if(StringUtils.isEmpty(boxCode)&&StringUtils.isEmpty(chipCode)) {
            throw new ServiceException("箱码跟片码信息不能都为空");
        }
        return AjaxResult.success(codingService.productInformation(boxCode,chipCode,isDepth));
    }


    @PostMapping("/productionInformation")
    @ApiOperation("生产信息查询")
    @ResponseBody
    @ApiLogger(apiName = "生产信息查询", from="生产信息查询")
    public AjaxResult<ProduceDom>  productionInformation(@RequestBody Map<String,String> map) {
        String boxCode =  map.get("boxCode");
        String chipCode =  map.get("chipCode");
        String isDepth =  map.get("isDepth");
        if(StringUtils.isEmpty(boxCode)&&StringUtils.isEmpty(chipCode)) {
            throw new ServiceException("箱码跟片码信息不能都为空");
        }
        return AjaxResult.success(codingService.productionInformation(boxCode,chipCode,isDepth));
    }


    @PostMapping("/inboundInformation")
    @ApiOperation("入库信息")
    @ResponseBody
    @ApiLogger(apiName = "入库信息", from="入库信息")
    public AjaxResult<List<StorageDom>>  inboundInformation(@RequestBody Map<String,String> map) {
        String boxCode =  map.get("boxCode");
        String chipCode =  map.get("chipCode");
        String isDepth =  map.get("isDepth");
        if(StringUtils.isEmpty(boxCode)&&StringUtils.isEmpty(chipCode)) {
            throw new ServiceException("箱码跟片码信息不能都为空");
        }
        return AjaxResult.success(codingService.inboundInformation(boxCode,chipCode,isDepth));
    }


    @PostMapping("/itemInformation")
    @ApiOperation("物料信息")
    @ResponseBody
    @ApiLogger(apiName = "物料信息", from="物料信息")
    public AjaxResult<List<LogisticsDom>>  itemInformation(@RequestBody Map<String,String> map) {
        String boxCode =  map.get("boxCode");
        String chipCode =  map.get("chipCode");
        String isDepth =  map.get("isDepth");
        if(StringUtils.isEmpty(boxCode)&&StringUtils.isEmpty(chipCode)) {
            throw new ServiceException("箱码跟片码信息不能都为空");
        }
        return AjaxResult.success(codingService.itemInformation(boxCode,chipCode,isDepth));
    }


    @PostMapping("/shipmentCheckNew")
    @ApiOperation("出库确认新")
    @ResponseBody
    @ApiLogger(apiName = "出库确认新", from="出库确认新")
    public AjaxResult shipmentCheckNew(@RequestBody Map<String,String> map) {
        String containerCode =  map.get("containerCode");
        String shipmentCode =  map.get("shipmentCode");
        String operator =  map.get("operator");
        if(StringUtils.isEmpty(containerCode)&&StringUtils.isEmpty(containerCode)) {
            return AjaxResult.error("容器号不能为空");
        }
        AjaxResult ajaxResult = handleMultiProcess("shipmentCheck",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = codingService.findShipmentRecordByLs(containerCode,shipmentCode,operator);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }
@PostMapping("/shipmentCheck")
@ApiOperation("出库确认")
@ResponseBody
public AjaxResult shipmentCheck(@RequestBody Map<String,String> map) {
    String containerCode =  map.get("containerCode");
    if(StringUtils.isEmpty(containerCode)&&StringUtils.isEmpty(containerCode)) {
        return AjaxResult.error("容器号不能为空");
    }
    AjaxResult ajaxResult = handleMultiProcess("shipmentCheck",new MultiProcessListener() {
        @Override
        public AjaxResult doProcess() {
            AjaxResult ajaxResult = codingService.findShipmentRecordByLs(containerCode);
            return ajaxResult;
        }
    });
    return ajaxResult;
}
    @PostMapping("/requestEmptyContainer")
    @ApiOperation("申请空托盘组")
    @ResponseBody
    @ApiLogger(apiName = "申请空托盘组", from="申请空托盘组")
    public AjaxResult requestEmptyContainer(@RequestBody EmptyZu emptyZu) {
        String requestInCode = emptyZu.getRequestInCode();
        if (requestInCode == null) {
            return AjaxResult.error("空托盘组信息,申请位置为空");
        }
        if (!requestInCode.equals("P3") && !requestInCode.equals("P6")){
            return AjaxResult.error("目标站台错误");
        }

        AjaxResult ajaxResult = handleMultiProcess("requestEmptyContainer",new MultiProcessListener() {
            @Override
            public AjaxResult doProcess() {
                AjaxResult ajaxResult = codingService.requestEmptyContainer(requestInCode);
                return ajaxResult;
            }
        });
        return ajaxResult;
    }



}