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) {
      return Promise.reject(error);
    },
    successEvent(response) {
      return response;
    },
    errorEvent(error) {
      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 { loading, warnning, clearLoading } = model("loadingModel");
      params = params || {};
      //   loading();
      return new Promise((resolve, reject) => {
        getAxiosInstance()
          .get(url, {
            params,
          })
          .then(res => {
            resolve(res.data);
            if (!needWarning) {
              clearLoading();
            }
          })
          .catch(e => {
            if (needWarning) {
              warnning(e.error);
            }
            reject(e);
          });
      });
    },
    httpPost(url, body, options, needWarning) {
      const { getAxiosInstance } = model();
      const { loading, warnning, clearLoading } = model("loadingModel");
      //   loading();
      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);
            if (!needWarning) {
              clearLoading();
            }
          })
          .catch(e => {
            reject(e);
            if (needWarning) {
              warnning(e.error);
            }
          });
      });
    },
    async addAsyncStorage(key, value) {
      await AsyncStorage.setItem(key, value);
    },
    async removeAsyncStorage(key) {
      await AsyncStorage.removeItem(key);
    },
    async getAsyncStorage(key) {
      const val = await AsyncStorage.getItem(key);
      return Promise.resolve(val);
    },
  }),
};