Customer-Service-Web/service/static/publicMethods.js

export default {
    //获取图片
    imgPreview(file, callback) {
      let self = this;
      let name = file.name.split('.')[0]
      //判断支不支持FileReader
      if (!file || !window.FileReader) return;
      if (/^image/.test(file.type)) {
          //创建一个reader
          let reader = new FileReader();
          //将图片转成base64格式
          reader.readAsDataURL(file);
          //读取成功后的回调
          reader.onloadend = function() {
              let result = this.result;
              let img = new Image();
              let formData = new FormData();
              img.src = result;
              img.onload = function() {
                  let data = self.compress(img,name);
                  let blob = self.dataURItoBlob(data);
                  formData.append("file", blob,name+'.jpeg');
                  //图片预览,配置文件,formData数据;
                  callback && callback(data,formData);
              };
          };
      }
  },
  // 压缩图片
  compress(img) {
      let canvas = document.createElement("canvas");
      let ctx = canvas.getContext("2d");
      // let initSize = img.src.length;
      let width = img.width;
      let height = img.height;
      canvas.width = width;
      canvas.height = height;
      // 铺底色
      ctx.fillStyle = "#fff";
      ctx.fillRect(0, 0, canvas.width, canvas.height);
      ctx.drawImage(img, 0, 0, width, height);

      //进行压缩
      let ndata = canvas.toDataURL("image/jpeg", 0.4);
      // console.log("*******压缩后的图片大小*******");
      // console.log(ndata)
      return ndata;
  },

  // base64转成bolb对象
  dataURItoBlob(base64Data) {
      var byteString;
      if (base64Data.split(",")[0].indexOf("base64") >= 0)
          byteString = atob(base64Data.split(",")[1]);
      else byteString = unescape(base64Data.split(",")[1]);
      var mimeString = base64Data
          .split(",")[0]
          .split(":")[1]
          .split(";")[0];
      var ia = new Uint8Array(byteString.length);
      for (var i = 0; i < byteString.length; i++) {
          ia[i] = byteString.charCodeAt(i);
      }
      return new Blob([ia], { type: mimeString});
    },


    //
    setApiToken(name, controller, time, modules) {
        let str = name + 'customer-service' + controller + time + modules
        return str.toLocaleLowerCase()
    },

    /**
     * 时间戳转日期自定义时间格式
     * timeStamp:时间戳
     * custom:转换日期时定义年月日用是什么符号隔开
     * isDtae:0=月份、1=日期、3=时间
     */
    customFormatDateTime(timeStamp,custom,isDtae) {
        var date = new Date();
        date.setTime(timeStamp * 1000);
        var y = date.getFullYear();
        var m = date.getMonth() + 1;
        m = m < 10 ? ('0' + m) : m;
        var d = date.getDate();
        d = d < 10 ? ('0' + d) : d;
        var h = date.getHours();
        h = h < 10 ? ('0' + h) : h;
        var minute = date.getMinutes();
        var second = date.getSeconds();
        minute = minute < 10 ? ('0' + minute) : minute;
        second = second < 10 ? ('0' + second) : second;
        if (isDtae == 0){
        return y + custom + m //+'student';
        }else if (isDtae ==1){
        return y + custom + m + custom + d;
        }else{
        return y + '-' + m + '-' + d + ' ' + h + ':' + minute //+ ':' + second;
        }
    },

    /*****************屏蔽关键字******************/
    /**
     * 
     * @param {*} data 
     * @param {*} sensitive 
     * @param {*} 
     */
    shieldingKeyword(data,sensitive) {
        //将敏感词组用|转换字符串
        let snstive = sensitive.join('|');
        let num = 0,text='';
        //匹配出会话中的敏感词
         data.replace(eval('/' + snstive + '/g'), (res) => {
            // var str = '';
            console.log(res)
            text +=','+res;
            // for (var i = 0; i < res.length; i++) {
            //     str += '*';
            // }
            num ++;
            // return str;
        })

        return {
            text,
            num
        }
    },

    /*****************用户屏蔽关键字******************/
    /**
     * 
     * @param {*} data 
     * @param {*} sensitive 
     * @param {*} 
     */
    userShieldingKeyword(data,sensitive) {
        //将敏感词组用|转换字符串
        let snstive = sensitive.join('|');
        let num = 0,text='';
        //匹配出会话中的敏感词
        return data.replace(eval('/' + snstive + '/g'), (res) => {
            var str = '';
            for (var i = 0; i < res.length; i++) {
                str += '*';
            }
            return str;
        })
    },


    /******************访客接入*********************/
   /**
    * 
    * @param {object} redata  接收消息源
    * @param {Array} offlineList  访客离线列表
    * @param {Array} sessionList  访客会话列表
    * @param {int} sessionType 选择列表状态默认未1(1是会话中，2是离线)
    * @param {int} dataIndex  定位当前会话，默认是0
    * @param {Array} dataList 当前会话信息列表
    * @param {string} user_name 当前会话访客名
    * @param {function} callback   访客匹配离线列表处理后链接回调方法
    * @param {function} callback1   访客正常链接回调方法
    */
   visitorsConnect([redata,offlineList,sessionList,sessionType,dataIndex,dataList,user_name],callback,callback1){
        //将会话工单写入访客信息
        redata.user_info.conversationId = redata.conversationId;
        //默认离线列表没有访客信息
        let isTrue = true;

        //匹配是否是离线用户上线
        if(offlineList.length > 0){
            for(let i = 0; i < offlineList.length; i++){
                //匹配离线列表是否有这个用户
                if(offlineList[i].id == redata.user_info.id  ){
                    //查询离线列表是否有此用户会话工单未结束
                    if(offlineList[i].conversationId  ==  redata.conversationId){
                        //工单号未结束的数据获取历史聊天消息和对象名字
                        if(sessionType == 2 && i == dataIndex){//客服选中离线重新链接访客
                            dataList = [];
                            dataList = offlineList[i].data;
                            user_name  = offlineList[i].name;
                            sessionType = 1;
                            dataIndex = sessionList.length == 0 ? 0 : sessionList.length-1;
                        }else if(sessionType == 2 && i < dataIndex){//客服选中离线列表重新链接访客后面的访客
                            if(i > 0){
                                dataList = offlineList[i].data;
                                user_name  = offlineList[i].name;
                            }
                        }
                        //将掉线前聊天消息写入到用户对象里面
                        redata.user_info.data = offlineList[i].data;
                    }else{
                        //工单号已结束数据处理
                        if(dataIndex == 0 && sessionList.length  == 0){
                            user_name = redata.user_info.name;
                            dataList = [];
                        }
                        redata.user_info.data = [];
                    }
                    //将离线状态用户删除
                    offlineList.splice(i,1);

                    //回调
                    callback && callback(offlineList);
                    isTrue = false;
                    break;
                }
            }
        }

        //新访客链接
        if(isTrue){
            if(sessionList.length  == 0){
                //判断是否选离线用户列表
                if(offlineList.length > 0 && sessionType ==2){
                //不做处理
                }else{
                    dataIndex = 0
                    sessionType = 1
                    user_name = redata.user_info.name;
                    dataList = [];
                }
            }else{
                for(let i = 0; i < sessionList.length; i++){
                    //匹配离线列表是否有这个用户
                    if(sessionList[i].id == redata.user_info.id  ){
                        sessionList.splice(i,1);
                        break;
                    }
                }
            }
            redata.user_info.data = [];
        }
        //回调
        callback1 && callback1(redata,sessionList,offlineList,sessionType,dataIndex,dataList,user_name);
    },

    /*****************用户会话离线及相关数据*********************/
    /**
     * @param {object} redata  接收消息源
     * @param {Array} sessionList  访客会话列表
     * @param {Array} offlineList  访客离线列表
     * @param {int} sessionType 选择列表状态默认未1(1是会话中，2是离线)
     * @param {int} dataIndex  定位当前会话，默认是0
     * @param {string} user_name 当前会话访客名
     * @param {Array} dataList 当前会话信息列表
     * @param {*} callback  回调函数
     */
    userOffline([redata,sessionList,offlineList,sessionType,dataIndex,user_name,dataList],callback){
        let userInfo = [];
        for(let i = 0 ; i < sessionList.length; i++){
            //匹配会话中离线用户
            if(sessionList[i].id  == redata.id ){
                //把数据添加到离线列表
                offlineList.push(sessionList[i]);
                //用户选中状态会话中处理
                if(sessionType == 1){
                    //判断会话中列表长度
                    if(sessionList.length > 1){
                        //判断是否离线用户是当前选中状态
                        if( dataIndex == i){
                            dataIndex = 0;
                            user_name = sessionList[0].name;
                            dataList = sessionList[0].data;
                            userInfo = sessionList;
                        }
                        //删除会话列表离线用户
                        sessionList.splice(i,1);
                    }else{
                        sessionType = 2;
                        dataIndex = 0;
                        user_name =offlineList[0].name;
                        dataList = offlineList[0].data;
                        userInfo = offlineList ;
                        sessionList.splice(i,1);
                    }
                }
                callback && callback(sessionList,offlineList,sessionType,dataIndex,user_name,dataList,userInfo);     
                break;
            }
        }
    },

    /**************删除会话中离线用户及相关数据**************/
    /**
     * @param {object} redata  接收消息源
     * @param {Array} sessionList  访客会话列表
     * @param {Array} offlineList  访客离线列表
     * @param {int} sessionType 选择列表状态默认未1(1是会话中，2是离线)
     * @param {int} dataIndex  定位当前会话，默认是0
     * @param {string} user_name 当前会话访客名
     * @param {Array} dataList 当前会话信息列表
     * @param {*} callback  回调函数
     */

    sessionEnd([redata,sessionList,offlineList,sessionType,dataIndex,user_name,dataList],callback){
        let isTrue = true;
        let userInfo = [];
        //会话中列表匹配
        if(sessionList.length > 0){
            for(let i = 0 ; i < sessionList.length; i++){
                //检测会话列表中是否有结束的会话对象
                if(sessionList[i].id  ==  redata.id){
                    //删除会话列表中结束的会话对象用户信息
                    sessionList.splice(i,1);
                    // this.$store.dispatch("SET_SESSION",sessionList);
                    if(sessionType == 1){
                        if(sessionList.length >1){
                            //处理会话显现状态
                            if(dataIndex == i){
                                user_name = sessionList[0].name;
                                dataList = sessionList[0].data;
                                userInfo = sessionList;
                            }
                        }else{
                            if(offlineList.length > 0 ){
                                sessionType = 2;
                                dataIndex = 0;
                                userInfo = offlineList;
                            }else{
                                user_name = '';
                                dataList = [];
                                userInfo = '';
                            }
                        }
                    }
                    isTrue = false;
                    break;
                }
            }
        }
        //离线列表查询
        if(isTrue){
            for(let i = 0 ; i < offlineList.length; i++){
                //判断离线列表是否结束会话
                if(offlineList[i].id ==  redata.id){
                    //删除离线列表中结束会话的用户信息
                    offlineList.splice(i,1);
                    // this.$store.dispatch("SET_OFFLINE",offlineList);
                    if(sessionType == 2){
                        if(dataIndex == i){
                            if(offlineList.length > 1){
                                if(sessionList.length >0){
                                    dataList = sessionList[0].data;
                                    user_name = sessionList[0].name;
                                    userInfo = sessionList;
                                }else{
                                    dataList = offlineList[0].data;
                                    user_name = offlineList[0].name;
                                    userInfo = offlineList;
                                }
                            }else{
                                if(sessionList.length >0){
                                    dataList = sessionList[0].data;
                                    user_name = sessionList[0].name;
                                    userInfo = sessionList;
                                }else{
                                    dataList = [];
                                    user_name = '';
                                    userInfo = '';
                                }
                            }
                        }
                    }
                    break;
                }
            }
        }
        //回调
        callback && callback(sessionList,offlineList,sessionType,dataIndex,user_name,dataList,userInfo);
        
    },


    /*****************接收用户会话消息***************/
    /**
     * 
     * @param {*} redata 数据源
     * @param {*} sessionList 会话列表
     * @param {*} frce 表情数据源
     * @param {*} callback  回调
     */
    receivesMessage(redata,sessionList,frce,callback){
        let dataIndex = 0;
        //匹配是那个用户回的消息
        for(let i = 0 ; i < sessionList.length ; i++){
            if(sessionList[i].id == redata.id ){
                dataIndex = i;
                break;
            }
        }
        
        //获取当前回复消息对象
        let chatList = sessionList[dataIndex]
        redata.type = 'user';
        redata.content = JSON.parse(redata.content);
        //这个地方转
        redata.content.text = this.turnFace(redata.content.text,frce);
        //将消息添加对应的会话列表中
        chatList.data.push(redata);
        callback && callback(redata,chatList,dataIndex);
    },

    /******************文字信息转表情******************/
    /**
     * @param {*} data 
     * @param {*} frce 
     */
    turnFace(data,frce){
        let str = data.match(/\#\[.*?\]\//g);
        let arr =Array.from(new Set(str));
        arr.forEach(e=>{
            let imgsrc = '';
            for(let i = 0 ; i < frce.length ; i++){
                let expText = e.slice(1,e.length-1);
                if(expText == frce[i]){
                    imgsrc = '<img class="hover" src="'+require(`@/assets/img/${i}.gif`)+'"/>'
                    break;
                }
            }
            data = data.replace(new RegExp(`\\#\\[${e.substring(2,e.length-2)}\\]\\/`,'g'),imgsrc);
        })
        return data;
    },
}