@aochuang/common 1.0.1 → 1.0.126

package/utils/time-task.js

@@ -0,0 +1,60 @@
+/**
+ * 创建定时任务
+ * @params { Function } execFn - 执行任务的异步函数
+ * @params { Function } resultFn - 获取结果的函数
+ * @params { Function } callbackFn - 执行完毕回调函数
+ * @params { Number } spanTime - 检查结果间隔秒数
+ * @params { Number } timeout - 超时时间，3分钟超时
+*/
+export function createTimeTask (execFn, resultFn, callbackFn, spanTime = 1000 * 5, timeout = 1000 * 60 * 3) {
+  let timer = null
+  let canceld = false
+  if (typeof callbackFn === 'number') {
+    spanTime = callbackFn
+    callbackFn = null
+  }
+  let startTime = Date.now()
+  const ps = new Promise((resolve, reject) => {
+    if (!execFn || !resultFn) {
+      throw new Error('缺少必须参数')
+    }
+    const checkFn = (result) => {
+      clearTimeout(timer)
+      if (canceld) {
+        return
+      }
+      if (Date.now() - startTime > timeout) {
+        reject('timeout')
+        return
+      }
+      Promise.all([resultFn(result)]).then(rs => rs[0]).then((rs) => {
+        if (rs === null) {
+          timer = setTimeout(() => {
+            checkFn(result)
+          }, spanTime)
+        } else {
+          if (callbackFn) {
+            const rrs = callbackFn(rs)
+            if (rrs && rrs.then) {
+              rrs.then(resolve, reject)
+            } else {
+              resolve(rrs)
+            }
+          } else {
+            resolve()
+          }
+        }
+      }, reject)
+    }
+    execFn().then((rs) => {
+      timer = setTimeout(() => {
+        checkFn(rs)
+      }, spanTime)
+    }, reject)
+  })
+  ps.cancel = () => {
+    canceld = true
+    clearTimeout(timer)
+  }
+  return ps
+}

package/utils/url.js

@@ -0,0 +1,46 @@
+import qs from 'query-string'
+
+export function buildUrl (url, params) {
+  let nextParams = buildUrlParams(params)
+  if (nextParams) {
+    if (url.indexOf('?') >= 0) {
+      return url + '&' + nextParams
+    } else {
+      return url + '?' + nextParams
+    }
+  } else {
+    return url
+  }
+}
+
+export function buildUrlParams (params) {
+  return qs.stringify(params, {
+    arrayFormat: 'comma'
+  })
+}
+
+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 {
+    if (url.indexOf('?') >= 0) {
+      url = url.substr(url.indexOf('?') + 1)
+    }
+    return qs.parse(url, options)
+  }
+}

package/utils/util.js

@@ -1,3 +1,5 @@
+import mergeOpts from 'merge-options'
+
 /**
  * 获取唯一字符串
 */
@@ -7,6 +9,419 @@ export function unique (prefix = 'unique_') {
   return (prefix || '') + _unique
 }
 
