slble-attend/sl.ble_sys-attend/src-js/global/index.js

/* *********************************************************** */
// 创建: Macheng 2019/08/29.
// 修改: Macheng 2019/08/29
// Description:
// 该文件定义了全局单例的vGlobal类。用于保存所有参数和数据的容器。
/* *********************************************************** */


import Project from '../model/project'
import Anchor from '../model/anchor'
import Tag from '../model/tag'
import SysCfg from '../model/sysCfg'
import Sign from '../model/sign'

// import Alarm from '../model/alarm'

// import Task from '../model/task'


// import { fetchRTAlarms } from '../api/alarm'

import { fetchProjects, deleteProject, modifyProject } from '../api/project'
import { fetchAnchors, fetchRTAncStatus, clearAnchor, batchModifyAnchors } from '../api/anchor'
import { fetchTags, fetchRTTagPos, clearTag, batchModifyTags } from '@/api/tag'
import { fetchSigns, clearSign, batchModifySigns } from '@/api/sign'
import { fetchSysCfg } from '@/api/system';

// import { fetchRTTasks } from '../api/task'
import app from '@/main'
// import { getRoles } from '../utils/auth'
// import { isString } from '../utils'

const vGlobal = {

  get isRt() {
    return vGlobal.mapEngine ? vGlobal.mapEngine.isRt : true
  },

  set isRt(val) {
    if (vGlobal.mapEngine) {
      vGlobal.mapEngine.isRt = val
    }
  },

  isInited() {
    return vGlobal._isInited
  },

  isRefreshAnchors() {
    return vGlobal._isRefreshAnchors
  },

  isRefreshProjects() {
    return vGlobal._isRefreshProjects
  },

  isRefreshSigns() {
    return vGlobal._isRefreshSigns
  },

  isRefreshTags() {
    return vGlobal._isRefreshTags
  },

  refreshTick() {
    vGlobal._tickRefresh++
    app.$store.dispatch('setTickRefresh', vGlobal._tickRefresh)
  },

  resetInit() {
    this.stepInit = 0
    this._isInited = false
  },

  getToken() {
    return this._token
  },

  setToken(tk) {
    this._token = tk
  }
}

vGlobal.SCHEDULE_INTERVAL = 5000

vGlobal.ancCmdReply = {
  optReply: '',
  optStatus: 'statusReady',
  uploadFlag: false,
  updateFlag: false
}

vGlobal.ancDLReply = {
  dlFlag: false
}

// 容器相关
vGlobal.gAltases = {} // 场景地图字典
vGlobal.gAnchors = {} // 基站
vGlobal.gTags = {} // 标签字典
vGlobal.vecAlarm = [] // 实时报警列表
vGlobal.vecAnchor = [] // 基站列表
vGlobal.vecProject = [] // 项目列表
vGlobal.vecSign = [] // 标记列表
vGlobal.vecTag = [] // 标签列表
vGlobal.vecTask = [] // 实时任务

// 地图引擎
vGlobal.mapEngine = null

// 索引相关
vGlobal.maxTagIndex = 0
vGlobal.maxAnchorIndex = 0
vGlobal._scheduleId = 0
vGlobal._queueSchedule = []

// 初始化相关
vGlobal._curRoute = null
vGlobal._isInited = false
vGlobal.isLogin = false
vGlobal.stepInit = 0
vGlobal._tickRefresh = 0
vGlobal._isRefreshAnchors = false
vGlobal._isRefreshProjects = false
vGlobal._isRefreshSigns = false
vGlobal._isRefreshTags = false

//
vGlobal.sysCfg = new SysCfg()


vGlobal._token = null

// Step 1 init projects
vGlobal._initProjects = function (logFunc) {
  vGlobal.stepInit = 10
  vGlobal.refreshProjects(vGlobal._initSigns, logFunc)
}

// Step 2 init signs
vGlobal._initSigns = function (logFunc) {
  vGlobal.stepInit = 20
  vGlobal.refreshSigns(vGlobal._initTags, logFunc)
}

