taro-book/src/interceptor.ts

import Taro from '@tarojs/taro';
import api from './server/index';
import { setApp } from './config';
import appInfoStore from '@src/store/appInfo'
import bookStore from '@src/store/book'
import { getRechargeTemplate } from './server/index/index';
export interface ResData {
    code: number,
    data: any,
    fail: boolean,
    msg: string,
    success: boolean
}
//拦截器
let isOpne = false //弹窗是否开启
// 因没有权限等待的请求
let pendingRequests: any[] = [];
// 请求拦截器
const requestInterceptor = (chain) => {
    // 展示loding弹窗逻辑
    if (app.isLoding && !isOpne) {
        isOpne = true
        Taro.showLoading({ title: "加载中..." })
    }
    const requestParams = chain.requestParams;
    requestParams.url = requestParams.url?.match(/^http[s]?:\/\//ig) ? requestParams.url : app.apiUrl + requestParams.url
    // 是登录接口token换成inittoken
    let token = requestParams.url.match(/(\/jsCodeLogin)|(\/appComponent\/list)/ig) ? app.initToken : app.token
    // 不存在token并且不是init和login接口关闭请求
    if (!token && !requestParams.url.match(/(\/jsCodeLogin)|(\/loginInitialize)/ig)) {
        // 打印日志或执行一些清理操作
        console.log("Token 无效，取消请求,并存入待请求列表，授权后重新请求");
        // 存入待请求列表
        pendingRequests.push(chain);
        // 返回一个被拒绝的Promise以中断请求
        return new Promise(() => { });
    }
    // 处理参数
    // if (requestParams.data?.workDirection) {
    //     if (requestParams.data?.workDirection === "男生") {
    //         requestParams.data.workDirection = 0
    //     } else {
    //         requestParams.data.workDirection = 1
    //     }
    // }
    //分类列表假如上次请求的频道没变就不再获取
    if (requestParams.url.includes('/app/bookCategory/list')) {
        if (requestParams.data.workDirection === bookStore.oldWorkDirection) {
            log("阻止参数不变获取分类")
            return new Promise(() => { });
        } else {
            //赋值本次的请求
            bookStore.setData({ oldWorkDirection: requestParams.data.workDirection })
        }
    }
    requestParams.header = {
        ...requestParams.header,
        "Token": token
    }
    // 继续请求
    return chain.proceed(requestParams);
};

// 响应拦截器
const responseInterceptor = (chain) => {
    return chain.proceed(chain.requestParams).then(async (response) => {
        const { data } = response;
        let { code } = data
        // 在这里处理返回的数据
        switch (code) {
            case 200:
                // 初始化接口调用登录接口，登录接口存在自己的执行判断
                if (chain.requestParams.url.includes("loginInitialize")) {
                    setApp({ initToken: data.data.token })
                    appInfoStore.actionAppInfo(data.data.appInfo)
                    let user: any = await api.login()
                    Taro.setStorageSync("userInfo", user)
                    let temp: any = await getRechargeTemplate()
                    console.log("temp", temp)
                    setApp({ appName: data?.data?.appInfo?.appName })
                    appInfoStore.setData({ appInfo: data.data.appInfo, })
                    // 检测待请求列表中是否存在请求，存在就执行请求
                    while (pendingRequests.length > 0) {
                        console.log("存在待请求")
                        const pendingChain = pendingRequests.shift();
                        Taro.request(pendingChain.requestParams);
                    }
                }
                break;
            case 300:
                log("token过期,重新登录", data)
                setApp({ token: "" })
                await api.loginInit(app.appId)
                // 重新执行当前请求
                console.log("登录后重新请求===>")
                const newRequestParams = chain.requestParams;
                return Taro.request(newRequestParams).then(newResponse => newResponse.data);
            default:
                log("未知错误", data)
                Taro.showToast({
                    title: data.msg,
                    icon: 'error',
                    duration: 1000
                })
                break;
        }
        //关闭login弹窗
        if (isOpne) {
            isOpne = false
            Taro.hideLoading()
        }
        return data;
    });
};
// 添加请求拦截器
Taro.addInterceptor(requestInterceptor);
// 添加响应拦截器
Taro.addInterceptor(responseInterceptor);