DIL-DAZHOU-WMS2/src/main/java/com/steerinfo/dil/service/impl/WmspOutboundResultServiceImpl.java

package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.feign.TmstruckFeign;
import com.steerinfo.dil.mapper.*;
import com.steerinfo.dil.model.WmspOutboundResult;
import com.steerinfo.dil.model.WmspOutboundScanResult;
import com.steerinfo.dil.service.IWmspOutboundResultService;
import com.steerinfo.dil.util.DataChange;
import com.steerinfo.dil.vo.OutBoundDetailed;
import com.steerinfo.dil.vo.OutBoundMaterialDetailedInfo;
import com.steerinfo.dil.vo.OutBoundTypeDetailedInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

/**
 * WmspOutboundResult服务实现：
 * @author generator
 * @version 1.0-SNAPSHORT 2021-09-08 10:35
 * 类描述
 * 修订历史：
 * 日期：2021-09-08
 * 作者：generator
 * 参考：
 * 描述：WmspOutboundResult服务实现
 * @see null
 * @Copyright 湖南视拓信息技术股份有限公司. All rights reserved.
 */
@Service
public class WmspOutboundResultServiceImpl  implements IWmspOutboundResultService {

    @Autowired
    private WmspOutboundResultMapper wmspOutboundResultMapper;

    @Autowired
    private WmspOutboundScanResultMapper wmspOutboundScanResultMapper;
    @Autowired
    private WmsInboundResultServiceImpl wmsInboundResultService;
    @Autowired
    private WmspOutboundResultMaterialServiceImpl wmspOutboundResultMaterialService;
    @Autowired
    private WmspOutboundScanResultServiceImpl wmspOutboundScanResultService;
    @Autowired
    private WmspInboundScanResultMapper wmspInboundScanResultMapper;
    @Autowired
    private WmspGridMaterialServiceImpl wmspGridMaterialService;
    @Autowired
    CommonSeq commonSeq;
    @Autowired
    private TmstruckFeign tmstruckFeign;

    @Autowired
    private WmspGridMaterialMapper wmspGridMaterialMapper;

    @Autowired
    WmspSendReceiveServiceImpl wmspSendReceiveService;

    @Override
    public List<Map<String, Object>> selectResultNumber(Map<String, Object> mapval) {
       // return wmspOutboundResultMapper.selectResultNumber(mapval);
        return wmspOutboundResultMapper.selectOutResult(mapval);
    }


    @Override
    public int insertSelective(WmspOutboundResult wmspOutboundResult) {
        return wmspOutboundResultMapper.insertSelective(wmspOutboundResult);
    }

    @Override
    public Map<String, Object> getOrder(String orderNumber) {
        return wmspOutboundResultMapper.getOrder(orderNumber);
    }

    @Override
    public List<Map<String, Object>> getwmspOutboundResultdetails(Integer orderId) {
        return wmspOutboundResultMapper.getwmspOutboundResultdetails(orderId);
    }

    @Override
    public int getcountOrderNumber(Integer orderId) {
        return wmspOutboundResultMapper.getcountOrderNumber(orderId);
    }

    @Override
    public String getmaterialCode(Integer resultId) {
        return wmspOutboundResultMapper.getmaterialCode(resultId);
    }

    @Override
    public int updateByPrimaryKeySelective(WmspOutboundResult wmspOutboundResult) {
        return wmspOutboundResultMapper.updateByPrimaryKeySelective(wmspOutboundResult);
    }

    @Override
    public List<Map<String, Object>> selectOutbountResultByOrderNumber(String orderNumber) {
        return wmspOutboundResultMapper.selectOutbountResultByOrderNumber(orderNumber);
    }

    @Override
    public String getPersonnelNameByJobnumber(String personnelJobNumber) {
        return wmspOutboundResultMapper.getPersonnelNameByJobnumber(personnelJobNumber);
    }

    @Override
    public List<Map<String, Object>> getMaterial(Integer orderId) {
        return wmspOutboundResultMapper.getMaterial(orderId);
    }

    @Override
    public int ExistWmspOutboundResult(Map<String, Object> map) {
        return wmspOutboundResultMapper.ExistWmspOutboundResult(map);
    }

