@aochuang/client-sdk 1.0.278

package/utils/log.js

@@ -0,0 +1,243 @@
+import { unique } from './string'
+import { parse } from './json'
+import { formatDate } from './date'
+
+function requestAnimationFrame (callback) {
+	if (typeof uni === 'object') {
+		return setTimeout(() => {
+			callback && callback()
+		}, 10)
+	} else {
+		return window.requestAnimationFrame(() => {
+			callback && callback()
+		})
+	}
+}
+
+function cancelAnimationFrame (rafId) {
+	if (typeof uni === 'object') {
+		clearTimeout(rafId)
+	} else {
+		window.cancelAnimationFrame(rafId)
+	}
+}
+
+const LogManage = {
+    list: [],
+    add: (logInstance) => {
+        if (!(logInstance instanceof Log)) {
+            throw new Error('不是有效日志实例')
+        }
+        if (!this.list.some(v => v === logInstance)) {
+            throw new Error('日志实例已存在')
+        }
+        this.list.push(logInstance)
+    },
+    remove: (logInstance) => {
+        let index = -1
+        this.list.some((v, i) => {
+            if (v === logInstance) {
+                index = i
+                return true
+            }
+        })
+        if (index < 0) {
+            return
+        }
+        this.list.splice(index, 1)
+    }
+}
+
+export default class Log {
+
+    prefix = 'log'
+    
+    name = null
+
+    tempStore = []
+
+    beforeAddCallback = null
+
+    constructor (options) {
+        options = Object.assign({
+            name: null,
+						console: false, // 是否控制台打印
+            maxSize: 1024 * 1024 * 3 // 最多存3M的日志数据
+        }, options)
+        if (!options.name) {
+            throw new Error('必须指定日志的name名称')
+        }
+        if (LogManage.list.some(v => v.name === options.name)) {
+            throw new Error('已存在同名的日志实例')
+        }
+				this.options = options
+        this.maxSize = options.maxSize
+        this.name = options.name
+        this.validTime = options.validTime
+    }
+
+    get storageKey () {
+        return this.prefix + '_' + this.name 
+    }
+
+    onBeforeAdd (callback) {
+        this.beforeAddCallback = callback
+    }
+
+    /**   
+     * 新增日志到内存
+    */
+    addLog (data) {
+        data = Object.assign({
+            group: this.defautGroup,
+            refererId: undefined, // 可以关联一个日志
+            content: null
+        }, data, { 
+            createTime: formatDate(new Date())
+        })
+        data.id = unique(data.group)
+        if (this.beforeAddCallback && this.beforeAddCallback({
+            data
+        }) === false) {
+            return
+        }
+		const size = JSON.stringify(data).length
+		data.size = size
+        this.tempStore.push(data)
+        if (this.tempStore.length > 5) {
+            this.publishLogData().then(null, err => {
+				console.log(err)
+			})
+        }
+		if (this.options.console) {
+			console.log(`【${this.name || 'operateLog'}】${JSON.stringify(data) || '--'}`)
+		}
+        return data
+    }
+
+    /**
+     * 清空本地日志
+    */
+    clearLogData () {
+        return new Promise((resolve) => {
+            this.tempStore = []
+						if (typeof uni !== 'undefined') {
+							uni.removeStorageSync(this.storageKey)
+						} else {
+							window.localStorage.removeItem(this.storageKey)
+						}
+            resolve()
+        })
+    }
+
+    loadLogData () {
+			return new Promise((resolve, reject) => {
+				if (this._lastLoadLogDataRaf) {
+					this._lastLoadLogDataRaf.cancelFn()
+				}
+				let rafId = null
+				this._lastLoadLogDataRaf = {
+					cancelFn: () => {
+						cancelAnimationFrame(rafId)
+						this._lastLoadLogDataRaf = null
+						reject('cancel')
+					},
+					execFn: () => {
+						rafId = requestAnimationFrame(() => {
+							let localTempStore
+							if (typeof uni !== 'undefined') {
+								localTempStore = uni.getStorageSync(this.storageKey)
+							} else {
+								localTempStore = window.localStorage.getItem(this.storageKey)
+							}
+							if (localTempStore) {
+								localTempStore = parse(localTempStore) 
+									if (Array.isArray(localTempStore)) {
+										let totalSize = 0
+										localTempStore = {
+											data: localTempStore.map(v => {
+												if (!v.size) {
+													v.size = JSON.stringify(v).length
+												}
+												totalSize += v.size
+												return v
+											})
+										}
+										localTempStore.size = totalSize
+									}
+							}
+							if (!localTempStore) {
+								localTempStore = {
+										size: 0,
+										data: []
+									}
+							}
+							// 自清理一下
+							if (this._lastLoadLogDataRaf) {
+								cancelAnimationFrame(this._lastLoadLogDataRaf)
+								this._lastLoadLogDataRaf = null
+							}
+							resolve(localTempStore)
+						})
+					}
+				}
+				this._lastLoadLogDataRaf.execFn()
+			})
+    }
+
+    publishLogData () {
+        return new Promise((resolve, reject) => {
+					if (this._lastPublishLogDataRaf) {
+						this._lastPublishLogDataRaf.cancelFn()
+					}
+					let rafId = null
+					this._lastPublishLogDataRaf = {
+						cancelFn: () => {
+							cancelAnimationFrame(rafId)
+							this._lastPublishLogDataRaf = null
+							reject('cancel')
+						},
+						execFn: () => {
+							if (!this.tempStore || !this.tempStore.length) {
+								return resolve()
+							}
+							rafId = requestAnimationFrame(() => {
+								this.loadLogData().then((localTempStore) => {
+									const allData = [].concat(this.tempStore, localTempStore.data)
+									const nextLocalStore = {
+										size: 0,
+										data: []
+									}
+									allData.some((item, index) => {
+										if (item.size + nextLocalStore.size >= this.maxSize) {
+											return true
+										}
+										nextLocalStore.data.push(item)
+										nextLocalStore.size = nextLocalStore.size + item.size
+									})
+									if (typeof uni !== 'undefined') {
+										uni.setStorageSync(this.storageKey, nextLocalStore)
+									} else {
+										window.localStorage.setItem(this.storageKey, JSON.stringify(nextLocalStore))
+									}
+									this.tempStore = []
+									// 自清理一下
+									if (this._lastPublishLogDataRaf) {
+										cancelAnimationFrame(this._lastPublishLogDataRaf)
+										this._lastPublishLogDataRaf = null
+									}
+									resolve()
+								}, reject)
+							})
+						}
+					}
+					this._lastPublishLogDataRaf.execFn()
+				})
+    }
+
+    exportLogData () {
+        return this.publishLogData().then(() => {
+            return this.loadLogData()
+        })
+    }
+}

