export function* watchSetAllowanceProgress() {
while (yield take(constants.SET_ALLOWANCE)) {
const progressTask = yield fork(setAllowanceProgressBarSaga)
yield take(constants.SET_ALLOWANCE_COMPLETED)
yield cancel(progressTask)
}
}
test('subscriptionWatcherCreator', t => {
const params = {};
const subscription = { id: 1 };
const watcher = sagaCreators.subscriptionWatcherCreator('test', params);
const gen = watcher();
const subsChannel = eventChannel(() => () => {});
const readyChannel = eventChannel(() => () => {});
const errorChannel = eventChannel(() => () => {});
const task = { cancel: () => {} };
t.deepEqual(gen.next().value, call(deps.libs.collectionEventChannel, 'test'));
t.deepEqual(gen.next(subsChannel).value, take(deps.types.LOGIN_SUCCEED));
t.deepEqual(gen.next().value, put(actions.subscriptionStarted('test')));
t.deepEqual(gen.next().value, call(deps.libs.subscribe, 'test', params));
t.deepEqual(gen.next(subscription).value, call(deps.libs.readyEventChannel, subscription));
t.deepEqual(gen.next(readyChannel).value, call(deps.libs.errorEventChannel, subscription));
t.deepEqual(gen.next(errorChannel).value,
fork(sagaCreators.subscriptionEvents, subsChannel, actions.subscriptionModified));
t.deepEqual(gen.next(task).value,
fork(sagaCreators.subscriptionEvents, readyChannel, actions.subscriptionReady));
t.deepEqual(gen.next(task).value,
fork(sagaCreators.subscriptionEvents, errorChannel, actions.subscriptionFailed));
t.deepEqual(gen.next(task).value, take(deps.types.LOGOUT_SUCCEED));
t.deepEqual(gen.next().value, call(deps.libs.unsubscribe, subscription.id));
t.deepEqual(gen.next().value, put(actions.subscriptionStopped('test')));
t.deepEqual(gen.next().value, take(deps.types.LOGIN_SUCCEED));
});
test('subscriptionEvents', t => {
const channel = eventChannel(() => () => {});
const action = () => ({ type: 'SOME_ACTION' });
const result = {};
const gen = sagaCreators.subscriptionEvents(channel, action);
t.deepEqual(gen.next().value, take(channel));
t.deepEqual(gen.next(result).value, put(action(result)));
t.deepEqual(gen.next().value, take(channel));
});
export function* mainWatch () {
while (true) {
yield take((action)=> {
return action.type == PAGE_ACTIVATE && action.payload.name == 'orders';
});
yield put(getTree());
yield take(PAGE_ACTIVATE);
}
}
beforeEach(() => {
expect(generator.next().value).toEqual(race({
loadRepos: take(LOAD_REPOS),
stop: take(LOCATION_CHANGE),
}));
expect(generator.next(take(LOAD_REPOS)).value).toEqual(select(selectUsername()));
const requestURL = `https://api.github.com/users/${username}/repos?type=all&sort=updated`;
expect(generator.next(username).value).toEqual(call(request, requestURL));
});
function* saveSourceCode(){
while(true){
const { payload } = yield take(actions.SAVE_SOURCE_CODE);
yield put(spinnerActions.started('Saving source code'));
const saveTask = yield fork(saveComponentSourceCode, payload);
const delayTask = yield fork(delaySaveComponentSourceCode);
yield take([actions.SAVE_SOURCE_CODE_DONE, actions.SAVE_SOURCE_CODE_TIMEOUT]);
yield cancel(saveTask);
yield cancel(delayTask);
yield put(spinnerActions.done('Saving source code'));
}
}
export default function* fetchAppDataSaga(): Generator<*, *, *> {
yield fork(doFetchRooms);
yield fork(doFetchBeacons);
yield fork(doFetchBookings);
yield fork(doFetchTimeslots);
yield put(fetchRooms());
yield take('FETCH_ROOMS_SUCCESS');
yield put(fetchBeacons());
yield take('FETCH_BEACONS_SUCCESS');
}
export function *saga () {
debug("starting listeners");
let listeners = yield *forkListeners();
// receiving & saving contracts into state
debug("waiting for contract information");
let { contexts, sources } = yield take(actions.RECORD_CONTRACTS);
debug("recording contract binaries");
yield *recordContexts(...contexts);
debug("recording contract sources");
yield *recordSources(...sources);
debug("waiting for start");
// wait for start signal
let {txHash, provider} = yield take(actions.START);
debug("starting");
// process transaction
debug("fetching transaction info");
let err = yield *fetchTx(txHash, provider);
if (err) {
debug("error %o", err);
yield *error(err);
} else {
debug("visiting ASTs");
// visit asts
yield *ast.visitAll();
debug("readying");
// signal that stepping can begin
yield *ready();
debug("waiting for trace EOT");
// wait until trace hits EOT
yield *trace.wait();
debug("finishing");
// finish
yield put(actions.finish());
}
debug("stopping listeners");
yield all(
listeners.map(task => cancel(task))
);
}
function* watchSignin() {
while (true) {
let action = yield take(actions.BEGIN_SIGNIN)
yield fork(auth.sagas.signin, action.network)
action = yield take([auth.actions.AUTH_SIGNIN_SUCCESS, auth.actions.AUTH_SIGNIN_FAILURE])
if (action.type === auth.actions.AUTH_SIGNIN_SUCCESS) {
yield put(push('/profile/welcome'))
}
else {
//TODO: notify user
}
}
}
function* watchSignout() {
while (true) {
let action = yield take(actions.BEGIN_SIGNOUT)
yield fork(auth.sagas.signout)
action = yield take([auth.actions.AUTH_SIGNOUT_SUCCESS, auth.actions.AUTH_SIGNOUT_FAILURE])
if (action.type === auth.actions.AUTH_SIGNOUT_SUCCESS) {
yield put(push('/'))
}
else {
//TODO: notify user
}
}
}
export default function* authFlowSaga() {
// wait for gapi to load from google
let gapiLoading = true;
while (gapiLoading) {
if (gapi) {
yield call(loadCalendarApi);
yield call(initClient);
gapiLoading = false;
} else {
yield delay(1000);
}
}
yield* handleAuth(
isSignedIn(),
'Could not automatically authenticate. Please click the button above to login.'
);
while (true) {
const { type } = yield take([AUTH_REQUEST, AUTH_LOGOUT]);
if (type === AUTH_REQUEST) {
yield call(signIn);
yield* handleAuth(
isSignedIn(),
'Authentication failed, please try again.'
);
} else if (type === AUTH_LOGOUT) {
yield call(signOut);
yield* handleAuth(isSignedIn());
}
}
}
function* receiverSaga() {
const channel = yield call(socketEventChannel)
try {
while (true) { // eslint-disable-line
// take(END) will cause the saga to terminate by jumping to the finally block
let message = yield take(channel)
console.log('message', message)
if (message.type === 'open') {
yield put({
type: 'SOCKET_OPEN',
})
} else if (message.type === 'messageReceived') {
yield put({
type: 'SOCKET_MESSAGE_ARRIVED',
message: message.value,
})
} else {
// when error happens
yield put({
type: 'SOCKET_ERROR',
error: message.value,
})
}
}
} finally {
yield put({
type: 'SOCKET_CLOSED',
// message: message.value,
})
socketConnection.close()
}
}
export function* watchForCompletedPlot(options, dispatch, getState) {
let masterPlot;
let plot;
while (!masterPlot || !plot) {
const action = yield take([ImagePlotCntlr.PLOT_IMAGE, ImagePlotCntlr.PLOT_IMAGE_FAIL]);
const {plotId, masterPlotId, wcsMatchType}= options;
if (action.type===ImagePlotCntlr.PLOT_IMAGE_FAIL && action.payload.plotId===plotId) {
return;
}
const visRoot= getState()[IMAGE_PLOT_KEY];
masterPlot= primePlot(visRoot, masterPlotId);
plot= primePlot(visRoot, plotId);
if (masterPlot && plot) {
const masterPv= getPlotViewById(visRoot, masterPlotId);
const pv= getPlotViewById(visRoot, plotId);
const level = wcsMatchType===WcsMatchType.Standard || wcsMatchType===WcsMatchType.Target ?
masterPlot.zoomFactor :
getEstimatedFullZoomFactor(primePlot(masterPv),masterPv.viewDim, FullType.WIDTH_HEIGHT);
const asPerPix= getArcSecPerPix(masterPlot,level);
if (wcsMatchType===WcsMatchType.Target) {
const ft= masterPlot.attributes[PlotAttribute.FIXED_TARGET];
if (ft) dispatchRecenter({plotId:masterPv.plotId, centerPt:ft});
}
syncPlotToLevel(pv, masterPv, asPerPix);
dispatchUpdateViewSize(pv.plotId);
}
}
}
function* clearStatisticsAndMemoryUsage() {
while (true) {
yield take(PFA_DOCUMENT_UPLOAD_SUCCESS);
yield put(resetStatisticsAction());
yield put(resetMemoryUsageAction());
}
}
export function* login () {
while(true) {
console.log('in saga');
// Wait for the REQUEST_USERS action
//Hard coded for dev
const info = yield take(ACTIONS.REQUEST_LOGIN);
console.log(info);
let formData = new FormData();
formData.append('email', '*****@*****.**');
formData.append('password', 'password123');
try {
console.log('SAGA TIME');
const options = {
method: 'POST',
url: API_URL.login,
params: formData,
};
// Tell redux-saga to call fetch with the specified options
const response = yield call(apiLogin, '*****@*****.**', 'password123');
const parseJson = yield JSON.parse(response);
const activeUser = yield mapActiveUser(parseJson);
yield put(loginResults(activeUser));
const addToken = yield makeToken(activeUser.api_token);
yield info.ctx.setState({signedIn: true, err: false, msg: `You have been logged in.`});
}
catch (err) {
// Send the error
console.log('ERRROR');
console.log(err);
yield put (loginResultsError(err));
yield info.ctx.setState({err: "Wrong Username/Password" , signedIn: false});
}
}
}
function * takeFlashMessages() {
while (DAEMON) {
const action = yield take('flash/ADD_MESSAGE')
log.sagas('Flash added, saga will remove it automatically')
yield fork(timeoutRemoveFlash, action.payload)
}
}
function* read(socket) {
const channel = yield call(subscribe, socket)
while (true) {
let action = yield take(channel)
yield put(action)
}
}
// Watchers
function* watchLoadStations() {
yield take(catFinderActions.LOAD_STATIONS)
const stationData = yield call(services.fetchStationsData)
const stations = services.prepareStations(stationData)
yield put({type: catFinderActions.STATIONS_LOADED, stations})
}
export function* getRecord1Watcher() {
while(true){
let action = yield take(LOAD_RECORD1);
//console.log("getShopWatcher:"+action.placeid);
yield call(getRecord1, [action.master_id]);
}
}
export default function* watchProvidersSaga() {
// eslint-disable-next-line no-constant-condition
while (true) {
yield take(PROVIDERS_FETCH); // wait for PROVIDERS_FETCH event
yield fork(fetchProviders);
}
}
export function* getTodosBoot() {
// Fork watcher so we can continue execution
const watcher = yield fork(getTodosWatcher);
// Suspend execution until location changes
yield take(LOCATION_CHANGE);
yield cancel(watcher);
}
export function * setActiveColumnsSaga () {
while (true) {
const { columns } = yield take(actions.SELECT_ACTIVE_COLUMNS);
const { currentList } = yield select(state => state.lists);
const newColumns = yield call(columnsParser, columns, currentList);
yield put({ type: actions.SET_ACTIVE_COLUMNS, columns: newColumns });
}
}
export function* record3Data() {
// Fork watcher so we can continue execution
const watcher = yield fork(getRecord3Watcher);
// Suspend execution until location changes
yield take(LOCATION_CHANGE);
yield cancel(watcher);
}
function* watchMoveStations() {
while(true) {
const {catOwners} = yield take(catFinderActions.MOVE_STATIONS)
yield call(delay, 1)
const newOwners = services.moveStations(catOwners)
yield put({type: catFinderActions.MOVE_COMPLETED, catOwners: newOwners})
}
}
test('reset Saga test', (t) => {
const generator = reset()
t.deepEqual(
generator.next().value,
take('RESET'),
'reset Saga wait RESET action'
)
t.deepEqual(
generator.next().value,
take('RESET'),
'reset Saga must go back to beginning of loop'
)
t.end()
});
// Individual exports for testing
export default function* defaultSaga() {
yield fork(takeLatest, ON_DELETE_PLUGIN_CONFIRM, deletePlugin);
const loadPluginsWatcher = yield fork(takeLatest, GET_PLUGINS, pluginsGet);
yield take(LOCATION_CHANGE);
yield cancel(loadPluginsWatcher);
}
const watchBlogMount = function* () {
let action;
while (action = yield take(blogActions.GET_POSTS)) {
const blogData = yield call(interceptData, action.url, null, null, true);
yield put(blogActions.setPosts(blogData));
}
};
const watchPostMount = function* () {
let action;
while (action = yield take(postActions.GET_POST)) {
const postData = yield call(interceptData, action.url, null, null, true);
yield put(postActions.setPost(postData));
}
};
const watchDrawerToggled = function* () {
let action;
while (action = yield take(appActions.TOGGLE_APP_DRAWER)) {
console.log('taken');
yield put(appActions.getDrawerData());
}
};
const watchEdition = function* () {
let action;
while (action = yield take(appActions.GET_DRAWER_DATA)) {
const edition = yield call(interceptData, action.endpoint);
yield put(appActions.setDrawerData(edition));
}
};