/// <summary> /// The login action. /// </summary> /// <param name="username">The username.</param> /// <param name="password">The password.</param> /// <returns>Redirect to index view result.</returns> public ActionResult Login(string username, string password) { // Build the request var request = new AuthenticateRequest { Username = username, Password = password }; // Call the service and get a response AuthenticateResponse response; using (var client = new AuthenticationServiceClient()) { response = client.AuthenticateUser(request); } // If not authenticated, make a note for model state if (!response.IsAuthenticated) { TempData.Add("Authentication", "The username/password did not match any user."); } // Redirect to the index view return RedirectToAction("Index"); }
public async Task <IActionResult> UserAuthentication(AuthenticateRequest loginUser) { if (ModelState.IsValid) { var result = await _userService.AuthenticateUser(loginUser.Email, loginUser.Password); if (result.IsSuccess) { Response.Headers.Add("Authorization", result.Token); return(Ok(result)); } } return(BadRequest("Something went wrong")); }
public AuthenticateResponse Authenticate(AuthenticateRequest model) { var user = _users.SingleOrDefault(x => x.Username == model.Username && x.Password == model.Password); // return null if user not found if (user == null) { return(null); } // authentication successful so generate jwt token var token = generateJwtToken(user); return(new AuthenticateResponse(user, token)); }
public AuthenticateResponse Authenticate(AuthenticateRequest body) { var user = _users.SingleOrDefault(x => x.UserName == body.Username && x.Password == body.Password); //Return null when user not found if (user == null) { return(null); } var token = generateJwtToken(user); return(new AuthenticateResponse(user, token)); }
public AuthenticateResponse Authenticate(AuthenticateRequest request) { var user = _users.SingleOrDefault(x => x.Username == request.Username && x.Password == request.Password); if (user == null) { return(null); } // authentication successful so generate jwt token var token = GenerateJwtToken(user); return(new AuthenticateResponse(user, token)); }
public string GetToken(AuthenticateRequest request) { var token = string.Empty; var user = _userService.GetAll() .FirstOrDefault(x => x.Username == request.Username && x.Password == request.Password ); if (user != null) { token = _userService.generateToken(user); } return(token); }
public ActionResult <AuthenticateResponse> Login([FromBody] AuthenticateRequest login) { var resultado = _loginService.validateUser(login); if (resultado != null) { var token = generateJwtToken(resultado); return(new AuthenticateResponse(resultado, token)); } else { return(Unauthorized()); } }
public IActionResult Register([FromBody] AuthenticateRequest request) { var user = Models.User.From(request); try { _userService.Create(user, request.Password); return(Ok()); } catch (AppException ex) { return(BadRequest(new { message = ex.Message })); } }
public async Task <IActionResult> Index(AuthenticateRequest req) { try { if (ModelState.IsValid) { var user = await _context.Users .FirstOrDefaultAsync(u => u.UserName.ToLower().Equals(req.UserName.ToLower()) && u.Deleted != 1); if (user == null) { TempData["Error"] = "Wrong username or password"; return(RedirectToAction("Index")); } if (!verifyPassword(req.Password, user.Password)) { TempData["Error"] = "Wrong username or password"; return(RedirectToAction("Index")); } var jwtToken = generateJwtToken(user); var response = new AuthenticateResponse { FullName = user.FullName, Id = user.ID, UserName = user.UserName, Token = jwtToken, }; if (response != null) { setTokenCookie(response.Token); TempData["Success"] = MESSAGE_SUCCESS; return(RedirectToAction("Index", "Home")); } TempData["Error"] = "Something wrong"; return(RedirectToAction("Index")); } return(View(req)); } catch (Exception ex) { TempData["Error"] = ex.Message; return(RedirectToAction("Index")); } }
public async Task <ActionResult <AuthenticateResponse> > Authenticate([FromBody] AuthenticateRequest request) { var user = _user.Authentificate(request.Username, request.Password); if (user is null) { return(NotFound()); } var tokenString = CreateToken(user); AuthenticateResponse response = CreateResponse(tokenString, user); return(Ok(response)); }
public async Task <AuthenticateResponse> Authenticate(AuthenticateRequest model) { var user = await _context.User.FirstOrDefaultAsync(x => x.Name == model.Username && x.Password == model.Password); if (user == null) { return(null); } var token = generateJwtToken(user); return(new AuthenticateResponse(new User { Username = user.Name }, token)); }
public void Initialize() { userService = new Mock <IUserService>(); logger = new Mock <ILogger <LoginController> >(); loginController = new LoginController(logger.Object); var user = new User { Cpf = "01234567895", Email = "*****@*****.**", Name = "Teste", Role = "Usuario", CreatedAt = new DateTimeOffset(), Id = "5f0e43f02f695b5ae0d8526e" }; authenticateResponse = new AuthenticateResponse(user, "5f0e43f02f695b5ae0d8526e"); authenticateRequest = new AuthenticateRequest { Email = "*****@*****.**", Password = "******" }; }
public async Task <AuthenticateResponse> Authenticate(AuthenticateRequest model) { var user = await GetUser(model.Mail, model.Password); if (user == null) { return(null); } // authentication successful so generate jwt token var token = generateJwtToken(user); return(new AuthenticateResponse(user, token)); }
public async Task <IActionResult> Authenticate(AuthenticateRequest request) { Guard.AgainstNull(request, nameof(request)); var(valid, response) = await _userService.Authenticate( email : request.Email, password : request.Password, getExpires : () => DateTime.Now.AddDays(1) ); return(!valid ? (IActionResult)Unauthorized() : Ok(response)); }
/** * get token from etcd with name and password. * * @param channel channel to etcd * @param username auth name * @param password auth password * @return authResp */ private static AuthenticateResponse Authenticate(Channel channel, ByteSequence username, ByteSequence password) { AuthenticateRequest requet = new AuthenticateRequest { Name = username.ToString(), Password = password.ToString() }; Auth.AuthClient authClient = new Auth.AuthClient(channel); var rsp = authClient.Authenticate(requet); AuthenticateResponse response = new AuthenticateResponse(rsp); return(response); }
public async Task <AuthenticateResponse> Authenticate(AuthenticateRequest model) { var user = await _userRepo.GetUserByUserName(model.Username); if (user != null && PasswordUtility.CheckPassword(user.PasswordHash, model.Password)) { var token = generateJwtToken(user); return(new AuthenticateResponse(user, token)); } else { return(null); } }
private void Authenticate() { if (log.IsDebugEnabled) { log.DebugFormat("TestClient, Authenticate {0}", userId); } var operation = new AuthenticateRequest { Token = this.token }; var request = new OperationRequest((byte)OperationCode.Authenticate, operation); this.gameServerClient.SendOperationRequest(request, new SendParameters()); }
public AuthenticateResponse Authenticate(AuthenticateRequest model) { // return null if user not found if (model.Username == null) { return(null); } // authentication successful so generate jwt token var token = generateJwtToken(model); return(token); }
public async Task <AuthenticateResponse> Authenticate(AuthenticateRequest model) { //var a = new Guid(); //chú ý, async func đi với async, nên khi func nào dùng cái này cũng thành async func var b = model.UserName; var user = await _userManager.FindByNameAsync(b); var userRole = await _userManager.GetRolesAsync(user); var token = GenerateJwtToken(user, userRole); var response = new AuthenticateResponse(user, token); return(response); }
public AuthenticateResponse Authenticate(AuthenticateRequest model) { var user = _dbContext.Users.SingleOrDefault(o => o.Username == model.Username); // return null if user not found if (user == null || !_hashService.Verify(model.Password, user.PasswordHash)) { return(null); } // authentication successful so generate jwt token var token = GenerateJwtToken(user); return(new AuthenticateResponse(user, token)); }
public async Task <IActionResult> Login(AuthenticateRequest request) { string response = string.Empty; // Sign user using the ASP.NET Identity platform. Microsoft.AspNetCore.Identity.SignInResult result = await _signInManager.PasswordSignInAsync(request.Username, request.Password, false, true); if (result.Succeeded) { response = await _tokenClaimsService.GetTokenAsync(request.Username); } return(Ok(response)); }
public IActionResult Authenticate([FromBody] AuthenticateRequest request) { request.Password = EncryptionService.Encrypt(request.Password, jwtOptions.Secret); User user = _context.Users.FirstOrDefault(x => x.Email == request.Email && x.Password == request.Password); if (user == null) { return(BadRequest(new AuthResponse { Message = "Prisijungti nepavyko, patikrinti įvestį." })); } return(Ok(GenerateAuthentificationResultForUser(user))); }
public AuthenticateResponse Authenticate(AuthenticateRequest request) { var user = users.Find(u => u.Email == request.UserName && u.Password == Helpers.GetSHA256Hash(request.Password)); if (user == null) { return(new AuthenticateResponse()); } var token = GenerateJwtToken(user); return(new AuthenticateResponse(user, token)); }
public async Task <AuthenticateResponse> AuthenticateAsync(AuthenticateRequest model) { var user = await _user.Find(u => u.UserId == model.UserId && u.Password == model.Password).FirstOrDefaultAsync(); if (user == null) { return(null); } // authentication successful so generate jwt token var token = generateJwtToken(user); return(new AuthenticateResponse(user, token)); }
public async Task <IActionResult> RefreshToken([FromBody] AuthenticateRequest authenticateRequest) { var refreshToken = Request.Cookies["refeshToken"]; var response = await _userService.RefreshToken(refreshToken); if (refreshtoken == null) { return(BadRequest(new { message = "Invalid username or password" })); } SetCookieToken(response.RerfershTokens); return(Ok(response)); }
public AuthenticateResponse Authenticate(AuthenticateRequest model) { var user = _users.SingleOrDefault (x => x.Username == model.Username && x.Password == model.Password); if (user == null) { return(null); } var token = generateJwt(user); return(new AuthenticateResponse(user, token)); }
public async Task <AuthenticateResponse> Authenticate(AuthenticateRequest model) { var hash = GetPasswordHash(model.Password); var user = await _context.Users.FirstOrDefaultAsync(x => model.UserName == x.UserName && hash == x.PasswordHash); if (user == null || user.PasswordHash != hash) { return(null); } var token = GenerateJwtToken(user); return(new AuthenticateResponse(user, token)); }
public async Task <IActionResult> Login([FromBody] AuthenticateRequest login) { if (login != null) { var remoteIp = Request.HttpContext.Connection.RemoteIpAddress?.ToString(); var result = await _accountService.Authenticate(login, remoteIp); if (result != null) { return(Ok(result)); } } return(BadRequest("Invalid username or password")); }
public AuthenticateResponse Authenticate(AuthenticateRequest model) { var admin = context.Admins.SingleOrDefault(x => x.Username == model.Username); // return null if user not found if (admin == null || !BC.Verify(model.Password, admin.Password)) { return(null); } // authentication successful so generate jwt token var token = generateJwtToken(admin); return(new AuthenticateResponse(admin, token)); }
public AuthenticateResponse Authenticate(AuthenticateRequest req) { User user = _users.SingleOrDefault(x => x.UserName == req.UserName && x.Password == req.Password); if (user == null) { return(null); } AuthenticateResponse res = new AuthenticateResponse(); res.Token = GetJWTToken(user); return(res); }
public AuthenticateResponse Authenticate(AuthenticateRequest model) { var account = _context.Accounts.SingleOrDefault(x => x.Email == model.Email && x.Password == HashPassword(model.Password)); // return null if user not found if (account == null) { return(null); } // authentication successful so generate jwt token var token = generateJwtToken(account); return(new AuthenticateResponse(account, token)); }
public static HttpSelfHostServer Create(string url) { /*AppDomain.CurrentDomain.FirstChanceException += (object source, FirstChanceExceptionEventArgs e) => { Console.WriteLine("FirstChanceException event raised in {0}: {1}", AppDomain.CurrentDomain.FriendlyName, e.Exception.Message); };*/ var config = new HttpSelfHostConfiguration(url); config.Routes.MapHttpRoute("API Default", "api/{controller}/{id}", constraints: null, defaults: new {id = RouteParameter.Optional}); config.Formatters.JsonFormatter.SerializerSettings.Formatting = Formatting.Indented; config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new StringEnumConverter()); HeimdallConfig.AllowPath("/api/clone"); HeimdallConfig.AllowPath("/api/clones"); HeimdallConfig.AllowPath("/api/clonesdelete"); HeimdallConfig.AllowPath("/api/cloneskill"); HeimdallConfig.AllowPath("/api/executeasync"); HeimdallConfig.AllowPath("/api/execute"); HeimdallConfig.AllowPath("/api/exit"); HeimdallConfig.AllowPath("/api/info"); HeimdallConfig.AllowPath("/api/ping"); HeimdallConfig.AllowPath("/api/trace"); HeimdallConfig.AllowPath("/api/upload"); var authenticateRequest = new AuthenticateRequest(new UserRepository()); config.MessageHandlers.Add(new HmacAuthenticationHandler(authenticateRequest)); var server = new HttpSelfHostServer(config); server.OpenAsync().Wait(); return server; }
/// <summary> /// Authenticates a user. /// </summary> /// <param name="request">The request.</param> /// <returns>The resposne.</returns> public AuthenticateResponse AuthenticateUser(AuthenticateRequest request) { AuditStack.Push(request); try { var response = new AuthenticateResponse(); using (var tx = new TransactionScope()) using (var session = Db.OpenSession()) { var user = session.Query<User>().FirstOrDefault(x => x.Username == request.Username && x.Password == request.Password); if (user == null) { response.IsAuthenticated = false; } else { response.IsAuthenticated = true; user.NumberOfLogins++; session.Store(user); session.SaveChanges(); } tx.Complete(); } AuditStack.Push(response); return response; } catch (Exception ex) { ElmahLogger.Log(ex); throw; } }
/// <summary> /// Starts the authentication process /// </summary> /// <returns></returns> public IStatusIndicator Authenticate() { AuthenticateRequest request = new AuthenticateRequest(_ctx); return (request.Execute() as IStatusIndicator); }