DAL-TMS-TRUCK-API/src/main/java/com/steerinfo/dil/service/impl/TmstruckLoadResultServiceImpl.java

package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.feign.OmsFeign;
import com.steerinfo.dil.feign.WMSFeign;
import com.steerinfo.dil.feign.WmshBoundFeign;
import com.steerinfo.dil.mapper.TmstruckEnfactoryResultMapper;
import com.steerinfo.dil.mapper.TmstruckLoadResultMapper;
import com.steerinfo.dil.mapper.TmstruckReturnResultMapper;
import com.steerinfo.dil.mapper.UtilsMapper;
import com.steerinfo.dil.model.TmstruckLoadResult;
import com.steerinfo.dil.service.ITmstruckLoadResultService;
import com.steerinfo.dil.util.DataChange;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.*;

/**
 * TmstruckLoadResult服务实现：
 * @author generator
 * @version 1.0-SNAPSHORT 2021-09-02 10:38
 * 类描述
 * 修订历史：
 * 日期：2021-09-02
 * 作者：generator
 * 参考：
 * 描述：TmstruckLoadResult服务实现
 * @see null
 * @Copyright 湖南视拓信息技术股份有限公司. All rights reserved.
 */
@Service(value = "tmstruckLoadResultService")
public class TmstruckLoadResultServiceImpl implements ITmstruckLoadResultService {

    @Autowired
    private TmstruckLoadResultMapper tmstruckLoadResultMapper;

    @Autowired
    private TmstruckEnfactoryResultMapper tmstruckEnfactoryResultMapper;

    @Autowired
    private TmstruckReturnResultMapper tmstruckReturnResultMapper;

    @Autowired
    private UtilsServiceImpl utilsService;

    @Autowired
    private RulesServiceImpl rulesService;

    @Autowired
    private WmshBoundFeign wmshBoundFeign;

    @Autowired
    private UtilsMapper utilsMapper;

    @Autowired
    OmsFeign omsFeign;

    @Autowired
    private TmstruckWeightResultServiceImpl tmstruckWeightResultService;

    @Autowired
    private TmstruckMeasureCommissionServiceImpl tmstruckMeasureCommissionService;