+/**
+ * 批量合并
+*/
+export function batchMerge (source, data) {
+  for (const i in source) {
+    const nv = (typeof data === 'function' ? data(source[i]) : data) || {}
+    source[i] = {
+      ...source[i],
+      ...nv
+    }
+  }
+  return source
+}
+
+/**
+ * 根据给定的正则匹配路径的符合规则的部分
+*/
+export function getPathByRegex (fullPath, regex) {
+  if (!fullPath || !regex) {
+    return
+  }
+  fullPath = fullPath.split('?')[0] // 去掉参数部分，vue的路由正则不支持参数，目前传了参数的是内嵌模式_mode
+  while (fullPath) {
+    const match = fullPath.match(regex)
+    if (match) {
+      return match[0]
+    } else {
+      fullPath = fullPath.substr(0, fullPath.lastIndexOf('/'))
+    }
+  }
+}
+
+/**
+ * 表格导出工具
+*/
+
+export function toolXlsFilte (data, fileName) {
+  const blob = new Blob([data])
+  if ('download' in document.createElement('a')) { // 非IE下载
+    const elink = document.createElement('a')
+    elink.download = fileName
+    elink.style.display = 'none'
+    elink.href = URL.createObjectURL(blob)
+    document.body.appendChild(elink)
+    elink.click()
+    URL.revokeObjectURL(elink.href) // 释放URL 对象
+    document.body.removeChild(elink)
+  } else { // IE10+下载
+    navigator.msSaveBlob(blob, fileName)
+  }
+}
+
+/**
+ * base64转换为文件
+ */
+export function dataURLtoFile (dataurl, filename) {
+  const arr = dataurl.split(',')
+  const mime = arr[0].match(/:(.*?);/)[1]
+  const bstr = atob(arr[1])
+  let n = bstr.length
+  const u8arr = new Uint8Array(n)
+  while (n--) {
+    u8arr[n] = bstr.charCodeAt(n)
+  }
+  return new File([u8arr], filename, { type: mime })
+}
+
+/**
+ * 格式化文件尺寸
+*/
+export function formatBytes (bytes) {
+  if (bytes === undefined || bytes === null) {
+    return
+  }
+  var b = 2
+  if (bytes === 0) {
+    return '0 B'
+  }
+  var c = 1024
+  var d = b || 2
+  var e = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
+  var f = Math.floor(Math.log(bytes) / Math.log(c))
+  return parseFloat((bytes / Math.pow(c, f)).toFixed(d)) + ' ' + e[f]
+}
+
+/**
+ * 字节转化为指定单位大小
+*/
+export function bytesToUnit (bytes, unit, toFixed = 2) {
+  if (!bytes) {
+    return 0
+  }
+  const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
+  if (!units.includes(unit)) {
+    throw new Error('单位不合法')
+  }
+  const index = units.indexOf(unit)
+  for (let i = 0; i < index; i++) {
+    bytes = bytes / 1024
+  }
+  if (toFixed === null) {
+    return bytes
+  }
+  return bytes.toFixed(toFixed)
+}
+
+export function mergeOptions (...args) {
+  return mergeOpts.apply(null, args)
+}
+
+/**
+ * 创建开发测试api
+*/
+export function createTestApi (name, fn) {
+  if (!window.DEVELOP_TEST_API) {
+    window.DEVELOP_TEST_API = {}
+  }
+  window.DEVELOP_TEST_API[name] = fn
+}
+
+/**
+ * 创建一个动态列
+*/
+export function createDynamicColumn (fileName, title, moduleName) {
+  return {
+    accountId: unique(),
+    columnName: fileName,
+    columnType: 'base-column',
+    id: unique(),
+    moduleName: moduleName,
+    show: true,
+    sortIndex: 1,
+    _custom: true,
+    title: title
+  }
+}
+
+export function createPromise () {
+  let psReject, psResolve
+  const ps = new Promise((resolve, reject) => {
+    psResolve = resolve
+    psReject = reject
+  })
+  ps.reject = psReject
+  ps.resolve = psResolve
+  return ps
+}
+
 export function isEmpty (value) {
   return value === null || value === undefined || value === ''
-}
+}
+
+/**
+ * 轮循加载
+*/
+export function createPollRequest (requestFn, spanTime = 5 * 1000, timeout = 60 * 1000) {
+  let _stop = false
+  let _timer = null
+  function stop () {
+    _stop = true
+    clearTimeout(_timer)
+  }
+  function start () {
+    return loopFn()
+  }
+  function loopFn () {
+    let countdown = timeout
+    return new Promise((resolve, reject) => {
+      const nextFn = () => {
+        if (_stop) {
+          reject('stop')
+          return
+        }
+        if (countdown <= 0) {
+          reject('timeout')
+          return
+        }
+        countdown = countdown - spanTime
+        requestFn({
+          done (res) {
+            stop()
+            resolve(res)
+          },
+          fail (err) {
+            stop()
+            reject(err)
+          }
+        }).then(() => {
+          _timer = setTimeout(() => {
+            nextFn()
+          }, spanTime)
+        }, reject)
+      }
+      nextFn()
+    })
+  }
+  return {
+    start,
+    stop
+  }
+}
+
+/**
+ * 将多个请求合并为一个请求
+ * @params { String } id - 请求的唯一id
+ * @params { Function } requestFn - 请求函数 
+*/
+export function createThrottleRequest (requestFn, idField = 'id') {
+  let cacheMap = {}
+  let loadMap = {}
+  let timer = null
+	return (id) => {
+    const ps = createPromise()
+    cacheMap[id] = ps
+    loadMap[id] = true
+    clearTimeout(timer)
+    timer = setTimeout(() => {
+      const keys = Object.keys(loadMap)
+      loadMap = {}
+      requestFn(keys).then(rs => {
+        if (rs && rs.length) {
+          rs.forEach(v => {
+            cacheMap[v[idField]]._execed = true
+            cacheMap[v[idField]].resolve(v)
+          })
+        }
+        keys.forEach(id => {
+          if (!cacheMap[id]._execed) {
+            // 如果没有返回表示没有找到数据
+            cacheMap[id].reject(new Error('未找到数据'))
+          }
+        })
+        return rs
+      }, err => {
+        keys.forEach(id => {
+          cacheMap[id]._execed = true
+          cacheMap[id].reject(err)
+        })
+      }).finally(() => {
+        cacheMap = {}
+      })
+    }, 20)
+    return ps
+  }
+}
+
+/**
+ * 合并请求，上面createThrottleRequest将被作废
+ * @param { String } groupName 分组名称
+ * @param { Function } mergeParamsMethod 合并参数方法
+ * @param { Function } sendRequestMethod 发送请求方法
+ * @param { Function } assignResultMethod 分配结果方法
+ * @example
+ * return mergeRequest('getAccountUnreadMessageNumMethod', (nextParams) => {
+ * 	if (!nextParams.wechatAccountIds) {
+ * 		nextParams.wechatAccountIds = []
+ * 	}
+ * 	nextParams.wechatAccountIds = [].concat(nextParams.wechatAccountIds, params.wechatAccountIds)
+ * 	return nextParams
+ * }, (nextParams) => {
+ * 	return getAccountUnreadMessageNum(nextParams)
+ * }, (rs) => {
+ * 	const currentRs = (rs.data || []).find(v => v.wxAccountId === params.wechatAccountIds[0])
+ * 	if (currentRs) {
+ * 		return Promise.resolve({
+ * 			code: rs.code,
+ * 			data: [currentRs],
+ * 			msg: rs.msg
+ * 		})
+ * 	} else {
+ * 		return Promise.reject(`未找到${params.wechatAccountIds}统计数据`)
+ * 	}
+ * })
+*/
+const mergeRequestMap = {}
+let mergeRequestTimer = null
+export function mergeRequest (groupName, mergeParamsMethod, sendRequestMethod, assignResultMethod) {
+	const ps = createPromise()
+	if (typeof groupName !== 'string' || typeof mergeParamsMethod !== 'function' || typeof sendRequestMethod !== 'function' || typeof assignResultMethod !== 'function') {
+		ps.reject(new Error('参数类型不正确'))
+	} else {
+		if (!mergeRequestMap[groupName]) {
+			mergeRequestMap[groupName] = {
+				params: {},
+				promise: createPromise()
+			}
+		}
+		mergeRequestMap[groupName].params = mergeParamsMethod(mergeRequestMap[groupName].params)
+		clearTimeout(mergeRequestTimer)
+		mergeRequestTimer = setTimeout(() => {
+			sendRequestMethod(mergeRequestMap[groupName].params).then((rs) => {
+				mergeRequestMap[groupName].promise.resolve(rs)
+			}, err => {
+				mergeRequestMap[groupName].promise.reject(err)
+			}).finally(() => {
+				delete mergeRequestMap[groupName]
+			})
+		}, 30)
+		mergeRequestMap[groupName].promise.then(rs => {
+			return assignResultMethod(rs).then(ps.resolve, ps.reject)
+		}, err => {
+			pr.reject(err)
+		})
+	}
+	return ps
+}
+
+/**
+ * 重试请求，后端请求频繁时，使用此方法降低频率
+*/
+export const retryRequest = (() => {
+	const retryRequestMap = {}
+	return {
+    /**
+     * @param { String } requestId - 首次请求的id，第一次发起请求需要传一个id，后续重试的时候需要带上这个id穿透使用
+     * @param { String } requestUrl - 请求的url地址，相同的地址，会做分组排队请求
+     * @param { Function } requestFn - 重试的请求方法
+    */
+		add (requestId, requestUrl, requestFn) {
+			if (!requestId || !requestUrl || !requestFn) {
+				throw new Error('缺少必须参数')
+			}
+			if (!retryRequestMap[requestUrl]) {
+				retryRequestMap[requestUrl] = {
+					requestList: [],
+					promiseMap: {},
+					checkTimeout: null
+				}
+			}
+			let ps = retryRequestMap[requestUrl].promiseMap[requestId]
+			if (!ps) {
+				ps = createPromise()
+				retryRequestMap[requestUrl].promiseMap[requestId] = ps
+			}
+			const requestItem = {
+				status: 'normal',
+				requestId,
+				requestFn: (index) => {
+					let isEnd = false
+					const rs = requestFn(index, (err) => {
+						ps.reject(err)
+						isEnd = true
+						this.clear(requestId, requestUrl)
+					})
+					if (rs && rs.then) {
+						requestItem.status = 'loading'
+						rs.then((res) => {
+							ps.resolve(res)
+							this.clear(requestId, requestUrl)
+							this.check(requestUrl)
+						}, err => {
+							requestItem.status = 'complete'
+							this.check(requestUrl)
+						})
+					} else {
+						requestItem.status = 'complete'
+            // 如果结束了，需要清理一下剩下的requestId排队请求
+            if (isEnd) {
+							this.clear(requestId, requestUrl)
+            }
+            // 继续其他非当前requestId的相同requestUrl的请求
+            this.check(requestUrl)
+					}
+				}
+			}
+			retryRequestMap[requestUrl].requestList.push(requestItem)
+			this.check(requestUrl)
+		},
+		check (requestUrl) {
+			if (!requestUrl) {
+				throw new Error('缺少必须参数')
+			}
+			if (!retryRequestMap[requestUrl]) {
+				return
+			}
+			if (!retryRequestMap[requestUrl].requestList) {
+				return
+			}
+			retryRequestMap[requestUrl].requestList.some((v, i) => {
+				if (v.status === 'normal') {
+					clearTimeout(retryRequestMap[requestUrl].checkTimeout)
+					retryRequestMap[requestUrl].checkTimeout = setTimeout(() => {
+						v.requestFn(i)
+					}, 500)
+					return true
+				}
+			})
+		},
+		get (requestId, requestUrl) {
+			if (!requestId || !requestUrl) {
+				throw new Error('缺少必须参数')
+			}
+			if (!retryRequestMap[requestUrl] || !retryRequestMap[requestUrl].promiseMap) {
+				return
+			}
+			return retryRequestMap[requestUrl].promiseMap[requestId]
+		},
+		clear (requestId, requestUrl) {
+			if (!requestId || !requestUrl) {
+				throw new Error('缺少必须参数')
+			}
+			if (retryRequestMap[requestUrl]) {
+				if (retryRequestMap[requestUrl].promiseMap) {
+					delete retryRequestMap[requestUrl].promiseMap[requestId]
+				}
+				if (retryRequestMap[requestUrl].requestList) {
+					for (let i = retryRequestMap[requestUrl].requestList.length - 1; i >= 0; i--) {
+						if (retryRequestMap[requestUrl].requestList[i].requestId === requestId) {
+							retryRequestMap[requestUrl].requestList.splice(i, 1)
+						}
+					}
+				}
+			}
+		}
+	}
+})()