zdqy_firm_former/src/utils/request.js

/**
 * 和服务端进行交互
 *  它封装了全局 request拦截器、respone拦截器、统一的错误处理、统一做了超时，baseURL设置等
 * <pre>
 * 作者:hugh zhuang
 * 邮箱:3378340995@qq.com
 * 日期:2015-11-02-下午3:29:34
 * 版权:广州流辰信息技术有限公司
 * </pre>
 */
import axios from 'axios'
import { Message, MessageBox } from 'element-ui'
import store from '@/store'
import router from '@/router'
// Internationalization 国际化
import I18n from '@/utils/i18n'
import Utils from '@/utils/util'
import Ids from 'ids'
import setting from '@/setting.js'
import { encryptByAes } from '@/utils/encrypt'

// 验权
import { getToken, updateToken, removeRefreshToken } from '@/utils/auth'
import { refreshAccessToken } from '@/api/oauth2/user'

import { showFullScreenLoading, tryHideFullScreenLoading } from './loading'

import requestState from '@/constants/state'
import { BASE_API, BASE_GATEWAY_API } from '@/api/baseUrl'
import {
  HEADER_TOKEN_KEY,
  HEADER_SYSTEM_ID,
  HEADER_TENANT_ID,
  MULTIPLE_DOMAIN,
  API_DOMAIN_NAMES,
  ENCRYPT_GET_PARAMS
} from '@/constant'

// 请求超时（timeout）时间
const TIMEOUT = setting.requestTimeout

/**
 * 创建axios实例
 */
const service = axios.create({
  // request timeout
  timeout: TIMEOUT,
  // 跨域安全策略
  withCredentials: true,
  headers: {
    'Cache-Control': 'no-cache',
    'Content-Type': 'application/json;charset=utf-8'
  }
})

// 是否正在刷新的标记
let isRefreshing = false
// 重试队列，每一项将是一个待执行的函数形式
let requests = []
// 取消请求
let cancelRequest = false

let requestCount = 0

/**
 * 请求(request)拦截器
 *
 * get请求，统一参数放在params里面，后台对应只有@RequestParam
 * `params`是即将与请求一起发送的 URL 参数，必须是一个无格式对象(plain object)或 URLSearchParams 对象
 *
 * post请求，统一参数放在data里面——json格式，后台对应@RequestBody ,其他 后台对应@RequestParam
 * `data` 是作为请求主体被发送的数据
 * 只适用于这些请求方法 'PUT', 'POST', 和 'PATCH'
 * 在没有设置 `transformRequest` 时，必须是以下类型之一：
 * - string, plain object, ArrayBuffer, ArrayBufferView, URLSearchParams
 * - 浏览器专属：FormData, File, Blob
 * - Node 专属： Stream
 * post 请求 `params` 这个同get 但要注意 后台对应@RequestParam 请求的`Content-Type`是 application/x-www-form-urlencoded 用 qs.stringify 去构造数据
 */
service.interceptors.request.use(
  async (config) => {
    console.log('config===>', config)
    if (!config.baseURL) {
      config.baseURL = BASE_API(parseInt(requestCount / 5, 10))
      if (MULTIPLE_DOMAIN) {
        requestCount >= (API_DOMAIN_NAMES.length - 1) * 5
          ? (requestCount = 0)
          : requestCount++
      }
    }
    if (config.gateway) {
      config.baseURL = BASE_GATEWAY_API()
      console.log(BASE_GATEWAY_API());

    }
    if (config.url == '/jyxt/SampleProcess/getSampleList') {
      console.log('aaaaa');

      config.baseURL = ''
    }

    config.isLoading =
      config.isLoading !== undefined && config.isLoading !== null
        ? config.isLoading
        : false
    if (config.isLoading) {
      showFullScreenLoading(config.loading)
    }
    // 如果超时不对还原默认超时时间
    if (config.timeout !== TIMEOUT) {
      config.timeout = TIMEOUT
    }
    // 只设置当前的时间设置以设置为准
    if (Utils.isNotEmpty(config.overtime)) {
      config.timeout = config.overtime
    }
    // 防止缓存，参数加密
    if (config.method.toUpperCase() === 'GET') {
      if (ENCRYPT_GET_PARAMS) {
        config.params = {
          _p: Utils.isNotEmpty(config.params)
            ? encryptByAes(JSON.stringify(config.params), 'get')
            : undefined,
          _t: new Ids([32, 36, 1]).next()
        }
      } else {
        config.params = {
          ...config.params,
          _t: new Ids([32, 36, 1]).next()
        }
      }
    }

    // 判断是否需要token
    if (setting.whiteRequestList.indexOf(config.url) !== -1) {
      return config
    }
    config.headers[HEADER_TOKEN_KEY] = getToken()
    // 系统ID
    if (store && store.getters.systemid) {
      config.headers[HEADER_SYSTEM_ID] = store.getters.systemid
    }
    // 租户ID
    if (store && store.getters.tenantid) {
      config.headers[HEADER_TENANT_ID] = store.getters.designTenantid
        ? store.getters.designTenantid
        : store.getters.tenantid
    }
    // 租户模式
    if (store && store.getters.isTenantOpen) {
      config.headers[HEADER_TENANT_ID] = store.getters.designTenantid
        ? store.getters.designTenantid
        : store.getters.tenantid
    }
    return config
  },
  (error) => {
    tryHideFullScreenLoading()
    // Do something with request error
    // for debug
    Utils.log.error('request' + error)
    Promise.reject(error)
  }
)