    /**
     * 查询所有装车实绩
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getAllLoadResult(Map<String, Object> map) {
        Integer orderType = (Integer) map.get("orderTypee");
        switch (orderType) {
            case 1:
            case 2:
            case 3:
                map.put("status", 0);
                return tmstruckLoadResultMapper.getXSLoadResult(map); //apiId = 221
            case 4:
                return tmstruckLoadResultMapper.getSteelNzLoadResult(map); //apiID: 263
            case 5:
                break;
            case 6:
                break;
            case 7:
                break;
            case 8:
                return tmstruckLoadResultMapper.getCGJKLoadResult(map); // apiId = 91
            case 9:
            case 10:
                return tmstruckLoadResultMapper.getImportedDomesticNzLoadResult(map); //apiId = 353
            case 11:
                return tmstruckLoadResultMapper.getInFactoryLoadResult(map); //apiId = 359
            case 12:
            case 13:
            case 15:
                return tmstruckLoadResultMapper.getSporadicSuppliesLoadResult(map); //apiId = 404
        }
        return null;
    }

    /**
     * 新增采购装车实绩  / 内转装车实绩
     * @param map  resultMeasuredTonnage ：计量吨位  portId：港口ID
     *             resultLoadStartTime：装车时间 resultIsclear：是否清场
     */
    @Transactional
    public int addCGLoadResult(Map<String,Object> map){
        //通过运输订单号 或 运单Id 查询实绩总表ID  此方法在 进厂作业mapper中
        Map<String,Object> orderMap = tmstruckEnfactoryResultMapper.selectTotalResultIdByCpAndOn(map);
        BigDecimal totalId = (BigDecimal) orderMap.get("resultTotalId");
        //通过实绩总表ID查询装车实绩ID
        BigDecimal loadResultId = tmstruckLoadResultMapper.getResultId(totalId);

        TmstruckLoadResult tmstruckLoadResult = tmstruckLoadResultMapper.selectByPrimaryKey(loadResultId);
        //添加主键Id
//        tmstruckLoadResult.setResultId(tmstruckLoadResultMapper.selectMaxId());
        //新增计量吨位 装车所装的重量
        BigDecimal resultMeasuredTonnage = DataChange.dataToBigDecimal(map.get("resultMeasuredTonnage"));
        tmstruckLoadResult.setResultMeasuredTonnage(resultMeasuredTonnage);
        tmstruckLoadResult.setStatus(new BigDecimal(0));
//        tmstruckLoadResult.setResultTotalId(totalId);
        String resultIsclear = (String) (map.get("resultIsclear"));
        tmstruckLoadResult.setResultIsclear(resultIsclear);
        tmstruckLoadResult.setResultLoadEndTime(new Date((long) map.get("resultLoadStartTime")));
        tmstruckLoadResult.setInsertUpdateRemark((String) map.get("insertUpdateRemark"));
        //根据订单ID查询订单类型
        Integer orderType = tmstruckLoadResultMapper.getOrderType(totalId);
        if(orderType == 8){
            tmstruckLoadResult.setSegmentSqe(new BigDecimal(1));
        }
        Object portId = map.get("portId"); //获取港口
        if(portId != null){
            //通过订单ID获取批次Id
            BigDecimal batchId = tmstruckLoadResultMapper.getBatchIdByOrderId(DataChange.dataToBigDecimal(map.get("orderId")));
            if(batchId != null){
                Map<String, Object> hashMap = new HashMap<>();
                hashMap.put("batchId", batchId);
                hashMap.put("portId", portId);
                hashMap.put("resultTonnage",resultMeasuredTonnage);
                hashMap.put("isClean", resultIsclear);
                wmshBoundFeign.addResult(hashMap);
                // 通过港口ID查询仓库表中的港存库ID
                BigDecimal warehouseId = tmstruckLoadResultMapper.getWarehouseIdByPortId(DataChange.dataToBigDecimal(portId));
                tmstruckLoadResult.setLoadingId(warehouseId); // 添加装货点为港口
            }
        }
        int i = tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
        String capacityNumber = (String) orderMap.get("capacityNumber");
        utilsService.pushMesToWebsocket(capacityNumber,"装货！");
        //修改订单状态为执行中 1
//        int i1 = utilsService.updateOrderStatus(map, 1);
        //修改运力状态为执行中 1
//        int i2 = utilsService.updateCapacityStatus(map, 1);
        return i ;
    }


    /**
     * 生成销售装车实绩（虚拟装车实绩）
     * @param map
     * @return
     */
    public int addLoadResult(Map<String, Object> map){
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        //添加主键Id
        tmstruckLoadResult.setResultId(tmstruckLoadResultMapper.selectMaxId());
        //添加物资Id
        tmstruckLoadResult.setMaterialId(DataChange.dataToBigDecimal(map.get("materialId")));
        //添加总实绩ID
        tmstruckLoadResult.setResultTotalId(DataChange.dataToBigDecimal(map.get("resultTotalId")));
        // 添加路段顺序号
        tmstruckLoadResult.setSegmentSqe(DataChange.dataToBigDecimal(map.get("segmentSqe")));
        return tmstruckLoadResultMapper.insertSelective(tmstruckLoadResult);
    }

    /**
     * 更新装车实绩表
     * @return
     */
    public int updateLoadingId(Map<String, Object> map){
        //获取装车实绩Id  订单ID 物资ID
        Integer loadResultId = tmstruckLoadResultMapper.getLoadResultId(map);
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        tmstruckLoadResult.setResultId(new BigDecimal(loadResultId));
        tmstruckLoadResult.setLoadingId(DataChange.dataToBigDecimal(map.get("loadingId")));
        return tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
    }

