public async Task<ObjectResource<LoginResource>> LoginAsync(LoginPayload payload) { if (payload == null) { return new ObjectResource<LoginResource> { Code = ResourceCodes.NullPayload, Data = null, Message = "Payload cannot be null" }; } string tokenString = string.Empty; bool validUser = Authenticate(payload); if (validUser) { tokenString = tokenGenerator.BuildJWTToken(); if(tokenGenerator == null) { logger.LogError($"unable to generate token for user {payload.Username}"); return new ObjectResource<LoginResource> { Code = ResourceCodes.InvalidToken, Message = "unable to generate Token" }; } logger.LogInformation($"Successfully generated token for {tokenString}"); return new ObjectResource<LoginResource> { Code = ResourceCodes.Success, Data = new LoginResource { Token = tokenString, UserName = payload.Username }, Message = "Login Successful" }; } else { logger.LogError($"Invalid Login payload: {payload} at {DateTime.Now}"); return new ObjectResource<LoginResource> { Code = ResourceCodes.InvalidLoginDetails, Data = null, Message = "password or username is incorrect" }; } }
public void ConnectToServer() { startMenu.SetActive(false); LoginPayload payload = new LoginPayload { login = username.text, password = password.text }; Packet pck = new Packet { Opcode = (int)Opcode.Opcode.CMSG_AUTH.LOGON_CHALLENGE, Payload = payload }; Client authClient = ClientManager.instance.authClient; authClient.SetAuthenticationPacket(pck); authClient.ConnectToServer(); /* * Network.Packet packet = new Network.Packet * { * Opcode = 0, * Payload = payload * }; * Debug.Log(packet.ToString()); */ }
public static void LoginUser(LoginPayload payload, ResponseCallback callback, ResponseFallback fallback) { HttpClient httpClient = new HttpClient(); Request request = new Request(HttpClient.Method.POST, Route.LOGIN_ROUTE, payload); httpClient.Request( request, (statusCode, response) => { LoginResponse loginResponse = Deserialize(response); callback(loginResponse); }, (statusCode, error) => { if (statusCode == StatusCodes.CODE_VALIDATION_ERROR) { ValidationError validationError = ErrorDeserilizer.DeserializeValidationErrorData(error); fallback(statusCode, validationError); } else { GenericError genericError = ErrorDeserilizer.DeserializeGenericErrorData(error); fallback(statusCode, genericError); } } ); }
public override ActionResult HandleRequest() { string __body = _contextWrapper.GetBody(); LoginPayload __paydload = __body.FromJsonTo <LoginPayload>(); if (__paydload.Password == "xx") { return(new ActionResult() { StatusCode = 401, Content = "Username or password is incorrect" }); } // ========================================================== // User autentication // ========================================================== //var user = new Core.Authentication.User(); //if (user == null) return null; // ========================================================== // Create token // ========================================================== return(new ActionResult() { StatusCode = 200, Content = CreateJwtToken(__paydload.Username) }); }
public async Task <ActionResult> Login([FromBody] LoginPayload loginPayload) { try { var m = new MailAddress(loginPayload.Email); } catch (FormatException) { Response.StatusCode = 400; return(new JsonResult(new { status = "false", message = "email format" })); } var foundUser = _db.Users .SingleOrDefault(u => u.Email == loginPayload.Email); if (foundUser != null) { if (BCrypt.Net.BCrypt.Verify(loginPayload.Password, foundUser.Password)) { var tokenString = GenerateJsonWebToken(foundUser); return(new JsonResult(new { foundUser.Email, foundUser.Id, foundUser.Nume, token = tokenString })); } return(BadRequest(new { status = false, message = "Wrong password or email " })); } return(BadRequest(new { status = false, message = "No user with this email found" })); }
public async Task <bool> LoginAsync(LoginPayload payload) { using var http = _httpFactory.CreateClient(Constants.AUTH_CLIENT_NAME); try { var res = await http.PostAsJsonAsync($"{http.BaseAddress}/login", payload); if (res.IsSuccessStatusCode) { var auth = await res.Content.ReadFromJsonAsync <AuthResponse>(); _localstorage.SetItem(Constants.ACCESS_TOKEN_NAME, auth.Token); _localstorage.SetItem(Constants.USER_DATA_NAME, auth.User); } else { var content = await res.Content.ReadFromJsonAsync <ErrorResponse>(); Console.Error.WriteLine($"Failed to Login: {content?.Message}"); return(false); } } catch (Exception e) { Console.Error.WriteLine(e.Message); return(false); } return(true); }
public async Task <IActionResult> Login([FromBody] LoginPayload loginPayload) { try { MailAddress m = new MailAddress(loginPayload.Email); } catch (FormatException) { return(new JsonResult(new { status = "false", message = "email format" })); } var foundUser = _db.Users .SingleOrDefault(u => u.Email == loginPayload.Email); if (foundUser != null) { if (BCrypt.Net.BCrypt.Verify(loginPayload.Password, foundUser.PasswordHash)) { var tokenString = GenerateJSONWebToken(foundUser); return(new JsonResult(new { status = "true", firstName = foundUser.UserName, Id = foundUser.Id, token = tokenString })); } return(BadRequest(new { status = false, message = "Wrong password or email " })); } else { return(BadRequest(new { status = false, message = "No user with this email found" })); } }
public async Task <IActionResult> Register([FromBody] LoginPayload registerPayload) { try { var existUser = _db.Users .Any(u => u.Email == registerPayload.Email); if (existUser) { //return JS } var userToCreate = new User { FirstName = registerPayload.FirstName, LastName = registerPayload.LastName, Email = registerPayload.Email, PasswordHash = BC.HashPassword(registerPayload.Password), Role = "Default" }; _db.Users.Add(userToCreate); _db.SaveChanges(); return(Ok(new { status = true })); } catch (Exception) { return(new StatusCodeResult(StatusCodes.Status500InternalServerError)); } }
public async Task <IActionResult> Auth([FromBody] LoginPayload payload) { return(await RunDefaultAsync(async() => { var user = await _userBusiness.Login(payload); return Ok(user); })); }
public async Task <ActionResult <TokenProxy> > Authenticate( [FromBody] LoginPayload loginPayload, [FromServices] SigningConfigurations signingConfigurations, [FromServices] TokenConfigurations tokenConfigurations ) { var user = await _context.Set <User>().FirstOrDefaultAsync(u => u.Email == loginPayload.Email); if (user == null) { return(StatusCode(404, new { Message = "O usuário com esse e-mail não foi encontrado", Status = 404 })); } if (user.Password != loginPayload.Password.HashMD5()) { return(BadRequest(new { Message = "A senha está incorreta.", Status = 400 })); } var identity = new ClaimsIdentity( new[] { new Claim(ClaimTypes.Name, user.Id.ToString()), new Claim(ClaimTypes.Role, user.Roles) } ); var dataCriacao = DateTime.Now; var dataExpiracao = dataCriacao + TimeSpan.FromSeconds(tokenConfigurations.Seconds); var handler = new JwtSecurityTokenHandler(); var securityToken = handler.CreateToken(new SecurityTokenDescriptor { Issuer = tokenConfigurations.Issuer, Audience = tokenConfigurations.Audience, SigningCredentials = signingConfigurations.SigningCredentials, Subject = identity, NotBefore = dataCriacao, Expires = dataExpiracao }); var token = handler.WriteToken(securityToken); return(StatusCode(200, new TokenProxy { Created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"), Expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"), Token = $"Bearer {token}" })); }
private bool Authenticate(LoginPayload login) { bool validUser = false; if (login.Username == "Smartace" && login.Password == "Smartace1$") { validUser = true; } return validUser; }
private async Task <IResult> OnLogin(LoginPayload login, IAuthService auth) { var(canLogin, user) = await auth.VerifyUserLoginAsync(login); if (!canLogin || user is null) { return(Results.BadRequest(new ErrorResponse("Credentials Not Valid"))); } var token = auth.SignJwtToken(user); return(Results.Ok(new AuthResponse(token, user))); }
public async Task <ActionResult <string> > LoginAsync([FromBody] LoginPayload loginPayload) { try { var res = await auth.LoginAsync(loginPayload); return(Ok(res)); } catch (AuthException ex) { return(BadRequest(ex.Message)); } }
public HttpResponse <string> Login(LoginPayload payload) { var results = from u in this._dbContext.Users where u.Email == payload.Email && u.Password == payload.Password select u; var result = results.ToList(); if (result.Count() == 0) { return(new BadRequest <string>("Invalid email or password.")); } var user = result[0]; var token = generateToken(user); return(new Ok <string>(token.ToString())); }
public async Task PasswordLogin(IHttpContext context) { var user = await Authenticator.Authenticate(context, AuthenticationMethod.Password); if (user == null) { // Authenticate is responsible for sending the response. return; } var token = Authenticator.GenerateToken(user); context.Response.Headers.Add("Authorization", string.Format("Bearer {0}", token)); await context.SendResponse(HttpStatusCode.OK, LoginPayload.FromToken(token)); }
public void OnLogin(string senderId, LoginPayload loginPayload) { Console.WriteLine(">> Login"); var player = new Player(uidCounter++, loginPayload.Name, new Position(0f, 0f, 0f)); players[player.Uid] = player; var loginResponseRpc = new LoginResponse(new LoginResponsePayload(player.Uid)); var loginResponseJson = JsonConvert.SerializeObject(loginResponseRpc); sendTo(loginResponseJson, senderId); Console.WriteLine(player.ToString() + " login."); }
public async Task LoginAsync_PassValidCredentials_ReturnSuccess() { var collection = GetCollection().BuildServiceProvider(); var authLogin = collection.GetService <IAuthenticationService>(); var tokengenerator = collection.GetService <ITokenGenerator>(); var payload = new LoginPayload { Username = "******", Password = "******" }; var tokenResult = await authLogin.LoginAsync(payload); Assert.Equals(ResourceCodes.Success, tokenResult.Code); }
public async Task <UserProxy> Login(LoginPayload payload) { var user = await _userRepository.GetByUsarname(payload.Username); if (user == null) { throw new InvalidProgramException("Usuário não encontrado."); } if (user.Password != payload.Password.CalculateMd5Hash()) { throw new InvalidProgramException("Senha inválida."); } return(new UserProxy().EntityToProxy(user)); }
/// <summary> /// Converts an audit event to a device event /// </summary> /// <param name="auditEvent">The audit event to be converted</param> /// <returns>Device event based on the input</returns> private IEvent AuditEventToDeviceEvent(AuditEvent auditEvent) { string remoteAddress = auditEvent.GetPropertyValue(AuditEvent.AuditMessageProperty.Address, throwIfNotExist: false); LoginPayload payload = new LoginPayload { Executable = auditEvent.GetPropertyValue(AuditEvent.AuditMessageProperty.Executable), ProcessId = Convert.ToUInt32(auditEvent.GetPropertyValue(AuditEvent.AuditMessageProperty.ProcessId)), UserId = auditEvent.GetPropertyValue(AuditEvent.AuditMessageProperty.LoginUserId, throwIfNotExist: false), UserName = auditEvent.GetPropertyValue(AuditEvent.AuditMessageProperty.Account, throwIfNotExist: false), Result = GetAuditEventLoginResult(auditEvent), RemoteAddress = remoteAddress == "?" ? null : remoteAddress, Operation = auditEvent.GetPropertyValue(AuditEvent.AuditMessageProperty.Operation, throwIfNotExist: false) }; return(new Login(Priority, payload, auditEvent.TimeUTC)); }
public async Task <string> LoginAsync(LoginPayload payload) { var login = await userManager.FindByEmailAsync(payload.Email); if (login is null) { throw new AuthException("Email Or Password Is Incorrect"); } var result = await signInManager.CheckPasswordSignInAsync(login, payload.Password, false); if (result.Succeeded) { return(tokenizer.GenerateToken(("ID", login.UserID), ("Email", login.Email))); } throw new AuthException("Email Or Password Is Incorrect"); }
public LoginResponsePayload Login(LoginPayload payload) { User user = _usersRep.FindOneAsync(x => x.Login == payload.Login).Result; if (user == null) { return(new LoginResponsePayload("error", "Login does not exist!")); } if (!VerifyUserPassword(user, payload.Password)) { return(new LoginResponsePayload("error", "Password is invalid!")); } _currentUser = user; UserInfo currentUserInfo = new UserInfo(_currentUser.Id.ToString(), _currentUser.Login, _currentUser.FirstName, _currentUser.LastName, _currentUser.AssistantChatId, _currentUser.BirthDate); return(new LoginResponsePayload("success", "logged in successfully", Guid.NewGuid().ToString(), currentUserInfo)); }
public ActionResult <User> Login([FromBody] LoginPayload loginPayload) { var foundUser = _db.Users.SingleOrDefault(u => u.Email == loginPayload.Email); if (foundUser != null) { if (BC.Verify(loginPayload.Password, foundUser.PasswordHash)) { var tokenString = GenerateJSONWebToken(foundUser); return(new JsonResult(new { status = true, foundUser.FirstName, foundUser.Id })); } return(new JsonResult(new { status = false, message = "Wrong password or email" })); } else { return(new JsonResult(new { status = false, message = "User does not exist" })); } }
public async Task <IActionResult> Login([FromBody] LoginPayload loginPayload) { var foundUser = _db.Users .SingleOrDefault(u => u.Email == loginPayload.Email); if (foundUser != null) { if (BC.Verify(loginPayload.Password, foundUser.PasswordHash)) { var tokenString = GenerateJSONWebToken(foundUser); return(Ok(new { status = true, token = tokenString })); } return(BadRequest(new { status = false, message = "wrond email or password" })); } else { return(BadRequest(new { status = false, message = "no user with this email found" })); } }
public IActionResult Login(LoginPayload payload) { if (!_db.StudentExists(payload.IndexNumber)) { return(Unauthorized("User not found")); } var SecurityData = _db.GetStudentSecurityData(payload.IndexNumber); Console.WriteLine(SecurityData.PasswordHash); if (String.IsNullOrEmpty(SecurityData.PasswordHash)) { var Salt = HashingService.GenerateSalt(); _db.UpdatePassword( payload.IndexNumber, Salt, HashingService.Hash(payload.PlainPassword, Salt) ); } else if (!HashingService.Check( payload.PlainPassword, SecurityData.Salt, SecurityData.PasswordHash )) { return(Unauthorized("Wrong password")); } var RefreshToken = Guid.NewGuid(); _db.UpdateRefreshToken(payload.IndexNumber, RefreshToken.ToString()); return(Ok(new { AccessToken = new JwtSecurityTokenHandler().WriteToken(_security.GenerateToken( payload.IndexNumber, SecurityData.Role )), RefreshToken = RefreshToken })); }
public async Task <(bool, UserDTO?)> VerifyUserLoginAsync(LoginPayload payload, CancellationToken ct = default) { var result = await _users.FindAsync(user => user.Email !.Equals(payload.Email), null, ct); var user = result.FirstOrDefault(ct); if (user is null) { return(false, null); } return( BCryptNet.EnhancedVerify(payload.Password, user.Password), new UserDTO { Email = user.Email, LastName = user.LastName, Name = user.Name, Id = user.Id } ); }
public static RegisterPersonRequest FromVisitor(Visitor visitor, LoginPayload loginPayload) { return(new RegisterPersonRequest() { vFirst_name = visitor.FirstName, vLast_name = visitor.LastName, vBirth_number = visitor.RC, vEmail = visitor.Email, vPhone_number = visitor.Phone, vMunicipality = visitor.City, vStreet = visitor.Street, vStreet_number = visitor.StreetNo, vPostal_code = visitor.ZIP, vHealth_insurance_company = visitor.Insurance, dBirth_date = $"{visitor.BirthDayYear}-{visitor.BirthDayMonth:D2}-{visitor.BirthDayDay:D2}", vEntered_by_first_name = loginPayload.User.FirstName, vEntered_by_last_name = loginPayload.User.LastName, vEntered_by_email = loginPayload.User.PrimaryEmail, nIs_mom_user = "******", }); }
public async Task <ActionResult> Register([FromBody] LoginPayload payload) { try { var m = new MailAddress(payload.Email); } catch (Exception) { return(new JsonResult(new { status = false, message = "email format " + payload.Email })); } try { var existingUserWithMail = _db.Users .Any(u => u.Email == payload.Email); if (existingUserWithMail) { return(new JsonResult(new { status = false, message = "An account with this email already exists " })); } var userToCreate = new User { Email = payload.Email, Password = BCrypt.Net.BCrypt.HashPassword(payload.Password), Nume = payload.Nume }; await _db.Users.AddAsync(userToCreate); await _db.SaveChangesAsync(); return(Ok()); } catch (Exception ex) { Response.StatusCode = 500; return(new JsonResult(new { error = ex.Message })); } }
public async Task <TokenProxy> Login(LoginPayload payload) { var userEntity = await _usersRepository.GetByLogin(payload.Username); if (userEntity == null) { throw new InvalidArgumentException("Usuário ou senha inválidos!", (int)ExceptionEnum.NotFound); } if (userEntity.Password != payload.Password.CalculateMd5Hash()) { throw new InvalidArgumentException("Usuário ou senha inválidos!", (int)ExceptionEnum.NotFound); } var jwtToken = JwtSecurityToken(userEntity); var tokenProxy = CreateTokenProxy(jwtToken); return(tokenProxy); }
public void Login() { var payload = new LoginPayload { Executable = "app.exe", UserName = "******", UserId = "500", LocalPort = "900", Operation = "opX", ProcessId = 3, RemoteAddress = "10.0.0.1", RemotePort = "70", Result = LoginPayload.LoginResult.Fail }; foreach (LoginPayload.LoginResult value in Enum.GetValues(typeof(LoginPayload.LoginResult))) { payload.Result = value; var obj = new Login(EventPriority.Low, payload, DateTime.UtcNow); obj.ValidateSchema(); } }
public IHttpActionResult Login(LoginPayload bodyPayload) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var adminUser = _userRepository.getAdminUser(); if (bodyPayload.email != adminUser.email) { return(Unauthorized()); } var cookie = new HttpCookie("user-token", new JWTServices().generateJWTToken(adminUser)); cookie.Expires = DateTime.Now.AddHours(1); cookie.Domain = Request.RequestUri.Host; cookie.Path = "/"; cookie.HttpOnly = true; HttpContext.Current.Response.SetCookie(cookie); return(Json(adminUser)); }