    @Override
    public Map<String, Object> getOutBoundDetailedInfo(BigDecimal orderId) {
        return wmspOutboundResultMapper.getOutBoundDetailedInfo(orderId);
    }

    @Override
    public int deleteWmspOutboundResult(BigDecimal resultId) {
        WmspOutboundResult wmspOutboundResult = wmspOutboundResultMapper.selectByPrimaryKey(resultId);
        wmspOutboundResult.setDeleted(new BigDecimal(1));
        return wmspOutboundResultMapper.updateByPrimaryKey(wmspOutboundResult);
    }

    @Override
    public BigDecimal getOutBoundId(String resultNumber) {
        return wmspOutboundResultMapper.getOutBoundId(resultNumber);
    }

    @Override
    public BigDecimal getPersonnelIdByJobnumber(String personnelJobNumber) {
        return wmspOutboundResultMapper.getPersonnelIdByJobnumber(personnelJobNumber);
    }

    @Override
    public int ExistScanResult(String resultMaterial) {
        return wmspOutboundResultMapper.ExistScanResult(resultMaterial);
    }

    @Override
    public BigDecimal getSteelMaterialIdByMaterialOnlyCode(String MaterialOnlyCode) {
        return wmspOutboundResultMapper.getSteelMaterialIdByMaterialOnlyCode(MaterialOnlyCode);
    }

    @Override
    public BigDecimal getOutboundMaterialByResultId(BigDecimal resultId) {
        return wmspOutboundResultMapper.getOutboundMaterialByResultId(resultId);
    }

    @Override
    public int scanResultInsert(WmspOutboundScanResult wmspOutboundScanResult) {
        return wmspOutboundScanResultMapper.insertSelective(wmspOutboundScanResult);
    }

    @Override
    public BigDecimal getPlatformIdByResultId(BigDecimal resultId) {
        return wmspOutboundResultMapper.getPlatformIdByResultId(resultId);
    }

    @Override
    public String getWarehouseNameByPlatformId(BigDecimal platformId) {
        return wmspOutboundResultMapper.getWarehouseNameByPlatformId(platformId);
    }

    @Override
    public Map<String, Object> theSameOutboundInfo(BigDecimal resultId) {
        return wmspOutboundResultMapper.theSameOutboundInfo(resultId);
    }

    @Override
    public List<Map<String, Object>> scanAuditSuccessInfo(BigDecimal resultId) {
        return wmspOutboundResultMapper.scanAuditSuccessInfo(resultId);
    }

    @Override
    public Map<String, Object> getOtherInfoByMaterialOnlyCode(String MaterialOnlyCode1) {
        return wmspOutboundResultMapper.getOtherInfoByMaterialOnlyCode(MaterialOnlyCode1);
    }

    /**
     * 出库(0:失败，非0:成功)
     * @param resultId
     * @return
     */
    @Override
    public int outbountResultToSuccess(Integer resultId) {
        int result = 0;
        //获得扫码出库实绩
        List<Map<String,Object>> materialNumberList = wmspOutboundResultMapper.getScanMaterialNumber(new BigDecimal(resultId));
        //获得运输订单的物资数量
        List<Map<String,Object>> orderMaterialNumberList = wmspOutboundResultMapper.getOunboundOrderNumber(new BigDecimal(resultId));
        BigDecimal orderMaterialNumber = (BigDecimal) orderMaterialNumberList.get(0).get("orderMaterialNumber");
        int outboundMaterialNumber = materialNumberList.size();
        if (orderMaterialNumber.intValue() == outboundMaterialNumber) {
            // 设置出库实绩为成功、将出库实绩改完已经出库
            WmspOutboundResult wmspOutboundResult = wmspOutboundResultMapper.selectByPrimaryKey(new BigDecimal(resultId));
            wmspOutboundResult.setResultStatus(new BigDecimal(1));

            // 调用装货
            BigDecimal orderId = wmspOutboundResult.getBillLadingId();
            //result += tmstruckFeign.addSaleLoadResult(orderId.intValue());
            // 修改实时库存（逻辑删除） grid
            BigDecimal materialId = wmspOutboundResult.getMaterialId();
//            创建一个方法用来修改入库实绩id的状态和仓储网格的状态,当且仅当返回值为2的时候是成功的
            if (wmsInboundResultService.updateInboundGridStatus(resultId)%2 == 0){
                result += wmspOutboundResultMapper.updateByPrimaryKeySelective(wmspOutboundResult);
                result += wmspOutboundResultMapper.updateGrid(materialId);
            }
        }
        return result;
    }

