Dingdong_app/models/httpModel.js

import axios from "axios";
import qs from "qs";
import { AsyncStorage } from "react-native";
export default {
    state: {
        baseUrl: "http://dingdong.izouma.com",
        token: "",
        config: {},
        httpLoading: false,
    },
    actions: ({ model, setState }) => ({
        getAxiosInstance() {
            const {
                baseUrl,
                setConfig,
                setConfigError,
                successEvent,
                errorEvent,
            } = model();
            const axiosInstance = axios.create({
                baseURL: baseUrl,
            });
            axiosInstance.interceptors.request.use(
                (config) => setConfig(config),
                (error) => setConfigError(error)
            );

            axiosInstance.interceptors.response.use(
                (response) => successEvent(response),
                (error) => errorEvent(error)
            );
            return axiosInstance;
        },
        async setConfig(config) {
            setState({ httpLoading: true });
            config.headers = config.headers || {};
            let token = await AsyncStorage.getItem("token");
            if (token) {
                config.headers["Authorization"] = "Bearer " + token;
            }
            return config;
        },
        setConfigError(error) {
            setState({ httpLoading: true });
            return Promise.reject(error);
        },
        successEvent(response) {
            setState({ httpLoading: false });
            return response;
        },
        errorEvent(error) {
            setState({ httpLoading: false });
            if (error.response.status) {
                error.response.data.status = error.response.status;
            }
            return Promise.reject(error.response.data);
        },
        httpGet(url, params, needWarning) {
            const { getAxiosInstance } = model();
            const { warnning } = model("loadingModel");
            params = params || {};
            return new Promise((resolve, reject) => {
                getAxiosInstance()
                    .get(url, {
                        params: params,
                    })
                    .then((res) => {
                        resolve(res.data);
                    })
                    .catch((e) => {
                        if (needWarning) {
                            warnning(e.error);
                        }
                        reject(e);
                    });
            });
        },
        httpPost(url, body, options, needWarning) {
            const { getAxiosInstance } = model();
            options = options || {};
            body = body || {};
            if (!(body instanceof FormData)) {
                if (options.body !== "json") {
                    body = qs.stringify(body);
                }
            }
            return new Promise((resolve, reject) => {
                getAxiosInstance()
                    .post(url, body, { withCredentials: true })
                    .then((res) => {
                        resolve(res.data);
                    })
                    .catch((e) => {
                        reject(e);
                        if (needWarning) {
                            warnning(e.error);
                        }
                    });
            });
        },
        addAsyncStorage(key, value) {
            console.log(value);
            return AsyncStorage.setItem(key, value);
        },
        removeAsyncStorage(key) {
            return AsyncStorage.removeItem(key);
        },
        getAsyncStorage(key) {
            return AsyncStorage.getItem(key);
        },
    }),
};