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"); }