DAL-QMS-API/src/main/java/com/steerinfo/dil/service/impl/QmsQueueResultServiceImpl.java

package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.controller.QmsQueueResultController;
import com.steerinfo.dil.feign.AmsFeign;
import com.steerinfo.dil.feign.IMFeign;
import com.steerinfo.dil.feign.LargeScreenFeign;
import com.steerinfo.dil.mapper.QmsQueueListMapper;
import com.steerinfo.dil.mapper.QueueInterfaceMapper;
import com.steerinfo.dil.mapper.QueuingRulesMapper;
import com.steerinfo.dil.model.QmsQueueList;
import com.steerinfo.dil.util.DataChange;
import com.steerinfo.dil.model.QmsQueueResult;
import com.steerinfo.dil.mapper.QmsQueueResultMapper;
import com.steerinfo.dil.service.IQmsQueueResultService;
import com.steerinfo.dil.util.ElectronicFenceUtils;
import com.steerinfo.framework.controller.RESTfulResult;
import oracle.sql.DATE;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

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

import static sun.security.krb5.Confounder.intValue;

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

    @Autowired
    private QmsQueueResultMapper qmsQueueResultMapper;

    @Autowired
    private QmsQueueListMapper qmsQueueListMapper;

    @Autowired
    QueueInterfaceServiceImpl queueInterfaceService;


    @Autowired
    private QmsQueueGridServiceImpl qmsQueueGridService;

    @Autowired
    private QueuingRulesMapper queuingRulesMapper;

    @Autowired
    private IMFeign imFeign;

    @Autowired
    AmsFeign amsFeign;

    @Autowired
    private QueueInterfaceMapper queueInterfaceMapper;

    private String lonlat = "107.4628199,31.1925279"; //中心点坐标
    private String radius = "15000"; //半径
    private String lat1 = "31.1925279";
    private String lng1 = "107.4628199";

    /**
     * 取消订阅方法
     */
    public void cancelSub(String capacityNumber){
        Map<String, Object> map = new HashMap<>();
        map.put("capacityNumber", capacityNumber.split("_")[0] + "_2");
        int j = queueInterfaceService.cancelSubsCapacity(map, 0);
        if(j == -1){
            System.out.println("取消订阅失败");
        }else if(j == -2){
            System.out.println("超过递归次数，取消订阅失败");
        }else if(j == 1){
            //修改订阅表 表示已取消订阅
            queueInterfaceMapper.cancelSubCapacity(capacityNumber.split("_")[0]);
        }
    }

    /**
     * 特殊情况 查询是否订阅过 如订阅过则需要取消订阅
     */
    public void judgeCancelSub(String capacityNumber){
        //查询订阅表是否已经订阅过如订阅过则取消订阅
        Integer subCapacityId = queueInterfaceMapper.getSubCapacity(capacityNumber.split("_")[0]);
        if(subCapacityId != null){
            cancelSub(capacityNumber);
        }
    }

    /**
     * 新增进厂排队实绩
     * @param  capacityNumber 车牌号
     * @return
     */
    @Override
    public int addQueueResult(String capacityNumber, String isPDA) {
        //获取传入的车牌号查找最近的运输订单号
        Map<String, Object> mesMap = queuingRulesMapper.getOrderNumberByCapacityNumber(capacityNumber.split("_")[0]);
        if(queuingRulesMapper.findStatus(mesMap)!=4){
            return -4;//未审批的订单，不允许排队
        }
        if(mesMap == null){
            judgeCancelSub(capacityNumber); //判断是否需要取消订阅
            return -1;
        }else{
            if(DataChange.dataToBigDecimal(mesMap.get("orderType")).intValue() != 1 && DataChange.dataToBigDecimal(mesMap.get("orderType")).intValue() != 4){
                judgeCancelSub(capacityNumber); //判断是否需要取消订阅
                return -3; //非钢材订单不添加排队
            }
            String insertUpdateRemark = String.valueOf(mesMap.get("insertUpdateRemark"));
            if("电子围栏订阅成功".equals(insertUpdateRemark)){
                //如果是电子围栏调用,并且订阅成功了，则取消订阅
                cancelSub(capacityNumber);
            }
        }
        Integer resultId = queuingRulesMapper.checkoutQQR(mesMap.get("resultTotalId"));
        if(resultId != null){ //预防重复新增排队
            return -2;
        }
        QmsQueueResult qmsQueueResult = new QmsQueueResult();
        qmsQueueResult.setId(qmsQueueResultMapper.selectMaxId());
        qmsQueueResult.setResultTotalId(DataChange.dataToBigDecimal(mesMap.get("resultTotalId")));
        int materialNum = DataChange.dataToBigDecimal(mesMap.get("materialNum")).intValue();
        BigDecimal grid;
        if(materialNum == 1){
            BigDecimal orderId = DataChange.dataToBigDecimal(mesMap.get("orderId"));
            //单拼添加仓储网格ID 、 通过物资Id查询网格ID
            grid = qmsQueueResultMapper.getGridIdByOrderId(orderId);
            if(grid == null){
                //新增一个仓储网格实绩   通过订单查询物资ID
                Integer materialId = qmsQueueResultMapper.getMaterialIdByOrderId(orderId);
                grid = qmsQueueGridService.addQQR(materialId);
            }
            qmsQueueResult.setGridId(grid);
            qmsQueueResult.setIsSpelling(new BigDecimal(0));
        }else {
            qmsQueueResult.setGridId(new BigDecimal(materialNum));
            qmsQueueResult.setIsSpelling(new BigDecimal(1));
        }
        //添加排队实绩表
        qmsQueueResult.setResultApplyforTime(new Date());
        //系统自动下发 添加下发时间
        qmsQueueResult.setResultDownTime(new Date());
        qmsQueueResult.setCapacityId(DataChange.dataToBigDecimal(mesMap.get("capacityId")));
        qmsQueueResult.setResultTotalId(DataChange.dataToBigDecimal(mesMap.get("resultTotalId")));
        qmsQueueResult.setInsertTime(new Date());
        qmsQueueResult.setInsertUsername("admin");
        return qmsQueueResultMapper.insertSelective(qmsQueueResult);
    }

    /**
     * 司机通过订单ID查询当前订单的排队实绩
     * @param resultTotalId
     * @return
     */
    public Map<String, Object> getQueueResultByTotalId(String resultTotalId){
        Map<String,Object> map = qmsQueueResultMapper.getQueueResultByOrderId(new BigDecimal(resultTotalId));
        if(map == null){
            return new HashMap<>();
        }
        //是否拼装
        int isSpelling = DataChange.dataToBigDecimal(map.get("isSpelling")).intValue();
        if(map.get("resultEndTime") != null){      //司机已排队结束
            //计算排队时长
            Date startTime = (Date) map.get("resultStartTime");
            Date endTime = (Date) map.get("resultEndTime");
            long differentTime = (endTime.getTime() - startTime.getTime()) / 60000;
            map.put("differentTime", differentTime + " 分钟");
            map.put("status", 3);
        }else if(map.get("resultStartTime") != null){
            //排队开始
            Integer num;
            Date startTime = (Date) map.get("resultStartTime");
            long differentTime = (System.currentTimeMillis() - startTime.getTime()) / 60000;
            map.put("differentTime", differentTime + " 分钟");
            if(isSpelling == 0){
                num = qmsQueueListMapper.getListSequenceNumber(map); //当前队列排队人数
            }else {
                num = qmsQueueListMapper.getSpellingSequenceNumber(map); //当前多拼队列排队人数
            }
            //获取是否已审批或者未轧/已轧
            try{
                //根据实绩主键去查询出运单主键
                Integer orderId = qmsQueueListMapper.getOrderId(resultTotalId);
                Map<String, Object> steelOrderMessageToApp = qmsQueueListMapper.getSteelOrderMessageToApp(orderId);
                String capacityMessage = (String) steelOrderMessageToApp.get("capacityMessage");
                map.put("orderSeqNum", num+capacityMessage);
            }catch (Exception e){
                e.printStackTrace();
            }
            map.put("status", 2);
        }else {
            //还未排队
            Integer num;
            if(isSpelling == 0){
                num = qmsQueueListMapper.getListGridNumber(map); //当前单拼网格排队人数
            }else {
                num = qmsQueueListMapper.getSpellingGridNumber(map); //当前多拼网格排队人数
            }
            map.put("gridSeqNum", num);
            map.put("status", 1);
        }
        return map;
    }

    /**
     * 查询排队申请
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getQueueApply(Map<String, Object> map) {
        return qmsQueueResultMapper.getQueueApply(map);
    }


    /**
     * 查询排队开始 数据
     * 可用 gridId 网格ID
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getQueueListByQueueUp(Map<String, Object> map) {
        return qmsQueueResultMapper.getQueueListByQueueUp(map);
    }

    public List<Map<String, Object>> getQueueListByQueueUpSpelling(Map<String, Object> map) {
        return  qmsQueueResultMapper.getQueueListByQueueUpSpelling(map);
    }

    /**
     * @author:zyf
     * @version:1.0
     * @Date:2022-09-27
     * @Description:查询出来所有的数据
    */
    public Map<String,Object> getnumber(){
        Map<String,Object> map=new HashMap<>();
        try{
            //查询出销售钢材的派车数
            //1.先把时间状态改为时分秒清零的状态
            Date now=new Date();
            Calendar call=Calendar.getInstance();
            call.setTime(now);
            call.set(Calendar.HOUR_OF_DAY,0);
            call.set(Calendar.MINUTE,0);
            call.set(Calendar.SECOND,0);
            call.set(Calendar.MILLISECOND,0);
            Date date=call.getTime();
            Map<String,Object> map1=new HashMap<>();
            map1.put("oneDate",date);
            map1.put("entity",date);
            RESTfulResult haveCarTruckNoList = amsFeign.getHaveCarTruckNoList(map1, 466, null, null, null, null, null);
            Map<String,Object> data = (Map<String, Object>) haveCarTruckNoList.getData();
            List<Map<String,Object>> data1 = (List<Map<String, Object>>) data.get("list");
            int SentCarNumber=0;
            try {
                for (int i=0;i<data1.size();i++){
                    for (int j=i+1;j<data1.size();j++){
                        if (data1.get(i).get("capacityNumber").equals(data1.get(j).get("capacityNumber"))){
                            data1.remove(j);
                            j--;
                        }
                    }
                }
                SentCarNumber=data1.size();
            }catch (Exception e){
                e.printStackTrace();
            }
            //int SentCarNumber = qmsQueueResultMapper.querySentCarNumber();
            //int IntoFactoryNumber=qmsQueueResultMapper.queryIntoFactoryNumber();
            //查询出销售钢材的进厂数(由于呼叫进厂页面的数据不止)
            int IntoFactoryNumber = qmsQueueResultMapper.getSteelOrderNum();
            //查询出销售钢材的出厂数
            //先把时间格式化
            SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String format = simpleDateFormat.format(date);
            Map<String,Object> map2=new HashMap<>();
            map2.put("oneDate",format);
            List<Map<String, Object>> capacityByDefend = qmsQueueResultMapper.getCapacityByDefend(map2);
            int LeaveFactoryNumber = capacityByDefend.size();
            //int LeaveFactoryNumber=qmsQueueResultMapper.queryLeaveFactoryNumber();
            map.put("sentCarNumber",SentCarNumber);
            map.put("intoFactoryNumber",IntoFactoryNumber);
            map.put("leaveFactoryNumber",LeaveFactoryNumber);
            map.put("waitIntoFactoryNumber",SentCarNumber-IntoFactoryNumber-LeaveFactoryNumber);
        }catch (Exception e){
            e.printStackTrace();
        }
        return map;
    }


    /**
     * 查询排队取消数据
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getQueueCancel(Map<String, Object> map) {
        return qmsQueueResultMapper.getQueueCancel(map);
    }

    /**
     * 查询排队结束
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getQueueEndResult(Map<String, Object> map) {
        return qmsQueueResultMapper.getQueueEndResult(map);
    }


    @Override
    public boolean isInCircle(String longitude, String latitude,String CapacityNo) {
        boolean s =  ElectronicFenceUtils.isInRange(15000,new BigDecimal(latitude),new BigDecimal(longitude),new BigDecimal(lat1),new BigDecimal(lng1));
        if(s){
            int i = addQueueResult(CapacityNo,"否");
            System.out.println(i);
        }
        return s;
    }
    @Override
    public List<Map<String, Object>> getStoreQueueList(){
        return qmsQueueResultMapper.getStoreQueueList();
    }
    /**
     * 新增仓库排队实绩
     * @param map orderNumber运输订单号  loadingId 装车点
     * @return
     */
