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.*;
import com.steerinfo.dil.model.*;
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.text.ParseException;
import java.text.SimpleDateFormat;
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 TmstruckTimeTaskResultServiceImpl tmstruckTimeTaskResultService;

    @Autowired
    private TmstruckReturnResultMapper tmstruckReturnResultMapper;

    @Autowired
    private UtilsServiceImpl utilsService;
    @Autowired
    private  TmstruckWeightResultMapper tmstruckWeightResultMapper;

    @Autowired
    private TmstruckLeaveFactoryResultMapper tmstruckLeaveFactoryResultMapper;

    @Autowired
    private TmstruckTimeTaskResultMapper tmstruckTimeTaskResultMapper;

    @Autowired
    private WmshBoundFeign wmshBoundFeign;

    @Autowired
    private UtilsMapper utilsMapper;

    @Autowired
    OmsFeign omsFeign;

    @Autowired
    private TmstruckWeightResultServiceImpl tmstruckWeightResultService;

    @Autowired
    private  TmstruckMeasureCommissionServiceImpl tmstruckMeasureCommissionService;
    @Autowired
    private TmstruckUnloadResultMapper tmstruckUnloadResultMapper;


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

    /**
     * 查询所有装车实绩
     * @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:
            case 15:
            case 16:
            case 20:
            case 23:
            case 24:
                return tmstruckLoadResultMapper.getImportedDomesticNzLoadResult(map); //apiId = 353
            case 11:
                return tmstruckLoadResultMapper.getInFactoryLoadResult(map); //apiId = 359
            case 12:
            case 13:
            case 14:
            case 19:
            case 100:
                 return tmstruckLoadResultMapper.getSporadicSuppliesLoadResult(map); //apiId = 430
        }
        return null;
    }



    /**
     * 更新装车实绩表
     * @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);
    }

    /**
     * 钢材装车
     * orderId materialId loadStartTime  loadId warehouseId insertUpdateRemark
     * @param map
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public int addXSLoadResult(Map<String, Object> map){
        //通过运输订单号查询实绩
        Map<String, Object> steelMesMap = tmstruckLoadResultMapper.getSteelLoadResult(map);
        if(steelMesMap == null){
            return -1;
        }
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        //总实绩ID 开始时间 结束时间 装车时长 物资Id 装卸工ID 装货点Id 备注
        tmstruckLoadResult.setResultId(DataChange.dataToBigDecimal(steelMesMap.get("resultId")));
        Date loadStartTime = DataChange.dataToDate(map.get("loadStartTime"));
        loadStartTime = loadStartTime == null ? new Date() : loadStartTime;
        tmstruckLoadResult.setResultLoadStartTime(loadStartTime);
        Date loadEndTime = new Date();
        tmstruckLoadResult.setResultLoadEndTime(loadEndTime);
        long duration = (loadEndTime.getTime() - loadStartTime.getTime()) / 60000;
        tmstruckLoadResult.setResultLoadDuration(new BigDecimal(duration));
        Object loadId = map.get("loadId");
        if(loadId != null){
            tmstruckLoadResult.setLoaderId(DataChange.dataToBigDecimal(map.get("loadId")));
        }
        BigDecimal materialId = DataChange.dataToBigDecimal(map.get("materialId"));
        tmstruckLoadResult.setMaterialId(materialId);
        tmstruckLoadResult.setLoadingId(DataChange.dataToBigDecimal(map.get("warehouseId")));
        tmstruckLoadResult.setInsertUpdateRemark((String) map.get("insertUpdateRemark"));
        steelMesMap.put("materialId", materialId);
        //给达钢发送委托
        steelMesMap.put("numberOfFurnaces", map.get("numberOfFurnaces")); //炉号件数
        int i = tmstruckMeasureCommissionService.addSteelMeasureCommission(steelMesMap);
        if(i == 0){
            return i;
        }
        tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
        //更新路段顺序号
        utilsService.updateOrderLineSequence(steelMesMap); //orderId segmentSqe
        //推送数据
        utilsService.pushMesToWebsocket((String) steelMesMap.get("capacityNumber"), "装货");
        return 1;
    }

    /**
     * PDA新增装车实绩 （非钢材）
     * loadStartTime 装车开始时间
     * @param map
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public int addXS2LoadResult(Map<String, Object> map) throws Exception {
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        BigDecimal orderId=null;
        int i=0;
        //通过运输订单号查询订单类型
        String orderNumber = (String) map.get("orderNumber");
        //通过订单号查询订单类型 及总实绩Id
        Map<String, Object> mesMap = utilsMapper.getOrderTypeByOrderNumber(orderNumber);
        String capacityNumber = (String) mesMap.get("capacityNumber");
        int orderType = DataChange.dataToBigDecimal(mesMap.get("orderType")).intValue();
        BigDecimal resultTotalId = DataChange.dataToBigDecimal(mesMap.get("totalId"));
        orderId = DataChange.dataToBigDecimal(mesMap.get("orderId"));
        //装货时查询是否含有净重
        Integer netWeight = tmstruckUnloadResultMapper.getNetWeightByTotalId(resultTotalId);
        if(orderType == 11 || orderType == 15 || orderType == 16){
            //判断是否有装货实绩,如果有装货实绩,则更新
            BigDecimal resultId = tmstruckLoadResultMapper.getResultId(resultTotalId);
            if (resultId==null) {
                int sqe = DataChange.dataToBigDecimal(mesMap.get("Sqe")).intValue();
                sqe = sqe + 1;
                map.put("resultId", tmstruckLoadResultMapper.selectMaxId());
                map.put("Sqe", sqe);//查询路段顺序号+1
                map.put("resultTotalId", resultTotalId);
                 i += tmstruckLoadResultMapper.insertSelective(generateLoad(map));
                //更新路段顺序号
                mesMap.put("orderLineSequence", sqe);
                utilsService.updateOrderLineSqeByOrderNumber(mesMap);
                //推送消息到websocket
                utilsService.pushMesToWebsocket(capacityNumber, "装货");
            }else {
                //已装货的实绩
                //map.put("resultId",resultId);
                tmstruckLoadResult.setResultId(resultId);
                if(map.get("personnelSsoId") != null){
                    //通过SSo主键查询人员管理主键
                    Integer personnelId = utilsMapper.getPersonnelIdBySsoId((String) map.get("personnelSsoId"));
                    if(personnelId != null){
                        tmstruckLoadResult.setLoaderId(new BigDecimal(personnelId));
                    }else{
                        String capacityName = utilsMapper.getCapacityNameBySsoId((String) map.get("personnelSsoId"));
                        if(capacityName != null){
                            tmstruckLoadResult.setCapacityRemark(capacityName);
                        }
                    }
                }
                i += tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);

            }
            //根据运输订单查找需求备注
            Map<String,Object>  remarkMap=tmstruckTimeTaskResultMapper.selectInwardDueTimeByOrderId(orderId);
            String remark =(String) remarkMap.get("remark");
            if (remark.contains("计时")){
                //判断计时是否开始
                BigDecimal startTime = utilsMapper.getTime(DataChange.dataToBigDecimal(orderId));
                if (startTime==null){
                    map.put("inwardTypes",1);
                    tmstruckTimeTaskResultService.addTimeTaskResult(map);
                }
            }
            return i;
        }
        //如果是零星多拼订单 需要查询这个物资是否已经装过了
        if(orderType == 12 || orderType == 13){
            mesMap.put("updateUnloadResult", 1);
            Integer checkMaterial = tmstruckLoadResultMapper.checkMaterialIdLoad(resultTotalId, DataChange.dataToBigDecimal(map.get("materialId")));
            if(checkMaterial != null){
                return -2; //已装过此物资
            }
        }
        Map<String, Object> dataMap = tmstruckLoadResultMapper.getLoadResultIdByMIdAndTotalId(mesMap);
        if(dataMap == null){
            return -3; //该订单没有装车作业
        }
        //获取该实绩的路段顺序号
        BigDecimal segmentSqe = DataChange.dataToBigDecimal(dataMap.get("segmentSqe"));
        //获取订单的路段顺序号
        BigDecimal orderSegmentSqe = DataChange.dataToBigDecimal(mesMap.get("orderSegmentSqe"));
        if(segmentSqe.intValue() > (orderSegmentSqe.intValue() + 1)){
            return -6;
        }
        //查询装车实绩ID
        map.putAll(dataMap);
        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")));
        if(netWeight == 0){ //如果没有净重 则更新路段顺序号  有则不更新
            //路段顺序号 + 1
            map.put("orderId", mesMap.get("orderId"));
            utilsService.updateOrderLineSequence(map);
        }
        ////更新路段顺序号
        //utilsService.updateOrderLineSequence(map);
        //判断是否存在未装货出厂的出厂实绩
        if(tmstruckLoadResultMapper.countJudgeLeave(mesMap)>0){
            //回滚出厂信息
            rollbackJudge(mesMap);
        }
        //判断是否为未装货
        if (map.get("insertUpdateRemark")!=null) {
            String insertUpdateRemark = (String) map.get("insertUpdateRemark");
            if("未装货".equals(insertUpdateRemark)){
                loadJudge(mesMap);
            }
            tmstruckLoadResult.setInsertUpdateRemark(insertUpdateRemark);
        }
        addCapacityRemark(map);
        tmstruckLoadResult.setCaseNumber((String) map.get("caseNumber"));
        tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
        //推送消息到websocket
        utilsService.pushMesToWebsocket(capacityNumber, "装货");
        //map.put("orderTypee",orderType);
        if (map.get("warehouseId")==null){
          map.put("warehouseName",null);
        }else {
            //根据id查找装货点名称
            String warehouseName = utilsMapper.queryWarehouseName(DataChange.dataToBigDecimal(map.get("warehouseId")));
            map.put("warehouseName",warehouseName);
        }
        i =  tmstruckMeasureCommissionService.addMeasureCommissionForLoding(map);
        return 1;
    }

    @Override
    public int LoadMeasure(Map<String, Object> map) throws Exception {
        return tmstruckMeasureCommissionService.addMeasureCommissionForLoding(map);
    }


    //内转添加装货实绩
    private TmstruckLoadResult generateLoad(Map<String, Object> map) {
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        tmstruckLoadResult.setId(DataChange.dataToBigDecimal(map.get("resultId")));
        tmstruckLoadResult.setResultTotalId(DataChange.dataToBigDecimal(map.get("resultTotalId")));
        tmstruckLoadResult.setStatus(new BigDecimal(0));
        tmstruckLoadResult.setSegmentSqe(DataChange.dataToBigDecimal(map.get("Sqe")));
        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));
            }else{
                String capacityName = utilsMapper.getCapacityNameBySsoId((String) map.get("personnelSsoId"));
                if(capacityName != null){
                    tmstruckLoadResult.setCapacityRemark(capacityName);
                }
            }
        }
        tmstruckLoadResult.setInsertUpdateRemark((String) map.get("insertUpdateRemark"));
        // 添加装货点
        tmstruckLoadResult.setLoadingId(DataChange.dataToBigDecimal(map.get("warehouseId")));
        return tmstruckLoadResult;
    }

    /**
     * 更改最大路段顺序号 -1
     * @Author TXF
     * @Date 2022/2/13 12:59
     * @param map
     * @return
     **/
    @Override
    public int loadJudge(Map<String, Object> map) {
        BigDecimal orderId =DataChange.dataToBigDecimal(map.get("orderId"));
        //查找当前订单共有几次出厂
        List<Integer> resultIdList = tmstruckLoadResultMapper.allOutFactoryNum(orderId);
        if(resultIdList.size() > 1){
            for(int i = 0; i < resultIdList.size() - 1; i ++){
                //给最后一次出厂 之外的出厂实绩 赋值出厂时间
                TmstruckLeaveFactoryResult tmstruckLeaveFactoryResult = new TmstruckLeaveFactoryResult();
                tmstruckLeaveFactoryResult.setResultId(new BigDecimal(resultIdList.get(i)));
                tmstruckLeaveFactoryResult.setResultOutMode("未装货出厂");
                tmstruckLeaveFactoryResult.setResultOutGateTime(new Date());
                tmstruckLeaveFactoryResultMapper.updateByPrimaryKeySelective(tmstruckLeaveFactoryResult);
            }
        }
        return tmstruckLoadResultMapper.updateSqe(orderId);
    }

    /**
     * 回退未装货
     * @Author TXF
     * @Date 2022/2/13 12:59
     * @param map
     * @return
     **/
    public int rollbackJudge(Map<String, Object> map) {
        BigDecimal orderId =DataChange.dataToBigDecimal(map.get("orderId"));
        //查找当前订单所有未装货出厂
        List<Integer> resultIdList = tmstruckLoadResultMapper.allOutFactoryJudge(orderId);
        for(Integer resultId: resultIdList){
            //清空出厂信息
            TmstruckLeaveFactoryResult tmstruckLeaveFactoryResult = tmstruckLeaveFactoryResultMapper.selectByPrimaryKey(new BigDecimal(resultId));
            tmstruckLeaveFactoryResult.setResultOutMode(null);
            tmstruckLeaveFactoryResult.setResultOutGateTime(null);
            tmstruckLeaveFactoryResultMapper.updateByPrimaryKey(tmstruckLeaveFactoryResult);
        }
        //更新订单路段顺序号为装货路段顺序号
        return tmstruckLoadResultMapper.updateLoadSeq(map);
    }

    /**
     * 添加装车标准时长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;
    }

    @Override
    public int addCapacityRemark(Map<String, Object> map) {
        int i=0;
        TmstruckLoadResult tmstruckLoadResult=new TmstruckLoadResult();
        String capacityName = utilsMapper.getCapacityNameBySsoId((String) map.get("personnelSsoId"));
        if (capacityName!=null) {
            map.put("capacityName",capacityName);
            //判断装机是否重复扫码
            BigDecimal loadResultId = utilsMapper.getLoadResultId(map);
            if (loadResultId == null) {
                tmstruckLoadResult.setResultId(DataChange.dataToBigDecimal(map.get("resultId")));
                tmstruckLoadResult.setCapacityRemark(capacityName);
                i = tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
            }else {
                i=-5;
            }
        }
        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);
    }

    /**
     * @author:zyf
     * @version:1.0
     * @Date:
     * @Description:新增装货表
    */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int addLoad1(Map<String, Object> map) {
        //获取装货表主键ID
        BigDecimal ResultId = tmstruckLoadResultMapper.selectMaxId();
        TmstruckLoadResult tmstruckLoadResult = new TmstruckLoadResult();
        //总实绩ID 开始时间 结束时间 装车时长 物资Id 装卸工ID 装货点Id 备注
        //主键ID
        tmstruckLoadResult.setResultId(ResultId);
        //装卸工ID
        tmstruckLoadResult.setLoaderId(DataChange.dataToBigDecimal(map.get("loadId")));
        //装货开始时间
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String loadStartTime =(String) map.get("loadStartTime");
        try {
            Date loadStartTime1 = sdf2.parse(loadStartTime);
            tmstruckLoadResult.setResultLoadStartTime(loadStartTime1);
            //结束时间
            Date loadEndTime = new Date();
            tmstruckLoadResult.setResultLoadEndTime(loadEndTime);
            //装货时长
            long duration = (loadEndTime.getTime() - loadStartTime1.getTime()) / 60000;
            tmstruckLoadResult.setResultLoadDuration(new BigDecimal(duration));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        //总实绩ID
        tmstruckLoadResult.setResultTotalId(DataChange.dataToBigDecimal(map.get("resultid")));
        //物资ID
        tmstruckLoadResult.setMaterialId(BigDecimal.valueOf((int)map.get("materialId")));
        //装货点ID
        tmstruckLoadResult.setLoadingId(BigDecimal.valueOf((int)map.get("warehouseId")));
        //理重
        BigDecimal lz= (BigDecimal.valueOf((Double) map.get("calculateTW")));
        tmstruckLoadResult.setResultMeasuredTonnage(lz);
        int i=tmstruckLoadResultMapper.insertSelective(tmstruckLoadResult);
        TmstruckWeightResult tmstruckWeightResult=new TmstruckWeightResult();
        tmstruckWeightResult.setWeightTaskResultId(tmstruckWeightResultMapper.selectMaxId());
        tmstruckWeightResult.setResultTotalId(DataChange.dataToBigDecimal(map.get("resultid")));
        tmstruckWeightResult.setResultNetWeight(lz);
        tmstruckWeightResultMapper.insertSelective(tmstruckWeightResult);
        //给运输订单的路段序列号加一
        //1.先查询出来
        BigDecimal orderId=BigDecimal.valueOf((int)map.get("orderId"));
        BigDecimal orderlinesequence=tmstruckWeightResultMapper.queryRoadId(orderId);
        if (orderlinesequence==null){
            orderlinesequence=BigDecimal.ZERO;
        }
        //2.加一在赋值进去
        tmstruckWeightResultMapper.updateToRoadId(orderlinesequence.add(BigDecimal.valueOf(1)),orderId);
        if (i==1){
            return i;
        }
        return 0;
    }

    @Override
    public Map<String, Object> selectLoadingIdRemark(Map<String, Object> map) {
        //查询装卸货信息（装载机(CAPACITY_REMARK),修改备注(INSERT_UPDATE_REMARK)，装货点，卸货点，卸货物资）
        return tmstruckLoadResultMapper.selectLoadingIdRemark(map);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int updateLoadingIdRemark(Map<String, Object> map) {
        if(DataChange.dataToBigDecimal(map.get("orderType")).intValue() == 11) {
            //如果是内转计重订单,则需要先寻找需求/计划进行替换
            BigDecimal orderPlanId = tmstruckLoadResultMapper.selectInwardOrderPlanId(map);
            if(orderPlanId == null) {
                return 11;
            }
            map.put("orderPlanId",orderPlanId);
            tmstruckLoadResultMapper.updateOOOrderPlanId(map);
            tmstruckLoadResultMapper.updateOOMaterialId(map);
        }
        if(DataChange.dataToBigDecimal(map.get("orderType")).intValue() == 21) {
            //如果是内转计重订单,则需要先寻找需求/计划进行替换
            BigDecimal orderPlanId = tmstruckLoadResultMapper.selectInwardOrderPlanId(map);
            if(orderPlanId == null) {
                return 11;
            }
            map.put("orderPlanId",orderPlanId);
            tmstruckLoadResultMapper.updateOOOrderPlanId(map);
            tmstruckLoadResultMapper.updateOOMaterialId(map);
            return 0;
        }
        //更新装货
        TmstruckLoadResult tmstruckLoadResult=new TmstruckLoadResult();
        tmstruckLoadResult.setResultId(DataChange.dataToBigDecimal(map.get("loadResultId")));
        tmstruckLoadResult.setLoadingId(DataChange.dataToBigDecimal(map.get("loadingId")));
        tmstruckLoadResult.setMaterialId(DataChange.dataToBigDecimal(map.get("materialId")));
        tmstruckLoadResult.setCapacityRemark((String)map.get("capacityRemark"));
        tmstruckLoadResult.setInsertUpdateRemark((String)map.get("insertUpdateRemark"));
        //更新卸货unloadResultId
        TmstruckUnloadResult tmstruckUnloadResult=new TmstruckUnloadResult();
        tmstruckUnloadResult.setResultId(DataChange.dataToBigDecimal(map.get("unloadResultId")));
        tmstruckUnloadResult.setResultUnloadPlaceId(DataChange.dataToBigDecimal(map.get("unloadingId")));
        tmstruckUnloadResult.setMaterialId(DataChange.dataToBigDecimal(map.get("materialId")));
        //若计量实绩不为空
        if(map.get("weightTaskId") != null) {
            TmstruckWeightResult tmstruckWeightResult = new TmstruckWeightResult();
            tmstruckWeightResult.setWeightTaskResultId(DataChange.dataToBigDecimal(map.get("weightTaskId")));
            tmstruckWeightResult.setMaterialId(DataChange.dataToBigDecimal(map.get("materialId")));
            tmstruckWeightResultMapper.updateByPrimaryKeySelective(tmstruckWeightResult);
        }
        tmstruckLoadResultMapper.updateByPrimaryKeySelective(tmstruckLoadResult);
        tmstruckUnloadResultMapper.updateByPrimaryKeySelective(tmstruckUnloadResult);
        return 0;
    }
}