index.js

import axios from 'axios';
import { Subject } from 'rxjs';

const ApiMap = {
  'development': 'http://127.0.0.1:4900',
  'production': '',
}
// console.log('process.env.NODE_ENV:', process.env.NODE_ENV);
export const ApiService = ApiMap[process.env.NODE_ENV] || '';

// console.log('api:', ApiService)

export const TypeMap = {
  LOADING: 'COMMON_LOADING',
  LOADING_HIDE: 'COMMON_LOADING_HIDE',
  USER_LOGIN: 'USER_LOGIN',
  USER_401: 'USER_401',
  USER_UPDATE: 'USER_UPDATE',
  USER_SIGNUP: 'USER_SIGNUP',
  CATEGORY_LIST: 'CATEGORY_LIST',
  CATEGORY_LIST_ALL: 'CATEGORY_LIST_ALL',
  CATEGORY_UPDATE: 'CATEGORY_PUT',
  CATEGORY_DELETE: 'CATEGORY_DELETE',
  CATEGORY_DETAIL: 'CATEGORY_DETAIL',

  BOOK_SEARCH_KEYWORD: 'BOOK_SEARCH_KEYWORD',
  BOOK_SEARCH: 'BOOK_SEARCH',
  BOOK_DETAIL: 'BOOK_DETAIL',
  BOOK_MY_RELEASE: 'BOOK_MY_RELEASE',
  BOOK_MY_UPDATE: 'BOOK_MY_UPDATE',
  BOOK_MY_DELETE: 'BOOK_MY_DELETE',
  BOOK_MY_LIST: 'BOOK_MY_LIST',

  BORROW_ADD: 'BORROW_ADD',
  BORROW_DETAIL: 'BORROW_DETAIL',
  BORROW_MY_LIST: 'BORROW_MY_LIST',
  BORROW_REQUEST: 'BORROW_REQUEST',
  BORROW_DELETE: 'BORROW_DELETE',
  BORROW_CONFIRM: 'BORROW_CONFIRM',
  BORROW_REQUEST_MSG: 'BORROW_REQUEST_MSG',
  BORROW_REPLY_MSG: 'BORROW_REPLY_MSG',
  BORROW_REFUSE: 'BORROW_REFUSE',
};

export class Utility {
  static NotifyUpdate = new Subject();
  static NotifyLogout = new Subject();

  /**
   * get token from localstorage
   *
   * @static
   * @memberof Utility
   */
  static get Token() {
    return window.localStorage.getItem('token');
  }

  /**
   * save token to localstorage
   *
   * @static
   * @memberof Utility
   */
  static set Token(val) {
    if (!val) {
      window.localStorage.removeItem('token');
    } else {
      window.localStorage.setItem('token', val);
    }
  }

  /**
   * sve user info to localstorage
   *
   * @static
   * @memberof Utility
   */
  static set UserInfo(val) {
    const key = 'userinfo';
    if (!val) {
      window.localStorage.removeItem(key);
    } else {
      window.localStorage.setItem(key, JSON.stringify(val));
    }
  }
  /**
   * get user info from localstorage
   *
   * @static
   * @memberof Utility
   */
  static get UserInfo() {
    const info = window.localStorage.getItem('userinfo');
    if (info) {
      try {
        return JSON.parse(info);
      } catch (ex) {
        return null;
      }
    }
    return null;
  }

  static Toast() { }

  static LoadingHide() { }

  static IsArray(obj) {
    if (!obj || !Array.isArray(obj) || obj.length === 0) {
      return false;
    }
    return Array.isArray(obj);
  }
}

export class Httphelper {
  static async __request({ method = 'get', url, headers, params, data, dispatch }) {
    try {
      if (!url) {
        Utility.Toast('url not found');
        return Promise.reject('url not found');
      }
      const _url = `${ApiService}${url}`;
      const token = Utility.Token;
      const _headers = Object.assign({}, headers);
      if (token) {
        _headers.token = token;
      }
      const opt = { method, url: _url, headers: _headers, params, data };
      const response = await axios(opt);
      const { data: body } = response;
      return body.data || body;
    } catch (ex) {
      const { response } = ex;
      const { data: errData, status, statusText } = response || {};
      const { msg } = errData || {};
      if (status === 401) {
        Utility.Token = null;
        Utility.UserInfo = null;
        alert(msg || statusText);
        

        if (dispatch) {
          dispatch({ type: TypeMap.USER_401, payload: '' });
        }
        Utility.NotifyLogout.next({ isLogin: true });
        console.log(statusText);
        return Promise.reject(msg);
      }
      if (msg) {
        alert(msg);
      }
      console.log('status:', msg);
      return Promise.reject(msg);
    }
  }