//    public int addQueueResultByCk(Map<String, Object> map){
//        QmsQueueResult qmsQueueResult = new QmsQueueResult();
//        //生成主键
//        qmsQueueResult.setId(qmsQueueResultMapper.selectMaxId());
//        //获取添加网格Id
//        map.put("queueLocationId", map.get("loadingId"));
//        map.put("gridType", 1);
//        BigDecimal gridId = queuingRulesService.getGridIdByGatepostIdAndGridType(map);
//        qmsQueueResult.setGridId(gridId);
//        //通过运输订单号查询实绩ID 等数据
//        map.putAll(qmsQueueResultMapper.queryCIdAndTIdByOrderNumber((String) map.get("orderNumber")));
//        qmsQueueResult.setResultApplyforTime(new Date());
//        //系统自动下发 添加下发时间
//        qmsQueueResult.setResultDownTime(new Date());
//        //添加运力ID和总实绩ID
//        qmsQueueResult.setCapacityId(DataChange.dataToBigDecimal(map.get("capacityId")));
//        qmsQueueResult.setResultTotalId(DataChange.dataToBigDecimal(map.get("resultTotalId")));
//        qmsQueueResult.setInsertTime(new Date());
//        qmsQueueResult.setInsertUsername("admin");
//        pushCKMesToWebSocket(DataChange.dataToBigDecimal(map.get("orderId")).intValue(), gridId.intValue());
//        return qmsQueueResultMapper.insertSelective(qmsQueueResult);
//    }

    /**
     * 推送仓库排队消息到websocket
     */
