ZLJ_UI_V6.0/CallCenterWe.../src/utils/telWebsocket...

/**
 * 修改 心跳开始结束的时机；20181212
 * 签入后心跳开始；签出后心跳结束；
 * 增加心跳 false 处理（签出）
 */
import { Message, MessageBox, Switch } from 'element-ui'
import store from '@/store'
import router from '@/router'

let ws // websocket 实例
let cls = 0
let lockReconnect = false // 避免重复连接
let websocktTimer // 定时器
let wsUrl = null
// const wsUrl = 'ws://' + process.env.SOCKET_IP + ':' + process.env.SOCKET_PORT
// 创建scoket连接
export function createWebSocket () {
  wsUrl = 'ws://' + store.getters.serverConfig.SOCKET_IP + ':' + store.getters.serverConfig.SOCKET_PORT
  try {
    if ('WebSocket' in window) {
      ws = new WebSocket(wsUrl)
      init()
    } else {
      Message.error('当前浏览器不支持Websocket!')
    }
  } catch (e) {
    reconnect()
  }
}

// 连接
function init () {
  ws.onopen = function () {
    // console.groupCollapsed(`telWebsocket:`)
    console.log(new Date() + '  telWebsocket  ' + '建立连接：' + wsUrl)
    // 修改store 中连接状态
    store.dispatch('ConnectWs', true)
    // 修改 store 中telwebsocket的数据
    store.dispatch('ChangeTelWSMsg', {
      'wsUrl': wsUrl,
      'operationType': '建立连接'
    })
    console.log(window.sessionStorage.getItem('telIsLogin'))
    if (Number(window.sessionStorage.getItem('telIsLogin'))) {
      // heartCheck.reset().start()
      // heartCheck.sendHeart()
    }
  }

  // 接收到消息的回调方法
  ws.onmessage = function (evt) {
    // 如果获取到消息，心跳检测重置
    // 拿到任何消息都说明当前连接是正常的
    // heartCheck.reset().start()
    console.log('%c' + new Date() + '%c receive%c telWebsocket %ctype:' + JSON.parse(evt.data).Type + '%c ' + evt.data, 'color: #111', 'color: #67C23A', 'color: #111', 'color: #67C23A', 'color: #111')
    dealMsg(JSON.parse(evt.data))
    // 修改 store 中telwebsocket的数据
    const telWSData = JSON.parse(evt.data)
    telWSData.operationType = '接收'
    store.dispatch('ChangeTelWSMsg', telWSData)
  }

  // 连接关闭的回调方法
  ws.onclose = function (evt) {
    if (cls === 0) {
      cls = 1
      console.log('telWebsocket连接关闭')
      // console.groupEnd()
      // 修改store 中连接状态
      store.dispatch('ConnectWs', false)
      store.dispatch('ChangeLineState', 1)
      // 修改 store 中telwebsocket的数据
      store.dispatch('ChangeTelWSMsg', {
        'wsUrl': wsUrl,
        'operationType': '连接关闭'
      })
      reconnect()
    }
  }

  // 连接发生错误的回调方法
  ws.onerror = function (evt) {
    // 产生异常
    console.warn('telWebsocket连接出现异常！')
    // 修改 store 中telwebsocket的数据
    store.dispatch('ChangeTelWSMsg', {
      'wsUrl': wsUrl,
      'operationType': '连接异常'
    })
    if (ws == null || ws.readyState !== ws.OPEN) {
      console.log(new Date() + 'telWebsocket开始重连')
      // 修改 store 中telwebsocket的数据
      store.dispatch('ChangeTelWSMsg', {
        'wsUrl': wsUrl,
        'operationType': '开始重连'
      })
      reconnect()
    }
  }
}

/**
 * 重新连接
 */
function reconnect () {
  if (lockReconnect) return
  lockReconnect = true
  // 没连接上会一直重连，设置延迟避免请求过多
  websocktTimer && clearTimeout(websocktTimer)
  websocktTimer = setTimeout(function () {
    console.log(new Date() + '    ' + 'telWebsocket重连中……')
    // 修改 store 中telwebsocket的数据
    store.dispatch('ChangeTelWSMsg', {
      'wsUrl': wsUrl,
      'operationType': '重连中……'
    })
    createWebSocket()
    lockReconnect = false
  }, 2000)
}

/**
 * 发送
 * @ socketDatas 发送的数据 type {}
 */
export function Send (scoketDatas) {
  if (ws.readyState !== ws.OPEN) {
    reconnect()
  }
  if (ws.readyState === ws.OPEN) {
    console.log('%c' + new Date() + '%c  send %c telWebsocket  ' + JSON.stringify(scoketDatas), 'color: #111', 'color: #409EFF', 'color: #111')
    ws.send(JSON.stringify(scoketDatas))
    scoketDatas.operationType = '发送'
    // 修改 store 中telwebsocket的数据
    store.dispatch('ChangeTelWSMsg', scoketDatas)
  }
}

