protected override Task OnProcess(Func <AppState> getState, PoisonPill action, IMultiDispatcher dispatcher, CancellationToken cancellationToken) { OnProcessExecuted = true; return(base.OnProcess(getState, action, dispatcher, cancellationToken)); }
/// <summary> /// Further processing after `UpdateTodoText` has beed dispatched. /// </summary> /// <param name="getState">Function to get the latest state.</param> /// <param name="action">Instance of action that is being dispatched.</param> /// <param name="dispatcher">Multi-Dispatcher</param> /// <param name="cancellationToken">Cancelation token that can be used to cancel validation step.</param> /// <returns>Awaitable task.</returns> protected override Task OnProcess(Func <TodoList> getState, UpdateTodoText action, IMultiDispatcher dispatcher, CancellationToken cancellationToken) { dispatcher.Dispatch(new HideTodoEditor(action.Id)); return(Task.CompletedTask); }
protected override Task OnProcess(Func <AppState> getState, TestAction action, IMultiDispatcher dispatcher, CancellationToken cancellationToken) { OnProcessExecuted = true; ProcessTask = Task.Delay(10000, cancellationToken); return(ProcessTask); }
protected override async Task OnProcess(Func <AppState> getState, LoginAction action, IMultiDispatcher dispatcher, CancellationToken cancellationToken) { List <Friend> friends = new List <Friend>(); try { cancellationToken.ThrowIfCancellationRequested(); dispatcher.DispatchImmediate(new LoadingFriendListAction()); var state = getState(); friends = await _friendService.GetFriends(state.UserName, state.AuthToken).AsCancelable(cancellationToken).ConfigureAwait(false); } finally { dispatcher.Dispatch(new AddToFriendListAction(friends)); } }
/// <summary> /// Validate the UpdateTodoText action being dispatched. /// </summary> /// <param name="getState">Function to get the latest state.</param> /// <param name="action">Instance of action that is being dispatched.</param> /// <param name="dispatcher">Multi-Dispatcher</param> /// <param name="cancellationToken">Cancelation token that can be used to cancel validation step.</param> /// <returns>Awaitable ValidationResult</returns> protected override Task <ValidationResult> OnValidate(Func <TodoList> getState, UpdateTodoText action, IMultiDispatcher dispatcher, CancellationToken cancellationToken) { if (string.IsNullOrWhiteSpace(action.Text)) { return(Task.FromResult(ValidationResult.Failure(new ValidationException("Cannot update")))); } return(Task.FromResult(ValidationResult.Success())); }
protected override Task <ValidationResult> OnValidate(Func <AppState> getState, string action, IMultiDispatcher dispatcher, CancellationToken token) { return(OnValidation?.Invoke(getState, action, dispatcher) ?? Task.FromResult(ValidationResult.Failure(new ValidationException("No handler", new[] { new ValidationDetails("", "") })))); }
protected override async Task <ValidationResult> OnValidate(Func <AppState> getState, LoginAction action, IMultiDispatcher dispatcher, CancellationToken cancellationToken) { dispatcher.DispatchImmediate(new LoginStartedAction()); string authToken = ""; List <ValidationDetails> validationDetails = new List <ValidationDetails>(); if (string.IsNullOrWhiteSpace(action.UserName)) { validationDetails.Add(new ValidationDetails("UserName", "Username cannot be empty")); } else if (string.IsNullOrWhiteSpace(action.Password)) { validationDetails.Add(new ValidationDetails("Password", "Password cannot be empty")); } else { var result = await _loginService.Login(action.UserName, action.Password); if (!result.Success) { validationDetails.Add(new ValidationDetails("*", "Invalid username/password")); } authToken = result.Token; } if (validationDetails.Count > 0) { return(ValidationResult.Failure(new ValidationException("One or more error occured while loging in.", validationDetails.AsEnumerable()))); } dispatcher.DispatchImmediate(new LoginSuccessfulAction(action.UserName, authToken)); return(ValidationResult.Success()); }
/// <summary> /// Validation occurs after Transformation, but before action are received by reducers. Validation decides whether or not /// reducers will receive this action at all. Validation decissions can be made based on current state and action that is /// being dispatched. It is an async operation, hence is flexible for validation to occur remotely on server, or for scenarios /// where validation may depend on some remote entities etc. /// </summary> /// <param name="getState">Function to get the current state</param> /// <param name="action">Action being dispatched</param> /// <param name="dispatcher">Multi-Dispatcher</param> /// <param name="cancellationToken">Token to request cancelation</param> /// <returns>Asynchronously returns <see cref="ValidationResult"/></returns> protected virtual Task <ValidationResult> OnValidate(Func <TState> getState, TAction action, IMultiDispatcher dispatcher, CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return(Task.FromResult(ValidationResult.Failure(new ValidationException("Cancel requested")))); } return(Task.FromResult(ValidationResult.Success())); }
Task ILogic <TState, TAction> .Process(Func <TState> getState, TAction action, IMultiDispatcher dispatcher) { if (_killed) { // Once fatal poision pill is received don't continue. TaskCompletionSource <object> tcs = new TaskCompletionSource <object>(); tcs.SetCanceled(); return(tcs.Task); } return(OnProcess(getState, action, dispatcher, CancellationTokenSource.Token)); }
/// <summary> /// Asynchronously process the action that has been dispatched to store. /// </summary> /// <param name="getState">Get latest state</param> /// <param name="action">Action that has been dispatched to store</param> /// <param name="dispatcher">Multi-dispatcher</param> /// <param name="cancellationToken">Token to request cancelation</param> /// <returns></returns> protected virtual Task OnProcess(Func <TState> getState, TAction action, IMultiDispatcher dispatcher, CancellationToken cancellationToken) { return(Task.WhenAll()); }
/// <summary> /// Hook to modify logic to decide what happens when validation error occurs. Default implementation is to dispatch the error /// and let reducers/UI to decide. /// </summary> /// <param name="e">Validation error.</param> /// <param name="action">Action which got validated.</param> /// <param name="dispatcher">Multi-dispatcher.</param> protected virtual void OnValidationError(ValidationException e, TAction action, IMultiDispatcher dispatcher) { dispatcher.Dispatch(e); }
/// <summary> /// Validate the AddTodo action being dispatched. /// </summary> /// <param name="getState">Function to get the latest state.</param> /// <param name="action">Instance of action that is being dispatched.</param> /// <param name="dispatcher">Multi-Dispatcher</param> /// <param name="cancellationToken">Cancelation token that can be used to cancel validation step.</param> /// <returns>Awaitable ValidationResult</returns> protected override Task <ValidationResult> OnValidate(Func <TodoList> getState, AddTodo action, IMultiDispatcher dispatcher, CancellationToken cancellationToken) { if (action.Payload == null) { return(Task.FromResult(ValidationResult.Failure(new ValidationException("No todo to add")))); } else if (string.IsNullOrEmpty(action.Payload.Text)) { return(Task.FromResult(ValidationResult.Failure(new ValidationException("Cannot add todo with empty text")))); } return(Task.FromResult(ValidationResult.Success())); }