//    public void pushCKMesToWebSocket(Integer orderId, Integer gridId){
//        //通过运输订单ID查询推送给司机的数据
//        Map<String, Object> mesMap = qmsQueueResultMapper.sendWarehouseMesToWebSocket(orderId);
//        mesMap.putAll(qmsQueueResultMapper.queryWarehouseNameByPlatformId(gridId));
//        HashMap<String, Object> sendMap = new HashMap<>();
//        sendMap.put("messageType", 2);
//        sendMap.put("receivePerson", mesMap.get("capacityNumber"));
//        sendMap.put("sendPerson", "system");
//        sendMap.put("messageContent", mesMap);
//        sendMap.put("createTime", new Date());
//        ArrayList<Object> list = new ArrayList<>();
//        list.add(sendMap);
//        HashMap<Object, Object> map = new HashMap<>();
//        map.put("messages", list);
//        //调用websocket接口
//        String s = imFeign.sendToUser(map);
//        System.out.println(s);
//    }

    /**
     * 查看排队转移界面
     * @param map
     * @return
     */
//    @Override
//    public List<Map<String, Object>> getChangeQueueMes(Map<String, Object> map) {
//        return qmsQueueResultMapper.getChangeQueueMes(map);
//    }


    /**
     * 查询执行中运单
     * @param map
     * @return
     */
