public async Task SignInHappyPathTest()
{
var loginModel = new LoginModel()
{
Login = "******",
Password = "******"
};
var result = await signInService.SignInAsync(loginModel);
Assert.That(result.Succeeded, Is.True);
}
public async Task <ActionResult> Login(LoginEditModel model)
{
string modelName = Request.Browser.IsMobileDevice ? "MobileLogin" : "Login";
if (!ModelState.IsValid)
{
return(View(modelName, model));
}
string message = string.Empty;
var userAdjust = _userService.FindByTrueName(model.UserName);
if (userAdjust == null)
{
AddError("用户名或密码错误");
return(View(modelName, model));
}
if (userAdjust.IsBlackUser == true)
{
AddError("该用户已被列为黑名单");
}
else
{
if (string.IsNullOrEmpty(model.Password))
{
AddError("请输入密码");
return(View(modelName, model));
}
var getUser = await _userService.FindAsync(model.UserName, model.Password);
//var result = await _userService.AddLoginAsync(getUser.Id, new UserLoginInfo("loginProvider", "providerKey"));//通过User添加登录信息
if (getUser != null)
{
_signInService.SetCurrentUser(getUser);
await _signInService.SignInAsync(getUser, isPersistent : false, rememberBrowser : false);
if (!string.IsNullOrEmpty(model.ReturnUrl) && Request.ApplicationPath != model.ReturnUrl)
{
return(Redirect(WebHelper.ResolveUrl("~/" + model.ReturnUrl)));
}
return(RedirectToAction("Index", "Admin"));
}
AddError("用户名或密码错误");
}
if (Request.Browser.IsMobileDevice)
{
return(View(modelName, model));
}
return(View(modelName, model));
}
public async Task <ActionResult <SignInSecurityTokenDto> > RefreshSignInAsync()
{
// Act.
TokenContext context = await _signInService.SignInAsync(User);
// Map.
var output = _mapper.Map <SignInSecurityTokenDto>(context);
// Return.
return(Ok(output));
}
public async Task <IHttpActionResult> WebPortalLogin(webLoginModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var getUser = await _userService.FindAsync(model.username, model.password);
if (getUser != null)
{
_signInService.SetCurrentUser(getUser);
await _signInService.SignInAsync(getUser, isPersistent : false, rememberBrowser : false);
return(Ok("/swagger"));
}
return(Ok("success"));
}
public void Service__ShouldSignInWithValidCredentials(string username, string password)
{
// ARRANGE
var mockResponse = new Mock <HttpResponseMessage>(HttpStatusCode.OK);
var mockApiService = new Mock <ISignInApiService>();
mockApiService.Setup(s => s.SignInAsync(It.IsAny <UserDto>()))
.ReturnsAsync(mockResponse.Object);
var userDto = new UserDto(username, password);
var service = new SignInService(mockApiService.Object);
// ACT
var response = Should.NotThrow(service.SignInAsync(userDto));
// ASSERT
mockApiService.Verify(s => s.SignInAsync(It.IsAny <UserDto>()), Times.Once);
response.ShouldBeTrue();
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl ??= Url.Content("~/");
if (ModelState.IsValid)
{
//Need to check account.
//if (result is invalid)
switch (_signInService.CheckAccount(Input.Email, Input.Password))
{
case AccountStatus.Banned:
ModelState.AddModelError(string.Empty, "Your account has been banned.");
return(Page());
case AccountStatus.Disabled:
ModelState.AddModelError(string.Empty, "Your account has been disabled.");
return(Page());
case AccountStatus.Unauthenticated:
ModelState.AddModelError(string.Empty, "Invalid credentials.");
return(Page());
case AccountStatus.LockedOut:
ModelState.AddModelError(string.Empty, "Account locked.");
return(Page());
case AccountStatus.PendingVerification:
ModelState.AddModelError(string.Empty, "Your account is pending verification.");
return(Page());
case AccountStatus.Ok:
await _signInService.SignInAsync(Input.Email, Input.RememberMe, HttpContext);
return(LocalRedirect(returnUrl));
}
}
// If we got this far, something failed, redisplay form
ModelState.AddModelError(string.Empty, "An unexpected error occured.");
return(Page());
}
public void Service__ShouldFailSignInWithInvalidCredentials(string username, string password)
{
var shouldFail = !string.IsNullOrWhiteSpace(username) && !string.IsNullOrWhiteSpace(password);
// ARRANGE
var mockResponse = new Mock <HttpResponseMessage>(HttpStatusCode.BadRequest);
var mockApiService = new Mock <ISignInApiService>();
mockApiService.Setup(s => s.SignInAsync(It.IsAny <UserDto>()))
.ReturnsAsync(mockResponse.Object);
var userDto = new UserDto(username, password);
var service = new SignInService(mockApiService.Object);
// ACT
var response = Should.NotThrow(service.SignInAsync(userDto));
// ASSERT
mockApiService.Verify(s => s.SignInAsync(It.IsAny <UserDto>()), Times.Once);
response.ShouldBe(shouldFail);
}
public async Task <ActionResult> ExternalLoginConfirmation(string returnUrl)
{
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await AuthenticationManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
string firstName = info.ExternalIdentity.Claims.FirstOrDefault(u => u.Type == ClaimTypes.GivenName).Value;
string lastName = info.ExternalIdentity.Claims.FirstOrDefault(u => u.Type == ClaimTypes.Surname).Value;
var user = new User {
UserName = info.Email, Email = info.Email, FirstName = firstName, LastName = lastName
};
var createUserResult = await _userService.CreateAsync(user);
if (createUserResult.Succeeded)
{
// Add login.
var addUserResult = await _userService.AddLoginAsync(user.Id, info.Login);
// Add user to the 'User' role.
_userService.AddToRole(user.Id, UserRoles.User);
if (addUserResult.Succeeded)
{
await _signInService.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToLocal(returnUrl));
}
}
}
return(RedirectToLocal(returnUrl));
}
public async Task <IActionResult> Signup(SignUpModel model, string storeName, string returnUrl)
{
if (ModelState.IsValid)
{
var member = new User
{
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = model.PhoneNumber,
};
await _userService.GenerateUserCodeAsync(member);
await _userService.GenerateUserNameAsync(member);
await PrepareStoreAsync(member);
var result = await _userService.CreateAsync(member, model.Password);
if (result.Succeeded)
{
result = await _userService.AddToRolesAsync(member, new[] { RoleNames.Seller, RoleNames.Customer });
if (!result.Succeeded)
{
throw new InvalidOperationException(result.Errors.Select(x => x.Description).Humanize());
}
if (!_signInService.Options.SignIn.RequireConfirmedEmail &&
!_signInService.Options.SignIn.RequireConfirmedPhoneNumber)
{
await _signInService.SignInAsync(member, isPersistent : false);
return(LocalRedirect(returnUrl ?? Url.Action("Index", "Home", new { area = "Portal" })));
}
else
{
var token = await _userService.GenerateEmailConfirmationTokenAsync(member);
var link = Url.Action(nameof(VerifyEmail), "Account", new { userId = member.Id, token, returnUrl }, protocol: Request.Scheme);
await _messageService.SendEmailAsync(
messageRole : MessageRole.Notification,
messageType : MessageType.VerifyEmail,
messageDisplay : "Neimart Support",
email : member.Email,
model : new ValueTuple <User, string>(member, link));
TempData.AddAlert(AlertMode.Alert, AlertType.Success, $"Congratulations! Your account has been created successfully. We'll send you an email within a few minutes with instructions to verify your email address. If the email does not arrive soon, check your spam, junk, and bulk mail folders.", title: "Email Verification Required");
return(RedirectToAction(nameof(Signin), new { returnUrl }));
}
}
else
{
ModelState.AddIdentityResult(result);
}
}
return(RedirectToAction(nameof(Signup), new { storeName, returnUrl }));
}
