public async Task <ActionResult <UserToken> > CreateUser([FromBody] UserInfoToken model) { try { var user = new ApplicationUserToken { UserName = model.Email, Email = model.Email }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { return(_tokenService.BuildToken(model)); } else { return(BadRequest("Usuário ou senha inválidos")); } } catch (Exception e) { return(NotFound(new { message = e.Message, errorCode = (int)HttpStatusCode.NotFound })); } }
public async Task <ActionResult <UserTokenDTO> > Register([FromBody] UserRegisterDTO userRegisterDTO) { var identityResult = await _authenticationService.RegisterAsync(userRegisterDTO); if (!identityResult.Succeeded) { return(BadRequest(identityResult.Errors)); } return(await _tokenService.BuildToken(userRegisterDTO)); }
public async Task <IActionResult> Login(string userAccessToken) { if (userAccessToken == string.Empty) { return(BadRequest()); } var appToken = await _facebookService.CreateAppAccessTokenAsync(_configuration["Facebook:AppID"], _configuration["Facebook:AppSecret"]); var userIsValid = await _facebookService.CheckTokenValidityAsync(userAccessToken, appToken); if (!userIsValid) { return(BadRequest()); } var userData = await _facebookService.GetUserDataAsync(userAccessToken); var userClaims = await _facebookService.Login(userData); var token = _tokenService.BuildToken(userClaims, DateTime.Now.AddDays(1)); return(Ok(new UserViewModel { Token = token, Username = userClaims.Email })); }
public IActionResult Login(UserCredentialsDTO credentials) { if (!IsCredentialsObjectValid(credentials)) { return(BadRequest()); } var user = _userService.GetAll().FirstOrDefault(x => x.Name == credentials.Username); if (user == null) { return(new NotFoundResult()); } if (!string.IsNullOrWhiteSpace(user.HashedPassword)) { //TODO: Hash the supplied password and compared it hashed password on the user object } var token = _tokenService.BuildToken( _config["Jwt:Key"].ToString(), _config["Jwt:Issuer"].ToString(), user); return(new ContentResult { Content = token, StatusCode = 200 }); }
public IActionResult Login(UserModel userModel) { if (string.IsNullOrEmpty(userModel.UserName) || string.IsNullOrEmpty(userModel.Password)) { return(RedirectToAction("Error")); } IActionResult response = Unauthorized(); var validUser = GetUser(userModel); if (validUser != null) { generatedToken = _tokenService.BuildToken(_config["Jwt:Key"].ToString(), _config["Jwt:Issuer"].ToString(), validUser); if (generatedToken != null) { HttpContext.Session.SetString("Token", generatedToken); return(RedirectToAction("mainwindow")); } else { return(RedirectToAction("Error")); } } else { return(RedirectToAction("Error")); } }
public async Task <Result <AuthToken> > TryRegister(RegisterInput input) { var errors = new Dictionary <string, List <string> >() { { "email", new List <string>() }, { "login", new List <string>() }, }; if (await _context.Users.AnyAsync(x => x.Email.ToLower() == input.Email.ToLower())) { errors["email"].Add("Ten adres e-mail został już użyty!"); } if (await _context.Users.AnyAsync(x => x.Login.ToLower() == input.Login.ToLower())) { errors["login"].Add("Ten login jest już używany"); } if (errors.Any(x => x.Value.Any())) { return(new Result <AuthToken>(false, null, errors, ErrorType.BadRequest)); } var user = User.CreateUser(input.Login, input.UserName, input.Email, 50.MBtoKB()); user.PasswordHash = _hasher.HashPassword(user, input.Password); var token = _tokenService.BuildToken(user); token.DiskInfo = new LoginDiskInfo { DiskId = user.DiskId, DiskName = user.Disk.Name, FolderId = user.Disk.FolderId }; var result = await _context.Users.AddAsync(user); var changedRows = await _context.SaveChangesAsync(); if (changedRows == 0) { return(new Result <AuthToken>(false, null, "Coś poszło nie tak. Spróbuj później", ErrorType.Internal)); } return(new Result <AuthToken>(true, token)); }
private string BuildVerificationEmailContent(User user) { var userClaims = _mapper.Map <UserClaimsDto>(user); var token = _tokenService.BuildToken(userClaims, DateTime.Now.AddDays(30)); return($"<a href=\"htt" + $"p://localhost:3000/verify/{token}\" > <H2>VERIFY</H2> </a> "); }
public async Task <OperationResult <JwtToken> > CreateToken(string email, string password) { User user = await userManager.FindByEmailAsync(email); if (user == null) { return(OperationResult <JwtToken> .Invalid("Login failed: invalid e-mail or password.")); } OperationResult result = await signInManager.CheckPasswordSignInAsync(user, password, lockoutOnFailure : false); if (!result.IsValid) { return(result.Cast <JwtToken>()); } var encodedToken = tokenService.BuildToken(user); return(OperationResult <JwtToken> .Valid(new JwtToken(encodedToken))); }
public async Task <ActionResult <UserToken> > PostUsuario(UsuarioVM usuarioVM) { var result = await _usuarioRepository.Criar(_mapper.Map <Usuario>(usuarioVM)); if (result.Equals(Resultado.Falha)) { ModelState.AddModelError("Error", "Não foi possível criar o usuário."); return(BadRequest(ModelState)); } return(_tokenService.BuildToken(usuarioVM.Email)); }
public async Task <IActionResult> CreateToken([FromBody] LoginService login) { IActionResult response = Unauthorized(); var user = await _token.Authenticate(login); if (user != null) { var tokenString = await _token.BuildToken(user); response = Ok(new { token = tokenString }); } return(response); }
public async Task <ActionResult <string> > Login(LoginViewModel model) { try { int userId = await _usersService.LoginUser(model); string token = _tokenService.BuildToken(userId); return(Ok(token)); } catch (Exception ex) { return(NotFound()); } }
public async Task <OperationResult <JwtToken> > ConfirmEmailChange(string userId, string email, string token) { User user = await userManager.FindByIdAsync(userId); OperationResult result = await emailConfirmationService.ConfirmEmailChange(user, email, token); if (!result.IsValid) { return(result.Cast <JwtToken>()); } // the information in the user's token is stale after the e-mail change // - generate and send a new token with current user info var encodedToken = tokenService.BuildToken(user); return(OperationResult <JwtToken> .Valid(new JwtToken(encodedToken))); }
public async Task <IActionResult> Login([FromBody] UserModel user) { if (!await ValidateModel(user)) { return(BadRequest()); } var userEntity = await _mediator.Send(new GetUserByUsernameRequest { Username = user.Username }); if (_cipherService.ValidatePasswordAgainstHash(user.Password, userEntity.PasswordSalt, userEntity.Password)) { return(Ok(new TokenResult { Token = _tokenService.BuildToken(user.Username) })); } return(BadRequest()); }
public async Task <ActionResult <UserToken> > Login([FromBody] CredenciaisVM credenciais) { var userIdentity = await _userManager.FindByNameAsync(credenciais.UserName); if (userIdentity == null) { return(FalhaLogin()); } var result = await _signInManager.PasswordSignInAsync(userIdentity, credenciais.Password, false, false); if (!result.Succeeded) { return(FalhaLogin()); } return(_tokenService.BuildToken(userIdentity.Email)); }
public async Task Invoke(HttpContext context) { IHeaderDictionary requestHeaders = context.Request.Headers; context.Response.OnStarting(() => { if (requestHeaders.TryGetValue("Authorization", out StringValues previousHeader)) { var previousJwt = new JwtSecurityToken(previousHeader.ToString().Replace("Bearer ", string.Empty)); var id = previousJwt.Claims.Where(x => x.Type == "Id").First().Value; var updatedToken = _tokenService.BuildToken(id); context.Response.Headers.Add("Authorization", updatedToken); } return(Task.CompletedTask); }); await _next(context); }
public ActionResult Login(UserModel userModel) { if (string.IsNullOrEmpty(userModel.UserName) || string.IsNullOrEmpty(userModel.Password)) { return(RedirectToAction("Error")); } IActionResult response = Unauthorized(); var user = _userRepositoryService.GetUser(userModel); if (user != null) { var generatedToken = _tokenService.BuildToken(_configuration["Jwt:Key"].ToString(), _configuration["Jwt:Issuer"].ToString(), user); return(Ok(new { token = generatedToken, user = user.UserName })); } return(RedirectToAction("Error")); }
public async Task <IActionResult> Login([FromBody] LoginViewModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } UserViewModel result = null; try { result = await _userService.FindUser(model); var jwtToken = _tokenService.BuildToken(result.Id); return(Ok(new { auth_token = jwtToken, user_id = result.Id })); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
public async Task <LoginRpsModel> Login(string userName, string password, string packType) { if (string.IsNullOrWhiteSpace(userName)) { throw new MyException(_localizer["用户名不能为空"]); } if (string.IsNullOrWhiteSpace(password)) { throw new MyException(_localizer["密码不能为空"]); } var user = await _userRepository.Query(x => x.UserName == userName).FirstOrDefaultAsync(); if (user == null) { throw new MyException(_localizer["用户名未注册"]); } //检查登录次数 //检查密码 //创建token //先删除以前的 //删除已有的token var rm = new LoginRpsModel() { UserId = user.Id, UserName = user.UserName, Token = null }; await _tokenService.DelToken(user.Id, packType); rm.Token = await _tokenService.BuildToken(new TokenInfo(user) { PackType = packType }); return(new LoginRpsModel() { }); }
public async Task <(LoginRpsModel rpsModel, ClaimsPrincipal principal)> Login(string userName, string password) { if (string.IsNullOrWhiteSpace(userName)) { throw new HopexException(_localizer["用户名不能为空"]); } if (string.IsNullOrWhiteSpace(password)) { throw new HopexException(_localizer["密码不能为空"]); } var user = await _adminUserRepository.Query(x => x.UserName == userName && x.IsValid && x.IsDeleted == false).SingleOrDefaultAsync(); if (user == null) { throw new HopexException(_localizer["用户不存在"]); } if (!HashUtil.PasswordHashCheck(user.Salt, user.PasswordHash, password)) { throw new HopexException(_localizer["密码不正确"]); } var(token, principal) = await _tokenService.BuildToken(new TokenInfo() { UserName = user.UserName, UserId = user.Id, IsAdmin = user.IsAdmin }); return(new LoginRpsModel() { UserId = user.Id, Token = token }, principal); }
public async Task <IActionResult> Login([FromBody] AddUserDto userDto) { UserClaimsDto user = await _service.Login(userDto); if (user == null) { return(Unauthorized()); } if (!user.Verified) { return(Forbid()); } string tokenString = _tokenService.BuildToken(user, DateTime.Now.AddDays(1)); var userViewModel = new UserViewModel { Username = user.UserName, Token = tokenString }; return(Ok(userViewModel)); }
public async Task <IActionResult> Authenticate([FromBody] UserDto userDto) { #region test //var details = _context.Users.Where(user => user.Username == input.Username).FirstOrDefault(); //PasswordService.GetPasswordHash(out byte[] passHash, details.PasswordSalt); //var results = await _signInManager.PasswordSignInAsync( // input.Username, // System.Text.Encoding.Default.GetString(passHash), // rememberMe, // lockoutOnFailure: false); //if (results.Succeeded) //{ // _logger.LogInformation("User logged in succesfully."); //} //Return the user info to client #endregion test var user = await _authenticationService.Authenticate(userDto.Email, userDto.Password); if (user == null) { return(BadRequest(new { message = "Username or password is incorrect" })); } return(Ok(new { Id = user.EncodedId, Username = user.Username, FirstName = user.FirstName, LastName = user.LastName, Token = _token.BuildToken(user) })); }
public async Task <UserToken> CreateUserAsync(RegisterViewModel model) { UserToken userToken = new UserToken(); try { var user = new ApplicationUser { UserName = model.Email, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, PhoneNumber = model.MobileNo, RegistrationTime = DateTime.Now }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { var roles = await _roleManager.Roles.CountAsync(); if (roles > 0) { var roleAssignResult = await _userManager.AddToRoleAsync(user, "User"); if (roleAssignResult.Succeeded) { var role = await _userManager.GetRolesAsync(user); var userInfo = new UserInfo { Email = model.Email, Name = $"{model.FirstName} {model.LastName}", Username = model.Email, Roles = role, UserId = user.Id }; userToken = _tokenService.BuildToken(userInfo); userToken.Status = "success"; return(userToken); } } else { IdentityRole role = new IdentityRole { Name = "User" }; var resultRole = await _roleManager.CreateAsync(role); if (resultRole.Succeeded) { var roleAssignResult = await _userManager.AddToRoleAsync(user, "User"); if (roleAssignResult.Succeeded) { var roleElse = await _userManager.GetRolesAsync(user); var userInfo = new UserInfo { Email = model.Email, Name = $"{model.FirstName} {model.LastName}", Username = model.Email, Roles = roleElse, UserId = user.Id }; userToken = _tokenService.BuildToken(userInfo); userToken.Status = "success"; return(userToken); } } } } } catch (Exception ex) { userToken.Status = ex.Message; return(userToken); } userToken.Status = "failed"; return(userToken); }
public IActionResult CreateJwtWithIdClaim([FromBody] string id) { var token = _tokenService.BuildToken(id); return(Ok(new { status = "success", token })); }