//    @Override
//    public List<Map<String, Object>> getAllExecutionOrder(Map<String, Object> map) {
//        return qmsQueueResultMapper.getAllExecutionOrder(map);
//    }

    /**
     * 查询指令接收 判断条件：是否有排队结束时间
     * @param map
     * @return
     */
//    @Override
//    public List<Map<String, Object>> orderReceive(Map<String, Object> map) {
//        Integer queueType = (Integer) map.get("queueType");
//        List<Map<String, Object>> orderReceiveList = null;
//        switch (queueType){
//            case 1: //进厂
//                orderReceiveList = qmsQueueResultMapper.getOrderReceive(map);
//                break;
//            case 2: //仓库
//                orderReceiveList = qmsQueueResultMapper.getWarehouseOrderReceive(map);
//        }
//        //遍历数据 通过是否有接收时间 来判断是否接收
//        for (Map<String, Object> orderReceiveMap : orderReceiveList) {
//            if(orderReceiveMap.get("resultAcceptTime") != null){
//                orderReceiveMap.put("isReceive", "是");
//            }else {
//                orderReceiveMap.put("isReceive", "否");
//            }
//        }
//        return orderReceiveList;
//    }


    /**
     * 查询排队详情
     * @param map
     * @return
     */
//    @Override
//    public List<Map<String, Object>> getQueueMes(Map<String, Object> map) {
//        return qmsQueueResultMapper.getQueueMes(map);
//    }


    /**
     * 通过实绩ID查询排队取消信息
     * @param resultId
     * @return
     */
