实时监控全部显示当前的传感器波形图；报警列表5s请求一次；session失效重新登录

src/permission.js

import store from './store'
import NProgress from 'nprogress' // Progress 进度条
import 'nprogress/nprogress.css'// Progress 进度条样式
import { Message } from 'element-ui'
import { getCookiesName } from '@/utils/auth' // 验权
import queryInfo from '@/utils/queryInfo'
      if (store.getters.roles.length === 0) { // 判断当前用户是否已拉取完user_info信息
        // console.log(5555)
        store.dispatch('GetUserInfo').then(res => { // 拉取user_info
          const roles = [res.data.type.toString()]
          store.dispatch('GenerateRoutes', { roles }).then(() => { // 根据roles权限生成可访问的路由表
            router.addRoutes(store.getters.addRouters) // 动态添加可访问路由表
            next({ ...to, replace: true })
          })
        }).catch((err) => {
          store.dispatch('FedLogOut').then(() => {
            Message.error(err || '登录状态失效，请重新登录')
            next({ path: '/' })
          })
          if (res.success) {
            const roles = [res.data.type.toString()]
            store.dispatch('GenerateRoutes', { roles }).then(() => { // 根据roles权限生成可访问的路由表
              router.addRoutes(store.getters.addRouters) // 动态添加可访问路由表
              next({ ...to, replace: true })
            })
          }
        })
      } else {
        // console.log(4444)

src/utils/index.js

    return result
  }
}
export function isEqualArr(arr1, arr2) {
  if (!arr1 || !arr2) {
    return false
  }
  if (arr1.length !== arr2.length) {
    return false
  }
  for (var i = 0; i < arr1.length; i++) {
    if (arr1[i] instanceof Array && arr2[i] instanceof Array) {
      if (!isEqualArr(arr1[i], arr2[i])) {
        return false
      } else if (arr1[i] !== arr2[i]) {
        return false
      }
    }
  }
  return true
}

src/utils/request.js

