redux-saga/effects#fork JavaScript Examples

function createAbortableSaga(saga) {
  if (process.env.NODE_ENV === 'development') {
    return function* main() {
      const sagaTask = yield fork(saga);

      yield take(CANCEL_SAGAS_HMR);
      yield cancel(sagaTask);
    };
  }
  return saga;
}

export function* studentGroupsWatcher() {
  yield all([
    fork(watchLoadingStudentGroups),
    fork(watchLoadingStudentGroupById),
    fork(watchEditingStudentGroups),
    fork(watchAddingStudentGroup),
    fork(watchLoadingHWStudentGroupsById)
  ]);
}

export function* secretariesWatcher() {
  yield all([
    fork(fetchSecretariesWatcher),
    fork(fetchActiveSecretariesWatcher),
    fork(createSecretaryWatcher),
    fork(updateSecretaryWatcher),
    fork(reactivateSecretaryWatcher),
    fork(deleteSecretaryWatcher)
  ]);
}

export function* schedulesWatcher() {
  yield all([
    fork(fetchSchedulesWatcher),
    fork(fetchSchedulesByGroupIdWatcher),
    fork(createScheduleWatcher),
    fork(editScheduleWatcher),
    fork(deleteScheduleWatcher),
  ]);
}

export function* mentorsWatcher() {
  yield all([
    fork(fetchingMentorsWatcher),
    fork(fetchingMentorsByIdWatcher),
    fork(fetchingActiveMentorsWatcher),
    fork(fetchingMentorsGroupsWatcher),
    fork(fetchingMentorsCoursesWatcher),
    fork(fetchingMentorsLessonsWatcher),
    fork(fetchAsyncMentorFilteredLessonsWatcher),
    fork(addingMentorWatcher),
    fork(editingMentorWatcher),
    fork(deletingMentorWatcher),
    fork(reactivatingMentorWatcher),
  ]);
}

export function* lessonsWatcher() {
  yield all([
    fork(fetchLessonsWatcher),
    fork(fetchLessonsByStudentIdWatcher),
    fork(fetchLessonByIdWatcher),
    fork(addLessonWatcher),
    fork(editLessonWatcher),
  ]);
}

export function* studentsWatcher() {
  yield all([
    fork(watchLoadingStudents),
    fork(watchLoadingStudentById),
    fork(watchLoadingActiveStudents),
    fork(watchLoadingStudentGroups),
    fork(watchAddingStudent),
    fork(watchEditingStudent),
    fork(watchRemovingStudent),
    fork(watchReactivatingStudent),
  ]);
}

export function* rootSaga() {
  yield all([
    fork(watchFetchCounter),
    fork(authWatcher),
    fork(mentorsWatcher),
    fork(coursesWatcher),
    fork(studentsWatcher),
    fork(schedulesWatcher),
    fork(themesWatcher),
    fork(lessonsWatcher),
    fork(secretariesWatcher),
    fork(studentGroupsWatcher),
    fork(watchAddAlert),
    fork(dashboardWatcher),
    fork(attachmentsWatcher),
    fork(importWatcher),
    fork(homeworkWatcher),
    fork(eventWatcher),
    fork(homeworkStudentWatcher),
    fork(exportWatcher)
  ]);
}

export function* exportWatcher() {
  yield all([
    fork(exportStudentsClassbookWatcher),
    fork(exportStudentClassbookWatcher),
    fork(exportStudentsResultsWatcher),
    fork(exportStudentResultsWatcher),
    fork(exportStudentGroupResultsWatcher),
  ]);
}

export function* dashboardWatcher() {
  yield all([
    fork(createStudentsClassbookWatcher),
    fork(createStudentClassbookWatcher),
    fork(createStudentsResultsWatcher),
    fork(createStudentResultsWatcher),
    fork(createStudentGroupResultsWatcher),
  ]);
}

export function* coursesWatcher() {
  yield all([
    fork(fetchActiveCoursesWatcher),
    fork(fetchNotActiveCoursesWatcher),
    fork(createCourseWatcher),
    fork(editCourseWatcher),
    fork(deleteCourseWatcher),
    fork(reactivateCourseWatcher),
  ]);
}

export function* authWatcher() {
  yield all([
    fork(loginWatcher),
    fork(logOutWatcher),
    fork(registrationWatcher),
    fork(fetchAssignedUserListWatcher),
    fork(fetchUnAssignedUserListWatcher),
    fork(changePasswordWatcher),
    fork(forgotPasswordWatcher),
    fork(resetPasswordWatcher),
  ]);
}

function* LayoutSaga() {
	yield all([
		fork(watchChangeLayoutType),
		fork(watchChangeLayoutWidth),
		fork(watchChangeLeftSidebarTheme),
		fork(watchChangeLeftSidebarType),
		fork(watchToggleRightSidebar),
		fork(watchShowRightSidebar),
		fork(watchHideRightSidebar),
		fork(watchChangeTopbarTheme)
	]);
}

