redux-saga/effects#takeLatest JavaScript Examples

/* ------------- Connect Types To Sagas ------------- */

export default function * root () {
  yield all([
    // some sagas only receive an action
    takeLatest(StartupTypes.STARTUP, startup, api),

    takeLatest(ProductsTypes.GET_PRODUCTS_REQUEST, getProducts, api),
    takeLatest(ProductsTypes.MORE_PRODUCTS_REQUEST, moreProducts, api),
    takeLatest(ProductsTypes.GET_DETAIL_REQUEST, getDetail, api),

    takeLatest(CategoryTypes.GET_CATEGORY_REQUEST, getCategory, api),
    takeLatest(CategoryTypes.SHOW_CATEGORY_REQUEST, showCategory, api),

    takeLatest(AuthTypes.DO_LOGIN_REQUEST, doLogin, api),
    takeLatest(AuthTypes.DO_REGISTER_REQUEST, doRegister, api),
    takeLatest(AuthTypes.DO_LOGOUT_REQUEST, doLogout, api),

    takeLatest(SessionTypes.GET_PROFILE_REQUEST, getProfile, api),

    takeLatest(InvoiceTypes.GET_INVOICE_REQUEST, getInvoice, api),
    takeLatest(InvoiceTypes.MORE_INVOICE_REQUEST, moreInvoice, api),
    takeLatest(InvoiceTypes.SHOW_INVOICE_REQUEST, showInvoice, api),

    takeLatest(OrderTypes.MAKE_ORDER_REQUEST, makeOrder, api),

    takeLatest(ConfirmPaymentTypes.CONFIRM_PAYMENT_REQUEST, confirmPayment, api)
  ])
}

/**
 * Root saga manages watcher lifecycle
 */
export default function* githubData() {
  // Watches for LOAD_REPOS actions and calls getRepos when one comes in.
  // By using `takeLatest` only the result of the latest API call is applied.
  // It returns task descriptor (just like fork) so we can continue execution
  // It will be cancelled automatically on component unmount
  yield takeLatest(LOAD_REPOS, getRepos);
}

export default function* Chat() {
  yield takeEvery(chatActions.fetchChats, getChats);
  yield takeEvery(chatActions.updateChats, updateChats);
  yield takeEvery(chatActions.fetchChatDetail, getChatDetail);
  yield takeEvery(chatActions.sendChat, sendChat);
  yield takeLatest(chatActions.sendChat, sendChatNotification);
  yield takeEvery(chatActions.setChatAsRead, setChatAsRead);
  yield takeEvery(chatActions.deleteChatConversation, deleteChatConversation);
}

//Not necessary unless you have more than one sagas exports
//The array should contain a list of actions to be listened to

export default function* albumsSaga() {
  yield takeLatest(AlbumsActionTypes.ADD_ALBUM_START, addAlbumStartAsync);
  yield takeLatest(AlbumsActionTypes.EDIT_ALBUM_START, editAlbumStartAsync);
  yield takeLatest(AlbumsActionTypes.DELETE_ALBUM_START, deleteAlbumStateAsync);
  yield takeLatest(AlbumsActionTypes.FETCH_ALBUMS_START, fetchAlbumsStartAsync);
  yield takeLatest(
    [
      AlbumsActionTypes.DELETE_ALBUM_FAILURE,
      AlbumsActionTypes.DELETE_ALBUM_SUCCESS,
      AlbumsActionTypes.ADD_ALBUM_FAILURE,
      AlbumsActionTypes.ADD_ALBUM_SUCCESS,
      AlbumsActionTypes.EDIT_ALBUM_FAILURE,
      AlbumsActionTypes.EDIT_ALBUM_SUCCESS,
      AlbumsActionTypes.FETCH_ALBUMS_FAILURE,
      AlbumsActionTypes.FETCH_ALBUMS_SUCCESS,
    ],
    clearAlbumMessagesStart
  );
}

/**
 * User Sagas
 */
