const axios = require('axios')
|
import { Message } from 'element-ui'
|
import { getToken } from '@/utils/auth'
|
function isF() { return typeof arguments[0] === 'function' }
|
|
/* json转formdata（序列化），仅支持一级字面量和字面量数组 */
|
function jsonToFormData(json) {
|
var arr = []
|
var e = encodeURIComponent
|
for (var key in json) {
|
var item = json[key]
|
var res
|
if (item instanceof Array) {
|
res = []
|
item.map(function(o) {
|
res.push(e(key) + '=' + e(o))
|
})
|
res = res.join('&')
|
} else {
|
res = e(key) + '=' + e(item)
|
}
|
arr.push(res)
|
}
|
return arr.join('&')
|
}
|
|
function Http(http_o) {
|
// 返回值 Object
|
// 参数说明
|
// o.baseUrl 这个参数根据传入的基础路径会初始化http中的所有请求方法
|
// ... 待扩展
|
var requestArr = [] // 请求次数
|
return {
|
// 这个对象是包含全部所有的请求
|
postFN(post_o, successCallBack, failCallBack) {
|
// post 方法
|
// 参数说明
|
// post_o.url 指的是请求的路径
|
// post_o.baseChgUrl 可动态切换的接口
|
// params 接受 对象序列化 传参 即 将传入的 params（对象） 参数 序列化为 url 传参的方式如 xxx.com/api?id=1212&name=456
|
// udData Object：即userDefined Data 用户自定义数据，这是一个扩展字段
|
// mockData Object 测试数据
|
Request({
|
method: 'post',
|
header: post_o.header,
|
params: post_o.params || false,
|
url: post_o.url,
|
baseChgUrl: post_o.baseChgUrl, // 动态切换接口
|
udData: post_o.udData, // 预留扩展字段
|
mockData: post_o.mockData // 测试数据
|
}).then(data => {
|
console.log('请求:', post_o.url, data, post_o.params)
|
// 登录失效
|
if (Number(data.code) === 603) {
|
Message({
|
type: 'error',
|
showClose: true,
|
duration: 10000,
|
message: data.msg
|
})
|
setTimeout(() => {
|
sessionStorage.clear()
|
// 未登录，刷新页面出发页面 checkLoginFN跳转登录页面
|
location.reload()
|
}, 800)
|
return
|
}
|
|
// todo 无code时的报错
|
if (Number(data.code) === 100) {
|
// 请求成功
|
isF(successCallBack) && successCallBack(data.data)
|
} else {
|
// 请求失败
|
if (isF(failCallBack)) {
|
failCallBack(data)
|
} else {
|
Message({
|
type: 'error',
|
showClose: true,
|
duration: 10000,
|
message: data.msg
|
})
|
}
|
}
|
})
|
},
|
getFN(get_o, successCallBack, failCallBack) {
|
// get 方法
|
// 参数说明
|
// get_o.url 指的是请求的路径
|
// get_o.baseChgUrl 可动态切换的接口
|
// params 接受 对象序列化 传参 即 将传入的 params（对象） 参数 序列化为 url 传参的方式如 xxx.com/api?id=1212&name=456
|
// udData Object：即userDefined Data 用户自定义数据，这是一个扩展字段
|
// mockData Object 测试数据
|
Request({
|
method: 'get',
|
header: get_o.header,
|
params: get_o.params || false,
|
url: get_o.url,
|
baseChgUrl: get_o.baseChgUrl, // 动态切换接口
|
udData: get_o.udData, // 预留扩展字段
|
mockData: get_o.mockData // 测试数据
|
}).then(data => {
|
console.log('请求:', get_o.url, data, get_o.params)
|
// 登录失效
|
if (Number(data.code) === 603) {
|
Message({
|
type: 'error',
|
showClose: true,
|
duration: 10000,
|
message: data.msg
|
})
|
setTimeout(() => {
|
sessionStorage.clear()
|
// 未登录，刷新页面出发页面 checkLoginFN跳转登录页面
|
location.reload()
|
}, 800)
|
return
|
}
|
|
if (Number(data.code) === 100) {
|
// 请求成功
|
isF(successCallBack) && successCallBack(data.inf)
|
} else {
|
// 请求失败
|
if (isF(failCallBack)) {
|
failCallBack(data)
|
} else {
|
Message({
|
type: 'error',
|
showClose: true,
|
duration: 10000,
|
message: data.msg
|
})
|
}
|
}
|
})
|
}
|
}
|
|
function Request(request_o) {
|
// 总请求方法,这是一个被独立处理出来的方法，因为这个方法是一个比较特殊的方法，首先这个方法不应被暴露出来，
|
// 然后因为根据项目的独特性，最底层的拦截、加密、权限的实现和代码都有所不同，这里应该独立处理，方便以后移植和复用
|
// 这个方法是所有请求方法的底层方法，具有错误码拦截，权限管理（鉴权）等 拦截的功能
|
// 返回值 Object
|
// 参数说明
|
// o.method 请求类型
|
// o.url 请求路径
|
// o.params 请求参数
|
// o.baseUrl 基本路径
|
// udData Object：即userDefined Data 用户自定义数据，这是一个扩展字段
|
// fullData 这个字段为真的话，将返回 服务端返回的所有数据，默认返回data
|
// 20210303 long 优化请求结束loading 将noLoading不计算如请求数组
|
if (request_o && (!request_o.udData || !request_o.udData.noLoading)) {
|
requestArr.push(request_o) // 将请求加入数组
|
}
|
// requestArr.push(request_o) // 将请求加入数组
|
if (http_o.startRequest) {
|
http_o.startRequest(http_o, request_o) // 事件委托,请求之前
|
}
|
return new Promise((resolve, reject) => {
|
// 添加切换调用接口域名功能 -- start
|
var ajaxUrl
|
if (request_o.baseChgUrl) {
|
ajaxUrl = request_o.baseChgUrl + request_o.url
|
} else {
|
ajaxUrl = http_o.baseUrl + request_o.url
|
}
|
// 添加切换调用接口域名功能 -- end
|
|
// 处理传参 -- start
|
// 将token放到params里
|
var noToken = request_o.udData && request_o.udData.noToken // noToken则不传token
|
var adminToken = getToken()
|
// 放到连接后得请求参数
|
|
var urlEncodes = {}
|
if (adminToken && !noToken) {
|
urlEncodes = { adminToken: adminToken }
|
// ...urlEncodes,
|
}
|
// // 将请求参数放到链接后面
|
var paramsUrl = urlEncode(urlEncodes)
|
if (!/\?/.test(ajaxUrl)) {
|
paramsUrl = paramsUrl.replace('&', '?')
|
}
|
ajaxUrl = ajaxUrl + paramsUrl
|
|
// console.log(ajaxUrl)
|
// console.log(request_o.params)
|
// 处理传参 -- end
|
|
// request_o.params.adminToken = adminToken
|
|
var requestConfig = {
|
// 請求對象
|
method: request_o.method,
|
url: ajaxUrl,
|
data: request_o.params,
|
header: request_o.header || {
|
'Content-type': 'application/x-www-form-urlencoded' // 默认值
|
}
|
}
|
|
// 转formData
|
if (requestConfig.header['Content-type'] === 'application/x-www-form-urlencoded') {
|
requestConfig.data = requestConfig.data ? jsonToFormData(requestConfig.data) : {}
|
}
|
|
// 使用测试数据
|
if (http_o.isMock) {
|
console.log('开始模拟等待800ms')
|
// 模拟请求
|
if (http_o.httpEventCode && http_o.httpEventCode['code200']) {
|
http_o.httpEventCode['code200'](request_o.mockData) // 事件委托,处理错误
|
}
|
if (http_o.endRequest) {
|
http_o.endRequest({ ...http_o, ...request_o.mockData }) // 事件委托,请求之前
|
}
|
setTimeout(() => {
|
console.log('结束模拟等待800ms')
|
resolve(request_o.mockData)
|
|
// 无论成功或者失败都会执行
|
requestArr.splice(0, 1)
|
if (requestArr.length === 0) {
|
// 批量请求全部完成
|
if (http_o.concurrentRequests) {
|
http_o.concurrentRequests()
|
}
|
}
|
}, 800)
|
return
|
}
|
|
axios(requestConfig).then((res) => {
|
if (http_o.httpEventCode && http_o.httpEventCode['code' + res.status]) {
|
http_o.httpEventCode['code' + res.status](res) // 事件委托,处理错误
|
}
|
if (http_o.endRequest) {
|
http_o.endRequest({ ...http_o, ...res }) // 事件委托,请求之前
|
}
|
if (http_o.defindFlow) {
|
// 自定义流程
|
resolve(http_o.defindFlow({ requestConfig: requestConfig, res: res, Request: Request }))
|
}
|
if (request_o.udData && request_o.udData.fullData === true) {
|
// 如果这里的fullData 为真的话,将返回服务器返回的所有数据
|
resolve(res)
|
}
|
resolve(res.data)
|
}).catch((err) => {
|
// console.log('异步报错：',err);
|
var code
|
err.response && (code = err.response.status) // 请求错误码
|
if (http_o.httpEventCode && http_o.httpEventCode['code' + code]) {
|
http_o.httpEventCode['code' + code](err) // 事件委托,处理错误
|
}
|
reject(err)
|
}).finally(() => {
|
// 无论成功或者失败都会执行
|
requestArr.splice(0, 1)
|
if (requestArr.length === 0) {
|
// 批量请求全部完成
|
if (http_o.concurrentRequests) {
|
http_o.concurrentRequests()
|
}
|
}
|
})
|
})
|
}
|
|
// 对象转url参数
|
function urlEncode(param, key, encode) {
|
if (param == null) return ''
|
var paramStr = ''
|
var t = typeof (param)
|
if (t === 'string' || t === 'number' || t === 'boolean') {
|
paramStr += '&' + key + '=' + ((encode == null || encode) ? encodeURIComponent(param) : param)
|
} else {
|
for (var i in param) {
|
var k = key == null ? i : key + (param instanceof Array ? '[' + i + ']' : '.' + i)
|
paramStr += urlEncode(param[i], k, encode)
|
}
|
}screenLeft
|
return paramStr
|
}
|
}
|
export { Http }
|