    /**
     * 判断物资是否已经都已经被扫描
     * @param resultId
     * @return
     */
    @Override
    public int EqualMaterialsNumber(BigDecimal resultId) {
        int EqualMaterialsNumber = 0;
        //获得被扫描物资
        List<Map<String,Object>> materialNumberList = wmspOutboundResultMapper.getScanMaterialNumber(resultId);
        //获得运单中间表的物资件数
        List<Map<String,Object>> orderMaterialNumberList = wmspOutboundResultMapper.getOunboundOrderNumber(resultId);
        BigDecimal orderMaterialNumber = (BigDecimal) orderMaterialNumberList.get(0).get("orderMaterialNumber");
        int outboundMaterialNumber = materialNumberList.size();
        if (orderMaterialNumber.intValue() == outboundMaterialNumber) {
            EqualMaterialsNumber = 1;
        }else {
            EqualMaterialsNumber = 0;
        }
        //返回结果
        return EqualMaterialsNumber;
    }

    @Override
    public int getOutboundStatus(BigDecimal orderId) {
        return wmspOutboundResultMapper.getOutboundStatus(orderId);
    }

    @Override
    public WmspOutboundResult createOutboundResult(BigDecimal orderId, BigDecimal orderType) {
        /**创建出库单实体*/
        WmspOutboundResult wmspOutboundResult = new WmspOutboundResult();
        /**使用序列号增加生成主键id*/
        int seq_wmspoutboundresult = commonSeq.getSeqNumber("seq__WMSP_OUTBOUND_RESULT");
        /**获取到当前时间*/
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
        /**生成出库单编号*/
        String resultNumber = "XSCK" + sdf.format(new Date());
        if(seq_wmspoutboundresult < 10){
            resultNumber += "0000000" + seq_wmspoutboundresult;
        }else if(seq_wmspoutboundresult < 100){
            resultNumber += "000000" + seq_wmspoutboundresult;
        }else if(seq_wmspoutboundresult < 1000){
            resultNumber += "00000" + seq_wmspoutboundresult;
        }else if(seq_wmspoutboundresult < 10000){
            resultNumber += "0000" + seq_wmspoutboundresult;
        }else  if(seq_wmspoutboundresult < 100000){
            resultNumber += "000" + seq_wmspoutboundresult;
        }else if(seq_wmspoutboundresult < 1000000){
            resultNumber += "00" + seq_wmspoutboundresult;
        }else if(seq_wmspoutboundresult < 10000000){
            resultNumber += "0" + seq_wmspoutboundresult;
        }else{
            resultNumber += seq_wmspoutboundresult;
        }

        /**运输订单类型判断
         *    orderType : 1 为普通出库
         *    orderType : 4 为调拨出库
         * */
        String resultOutboundType = "普通出库";
        if(orderType.intValue() == 4){
            resultOutboundType = "调拨出库";
        }
        //添加订单类型
        if(orderType.intValue()==25){
            resultOutboundType= "倒库";
        }
        /**把出库单主键id添加到出库单实体中*/
        wmspOutboundResult.setResultId(new BigDecimal(seq_wmspoutboundresult));
        /**把出库单编号添加到出库单实体中*/
        wmspOutboundResult.setResultNumber(resultNumber);
        /**把运输订单主键添加到出库单实体中*/
        wmspOutboundResult.setBillLadingId(orderId);
        /**把出库类型添加到出库单实体中*/
        wmspOutboundResult.setResultOutboundType(resultOutboundType);
        /**第一次添加为待出库*/
        wmspOutboundResult.setResultStatus(new BigDecimal(0));
        //常规字段
        wmspOutboundResult.setInsertUsername("admin");
        wmspOutboundResult.setInsertTime(new Date());
        wmspOutboundResult.setUpdateUsername("admin");
        wmspOutboundResult.setUpdateTime(new Date());
        wmspOutboundResult.setInsertUpdateRemark("无");
        wmspOutboundResult.setDeleted(new BigDecimal(0));
        //还没装货的物资id的第一条添加到出库单实体中
        //wmspOutboundResult.setMaterialId(materialId);
        Integer res =insertSelective(wmspOutboundResult);
        if (res>0){
            return wmspOutboundResult;
        }
        return null;
    }