  /**
   * post request
   *
   * @param {*} { url, headers, params, data }
   * @returns
   * @memberof Httphelper
   */
  static async onPost(url, { headers, params, data }, dispatch) {
    return this.__request({ method: 'post', url, headers, params, data, dispatch });
  }

  /**
   * put request
   *
   * @param {*} { url, headers, params, data }
   * @returns
   * @memberof Httphelper
   */
  static async onPut(url, { headers, params, data }, dispatch) {
    return this.__request({ method: 'put', url, headers, params, data, dispatch });
  }

  /**
   * delete request
   *
   * @param {*} { url, headers, params, data }
   * @returns
   * @memberof Httphelper
   */
  static async onDelete(url, { headers, params, data }, dispatch) {
    return this.__request({ method: 'delete', url, headers, params, data, dispatch });
  }

  /**
   *  get request
   *
   * @param {*} { url, headers, params }
   * @returns
   * @memberof Httphelper
   */
  static async onGet(url, { headers, params }, dispatch) {
    return this.__request({ method: 'get', url, headers, params, dispatch });
  }
}

// update user info
export const userUpdate = (userInfo) => {
  return { type: TypeMap.USER_UPDATE, payload: userInfo };
};
/**
 * user login
 * @param {*} info
 */
export const userLogin = (info) => {
  return async (dispatch) => {
    const item = await Httphelper.onPost('/api/user/signin', { data: info }, dispatch);
    Utility.Token = item.token;
    Utility.UserInfo = item;
    dispatch({ type: TypeMap.USER_LOGIN, payload: item });
  };
};

/**
 * user signup
 * @param {*} info
 */