// Step 3 init tags
vGlobal._initTags = function (logFunc) {
  vGlobal.stepInit = 30
  vGlobal.refreshTags(vGlobal._initSysCfg, logFunc)
}

vGlobal._initSysCfg = function (logFunc) {
  vGlobal.stepInit = 40
  vGlobal.refreshSysCfg(vGlobal._initAnchors, logFunc)
}

// Step 4 init anchors
vGlobal._initAnchors = function (logFunc) {
  vGlobal.stepInit = 50
  vGlobal.refreshAnchors((logFunc) => {
    vGlobal._isInited = true
    vGlobal._tickRefresh++
    vGlobal.stepInit = 70
    console.log('vGlobal isInited')

    vGlobal.schedule()
  }, logFunc)
}

vGlobal.init = function (logFunc) {
  vGlobal._isInited = false
  vGlobal.stepInit = 0

  vGlobal.gAnchors = {}
  vGlobal.gTags = {}

  vGlobal.vecAlarm.splice(0, vGlobal.vecAlarm.length)
  vGlobal.vecProject.splice(0, vGlobal.vecProject.length)
  vGlobal.vecSign.splice(0, vGlobal.vecSign.length)
  vGlobal.vecTag.splice(0, vGlobal.vecTag.length)
  vGlobal.vecTask.splice(0, vGlobal.vecTask.length)

  vGlobal._initProjects(logFunc)
  clearInterval(vGlobal._scheduleId)
  vGlobal._scheduleId = setInterval(vGlobal.schedule, vGlobal.SCHEDULE_INTERVAL)

}

vGlobal.addAnchor = function (anchor) {
  const newAnchor = new Anchor(anchor)
  if (vGlobal.gAnchors[newAnchor.addr] || newAnchor.addr <= 0) {
    return false
  }
  vGlobal.vecAnchor.push(newAnchor)
  vGlobal.gAnchors[newAnchor.addr] = newAnchor
  vGlobal.vecAnchor.sort((v1, v2) => { return v1.addr - v2.addr })
  return true
}

vGlobal.addTag = function (tag) {
  const newTag = new Tag(tag)
  if (vGlobal.gTags[newTag.addr] || newTag.addr <= 0) {
    return false
  }
  vGlobal.vecTag.push(newTag)
  vGlobal.gTags[newTag.addr] = newTag
  vGlobal.vecTag.sort((v1, v2) => { return v1.addr - v2.addr })
  return true
}

vGlobal.clearSchedule = function () {
  clearInterval(vGlobal._scheduleId)
  vGlobal._scheduleId = 0
}

vGlobal.clearAnchors = function () {
  clearAnchor({}).then(response => {
    if (response.success) {
      vGlobal.vecAnchor.splice(0, vGlobal.vecAnchor.length)
      vGlobal.gAnchors = {}
    }
  })
}

vGlobal.clearProjects = function () {
  for (const project of vGlobal.vecProject) {
    const data = {
      projId: project.id
    }
    deleteProject(data).then(response => {
      // if (response.success) {
      // }
    })
  }
  vGlobal.vecProject.splice(0, vGlobal.vecProject.length)
}


vGlobal.clearSigns = function () {
  clearSign({}).then(response => {
    if (response.success) {
      vGlobal.vecSign.splice(0, vGlobal.vecSign.length)
    }
  })
}

vGlobal.clearTags = function () {
  clearTag({}).then(response => {
    if (response.success) {
      vGlobal.vecTag.splice(0, vGlobal.vecTag.length)
      vGlobal.gTags = {}
    }
  })
}

vGlobal.clickMtTag = function (tag) {
  if (!tag) {
    app.$store.dispatch('setRtSelTag', null)
  } else {
    app.$store.dispatch('setRtSelTag', tag)
  }
}

vGlobal.clickMtTrace = function (tag) {
  vGlobal.clearMtTrace()
  if (!tag) {
    app.$store.dispatch('setRtTraceTag', null)
  } else {
    tag.isFocus = true
    app.$store.dispatch('setRtTraceTag', tag)
  }
}