//    @Override
//    public List<Map<String, Object>> getQueueCancelByResultId(Integer resultId) {
//        return qmsQueueResultMapper.getQueueCancelByResultId(resultId);
//    }

    /**
     * 修改排队取消实绩
     * @param qmsQueueResult
     * @return
     */
//    @Override
//    public int updateQueueCancel(QmsQueueResult qmsQueueResult) {
//        qmsQueueResult.setUpdateTime(new Date());
//        qmsQueueResult.setUpdateUsername("admin");
//        return qmsQueueResultMapper.updateByPrimaryKeySelective(qmsQueueResult);
//    }

    /**
     * 查询排队插队
     * @return
     */
//    @Override
//    public List<Map<String, Object>> getQueueInsert(Map<String, Object> map) {
//        return qmsQueueResultMapper.getQueueInsert(map);
//    }



    /**
     * 汽车监控
     * @param map
     * @return
     */
//    @Override
//    public List<Map<String, Object>> capacityMonitor(Map<String, Object> map) {
//        List<Map<String, Object>> list = qmsQueueResultMapper.capacityMonitor(map);
//        for (Map<String, Object> capacityMap : list) {
//            //如果结束时间为空 排队总时长为
//            if(capacityMap.get("resultEndTime") == null){
//                Date date1 = (Date) capacityMap.get("resultStartTime");
//                Date date2;
//                if(capacityMap.get("resultCancelTime") != null){ //如果取消排队了则以取消排队时间为结束时间
//                    date2 = (Date) capacityMap.get("resultCancelTime");
//                }else {
//                    date2 = new Date();
//                }
//                long differenceTime = (date2.getTime() - date1.getTime()) / 60000;
//                capacityMap.put("resultQueueAllTime", differenceTime + "min");
//            }else {
//                //否则排队时长为结束时长 - 申请时长
//                Date date1 = (Date)capacityMap.get("resultStartTime");
//                Date date2 = (Date)capacityMap.get("resultEndTime");
//                long differenceTime = (date2.getTime() - date1.getTime()) / 60000;
//                capacityMap.put("resultQueueAllTime",differenceTime + "min");
//            }
//        }
//        return list;
//    }

    //=========================================仓库排队===========================================

    /**
     * 查看仓库排队申请
     * @param map
     * @return
     */
