public async Task <ActionResult> Create(InternalUserCreationViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var userCreationData = new InternalUserCreationData
{
Email = model.Email,
FirstName = model.Name,
Surname = model.Surname,
Password = model.Password,
ConfirmPassword = model.ConfirmPassword,
ActivationBaseUrl = externalRouteService.ActivateInternalUserAccountUrl,
};
try
{
using (var client = apiClient())
{
var response = await apiClientCredential().GetClientCredentialsAsync();
var userId = await client.User.CreateInternalUserAsync(userCreationData, response.AccessToken);
var loginResult = await weeeAuthorization.SignIn(model.Email, model.Password, false);
if (loginResult.Successful)
{
await client.SendAsync(loginResult.AccessToken, new AddCompetentAuthorityUser(userId));
return(RedirectToAction("AdminAccountActivationRequired"));
}
ModelState.AddModelError(string.Empty, loginResult.ErrorMessage);
}
}
catch (ApiBadRequestException ex)
{
this.HandleBadRequest(ex);
if (ModelState.IsValid)
{
throw;
}
AddRemoveModelStateErrors();
}
catch (SmtpException)
{
ViewBag.Errors = new[] { "The activation email was not sent, please try again later." };
}
return(View(model));
}
public async void HttpPost_Create_ModelIsValid_ShouldIncludeUserDetails()
{
var model = ValidModel();
var newUser = A.Fake <IUnauthenticatedUser>();
var token = A.Fake <TokenResponse>();
var accessToken = "token";
A.CallTo(() => oauthClientCredential.GetClientCredentialsAsync()).Returns(token);
var userCreationData = new InternalUserCreationData();
A.CallTo(() => newUser.CreateInternalUserAsync(A <InternalUserCreationData> ._, token.AccessToken))
.Invokes((InternalUserCreationData u, string t) =>
{
userCreationData = u;
accessToken = token.AccessToken;
})
.Returns(Task.FromResult(A.Dummy <string>()));
A.CallTo(() => apiClient.User).Returns(newUser);
A.CallTo(() => weeeAuthorization.SignIn(A <string> ._, A <string> ._, A <bool> ._))
.Returns(LoginResult.Success("dshadjk", A.Dummy <ActionResult>()));
await AccountController().Create(model);
Assert.Equal(model.Name, userCreationData.FirstName);
Assert.Equal(model.Surname, userCreationData.Surname);
Assert.Equal(model.Email, userCreationData.Email);
Assert.Equal(model.Password, userCreationData.Password);
}
public async Task <ActionResult> SignIn(LoginViewModel model)
{
if (ModelState.IsValid)
{
var loginResult = await weeeAuthorization.SignIn(model.Email, model.Password, model.RememberMe);
if (loginResult.Successful)
{
return(this.LoginRedirect(loginResult.DefaultLoginAction, model.ReturnUrl));
}
ModelState.AddModelError(string.Empty, loginResult.ErrorMessage);
}
return(View(model));
}
public async void HttpPost_ResetPassword_ModelIsValid_CallsApiToResetPassword()
{
var passwordResetModel = new ResetPasswordModel();
A.CallTo(() => unauthenticatedUserClient.ResetPasswordAsync(A <PasswordResetData> ._, A <string> ._))
.Returns(true);
A.CallTo(() => weeeAuthorization.SignIn(A <string> ._, A <string> ._, A <bool> ._))
.Returns(LoginResult.Success("dshjkal", A.Dummy <ActionResult>()));
A.CallTo(() => apiClient.User)
.Returns(unauthenticatedUserClient);
await AccountController().ResetPassword(A.Dummy <Guid>(), A.Dummy <string>(), passwordResetModel);
A.CallTo(() => unauthenticatedUserClient.ResetPasswordAsync(A <PasswordResetData> ._, A <string> ._))
.MustHaveHappened(Repeated.Exactly.Once);
}