// 心跳检测
const heartCheck = {
  timeout: 20000, // 5秒
  timeoutObj: null,
  serverTimeoutObj: null,
  reset: function () {
    clearTimeout(this.timeoutObj)
    clearTimeout(this.serverTimeoutObj)
    return this
  },
  start: function () {
    const _self = this
    this.timeoutObj = setTimeout(function () {
      // 这里发送一个心跳，后端收到后，返回一个心跳消息，
      // onmessage拿到返回的心跳就说明连接正常
      _self.sendHeart()
    }, this.timeout)
  },
  sendHeart: function () {
    const scoketDatas = {
      'Type': 'Heart',
      'Result': true,
      'AgentID': store.getters.usercode, // 工号
      'AgentExten': store.getters.extension, // 分机号
      'AgentGroup': store.getters.groupcode // 坐席组id
    }
    Send(scoketDatas)
  }
}

/**
 * 处理接收的消息
 * @ msgData 接收的数据 type {}
 */
function dealMsg (msgData) {
  if (msgData) {
    const rlt = msgData.Result
    if (rlt === true) {
      switch (msgData.Type.toLowerCase()) {
        case 'login': // 签入
          LoginBack()
          break
        case 'logout': // 签出
          LogoutBack()
          break
        case 'dropcall': // 挂断
          DropCallBack()
          break
        case 'makecall': // 外呼
          MakeCallBack(msgData)
          break
        case 'saybusy': // 置忙
          SayBusyBack(msgData)
          break
        case 'sayfree': // 置闲
          SayFreeBack(msgData)
          break
        case 'meeting': // 会议
          MeetingBack()
          break
        case 'transfer': // 转移
          TransferBack()
          break
        // case 'consult': // 协商呼叫
        //   ConsultBack()
        //   break
        case 'hold': // 保持
          HoldBack(msgData)
          break
        case 'retrieve': // 接回
          RetrieveBack()
          break
        case 'incoming': // 来电
          IncomingBack(msgData)
          break
      }
    } else if (rlt === false) {
      const errCode = msgData.Error % 10000
      // console.error(`telWebsocket错误信息: ${errTips}(errorCode:${errCode})!`)
    } else {
      if (msgData.Type.toLowerCase() === 'linestate') {
        LineStateAgentBack(msgData)
      } else if (msgData.Type.toLowerCase() === 'monitor') {
        //console.log(msgData)
        updateSeatMonitorlists(msgData)
      } else {
        Message.error(`telWebsocket错误信息: ${rlt} !`)
      }
      // Message.error(`telWebsocket错误信息: ${rlt} !`)
    }
  }
}
function updateSeatMonitorlists (msgData) {
  store.dispatch('ChangeMonitor', true) // 修改监听操作的返回值
  store.dispatch('ChangeMonitorstate', msgData.Result) // 监控状态
  store.dispatch('ChangeMonitoragent', msgData.AgentID) // 监控坐席
}
// 签入
function LoginBack (reState) {
  // 心跳检测开始
  // heartCheck.reset().start()
  cls = 0
  store.dispatch('LoginWs')
  store.dispatch('ChangeTopRightState', ['空闲', true])
  // 弹出任务信息
  store.dispatch('ChangeTask', true)
}

// 签出
function LogoutBack (reState) {
  // 心跳检测关闭
  // heartCheck.reset()
  store.dispatch('LogoutWs')
  store.dispatch('ChangeTopRightState', ['已签出', false])
  // 重置初始化状态
  resetInitState()
}

// 重置初始化状态
function resetInitState () {
  store.dispatch('ChangeSeatState', 2) // 坐席状态（空闲）
  store.dispatch('ChangeLineState', 1) // 线路状态（空闲）
  store.dispatch('ChangeCallNum', '') // 顶部电话号码（''）
  store.dispatch('ChangeCallType', 'MakeCall') // 发送的通话类型（默认是外呼）
  store.dispatch('ChangeTask', false) // 外呼任务信息是否显示
  store.dispatch('ChangeTaskFirst', true) // 外呼任务信息是否是第一次弹出
}

/**
 * 置忙
 * sayOption (点击置忙置闲后的返回值)
 * */
function SayBusyBack (sayOption) {
  store.dispatch('ChangeSeatState', 5)
  if (sayOption.Type === 'SayBusy') {
    console.log(sayOption.Type)
    store.dispatch('ChangeTopRightState', ['忙碌', false])
  }
}
/**
 * 置闲
 * sayOption (点击置忙置闲后的返回值)
 * */
function SayFreeBack (sayOption) {
  store.dispatch('ChangeSeatState', 2)
  if (sayOption.Type === 'SayFree') {
    console.log(sayOption.Type)
    store.dispatch('ChangeTopRightState', ['空闲', true])
  }
}