export default function* root() {
  yield all([
    takeLatest(ActionTypes.USER_LOGIN, login),
    takeLatest(ActionTypes.USER_LOGOUT, logout),
  ]);
}

/* ------------- Connect Types To Sagas ------------- */

export default function * root () {
  yield all([
    // some sagas only receive an action
    takeLatest(StartupTypes.STARTUP, startup),

    // some sagas receive extra parameters in addition to an action
    takeLatest(GithubTypes.USER_REQUEST, getUserAvatar, api)
  ])
}

export default function* loginPageSaga() {
  yield takeLatest(LOGOUT_REQUEST, logout);
  yield takeLatest(GET_CURRENCIES_REQUEST, getCurrencies);
  yield takeLatest(CHECK_EMAIL_REQUEST, checkEmail);
  yield takeLatest(GET_MESSAGES_REQUEST, getMessages);
  yield takeLatest(READ_ALL_MESSAGES_REQUEST, readAllMessages);
  yield takeLatest(OPEN_MESSAGE_MODAL, openMessageModal);
  yield takeLatest(GET_NOTIFICATIONS_REQUEST, getNotifications);
}

export default function* watcherSaga() {
  yield takeLatest(FETCH_ACTIVE_USER, fetchActiveUserSaga);
  yield takeLatest(GITHUB_SIGN_IN, githubSignInSaga);
  yield takeLatest(RESEND_CODE, resendCodeSaga);
  yield takeLatest(RESEND_SIGN_UP, resendSignUpSaga);
  yield takeLatest(RESET_PASSWORD, resetPasswordSaga);
  yield takeLatest(SEND_LINK, sendLinkSaga);
  yield takeLatest(SIGN_IN, signInSaga);
  yield takeLatest(SIGN_OUT, signOutSaga);
  yield takeLatest(SIGN_UP, signUpSaga);
  yield takeLatest(VERIFY_EMAIL, verifyEmailSaga);
}

export default function* () {
  yield all([
    takeLatest(STAKING_GET_STAKE_LIST, fetchEventStackedList),
    takeLatest(STAKING_GET_TOTAL_STAKE, fetchTotalStake),
    takeLatest(STAKING_GET_YOUR_STAKE, fetchYourStake),
    takeLatest(STAKING_DO_STAKE, doStake),
    takeLatest(STAKING_DO_CLAIM, doClaim),
    takeLatest(STAKING_DO_WITHDRAW, doWithdraw),
  ]);
}

export default function* runList() {
  yield takeLatest(SET_PAGE, getRuns);
  yield takeLatest(SET_FILTER_DATE_START, getRuns);
  yield takeLatest(SET_FILTER_DATE_END, getRuns);
  yield takeLatest(SET_FILTER_QUERY, getRuns);
  yield takeLatest(GET_RUNS, getRuns);
}

export default function* rootSaga() {
  yield all([takeLatest(login, loginAPI)]);
}

SearchSaga = function* Search() {
  yield takeLatest(actions.doSearch, fetchSearchResult);
  yield takeLatest(actions.doSearchUser, fetchUserSearchResult);
  yield takeLatest(actions.appendSearch, fetchSearchResult);
  yield takeLatest(actions.appendUserSearch, fetchUserSearchResult);
  yield takeEvery(actions.updateFilter, updateFilter);
}

function * watchForView () {
  yield takeLatest(reducerConstants.app.f.VIEW_LOADED, loadSettings)
}

export default function* watchDecrementCountSaga() {
  yield takeLatest(DECREMENT, decrementUserCountSaga);
}

export function* watchGetFollower() {
  yield takeLatest(GET_FOLLOWER_REQUEST, handleGetFollower);
}

/**
 * Root saga manages watcher lifecycle
 */
export default function* launchBackgroundTask() {
  yield takeEvery(SAY_HELLO_REQUEST, sayHello);
  yield takeEvery(BACKGROUND_JOB_SUBMIT, submitBackgroundJob);
  yield takeLatest(BACKGROUND_JOB_STATUS_POLL, getBackgroundJobStatus);
}

