public new void SetUp()
{
base.SetUp();
AuthLoginRequest = null;
AuthLoginResponse = null;
Exception = null;
}
public async Task <IActionResult> Login([FromBody] AuthLoginRequest request)
{
var profilis = _authService.BuildLoginRequest(request);
var isUserExists = await _context.Profiliai.AnyAsync(x => x.Pastas.Equals(profilis.Pastas));
if (!isUserExists)
{
return(NotFound("Paskyra neegzistuoja"));
}
var hashedPassword = _authService.HashedPassword(request.Password);
var isPasswordExists = await _context.Profiliai.AnyAsync(x => x.Password.Equals(hashedPassword));
if (!isPasswordExists)
{
return(NotFound("Blogas slaptažodis"));
}
var user = await _context.Profiliai.Where(x => x.Pastas.Equals(profilis.Pastas)).FirstOrDefaultAsync();
var passwordExists = await _context.Profiliai.Where(x => x.Password.Equals(hashedPassword)).FirstOrDefaultAsync();
var tokenHandler = new JwtSecurityTokenHandler();
var token = await _authService.TokenGenerator(user, tokenHandler);
return(Ok(new AuthLoginResponse {
ID = user.Id, Name = user.Vardas, Token = tokenHandler.WriteToken(token)
}));
}
public async Task Login__User_Token_Should_Have_Role_Claim()
{
User user = Factory.UserFactory.GetModel("Admin");
user.Email = user.Email.ToLower();
await Context.Users.AddAsync(user);
await Context.SaveChangesAsync();
AuthLoginRequest loginRequest = Factory.Auth.AuthLoginRequest(user.Email);
var response = await Client.PostAsJsonAsync(ApiRoutes.Auth.Login, loginRequest);
var loginResponse = await response.Content.ReadAsAsync <AuthSuccessResponse>();
var handler = new JwtSecurityTokenHandler();
var token = handler.ReadJwtToken(loginResponse.Token);
var role = token.Claims.FirstOrDefault(x => x.Type == "role")?.Value;
var dbUser = await Context.Users.FirstOrDefaultAsync(x => x.Email == loginRequest.Email.ToLower());
var dbRole = await Context.Roles.FirstOrDefaultAsync(x => x.Name == role);
dbRole.Should().NotBeNull();
role.Should().Be(dbRole.Name);
dbUser.RoleId.Should().Be(user.RoleId);
}
public async Task <IActionResult> LoginAsync(
[FromBody] AuthLoginRequest request,
[FromServices] JwtConfiguration jwtConfiguration)
{
try
{
var identityUser = await _identityUserManager.FindByNameAsync(request.Username);
if (identityUser is null)
{
return(NotFound());
}
var signInResult = await _signInManager.PasswordSignInAsync(
identityUser,
request.Password,
isPersistent : false,
lockoutOnFailure : false);
if (!signInResult.Succeeded)
{
return(BadRequest());
}
var chatUser = await _chatUserManager.GetUserAsync(request.Username);
var jwtConfig = jwtConfiguration.GetSchemeConfig(JwtSchemes.User);
var jwtClaims = new Claim[]
{
new Claim(JwtRegisteredClaimNames.Sub, chatUser !.Id.ToString()),
new Claim(JwtRegisteredClaimNames.UniqueName, request.Username),
};
var signingCredentials = new SigningCredentials(
key: jwtConfig.SecurityKey,
algorithm: JwtConfiguration.SecurityAlgorithm
);
var createdAt = DateTime.UtcNow;
var validBefore = createdAt.AddMinutes(5);
var token = new JwtSecurityToken(
issuer: jwtConfig.Issuer,
audience: jwtConfig.Audience,
claims: jwtClaims,
notBefore: createdAt,
expires: validBefore,
signingCredentials: signingCredentials);
return(new JsonResult(new AuthLoginResponse(
userId: chatUser !.Id,
auth: new AuthTokenResponse(
accessToken: new JwtSecurityTokenHandler().WriteToken(token),
createdAt: createdAt.ToString("o"),
validBefore: validBefore.ToString("o")))));
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Login failed.");
return(BadRequest("Could not complete login."));
}
}
public HttpResponseMessage Authenticate(AuthLoginRequest authLoginRequest)
{
bool isAuthentic = _authLoginInfoRepository.Authenticate(ObjectMapper.Instance.Map<AuthLoginInfoPoco>(authLoginRequest));
return new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(_serializationService.Serialize(isAuthentic), Encoding.Unicode)
};
}
private void When_A_User_With_A_Repeated_Username_Is_Created()
{
AuthLoginRequest = new AuthLoginRequest
{
PlainPassword = RandomData.String(),
UserName = AuthLoginRequest.UserName
};
Exception = Catcher.Try(() => AuthLoginResponse = AuthServiceClient.Client.Create(AuthLoginRequest).Result);
}
public Profiliai BuildLoginRequest(AuthLoginRequest request)
{
var profilis = new Profiliai
{
Password = request.Password,
Pastas = request.Pastas,
};
return(profilis);
}
public async Task <ActionResult <AuthLoginResponse> > LoginAsync(
[FromBody] AuthLoginRequest request)
{
if (await _auth.LoginAsync(request.User, request.Password).ConfigureAwait(false))
{
return(Ok(new AuthLoginResponse {
User = request.User
}));
}
return(Unauthorized());
}
protected void Given_An_Invalid_User(string userName = null, string password = null)
{
userName = userName.IfNullThen(RandomData.String());
password = password.IfNullThen(RandomData.String());
AuthLoginRequest = new AuthLoginRequest
{
PlainPassword = password,
UserName = userName
};
}
public async Task Login__Non_Existing_User_Cant_Login()
{
User user = Factory.UserFactory.GetModel();
user.Email = user.Email.ToLower();
AuthLoginRequest loginRequest = Factory.Auth.AuthLoginRequest(user.Email);
var response = await Client.PostAsJsonAsync(ApiRoutes.Auth.Login, loginRequest);
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public async Task Login__Fields_Are_Required()
{
foreach (PropertyInfo propertyInfo in typeof(AuthLoginRequest).GetProperties())
{
AuthLoginRequest loginRequest = Factory.Auth.AuthLoginRequest();
propertyInfo.SetValue(loginRequest, "");
var response = await Client.PostAsJsonAsync(ApiRoutes.Auth.Login, loginRequest);
response.StatusCode.Should().Be(HttpStatusCode.UnprocessableEntity);
}
}
protected void When_A_User_Is_Created(string userName = null, string password = null)
{
userName = userName.IfNullThen(RandomData.String());
password = password.IfNullThen(RandomData.String());
AuthLoginRequest = new AuthLoginRequest
{
PlainPassword = password,
UserName = userName
};
Exception = Catcher.Try(() => AuthLoginResponse = AuthServiceClient.Client.Create(AuthLoginRequest).Result);
}
public async Task <AuthLoginResponse> LoginAndStoreAsync(AuthLoginRequest body,
CancellationToken cancellationToken)
{
Logout();
var result = await LoginAsync(body, cancellationToken);
if (result.Code == 0 && !string.IsNullOrEmpty(result.Data.Token))
{
_accessToken = result.Data.Token;
}
return(result);
}
public IActionResult Login(AuthLoginRequest authLogin)
{
var resp = GetLoginResponse(authLogin);
if (resp.Success)
{
return(Ok(resp));
}
else
{
return(BadRequest(resp));
}
}
public async Task <IActionResult> Login([FromBody] AuthLoginRequest request)
{
var authResponse = await _authService.LoginAsync(request);
if (!authResponse.Success)
{
return(BadRequest(new ErrorResponse(authResponse.Error)));
}
return(Ok(new AuthSuccessResponse
{
Token = authResponse.Token,
RefreshToken = authResponse.RefreshToken
}));
}
private AuthReponse GetLoginResponse(AuthLoginRequest authLogin)
{
var objResp = new AuthReponse();
try
{
if (authLogin != null)
{
if (authLogin.Email == "*****@*****.**")
{
if (authLogin.Password == "p123")
{
objResp = _jwtManager.GenerateToken(authLogin.Email, "Admin");
}
else
{
objResp.Error = new ErrorResponse {
Errors = new List <string> {
"Invalid password"
}
}
};
}
else
{
objResp.Error = new ErrorResponse {
Errors = new List <string> {
"Invalid user"
}
}
};
}
else
{
objResp.Error = new ErrorResponse {
Errors = new List <string> {
"Invalid inputs"
}
}
};
}
catch (Exception ex)
{
}
return(objResp);
}
public async Task <IActionResult> LoginAsync([FromBody] AuthLoginRequest request)
{
var employee = await EmployeeRepository.GetByEmailAsync(request.Email);
if (employee == null)
{
throw new InvalidCredentialsException();
}
if (!HashHelper.AreSameHashes(employee.Password, request.Password))
{
throw new InvalidCredentialsException();
}
var authTokenDto = AuthenticationService.GenerateToken(employee);
return(Ok(authTokenDto));
}
public HttpResponseMessage Create(AuthLoginRequest authLoginRequest)
{
if (!_authLoginInfoRepository.IsUsernameAvailable(authLoginRequest.UserName))
{
return new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent("User name already exists")
};
}
var authLoginId = _authLoginInfoRepository.Create(ObjectMapper.Instance.Map<AuthLoginInfoPoco>(authLoginRequest));
AuthLoginResponse response = ObjectMapper.Instance.Map<AuthLoginResponse>(authLoginRequest);
response.AuthLoginId = authLoginId;
return new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(_serializationService.Serialize(response), Encoding.Unicode)
};
}
public async Task <IResponseEntity> LoginAsync(AuthLoginRequest req)
{
var password = MD5Encrypt.Encrypt32(req.Password);
SysUserEntity user = new SysUserEntity();
using (_userRepository.DataFilter.Disable("Group"))
{
user = await _userRepository.GetAsync(a => a.UserName == req.UserName && a.Password == password);
}
if (user?.Id == "")
{
return(ResponseEntity.Error("账号或密码错误!"));
}
var res = await getUserItem(user);
return(ResponseEntity.Ok(res));
}
public async Task Login__Existing_User_Can_Login()
{
User user = Factory.UserFactory.GetModel();
user.Email = user.Email.ToLower();
await Context.Users.AddAsync(user);
await Context.SaveChangesAsync();
AuthLoginRequest loginRequest = Factory.Auth.AuthLoginRequest(user.Email);
var response = await Client.PostAsJsonAsync(ApiRoutes.Auth.Login, loginRequest);
response.StatusCode.Should().Be(HttpStatusCode.OK);
var registerResponse = await response.Content.ReadAsAsync <AuthSuccessResponse>();
registerResponse.Token.Should().NotBeNullOrEmpty();
registerResponse.RefreshToken.Should().NotBeNullOrEmpty();
}
public async Task <AuthLoginResponse> Login(Guid businessId, AuthLoginRequest request)
{
var user = await UserManager.FindByEmailAsync(request.Email);
if (user == null)
{
throw new KeyNotFoundException("Invalid Email");
}
var check = await SignInManager.CheckPasswordSignInAsync(user, request.Password, false);
if (!check.Succeeded)
{
throw new AppException("Invalid Password");
}
if (user.BusinessId != businessId)
{
throw new AppException("Invalid, User not registered to this business");
}
var roles = await UserManager.GetRolesAsync(user);
var response = AuthHelper.WriteJwt(user, roles, _appSettings);
var returnValue = new AuthLoginResponse()
{
Email = user.Email,
Name = user.FullName,
Id = user.Id,
PhoneNumber = user.PhoneNumber,
Token = response.Token,
TokenExpirationDate = response.Expiration
};
return(returnValue);
}
public async Task <AuthenticationResult> LoginAsync(AuthLoginRequest request)
{
request.Email = request.Email.ToLower();
User user = await _context.Users.FirstOrDefaultAsync(u => u.Email == request.Email);
if (user == null)
{
return new AuthenticationResult {
Error = "Użytkownik nie istnieje"
}
}
;
if (!_authHelper.VerifyPasswordHash(request.Password, user.PasswordHash, user.PasswordSalt))
{
return new AuthenticationResult {
Error = "Podano błędne hasło"
}
}
;
return(await GenerateAuthenticationResultAsync(user));
}
public async Task <IActionResult> Login([FromRoute] Guid businessId, [FromBody] AuthLoginRequest request)
{
var response = await AuthLogin.Login(businessId, request);
return(Ok(response));
}
public async Task <IResponseEntity> Login(AuthLoginRequest req)
{
var sw = new Stopwatch();
sw.Start();
var res = (await _authService.LoginAsync(req)) as IResponseEntity;
sw.Stop();
if (!res.Success)
{
return(res);
}
else
{
var user = (res as IResponseEntity <AuthLoginResponse>).Data;
#region 写登录日志
string ua = HttpContext.Request.Headers["User-Agent"];
var client = UAParser.Parser.GetDefault().Parse(ua);
var device = client.Device.Family;
var loginLogAddRequest = new LoginLogAddRequest()
{
CreatedBy = user.Id,
CreatedByName = user.UserName,
RealName = user.DisplayName,
ElapsedMilliseconds = sw.ElapsedMilliseconds,
Status = res.Success,
Message = res.Message,
Browser = client.UA.Family,
Os = client.OS.Family,
Device = device.ToLower() == "other" ? "" : device,
BrowserInfo = ua,
Ip = IPHelper.GetIP(HttpContext?.Request)
};
await _loginLogService.CreateAsync(loginLogAddRequest);
#endregion
#region 构造JWT Token
var claims = new Claim[] {
new Claim(ClaimAttributes.UserId, user.Id.ToString()),
new Claim(ClaimAttributes.UserName, user.UserName),
new Claim(ClaimAttributes.DisplayName, user.DisplayName),
new Claim(ClaimAttributes.PermissionId, user.PermissionId)
};
var token = _authToken.Build(claims);
#endregion
var data = new
{
token,
uuid = user.Id,
info = new
{
id = user.Id,
name = user.UserName,
displayName = user.DisplayName,
avatar = user.Avatar,
menus = user.Menus,
functionPoints = user.FunctionPoints
}
};
return(ResponseEntity.Ok(data));
}
}
public Task <AuthLoginResponse> LoginAndStoreAsync(AuthLoginRequest body)
{
return(LoginAndStoreAsync(body, System.Threading.CancellationToken.None));
}
public async Task<bool> Authenticate(AuthLoginRequest authLoginRequest)
{
return await PostWithObjectContentAsync<bool, AuthLoginRequest>(authLoginRequest, "v1/Auth/Authenticate");
}
public async Task<AuthLoginResponse> Create(AuthLoginRequest authLoginRequest)
{
return await PostWithObjectContentAsync<AuthLoginResponse, AuthLoginRequest>(authLoginRequest, "v1/Auth/Create");
}