package/utils/queue.js

@@ -0,0 +1,97 @@
+import { unique } from './string'
+import { createPromise } from './util'
+
+/***
+ * 创建一个串行执行队列
+ */
+export function createSerialQueue (options) {
+    options = Object.assign({
+        spanTime: 1000 * 5 // 每个任务间隔时间，因为后端有节流控制，这里稍微加点时间间隔
+    }, options)
+    const queue = []
+    let _timer 
+    let _lastExecTime = null
+    return {
+        add (taskFn) {
+            if (typeof taskFn !== 'function') {
+                throw new Error('不是一个函数')
+            }
+            if (queue.some(v => v.fn === taskFn)) {
+                return
+            }
+            const ps = createPromise()
+            const item = {
+                id: unique(),
+                status: 'normal',
+                fn: () => {
+                    if (item.status === 'loading' || item.status === 'destroyed') {
+                        return
+                    }
+                    item.status = 'loading'
+                    const rs = taskFn()
+                    if (rs && rs.then) {
+                        rs.then(ps.resolve, ps.reject).finally(() => {
+                            _lastExecTime = Date.now()
+                            item.status = 'complete'
+                        })
+                    } else {
+                        _lastExecTime = Date.now()
+                        item.status = 'complete'
+                    }
+                }
+            }
+            queue.push(item)
+            this.check(queue.length - 1)
+            return ps
+        },
+        remove (taskFn) {
+            let index = -1
+            queue.some((v, i) => {
+                if (v.fn === taskFn) {
+                    index = i
+                    return true
+                }
+            })
+            if (index < 0) {
+                return
+            }
+            queue[index].status = 'destroyed'
+            queue.splice(index, 1)
+            this.check()
+        },
+        clear () {
+            if (!queue || !queue.length) {
+                return
+            }
+            for (let i = queue.length - 1; i >= 0; i--) {
+                this.remove(queue[i].fn)
+            }
+            clearTimeout(_timer)
+            _lastExecTime = null
+        },
+        check () {
+            // 把执行完的清理一下
+            for (let i = queue.length - 1; i >= 0; i--) {
+                if (queue[i].status === 'complete') {
+                    queue.splice(i, 1)
+                }
+            }
+            if (!_lastExecTime || ((Date.now() - _lastExecTime) > options.spanTime * 2)) {
+                if (queue[0] && queue[0].status === 'normal') {
+                    Promise.all([queue[0].fn()]).finally(() => {
+                        this.check()
+                    })
+                }
+            } else {
+                clearTimeout(_timer)
+                _timer = setTimeout(() => {
+                    if (queue[0] && queue[0].status === 'normal') {
+                        Promise.all([queue[0].fn()]).finally(() => {
+                            this.check()
+                        })
+                    }
+                }, options.spanTime)
+            }
+        }
+    }
+}