vGlobal.clickMtTraceByAddr = function (tagAddr) {
  const tag = vGlobal.getTag(tagAddr)
  vGlobal.clickMtTrace(tag)
}

vGlobal.copyProjects = function () {
  const vec = []
  for (const v of vGlobal.vecProject) {
    const project = new Project(v.toJson())
    vec.push(project)
  }
  return vec
}

vGlobal.deleteProject = function (project, successFunc, failFunc) {
  if (!project) {
    return
  }
  const data = {
    projectId: project.id
  }
  deleteProject(data).then(response => {
    if (response.success) {
      for (const v of vGlobal.vecProject) {
        if (v.id === project.id) {
          vGlobal.vecProject.splice(vGlobal.vecProject.indexOf(v), 1)
          break
        }
      }
      if (successFunc) successFunc()
    } else {
      if (failFunc) failFunc()
    }
  })
}

vGlobal.getAlarmType = function (type) {
  switch (type) {
    case 1:
      return '求救报警'
    case 2:
      return '紧急报警'
    case 3:
      return '心率过速'
    case 4:
      return '位置报警'
    case 5:
      return '跌落报警'
    case 6:
      return '基站离线'
    case 7:
      return '基站失电'
    case 8:
      return '标签低电'
  }
  return '无效报警'
}

vGlobal.getAlarm = function (alarmId) {
  for (const v of vGlobal.vecAlarm) {
    if (v.id === alarmId) {
      return v
    }
  }
  return null
}

vGlobal.getAlarmAllTypes = function () {
  return ['求救报警', '紧急报警', '心率过速', '位置报警', '跌落报警', '基站离线', '基站失电', '标签低电']
}

vGlobal.getAlarmVecBySet = function (alarmSet) {
  const vec = []
  Math.floor(Math.floor(Number(alarmSet))) & (0x1 << 0) ? vec.push(1) : null  // 求救报警
  Math.floor(Math.floor(Number(alarmSet))) & (0x1 << 1) ? vec.push(2) : null  // 紧急报警
  Math.floor(Math.floor(Number(alarmSet))) & (0x1 << 2) ? vec.push(3) : null  // 心率过速
  Math.floor(Math.floor(Number(alarmSet))) & (0x1 << 3) ? vec.push(5) : null  // 位置报警
  Math.floor(Math.floor(Number(alarmSet))) & (0x1 << 4) ? vec.push(4) : null  // 跌落报警
  Math.floor(Math.floor(Number(alarmSet))) & (0x1 << 5) ? vec.push(8) : null  // 标签低电
  return vec
}

vGlobal.getAnchor = function (addr) {
  return vGlobal.gAnchors[addr]
}


vGlobal.getBatStr = function (battery) {
  if (Number(battery) < 0) {
    return 'INF'
  }
  let vL = Math.round(Number(battery) * 20)
  vL = vL > 100 ? 100 : (vL < 0 ? 0 : vL)
  return vL + '%'
}

vGlobal.getProject = function (projId) {
  for (const v of vGlobal.vecProject) {
    if (v.id === Number(projId)) {
      return v
    }
  }
  return null
}

vGlobal.getProjName = function (projId) {
  for (const p of vGlobal.vecProject) {
    if (Number(p.id) == Number(projId)) {
      return p.name;
    }
  }
  return ''
}

vGlobal.getLocName = function (projId, locId) {
  for (const p of vGlobal.vecProject) {
    if (Number(p.id) == Number(projId)) {
      for (const loc of p.locations) {
        if (Number(loc.id) == Number(locId)) {
          return loc.name;
        }
      }
    }
  }
  return ''
}

/**
 * 获取标定
 * @param signId
 * @returns {Sign}
 */
vGlobal.getSign = function (signId) {
  for (const v of vGlobal.vecSign) {
    if (v.id === signId) {
      return v
    }
  }
  return null
}