    /**
     * PDA新增销售钢材装车实绩  （如果是多种物资【多拼】，通过物资Id和运输订单号来确定唯一的装车实绩进行修改）
     *    orderNumber 运输订单号
     *  insertUpdateRemark 备注   scanText 扫描结果
     * @param map
     * @return
     */
    @Transactional
    public int addXSLoadResult(Map<String, Object> map){
        //通过扫描结果截取物资唯一编码
        String scanText = (String) map.get("scanText");
        String[] split = scanText.split("-");
        String materialOnlyCode = split[7];
        //通过物资唯一编码查找物资Id
        BigDecimal materialId = tmstruckLoadResultMapper.getMaterialIdByMaterialCode(materialOnlyCode);
        //通过运输订单号查找总实绩ID
        Map<String,Object> orderMap = tmstruckEnfactoryResultMapper.selectTotalResultIdByCpAndOn(map);
        BigDecimal resultTotalId = (BigDecimal) orderMap.get("resultTotalId");
        map.put("resultTotalId", resultTotalId.intValue());
        //通过总实绩ID与物资ID查找 装车实绩主键ID
        Map<String, Object> resultIdMap = tmstruckLoadResultMapper.getLoadResultIdByMIdAndTotalId(resultTotalId.intValue(), materialId.intValue());
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        tmstruckLoadResult.setStatus(new BigDecimal(0)); // 添加状态0:正常
        //编辑装车实绩主键ID对应的各个字段
        tmstruckLoadResult.setResultId(DataChange.dataToBigDecimal(resultIdMap.get("resultId")));
        // 获取扫描实绩最小Id  添加扫描开始时间
        map.put("materialId", materialId);
        Map<String, Object> scanMap = tmstruckLoadResultMapper.getMinScanIdByOrderNum(map);
        Date resultLoadStartTime = tmstruckLoadResultMapper.selectLoadTimeByResultId(DataChange.dataToBigDecimal(scanMap.get("resultId")));
        tmstruckLoadResult.setResultLoadStartTime(resultLoadStartTime);
        // 添加装卸工Id
        tmstruckLoadResult.setLoaderId(DataChange.dataToBigDecimal(scanMap.get("loadId")));
        // 添加扫描结束时间 以调用当前接口时间为结束时间
        Date resultLoadEndTime = new Date();
        tmstruckLoadResult.setResultLoadEndTime(resultLoadEndTime);
        // 添加装车实绩时长  ----  计算装车时长
        long time = (resultLoadEndTime.getTime() - resultLoadStartTime.getTime()) / 60000; // 分钟
        tmstruckLoadResult.setResultLoadDuration(new BigDecimal(time));
        //添加装车标准时长
        setLoadStandardTimeId((String)map.get("orderNumber"), tmstruckLoadResult);
        Object platformName = map.get("platformName");
        if(platformName != null){
            // 如果月台不为空则更新月台
            Integer platformId = utilsService.queryPlatformIdByName((String) platformName);
            tmstruckLoadResult.setLoadingId(new BigDecimal(platformId));
        }
        // 添加备注
        tmstruckLoadResult.setInsertUpdateRemark((String) map.get("insertUpdateRemark"));
        int i = tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
        //更新汽车衡
        i += tmstruckWeightResultService.calculateTruckCalculate(map, resultTotalId.intValue());
        //发送计毛委托 订单类型：1
//        map.put("orderTypee", 1);
//        tmstruckMeasureCommissionService.addMaoMeasureCommission(map);
        return i;
    }