package/utils/regexp.js

@@ -0,0 +1,9 @@
+/**
+ * 编码正则表达式字符串
+ * 将敏感的字符进行编码，防止报错
+*/
+export function encodeRegexpString (s) {
+  /* eslint-disable */
+  return s.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+  /* eslint-enable */
+}

package/utils/string.js

@@ -0,0 +1,66 @@
+import shajs from 'sha.js'
+
+/**
+ * 生成会话id
+ * @param accountId - 客服id
+ * @param targetId - wechatFriendId | wechatChatroomId
+*/
+export function createSessionId (accountId, targetId) {
+	if (!accountId || !targetId) {
+		return
+	}
+	return shajs('sha1').update(`${accountId}${targetId}`).digest('hex')
+}
+
+let num = Date.now()
+export function unique () {
+	num++
+	return num
+}
+
+export function firstLetterUpperCase(string) {
+	if (!string) {
+		return
+	}
+	return string.charAt(0).toUpperCase() + string.slice(1)
+}
+
+export function html2Escape (sHtml) {
+  return (sHtml || '').replace(/[<>]/g, (c) => {
+    return {
+      '<': '&lt;',
+      '>': '&gt;'
+    }[c]
+  })
+}
+
+export function copyText (text) {
+	return new Promise((resolve, reject) => {
+		uni.setClipboardData({
+			data: text,
+			success: () => {
+				resolve()
+			},
+			fail: err => {
+				reject(err)
+			}
+		});
+	})
+}
+
+export function unUnicode (str) {
+  if (!str) {
+    return
+  }
+  /* eslint-disable */
+  return str.replace(/&#(x)?([^&]{1,5});?/g, function (a, b, c, d) {
+    return unescape(`%${c}`)
+  })
+  /* eslint-enable */
+}
+
+let number = Date.now()
+export function unqiue () {
+	++number
+	return 'u-' + number
+}

package/utils/url.js