export default function* communicationProviderSaga() {
  const client = yield call(initWebsocket);

  // Channel Actions
  yield takeLatest(START_JOIN, (action) =>
    hcClient.join(action.username, action.password, action.channel),
  );

  yield takeLatest(SEND_CHAT, (action) =>
    hcClient.say(action.channel, action.message),
  );

  yield takeLatest(ENABLE_CAPTCHA, (action) =>
    hcClient.enableCaptcha(action.channel),
  );

  yield takeLatest(DISABLE_CAPTCHA, (action) =>
    hcClient.disableCaptcha(action.channel),
  );

  yield takeLatest(LOCK_CHANNEL, (action) =>
    hcClient.lockChannel(action.channel),
  );

  yield takeLatest(UNLOCK_CHANNEL, (action) =>
    hcClient.unlockChannel(action.channel),
  );

  // User Actions
  yield takeLatest(INVITE_USER, (action) =>
    action.user.sendInvite(action.channel),
  );

  yield takeLatest(WHISPER_USER, (action) =>
    hcClient.say(action.channel, 'I wish the developer wasnt so lazy. . .'),
  );

  yield takeLatest(IGNORE_USER, (action) => action.user.toggleBlock());

  yield takeLatest(KICK_USER, (action) => action.user.kick(action.channel));

  yield takeLatest(BAN_USER, (action) => action.user.ban(action.channel));

  yield takeLatest(MUTE_USER, (action) => action.user.mute(action.channel));

  yield takeLatest(UNMUTE_USER, (action) => action.user.unmute(action.channel));

  while (true) {
    const action = yield take(client);
    yield put(action);
  }
}

/**
 * App Sagas
 */
export default function* root() {
  yield all([takeLatest(ActionTypes.SWITCH_MENU, switchMenu)]);
}

function* loginWatcher() {
  yield takeLatest(actionTypes.LOGIN_REQUESTING, loginWorker);
}

export default function* users() {
  yield takeEvery(SAGA.SAGA_GETMENUTREE, effects.getMenTree);
  yield takeLatest(SAGA.SAGA_GETMENULIST, effects.getMenuList);
  yield takeLatest(SAGA.SAGA_GET_USER_LIST, effects.getUserData);
  yield takeEvery(SAGA.SAGA_GET_USER_INFO, effects.getUserInfoData);
}

export default function* root() {
	yield all([
		takeLatest(AuthActionTypes.FETCH_USER, fetchUser),
		takeLatest(AuthActionTypes.SIGN_IN_USER, signInUser),
		takeLatest(AuthActionTypes.SIGN_OUT_USER, signoutUser)
	]);
}

export default function* dashboardPageSaga() {
  yield takeLatest(GET_AVAILABLE_FUNDS_REQUEST, getAvailableFunds);
  yield takeLatest(GET_ACCOUNT_BALANCE_REQUEST, getAccountBalance);
  yield takeLatest(GET_BILLS_REQUEST, getBills);
  yield takeLatest(GET_RECENT_TRANSACTIONS_REQUEST, getRecentTransactions);
  yield takeLatest(CREATE_NEW_BILL_REQUEST, createNewBill);
}

function * walletSages () {
  yield all([
    takeLatest(cacheActions.fetchCode().type, handleFetchCode),
    takeLatest(cacheActions.fetchVersion().type, handleFetchVersion),
    takeLatest(cacheActions.fetchGlobalStats().type, handleFetchGlobalStats),
  ])
}

export default function* watcherSaga() {
  yield takeLatest(FETCH_COMPANY, fetchCompanySaga);
  yield takeLatest(FETCH_POSITION_DETAIL, fetchPositionDetailSaga);
  yield takeLatest(NOTIFY_COMPANY, notifyCompanySaga);
}

export function* onSignOutSuccess() {
  yield takeLatest(UserActionTypes.SIGN_OUT_SUCCESS, clearCartOnSignOut);
}