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()));
}