export const userSignUp = (data) => {
  return async (dispatch) => {
    dispatch({ type: TypeMap.LOADING });
    try {
      const item = await Httphelper.onPost('/api/user/signup', { data }, dispatch);
      dispatch({ type: TypeMap.USER_SIGNUP, payload: item });
      return item;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};

// get category list
export const categoryList = (params) => {
  return async (dispatch) => {
    dispatch({ type: TypeMap.LOADING });
    try {
      const item = await Httphelper.onGet('/api/category', { params }, dispatch);
      dispatch({ type: TypeMap.CATEGORY_LIST, payload: item });
      return item;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};
// get category list
export const categoryListAll = (params) => {
  return async (dispatch) => {
    dispatch({ type: TypeMap.LOADING });
    try {
      const item = await Httphelper.onGet('/api/category/all', { params }, dispatch);
      dispatch({ type: TypeMap.CATEGORY_LIST_ALL, payload: item });
      return item;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};

// edit category by id
export const categoryEdit = (id, data) => {
  return async (dispatch) => {
    dispatch({ type: TypeMap.LOADING });
    try {
      const item = await Httphelper.onPut('/api/category/' + id, { data }, dispatch);
      dispatch({ type: TypeMap.CATEGORY_DELETE, payload: item });
      return item;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};

// search book by keyword
export const bookSearch = (keyword, page = 1, size = 20) => {
  return async (dispatch) => {
    dispatch({ type: TypeMap.LOADING });
    try {
      dispatch({ type: TypeMap.BOOK_SEARCH_KEYWORD, payload: { keyword, page, size } });
      const item = await Httphelper.onGet('/api/book/search', { params: { page, size, keyword } }, dispatch);

      dispatch({ type: TypeMap.BOOK_SEARCH, payload: item });
      return item;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};

// search book by keyword
export const bookListByMy = () => {
  return async (dispatch) => {
    dispatch({ type: TypeMap.LOADING });
    try {
      const item = await Httphelper.onGet('/api/book/my', { params: {} }, dispatch);
      dispatch({ type: TypeMap.BOOK_MY_LIST, payload: item });
      return item;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};

// get book detail info by id
export const bookDetail = (id) => {
  return async (dispatch) => {
    dispatch({ type: TypeMap.LOADING });
    try {
      const item = await Httphelper.onGet('/api/book/' + id, { params: {} }, dispatch);
      dispatch({ type: TypeMap.BOOK_DETAIL, payload: item });
      return item;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};

// delete book by id
export const bookDelete = (id, index) => {
  return async (dispatch) => {
    dispatch({ type: TypeMap.LOADING });
    try {
      const item = await Httphelper.onDelete('/api/book/' + id, { params: {} }, dispatch);
      dispatch({ type: TypeMap.BOOK_MY_DELETE, payload: { id, index } });
      return item;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};

// add book
export const bookAdd = (data) => {
  return async (dispatch) => {
    dispatch({ type: TypeMap.LOADING });
    try {
      let formData = new FormData();
      for (let key in data) {
        formData.append(key, data[key]);
      }
      const item = await Httphelper.onPost('/api/book/', { data: formData });
      dispatch({ type: TypeMap.BOOK_MY_RELEASE, payload: item }, dispatch);
      return item;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};

// edit book
export const bookEdit = (id, data) => {
  return async (dispatch) => {
    dispatch({ type: TypeMap.LOADING });
    try {
      let formData = new FormData();
      for (let key in data) {
        formData.append(key, data[key]);
      }
      const item = await Httphelper.onPut('/api/book/' + id, { data: formData });
      dispatch({ type: TypeMap.BOOK_MY_UPDATE, payload: item }, dispatch);
      return item;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};

// book search keyword
export const bookSearchKeyword = (keyword, page = 1, size = 20) => {
  return { type: TypeMap.BOOK_SEARCH_KEYWORD, payload: { keyword, page, size } };
};

export const borrowAdd = (data) => {
  return async (dispatch) => {
    dispatch({ type: TypeMap.LOADING });
    try {
      const item = await Httphelper.onPost('/api/borrow/', { data }, dispatch);
      dispatch({ type: TypeMap.BORROW_ADD, payload: item });
      return item;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};

export const borrowDelete = (id, index) => {
  return async (dispatch) => {
    dispatch({ type: TypeMap.LOADING });
    try {
      const item = await Httphelper.onDelete('/api/borrow/' + id, {}, dispatch);
      dispatch({ type: TypeMap.BORROW_DELETE, payload: { id, index } });
      return item;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};
export const borrowDetail = (id) => {
  return async (dispatch) => {
    dispatch({ type: TypeMap.LOADING });
    try {
      const detail = await Httphelper.onGet('/api/borrow/' + id, {}, dispatch);
      dispatch({ type: TypeMap.BORROW_DETAIL, payload: detail });
      return detail;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};

export const borrowMyList = () => {
  return async (dispatch) => {
    dispatch({ type: TypeMap.LOADING });
    try {
      const item = await Httphelper.onGet('/api/borrow/my', { params: {} }, dispatch);
      dispatch({ type: TypeMap.BORROW_MY_LIST, payload: item });
      return item;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};

export const borrowRequest = () => {
  return async (dispatch) => {
    dispatch({ type: TypeMap.LOADING });
    try {
      const item = await Httphelper.onGet('/api/borrow/request', {}, dispatch);
      dispatch({ type: TypeMap.BORROW_REQUEST, payload: item });
      return item;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};

export const borrowRequestMsg = (id, content) => {
  return async (dispatch) => {
    //BORROW_REPLY_TO
    dispatch({ type: TypeMap.LOADING });
    try {
      const item = await Httphelper.onPut('/api/borrow/request/msg/' + id, { data: { content } }, dispatch);
      dispatch({ type: TypeMap.BORROW_REQUEST_MSG, payload: item });
      return item;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};

export const borrowReplyMsg = (id, content) => {
  return async (dispatch) => {
    //BORROW_REPLY_TO
    dispatch({ type: TypeMap.LOADING });
    try {
      const item = await Httphelper.onPut('/api/borrow/reply/msg/' + id, { data: { content } }, dispatch);
      dispatch({ type: TypeMap.BORROW_REPLY_MSG, payload: item });
      return item;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};

export const borrowRefuse = (id, content) => {
  return async (dispatch) => {
    dispatch({ type: TypeMap.LOADING });
    try {
      const item = await Httphelper.onPut('/api/borrow/refuse/' + id, { data: { content } }, dispatch);
      dispatch({ type: TypeMap.BORROW_REFUSE, payload: item });
      return item;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};

export const borrowConfirm = (id, content) => {
  return async (dispatch) => {
    dispatch({ type: TypeMap.LOADING });
    try {
      const item = await Httphelper.onPut('/api/borrow/confirm/' + id, { data: { content } }, dispatch);
      dispatch({ type: TypeMap.BORROW_CONFIRM, payload: item });
      return item;
    } finally {
      dispatch({ type: TypeMap.LOADING_HIDE });
    }
  };
};