front-end/mallApp/src/plugins/luch-request_0.0.7/request.js

/**
 * Request 0.0.7
 * @Class uni-app request网络请求库
 * @Author lu-ch
 * @Date 2019-07-11
 * @Email webwork.s@qq.com
 * http://ext.dcloud.net.cn/plugin?id=392
 * **/
import qs from 'qs'
import constant from '@/constant/index'
import { TOKEN_STORAGE_KEY } from '@/constant/storageKeys'
// import common from '@/utils/common'
import { parse } from '@/utils/util'
import store from '@/store'

const Base64 = require('js-base64').Base64
class Request {
	config = {
		// #ifdef H5
		// baseUrl: process.env.NODE_ENV == 'development' ? '/api' : constant.hostUrl,
		baseUrl: constant.hostUrl,
		// #endif
		// #ifdef MP-WEIXIN
		baseUrl: constant.hostUrl,
		// #endif
		header: {
			'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8'
		},
		data: {},
		method: 'GET',
		dataType: 'json',  /* 如设为json，会对返回的数据做一次 JSON.parse */
		responseType: 'text',
		success() { },
		fail() { },
		complete() { }
	}

	static isAbsoluteUrl(url) { /* 判断url是否为绝对路径 */
		return /(http|https):\/\/([\w.]+\/?)\S*/.test(url)
	}

	static posUrl(url) { /* 兼容旧方法名 */
		return Request.isAbsoluteUrl(url)
	}

	interceptor = {
		request: (f) => {
			if (f && typeof f === 'function') {
				this.requestBeforeFun = f
			}
		},
		response: (f) => {
			if (f && typeof f === 'function') {
				this.requestComFun = f
			}
		}
	}

	requestBeforeFun(config, cancel) {
		let token = ''
		try {
			const st = uni.getStorageSync(TOKEN_STORAGE_KEY)
			if (st) {
				token = st
			}
		} catch (e) {
			console.error(e, '获取token异常')
		}
		config.header = {
			...config.header
		}
		// 将token 放入header
		if (token) {
			config.header['token'] = token
		}
		// const token = uni.getStorageSync('token')
		// config.data = JSON.stringify(config.data);
		// 统一使用 config.header，避免混用 headers
		// if (token) { // 判断是否存在token，如果存在的话，则每个http header都加上token
		// 	// axios.defaults.headers.common['token'] = token;
		// 	config.headers.token = token
		// }
		// config.headers.HkdsRequestFrom = window.location.href
		// config.header.userRegion = Base64.encode(uni.getStorageSync('userRegion')) || null
		// config.header['x-client-hash'] = uni.getStorageSync('client_hash') || null
		// const userRegion = Base64.encode(uni.getStorageSync('userRegion')) || null
		// if (userRegion) {
		// 	config.header.userRegion = userRegion
		// }
		const account = uni.getStorageSync('account') || null
		if (account) {
			config.header['account'] = account
		}
		// const source = uni.getStorageSync('source') || null
		// if (source) {
		// 	config.header['source'] = source
		// }
		if (constant.source == 'mobile') {
			const shopId = uni.getStorageSync('shopId') || 0
			if (shopId) {
				config.header['shopId'] = shopId
			}
		}
		if (config.config.loading) {
			uni.showLoading({
				title: '',
				mask: true
			})
		}
		return config
	}

	requestComFun(response) {
		if (response.config.config.loading) {
			uni.hideLoading()
		}
		// const client_hash = response.header.client_hash || null
		// console.log('X-Client-Hash', response.header['X-Client-Hash'])
		// if (client_hash) {
		// 	uni.setStorageSync('client_hash', client_hash)
		// }
		return response
	}

	/**
	 * 处理鉴权失效后的通用逻辑
	 * @param {string} currentRoute 当前页面路由
	 */
	handleAuthExpired(currentRoute) {
		uni.removeStorageSync(TOKEN_STORAGE_KEY)
		store.commit('setLoginInfo', {})
		uni.showToast({
			title: '加载中...',
			icon: 'none',
			mask: true
		})
		const account = uni.getStorageSync('account')
		if (account) {
			setTimeout(() => {
				uni.reLaunch({
					url: '/' + currentRoute + '?account=' + account
				})
			}, 1000)
		} else {
			setTimeout(() => {
				uni.reLaunch({
					url: `/pages/home/recent`
				})
			}, 1000)
		}
	}

