public AccountUnlockViewModel RequestAccountUnlockCode(AccountUnlockViewModel model)
{
_logger.Debug("Calling CandidateServiceProvider to request an account unlock code for user {0}",
model.EmailAddress);
try
{
_userAccountService.ResendAccountUnlockCode(model.EmailAddress);
return(new AccountUnlockViewModel {
EmailAddress = model.EmailAddress
});
}
catch (CustomException e)
{
AccountUnlockState status;
switch (e.Code)
{
case Domain.Entities.ErrorCodes.EntityStateError:
status = AccountUnlockState.UserInIncorrectState;
_logger.Info(e.Message, e);
break;
case Application.Interfaces.Users.ErrorCodes.UnknownUserError:
status = AccountUnlockState.AccountEmailAddressOrUnlockCodeInvalid;
_logger.Info(e.Message, e);
break;
default:
status = AccountUnlockState.Error;
_logger.Error(e.Message, e);
break;
}
return(new AccountUnlockViewModel(e.Message)
{
EmailAddress = model.EmailAddress, Status = status
});
}
catch (Exception e)
{
var message = string.Format("Send account unlock code failed for " + model.EmailAddress);
_logger.Error(message, e);
return(new AccountUnlockViewModel(message)
{
EmailAddress = model.EmailAddress, Status = AccountUnlockState.Error
});
}
}
public void Error()
{
var viewModel = new AccountUnlockViewModel {
EmailAddress = "*****@*****.**", ViewModelMessage = "Error", Status = AccountUnlockState.Error
};
var candidateServiceProvider = new Mock <ICandidateServiceProvider>();
candidateServiceProvider.Setup(x => x.RequestAccountUnlockCode(It.IsAny <AccountUnlockViewModel>())).Returns(viewModel);
var userDataProvider = new Mock <IUserDataProvider>();
userDataProvider.Setup(x => x.Push(It.IsAny <string>(), It.IsAny <string>()));
var mediator = new LoginMediatorBuilder().With(candidateServiceProvider).With(userDataProvider).Build();
var response = mediator.Resend(viewModel);
response.AssertMessage(LoginMediatorCodes.Resend.ResendFailed, AccountUnlockPageMessages.AccountUnlockResendCodeFailed, UserMessageLevel.Warning, true);
}
public void AccountEmailAddressOrUnlockCodeInvalid()
{
var viewModel = new AccountUnlockViewModel {
EmailAddress = "*****@*****.**", ViewModelMessage = "Unknown [email protected]", Status = AccountUnlockState.AccountEmailAddressOrUnlockCodeInvalid
};
var candidateServiceProvider = new Mock <ICandidateServiceProvider>();
candidateServiceProvider.Setup(x => x.RequestAccountUnlockCode(It.IsAny <AccountUnlockViewModel>())).Returns(viewModel);
var userDataProvider = new Mock <IUserDataProvider>();
userDataProvider.Setup(x => x.Push(It.IsAny <string>(), It.IsAny <string>()));
var mediator = new LoginMediatorBuilder().With(candidateServiceProvider).With(userDataProvider).Build();
var response = mediator.Resend(viewModel);
response.AssertMessage(LoginMediatorCodes.Resend.ResentSuccessfully, AccountUnlockPageMessages.AccountUnlockCodeMayHaveBeenResent, UserMessageLevel.Success, true);
}
public async Task <ActionResult> Unlock(AccountUnlockViewModel model)
{
return(await Task.Run <ActionResult>(() =>
{
var response = _loginMediator.Unlock(model);
switch (response.Code)
{
case LoginMediatorCodes.Unlock.ValidationError:
ModelState.Clear();
response.ValidationResult.AddToModelState(ModelState, string.Empty);
return View(model);
case LoginMediatorCodes.Unlock.UnlockedSuccessfully:
UserData.Pop(UserDataItemNames.EmailAddress);
SetUserMessage(AccountUnlockPageMessages.AccountUnlockedText);
return RedirectToRoute(RouteNames.SignIn);
case LoginMediatorCodes.Unlock.UserInIncorrectState:
return RedirectToRoute(RouteNames.SignIn);
case LoginMediatorCodes.Unlock.AccountEmailAddressOrUnlockCodeInvalid:
SetUserMessage(AccountUnlockPageMessages.WrongEmailAddressOrAccountUnlockCodeErrorText, UserMessageLevel.Error);
return View(model);
case LoginMediatorCodes.Unlock.AccountUnlockCodeExpired:
SetUserMessage(AccountUnlockPageMessages.AccountUnlockCodeExpired, UserMessageLevel.Warning);
return View(model);
case LoginMediatorCodes.Unlock.AccountUnlockFailed:
SetUserMessage(AccountUnlockPageMessages.AccountUnlockFailed, UserMessageLevel.Warning);
return View(model);
default:
throw new InvalidMediatorCodeException(response.Code);
}
}));
}
public MediatorResponse <AccountUnlockViewModel> Resend(AccountUnlockViewModel accountUnlockViewModel)
{
var validationResult = _resendAccountUnlockCodeViewModelServerValidator.Validate(accountUnlockViewModel);
if (!validationResult.IsValid)
{
return(GetMediatorResponse(LoginMediatorCodes.Resend.ValidationError, accountUnlockViewModel, validationResult));
}
accountUnlockViewModel = _candidateServiceProvider.RequestAccountUnlockCode(accountUnlockViewModel);
_userDataProvider.Push(UserDataItemNames.EmailAddress, accountUnlockViewModel.EmailAddress);
if (accountUnlockViewModel.HasError())
{
if (accountUnlockViewModel.Status == AccountUnlockState.UserInIncorrectState || accountUnlockViewModel.Status == AccountUnlockState.AccountEmailAddressOrUnlockCodeInvalid)
{
return(GetMediatorResponse(LoginMediatorCodes.Resend.ResentSuccessfully, accountUnlockViewModel, AccountUnlockPageMessages.AccountUnlockCodeMayHaveBeenResent, UserMessageLevel.Success));
}
return(GetMediatorResponse(LoginMediatorCodes.Resend.ResendFailed, accountUnlockViewModel, AccountUnlockPageMessages.AccountUnlockResendCodeFailed, UserMessageLevel.Warning));
}
return(GetMediatorResponse(LoginMediatorCodes.Resend.ResentSuccessfully, accountUnlockViewModel, AccountUnlockPageMessages.AccountUnlockCodeMayHaveBeenResent, UserMessageLevel.Success));
}
