public async Task <RequestResult <UserViewModel> > LoginAsync(LoginUserRequestModel loginModel) { var result = new RequestResult <UserViewModel>(); try { User user = string.IsNullOrEmpty(loginModel.Email) ? await _userManager.FindByNameAsync(loginModel.Username) : await _userManager.FindByEmailAsync(loginModel.Email); if (user == null || !await _userManager.CheckPasswordAsync(user, loginModel.Password)) { result.Errors = new[] { "Incorrect username or password." }; return(result); } var userViewModel = new UserViewModel().SetFrom(user); userViewModel.Token = GenerateAuthenticationToken(user); result.Obj = userViewModel; result.SetStatusOK(); } catch (Exception ex) { result.SetInternalServerError(); _logger.LogException(ex); } return(result); }
public async Task <ActionResult <string> > Login(LoginUserRequestModel loginUserRequestModel) { var user = await _userManager.FindByNameAsync(loginUserRequestModel.UserName); if (user == null) { return(Unauthorized()); } var isPasswordValid = await _userManager.CheckPasswordAsync(user, loginUserRequestModel.Password); if (!isPasswordValid) { return(Unauthorized()); } var tokenHandler = new JwtSecurityTokenHandler(); var key = Encoding.ASCII.GetBytes(_appSettings.Secret); var tokenDescriptor = new SecurityTokenDescriptor { Subject = new ClaimsIdentity(new Claim[] { new Claim(ClaimTypes.Name, user.Id.ToString()) }), Expires = DateTime.UtcNow.AddDays(7), SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature) }; var token = tokenHandler.CreateToken(tokenDescriptor); var encryptedToken = tokenHandler.WriteToken(token); return(encryptedToken); }
public async Task <Result <LoginModel> > Login(LoginUserRequestModel model) { if (model == null) { throw new ArgumentNullException(nameof(model)); } var user = await this.userManager.FindByNameAsync(model.Username); if (user == null) { return(Result <LoginModel> .Error("Username or password are invalid")); } var validationResult = await this.userManager.CheckPasswordAsync(user, model.Password); if (!validationResult) { return(Result <LoginModel> .Error("Username or password are invalid")); } return(Result <LoginModel> .Success( new LoginModel { ProfileUrl = user.ProfileUrl, Token = this.GenerateJwtToken(user), })); }
public async Task <IActionResult> Login([FromBody] LoginUserRequestModel model) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, false, false); if (!result.Succeeded) { return(BadRequest("Could not login")); } var user = await _userManager.FindByEmailAsync(model.Email); var token = await BuildToken(user); return(Ok(token)); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public async Task <ActionResult <ResultModel <LoginResponseModel> > > Login(LoginUserRequestModel model) { var result = await this.identityService.LoginAsync(model.Username, model.Password, appSettings.Secret); if (!result.Success) { return(this.Unauthorized(new { result.Errors })); } return(result); }
public async Task <ActionResult> Login(LoginUserRequestModel model) { var result = await this.identityService.Login(model); if (result.IfHaveError) { return(BadRequest(result)); } return(Ok(result)); }
public async Task <ActionResult <LoginResponseModel> > Login([FromBody] LoginUserRequestModel model) { var user = await _userManager.FindByNameAsync(model.Username); if (user != null && await _userManager.CheckPasswordAsync(user, model.Password)) { var response = new LoginResponseModel() { Token = _identityEngine.GenerateJwtToken(_appSettings.JwtSecret, user.Id, user.UserName) }; return(Ok(response)); } return(Unauthorized()); }
public async Task <ActionResult <TokenResponse> > Login(LoginUserRequestModel model) { TokenResponse token; try { token = await _service.LogIn(model); } catch (Exception ex) { return(Unauthorized(ex.Message)); } return(token); }
public IActionResult Login([FromBody] LoginUserRequestModel login) { try { var token = _authenticationService.Authenticate(login); return(Ok(new { token = token.Item1, user = token.Item2, })); } catch (AuthenticationException) { return(Unauthorized()); } }
public async Task <TokenResponse> LogIn(LoginUserRequestModel model) { LoginResponse result = new(); try { result = await _repository.LogIn(model); } catch (Exception) { throw; } var token = GenerateToken(result.ID, result.Username, "this is secret this is secret this is secret this is secret this is secret this is secret this is secret"); return(new TokenResponse { Token = token }); }
public async Task <LoginResponse> LogIn(LoginUserRequestModel model) { var user = await UserManager.FindByEmailAsync(model.Email); if (user == default) { throw new System.Exception("User was not found"); } var passwordValid = await UserManager.CheckPasswordAsync(user, model.Password); if (!passwordValid) { throw new System.Exception("password doesnot match"); } return(new LoginResponse { Username = user.UserName, ID = user.Id }); }
public async Task <ResultModel> Login([FromBody] LoginUserRequestModel requestModel) { if (!ModelState.IsValid) { return(new ResultModel { Message = "Invalid data", Status = Status.Error, Data = string.Join("", ModelState.Keys.Select(e => "<li>" + e + "</li>")) }); } var user = await userManager.FindByNameAsync(requestModel.UserName); var checkPw = await userManager.CheckPasswordAsync(user, requestModel.Password); if (user != null && checkPw) { var identity = new ClaimsIdentity(CookieAuthenticationDefaults.AuthenticationScheme); identity.AddClaim(new Claim(ClaimTypes.NameIdentifier, user.ID)); identity.AddClaim(new Claim(ClaimTypes.Name, user.UserName)); await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(identity)); return(new ResultModel { Status = Status.Success, Message = "Succesfull login", Data = requestModel }); } else { return(new ResultModel { Status = Status.Error, Message = "Invalid data", Data = "<li>Invalid Username or Password</li>" }); } }
public async Task <ActionResult <object> > Login(LoginUserRequestModel model) { User user = await this.userManager.FindByNameAsync(model.Username); if (user == null) { return(Unauthorized()); } bool passwordValid = await this.userManager.CheckPasswordAsync(user, model.Password); if (!passwordValid) { return(Unauthorized()); } return(new { Token = this.identityService.GenerateJwtToken(user, this.appSettings.Secret) }); }
public async Task <ActionResult <string> > Login(LoginUserRequestModel model) { using (var transaction = _dbContext.Database.BeginTransaction()) { if (model.Password == null) { return(BadRequest(new { message = "Bad data" })); } if (model.Password.Length < 6) { return(BadRequest(new { message = "Bad data" })); } var user = await this.userManager.FindByEmailAsync(model.Email); if (user == null) { return(Unauthorized("Email is not registered!")); } //KOMENTARISATI KAKO BI SE ULOGOVALi //var isEmailConfirmed = await this.userManager.IsEmailConfirmedAsync(user); //if (!isEmailConfirmed) //{ // return Unauthorized("Email is not confirmed!"); //} var passwordValid = await this.userManager.CheckPasswordAsync(user, model.Password); if (!passwordValid) { return(Unauthorized("Wrong password!")); } var token = generateJwtToken(user); transaction.Commit(); return(Ok(new { token })); } }
public ActionResult <CommonResponeModel> Login(LoginUserRequestModel model) { var LoginResponeModel = new LoginResponeModel(); //login success if (userRepository.IsValidUser(model.Username, model.Password)) { Result = new SuccessResultFactory().Factory(ActionType.Login); LoginResponeModel.TokenExpireDate = DateTime.Now.AddDays(1); LoginResponeModel.Token = TokenProvider.GenerateTokenString(model.ToDictionaryStringString()); LoginResponeModel.User = userRepository.GetDataTransferByUsername(model.Username); } else //login fail { Result = new ErrorResultFactory().Factory(ActionType.Login); } //set data Data = LoginResponeModel; return(GetCommonRespone()); }
public async Task <IActionResult> Login(LoginUserRequestModel model) { var user = await userManager.FindByEmailAsync(model.Email); if (user == null) { return(Unauthorized()); } var passwordValid = await userManager.CheckPasswordAsync(user, model.Password); if (!passwordValid) { return(Unauthorized()); } var result = new LoginResponseModel { Token = identityService.GenerateJwtToken(user, appSettings.Secret) }; return(Ok(result)); }
public async Task <RequestResult> LoginAsync(LoginUserRequestModel loginUser) { return(await _userService.LoginAsync(loginUser)); }