/**
 *
 * @param tagAddr
 * @returns {Tag}
 */
vGlobal.getTag = function (tagAddr) {
  return vGlobal.gTags[tagAddr]
}

vGlobal.getTask = function (taskId) {
  for (const v of vGlobal.vecTask) {
    if (v.id === taskId) {
      return v
    }
  }
  return null
}

vGlobal.applySysCfg = function (noSchedule) {
  if (document.getElementsByTagName('title')) {
    document.getElementsByTagName('title')[0].innerText = vGlobal.sysCfg.sysCfgView.webTitle
  }
  // if (app.$store.getters && app.$store.getters.navbar) {
  //   app.$store.getters.navbar.refreshLogo()
  // }
  clearInterval(vGlobal._scheduleId)
  vGlobal._scheduleId = 0
  vGlobal.SCHEDULE_INTERVAL = vGlobal.sysCfg.sysCfgView.scheduleInterval

  if (!noSchedule) {
    vGlobal._scheduleId = setInterval(vGlobal.schedule, vGlobal.SCHEDULE_INTERVAL)
  }
}


vGlobal.isAllow = function (arr) {
  const arrRole = JSON.parse(getRoles())
  for (const v of arr) {
    for (const role of arrRole) {
      if (v === role) {
        return true
      }
    }
  }
  return false
}

vGlobal.genScheduleKey = function (vue) {
  return vue.$options.name
}

vGlobal.refreshAnchors = function (successFunc, logFunc) {
  vGlobal._isRefreshAnchors = false
  vGlobal.gAnchors = {}
  vGlobal.vecAnchor.splice(0, vGlobal.vecAnchor.length)

  fetchAnchors({}).then(response => {
    if (response.success) {
      for (let j = 0; j < response.items.length; j++) {
        const anchor = new Anchor(response.items[j])
        vGlobal.vecAnchor.push(anchor)
        vGlobal.gAnchors[anchor.addr] = anchor
      }
      vGlobal.vecAnchor.sort((v1, v2) => { return v1.addr - v2.addr })
      vGlobal._isRefreshAnchors = true
      if (logFunc) {
        logFunc(0, 'refresh anchors success')
      }
      if (successFunc) {
        successFunc(logFunc)
      }
    } else {
      if (logFunc) {
        logFunc(2, 'refresh anchors error: ' + response.error)
      }
    }
  })
}

vGlobal.refreshProjects = function (successFunc, logFunc) {
  vGlobal._isRefreshProjects = false
  vGlobal.vecProject.splice(0, vGlobal.vecProject.length)
  fetchProjects({}).then(response => {
    if (response.success) {
      vGlobal.vecProject.splice(0, vGlobal.vecProject.length);
      for (let j = 0; j < response.items.length; j++) {
        const project = new Project(response.items[j])
        vGlobal.vecProject.push(project)
      }
      vGlobal.vecProject.sort((v1, v2) => { return v2.id - v1.id })
      vGlobal._isRefreshProjects = true
      if (logFunc) {
        logFunc(0, 'refresh projects success')
      }
      if (successFunc) {
        successFunc(logFunc)
      }
    } else {
      if (logFunc) {
        logFunc(2, 'refresh projects error: ' + response.error)
      }
    }
  })
}


vGlobal.refreshSigns = function (successFunc, logFunc) {
  vGlobal._isRefreshSigns = false
  vGlobal.vecSign.splice(0, vGlobal.vecSign.length)
  fetchSigns({}).then(response => {
    if (response.success) {
      for (let j = 0; j < response.items.length; j++) {
        const sign = new Sign(response.items[j])
        vGlobal.vecSign.push(sign)
      }
      vGlobal.vecSign.sort((v1, v2) => { return v1.id - v2.id })
      vGlobal._isRefreshSigns = true

      if (logFunc) {
        logFunc(0, 'refresh signs success')
      }
      if (successFunc) {
        successFunc(logFunc)
      }
    } else {
      if (logFunc) {
        logFunc(2, 'refresh signs error: ' + response.error)
      }
    }
  })
}

