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

package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.feign.OmsFeign;
import com.steerinfo.dil.mapper.TmstruckTimeTaskResultMapper;
import com.steerinfo.dil.mapper.UtilsMapper;
import com.steerinfo.dil.model.TmstruckTimeTaskResult;
import com.steerinfo.dil.service.ITmstruckTimeTaskResultService;

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 javax.xml.crypto.Data;
import java.math.BigDecimal;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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

    @Autowired
    private TmstruckTimeTaskResultMapper tmstruckTimeTaskResultMapper;
    @Autowired
    private UtilsMapper utilsMapper;
    @Autowired
    private UtilsServiceImpl utilsService;
    @Autowired
    private OmsFeign omsFeign;



    /**
     * 通用生成实例数据
     *
     * @param map
     * @return
     */
    public TmstruckTimeTaskResult generateTimeTaskResult(Map<String, Object> map) {
        TmstruckTimeTaskResult tmstruckTimeTaskResult = new TmstruckTimeTaskResult();
        //获取主键ID
        tmstruckTimeTaskResult.setId(tmstruckTimeTaskResultMapper.selectMaxId());
        String orderNumber = (String) map.get("orderNumber");
        BigDecimal inwardType = DataChange.dataToBigDecimal(map.get("inwardType"));
        //通过运输订单号查询总实绩ID等数据
        map.putAll(tmstruckTimeTaskResultMapper.getResultTotalIdByOrderNum(orderNumber));
        tmstruckTimeTaskResult.setResultTotalId(DataChange.dataToBigDecimal(map.get("resultTotalId")));
        //生成时间
        tmstruckTimeTaskResult.setResultTime(new Date());
        //生成订单结束
        tmstruckTimeTaskResult.setResultUomId(new BigDecimal(900));
        //设置时间类型
        tmstruckTimeTaskResult.setResultTimeType(inwardType);
        String personnelSsoId =(String) map.get("personnelSsoId");
        tmstruckTimeTaskResult.setInsertUsername(personnelSsoId);
        tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
        return tmstruckTimeTaskResult;
    }

    /**
     * 司机申请开始
     *
     * @param map
     * @return
     */
    @Override
    public int applyStartTime(Map<String, Object> map) {
        //设置时间类型 0
        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map);
        return tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
    }

    /**
     * 用车单位确认开始
     *
     * @param map
     * @return
     */
    @Override
    public int unitSureStartTime(Map<String, Object> map) {
        //设置时间类型 1
        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map);
        return tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
    }

    /**
     * 司机申请暂停
     *
     * @param map
     * @return
     */
    @Override
    public int applyStartTimeout(Map<String, Object> map) {
        //设置时间类型 4
        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map);
        return tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
    }

    /**
     * 用车单位确认
     *
     * @param map
     * @return
     */
    @Override
    public int unitSureStartTimeout(Map<String, Object> map) {
        //设置时间类型 5
        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map);
        return tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
    }

    /**
     * 司机申请暂停结束
     *
     * @param map
     * @return
     */
    @Override
    public int applyEndTimeout(Map<String, Object> map) {
        //设置时间类型 6
        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map);
        return tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
    }

    /**
     * 用车单位确认暂停结束
     *
     * @param map
     * @return
     */
    @Override
    public int unitSureEndTimeout(Map<String, Object> map) {
        int i=0;
        //map中传输的参数为InwardType,orderNumber
        //根据运输订单号查找订单id
        //如果订单类型为5
        String personnelSsoId =(String) map.get("personnelSsoId");
        String orderNumber =(String) map.get("orderNumber");
        //根据运输订单号查找运输订单id
        BigDecimal orderId = utilsMapper.getOrderIdByOrderNumber(orderNumber);
        map.put("orderId",orderId);
        BigDecimal inwardType =DataChange.dataToBigDecimal(map.get("inwardType"));
        if (inwardType.intValue()==5){
            generateTimeTaskResult(map);
        }else if (inwardType.intValue()==7){
            TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map);
            //生成计时实绩暂停
            //根据运输订单号查找总实绩id
            BigDecimal totalId = utilsMapper.getTotalIdByOrderNumber(orderNumber);
            //根据总实绩id查找开始时间
            Map<String, Object> lastTimeout = tmstruckTimeTaskResultMapper.getLastTimeout(totalId);
            Date startTime =(Date) lastTimeout.get("resultTime");
            //根据总实绩id查找结束时间
            Map<String, Object> lastTimeEnd = tmstruckTimeTaskResultMapper.getLastTimeEnd(totalId);
            Date EndTime = (Date) lastTimeEnd.get("resultTime");
            long dueTime=EndTime.getTime()-startTime.getTime();
            tmstruckTimeTaskResult.setTimeTaskResultId(tmstruckTimeTaskResult.getTimeTaskResultId());
            tmstruckTimeTaskResult.setResultValue(new BigDecimal((dueTime/(1000*60))));
            tmstruckTimeTaskResult.setUpdateTime(new Date());
            tmstruckTimeTaskResult.setUpdateUsername(personnelSsoId);
            i+=tmstruckTimeTaskResultMapper.updateByPrimaryKeySelective(tmstruckTimeTaskResult);

        }

        return i;
    }
   //判断计时订单结束后推单
    @Override
    public int pushOrderForPause(Map<String, Object> map) {
         int i=0;
         //关闭内转订单
         map.put("orderStatus", 2);
         i = utilsMapper.updateOrderStatusByOrderIdOrNum(map);
         BigDecimal orderId1 = DataChange.dataToBigDecimal(map.get("orderId"));
         map= tmstruckTimeTaskResultMapper.selectInwardDueTimeByOrderId(orderId1);
        //根据运输订单id查找需求日期是否超过一个月
        if(map != null) {
            Date dueDate = (Date) map.get("dueTime");
            //当前时间小于截至日期
            long DueTime = dueDate.getTime() + 86400000;
            //获取当前时间
            Date date = new Date();
            long nowTime = date.getTime();
            if (nowTime < DueTime) {
                //推送
                 omsFeign.addNewTransportOrder(orderId1);
            }

        }
        return i;
    }

    /**
     * 司机申请结束
     * @param map
     * @return
     */
    @Override
    public int applyEndTime(Map<String, Object> map) {
        //设置时间类型 2
        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map);
        return tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
    }

    /**
     * 用车单位确认结束
     * @param map
     * @return
     */
    @Override
    public int unitSureEndTime(Map<String, Object> map) {
        //设置时间类型 3
        TmstruckTimeTaskResult tmstruckTimeTaskResult = generateTimeTaskResult(map);
        //查询当前车辆排队开始时间 计算出总时长
        Map<String, Object> startTimeMap = tmstruckTimeTaskResultMapper.getStartTime(tmstruckTimeTaskResult.getResultTotalId());
        Date endTime = new Date();
        //计算当前时间与确认开始时间相差的毫秒数（时间戳）
        Date startTime = (Date) startTimeMap.get("resultTime");
        long allTime = endTime.getTime() - startTime.getTime();
        //查询所有确认暂停结束的时长时间戳
        List<Map<String, Object>> allTimeout = tmstruckTimeTaskResultMapper.getAllTimeout(tmstruckTimeTaskResult.getResultTotalId());
        long allTimeoutTime = 0;
        //计算所有暂停时间时长时间戳总和
        for (Map<String, Object> timeoutMap : allTimeout) {
            BigDecimal resultTime = DataChange.dataToBigDecimal(timeoutMap.get("resultValue"));
            allTimeoutTime += resultTime.longValue();
        }
        long realTime = allTime - allTimeoutTime;
        //计算总工作时长（分钟）
        realTime = realTime / (1000 * 60);
        tmstruckTimeTaskResult.setResultValue(new BigDecimal(realTime));
        return tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
    }


    /**
     * 查询计时作业
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getAllTimeTaskResult(Map<String, Object> map) {
        return tmstruckTimeTaskResultMapper.getAllTimeTaskResult(map);
    }

    /**
     * 添加计时作业实绩
     * @param map
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int addTimeTaskResult(Map<String, Object> map) throws Exception {
        //判断是否是计时开始还是计时结束
        int i=0;
        BigDecimal inwardType =DataChange.dataToBigDecimal(map.get("inwardTypes")) ;
        String orderNumber = (String) map.get("orderNumber");
        String personnelSsoId = (String) map.get("personnelSsoId");
        BigDecimal resultTotalId = utilsMapper.getTotalIdByOrderNumber(orderNumber);
        TmstruckTimeTaskResult tmstruckTimeTaskResult = new TmstruckTimeTaskResult();
        BigDecimal orderId = utilsMapper.getOrderIdByOrderNumber(orderNumber);
        map.put("orderId", orderId);
        //根据运输订单id查找实绩中是否已经含有计时结束的实绩，如果有则抛出异常
        int countEndTimeNum = tmstruckTimeTaskResultMapper.CountTimeTaskByOrderId(orderId);
        if (countEndTimeNum >= 1) {
            throw new Exception("请勿重复计时");
        }
        tmstruckTimeTaskResult.setTimeTaskResultId(tmstruckTimeTaskResultMapper.selectMaxId());
        tmstruckTimeTaskResult.setResultTotalId(DataChange.dataToBigDecimal(resultTotalId));
        //获取计时开始的订单类型
        tmstruckTimeTaskResult.setResultTimeType(inwardType);
        tmstruckTimeTaskResult.setResultTime(new Date());
        tmstruckTimeTaskResult.setInsertTime(new Date());
        if (personnelSsoId!=null) {
            tmstruckTimeTaskResult.setInsertUsername(personnelSsoId);
        }
        //新增第一条计时实绩
        i += tmstruckTimeTaskResultMapper.insertSelective(tmstruckTimeTaskResult);
        if(inwardType.intValue() == 3){
            //获取最新暂停结束确认时间
            Map<String, Object> map2 = new HashMap<>();
            map2.put("type", 7);
            map2.put("orderId", orderId);
            BigDecimal resultPauseTime = utilsMapper.TimeTaskPause(map2);
            if(resultPauseTime != null) {
                Map<String, Object> timeMaps = utilsMapper.FristTimeTask(map);
                Date resultTime2 = (Date) timeMaps.get("resultTime");
                Map<String, Object> timeStatus = utilsMapper.getTimeStatus(map);
                Date resultTime1 = (Date) timeStatus.get("resultTime");
                long dateTime1 = resultTime2.getTime() - resultTime1.getTime();
                BigDecimal dateTime3 = new BigDecimal(dateTime1 / (1000 * 60));
                int Time1 = dateTime3.intValue() - resultPauseTime.intValue();
                tmstruckTimeTaskResult.setTimeTaskResultId(tmstruckTimeTaskResult.getTimeTaskResultId());
                tmstruckTimeTaskResult.setResultValue(new BigDecimal((Time1)));
                tmstruckTimeTaskResult.setResultUomId(new BigDecimal(900));
                if (personnelSsoId != null) {
                    tmstruckTimeTaskResult.setUpdateUsername(personnelSsoId);
                }
                i += tmstruckTimeTaskResultMapper.updateByPrimaryKeySelective(tmstruckTimeTaskResult);
               } else {
                Map<String, Object> timeMaps = utilsMapper.FristTimeTask(map);
                Date resultTime2 = (Date) timeMaps.get("resultTime");
                Map<String, Object> timeStatus = utilsMapper.getTimeStatus(map);
                Date resultTime1 = (Date) timeStatus.get("resultTime");
                long dateTime1 = resultTime2.getTime() - resultTime1.getTime();
                BigDecimal dateTime3 = new BigDecimal(dateTime1 / (1000 * 60));
                tmstruckTimeTaskResult.setTimeTaskResultId(tmstruckTimeTaskResult.getTimeTaskResultId());
                tmstruckTimeTaskResult.setResultValue(dateTime3);
                tmstruckTimeTaskResult.setResultUomId(new BigDecimal(900));
                if (personnelSsoId != null) {
                    tmstruckTimeTaskResult.setUpdateUsername(personnelSsoId);
                }
                i += tmstruckTimeTaskResultMapper.updateByPrimaryKeySelective(tmstruckTimeTaskResult);
            }
            Map<String, Object> orderMes = utilsMapper.getOrderTypeByOrderNumber(orderNumber);
            BigDecimal orderType =DataChange.dataToBigDecimal(orderMes.get("orderType"));
            if (orderType.intValue()==21) {
                pushOrderForPause(map);
            }
         }
            return i;
        }

   //通过运输订单号判断计时是否开始
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int JudgeTimeTask(Map<String, Object> mapValue) throws Exception {
        String orderNumber =(String)mapValue.get("orderNumber");
        BigDecimal orderId = utilsMapper.getOrderIdByOrderNumber(orderNumber);
        //通过运输订单号查找当前是第几次
        BigDecimal inwardType = utilsMapper.getInwardType(orderId);
        if (inwardType!=null){
            throw new Exception("计时已经开始");
        }
        return inwardType.intValue();
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public int JudgeTimeTaskPause(Map<String, Object> mapValue) throws Exception {
        String orderNumber =(String)mapValue.get("orderNumber");
        int i=0;
        BigDecimal orderId = utilsMapper.getOrderIdByOrderNumber(orderNumber);
        //通过运输订单号查找当前是第几次
        BigDecimal inwardStartTime = utilsMapper.getInwardStartTime(orderId);
//        System.out.println(inwardStartTime);
        BigDecimal inwardEndTime = utilsMapper.getInwardEndTime(orderId);
//        System.out.println(inwardEndTime);
        int Time=inwardEndTime.intValue()-inwardStartTime.intValue();
//        System.out.println(Time);
       if (Time==0) {
           i=0;
       }else if (Time==-1){
           i=1;
       }else {
           i=3;
       }
        return i;
    }
}