public IEnumerable<ClaimModel> Login(string email, string password, out string message) { int status = 0; var request = new UserLoginRequest() { Email = email, Password = password }; var userInfo = client.Login(request, out status, out message); if (userInfo != null && userInfo.UserId > 0) { var claims = new List<ClaimModel>(); var properties = userInfo.GetType().GetProperties(); foreach (var prop in properties) { string att = prop.Name; string value = string.Empty; if (prop.GetValue(userInfo, null) != null) { value = prop.PropertyType != typeof(Dictionary<string, string>) ? prop.GetValue(userInfo, null).ToString() : ""; } claims.Add(new ClaimModel(att, value)); } return claims; } return null; }
public async Task <IActionResult> Login([FromBody] UserLoginRequest request) { if (request == null) { return(BadRequest()); } var authResponse = await _identityService.LoginAsync(request.Email, request.Password); if (!authResponse.Success) { return(BadRequest(new AuthFailedResponse { Errors = authResponse.Errors })); } return(Ok(new AuthSuccessResponse { Token = authResponse.Token, RefreshToken = authResponse.RefreshToken })); }
public MainResponse LoginUser(UserLoginRequest userLoginRequest) { string encodePassword = EncryptDecryptHelper.GetMd5Hash(userLoginRequest.Password); var userDetails = _userRepository.GetSingle(x => x.UserName == userLoginRequest.UserName.ToLower() && x.Password == encodePassword && x.IsActive == true && x.IsDeleted == false); if (userDetails != null) { if (userDetails.IsApproved == true) { var userRole = _userRoleRepository.GetSingle(x => x.UserId == userDetails.UserId); if (userRole != null) { var role = _roleRepository.GetSingle(x => x.RoleId == userRole.RoleId); var userResponse = _mapper.Map <UserResponse>(userDetails); userResponse.Role = role.RoleName; _mainResponse.UserResponse = userResponse; } else { var userResponse = _mapper.Map <UserResponse>(userDetails); _mainResponse.UserResponse = userResponse; } _mainResponse.Message = Constants.LOG_IN; _mainResponse.Success = true; } else { _mainResponse.Message = Constants.ADMIN_APPROVAL; _mainResponse.Success = false; } } else { _mainResponse.Message = Constants.USERNAME_PASSWORD_INCORRECT; _mainResponse.Success = false; } return(_mainResponse); }
public async Task <ActionResult <string> > SignIn([FromForm] UserLoginRequest form) { var user = await(from x in _db.Users where x.Email == form.Email select x).FirstOrDefaultAsync(); if (user == null) { return(BadRequest("Email wrong !")); } if (!BC.Verify(form.Password, user.Password)) { return(BadRequest("Password wrong !")); } var token = JWTTool.GeneraToken(user); return(Ok(new { token = new JwtSecurityTokenHandler().WriteToken(token), expiration = token.ValidTo })); }
public async Task <IActionResult> Register([FromBody] UserLoginRequest userRegistrationRequest) { if (!ModelState.IsValid) { return(BadRequest(new AuthFailedResponse() { Errors = ModelState.Values.SelectMany(x => x.Errors.Select(y => y.ErrorMessage)) })); } var authResponse = await this.identity.Register(userRegistrationRequest); if (!authResponse.Success) { return(BadRequest(authResponse.ErrorMessage)); } return(Ok(new AuthResponse() { Token = authResponse.Token })); }
public async Task <IActionResult> Login(UserLoginRequest request) { try { var _userInfo = await _facade.AutenticateUser(request); if (_userInfo != null) { return(Ok(new { token = GenerarTokenJWT(_userInfo) })); } else { return(Unauthorized()); } } catch (Exception ex) { log.Error(new Exception(), ex.Message); } return(null); }
public IActionResult Login([FromBody] UserLoginRequest request) { try { var authResponse = _authService.Login(request.Email, request.Password); if (authResponse.Success) { return(Ok(new LoginSuccessResponse { Token = authResponse.Token })); } return(BadRequest(new LoginFailedResponse { Error = authResponse.Error })); } catch (Exception ex) { return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message)); } }
/// <summary> /// 用户登陆 /// </summary> /// <param name="userName"></param> /// <param name="password"></param> /// <returns></returns> public string LoginIn(string userName, string password) { string resultToken = ""; try { string apiName = "token"; UserLoginRequest user = new UserLoginRequest() { username = userName, password = password }; string json = JsonConvert.SerializeObject(user); string resultStr = HttpHelper.HttpUrlSend(apiName, "POST", json); UserLoginResponse resultInfo = JsonConvert.DeserializeObject <UserLoginResponse>(resultStr); resultToken = resultInfo.sessionToken; } catch (Exception ex) { WPFClientCheckWordUtil.Log.TextLog.SaveError(ex.Message); } return(resultToken); }
public async Task <IActionResult> UserLogin([FromBody] UserLoginRequest userObj) { if (!ModelState.IsValid) { return(BadRequest(new AuthFailedResponse { Errors = ModelState.Values.SelectMany(x => x.Errors.Select(xx => xx.ErrorMessage)) })); } var AuthResponse = await _identityService.LoginAsync(userObj.Email, userObj.Password); if (!AuthResponse.Success) { return(BadRequest(new AuthFailedResponse { Errors = AuthResponse.Errors })); } return(Ok(new AuthSuccessResponse { Token = AuthResponse.Token })); }
public UserResponse loginUser(UserLoginRequest userLoginRequest) { var response = new HttpResponseMessage(); try { using (var context = new HackathonEntities()) { var user = context.users.FirstOrDefault(x => x.email.Equals(userLoginRequest.email) && x.delete_ts != null); if (user == null) { response = Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Email supplied does not match account in our records."); throw new HttpResponseException(response); } var success = unHashPassword(user.password, userLoginRequest.password); if (!success) { response = Request.CreateErrorResponse(HttpStatusCode.BadRequest, "User email and password combination does not match our records."); throw new HttpResponseException(response); } return(new UserResponse() { id = user.id, email = user.email, firstName = user.first_name, lastName = user.last_name }); } } catch (Exception e) { throw new HttpResponseException(response); } }
public ActionResult Index(UserLoginRequest model) { model.Recaptcha = Request["g-recaptcha-response"]; if (string.IsNullOrEmpty(model.Recaptcha)) { ViewBag.ScriptUp = $"ShowError('{ConfigurationManager.AppSettings.Get("Recaptcha.Empty")}');"; return(View(model)); } if (ModelState.IsValid) { var recaptchaResponse = userBLL.ValidateCaptcha(model.Recaptcha); if (!(recaptchaResponse.IsSuccess && recaptchaResponse.Result)) { ViewBag.ScriptUp = $"ShowError('{ConfigurationManager.AppSettings.Get("Recaptcha.Invalid")}');"; return(View(model)); } Response <User> response = userBLL.Login(model); if (response.Message.Count > 0) { ViewBag.ScriptUp = response.Message.FirstOrDefault().Message; } if (response.IsSuccess && response.Result != null) { FormsAuthentication.SignOut(); string userName = Convert.ToString(response.Result.Id); SessionHelper.Id = Convert.ToString(response.Result.Id); SessionHelper.Role = response.Result.Role; SessionHelper.Name = response.Result.UserName; //Set the Form Aunthentication Cookie FormsAuthentication.SetAuthCookie(userName, true); return(RedirectToAction("Index", "Home")); } } //return RedirectToAction("Index", "Account", new { ViewBag.ScriptUp } ); return(View(model)); }
public async Task <IActionResult> Login([FromBody] UserLoginRequest request) { if (!ModelState.IsValid) { return(BadRequest(UserLoginResponse.Failed(Resource.InvalidPayload))); } var existingUser = await _UserManager.FindByEmailAsync(request.Email); if (existingUser == null) { return(BadRequest(UserLoginResponse.Failed(Resource.InvalidLoginRequest))); } var isCorrect = await _UserManager.CheckPasswordAsync(existingUser, request.Password); if (!isCorrect) { return(BadRequest(UserLoginResponse.Failed(Resource.InvalidLoginRequest))); } //убедиться что Email подтвержден bool emailConfirmed = await _UserManager.IsEmailConfirmedAsync(existingUser); if (!emailConfirmed) { return(BadRequest(UserLoginResponse.Failed(Resource.EmailNotConfirmed))); } var jwtToken = _GenerateJwtToken(existingUser); return(Ok(new RegistrationResponse() { Success = true, Token = jwtToken.JWT, Expires = jwtToken.Expires })); }
public AuthenticatedUser Login(UserLoginRequest request) { var entity = _context.Users.FirstOrDefault(x => x.UserName == request.UserName); #region User existence check if (entity == null) { throw new UserException("Wrong username or password"); } var hash = GenerateHash(entity.PasswordSalt, request.Password); if (hash != entity.PasswordHash) { throw new UserException("Wrong username or password"); } #endregion #region Token var tokenHandler = new JwtSecurityTokenHandler(); var key = Encoding.ASCII.GetBytes(_options.Value.Secret); var tokenDescriptor = new SecurityTokenDescriptor { Subject = new ClaimsIdentity(new Claim[] { new Claim(ClaimTypes.NameIdentifier, entity.Id.ToString()), new Claim(ClaimTypes.Name, entity.UserName), }), Expires = DateTime.UtcNow.AddDays(7), SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256) }; var token = tokenHandler.CreateToken(tokenDescriptor); #endregion var user = _mapper.Map <AuthenticatedUser>(entity); user.Token = tokenHandler.WriteToken(token); return(user); }
public async Task <bool> LoginAsync(UserLoginRequest loginRequest) { var user = await _userService.LoginAsync <UserLoggedResponse>(loginRequest); if (user == null) { return(false); } var claims = new List <Claim> { new Claim(nameof(user.Id), user.Id.ToString()), new Claim(nameof(user.Email), user.Email) }; var id = new ClaimsIdentity(claims, "ApplicationCookie", nameof(user.Email), ClaimsIdentity.DefaultRoleClaimType); await _httpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(id)); return(true); }
public async Task <IActionResult> Login([FromBody] UserLoginRequest user) { if (!ModelState.IsValid) { return(new BadRequestResult()); } try { var jwt = await _loginService.Login(user.Email, user.Password); return(Ok(new { authToken = jwt })); } //TODO: catch unauthorized exception catch (LoginFailedException) { return(new UnauthorizedResult()); } catch (Exception) { return(new StatusCodeResult(500)); } }
public async Task <IActionResult> Login(UserLoginRequest request) { var user = await _userManager.Users.IgnoreQueryFilters() .Include(x => x.Organization) .Include(x => x.UserRoles).ThenInclude(x => x.Role) .FirstOrDefaultAsync(x => x.UserName == request.Username); if (user == null) { return(Unauthorized()); } var result = await _signInManager.CheckPasswordSignInAsync(user, request.Password, false); if (result.Succeeded) { var userInfo = _mapper.Map <UserDetail>(user); return(Ok(new { token = GenerateJwtToken(user).Result, user = userInfo })); } return(Unauthorized()); }
public UserSession Login(UserLoginRequest user) { //Daniel 123 var userHelper = CommonContext.GetInstance().Users.SingleOrDefault(u => u.Email == user.Email && u.Password == user.Password); if (!(userHelper == null)) { return(new UserSession { IsSuccess = true, Email = userHelper.Email, Rut = userHelper.Rut, Message = "Session Open", IdUserType = userHelper.IdUserType }); } return(new UserSession { IsSuccess = false, Message = "Session not created" }); }
public async Task <IActionResult> SignIn(UserLoginRequest model) { if (!ModelState.IsValid) { return(CustomResponse(ModelState)); } var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, false, true); if (result.Succeeded) { return(CustomResponse(await GenerateJwt(model.Email))); } if (result.IsLockedOut) { AddError("User temporarily blocked by invalid attempts"); return(CustomResponse()); } AddError("Incorrect username or password"); return(CustomResponse()); }
/// <summary> /// 用户安全密码获取 /// </summary> /// <returns></returns> public async Task <XDocument> GetUserSecurityquestion(UserLoginRequest request) { return(await Task <XDocument> .Run(() => { var fetchXml = $@"<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='true'> <entity name='mcs_usersecurityquestion'> <attribute name='mcs_securityquestionid' /> <attribute name='mcs_answer' /> <attribute name='mcs_name' /> <link-entity name='mcs_user' from='mcs_userid' to='mcs_userid' link-type='inner' alias='ac'> <link-entity name='mcs_loginname' from='mcs_userid' to='mcs_userid' link-type='inner' alias='ad'> <filter type='and'> <condition attribute='mcs_name' operator='eq' value='{request.account}' /> <condition attribute='mcs_status' operator='eq' value='1' /> <condition attribute='mcs_logintype' operator='eq' value='{request.logintype}' /> </filter> </link-entity> </link-entity> </entity> </fetch>"; return XDocument.Parse(fetchXml); })); }
public async Task <ActionResult <LoginResponse> > LoginAsync([FromBody] UserLoginRequest userLoginRequest) { var user = await userManager.FindByEmailAsync(userLoginRequest.Email); if (user == null) { return(NotFound($"Can't find user with email {userLoginRequest.Email}")); } if (!user.EmailConfirmed) { return(BadRequest("User's email isn't confirmed")); } if (!await userManager.CheckPasswordAsync(user, userLoginRequest.Password)) { return(BadRequest($"Incorrect password")); } var loginResponse = await GetLoginResponseAsync(user); return(Ok(loginResponse)); }
public async Task <AuthenticationResult> Login(UserLoginRequest userLoginRequest) { var content = new StringContent(JsonSerializer.Serialize(userLoginRequest), Encoding.UTF8, HttpContentType.ApplicationJson); var response = await _identityClient.PostAsync(IdentityActions.Login, content); var authResult = JsonSerializer.Deserialize <AuthenticationResult>(await response.Content.ReadAsStringAsync(), new JsonSerializerOptions { PropertyNameCaseInsensitive = true }); authResult.Success = response.IsSuccessStatusCode; if (!response.IsSuccessStatusCode) { return(authResult); } await SetTokens(authResult.Token, authResult.RefreshToken); ((ApiAuthenticationStateProvider)_authenticationStateProvider).MarkUserAsAuthenticated(userLoginRequest.Email); return(authResult); }
public async Task <IActionResult> Login(UserLoginRequest user) { var logged = await _repo.LoginAsync(user); if (logged == null) { return(Unauthorized("You do not have access to login")); } string jwtToken = _provider.GeneratedToken( new User { UserUniqueIdentity = logged.UserUniqueIdentity, Username = logged.Username, Email = logged.Email }); return(Ok(new { token = jwtToken, logged })); }
public async Task ValidateAsync(ResourceOwnerPasswordValidationContext context) { // call api UserLoginRequest userLoginRequest = new UserLoginRequest() { UserSubject = context.UserName, UserPassword = context.Password }; try { UserInfo currentUserInfo = await _callSystemServiceApi.UserLogin(userLoginRequest); context.Result = new GrantValidationResult( subject: userLoginRequest.UserSubject, authenticationMethod: "custom", claims: new Claim[] { new Claim("current_user_info", JsonConvert.SerializeObject(currentUserInfo)) } ); } catch (Exception ex) { context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant, ex == null ? "InvalidGrant" : ex.Message); } }
public async Task <IActionResult> Login([FromBody] UserLoginRequest request) { if (!ModelState.IsValid) { return(BadRequest(ValidFildeFormBody())); } var authResponse = await _identityService.Login_Async(request.Email, request.Password); if (authResponse == null || !authResponse.Success) { return(BadRequest(new AuthFailedResponse { Errors = authResponse.Errors })); } return(Ok( new AuthSuccessResopnse { Token = authResponse.Token, RefreshToken = authResponse.RefreshToken } )); }
public async Task <IActionResult> Login([FromBody] UserLoginRequest request) { if (!ModelState.IsValid) { return(BadRequest(new AuthFailedResponse { Errors = ModelState.Values.SelectMany(e => e.Errors.Select(er => er.ErrorMessage)) })); } var authResponse = await _identityService.LoginAsync(request.Email, request.Password); if (!authResponse.Success) { return(BadRequest(new AuthFailedResponse { Errors = authResponse.Errors })); } return(Ok(new AuthSuccessResponse { Token = authResponse.Token })); }
public async Task <ActionResult> UserLogin([FromBody] UserLoginRequest request) { if (ModelState.IsValid) { AppUser user = await _userManager.FindByEmailAsync(request.Email); if (user != null && await _userManager.CheckPasswordAsync(user, request.Password)) { HttpContext.Session.SetString(SessionKeyManager.Login, user.Id.ToString()); var claims = new[] { new Claim(JwtRegisteredClaimNames.Sub, user.UserName), new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()) }; var signinKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("MySuperSecureKey")); var token = new JwtSecurityToken( issuer: "http://google.com", audience: "http://google.com", expires: DateTime.UtcNow.AddHours(1), claims: claims, signingCredentials: new Microsoft.IdentityModel.Tokens.SigningCredentials(signinKey, SecurityAlgorithms.HmacSha256) ); return(Ok(new { token = new JwtSecurityTokenHandler().WriteToken(token), expiration = token.ValidTo })); } else { return(BadRequest("Hatalı kullanıcı girişi yaptınız...")); } } return(BadRequest("Veriler uygun değil")); }
/// <summary> /// 用户登录 /// </summary> /// <param name="name"></param> /// <param name="dh"></param> /// <returns></returns> public UserLoginResponse UserLogin(UserLoginRequest userlogin) { UserLoginResponse response = new UserLoginResponse(); UserModel userModel = new UserModel() { UserName = userlogin.UserName, PassWord = userlogin.Pwd }; if (userlogin == null || userlogin.UserName == null) { response.Status = false; response.Message = "用户不能为空"; return(response); } if (userlogin == null || userlogin.Pwd == null) { response.Status = false; response.Message = "密码不能为空"; return(response); } var res = d.UserLogin(userModel); if (res > 0) { response.IsRegistSuccess = true; response.UserName = userlogin.UserName; response.Message = "登录成功"; } else { response.Status = false; response.Message = "登录失败"; } return(response); }
public async Task <AuthenticationResult> LoginAsync(UserLoginRequest request) { var user = await this.userManager.FindByEmailAsync(request.Email); if (user == null) { return(new AuthenticationResult { Errors = new[] { "User does not exist" } }); } var userHasValidPassword = await this.userManager.CheckPasswordAsync(user, request.Password); if (!userHasValidPassword) { return(new AuthenticationResult { Errors = new[] { "User/password combination is wrong" } }); } return(await GenerateAuthenticationResultForUserAsync(user)); }
public async Task <IActionResult> Authenticate(UserLoginRequest userLoginRequest) { var user = await _userManager.FindByNameAsync(userLoginRequest.UserName); if (user == null) { return(BadRequest("Invalid user name or password.")); } var loginResult = await _signInManager.CheckPasswordSignInAsync(user, userLoginRequest.Password, false); if (!loginResult.Succeeded) { return(BadRequest("Invalid user name or password.")); } // TODO: setup JWT token DateTime expires = DateTime.UtcNow.AddHours(24); var token = await CreateJwtKey(user, expires); var response = new JwtSecurityTokenHandler().WriteToken(token); return(Ok(new { jwt = response, expires, user.UserName })); }
public Token GenerateToken(UserLoginRequest user) { ClaimsIdentity identity = new ClaimsIdentity( new GenericIdentity(user.Email, "Login"), new[] { new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")), new Claim(JwtRegisteredClaimNames.UniqueName, user.Email), new Claim(ClaimTypes.Role, _userService.GetBy(x => x.Email.Equals(user.Email)).Role), } ); DateTime dataCriacao = DateTime.Now; DateTime 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(new Token() { Authenticated = true, Created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"), Expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"), AccessToken = token, Message = "OK", }); }
public async Task <IActionResult> Token(UserLoginRequest model) { if (!ModelState.IsValid) { return(BadRequest()); } var user = await _context.Users.FirstOrDefaultAsync(t => t.UserPhone == model.UserPhone && t.UserPwd == model.UserPwd.ToMD5()); if (user == null) { return(NotFound()); } var token = GetJwtSecurityToken(user); return(new ObjectResult( FormatResult.Success( new { token = new JwtSecurityTokenHandler().WriteToken(token), expiration = token.ValidTo }))); }
public UserInfoResponse Register(UserLoginRequest request, out int status, out string message) { status = 0; message = string.Empty; var response = new UserInfoResponse(); try { IHttpOrderClient client = new HttpOrderClient(Publickey, true); var dic = new Dictionary<string, string>(); var url = GetUrl(BusinessObjectPublicUser.RequestFunction.Register); var result = client.Post(request, url, dic, Appid, Uid); if (result != null && result.ResponseData != null) { status = result.Status; message = result.Message; ResponseMessage = result.Message; Status = result.Status; return SerializerObject.ProtoBufDeserialize<UserInfoResponse>(result.ResponseData, client.Saltkey); } return null; } catch (Exception exception) { status = 0; message = "Lỗi từ user api"; ResponseMessage = SetResponseMessage(exception); return null; } }