redux-saga/effects#call JavaScript Examples

export function* getRatingsAction(action) {
  const { username, password } = yield select(getUserCredentails);
  const { peerID, slug } = action.payload;
  try {
    const result = yield call(getRatings, username, password, slug, peerID);
    if (result.success !== false) {
      const { ratings = [], average = 0, count = 0 } = result;
      yield put({
        type: actions.setRatings,
        payload: {
          reference: `${peerID}/${slug}`,
          ratings: ratings.reverse(),
          avgRating: average,
          count,
        },
      });
    } else {
      yield put({ type: actions.fetchRatingsFailure });
    }
  } catch (err) {
    yield put({ type: actions.fetchRatingsFailure });
  }
}

export function* handleBusinessPageError(e) {
  if (
    e.message === AUTH_ERRORS.REFRESH_TOKEN_IS_NOT_VALID ||
    e.message === AUTH_ERRORS.USER_IS_BLOCKED
  ) {
    yield call(handleAdminLogout);
  } else {
    yield put(setLoading(false));
    yield put(setBusinessPagesError({ e }));
    yield call(handleErrorSnackbar, e.message);
  }
}

/**
 * Get Repos
 *
 * @param {Object} action
 *
 */
export function* getRepos({ payload }) {
  try {
    const response = yield call(
      request,
      `https://api.github.com/search/repositories?q=${payload.query}&sort=stars`,
    );
    yield put({
      type: ActionTypes.GITHUB_GET_REPOS_SUCCESS,
      payload: { data: response.items },
    });
  } catch (err) {
    /* istanbul ignore next */
    yield put({
      type: ActionTypes.GITHUB_GET_REPOS_FAILURE,
      payload: err,
    });
  }
}

export default function* rootSaga() {
  yield all([
    call(albumsSaga),
    call(commentsSaga),
    call(photosSaga),
    call(postsSaga),
    call(todosSaga),
    call(usersSaga),
  ]);
}

export function * LOGOUT () {
  const { authProvider } = yield select(state => state.settings)
  yield call(mapAuthProviders[authProvider].logout)
  yield put({
    type: 'user/SET_STATE',
    payload: {
      id: '',
      name: '',
      role: '',
      email: '',
      avatar: '',
      authorized: false,
      loading: false
    }
  })
}

/**
 * Changes the left sidebar type
 * @param {*} param0
 */
function* changeLeftSidebarType({ payload: { sidebarType, isMobile } }) {
	try {
		switch (sidebarType) {
			case "compact":
				yield call(changeBodyAttribute, "data-sidebar-size", "small");
				yield call(manageBodyClass, "sidebar-enable", "remove");
				yield call(manageBodyClass, "vertical-collpsed", "remove");
				break;
			case "icon":
				yield call(changeBodyAttribute, "data-keep-enlarged", "true");
				yield call(manageBodyClass, "vertical-collpsed", "add");
				break;
			case "condensed":
				yield call(manageBodyClass, "sidebar-enable", "add");
				if (!isMobile) yield call(manageBodyClass, "vertical-collpsed", "add");
				break;
			default:
				yield call(changeBodyAttribute, "data-sidebar-size", "");
				yield call(manageBodyClass, "sidebar-enable", "remove");
				if (!isMobile) yield call(manageBodyClass, "vertical-collpsed", "remove");
				break;
		}
	} catch (error) { }
}

export function* submitReminder(action) {
  const reminder = action.payload;
  let id = reminder.id;
  if (!id) {
    // It is a new reminder, create an id for it since we don't have a backend.
    id = yield call(generateUUID);
  }

  const reminderToSet = {
    id,
    description: reminder.description,
    color: reminder.color,
    dateTime: dateTimeStringsToMillis(reminder.date, reminder.time),
    city: reminder.city,
  };

  const dateReminder = { date: reminder.date, reminderId: reminderToSet.id };

  // TODO: Save do IDB (with dexie)

  yield put(setReminder(reminderToSet));
  yield put(setDateReminder(dateReminder));

  yield put(reminderUIActions.closeReminder());
}

function* handleGetProfile(action) {
  const response = yield call(getProfile, action.payload);
  if (response.ok) {
    yield put(getProfileSuccess(response.data));
  } else {
    if (
      response.problem !== 'NETWORK_ERROR' &&
      response.problem !== 'TIMEOUT_ERROR' &&
      response.problem !== 'CONNECTION_ERROR'
    ) {
      yield put(getProfileFail(response.problem));
    } else {
      yield put(sendNetworkFail(response.problem));
      yield put(getProfileFail(response.problem));
    }
  }
}

function* signupSaga({ payload }) {
  try {
    const response = yield call(signUp, payload);
    if (response.success) {
      AsyncStorage.setItem('@token', response.success.token);
      const user = {
        ...response.success.user,
        token: response.success.token,
      };
      yield put(authActionsCreator.registerSuccess({ user }));
    }
  } catch (error) {
    yield put(
      authActionsCreator.registerError({
        error: error ? error : 'User Signup Failed',
      }),
    );
  }
}

function* sendFunds(action) {
  const { data, nextAction } = action.payload;
  const result = yield call(sendBitcoins, data);
  if (hasIn(result, 'confirmedBalance')) {
    if (nextAction) {
      yield call(nextAction);
    }
    eventTracker.trackEvent('Wallet-PaymentSuccess');
    yield put({ type: actions.sendFundsSuccess });
    yield put({ type: actions.fetchWalletBalance });
    yield put({ type: actions.setTxid, payload: result.txid });
    yield put({ type: actions.fetchTransactions, payload: data.wallet });
  } else if (result.success === false) {
    const { reason } = result;
    eventTracker.trackEvent('Wallet-PaymentFailed', reason);
    yield put({ type: actions.sendFundsFailure, payload: getWalletFailureMessage(reason) });
  }
}

export function* getRuns() {
  const page = yield select(makeSelectSharedRunsPage());
  const filter = yield select(makeSelectSharedFilter());
  const offset = 10 * (page - 1);
  const limit = 10;
  const requestUrl = `${getBaseUrl()}/api/v1/core/runs/public/?offset=${offset}&limit=${limit}`;

  try {
    const response = yield call(request, requestUrl);
    yield put(updateRunsAction({ ...response, page }));
  } catch (err) {
    if (err.response.status === 401) {
      yield put(logoutAction());
    } else {
      yield put(repoLoadingError(err));
    }
  }
}