    /**
     * 通过出库实绩id查询出 出库物资的详情信息
     * @param resultId
     * @return
     */
    @Override
    public OutBoundDetailed getInitOutboundScanResultMaterialInfo(BigDecimal resultId) {

        //查询待出库物资类型详情
        List<OutBoundTypeDetailedInfo> outBoundTypeDetailedInfos= wmspOutboundResultMaterialService.getOutBoundTypeDetailedInfo(resultId,null);
        //查询扫码实绩的扫码结构
        List<String> onlycodes= wmspOutboundScanResultService.getOutBoundScanResultOnlyCodes(resultId);
        //出库信息展示
        OutBoundDetailed outBoundDetailed=new OutBoundDetailed();
        if (onlycodes.size()>0){
            //查询出已经扫码的物资信息
            List<OutBoundMaterialDetailedInfo> outBoundMaterialDetailedInfos= wmspOutboundScanResultService.getOutBoundMaterialDetailedInfos(onlycodes,null);
            //统计出已经扫码的物资数量
            for (OutBoundTypeDetailedInfo typeDetailedInfo :outBoundTypeDetailedInfos){
                int count=0;
                for (OutBoundMaterialDetailedInfo outBoundMaterialDetailedInfo: outBoundMaterialDetailedInfos){
                    if (typeDetailedInfo.getMaterialId().equals(outBoundMaterialDetailedInfo.getMaterialId())){
                        count++;
                    }
                }
                //统计完数量赋值
                typeDetailedInfo.setScanCodeNumber(count);
            }
            outBoundDetailed.setOutBoundMaterialDetailedInfos(outBoundMaterialDetailedInfos);
        }
        outBoundDetailed.setOutBoundTypeDetailedInfos(outBoundTypeDetailedInfos);
        return outBoundDetailed;
    }
    @Transactional
    @Override
    public int createOutboundScanResult(String resultMaterial, BigDecimal personnelId, BigDecimal resultId,BigDecimal inboundResultId,BigDecimal resultMaterialId) {
        //截取扫描结果，得到物资唯一编码
        String[] split = resultMaterial.split("-");
        //唯一编码
        String MaterialOnlyCode = split[7];
        //通过物资物资唯一编码查询钢材物资表的物资Id
        BigDecimal SteelMaterialId = getSteelMaterialIdByMaterialOnlyCode(MaterialOnlyCode);
        //通过出库实绩Id查询物资Id
        BigDecimal OutboundMaterialId = getOutboundMaterialByResultId(resultId);

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

        //使用序列号增加生成主键id
        int seq_wmspOutboundScanResult = commonSeq.getSeqNumber("seq__WMSP_OUTBOUND_SCAN_RESULT");
        //插入主键id
        wmspOutboundScanResult.setResultId(new BigDecimal(seq_wmspOutboundScanResult));
        //入库实绩
        wmspOutboundScanResult.setInboundResultId(inboundResultId==null?new BigDecimal(1):inboundResultId);
        //插入出库实绩ID
        wmspOutboundScanResult.setOutboundResultId(resultId);
        //插入装卸工Id
        wmspOutboundScanResult.setLoadId(personnelId);
        //插入装卸工扫描吊牌结果
        wmspOutboundScanResult.setResultMaterial(resultMaterial);
        //插入装卸工扫描吊牌时间
        wmspOutboundScanResult.setResultLoadTime(new Date());
        //插入出库物资数量
        wmspOutboundScanResult.setOutboundMaterialNumber(new BigDecimal(1));
        //出库类型ID
        wmspOutboundScanResult.setResultMaterialId(resultMaterialId);
        //常规字段
        wmspOutboundScanResult.setInsertUsername("admin");
        wmspOutboundScanResult.setInsertTime(new Date());
        wmspOutboundScanResult.setUpdateUsername("admin");
        wmspOutboundScanResult.setUpdateTime(new Date());
        wmspOutboundScanResult.setInsertUpdateRemark("无");
        //稽核成功,设定扫描实绩稽核结果为成功
        wmspOutboundScanResult.setResultCheck(new BigDecimal(0));
        //插入扫描实绩
        return scanResultInsert(wmspOutboundScanResult);
    }