    /**
     * PDA新增销售钢渣、水渣、危化品装车实绩  采购内转
     * loadStartTime 装车开始时间
     * warehouseId  仓库Id      orderNumber 运输订单号 / orderId   insertUpdateRemark 备注
     * @param map
     * @return
     */
    @Transactional
    public int addXS2LoadResult(Map<String, Object> map){
        //通过运输订单号 查询 总实绩ID、订单类型
        Map<String,Object> orderMap = tmstruckEnfactoryResultMapper.selectTotalResultIdByCpAndOn(map);
        BigDecimal resultTotalId = (BigDecimal) orderMap.get("resultTotalId");
        //查询装车实绩ID
        map.putAll(tmstruckLoadResultMapper.getLoadResultIdByMIdAndTotalId(resultTotalId.intValue(), null));
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        tmstruckLoadResult.setResultId(DataChange.dataToBigDecimal(map.get("resultId")));
        tmstruckLoadResult.setStatus(new BigDecimal(0));
        tmstruckLoadResult.setMaterialId(DataChange.dataToBigDecimal(map.get("materialId")));
        //添加装车开始时间
        Date loadStartTime = new Date((long) map.get("loadStartTime"));
        tmstruckLoadResult.setResultLoadStartTime(loadStartTime);
        //添加装车结束时间(当前时间)
        Date loadEndTime = new Date();
        tmstruckLoadResult.setResultLoadEndTime(loadEndTime);
        //计算装车时长 取分钟
        long differentTime = (loadEndTime.getTime() - loadStartTime.getTime()) / 60000;
        tmstruckLoadResult.setResultLoadDuration(new BigDecimal(differentTime));
        if(map.get("personnelSsoId") != null){
            //通过SSo主键查询人员管理主键
            Integer personnelId = utilsMapper.getPersonnelIdBySsoId((String) map.get("personnelSsoId"));
            if(personnelId != null){
                tmstruckLoadResult.setLoaderId(new BigDecimal(personnelId));
            }
        }
        // 更新装货点
        tmstruckLoadResult.setLoadingId(DataChange.dataToBigDecimal(map.get("warehouseId")));
        tmstruckLoadResult.setInsertUpdateRemark((String) map.get("insertUpdateRemark"));
        int i = tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
        //装车成功后计算计毛汽车衡（出厂：2）
        BigDecimal orderType = DataChange.dataToBigDecimal(orderMap.get("orderType"));
        BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
        Map<String, Object> mesMap = new HashMap<>();
        mesMap.put("orderType", orderType);
        mesMap.put("orderId", orderId);
        int placeId = rulesService.calculateWeighbridge(mesMap);
        mesMap.put("grossPlaceId", placeId);
        i += tmstruckWeightResultService.updateWeightResult(mesMap);

        //更新路段顺序号
        i += utilsService.updateOrderLineSequence(map);
        //推送消息到websocket
        utilsService.pushMesToWebsocket((String) orderMap.get("capacityNumber"), "装货");
        return i;
    }

    /**
     * 添加装车标准时长ID
     * @param orderNumber
     * @param tmstruckLoadResult
     */
    public void setLoadStandardTimeId(String orderNumber, TmstruckLoadResult tmstruckLoadResult){
        //添加标准时长ID 通过运输订单号查找运输订单类型
        Integer orderType = tmstruckLoadResultMapper.selectOrderTypeByOrderNumber(orderNumber);
        if(orderType == 1){
            tmstruckLoadResult.setLoadStandardTimeId(new BigDecimal(1));
        }else if(orderType == 2){
            tmstruckLoadResult.setLoadStandardTimeId(new BigDecimal(2));
        }else if(orderType == 3){
            tmstruckLoadResult.setLoadStandardTimeId(new BigDecimal(3));
        }
    }

    /**
     * 修改装车作业
     * @param tmstruckLoadResult
     * @return
     */
    @Override
    public int updateLoadResult(TmstruckLoadResult tmstruckLoadResult) {
//        BigDecimal orderId = tmstruckLoadResultMapper.getOrderId(tmstruckLoadResult.getResultId());
//        Map<String , Object> map = new
//        omsFeign.pushMesToWebsocket(map);
        return tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
    }



    /**
     * 通过ID查询装车实绩
     *
     * @param resultId
     * @return
     */
    @Override
    public List<Map<String, Object>> getLoadResultById(Integer resultId) {
        return tmstruckLoadResultMapper.getLoadResultById(resultId);
    }

    /**
     * 逻辑删除装车实绩 状态 1
     * @param resultId
     * @return
     */
    @Override
    public int deleteLoadResult(Integer resultId) {
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        tmstruckLoadResult.setResultId(new BigDecimal(resultId));
        tmstruckLoadResult.setStatus(new BigDecimal(1));
        return tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
    }

    /**
     * 修改装车作业点
     * @param mapList
     * @return
     */
    @Override
    public int updateLoadingIds(List<Map<String, Object>> mapList) {
        int i = 0;
        //获取所有装车实绩ID
        for (Map<String, Object> map : mapList) {
            TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
            //通过传过来的物资ID（一个订单中物资ID唯一） 和订单Id 寻找装车实绩ID
            Integer resultIdList = tmstruckLoadResultMapper.getLoadResultId(map);
            tmstruckLoadResult.setResultId(new BigDecimal(resultIdList));
            //获取算出来的装车点
            tmstruckLoadResult.setLoadingId(DataChange.dataToBigDecimal(map.get("loadingId")));
            i += tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
        }
        return i;
    }