vGlobal.refreshTags = function (successFunc, logFunc) {
  vGlobal._isRefreshTags = false
  vGlobal.gTags = {}
  vGlobal.vecTag.splice(0, vGlobal.vecTag.length)

  fetchTags({}).then(response => {
    if (response.success) {
      for (let j = 0; j < response.items.length; j++) {
        const tag = new Tag(response.items[j])
        vGlobal.vecTag.push(tag)
        vGlobal.gTags[tag.addr] = tag
      }
      vGlobal.vecTag.sort((v1, v2) => { return v1.addr - v2.addr })
      vGlobal._isRefreshTags = true

      if (logFunc) {
        logFunc(0, 'refresh tags success')
      }
      if (successFunc) {
        successFunc(logFunc)
      }
    } else {
      if (logFunc) {
        logFunc(2, 'refresh tags error: ' + response.error)
      }
    }
  })
}

vGlobal.refreshSysCfg = function (successFunc, logFunc) {
  vGlobal._isRefreshTags = false
  
  fetchSysCfg({}).then(response => {
    if (response.success) {
      vGlobal.sysCfg.init(response.dict);
      vGlobal.applySysCfg();

      if (logFunc) {
        logFunc(0, 'refresh sysCfg success')
      }
      if (successFunc) {
        successFunc(logFunc)
      }
    } else {
      if (logFunc) {
        logFunc(2, 'refresh sysCfg error: ' + response.error)
      }
    }
  })
}

vGlobal.refreshTasks = function (successFunc, logFunc) {
  fetchRTTasks({}).then(response => {
    if (response.success) {
      let isModify = false
      const vec = []
      for (let i = 0; i < response.items.length; i++) {
        const item = new Task(response.items[i])
        const task = vGlobal.getTask(item.id)
        if (!task) {
          isModify = true
          vGlobal.vecTask.push(item)
        } else {
          if (!task.cmpSame(item)) {
            task.init(item)
          }
        }
        vec.push(item.id)
      }
      for (let i = vGlobal.vecTask.length - 1; i >= 0; i--) {
        const v = vGlobal.vecTask[i]
        if (vec.indexOf(v.id) < 0) {
          isModify = true
          vGlobal.vecTask.splice(i, 1)
        }
      }

      if (isModify) {
        console.log('task modify')
        vGlobal.vecTask.sort((v1, v2) => {
          return v1.id - v2.id
        })
      }

      if (successFunc) {
        successFunc(logFunc)
      }
    }
  })
}

vGlobal.schedule = function () {
  vGlobal.scheduleRtTagPos()

  vGlobal.scheduleRtAncStatus()
}

vGlobal.scheduleRtTagPos = function () {
  // fetch rt tag pos
  fetchRTTagPos({}).then(response => {
    const posList = response.dict
    const newTime = new Date().getTime()
    for (const k in posList) {
      const addr = Number(k)
      const tag = vGlobal.gTags[addr]
      if (!tag) continue

      tag.areaAddr = Number(posList[addr].areaAddr)
      tag.status = Number(posList[addr].status)
      tag.heart = Number(posList[addr].heart)
      tag.battery = Number(posList[addr].battery)

      const x = Math.floor(Number(posList[addr].x) * 100) / 100
      const y = Math.floor(Number(posList[addr].y) * 100) / 100
      const z = Math.floor(Number(posList[addr].z) * 100) / 100
      const dx = x - tag.x
      const dy = y - tag.y
      const dz = z - tag.z

      const online = Number(posList[addr].online)

      tag.online = online
      tag.x = x
      tag.y = y
      tag.z = z
      tag.lastTime = newTime
      tag.setAlarmSet(Number(posList[addr].alarmSet))

      if (tag.online) {

      } else {

      }
    }

  })
}