/**
 * 响应(respone)拦截器
 */
service.interceptors.response.use(
  (response) => {
    // 临时关闭了保存等待的取消功能
    tryHideFullScreenLoading()

    const dataAxios = response.data
    const { state, message, cause } = dataAxios
    // 获取接口保留参数，用于部分接口的后续请求
    const { retainData } = response.config
    if (response.config.responseType === 'arraybuffer') {
      // 刷新tonken
      return response
    }
    // 如果没有 state 代表这不是项目后端开发的接口 比如可能是请求最新版本,或者是请求的数据，或者是
    if (state === undefined) {
      const msg = '接口异常，没有返回[state]参数</br>' + response.config.url
      Message.closeAll()
      Message({
        message: `${msg}`,
        type: 'error',
        showClose: true,
        dangerouslyUseHTMLString: true,
        duration: 10000
      })
      return
    }
    // state为200是正确的请求 或者 验证码问题,或者警告类型的错误 自行处理
    if (
      state === requestState.SUCCESS ||
      state === requestState.UNSUPORT ||
      state === requestState.WARNING ||
      state === requestState.WARN
    ) {
      return { ...dataAxios, retainData }
    }
    // 处理刷新tonken问题,说明token过期了,刷新token
    if (state === requestState.TOKEN_EXPIRED) {
      const config = response.config
      if (!isRefreshing) {
        isRefreshing = true
        return refreshAccessToken()
          .then((res) => {
            const data = res.data
            updateToken(data)
            const token = getToken()
            config.headers[HEADER_TOKEN_KEY] = token
            // 已经刷新了token，将所有队列中的请求进行重试
            requests.forEach((cb) => cb(token))
            requests = []
            return service(config)
          })
          .catch((res) => {
            console.error('refreshtoken error =>', res)
            removeRefreshToken()
            window.location.href = this.$baseUrl
          })
          .finally(() => {
            isRefreshing = false
          })
      } else {
        // 正在刷新token，将返回一个未执行resolve的promise
        return new Promise((resolve) => {
          // 将resolve放进队列，用一个函数形式来保存，等token刷新后直接执行
          requests.push((token) => {
            config.headers[HEADER_TOKEN_KEY] = token
            resolve(service(config))
          })
        })
      }
      // 6020201:非法的token;6020202:其他客户端登录了;6020301:Token 过期了;
    } else if (
      state === requestState.ILLEGAL_TOKEN ||
      state === requestState.OTHER_CLIENTS
    ) {
      // if (!cancelRequest) {
      cancelRequest = false
      MessageBox.confirm(
        I18n.t('error.logout.message'),
        I18n.t('error.logout.title'),
        {
          confirmButtonText: I18n.t('error.logout.confirmButtonText'),
          cancelButtonText: I18n.t('error.logout.cancelButtonText'),
          type: 'warning'
        }
      )
        .then(() => {
          store
            .dispatch('ibps/account/fedLogout')
            .then(() => {
              // 终止所有请求
              cancelRequest = true
              router.push({
                name: 'login'
              })
            })
            .catch(() => {
              cancelRequest = false
            })
        })
        .finally(() => {
          cancelRequest = false
        })
      // }
      return Promise.reject(new Error(message))
    } else {
      // 错误处理
      let errorMsg = ''
      if (Utils.isNotEmpty(message)) {
        // 有错误消息
        errorMsg = Utils.isNotEmpty(dataAxios.cause)
          ? I18n.t('error.messageCause', {
            message,
            cause: dataAxios.cause
          })
          : I18n.t('error.message', {
            message
          })
      } else if (Utils.isNotEmpty(cause)) {
        // 只有错误原因
        errorMsg = I18n.t('error.cause', {
          cause
        })
      } else if (I18n.te('error.status.' + state)) {
        // 有错误编码
        errorMsg = I18n.t('error.status.' + state)
      } else {
        // 未知
        errorMsg =
          message ||
          I18n.t('error.unknown', {
            state
          })
      }
      Message.closeAll()
      Message({
        message: `${errorMsg}`,
        type: 'error',
        showClose: true,
        dangerouslyUseHTMLString: true,
        duration: 5 * 1000
      })
      const err = new Error(errorMsg)
      err.state = state
      err.cause = cause
      return Promise.reject(err)
    }
  },
  (error) => {
    // 异常处理
    tryHideFullScreenLoading()
    // for debug
    console.error('request-error', error)
    if (error && error.response) {
      error.message = I18n.t('error.status.' + error.response.status, {
        url: error.response.config.url
      })
    } else {
      error.state = 500
      // '服务器君开小差了，请稍后再试'
      error.message = I18n.t('error.network')
    }
    Message.closeAll()
    Message({
      message: error.message || I18n.t('error.network'),
      type: 'error',
      showClose: true,
      duration: 5 * 1000
    })
    return Promise.reject(error)
  }
)

export default service