    public int deleteGridMaterial(String materialOnlyCode) {
            int i=0;
            String[] tag1 = materialOnlyCode.split("\\-");
           Map<String,Object> map  = wmspOutboundScanResultMapper.getMaterialSteelId(tag1[7]);
            if(map == null){
                return -2;
            }
            BigDecimal materialSteelId = DataChange.dataToBigDecimal(map.get("materialId"));
            Date date = (Date) map.get("updateTime");
            //如果修改时间为空，就表示该钢材还未出库
            if(date==null){
                //将这些物资钢材id进行逻辑删除
                i += wmspGridMaterialMapper.updateByMaterialId(materialSteelId,new Date());
                //判断物资是否是预留物资
                int isReserve= wmsInboundResultService.getTypeMaterilaId(materialSteelId);
                //如果是预留物资
                if (isReserve>0){
                    //将最新的一条真实库数据，状态改为预留状态状态，代替预留库存
                    int status2= wmsInboundResultService.updateStatusByMaterialId(materialSteelId);
                    //将预留库出库的钢材，状态改为完全入库状态
                    int status= wmsInboundResultService.updateStatusByMaterilaId(materialSteelId);

                }

            }
            //表示该钢材已出库,请勿重复扫码
            else{
                return -1;
            }

        return i;
    }

