public void WhenLoginReturnsAnError()
{
// Arrange
var model = new LoginRequestDto
{
Password = "******",
UserName = "******"
};
var loggedInUser = new LoggedInUserDto
{
UserName = "******"
};
var users = new List <ApplicationUser> {
new ApplicationUser {
UserName = "******"
}
}.AsQueryable();
_userManager = new FakeUserManager(_userStore, users);
_signInManager = new FakeSignInManager(_userStore, users, Microsoft.AspNetCore.Identity.SignInResult.Failed);
_tokenService.Setup(x => x.GenerateJwtToken(It.IsAny <ApplicationUser>())).Returns(new Logic.Models.JsonWebToken("123", 1));
_mapper.Setup(x => x.Map <LoggedInUserDto>(It.IsAny <ApplicationUser>())).Returns(loggedInUser);
var controller = new AccountController(_userManager, _signInManager, _mapper.Object, _tokenService.Object);
// Act
var result = controller.Login(model).Result;
// Assert
Assert.Equal(typeof(BadRequestObjectResult), result.GetType());
}
public async Task <ActionResult <LoggedInUserDto> > Login(UserForLoginDto requestUser)
{
var user = await this.userManager.Users
.Include(u => u.Photos)
.SingleOrDefaultAsync(u => u.UserName == requestUser.Username);
if (user == null)
{
return(Unauthorized("Invalid username."));
}
var result = await this.signInManager.CheckPasswordSignInAsync(user, requestUser.Password, false);
LoggedInUserDto loggedInUserDto = new LoggedInUserDto
{
Id = user.Id,
Username = user.UserName,
Token = await this.authServiceInterface.CreateJwtToken(user),
PhotoUrl = user.Photos.FirstOrDefault(photo => photo.IsMain)?.Url
};
return(Created("", new
{
user = loggedInUserDto
}));
}
public LoggedInUserDto UserAuthenticate(AuthUserDto authUserDto)
{
AuthUserEntity authUserEntity = _userMapping.AuthUserDto2AuthUserEntity(authUserDto);
LoggedInUserEntity loggedInUserEntity = _userService.UserAuthenticate(authUserEntity);
LoggedInUserDto loggedInUserDto = _userMapping.LoggedInUserEntity2LoggedInUserDto(loggedInUserEntity);
return(loggedInUserDto);
}
public ViewViewComponentResult Invoke()
{
var user = _userManager.GetUserAsync(HttpContext.User).Result;
var roles = _userManager.GetRolesAsync(user).Result;
var model = new LoggedInUserDto()
{
User = user,
Roles = roles
};
return(View(model));
}
private LoggedInUserDto GetUserDto(User user)
{
var dto = new LoggedInUserDto
{
Id = user.Id,
FirstName = user.FirstName,
LastName = user.LastName,
Culture = user.Culture,
TimeZone = user.TimeZone,
Email = user.Email
};
return(dto);
}
private string RetrieveJwtToken(LoggedInUserDto user)
{
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(jwtOptions.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.Id.ToString(), ClaimValueTypes.Integer32),
new Claim(ClaimTypes.Role, user.Role.ToString())
}),
Expires = DateTime.UtcNow.AddHours(jwtOptions.JwtExpirationInHours),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
return(tokenHandler.WriteToken(token));
}
private async Task <AuthenticationResultDto> CreateJwtTokenAsync(LoggedInUserDto userDto)
{
var utcUnixTimeString = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
var expUnitTime = DateTimeOffset.UtcNow.AddMinutes(1).ToUnixTimeSeconds();
var claimsIdentity = new ClaimsIdentity();
claimsIdentity.AddClaim(new Claim(JwtRegisteredClaimNames.Iss, _jwtOptions.Issuer));
claimsIdentity.AddClaim(new Claim(JwtRegisteredClaimNames.Sub, userDto.Id.ToString()));
claimsIdentity.AddClaim(new Claim(JwtRegisteredClaimNames.Aud, _jwtOptions.Audience));
claimsIdentity.AddClaim(new Claim(JwtRegisteredClaimNames.Exp, expUnitTime.ToString()));
claimsIdentity.AddClaim(new Claim(JwtRegisteredClaimNames.Nbf, utcUnixTimeString));
claimsIdentity.AddClaim(new Claim(JwtRegisteredClaimNames.Iat, utcUnixTimeString));
//claimsIdentity.AddClaim(new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()));
claimsIdentity.AddClaim(new Claim(JwtRegisteredClaimNames.UniqueName, userDto.Name));
claimsIdentity.AddClaim(new Claim(JwtRegisteredClaimNames.Email, userDto.Email));
claimsIdentity.AddClaim(new Claim(ClaimTypes.Role, userDto.Roles.First()));
var signingCredentials = new SigningCredentials(_jwtOptions.SigningCredentials,
SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(new JwtHeader(signingCredentials),
new JwtPayload(claimsIdentity.Claims));
var accessToken = new JwtSecurityTokenHandler().WriteToken(token);
await _refreshTokenService.DeleteRefreshTokenAsync(userDto.Id);
var refreshTokenDto = new RefreshTokenDto
{
Id = userDto.Id,
Expiration = DateTime.UtcNow.AddDays(30),
Value = Guid.NewGuid().ToString()
};
await _refreshTokenService.CreateRefreshTokenAsync(refreshTokenDto);
return(new AuthenticationResultDto
{
AccessToken = accessToken,
Expiration = expUnitTime,
RefreshToken = refreshTokenDto.Value
});
}
public async Task <UserLoginResponse?> Login(UserLoginRequest request)
{
var user = await _dbContext.Users.SingleOrDefaultAsync(u => u.Email == request.Email);
if (user == null)
{
return(null);
}
var passwordValid = _passwordValidator.Validate(request.Password, user.Password);
if (!passwordValid)
{
return(null);
}
var loggedInUser = new LoggedInUserDto(user.Id, user.GetMainPhoto()?.Url);
return(new UserLoginResponse(loggedInUser, _tokenService.Generate(user)));
}
public LoggedInUserDto Login(UserForLoginDto userForLoginDto)
{
var userFromRepo = _repo.Login(userForLoginDto.Username, userForLoginDto.Password);
if (userFromRepo != null)
{
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, userFromRepo.Id.ToString()),
new Claim(ClaimTypes.Name, userFromRepo.Username)
};
var key = new SymmetricSecurityKey(Encoding.UTF8
.GetBytes(_config.GetSection("AppSettings:Token").Value));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = creds
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
// We can use AutoMapper to return only those info that is required.
var returnObj = new LoggedInUserDto
{
Token = tokenHandler.WriteToken(token),
User = userFromRepo
};
return(returnObj);
}
return(null);
}
public void WhenRegisterReturnsLoggedInUser()
{
// Arrange
var model = new RegisterRequestDto
{
Password = "******",
UserName = "******"
};
var loggedInUser = new LoggedInUserDto
{
UserName = "******"
};
var appUser = new ApplicationUser
{
UserName = "******"
};
var users = new List <ApplicationUser>().AsQueryable();
_userManager = new FakeUserManager(_userStore, users);
_signInManager = new FakeSignInManager(_userStore, users, Microsoft.AspNetCore.Identity.SignInResult.Success);
_tokenService.Setup(x => x.GenerateJwtToken(It.IsAny <ApplicationUser>())).Returns(new Logic.Models.JsonWebToken("123", 1));
_mapper.Setup(x => x.Map <ApplicationUser>(It.IsAny <RegisterRequestDto>())).Returns(appUser);
_mapper.Setup(x => x.Map <LoggedInUserDto>(It.IsAny <ApplicationUser>())).Returns(loggedInUser);
var controller = new AccountController(_userManager, _signInManager, _mapper.Object, _tokenService.Object);
// Act
OkObjectResult result = controller.Register(model).Result as OkObjectResult;
var resultModel = result.Value as Logic.Models.JsonWebToken;
// Assert
Assert.Equal("123", resultModel.Token);
}
public void WhenRegisterReturnsAnErrorBecauseUserAlreadyExists()
{
// Arrange
var model = new RegisterRequestDto
{
Password = "******",
UserName = "******"
};
var loggedInUser = new LoggedInUserDto
{
UserName = "******"
};
var appUser = new ApplicationUser
{
UserName = "******"
};
var users = new List <ApplicationUser> {
new ApplicationUser {
UserName = "******"
}
}.AsQueryable();
_userManager = new FakeUserManager(_userStore, users);
_signInManager = new FakeSignInManager(_userStore, users, Microsoft.AspNetCore.Identity.SignInResult.Failed);
_tokenService.Setup(x => x.GenerateJwtToken(It.IsAny <ApplicationUser>())).Returns(new Logic.Models.JsonWebToken("123", 1));
_mapper.Setup(x => x.Map <ApplicationUser>(It.IsAny <RegisterRequestDto>())).Returns(appUser);
_mapper.Setup(x => x.Map <LoggedInUserDto>(It.IsAny <ApplicationUser>())).Returns(loggedInUser);
var controller = new AccountController(_userManager, _signInManager, _mapper.Object, _tokenService.Object);
// Assert
Assert.Throws <AggregateException>(() => controller.Register(model).Result);
}
public JsonResult Login(AuthUserDto authUserDto)
{
try
{
LoggedInUserDto loggedInUserDto = _userAf.UserAuthenticate(authUserDto);
if (loggedInUserDto != null && loggedInUserDto.IsSuccess == true)
{
string userType;
if (loggedInUserDto.UserType == 1)
{
userType = "User";
}
else if (loggedInUserDto.UserType == 3)
{
userType = "Super Admin";
}
else
{
userType = "Admin";
}
var claims = new List <Claim>
{
new Claim("typeofuser", userType),
new Claim("CreatedBy", loggedInUserDto.CreatedBy),
new Claim("userid", loggedInUserDto.UserID),
new Claim("userid1", loggedInUserDto.UserID),
new Claim("username", loggedInUserDto.UserName),
new Claim("logintime", DateTime.Now.ToString()),
new Claim("usertype", loggedInUserDto.UserType.ToString()),
new Claim("deptid", loggedInUserDto.DeptID.ToString()),
new Claim("clientid", loggedInUserDto.ClientID.ToString()),
new Claim("lobid", loggedInUserDto.LOBID.ToString()),
new Claim("useradmincheck", loggedInUserDto.UserAdminCheck.ToString()),
new Claim("prefix", loggedInUserDto.Prefix),
new Claim("Password", loggedInUserDto.Password),
};
ClaimsIdentity userIdentity = new ClaimsIdentity(claims, "reportuserlogin");
ClaimsPrincipal principal = new ClaimsPrincipal(userIdentity);
HttpContext.SignInAsync("ReportUserCookies", principal, new AuthenticationProperties {
ExpiresUtc = DateTime.UtcNow.AddHours(12)
});
}
else
{
loggedInUserDto.IsSuccess = false;
}
return(Json(loggedInUserDto));
}
catch (Exception ex)
{
_logger.LogError((int)EventLevel.Error, ex, ex.Message);
return(Json(null));
}
}
public UserLoginResponse(LoggedInUserDto loggedInUser, string accessToken)
{
LoggedInUser = loggedInUser;
AccessToken = accessToken;
}