// 线路状态通知
function LineStateAgentBack (linedata) {
  // 0分机不可用，1空闲，2摘机等待拨号，3正在拨号，4呼出振铃，5来电振铃，6通话中，7播放忙音中，8移除IP分机，10通话保持中
  store.dispatch('ChangeTopRightState', [linedata.Result, true])
  switch (linedata.Result) {
    case '空闲':
      store.dispatch('ChangeLineState', 1)
      store.dispatch('ChangeCallNum', '') // 顶部电话号码（''）
      break
    case '摘机等待拨号':
      store.dispatch('ChangeLineState', 2)
      break
    case '正在拨号':
      store.dispatch('ChangeLineState', 3)
      break
    case '呼出振铃':
      store.dispatch('ChangeLineState', 4)
      break
    case '来电振铃':
      store.dispatch('ChangeLineState', 5)
      break
    case '通话中':
      store.dispatch('ChangeLineState', 6)
      break
    case '播放忙音中':
      store.dispatch('ChangeLineState', 7)
      break
    case '移除IP分机':
      store.dispatch('ChangeLineState', 8)
      break
    case '通话保持中':
      store.dispatch('ChangeLineState', 10)
      break
  }

}

// 来电
function IncomingBack (inComingData) {


  const inComingCallId = inComingData.CallID
  let inComingNumber = inComingData.Number

  // 组id和groupid一致是正常弹屏；不一致是预测外呼弹屏；

  if (inComingData.IncomintType === 1) {
    // 来电弹屏 TaskIcon 的值是坐席组id , query: {selected: "2"}
    inComingNumber = inComingData.Number
    //this.$router.push({path: '/backend/order'});  view.path = `/callScreen`  view.fullPath = `/callScreen`      
    router.push({ name: 'callScreen', path: '/callScreen', fullPath: '/callScreen', params: { callid: inComingCallId, telInNumber: inComingNumber } })
    // router.push({ name: 'callScreenHY', params: { callid: inComingCallId, telInNumber: inComingNumber }}) // 售后
    //router.push({ name: 'callScreen', params: { callid: inComingCallId, telInNumber: inComingNumber } })
    // router.push({ name: 'autoCallScreen', params: { callid: inComingCallId, telInNumber: inComingNumber }})
    // router.push({ path: '/callScreen', query: { callid: inComingCallId, telInNumber: inComingNumber }})
  } else if (inComingData.IncomintType === 2) {
    if (store.getters.telOutboundScreen) {
      inComingNumber = inComingData.CalleeNumber
      router.push({ name: 'clickCallScreen', params: { callid: inComingCallId, telInNumber: inComingNumber } })
    } else {
      store.dispatch('UpdateOutboundScreen', true)
    }
    // 自动外呼弹屏 TaskIcon值是任务id
    // router.push({ name: 'autoCallScreen', params: { callid: inComingCallId, telInNumber: inComingNumber, taskId: inComingData.TaskIcon }})
  }
  store.dispatch('ChangeCallNum', inComingNumber)
}

// 挂断
function DropCallBack () {
  store.dispatch('ChangeCallNum', '') // 顶部电话号码（''）
  store.dispatch('ChangeCallType', 'MakeCall') // 发送的通话类型（默认是外呼）
  // 当前在坐席监控中需要 更新坐席监控内坐席的状态
  const curentViews = store.state.tagsView.visitedViews
  for (let i = 0, len = curentViews.length; i < len; i++) {
    if (curentViews[i].name === 'seatMonitor') {
      // updateSeatMonitorlists()
      return
    }
  }
}

// 转接
function TransferBack () {
  store.dispatch('ChangeCallNum', '') // 顶部电话号码（''）
  store.dispatch('ChangeCallType', 'MakeCall') // 发送的通话类型（默认是外呼）
}

// 外呼 结果 弹出来电弹屏
function MakeCallBack (callBackData) {
  const inComingNumber = store.getters.telCallNum
  const inComingCallId = callBackData.CallID
  // 点击外呼弹屏
  // router.push({ name: 'clickCallScreen', params: { callid: inComingCallId, telInNumber: inComingNumber } })
  // router.push({ name: 'callScreen', params: { callid: inComingCallId, telInNumber: inComingNumber } })
}

// 多方通话
function MeetingBack () { }

// 录音返回
function RecordPathBack () { }

// 保持
function HoldBack (holdData) {
  if (holdData.Result === true) {
    store.dispatch('ChangeLineState', 10)
  }
}

// 接回
function RetrieveBack (RetrieveData) {
  // if (RetrieveData.Result === true) {
  //   store.dispatch('ChangeLineState', 6)
  // }
}

// 更新坐席监控内坐席的状态
// function updateSeatMonitorlists (moitorData) {
//   console.log(moitorData)
//   // store.dispatch('ChangeMonitor', true) // 修改监听操作的返回值
// }