@@ -0,0 +1,48 @@
+import qs from 'query-string'
+
+export function getUrlParams (url, options) {
+  if (!url) {
+    const pageHref = window.location.href
+    const searchIndex = pageHref.indexOf('?')
+    if (searchIndex >= 0) {
+      url = pageHref.substr(searchIndex)
+      // http://localhost:8082/?tenantId=yangyutest&_layout=left#/admin/app/workchat/livecode?_layout=left&_mode=module&tenantId=yangyutest
+      return url.split('#').reduce((rs, search) => {
+        const hashQuery = search.indexOf('?')
+        if (hashQuery >= 0) {
+          search = search.substr(hashQuery)
+          rs = Object.assign({}, rs, qs.parse(search, options))
+        }
+        return rs
+      }, {})
+    } else {
+      return {}
+    }
+  } else {
+    return qs.parse(url, options)
+  }
+}
+
+/**
+ * 解析url字符串
+*/
+let aElement = null
+export function parseUrl (url) {
+  if (!aElement) {
+    aElement = document.createElement('a')
+  }
+  aElement.href = url
+  const ds = aElement.hostname.split('.')
+  return {
+    protocol: aElement.protocol.replace(':', ''),
+    host: aElement.hostname,
+    port: aElement.port,
+    query: aElement.search,
+    params: getUrlParams(aElement.search),
+    hash: aElement.hash.replace('#', ''),
+    domain: ds[ds.length - 2],
+    /* eslint-disable */
+    path: aElement.pathname.replace(/^([^\/])/, '/$1')
+    /* eslint-enable */
+  }
+}

package/utils/util.js

@@ -0,0 +1,130 @@
+export function createPromise () {
+  let psReject, psResolve, isTry = false, _timer
+  const ps = new Promise((resolve, reject) => {
+    isTry = true
+    clearTimeout(_timer)
+    psResolve = resolve
+    psReject = reject
+  })
+  ps.reject = psReject
+  ps.resolve = psResolve
+  _timer = setTimeout(() => {
+    if (isTry) {
+      return
+    }
+    psReject('timeout')
+  }, 1000 * 60)
+  return ps
+}
+
+export function isEmptyObject (obj) {
+	if (!obj) {
+		return true
+	}
+	for (let key in obj) {
+		if (obj.hasOwnProperty(key)) {
+			return false
+		}
+	}
+  return true
+}
+
+/**
+ * 轮循加载
+*/
+export function createPollRequest (requestFn, spanTime = 5 * 1000, timeout = 60 * 1000) {
+  let _stop = false
+  let _timer = null
+  let _reject = null
+  function stop () {
+    if (_stop) {
+      return
+    }
+    _stop = true
+    clearTimeout(_timer)
+    if (_reject) {
+      _reject('stop')
+      _reject = null
+    }
+  }
+  function start () {
+    return loopFn()
+  }
+  function loopFn () {
+    let countdown = timeout
+    return new Promise((resolve, reject) => {
+      let settled = false
+      const done = (res) => {
+        if (settled) {
+          return
+        }
+        settled = true
+        _stop = true
+        clearTimeout(_timer)
+        _reject = null
+        resolve(res)
+      }
+      const fail = (err) => {
+        if (settled) {
+          return
+        }
+        settled = true
+        _stop = true
+        clearTimeout(_timer)
+        _reject = null
+        reject(err)
+      }
+      _reject = fail
+      const nextFn = () => {
+        if (_stop) {
+          fail('stop')
+          return
+        }
+        if (countdown <= 0) {
+          fail('timeout')
+          return
+        }
+        countdown = countdown - spanTime
+        let requestPromise
+        try {
+          requestPromise = requestFn({
+            done (res) {
+              if (_stop || settled) {
+                return
+              }
+              done(res)
+            },
+            fail (err) {
+              if (_stop || settled) {
+                return
+              }
+              fail(err)
+            }
+          })
+        } catch (err) {
+          requestPromise = Promise.reject(err)
+        }
+        Promise.resolve(requestPromise).then(() => {
+          if (_stop || settled) {
+            return
+          }
+          _timer = setTimeout(() => {
+            nextFn()
+          }, spanTime)
+        }, () => {
+          if (_stop || settled) {
+            return
+          }
+          _timer = setTimeout(() => {
+            nextFn()
+          }, spanTime)
+        })
+      }
+      nextFn()
+    })
+  }
+  return {
+    start,
+    stop
+  }
+}