DIL-DAZHOU-WMS2/src/main/java/com/steerinfo/dil/controller/WmspOutboundResultController.java

package com.steerinfo.dil.controller;

import com.steerinfo.dil.feign.ESFeign;
import com.steerinfo.dil.mapper.CommonSeq;
import com.steerinfo.dil.mapper.WmspInboundScanResultMapper;
import com.steerinfo.dil.model.WmspOutboundResult;
import com.steerinfo.dil.model.WmspOutboundScanResult;
import com.steerinfo.dil.service.IWmspOutboundResultMaterialService;
import com.steerinfo.dil.service.impl.WmsInboundScanResultServiceImpl;
import com.steerinfo.dil.service.impl.WmspOutboundResultServiceImpl;
import com.steerinfo.dil.service.impl.WmspOutboundScanResultServiceImpl;
import com.steerinfo.dil.util.BaseRESTfulController;
import com.steerinfo.dil.util.ColumnDataUtil;
import com.steerinfo.dil.util.DataChange;
import com.steerinfo.dil.util.PageListAdd;
import com.steerinfo.dil.vo.OutBoundDetailed;
import com.steerinfo.framework.controller.RESTfulResult;
import com.steerinfo.framework.service.pagehelper.PageHelper;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * WmspOutboundResult RESTful接口：
 * @author generator
 * @version 1.0-SNAPSHORT 2021-09-08 10:35
 * 类描述
 * 修订历史：
 * 日期：2021-09-08
 * 作者：generator
 * 参考：
 * 描述：WmspOutboundResult RESTful接口
 * @see null
 * @Copyright 湖南视拓信息技术股份有限公司. All rights reserved.
 */
@RestController
@RequestMapping("/${api.version}/wmspoutboundresults")
public class WmspOutboundResultController extends BaseRESTfulController {

    @Autowired
    WmsInboundScanResultServiceImpl wmsInboundScanResultService;
    @Autowired
    private WmspOutboundResultServiceImpl wmspOutboundResultService;
    @Autowired
    private WmspInboundScanResultMapper wmspInboundScanResultMapper;
    @Autowired
    private IWmspOutboundResultMaterialService wmspOutboundResultMaterialService;
    @Autowired
    private WmspOutboundScanResultServiceImpl wmspOutboundScanResultService;
    @Autowired
    private CommonSeq commonSeq;
    @Autowired
    private  ESFeign esFeign;

    private final SimpleDateFormat sdfDateTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");