    public int replaceSave(String materialOnlyCode) {
        int i=0;
        Map<String,Object> map  = wmspOutboundScanResultMapper.getMaterialSteelId(materialOnlyCode);
        if(map == null){
            return -2;
        }
        BigDecimal materialSteelId = DataChange.dataToBigDecimal(map.get("materialId"));
        Date date = (Date) map.get("updateTime");
        //如果修改时间为空，就表示该钢材还未出库
        if(date==null){
            //判断物资是否是预留物资
            int isReserve= wmsInboundResultService.getTypeMaterilaId(materialSteelId);
            //如果是预留物资
            if (isReserve>0){
                //将最新的一条真实库数据，状态改为预留状态状态，代替预留库存
                i+= wmsInboundResultService.updateStatusByMaterialId(materialSteelId);
                //将预留库出库的钢材，状态改为完全入库状态
                i+= wmsInboundResultService.updateStatusByMaterilaId(materialSteelId);

            }

        }
        //表示该钢材已出库,请勿重复扫码
        else{
            return -1;
        }

        return i;
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public synchronized int sureOutbount(BigDecimal resultId) throws Exception {
        //查询提货单，没有确定出库物资类型集合
        List<OutBoundTypeDetailedInfo> outBoundTypeDetailedInfos= wmspOutboundResultMaterialService.getOutBoundTypeDetailedInfo(resultId,1);
        //查询出库扫描实绩，并且在实时库存没有删除的出库扫描实绩
        //查询扫码实绩的扫码结构
        List<String> onlycodes= wmspOutboundScanResultService.getOutBoundScanResultOnlyCodes(resultId);
        //出库信息展示
        OutBoundDetailed outBoundDetailed=new OutBoundDetailed();
        int cunt2=0;
        if (onlycodes.size()>0){
            //查询出已经扫码的物资信息
            List<OutBoundMaterialDetailedInfo> outBoundMaterialDetailedInfos= wmspOutboundScanResultService.getOutBoundMaterialDetailedInfos(onlycodes,null);
            //暂时保存
            //统计出已经扫码的物资数量
            for ( int i =0;i<outBoundTypeDetailedInfos.size();i++){
               //初始化一个
                OutBoundTypeDetailedInfo typeDetailedInfo=outBoundTypeDetailedInfos.get(i);
                //这一个类型的物资
                List<OutBoundMaterialDetailedInfo> thisMaterialDetailedInfos=new  ArrayList<>();
                //获得当前类型的已扫描数量
                int count=0;
                for (OutBoundMaterialDetailedInfo outBoundMaterialDetailedInfo: outBoundMaterialDetailedInfos){
                    if (typeDetailedInfo.getMaterialId().equals(outBoundMaterialDetailedInfo.getMaterialId())){
                        thisMaterialDetailedInfos.add(outBoundMaterialDetailedInfo);
                        count++;
                    }
                }
                //统计完数量赋值
                typeDetailedInfo.setScanCodeNumber(count);

                //统计，并且判断是否有某种物资已经扫满了
                if (typeDetailedInfo.getNumber().equals(typeDetailedInfo.getScanCodeNumber())){
                    //如果有某一种物资扫满了，需要将这一类物资，在实时库存删除，并且修改出库物资类型状态，发送计量委托
                    int cunt= wmspGridMaterialService.deleteGridMaterial(thisMaterialDetailedInfos);
                    cunt2=wmspOutboundResultMaterialService.updateStatus(typeDetailedInfo.getResultMaterialId());
                    //如果所以物资都已经结束，需要改变提货单状态
                    if (outBoundTypeDetailedInfos==null||outBoundTypeDetailedInfos.size()-cunt2==0){
                        int cunt3=wmspOutboundResultMapper.updateStatus(resultId);
                        //表示全部完成
                        finishLoadResult(outBoundMaterialDetailedInfos.get(0), resultId);
                        return 2;
                    }
                    //表示一项完成
                    finishLoadResult(outBoundMaterialDetailedInfos.get(0), resultId);
                    return cunt2;
                }

            }
            outBoundDetailed.setOutBoundMaterialDetailedInfos(outBoundMaterialDetailedInfos);
        }


        //返回结果
        return 0;
    }

    /**
     * Notes：完成出库调用装车实绩
     * @Author: TXF
     * @DateTime: 2022/3/24 21:10
     */
    public void finishLoadResult(OutBoundMaterialDetailedInfo outBoundMaterialDetailedInfo, BigDecimal resultId) throws Exception {
        BigDecimal materialId = new BigDecimal(outBoundMaterialDetailedInfo.getMaterialId());
        //通过物资ID和出库实绩ID查询相关数据 :运输订单ID 物资ID 装车开始时间 备注
        Map<String, Object> mesMap = wmspOutboundResultMapper.getOutboundMesByMateAndResultId(resultId, materialId);
        //通过钢材物资ID查询仓库ID
        Integer warehouseId = wmspOutboundResultMapper.getWarehouseIdBySteelMaterialId(new BigDecimal(outBoundMaterialDetailedInfo.getMaterialSteelId()));
        List<Map<String, Object>> luHaoNumberList = wmspOutboundResultMapper.getLuHaoAndNumber(DataChange.dataToBigDecimal(mesMap.get("resultMaterialId")), materialId);
        StringBuilder sb = new StringBuilder();
        for (Map<String, Object> luHaoMap : luHaoNumberList) {
           sb.append(luHaoMap.get("materialFurnaceNumber"));
           sb.append("-");
           sb.append(luHaoMap.get("materialNum"));
           sb.append("/");
        }
        sb.deleteCharAt(sb.length() - 1);
        mesMap.put("numberOfFurnaces", sb.toString());
        mesMap.put("materialId", materialId);
        mesMap.put("warehouseId", warehouseId);
        //查询出运输订单类型
        BigDecimal orderId= (BigDecimal) mesMap.get("orderId");
        BigDecimal orderType = wmspOutboundResultMapper.getSteelOrderType(orderId);
        //加一个对运输订单类型的判断如果为25则是倒库的判断
        if (orderType.compareTo(BigDecimal.valueOf(25))==0){
            //查出总实绩ID
            BigDecimal resultid = wmspOutboundResultMapper.queryID(orderId);
            mesMap.put("resultid",resultid);
            //计算理重总和
            BigDecimal calculateTW = wmspOutboundResultMapper.calculateTW(DataChange.dataToBigDecimal(mesMap.get("resultMaterialId")), materialId);
            mesMap.put("calculateTW",calculateTW.divide(new BigDecimal(1000),3,BigDecimal.ROUND_HALF_UP));
            tmstruckFeign.addLoad(mesMap);
        }else {
            Map<String, Object> returnMap = tmstruckFeign.addSaleLoadResult(mesMap);
            String code = (String) returnMap.get("code");
            if("200".equals(code)){
                System.out.println("新增装车成功：" + mesMap.get("orderId"));
            }else {
                throw new Exception("新增装车失败");
            }
        }
    }

    @Override
    public List<Map<String, Object>> getWmsOutboundResultStatistics(Map<String, Object> mapValue) {
        return wmspOutboundResultMapper.getWmsOutboundResultStatistics(mapValue);
    }


    @Override
    //@Transactional(rollbackFor = Exception.class)
    public synchronized int disorderlyOutbound(Map<String, Object> mapVal) throws Exception {
        //需要获取几个因子,1.物资名称
        String masterialName = (String) mapVal.get("materialName");
        if(!masterialName.contains("乱尺")){
            return -1;
        }
        //获取运输订单ID
        BigDecimal orderId = DataChange.dataToBigDecimal(mapVal.get("orderId"));
        //根据运输订单ID查询订单类型
        BigDecimal orderType = wmspOutboundResultMapper.getSteelOrderType(orderId);
        //根据运输订单ID即提货单ID查询是否生成出库单ID
        /**根据运输订单ID和物资id查询出库单(没有逻辑删除）
         *若orderNum大于0,则不是第一次扫描，已经新增出库单,返回详情信息
         *若orderNum等于0，则是第一次扫描，需要增加出库单，再返回详情信息
         * */
        int orderNum = ExistWmspOutboundResult(mapVal);
        if(orderNum == 0){
            //创建出货单
            WmspOutboundResult wmspOutboundResult=createOutboundResult(orderId,orderType);
            if (wmspOutboundResult!=null){
                /**根据运输订单号，查询出该订单还没有装货的物资*/
                List<Map<String,Object>> orderList = getMaterial(orderId.intValue());
                wmspOutboundResultMaterialService.insertOutboundMaterial(wmspOutboundResult.getResultId(),orderList);
            }
        }
        //根据运输地点ID和物资ID查询是否出库
        Map<String,Object> outMap = wmspOutboundResultMapper.getIsOutBound(mapVal);
        if(outMap == null){
            return -2;
        }
        if(DataChange.dataToBigDecimal(outMap.get("billStatus")).intValue() == 1){
            return -3;
        }
        if(DataChange.dataToBigDecimal(outMap.get("billMaterialStatus")).intValue() == 2){
            return -4;
        }
        //通过ssoid去人员管理里面找loadId
        BigDecimal loadId = wmspOutboundResultMapper.getLoadId(mapVal);
        mapVal.put("loadStartTime",new Date());
        mapVal.put("insertUpdateRemark","无");
        mapVal.put("loadId",loadId);
        mapVal.putAll(outMap);
        Map<String, Object> returnMap = tmstruckFeign.addSaleLoadResult(mapVal);
        String code = (String) returnMap.get("code");
        if("200".equals(code)){
            System.out.println("新增装车成功：" + mapVal.get("orderId"));
            //判断该车是否已全部出库 -- 查询该车待出库物资数量
            int outBoundingNum = wmspOutboundResultMapper.getOutBoundingNum(orderId);
            if(outBoundingNum -1 == 0){
                //代表全部出库,修改出库表和出库物资表的状态
                wmspOutboundResultMapper.updateStatus(DataChange.dataToBigDecimal(outMap.get("resultId")));
                wmspOutboundResultMapper.updateMaterialStatus(DataChange.dataToBigDecimal(outMap.get("resultMaterialId")));
            }else{
                wmspOutboundResultMapper.updateMaterialStatus(DataChange.dataToBigDecimal(outMap.get("resultMaterialId")));
            }
        }else {
            throw new Exception("新增装车失败");
        }
        //获取装车所需字段
        return 1;
    }



}