    /**
     * 查询销售合同装车实绩
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> selectLoadResultForSale(Map<String, Object> map) {
        return tmstruckLoadResultMapper.selectLoadResultForSale(map);
    }

    /**
     * 内转物流，新增装车实绩
     */
    @Override
    public int addLoadResultForconverted(Map<String, Object> map) {
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        //设置主键id
        tmstruckLoadResult.setResultId(tmstruckLoadResultMapper.selectMaxId());

        //获取开始时间
        Date startTime = (Date) map.get("startTime");
        //获取运输订单号
        String OrderNumber = map.get("OrderNumber").toString();
        Map<String, Object> Map = new HashMap<>();
        Map.put("OrderNumber", OrderNumber);
        //通过运输订单号查找物资id
        List<Map<String, Object>> materialIdList = tmstruckLoadResultMapper.selectMaterialIdByOrderNumber(Map);
        //设置物资id
        for (int i = 0; i < materialIdList.size(); i++) {
            Map<String, Object> map1 = materialIdList.get(i);
            Integer materialId = (Integer) map1.get("materialId");
            tmstruckLoadResult.setMaterialId(new BigDecimal(materialId));
        }
        //绑定总实绩id
        Map<String, Object> map2 = tmstruckReturnResultMapper.getResultTotalIdByOrderNumber(OrderNumber);
        BigDecimal reultTotalId = (BigDecimal) map2.get("resultTotalId");
        //设置总实绩id
        tmstruckLoadResult.setResultTotalId(reultTotalId);
        tmstruckLoadResult.setResultLoadStartTime(startTime);
        //获取用户id
        Integer personnelId = (Integer) map.get("personnelId");
        String personnelName = tmstruckLoadResultMapper.selectPersonNameByPersonnelId(personnelId);
        tmstruckLoadResult.setInsertTime(new Date());
        tmstruckLoadResult.setInsertUsername(personnelName);
        int i = tmstruckLoadResultMapper.insertSelective(tmstruckLoadResult);
        return i;
    }

    //内转物流,修改装车实绩
    @Override
    public int updateLoadResultForconverted(Map<String, Object> map) {
        //获取装车实绩id
        //通过运输订单号查找装车实绩
        String orderNumber = (String) map.get("orderNumber");
        Map<String, Object> map1 = tmstruckLoadResultMapper.selectLoadResultIdByOrderNumber(orderNumber);
        //获取结束时间
        Integer LoadResultId = (Integer) map1.get("loadResultId");
        Date endTime = (Date) map.get("endTime");
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        //根据主键id设置装车结束时间
        tmstruckLoadResult.setResultId(new BigDecimal(LoadResultId));
        tmstruckLoadResult.setResultLoadEndTime(endTime);
        //获取装车开始时间
        Date startTime = (Date) map1.get("startTime");
        //开始时间
        long LoadstartTime = startTime.getTime();
        long LoadendTime = endTime.getTime();
        long time = LoadendTime - LoadstartTime;
        long l = time / 1000;
        //设置标准时长
        tmstruckLoadResult.setResultLoadDuration(new BigDecimal(l));
        int i = tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
        return i;
    }

    @Override
    public Map<String, Object> getLoadResultIdForOrderNumber(String orderNumber) {
        return tmstruckLoadResultMapper.selectLoadResultIdByOrderNumber(orderNumber);
    }

    /**
     * 内转物流汽车装货实绩展示
     *
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> selectLoadResultForConverted(Map<String, Object> map) {
        return tmstruckLoadResultMapper.selectLoadResultForConverted(map);
    }


    /**
     * 根据实绩id渲染数据
     *
     * @param resultId
     * @return
     */
    @Override
    public List<Map<String, Object>> selectLoadResultByResultId(Integer resultId) {
        return tmstruckLoadResultMapper.selectLoadResultByResultId(resultId);
    }