    /**
     * 编写人：hukui
     * PC端查看钢材出库实绩
     * 参数：
     *  apiId：表头id
     *  pageSize：每页记录数
     *  pageNum：查询页数
     * 返回值：
     *  data：所有出库单实绩
     * */
    @Autowired
    ColumnDataUtil columnDataUtil;
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "查询页数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "pageSize", value = "每页记录数", required = false, dataType = "Integer"),
            @ApiImplicitParam(name = "apiId", value = "96", required = false, dataType = "BigDecimal"),
    })
    @PostMapping(value = "/getWmspOutboundResult")
    public RESTfulResult getWmspOutboundResult(@RequestBody(required = false) Map<String, Object> mapval,
                                               Integer pageNum,
                                               Integer pageSize,
                                               Integer apiId,
                                               Integer warehouseId,
                                               String startTime,
                                               String endTime){
        mapval.put("warehouseId",warehouseId);
        DataChange.queryDataByDateTime(startTime,endTime,mapval,simpleDateFormat);
        List<Map<String, Object>> libaryOutBoundList  = wmspOutboundResultService.selectResultNumber(mapval);
        PageHelper.startPage(pageNum, pageSize);
        List<Map<String, Object>> columnList =wmspOutboundResultService.selectResultNumber(mapval);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId, libaryOutBoundList, columnList);
        return success(pageList);
    }
    @ApiOperation("进入出库扫码页面，查询出库物资信息详情")
    @GetMapping("/getInitOutboundScanResultMaterialInfo")
    @ApiImplicitParam(name = "resultId",value = "出库实绩id",paramType = "BigDecimal",required = true)
    public RESTfulResult getInitOutboundScanResultMaterialInfo(@RequestParam(value = "resultId",required = true) BigDecimal resultId){
        OutBoundDetailed outBoundDetailed= wmspOutboundResultService.getInitOutboundScanResultMaterialInfo(resultId);
        return success(outBoundDetailed);
    }

    /**
     * 编写人：hukui
     * 通过前端扫描司机运单二维码，新增出单实绩并返回新增的出库单实绩
     * 参数：
     *   mapval（运输订单号，订单类别）
     * 返回值：
     *   list：出库单实绩
     * */
    @PostMapping(value = "/insertWmspOutBoundResult")
    public Map<String, Object> insertWmspOutBoundResult(@RequestBody(required = false) Map<String, Object> mapval){

        /**拿到前端传递的运输订单号*/
        String orderNumber = mapval.get("orderNumber").toString();
        /**根据运输订单号，查询运输订单信息，*/
        Map<String, Object> order = wmspOutboundResultService.getOrder(orderNumber);
        /**拿运输订单信息中的运输订单Id*/
        if(order!=null){
            BigDecimal orderId = (BigDecimal) order.get("orderId");
            //根据该运输订单Id判断当前订单是否已经完成出厂，若完成直接返回null
            if (wmspOutboundResultService.getOutboundStatus(orderId)==0){

                Map<String,Object> map = new HashMap<>();
                map.put("orderId",orderId);
                /**根据运输订单ID和物资id查询出库单(没有逻辑删除）
                 *若orderNum大于0,则不是第一次扫描，已经新增出库单,返回详情信息
                 *若orderNum等于0，则是第一次扫描，需要增加出库单，再返回详情信息
                 * */
                int orderNum = wmspOutboundResultService.ExistWmspOutboundResult(map);
                if(orderNum == 0){
                    //创建出货单
                    WmspOutboundResult wmspOutboundResult=wmspOutboundResultService.createOutboundResult(orderId,new BigDecimal(order.get("orderType").toString()));
                    if (wmspOutboundResult!=null){
                        /**根据运输订单号，查询出该订单还没有装货的物资*/
                        List<Map<String,Object>> orderList = wmspOutboundResultService.getMaterial(orderId.intValue());
                        int status= wmspOutboundResultMaterialService.insertOutboundMaterial(wmspOutboundResult.getResultId(),orderList);

                    }
                }
                //查询运单相关信息

                return wmspOutboundResultService.getOutBoundDetailedInfo(orderId);
            }
        }

        return null;
    }

    /**
     * 编写人：zouzhendon
     * PDA前端装卸工拒绝扫描出的运输订单，并逻辑删除出库单
     * 参数：
     *   resultId（出库单Id）
     * 返回值：
     *   int：是否逻辑删除出库单
     * */
    @PostMapping(value = "/deletewmspOutboundResult")
    public RESTfulResult deleteWmspOutboundResult(@RequestParam Integer resultId){
        //通过出库单Id逻辑删除出库单
        int i = wmspOutboundResultService.deleteWmspOutboundResult(new BigDecimal(resultId));
        return success(i);
    }



    /**
     * 编写人：yanghaiming
     * 装卸工PDA前端扫描钢材吊牌二维码，新增出库单扫描实绩并返回已扫描并稽核成功的物资信息
     * 参数：
     *   map（resultNumber 出库单号，personnelJobNumber 装卸工工号 resultMaterial 装卸工扫描吊牌结果)
     * 返回值：
     *   list：出库单实绩
     * */
    @Transactional(isolation = Isolation.READ_COMMITTED)
    @PostMapping(value = "/insertwmspOutboundScanResult")
    public synchronized RESTfulResult insertwmspOutboundScanResult(@RequestBody(required = false) Map<String, Object> map) throws ParseException {
        //判断物资是否满足要求,目前以下三种不做处理的判断
        //获取装卸工扫描吊牌结果   HRB400-14-21706854-9-3049-280-20211001015115-7a63cd87a4095e7f-08010103010100003-4
        String subResultMaterial = map.get("resultMaterial").toString().substring(0,map.get("resultMaterial").toString().length() - 1);
        //获取出库单号
        BigDecimal resultId = new BigDecimal(map.get("resultId").toString());
        //物资唯一编码
        String materialOnlyCode=subResultMaterial.split("-")[7];


        //判断物质是否已经被扫描
        int isScan = wmspOutboundResultService.ExistScanResult(subResultMaterial);
        //根据物资id查询相对应的入库实绩ID，并将其赋值给相对应的入库扫描实绩表,判断是否入库
        List<Map<String, Object>> list = wmspInboundScanResultMapper.getInboundResultIdByMaterial(subResultMaterial);
        if (list==null||list.size()==0){
            //Map<String, Object> inboundScanResultByResultMaterial = wmsInboundScanResultService.createInboundScanResultByResultMaterial(1, map.get("personnelJobNumber").toString(), map.get("resultMaterial").toString());
           // if (inboundScanResultByResultMaterial==null){
                //没有入库
                return failed(-2);
           // }

        }
        //判断物资是否是需要出库的物资类型,需要出库物资数量不等于0,通过物资唯一编码和出库实绩
        //判断物资是否是需要出库的物资,需要出库物资数量不等于0,通过物资唯一编码和出库实绩
        Map<String,Object> materialMap = wmspOutboundResultMaterialService.isOutboundResultMaterial(materialOnlyCode,resultId);
        if (materialMap==null){
            //物质类型错误
            return failed(-4);
        }
        Integer materialNumber= Integer.valueOf(materialMap.get("materailNumber").toString());
        //获得已经扫描的物质数量
        int scanCount = wmspOutboundScanResultService.getScanCount(materialOnlyCode,resultId);

        if(list.size()>0&&isScan==0&&(materialNumber!=null&&materialNumber!=0)&&(materialNumber>scanCount)){
            //替代操作
            int result = wmspOutboundResultService.replaceSave(materialOnlyCode);
            //创建扫描实绩
            //通过装卸工工号查询装卸工Id
            BigDecimal personnelId = wmspOutboundResultService.getPersonnelIdByJobnumber(map.get("personnelJobNumber").toString());
            //默认以获取到的第一个值作为入库实绩Id
            Map<String, Object> map1 = list.get(0);
            int status= wmspOutboundResultService.createOutboundScanResult(subResultMaterial,personnelId,resultId,(BigDecimal)map1.get("inboundResultId"),new BigDecimal(materialMap.get("resultMaterialId").toString()));

            return success(status);
        }else {

            if (list.size()==0){
                //没有入库
                return failed(-2);
            }else {
                if (isScan>0){
                    //重复扫描
                    return failed(-1);
                }
                //货物已满
                return failed(-3);
            }

        }
    }
    /**
     * 编写人：zouzhendon
     * 装卸工PDA前端扫描钢材吊牌二维码，新增出库单扫描实绩并返回已扫描并稽核成功的物资信息
     * 参数：
     *   map（resultNumber 出库单号，personnelJobNumber 装卸工工号 resultMaterial 装卸工扫描吊牌结果)
     * 返回值：
     *   list：出库单实绩
     * */
    @Transactional
    @PostMapping(value = "/insertwmspOutboundScanResult2")
    public synchronized RESTfulResult insertwmspOutboundScanResult2(@RequestBody(required = false) Map<String, Object> map){
      ///获得前台传来得信息

       //获取装卸工扫描吊牌结果   HRB400-14-21706854-9-3049-280-20211001015115-7a63cd87a4095e7f-08010103010100003-4
        String resultMaterial = (String) map.get("resultMaterial");
        String subResultMaterial = resultMaterial.substring(0,resultMaterial.length() - 1);
        //获取出库单号
        BigDecimal resultId = new BigDecimal(map.get("resultId").toString());
        /**根据扫描结果查询扫描实绩、判断是否一件出库
         *          若scanCount大于0,则不是第一次扫描，已经新增出库扫描实绩,返回已扫描过
         *          若scanCount等于0，则是第一次扫描，需要增加出库扫描实绩，再返回已扫描并稽核成功的物资信息
         * */

        ///判断物质是否已经被扫描
        int scanCount = wmspOutboundResultService.ExistScanResult(subResultMaterial);
        ///如果没有被扫描
        if(scanCount==0){
            //wmspOutboundResultService.getOutBoundId(resultNumber);
            //获取装卸工工号
            String personnelJobNumber = (String) map.get("personnelJobNumber");
            //通过装卸工工号查询装卸工Id
            BigDecimal personnelId = wmspOutboundResultService.getPersonnelIdByJobnumber(personnelJobNumber);
            //通过出库实绩Id判断出库单已扫描的件数是否等于运输订单物资表的物资件数
                ///解析物质二维码信息
                //截取扫描结果，得到物资唯一编码
                String[] split = resultMaterial.split("-");
                //唯一编码
                String MaterialOnlyCode=split[7];
                //通过物资物资唯一编码查询钢材物资表的物资Id
                BigDecimal SteelMaterialId = wmspOutboundResultService.getSteelMaterialIdByMaterialOnlyCode(MaterialOnlyCode);
                //通过出库实绩Id查询物资Id
                BigDecimal OutboundMaterialId = wmspOutboundResultService.getOutboundMaterialByResultId(resultId);

                //初始化出库扫描实绩
                WmspOutboundScanResult wmspOutboundScanResult = new WmspOutboundScanResult();

                //使用序列号增加生成主键id
                int seq_wmspOutboundScanResult = commonSeq.getSeqNumber("seq__WMSP_OUTBOUND_SCAN_RESULT");
                //插入主键id
                wmspOutboundScanResult.setResultId(new BigDecimal(seq_wmspOutboundScanResult));
                //根据物资id查询相对应的入库实绩ID，并将其赋值给相对应的入库扫描实绩表
                List<Map<String, Object>> list= wmspInboundScanResultMapper.getInboundResultIdByMaterial(subResultMaterial);
                //默认以获取到的第一个值作为入库实绩Id
                Map<String ,Object> map1 = list.get(0);
                //如果等于0说明该物资没有录入系统
                if (list.size()==0){

                }
                wmspOutboundScanResult.setInboundResultId((BigDecimal) map1.get("inboundResultId"));
                //插入出库实绩ID
                wmspOutboundScanResult.setOutboundResultId(resultId);
                //插入装卸工Id
                wmspOutboundScanResult.setLoadId(personnelId);
                //插入装卸工扫描吊牌结果
                wmspOutboundScanResult.setResultMaterial(resultMaterial);
                //插入装卸工扫描吊牌时间
                wmspOutboundScanResult.setResultLoadTime(new Date());
                //插入出库物资数量
                wmspOutboundScanResult.setOutboundMaterialNumber(new BigDecimal(1));
                //常规字段
                wmspOutboundScanResult.setInsertUsername("admin");
                wmspOutboundScanResult.setInsertTime(new Date());
                wmspOutboundScanResult.setUpdateUsername("admin");
                wmspOutboundScanResult.setUpdateTime(new Date());
                wmspOutboundScanResult.setInsertUpdateRemark("无");
                if(SteelMaterialId.intValue()==OutboundMaterialId.intValue()){
                    int EqualMaterialsNumber = wmspOutboundResultService.EqualMaterialsNumber(resultId);
                    if(EqualMaterialsNumber==1){
                        //相等返回装货数量已够
                        wmspOutboundScanResult.setResultCheck(new BigDecimal(1));
                    }else {
                        //稽核成功,设定扫描实绩稽核结果为成功
                        wmspOutboundScanResult.setResultCheck(new BigDecimal(0));
                    }

                    //插入扫描实绩
                    wmspOutboundResultService.scanResultInsert(wmspOutboundScanResult);
                }else {
                    //稽核失败,设定扫描实绩稽核结果为失败
                    wmspOutboundScanResult.setResultCheck(new BigDecimal(1));
                    //插入扫描实绩
                    wmspOutboundResultService.scanResultInsert(wmspOutboundScanResult);
                }
                //返回已扫描并并稽核成功的物资信息
                //1、获取出库单统一信息
                //获取月台Id
                //BigDecimal platformId = wmspOutboundResultService.getPlatformIdByResultId(resultId);
                //通过月台Id获取仓库名
                //String warehouseName = wmspOutboundResultService.getWarehouseNameByPlatformId(platformId);
                //获取出库单统一部分信息
                Map<String,Object> theSameOutboundInfo = wmspOutboundResultService.theSameOutboundInfo(resultId);
                //theSameOutboundInfo.put("warehouseName",warehouseName);
                //2、获取出库扫描实绩数据
                List<Map<String,Object>> scanAuditSuccessInfo = wmspOutboundResultService.scanAuditSuccessInfo(resultId);
                //补全出库扫描实绩数据的信息,对扫描实绩进行去重


                for (Map<String, Object> stringObjectMap : scanAuditSuccessInfo) {
                    String resultMaterial1 = (String) stringObjectMap.get("resultMaterial");
                    //截取扫描结果，得到一件物资的详细信息
                    String[] split1 = resultMaterial1.split("-");
                    //规格
                    String Specification="Φ"+split1[1];
                    stringObjectMap.put("Specification",Specification);
                    //型号
                    String Model=split1[0];
                    stringObjectMap.put("Model",Model);
                    //炉号
                    String FurnaceNumber=split1[2];
                    stringObjectMap.put("FurnaceNumber",FurnaceNumber);
                    //理重
                    String TheoreticalWeight=split1[4];
                    stringObjectMap.put("TheoreticalWeight",TheoreticalWeight);
                    //唯一编码
                    String MaterialOnlyCode1=split1[7];
                    stringObjectMap.put("MaterialOnlyCode",MaterialOnlyCode1);
                    //通过唯一编码获取物资名称、计量单位、垛位
                    Map<String,Object> otherMap = wmspOutboundResultService.getOtherInfoByMaterialOnlyCode(MaterialOnlyCode1);
                    //取出再放入物资名称
                    String materialName = otherMap.get("materialName").toString();
                    stringObjectMap.put("materialName",materialName);
                    //取出再放入计量单位
                    String unitOfMeasureName = otherMap.get("unitOfMeasureName").toString();
                    stringObjectMap.put("unitOfMeasureName",unitOfMeasureName);
                    //取出再放入垛位
                    String stackingNo = otherMap.get("stackingNo").toString();
                    stringObjectMap.put("stackingNo",stackingNo);
                    //合并出库单统一信息map
                    stringObjectMap.putAll(theSameOutboundInfo);
                }
                return success(scanAuditSuccessInfo);

        }else{
            //返回已扫描并并稽核成功的物资信息
            //1、获取出库单统一信息
            //获取月台Id
            //BigDecimal platformId = wmspOutboundResultService.getPlatformIdByResultId(resultId);
            //通过月台Id获取仓库名
            //String warehouseName = wmspOutboundResultService.getWarehouseNameByPlatformId(platformId);
            //获取出库单统一部分信息
            Map<String,Object> theSameOutboundInfo = wmspOutboundResultService.theSameOutboundInfo(resultId);
            //theSameOutboundInfo.put("warehouseName",warehouseName);
            //2、获取出库扫描实绩数据
            List<Map<String,Object>> scanAuditSuccessInfo = wmspOutboundResultService.scanAuditSuccessInfo(resultId);
            //补全出库扫描实绩数据的信息
            for (Map<String, Object> stringObjectMap : scanAuditSuccessInfo) {
                String resultMaterial1 = (String) stringObjectMap.get("resultMaterial");
                //截取扫描结果，得到一件物资的详细信息
                String[] split1 = resultMaterial1.split("-");
                //规格
                String Specification = "Φ" + split1[1];
                stringObjectMap.put("Specification", Specification);
                //型号
                String Model = split1[0];
                stringObjectMap.put("Model", Model);
                //炉号
                String FurnaceNumber = split1[2];
                stringObjectMap.put("FurnaceNumber", FurnaceNumber);
                //理重
                String TheoreticalWeight = split1[4];
                stringObjectMap.put("TheoreticalWeight", TheoreticalWeight);
                //唯一编码
                String MaterialOnlyCode1 = split1[7];
                stringObjectMap.put("MaterialOnlyCode", MaterialOnlyCode1);
                //通过唯一编码获取物资名称、计量单位、垛位
                Map<String, Object> otherMap = wmspOutboundResultService.getOtherInfoByMaterialOnlyCode(MaterialOnlyCode1);
                //取出再放入物资名称
                String materialName = otherMap.get("materialName").toString();
                stringObjectMap.put("materialName", materialName);
                //取出再放入计量单位
                String unitOfMeasureName = otherMap.get("unitOfMeasureName").toString();
                stringObjectMap.put("unitOfMeasureName", unitOfMeasureName);
                //取出再放入垛位
                String stackingNo = otherMap.get("stackingNo").toString();
                stringObjectMap.put("stackingNo", stackingNo);
                //合并出库单统一信息map
                stringObjectMap.putAll(theSameOutboundInfo);
            }
            return success(scanAuditSuccessInfo);
        }
    }


    /**
     * 编写人：hujianguo
     * 装卸工PDA前端点击出库
     * 参数：
     *   resultId
     * 返回值：
     *   result：出库成功标志
     * */
    @ApiOperation(value = "出库(非0:成功,0:失败)")
    @PostMapping("/outbountResultToSuccess3")
    public RESTfulResult outbountResultToSuccess2(@RequestParam Integer resultId) {
        int result = wmspOutboundResultService.outbountResultToSuccess(resultId);
        if (result == 0) {
            return failed("还未扫描完，请继续！");
        }
        else {
            return success(result);
        }
    }
    @ApiOperation( value = "确定出厂",notes ="通过提货单对已扫出厂码的钢材进行出库。" +
            "如果是拼装的提货单，当某一类钢材全部扫完，将当前物资的实时库存删除，并改变物质类型状态" +
            "如果是单一物质则，就当物质全部扫完才能确定出库，并将出库实绩改为完成" )
    @ApiImplicitParam(name = "resultId",dataType = "BigDecimal",value = "出库实绩Id")
    @PostMapping("/outbountResultToSuccess")
    public RESTfulResult sureOutbount(@RequestParam BigDecimal resultId){
        int result = 0;
        try {
            result = wmspOutboundResultService.sureOutbount(resultId);
        } catch (Exception e) {
            return failed(2, e.getMessage());
        }
        if(result == 1){
            return success(1,"该类型已出库");
        }
        if(result == 2){
            return success(2,"该订单已出库");
        }
        return failed(result);
    }

    @ApiOperation(value = "出库(非0:成功,0:失败)")
    @PostMapping("/outbountResultToSuccess2")
    public RESTfulResult outbountResultToSuccess(@RequestParam Integer resultId) {
        int result = wmspOutboundResultService.outbountResultToSuccess(resultId);
        if (result == 0) {
            return failed("还未扫描完，请继续！");
        }
        else {
            return success(result);
        }
    }

    /**
     * 编写人：hukui
     * 通过前端扫描司机运单二维码，新增出单实绩并返回新增的出库单实绩
     * 参数：
     *   mapval（运输订单号，订单类别）
     * 返回值：
     *   list：出库单实绩
     * */
    @PostMapping(value = "/updataResultStatus")
    public RESTfulResult updataResultStatus(@RequestBody(required = false) Integer resultId){
        // 创建一个出库单实体
        WmspOutboundResult wmspOutboundResult = new WmspOutboundResult();
        // 把前端传递的出库单主键id赋值给实体
        wmspOutboundResult.setResultId(new BigDecimal(resultId));
        // 把出库单状态改为已出库
        wmspOutboundResult.setResultStatus(new BigDecimal(1));
        int i = wmspOutboundResultService.updateByPrimaryKeySelective(wmspOutboundResult);
        return success(i);
    }
    /**
     * 司机扫描订单二维码进行倒库，首先根据运输订单号查找运输订单，
     *
     */
    @PostMapping("/insertOutBoundResult")
    public  RESTfulResult insertOutBoundResult(@RequestBody(required = false) Map<String, Object> map){
        return success();
    }

    //创建一个删除实时库的接口
    @PostMapping("/deleteGridMaterial")
    public RESTfulResult deleteGridMaterial(@RequestParam String materialOnlyCode){


        //根据物资id查询相对应的入库实绩ID，并将其赋值给相对应的入库扫描实绩表,判断是否入库
        List<Map<String, Object>> list = wmspInboundScanResultMapper.getInboundResultIdByMaterial(materialOnlyCode);

        int result = wmspOutboundResultService.deleteGridMaterial(materialOnlyCode);

        //判断物质是否已经被扫描
        int isScan = wmspOutboundResultService.ExistScanResult(materialOnlyCode);
        if (result>0&&isScan==0&&list.size()>0){
            Map<String, Object> map1 = list.get(0);
            //创建出库实绩
            WmspOutboundResult wmspOutboundResult=wmspOutboundResultService.createOutboundResult(new BigDecimal(1),new BigDecimal(2));

            int status= wmspOutboundResultService.createOutboundScanResult(materialOnlyCode,new BigDecimal(1),wmspOutboundResult.getResultId(),(BigDecimal)map1.get("inboundResultId"),new BigDecimal(1));
        }
        if(result == -1){
            return failed(-1,"请勿重复扫码");
        }
        if(result == -2){
            return  failed(-2,"该钢材还未入库");
        }
        return success("操作成功");
    }

    //统计出厂每个炉号生产的支数
    @PostMapping("/getWmsOutboundResultStatistics")
    @ApiOperation(value = "展示出库统计信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "apiId", value = "371", required = false, dataType = "BigDecimal"),
    })
    public RESTfulResult getWmsOutboundResultStatistics(@RequestBody(required = false) Map<String, Object> mapValue,
                                                       Integer apiId,
                                                       Integer pageNum,
                                                       Integer pageSize,
                                                       Integer warehouseId,
                                                       String con,
                                                       String startTime,
                                                       String endTime) {
        if (con!=null && !con.equals("undefined") && !"".equals(con)){
            mapValue.put("con","%"+con+"%");
        }
        if(mapValue == null){
            mapValue =new HashMap<>();
        }
        mapValue.put("warehouseId",warehouseId);
        DataChange.queryDataByDateTime(startTime, endTime, mapValue, sdfDateTime);//根据时间段查询数据
        List<Map<String,Object>> inboundResultList = wmspOutboundResultService.getWmsOutboundResultStatistics(mapValue);

        /*分页*/
        PageHelper.startPage(pageNum, pageSize);
        List<Map<String,Object>> columnList = wmspOutboundResultService.getWmsOutboundResultStatistics(mapValue);
        PageListAdd pageList = columnDataUtil.tableColumnData(apiId,inboundResultList,columnList);
        return success(pageList);
    }
}