	setConfig(f) {
		this.config = f(this.config)
	}

	/**
	 * 发送 HTTP 请求
	 * @param {Object} options uni.request 的参数子集
	 * @param {Object} config 业务控制参数 { loading?: boolean, hideError?: boolean }
	 */
	request(options = {}, config) {
		options.baseUrl = options.baseUrl || this.config.baseUrl
		options.dataType = options.dataType || this.config.dataType
		options.url = Request.posUrl(options.url) ? options.url : (options.baseUrl + options.url)
		options.data = qs.stringify(options.data) || {}
		options.header = options.header || this.config.header
		options.method = options.method || this.config.method
		return new Promise((resolve, reject) => {
			let next = true
			let _config = null
			options.complete = (response) => {
				const statusCode = response.statusCode
				response.config = _config
				//   if(config.method === 'get') {
				// 	response.config.config = config
				//   }else if(config.method === 'post'){
				// 	response.config.config.config = config
				//   }
				response.config.config = config
				response = this.requestComFun(response)
				// 全局忽略错误，在单个请求里面自行处理
				if (config.hideError) {
					resolve(response.data)
					return
				}
				if (statusCode === 200) { // 成功
			
					
					if (response.data.code === 1) {
						resolve(response.data)
					} else {
						let currentPages = getCurrentPages()[0].route
						// 返回错误信息
						if (response.data.code == 0) {
							if (!config.hideError) {
								// this.$msg(response.data.msg)
								uni.showToast({
									title: response.data.msg,
									icon: 'none',
									mask: true
								})
							}
							reject(response.data)
						} else if (response.data.code && response.data.code == -1) {
							// this.handleAuthExpired(currentPages)
							// -1 仅作为业务失败返回，不触发自动登出
							resolve(response.data)
						} else if (response.data.code == 2) {
							this.handleAuthExpired(currentPages)
						} else {
							console.log('response.data', response.data)
							if (!config.hideError) {
								// this.$msg(response.data.msg)
								uni.showToast({
									title: response.data.msg,
									icon: 'none',
									mask: true
								})
							}
							reject(response.data)
						}
					}
				} else {
					reject(response)
				}
			}
			const cancel = (t = 'handle cancel') => {
				const err = {
					errMsg: t,
					config: afC
				}
				reject(err)
				next = false
			}
			const afC = { ...this.config, ...options, config: config }
			_config = { ...afC, ...this.requestBeforeFun(afC, cancel) }
			if (!next) return
			uni.request(_config)
		})
	}

	get(url, data = {}, options = {}, config = {}) {
		const account = uni.getStorageSync('account') || 0;
		const hdId = uni.getStorageSync('hdId') || 0;
		if(account != 0 && hdId != 0){
			options.url = url + parse({...data,'account':account,'hdId':hdId})
		} else {
			// console.log("-----get----- data: ", data);
			// 判断data中有无account和hdId
			if(data.account && data.hdId){
				options.url = url + parse({...data})
			} else if(data.account && !data.hdId){
				options.url = url + parse({...data, 'hdId':hdId})
			} else if(!data.account && data.hdId){
				options.url = url + parse({...data, 'account':account})
			} else {
				options.url = url + parse({...data, 'account':account, 'hdId':hdId})
			}
		}
		options.data = {}
		options.method = 'GET'
		return this.request(options, config)
	}

	post(url, data = {}, options = {}, config = {}) {
		const account = uni.getStorageSync('account') || 0;
		const hdId = uni.getStorageSync('hdId') || 0;
		if(account != 0 && hdId != 0){
			options.url = url+'?account='+account+'&hdId='+hdId
		} else {
			//console.log("-----post----- data: ", data);
			// 判断data中有无account和hdId
			if(data.account && data.hdId){
				options.url = url + parse({...data, 'account':data.account, 'hdId':data.hdId})
			} else if(data.account && !data.hdId){
				options.url = url + parse({...data, 'hdId':hdId})
			} else if(!data.account && data.hdId){
				options.url = url + parse({...data, 'account':account})
			} else {
				options.url = url + parse({...data, 'account':account, 'hdId':hdId})
			}
		}
		options.data = data
		options.method = 'POST'
		return this.request(options, config)
	}
}
export default new Request()