import axios from 'axios'
import qs from 'qs'
import { comUrl } from '@/utils/index'
import { Message } from 'element-ui'
import router from '@/router'
import store from '@/store'
// 创建axios实例
const service = axios.create({
    }
    if (!(data instanceof Object)) {
      // 判断data不是Object时，解析成Object
      // data = JSON.parse(data)
      data = JSON.parse(data)
    }
    if (!response.data.success && response.data.code === 1) {
      store.dispatch('FedLogOut').then(() => {
        Message.error('登录状态失效，请重新登录')
        router.push({ path: '/' })
      })
    }
    return response.data
  } else {

src/utils/timingConstruct.js

    for (let i = 0; i < $data.length; ++i) {
      if ($data[i].ctime === $data[0].ctime) {
        mCache.push({
          cid: $data[i].cid,
          cid: $data[i].seq,
          cd: {
            tit: '',
            tit: $data[i].code,
            xData: [],
            seData: []
          }
      item.xData.push(parseTime(ftend, true, true))
      item.seData.push($daI.hvalue)
      item.seData.push($daI.lvalue)
      item.tit = $daI.cid
    } else {
      item.xData.push(parseTime(ftbegin, true, true))
      item.xData.push(parseTime(ftend, true, true))

src/views/bridgesConsole/bridgeDetail/components/BInfoDialog03.vue

  data() {
    return {
      dialogW: this.$parent.dialogW,
      deviceList: this.$parent.deviceList,
      deviceList: [],
      dialogTableVisible: false,
      pageSize: 4,
      pageNo: 1

src/views/bridgesConsole/bridgeDetail/index.vue

import queryInfo from '@/utils/queryInfo'
import queryDict from '@/utils/queryDict'
import monModel from '@/utils/timingConstruct'
import { urlParse, parseTime } from '@/utils'
import { urlParse, parseTime, isEqualArr } from '@/utils'
import { getDangerList, getSysTime, getMonitorByTime } from '@/api/bridgeInfo'
import lineChart from '../lineChart/LineChart'
      cableMain: {},
      addr: {},
      dangerList: '',
      dangerAidArr: [],
      first_Dan: true,
      serverSeqArr: [],
      serverList: [],
      deviceList: [],
      transducerList: [],
      currentNo: 1,
      currentSize: 4,
      maxShowLength: 300,
      monitorList: [],
      monitorCache: [],
      jishiTime: ''
      jishiTime: '',
      jishiTime2: ''
    }
  },
  computed: {
    queryInfo.qaiCb(function() {
      if (that.bridgeId) {
        that.serverSeqArr = queryInfo.queryServers(that.bridgeId, true)
        that.transducerList = queryInfo.queryTrans(that.bridgeId)
        if (that.serverSeqArr.length) {
          that.updateDataList()
          that.getDangerList()
  },
  methods: {
    updateDataList() {
      clearTimeout(this.jishiTime)
      this.jishiTime = ''
      this.sysTime = ''
      this.monitorList = []
      this.monitorCache = []
      this.getSysTime()
      var that = this
      clearTimeout(that.jishiTime)
      that.jishiTime = ''
      that.sysTime = ''
      that.monitorList = []
      that.monitorCache = []
      if (that.transducerList.length) {
        monModel.construct(that.monitorCache, that.transducerList)
      }
      that.getSysTime()
    },
    getDangerList() {
      var that = this
      var arr = this.serverSeqArr
      const param = {
        seq: arr,
        pageSize: 5,
        pageNo: 1
      }
      this.loadprogress1 = true
      if (that.first_Dan) {
        this.loadprogress1 = true
      }
      getDangerList(param).then(res => {
        var dCache = that.dangerAidArr
        var DList = []
        if (res.success && res.data.data) {
          this.loadprogress1 = false
          const dataS = res.data.data
          for (let i = 0; i < dataS.length; i++) {
            if (dataS[i].alarmTime) {
              dataS[i].alarmTime = parseTime(dataS[i].alarmTime, true)
          if (that.first_Dan) {
            that.first_Dan = false
            for (let i = 0; i < dataS.length; i++) {
              dCache.push(dataS[i].aid)
              if (dataS[i].alarmTime) {
                dataS[i].alarmTime = parseTime(dataS[i].alarmTime, true)
              }
              dataS[i].device = `${this.bridgeName}大桥${dataS[i].device}采集盒检测到异常情况`
            }
            that.dangerList = dataS
          } else {
            for (let i = 0; i < dataS.length; i++) {
              DList.push(dataS[i].aid)
              if (dataS[i].alarmTime) {
                dataS[i].alarmTime = parseTime(dataS[i].alarmTime, true)
              }
              dataS[i].device = `${this.bridgeName}大桥${dataS[i].device}采集盒检测到异常情况`
            }
            if (!isEqualArr(DList, dCache)) {
              dCache = []
              dCache = DList
              that.dangerList = dataS
            }
            dataS[i].device = `${this.bridgeName}大桥${dataS[i].device}采集盒检测到异常情况`
          }
          this.dangerList = dataS
          that.loadprogress1 = false
          if (that && !that._isDestroyed) {
            that.jishiTime2 = setTimeout(function() {
              if (that && !that._isDestroyed) {
                that.getDangerList(param)
              }
            }, 5000)
          } else {
            that.jishiTime2 = ''
          }
        } else {
          that.loadprogress1 = false
        }
      })
    },
      var that = this
      var arr = this.serverSeqArr
      getSysTime({ seq: arr }).then(res => {
        if (res.success && res.data && res.data.length > 0) {
          const nowt = parseTime(res.data[0].ctime, true, true)
          that.sysTime = (new Date(nowt)).getTime() + that.eastEightDistrict - 2 * 1000
          const localTime = new Date().getTime() + that.eastEightDistrict
          that.localTimeiv = localTime - that.sysTime
          that.first_Q = true
          that.getTimingMonitor()
        } else {
          that.loadprogress2 = false
        if (res.success) {
          if (res.data && res.data.length > 0) {
            const nowt = parseTime(res.data[0].ctime, true, true)
            that.sysTime = (new Date(nowt)).getTime() + that.eastEightDistrict - 2 * 1000
            that.first_Q = true
          } else {
            that.sysTime = (new Date()).getTime() + that.eastEightDistrict - 2 * 1000
            that.loadprogress2 = false
          }
          setTimeout(function() {
            const localTime = new Date().getTime() + that.eastEightDistrict
            that.localTimeiv = localTime - that.sysTime
            that.getTimingMonitor()
          }, 1)
        }
      })
    },
      var endTime = this.formatTime(this.sysTime)
      that.sysTime += 1000
      getMonitorByTime({ seq: arr, begin: startTime, end: endTime }).then(res => {
        var mCache = that.monitorCache
        var mList = []
        if (res.success && res.data) {
          if (that.first_Q) {
            that.loadprogress2 = false
            if (res.data.length) {
              that.first_Q = false
              that.loadprogress2 = false
              var ftime = res.data[0].ctime
              monModel.construct(mCache, res.data)
              var f_q_t = that.sysTime
              for (;;) {
                var ftsE = that.formatTime(f_q_t + 500)
                if (fts >= ftime) {
                  if (fts > that.sysTime) {
                    monModel.setData(mCache, res.data, fts, ftsE, null)
                    monModel.setData(that.monitorCache, res.data, fts, ftsE, null)
                  }
                }
                f_q_t += 1000
                  break
                }
              }
              for (let l = 0; l < mCache.length; ++l) {
                mList.push(mCache[l].cd)
              for (let l = 0; l < that.monitorCache.length; ++l) {
                mList.push(that.monitorCache[l].cd)
              }
            }
          } else {
            var xtime = that.formatTime(that.sysTime)
            var xtimeE = that.formatTime(that.sysTime + 500)
            monModel.setData(mCache, res.data, xtime, xtimeE, that.maxShowLength)
            for (let l = 0; l < mCache.length; ++l) {
              mList.push(mCache[l].cd)
            monModel.setData(that.monitorCache, res.data, xtime, xtimeE, that.maxShowLength)
            for (let l = 0; l < that.monitorCache.length; ++l) {
              mList.push(that.monitorCache[l].cd)
            }
          }
          that.monitorList = mList
  },
  beforeDestroy() {
    this.$once('hook:beforeDestroy', () => {
      clearInterval(this.jishiTime)
      clearTimeout(this.jishiTime)
      clearTimeout(this.jishiTime2)
    })
  }
}