export default function* root() {
  yield fork(watchSetupNewAccount);
  yield fork(watchStartTracing);
  yield fork(watchSubmitDiagnosisRequests);
  yield fork(watchSwitchTracing);
  yield fork(watchUpdateStatus);
  yield fork(watchSetErrors);
  yield fork(watchSetInfectionStatus);
  yield fork(watchUpdateLanguage);
  yield fork(watchEnableExposureNotifications);
  yield fork(watchRequestIgnoreBatteryOptimizations);
}

export function* watchGetForecast() {
  let task;
  while (true) {
    const action = yield take(forecastUIActions.GET_FORECAST);
    if (task) {
      yield cancel(task);
    }
    task = yield fork(getForecastDebounced, action);
  }
}

export function* importWatcher() {
  yield all([
    fork(sendGroupsWatcher),
    fork(sendStudentsWatcher),
    fork(sendThemesWatcher),
  ]);
}

export function* startTracing() {
  if (Configuration.UI) {
    yield put(accountActions.setTracingEnabled(true));
    yield put(accountActions.startTracingResult(TRACING_RESULTS.SUCCESS));
    yield take(accountTypes.STOP_TRACING);
    yield put(accountActions.stopTracingResult(TRACING_RESULTS.SUCCESS));
    return;
  }

  const watcher = yield fork(watchTracingStatus);

  // Wait for listener to registered
  yield take(accountTypes.TRACING_STATUS_LISTENER_REGISTERED);
  try {
    const result = yield call(TracingManager.start);

    if (result === GAEN_RESULTS.EN_CANCELLED) {
      if (Platform.OS === 'android') {
        // Show alert
        Alert.alert(
          i18n.translate('common.dialogs.gaen.enable.title'),
          i18n.translate('common.dialogs.gaen.enable.description'),
          [
            {
              text: i18n.translate('common.actions.ok'),
              style: 'default',
            },
          ],
        );
      }

      yield put(accountActions.startTracingResult(TRACING_RESULTS.GAEN));
      yield cancel(watcher);
      return;
    }

    try {
      yield call(TracingManager.sync);

      // Get status
      const status = yield call(TracingManager.getStatus);
      yield put(accountActions.updateStatus(status));
    } catch (error) {
      // Sync error. Probably exposure check limit reached.
      // Clear errors
      yield put(accountActions.setErrors([]));
      console.log(error);
    }

    yield put(accountActions.startTracingResult(TRACING_RESULTS.SUCCESS));
  } catch (error) {
    console.log(error);
    yield put(accountActions.startTracingResult(TRACING_RESULTS.FAILED));
    yield cancel(watcher);
    return;
  }

  try {
    yield take(accountTypes.STOP_TRACING);
    yield cancel(watcher);
    yield call(TracingManager.stop);
    yield put(accountActions.stopTracingResult(TRACING_RESULTS.SUCCESS));
  } catch (error) {
    console.log(error);
    yield put(accountActions.stopTracingResult('ERROR'));
  }
}

export default function* root() {
  yield all([
    fork(watchMovieBrowser),
    fork(watchMovieDetails)
  ]);
}

export function* watch() {
  yield fork(startupSagas);
  yield fork(accountSagas);
  yield fork(permissionsSagas);
}

export function* themesWatcher() {
  yield all([
    fork(loadThemesWatcher),
    fork(createThemeWatcher),
    fork(editThemeWatcher),
    fork(deleteThemeWatcher),
  ]);
}

export default function* root() {
  yield fork(watchCheckPermission);
  yield fork(watchCheckAllPermissions);
  yield fork(watchRequestPermission);
  yield fork(watchRequestAllPermissions);
}

export default function* root() {
  yield fork(watchStartup);
  yield fork(watchAppStateChange);
}

combinedEffect = function* () {
  yield all([
    fork(settingsEffect),
    fork(tokenEffect),
    fork(stakingEffect),
    fork(feeEffect),
  ]);
}

export default function* routeSaga() {
  yield all([fork(actionWatcher)]);
}

export default function* rootSaga() {
  yield all([
    fork(watcherInfectionsSaga),
    fork(watcherReportSaga),
    fork(watcherCaseSaga)
  ]);
}

export default function* eventSaga() {
  const socket = yield call(connect);
  yield fork(read, socket);
}

export function* homeworkStudentWatcher() {
  yield all([
    fork(getHomeworkStudentWatcher),
    fork(getHomeworkStudentByIdWatcher),
    fork(addHomeworkStudentWatcher),
    fork(updateHomeworkStudentWatcher),
  ]);
}

export function* homeworkWatcher() {
  yield all([
    fork(getHomeworkWatcher),
    fork(addHomeworkWatcher),
    fork(updateHomeworkWatcher),
  ]);
}

export function* eventWatcher() {
  yield all([
    fork(getEventWatcher),
    fork(updateEventWatcher),
    fork(deleteEventWatcher),
    fork(connectEventToLessonWatcher),
  ]);
}