Dingdong_app/models/httpModel.js

/* eslint-disable no-async-promise-executor */
import axios from "axios";
import qs from "qs";
import { AsyncStorage } from "react-native";

export default {
    state: {
        baseUrl: "http://dingdong.izouma.com",
        // baseUrl: "http://localhost:8080",
        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 || {};
            const 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,
                    })
                    .then(res => {
                        resolve(res.data);
                    })
                    .catch(e => {
                        if (needWarning) {
                            warnning(e.error);
                        }
                        reject(e);
                    });
            });
        },
        httpPost(url, body, options, needWarning) {
            const { getAxiosInstance } = model();
            const { warnning } = model("loadingModel");
            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) {
            return new Promise(async (resolve, reject) => {
                try {
                    await AsyncStorage.setItem(key, value);
                    resolve();
                } catch (e) {
                    reject(e);
                }
            });
        },
        removeAsyncStorage(key) {
            return new Promise(async (resolve, reject) => {
                try {
                    await AsyncStorage.removeItem(key);
                    resolve();
                } catch (e) {
                    reject(e);
                }
            });
        },
        getAsyncStorage(key) {
            return new Promise(async (resolve, reject) => {
                try {
                    const val = await AsyncStorage.getItem(key);
                    resolve(val);
                } catch (e) {
                    reject(e);
                }
            });
        },
    }),
};