    /**
     * 内转物流新增装车实绩(火车卸货后装车，装车点固定为达州站）
     *
     * @param map
     * @return
     */
    @Override
    public int addLoadResultForConverted(Map<String, Object> map) {
        Integer personnelId = (Integer) map.get("personnelId");
        String personnelName = tmstruckLoadResultMapper.selectPersonNameByPersonnelId(personnelId);
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        tmstruckLoadResult.setResultId(tmstruckLoadResultMapper.selectMaxId());
        //获取车牌号，物资id以及总实绩id
        String capacityNumber = (String) map.get("capacityNumber");
        Map<String, Object> map1 = tmstruckLoadResultMapper.selectMaterialIdAndCapacityId(capacityNumber);
        BigDecimal materialId = (BigDecimal) map1.get("materialId");
        BigDecimal resultTotalId = (BigDecimal) map1.get("resultTotalId");
        tmstruckLoadResult.setMaterialId(materialId);
        tmstruckLoadResult.setResultTotalId(resultTotalId);
        tmstruckLoadResult.setInsertTime(new Date());
        //获取装货点
        Integer arrivalId = (Integer) map.get("arrivalId");
        tmstruckLoadResult.setLoadingId(DataChange.dataToBigDecimal(arrivalId));
        Date insertTime = (Date) map.get("insertTime");
        tmstruckLoadResult.setInsertTime(insertTime);
        Integer tonnage = (Integer) map.get("tonnage");
        tmstruckLoadResult.setResultMeasuredTonnage(DataChange.dataToBigDecimal(tonnage));
        tmstruckLoadResult.setInsertUsername(personnelName);
        return tmstruckLoadResultMapper.insertSelective(tmstruckLoadResult);
    }


    /**
     * 查询所有正在排队的销售订单
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getSaleOrderOnQueue(Map<String, Object> map) {
        return tmstruckLoadResultMapper.getSaleOrderOnQueue(map);
    }


    /**
     * 修改装车点和装车顺序
     * @param map
     * @return
     */
    public int updateLoadingIdAndLoadSq(Map<String, Object> map){
        //前端传来数据结构类型为 {order: Integer, list: List<Map<String, Object>>}
        BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
        List<Map<String, Object>> list = (List<Map<String, Object>>) map.get("list");
        int i = 0;
        for (Map<String, Object> mesMap : list) {
            mesMap.put("orderId", orderId);
            //通过物资ID和订单ID查询装车实绩ID
            Integer resultId = tmstruckLoadResultMapper.getLoadIdByOrderIdAndMId(mesMap);
            TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
            tmstruckLoadResult.setResultId(new BigDecimal(resultId));
            //设置装车顺序
            tmstruckLoadResult.setLoadingSequence(DataChange.dataToBigDecimal(mesMap.get("serialNumber")));
            //设置装车月台
            tmstruckLoadResult.setLoadingId(DataChange.dataToBigDecimal(mesMap.get("platformId")));
            i += tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
        }
        return i;
    }


    /**
     * 新增内转国产矿进口矿装车实绩
     * @param map
     * @return
     */
    public int addDaZhouToDaGangLoadResult(Map<String, Object> map){
        List<Integer> totalResultIdList = (List<Integer>) map.get("totalResultIdList");
        BigDecimal loadingId = DataChange.dataToBigDecimal(map.get("loadingId"));
        //添加是否需要质检字段
        BigDecimal isdeduct = DataChange.dataToBigDecimal(map.get("isdeduct"));
        Date loadTime = new Date((long) map.get("loadTime"));
        int count = 0;
        for (Integer totalResultId : totalResultIdList) {
            TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
            tmstruckLoadResult.setResultId(tmstruckLoadResultMapper.selectMaxId());
            tmstruckLoadResult.setResultTotalId(new BigDecimal(totalResultId));
            tmstruckLoadResult.setLoadingId(loadingId);
            tmstruckLoadResult.setIsdeduct(isdeduct);
            tmstruckLoadResult.setResultLoadStartTime(loadTime);
            tmstruckLoadResult.setStatus(new BigDecimal(0));
            tmstruckLoadResult.setInsertTime(new Date());
            tmstruckLoadResult.setInsertUsername("admin");
            count += tmstruckLoadResultMapper.insertSelective(tmstruckLoadResult);
        }
        return count;
    }

    @Override
    public List<Map<String, Object>> getCgNzLoadingResult(Map<String, Object> mapval) {
        return tmstruckLoadResultMapper.getCgNzLoadingResult(mapval);
    }
}