vGlobal.scheduleRtAncStatus = function () {
  //fetch rt anchor status
  fetchRTAncStatus({}).then(response => {
    if (response.success) {
      for (let i = 0; i < response.items.length; i++) {
        const item = response.items[i]
        const anchor = vGlobal.gAnchors[Number(item.addr) || Number(item.id)]
        if (!anchor) continue
        anchor.status = Number(item.status)
        anchor.battery = Number(item.battery)
        anchor.online = Number(item.online)
        anchor.x = Number(item.x)
        anchor.y = Number(item.y)
        anchor.z = Number(item.z)
        anchor.lastUpdateTime = Number(item.lastUpdateTime)

      }
    }
  })
}

vGlobal.scheduleRtAlarm = function () {
  fetchRTAlarms({}).then(response => {
    if (response.success) {
      let isModify = false
      const vec = []
      for (let i = 0; i < response.items.length; i++) {
        const item = new Alarm(response.items[i])
        const alarm = vGlobal.getAlarm(item.id)
        if (!alarm) {
          isModify = true
          vGlobal.vecAlarm.push(item)
        } else {
          if (alarm.confirmTime !== Number(item.confirmTime) ||
            alarm.endTime !== Number(item.endTime)) {
            alarm.init(item)
            isModify = true
          }
        }
        vec.push(item.id)
      }
      for (let i = vGlobal.vecAlarm.length - 1; i >= 0; i--) {
        const v = vGlobal.vecAlarm[i]
        if (vec.indexOf(v.id) < 0) {
          isModify = true
          vGlobal.vecAlarm.splice(i, 1)
        }
      }

      if (isModify) {
        vGlobal.vecAlarm.sort((v1, v2) => {
          return v1.type - v2.type
        })
      }
    }
  })
}

/**
 * @function Update updateAnchors
 * @param {Array}[list=null]
 * @param {function}[successFunc=null]
 * @param {function}[failedFunc=null]
 */
vGlobal.updateAnchors = function (list, successFunc, failedFunc) {
  const vec = []
  for (const v of list) {
    vec.push(v.toJson())
  }
  batchModifyAnchors({
    anchors: vec
  }).then((response) => {
    if (response.success) {
      if (successFunc) {
        successFunc(list)
      }
    } else {
      if (failedFunc) {
        failedFunc(list)
      }
    }
  })
}


/**
 * @function Update updateSigns
 * @param {Array}[list=null]
 * @param {Boolean}[forceUpdate=false]
 * @param {function}[successFunc=null]
 * @param {function}[failedFunc=null]
 */
vGlobal.updateSigns = function (list, forceUpdate, successFunc, failedFunc) {
  let signs = []
  if (list) {
    for (const id of list) {
      signs.push(vGlobal.getSign(id))
    }
  } else {
    signs = vGlobal.vecSign
  }

  if (!signs) return

  const vec = []
  for (const v of signs) {
    vec.push(v.toJson())
  }
  batchModifySigns({
    signs: vec
  }).then((response) => {
    if (response.success) {
      if (successFunc) {
        successFunc(signs)
      }
    } else {
      if (failedFunc) {
        failedFunc(signs)
      }
    }
  })
}

/**
 * @function Update updateTags
 * @param {Array}[list=null]
 * @param {function}[successFunc=null]
 * @param {function}[failedFunc=null]
 */
vGlobal.updateTags = function (list, successFunc, failedFunc) {
  console.log('enter');
  const vec = []
  for (const v of list) {
    vec.push(v.toJson())
  }
  console.log('updateTags', vec);
  batchModifyTags({
    tags: vec
  }).then((response) => {
    if (response.success) {
      if (successFunc) {
        successFunc(list)
      }
    } else {
      if (failedFunc) {
        failedFunc(list)
      }
    }
  })
}

vGlobal.updateProject = function (project, successFunc, failedFunc) {
  modifyProject({
    project: project.toJson()
  }).then((response) => {
    if (response.success) {
      if (successFunc) {
        successFunc(project)
      }
    } else {
      if (failedFunc) {
        failedFunc(project)
      }
    }
  })
}

export default vGlobal