//    @Override
//    public List<Map<String, Object>> getWarehouseQueueApply(Map<String, Object> map) {
//        return qmsQueueResultMapper.getWarehouseQueueApply(map);
//    }

    /**
     * 查看排队开始
     * @param map
     * @return
     */
//    @Override
//    public List<Map<String, Object>> getWarehouseQueueListByQueueUp(Map<String, Object> map) {
//        return qmsQueueResultMapper.getWarehouseQueueListByQueueUp(map);
//    }

    /**
     * 查看仓库排队详情 通过运输订单号查询仓库
     * @param map
     * @return
     */
//    @Override
//    public List<Map<String, Object>> getWarehouseQueueMes(Map<String, Object> map) {
//        return qmsQueueResultMapper.getWarehouseQueueMes(map);
//    }

    /**
     * 查询仓库排队转移详情
     * @param map
     * @return
     */
//    @Override
//    public List<Map<String, Object>> getWarehouseQueueChange(Map<String, Object> map) {
//        return qmsQueueResultMapper.getWarehouseQueueChange(map);
//    }

    /**
     * 查询仓库排队结束
     * @param map
     * @return
     */
//    @Override
//    public List<Map<String, Object>> getWarehouseQueueEndMes(Map<String, Object> map) {
//        return qmsQueueResultMapper.getWarehouseQueueEndMes(map);
//    }

    //********************************APP*********************************************

    /**
     * 根据车牌号查询排队下发
     * @param capacityNumber
     * @return
     */
//    @Override
//    public List<Map<String, Object>> getOrderReceive2(String capacityNumber) {
//        BigDecimal gridId = getGridId(capacityNumber);
//        if (gridId == null) {
//            List<Map<String,Object>> mapList = new ArrayList<>();
//            return mapList;
//        }
//        Map<String,Object> map = new HashMap<>();
//        map.put("capacityNumber",capacityNumber);
//        map.put("gridId",gridId);
//        List<Map<String, Object>> orderReceive = qmsQueueResultMapper.getOrderReceive2(map);
//        return orderReceive;
//    }

    /**
     * 排队取消
     * @param mapValue
     * @return
     */
//    @Override
//    public int cancelQueue(Map<String,Object> mapValue) {
//        String capacityNumber = (String) mapValue.get("capacityNumber");
//        String resultCancelReason = (String) mapValue.get("resultCancelReason");
//        BigDecimal resultId = qmsQueueResultMapper.getResultIdByCapacityId(capacityNumber);
//        QmsQueueResult qmsQueueResult = qmsQueueResultMapper.selectByPrimaryKey(resultId);
//        Map<String, Object> listIdMap = qmsQueueResultMapper.getListIdByResultId(resultId);
//        BigDecimal listId = (BigDecimal) listIdMap.get("listId");
//        QmsQueueList qmsQueueList = qmsQueueListMapper.selectByPrimaryKey(listId);
//        qmsQueueResult.setResultCancelTime(new Date());
//        qmsQueueResult.setResultCancelReason(resultCancelReason);
//        qmsQueueListMapper.updateByPrimaryKeySelective(qmsQueueList);
//        return qmsQueueResultMapper.updateByPrimaryKeySelective(qmsQueueResult);
//    }


    /**
     * 通过车牌号得到网格id
     * @param capacityNumber
     * @return
     */
//    @Override
//    public BigDecimal getGridId(String capacityNumber) {
//        return qmsQueueResultMapper.getGridIdNotNull(capacityNumber);
//    }


    /**
     * 查询各门岗和仓库的排队状态
     * @return
     */
//    @Override
//    public List<Map<String, Object>> getQueueStatusList() {
//        return qmsQueueResultMapper.getQueueStatusList();
//    }
//

}