fcc-core/utils/call-center/events/agentEvent.js

Fusion communication center.

import agentapi from '../api/agentApi'
import events from './eventsConfig'
import { extend } from '../util/util'
import { ignoreEvent } from './ignoreEvents'
import eventlife from './eventlife'
// import client from './websocket'
import client from '../../nats/fsnats'
import eventAnalysis from './eventAnalysis'

/**
 * 事件获取及处理
 * 目前支持华为平台 以及freeswitch 两个平台
 * 华为平台获取事件通过轮询方式
 * freeswitch 通过对接emq的websocket 方式获取
 * 两者获取方法都在签入成功后 init 方法里面初始化启动
 * 签出成功停止事件的获取
 * 两者除获取事件方式不一致  其他逻辑完全一样
 */
class AgentEvents {
  constructor (ucc) {
    extend(AgentEvents.prototype, events)
    this.ucc = ucc
    this.stop = false
    this.eventQueue = []
  }
  // 启动获取事件以及一些初始化的操作
  init () {
    this.stop = false

    // 如果是agentgateway平台  则轮询获取事件
    if (!this.ucc.isFS) {
      this.getEvent()
    } else {
      const self = this
      this.client = client
      this.client.open(() => {
        this.client.on(`callcenter.agentEvent.${this.ucc.userInfo.AGENT_ID}.>`, response => {
          this.parseEvent.call(self, response)
          eventAnalysis.analysis(response)
        })
      }, this.ucc.xw)
      // this.client = client({
      //   agentId: this.ucc.userInfo.AGENT_ID,
      //   phonenum: this.ucc.userInfo.SIGNIN_CODE,
      //   cb: (client) => {
      //     let subscribe = 'callcenter.agentEvent.' + this.ucc.userInfo.AGENT_ID + '.>'
      //     client.nats.subscribe(subscribe, message => {
      //       this.parseEvent.call(self, JSON.parse(message))
      //       eventAnalysis.analysis(message)
      //     })
      //   }
      // })
    }
  }

  /**
   * 轮询获取华为平台的事件
   * 每次调用成功时
   * 1.获取到事件，则立即递归方式调用自己
   * 2.没有取到事件，则1S后重新获取，后台会挂起10S后再响应该请求
   */
  getEvent () {
    if (this.stop) {
      return
    }
    const self = this
    agentapi
      .getAgentEvent()
      .then(async data => {
        const { event } = data
        // 没有获取到事件 则600ms之后重新拉取事件
        if (event === undefined) {
          setTimeout(() => {
            self.getEvent()
          }, 1000)
        } else {
          this.parseEvent.call(self, event, self.getEvent)
        }
      })
      .catch(e => {
        console.error(e)
        // 坐席没有登录
        if (e === '100-006') {
          return
        }
        self.getEvent()
      })
  }

  /**
   * websocket收到FS平台事件消息时
   */
  onMessageArrived () {
    return function (message) {
      if (message) {
        const obj = JSON.parse(message.payloadString)
        if (!obj['content']) {
          obj['content'] = ''
        }
        this.parseEvent.call(self, obj)
      }
    }
  }

  /**
   * 解析平台事件
   * @param event
   * @param cb
   */
  parseEvent (event, cb) {
    const self = this
    // 纠正坐席状态状态
    self.checkedState()
    // 执行下一个获取事件操作
    cb && cb.call(this)
    // 事件里面带来的参数
    let { content: params } = event
    self.ucc.db.addLog({
      action: `收到事件`,
      usercode: self.ucc.userInfo.USER_CODE,
      interface: '获取事件接口',
      state: self.ucc.agentState,
      params: event
    })
    // 缓存callid
    this.pushCallid(event)
    const type = self.ucc.transType
    // 如果存在转移操作 则屏蔽转移操作触发的事件
    if (type && ignoreEvent(type, event.eventType)) {
      return
    }
    params = typeof params === 'string' ? { content: params } : params
    // 将平台事件转换成业务事件
    const uccevent = typeof self[event.eventType] === 'function' ? self[event.eventType]() : ''
    // 发射事件
    self.emitEvent(uccevent, params, event.eventType)
  }
  /**
   * 发射事件
   * @param uccevent
   */
  async emitEvent (uccevent, params = {}, eventType) {
    if (uccevent) {
      // 来电相关事件时，查询出随路数据  主要针对有通话的时候
      let callData = await this.ucc.getCallData(eventType, params)
      // 分发事件到组件
      if (this.ucc.transType) {
        this.emitEventToComponent(uccevent, params)
      }
      // 初始化每个事件数据对象
      this.ucc.eventData[uccevent] = { time: new Date().getTime(), params: Object.assign(callData, params) }
      // 判断事件队列里面是否存在 存在表示事件操作之后预期事件获取没有完成
      if (this.eventQueue.length > 0) {
        if (uccevent === this.eventQueue[0]) {
          clearTimeout(this.ucc.eventTimer)
          this.ucc.eventTimer = null
          while (this.eventQueue.length > 0) {
            this.executeChangebtn(this.eventQueue.shift())
          }
        } else {
          this.eventQueue.push(uccevent)
        }
        return
      }
      // 执行按钮变化按钮
      this.executeChangebtn(uccevent)
    }
  }

  /**
   *通过事件触发按钮的变化
   * @param uccevent
   */
  executeChangebtn (uccevent) {
    // 事件触发前
    eventlife[uccevent] && eventlife[uccevent]['beforeEvent'].call(this.ucc, uccevent)
    // 执行对应事件的业务代码得到按钮变化所需要的事件
    const btnevent = typeof this.ucc[uccevent] === 'function' && this.ucc[uccevent](uccevent)
    // 事件触发后
    eventlife[uccevent] && eventlife[uccevent]['afterEvent'].call(this.ucc, uccevent)
    // 修改按钮的初始配置 触发按钮变化
    /* if (btnevent) {
      const btnconfig = this.ucc.btnctrl.getBtnConfig(btnevent)
      extend(this.ucc.btnctrl.initConfig, btnconfig)
    } */
  }

  /**
   * 广播事件到组件
   */
  emitEventToComponent (event, params) {
    const components = this.ucc.components
    for (let component in components) {
      components[component]['emitEvent'] && components[component]['emitEvent'](event, params)
    }
  }
  /**
   *获取坐席状态并纠正
   * @returns {Promise<void>}
   */
  async checkedState () {
    const {
      result: { agentState }
    } = await agentapi.getAgentStatusSync()
    if (this.ucc.agentState === 4 && agentState !== 4) {
      // 更新示闲话务操作流水
    }
    this.ucc.agentState = agentState
  }

  /**
   * 缓存callid
   * @param event
   */
  pushCallid (event) {
    if (event.eventType === 'AgentEvent_Talking') {
      console.log('///', this)
      const index = this.ucc.callids.indexOf(event.content.callId)
      index < 0 && this.ucc.callids.push(event.content.callId)
      this.ucc.transType && this.emitEventToComponent('OnAnswerSuccess')
    }
  }
  /**
   *停止获取事件
   */
  stopGetEvent () {
    this.stop = true
  }
}

export default AgentEvents