public async Task <IActionResult> UserLogin(UserSignInModel userSignInModel) { if (ModelState.IsValid) { if (User.Identity.IsAuthenticated) { return(BadRequest("user is already logged in")); } Microsoft.AspNetCore.Identity.SignInResult result = await _authService.Login(userSignInModel.Password, userSignInModel.Email); if (result.Succeeded) { IdentityUser identityUser = await _authService.GetIdentUserByEmail(userSignInModel.Email); return(Ok(_mapper.Map <AuthOutgoingDto>(identityUser))); } ModelState.AddModelError("", "Invalid username or password"); } IEnumerable <string> errorList = ModelState.SelectMany(m => m.Value.Errors.Select(e => e.ErrorMessage)); return(BadRequest(errorList)); }
public async Task<IActionResult> SingIn([FromBody]UserSignInModel model) { try { await _accountService.SignInAsync(model); TokenResponseModel token = await _jwtProvider.GetTokensAsync(model.Email); return Ok(token); } catch(ServerException ex) { switch (ex.ErrorCode) { case Enums.Errors.Unauthorized: return Unauthorized(ex.Description); break; case Enums.Errors.NotFound: return NotFound(ex.Description); break; default: break; } } return Ok(); }
public async Task <IHttpActionResult> SignInAsync( UserSignInModel model) { var user = await appService.SignInAsync(OwinContext, model); return(Ok(user.Id)); }
public async Task <IActionResult> UserLogin(UserSignInModel userSignInModel, string returnUrl) { // valid the login form and login user if success if (ModelState.IsValid) { var result = await _accountRepository.SignInUserAsync(userSignInModel); if (result.Succeeded) { if (!string.IsNullOrEmpty(returnUrl)) { return(LocalRedirect(returnUrl)); } return(RedirectToAction("Index", "Home")); } if (result.IsNotAllowed) { ModelState.AddModelError("", "Not allowed to login"); } else if (result.IsLockedOut) { ModelState.AddModelError("", "You account is locked, Please try again"); } else { ModelState.AddModelError("", "Invalid credentials!"); } } return(View(userSignInModel)); }
public async Task <IActionResult> SignUp([FromBody] UserSignInModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { if (await _userManager.FindByEmailAsync(model.Email) != null) { return(BadRequest("Email exists")); } var user = new ApplicationUser() { Email = model.Email, UserName = model.Email }; var results = await _userManager.CreateAsync(user, model.Password); if (!results.Succeeded) { throw new Exception($"Error: {results.Errors}"); } return(Ok()); } catch (Exception e) { return(BadRequest(e.Message)); } }
public Task <AppUser> SignInAsync( IOwinContext owinContext, UserSignInModel model) { model.Valid(); var timeSpan = TimeSpan.FromHours(8); return(service.SignInAsync(owinContext, model.UserName, model.UserPwd, timeSpan)); }
public async Task<IActionResult> Login(UserSignInModel userModel) { if (!ModelState.IsValid) return BadRequest("Model state issue"); var user = await factory.GetByNameAsync(userModel.Name); if (user == null) return BadRequest("User not found"); if (userModel.Password != user.Password) return BadRequest("Incorrect password"); var token = AuthService.GenerateToken(user.Id); userModel.Token = token; return Ok(userModel); }
public async Task <IResponse> SignIn(UserSignInModel model) { IResponse response = null; try { } catch (Exception ex) { _logger.LogWarning("Error when sign In", ex); } return(await Task.FromResult(response)); }
[ValidateAntiForgeryToken]//güvenlik önlemi. dışarıdan değer gönderilemez. public async Task <IActionResult> GirisYap(UserSignInModel model) { if (ModelState.IsValid) { var identityResult = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, false); if (identityResult.Succeeded) { return(RedirectToAction("Index", "Panel")); } ModelState.AddModelError("", "Kullanıcı adı yada şifre hatalı"); } return(View("Index", model)); }
public async Task <(bool, UserModel)> SignInAsync(UserSignInModel userSignInModel) { var user = await _context.Users.Where(u => u.Email == userSignInModel.Email) .SingleOrDefaultAsync(); if (user == null) { throw new NotFoundException(); } if (user.Password.Equals(userSignInModel.Password) && user.IsEmailComfirmed == true) { return(true, _mapper.Map <UserModel>(user)); } else { return(false, null); } }
public Task SignInAsync(HttpContext httpContext, UserSignInModel user) { var claims = new[] { new Claim(ClaimTypes.Email, user.Email), new Claim(ClaimTypes.Role, user.Role.Name), new Claim("Id", user.Id.ToString()), }; var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme); var authProperties = new AuthenticationProperties { IsPersistent = true, ExpiresUtc = DateTimeOffset.UtcNow.AddDays(2), }; return(httpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(claimsIdentity), authProperties)); }
private void button6_Click(object sender, EventArgs e) { Users users = new Users(); UserSignInModel userSignIn = new UserSignInModel(); userSignIn.Email = txbx_email.Text; userSignIn.Password = txbx_password.Text; dbContext.GetAllData(users.GetType()); Table <Users> data = dbContext.userData; if (DbExtensions.HasUserByEmail(data, userSignIn.Email) && DbExtensions.HasUserByPassword(data, userSignIn.Password)) { AddCAR addCAR = new AddCAR(userSignIn.Email); this.Hide(); addCAR.ShowDialog(); } else { MessageBox.Show("Bele Bir User Qeydiyyatdan Kecmeyib"); } }
private void button1_Click(object sender, EventArgs e) { text_errorEmail.Text = ""; text_errorPassword.Text = ""; Users users = new Users(); UserSignInModel signInModel = new UserSignInModel(); signInModel.Email = text_sign_email.Text; signInModel.Password = text_sign_password.Text; UserValidator validator = new UserValidator(); if (!validator.Valid <UserSignInModel>(signInModel)) { carSearch = new CarSearch(signInModel.Email); dbContext.GetAllData(users.GetType()); Table <Users> data = dbContext.userData; if (DbExtensions.HasUserByEmail(data, signInModel.Email) && DbExtensions.HasUserByPassword(data, signInModel.Password)) { carSearch = new CarSearch(signInModel.Email); this.Hide(); carSearch.ShowDialog(); } } else { var errors = validator.GetAllData(); foreach (var user in errors) { if (user.Key == 3) { text_errorEmail.Text = user.Value; } if (user.Key == 4) { text_errorPassword.Text = user.Value; } } } }
public async Task SignInAsync(UserSignInModel userModel) { User user = await _userRepository.GetUserByEmailAsync(userModel.Email); if (user is null) { throw new ServerException(Constants.Errors.USER_NOT_FOUND, Enums.Errors.NotFound); } if (user.IsBlocked) { throw new ServerException(Constants.Errors.USER_IS_BLOCKED, Enums.Errors.Unauthorized); } var result = await _signInManager.PasswordSignInAsync(user, userModel.Password, userModel.IsRemember, false); if (!result.Succeeded) { throw new ServerException(Constants.Errors.INVALID_CREDENTIALS, Enums.Errors.Unauthorized); } }
public async Task <IActionResult> SignIn(UserSignInModel userSignInModel) { if (!ModelState.IsValid) { return(BadRequest(new { title = "Model is not valid" })); } var(state, user) = await _authService.SignInAsync(userSignInModel); if (state) { var access_token = new JwtSecurityTokenHandler().WriteToken(await _tokenService.GenerateAccessTokenAsync(user.Id)); var refresh_token = (await _tokenService.GenerateRefreshTokenAsync(user)).Token; return(Ok(new { access_token, refresh_token })); } return(NotFound(new { title = "You have entered an invalid username or password" })); }
public async Task <IActionResult> SignUp(UserSignInModel model) { if (ModelState.IsValid) { if (await _userManager.FindByEmailAsync(model.Email) != null) { return(BadRequest("Email exists")); } var user = new ApplicationUser() { Email = model.Email, UserName = model.Username }; var results = await _userManager.CreateAsync(user, model.Password); if (results.Succeeded) { //success } } return(BadRequest()); }
public async Task <IActionResult> Register(UserSignInModel model) { if (ModelState.IsValid) { User user = new User { Email = model.Email, UserName = model.Email, DateOfRegistration = DateTime.Now }; var result = await userManager.CreateAsync(user, model.Password); if (result.Succeeded) { await signInManager.SignInWithClaimsAsync(user, false, new List <Claim>() { new Claim(ClaimTypes.Role, "user") }); } else { foreach (var error in result.Errors) { log.LogError(error.Description, null); } } } return(RedirectToAction("MainPage", "Main")); }
public async Task <TokenResponseModel> SignInAsync(UserSignInModel signInModel) { var user = await _userManager.FindByNameAsync(signInModel.Email); if (user is null) { throw new CustomExeption(Constants.Error.LOGIN_FAILD_NO_USER_WITH_THIS_EMAIL, StatusCodes.Status400BadRequest); } var signIn = await _signInManager.PasswordSignInAsync(signInModel.Email, signInModel.Password, false, false); if (!signIn.Succeeded) { throw new CustomExeption(Constants.Error.LOGIN_FAILD_WRONG_PASSWORD, StatusCodes.Status400BadRequest); } var roleList = await _userManager.GetRolesAsync(user); if (roleList is null) { throw new Exception($"{Constants.Error.ERROR_NO_USERROLE} {StatusCodes.Status500InternalServerError}"); } bool isRoleAdmin = roleList.Any(s => s.Contains("admin")); var result = new TokenResponseModel(); if (isRoleAdmin) { result.AccessToken = _jwtProvider.GenerateJwt(signInModel.Email, "admin"); return(result); } result.AccessToken = _jwtProvider.GenerateJwt(signInModel.Email, "user"); return(result); }
public async Task <ActionResult> SignIn(UserSignInModel userView) { User user = await userManager.Users .Include(u => u.LockRecord) .Where(u => u.Email == userView.Email || u.UserName == userView.UserName) .FirstOrDefaultAsync(); if (user != null) { var result = await signInManager.CheckPasswordSignInAsync(user, userView.Password, true); if (result.Succeeded && user.EmailConfirmed) { logger.LogInformation($"Account/SignIn: User {user.Email} successfully signed in"); IList <string> roles = await userManager.GetRolesAsync(user); return(Ok(new { id = user.Id, userName = user.UserName, email = user.Email, accessToken = tokensService.GetAccessToken(user, roles), refreshToken = tokensService.GetRefreshToken(user), roles })); } else if (result.IsLockedOut) { logger.LogInformation($"Account/SignIn: User {user.Email} has been blocked"); return(Unauthorized(new { error = $"Account blocked: {user.ReasonOfLockOut}" })); } else { return(Unauthorized(new { error = "Email is not confirmed" })); } } return(UnprocessableEntity(new { error = "Wrong email or password" })); }
public ActionResult ChangePassword(UserSignInModel model, string newPassword, string confirmPassword) { try { if (_userService.ValidateLogin(model.Username, model.Password)) { if (newPassword.Equals(confirmPassword, StringComparison.Ordinal)) { var user = _userService.GetUserByUsername(model.Username); var salt = ""; var hashedPassword = SecurityHelper.HashPassword(newPassword, ref salt); user.PasswordHash = hashedPassword; user.PasswordSalt = salt; user.IsLocked = false; Success("Record Saved."); _userService.Update(user); return RedirectToAction("Index", "Home"); } throw new Exception("Passwords do not match"); } throw new Exception("Current Password is incorrect"); } catch (Exception ex) { Error(ex.Message); return RedirectToAction("ChangePassword"); } }
public async Task <SignInResult> SignInUserAsync(UserSignInModel userSignInModel) { // sign in user return(await _signManager.PasswordSignInAsync( userSignInModel.Email, userSignInModel.Password, userSignInModel.RememberMe, true)); }
public PartialViewResult LoadForgotPassword(UserSignInModel model) { return PartialView("_ForgotPassword", model); }
public ActionResult ResetPassword(UserSignInModel model, string returnUrl = "swag") { try { User user = _userService.GetUserByUsername(model.Username); if (user != null) { var salt = ""; var tempPassword = CommonHelper.GenerateRandomString(); var hashedPassword = SecurityHelper.HashPassword(tempPassword, ref salt); user.PasswordHash = hashedPassword; user.PasswordSalt = salt; user.IsLocked = true; _userService.Update(user); _emailService.SendResetPasswordEmail(user, tempPassword); } else { throw new Exception("Invalid username."); } } catch (Exception ex){ return RedirectToAction("SignIn",ex.Message); } return RedirectToAction("SignIn", "User"); }
public ActionResult SignIn(string returnUrl) { var model = new UserSignInModel(); model.ReturnUrl = returnUrl; return View("SignIn", model); }
public ActionResult SignIn(UserSignInModel model, string returnUrl) { try { if (_userService.ValidateLogin(model.Username, model.Password)) { var user = _userService.GetUserByUsername(model.Username); if (_userService.VerifyKeyCheck(user)) { // Set the last login date user.LastLogin = DateTime.Now; user.PasswordFailuresSinceLastSuccess = 0; _userService.Update(user); FormsAuthentication.SetAuthCookie(model.Username, model.RememberMe); // Store data in session SessionDataHelper.Username = model.Username; SessionDataHelper.UserRole = user.Role; SessionDataHelper.UserId = user.Id; SessionDataHelper.SessionId = System.Web.HttpContext.Current.Session.SessionID; // Store the login entry if (SessionDataHelper.UserId != 1) { _loginService.LogUser(SessionDataHelper.UserId, SessionDataHelper.SessionId); } SessionDataHelper.SubscriberId = user.SubscriberId ?? 0; if (Url.IsLocalUrl(returnUrl)) { return Redirect(returnUrl); } if (user.IsLocked) { UserSignInModel signInModel = new UserSignInModel(); return ChangePassword(); } return RedirectToAction("Index", "Home"); } throw new Exception("Your subscription is out of date, please provide payment to renew."); } throw new Exception("Your username/password combination was incorrect"); } catch (Exception ex) { ModelState.AddModelError("Error", ex.Message); } return View(model); }
public async Task <IActionResult> SignIn([FromBody] UserSignInModel model) { return(Json(await _managerUserControl.SignIn(model))); }
public async Task <IActionResult> SignIn([FromBody] UserSignInModel signInModel) { var result = await _accountService.SignInAsync(signInModel); return(Ok(result)); }
public ActionResult ChangePassword() { var model = new UserSignInModel(); model.Username = SessionDataHelper.Username; return View("_ChangePasswordPartial", model); }
public async Task <UserStatusModel> SignIn(UserSignInModel model) { var user = await _managerUser.FindByEmailAsync(model.Email); if (user == null || !await _managerUser.CheckPasswordAsync(user, model.Password)) { _eNotFound <UserStatusModel>("User not found"); } var userRoles = await _managerUser.GetRolesAsync(user); var token = _serviceToken.GenerateToken(user.Id, user.Email, userRoles); UserLoginInfo li = null; string callbackToken = null; if (!string.IsNullOrWhiteSpace(model.ProviderSlug)) { var provider = await _repositoryProvider.GetFirst(x => x.Slug == model.ProviderSlug && x.State == MREntityState.Active); if (provider != null && provider.Options.IsEnabled) { li = new UserLoginInfo(provider.Id, token, provider.Slug); _serviceToken.GenerateToken("SOME_SECRET_KEY", "MR_IDENTITY", "SOME_PROVIDER", 60, new List <Tuple <string, string> > { new Tuple <string, string>("provider.id", provider.Id), new Tuple <string, string>("user.id", user.Id) }, "name", "password"); callbackToken = ProviderTokenGenerator.Generate(provider.Id, user.Id); } } if (li == null) { li = new UserLoginInfo(_tokenOptions.Issuer, token, _tokenOptions.Issuer); } if (await _managerUser.FindByLoginAsync(li.LoginProvider, li.ProviderKey) != null) { await _managerUser.RemoveLoginAsync(user, li.LoginProvider, li.ProviderKey); } await _managerUser.AddLoginAsync(user, li); var isEmailOnChange = await _repositoryEmailChangeUnit.Any(x => x.State == MREntityState.Active && x.UserId == user.Id && x.Status == Infrastructure.Entity.Enum.EmailChangeResult.NEW); _logger.LogInformation($"User login"); return(new UserStatusModel { FirstName = user.FirstName, LastName = user.LastName, Roles = userRoles.ToList(), AccessToken = token, LanguageCode = user.LanguageCode, Email = user.Email, Sex = user.Sex, IsEmailConfirmed = user.IsEmailConfirmed, IsEmailOnChange = isEmailOnChange, CallbackUrl = model.CallbackUrl, CallbackToken = callbackToken }); }