public ActionResult SignIn(SigninViewModel member) { string Validatestr = memberservice.SigninCheck(member.Account, member.Password); if (String.IsNullOrEmpty(Validatestr)) { string RoleData = memberservice.GetRole(member.Account); JwtService jwtService = new JwtService(); string CookieName = WebConfigurationManager.AppSettings["CookieName"].ToString(); string Token = jwtService.GenerateToken(member.Account, RoleData); HttpCookie cookie = new HttpCookie(CookieName); cookie.Value = Server.UrlEncode(Token); Response.Cookies.Add(cookie); Response.Cookies[CookieName].Expires = DateTime.Now.AddMinutes(Convert.ToInt32(WebConfigurationManager.AppSettings["ExpireMinutes"])); return(RedirectToAction("Index", "Platform")); } else { ModelState.AddModelError("", Validatestr); return(View(member)); } }
public async Task <IActionResult> Signin(SigninViewModel model) { if (ModelState.IsValid) { var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, false); if (result.Succeeded) { if (!string.IsNullOrEmpty(model.ReturnUrl) && Url.IsLocalUrl(model.ReturnUrl)) { return(Redirect(model.ReturnUrl)); } else { return(RedirectToAction("Index", "Home")); } } else { ModelState.AddModelError("", "Incorrect email and (or) password."); } } return(View(model)); }
public IActionResult SigninUser(SigninViewModel user) { if (ModelState.IsValid) { PasswordHasher <User> hasher = new PasswordHasher <User>(); User myUser = _context.Users.SingleOrDefault(User => User.Email == user.Email); if (myUser != null) { if (hasher.VerifyHashedPassword(myUser, myUser.Password, user.Password) == PasswordVerificationResult.Success) { HttpContext.Session.SetInt32("id", myUser.Id); return(RedirectToAction("Index", "Dashboard")); } else { TempData["Login Error"] = "Incorrect Password"; } } else { TempData["Login Error"] = "This user does not exist."; } } else { foreach (var modelState in ModelState.Values) { foreach (var error in modelState.Errors) { TempData[error.ErrorMessage] = error.ErrorMessage; } } } return(RedirectToAction("Signin")); }
public async Task <IActionResult> Signin(SigninViewModel model) { if (ModelState.IsValid) { User user = new User { Email = model.Email, UserName = model.Name, RegisterDate = DateTime.Now, LoginDate = DateTime.Now, Status = "Unblocked" }; // добавляем пользователя var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { // установка куки await _signInManager.SignInAsync(user, false); return(RedirectToAction("Index", "Home")); } else { foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } } return(View(model)); }
public async Task <IActionResult> TokenAuth(SigninViewModel model) { var issuer = _configuration["Tokens:Issuer"]; var audience = _configuration["Tokens:Audience"]; var key = _configuration["Tokens:Key"]; if (ModelState.IsValid) { var signinResult = await _signInManager.PasswordSignInAsync(model.Username, model.Password, false, false); if (signinResult.Succeeded) { var user = await _userManager.FindByEmailAsync(model.Username); if (user != null) { var claims = new[] { new Claim(JwtRegisteredClaimNames.Email, user.Email), new Claim(JwtRegisteredClaimNames.Jti, user.Id), }; var keyBytes = Encoding.UTF8.GetBytes(key); var theKey = new SymmetricSecurityKey(keyBytes); var creds = new SigningCredentials(theKey, SecurityAlgorithms.HmacSha256); var token = new JwtSecurityToken(issuer, audience, claims, expires: DateTime.Now.AddMinutes(30), signingCredentials: creds); return(Ok(new { token = new JwtSecurityTokenHandler().WriteToken(token) })); } } } return(BadRequest()); }
public async Task <ActionResult> Signin(SigninViewModel loginModel) { var model = new LoginViewModel(loginModel, new RegistrationViewModel(loginModel.ReturnUrl)); if (!ModelState.IsValid) { return(View("Login", model)); } var clientAccount = await _clientAccountsRepository.AuthenticateAsync(loginModel.Username, loginModel.Password) ?? //ToDo: to remove when migrated to hashes await _clientAccountsRepository.AuthenticateAsync(loginModel.Username, PasswordKeepingUtils.GetClientHashedPwd(loginModel.Password)); if (clientAccount == null) { ModelState.AddModelError("Username", " "); ModelState.AddModelError("Password", "Invalid user"); return(View("Login", model)); } var identity = await _userManager.CreateUserIdentityAsync(clientAccount, loginModel.Username); await HttpContext.Authentication.SignInAsync("ServerCookie", new ClaimsPrincipal(identity), new AuthenticationProperties()); return(RedirectToLocal(loginModel.ReturnUrl)); }
public ActionResult Signin(SigninViewModel model) { if (ModelState.IsValid && !User.Identity.IsAuthenticated) { var result = SignInManager.PasswordSignInAsync(model.Login, model.Password, model.RememberMe, false).Result; switch (result) { case SignInStatus.Success: return(RedirectToAction("Index", "Home")); case SignInStatus.LockedOut: ModelState.AddModelError("", "Аккаунт заблокирован"); break; case SignInStatus.Failure: ModelState.AddModelError("", "Неверное имя пользователя или пароль"); break; case SignInStatus.RequiresVerification: ModelState.AddModelError("", "Требуется дополнительная верификация"); break; } } return(View(model)); }
public async Task <IActionResult> Signin([Bind("Email,Password")] SigninViewModel args) { try { User user = _context.Users.Where(u => u.Email == args.Email).Single(); bool isValidPassword = BCrypt.Net.BCrypt.Verify(args.Password, user.Password); if (isValidPassword) { await this.Login(user); } else { InvalidOperationException ex = new InvalidOperationException(); ex.Data["field"] = "password"; throw ex; } } catch (InvalidOperationException e) { if (e.Data["field"] != null && e.Data["field"].ToString() == "password") { return(RedirectToAction("Signin", new RouteValueDictionary(new { error = "Invalid Password" }))); } return(RedirectToAction("Signin", new RouteValueDictionary(new { error = "Email Not found" }))); } return(RedirectToAction("Index", "")); }
public async Task IShouldReturnBadRequestIfUserIsInactiveOnLogin() { var existentUser = new User { Id = "asdf-aewrwe-asdfa", Email = "*****@*****.**", IsActive = false }; var viewModel = new SigninViewModel { Email = "*****@*****.**", Password = "******" }; var mockForDomainUserService = new Mock <IUserService>(); mockForDomainUserService.Setup(service => service.GetUserByEmail(It.IsAny <string>())) .ReturnsAsync(existentUser) .Verifiable(); var controller = new UserController( mockForDomainUserService.Object, null, null, null); var result = await controller.Login(viewModel); var resultData = result as BadRequestObjectResult; string error = resultData.Value?.GetType().GetProperty("error_description")?.GetValue(resultData.Value, null).ToString(); Assert.IsInstanceOfType(resultData, typeof(BadRequestObjectResult)); Assert.AreEqual(resultData.StatusCode, 400); Assert.AreEqual(error, "Usuario não esta ativo"); mockForDomainUserService.VerifyAll(); }
public async Task <IActionResult> Signin(SigninViewModel model) { if (ModelState.IsValid) { User user = new User { Email = model.Email, UserName = model.Name, }; var result = userManager.CreateAsync(user, model.Password).GetAwaiter().GetResult(); if (result.Succeeded) { signInManager.SignInAsync(user, false).Wait(); ViewBag.Status = 2; return(Redirect($"/Home/Index/{model.Name}")); } else { foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } } return(View(model)); }
public async Task <IActionResult> Signin(SigninViewModel model, string returnUrl = null) { this.ViewData["ReturnUrl"] = returnUrl; if (this.ModelState.IsValid) { try { var result = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, false); if (result.Succeeded) { return(this.RedirectToLocal(returnUrl)); } // I added the exclamation mark to make it more dramatic this.TempData["ErrorMessage"] = "The username and/or password are incorrect!"; return(this.View(model)); } catch (Exception) { this.TempData["ErrorMessage"] = "Something bad happened while logging in..."; return(this.View(model)); } } return(this.View(model)); }
public async Task<ActionResult> Signin(SigninViewModel model) { if (ModelState.IsValid) { var pharmacy = await context.Pharmacies .SingleOrDefaultAsync(m => m.PharmacyName == model.PharmacyName && m.Password == model.Password); if (pharmacy == null) { ModelState.AddModelError("", "Invalid login attempt."); return View("Signin"); } HttpContext.Session.SetString("userId", pharmacy.PharmacyName); var identity = new ClaimsIdentity(new[] { new Claim(ClaimTypes.Name, model.PharmacyName), new Claim(ClaimTypes.Role, "Pharmacy") }, CookieAuthenticationDefaults.AuthenticationScheme); var principal = new ClaimsPrincipal(identity); var login = HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, principal); } else { return View("Signin"); } return RedirectToAction("Index"); }
public async Task <IActionResult> Signin(SigninViewModel model, string returnUrl) { if (string.IsNullOrEmpty(returnUrl)) { returnUrl = "/"; } ViewData["returnUrl"] = returnUrl; bool isLogin = false; var user = await _userManager.FindByNameAsync(model.UserName); if (user == null) { isLogin = false; } else { isLogin = await _userManager.CheckPasswordAsync(user, model.PassWord); } if (isLogin) { await _signInManager.SignInAsync(user, true); return(Redirect(returnUrl)); } return(View(model)); }
public async Task <IActionResult> SignIn(SigninViewModel model) { if (!User.Identity.IsAuthenticated) { if (ModelState.IsValid) { var user = await userManager.FindByNameAsync(model.phoneNumber); if (user != null) { var passwordValidation = await signinManager.CheckPasswordSignInAsync(user, model.password, false); if (passwordValidation.Succeeded) { await signinManager.SignInAsync(user, false); } } } else { return(View(model)); } } return(Redirect("/Home/Index")); }
public async Task<ActionResult> Signin(SigninViewModel vm, string returnUrl = null) { if (this.ModelState.IsValid) { var user = this.userRepository.GetAccountingUserByEmailOrUserName(vm.Username); if (user != null) { var signInResult = await this.signInManager.PasswordSignInAsync(user, vm.Password, true, false); if (signInResult.Succeeded) { this.Alert("Successfully signed in.", "success"); if (string.IsNullOrWhiteSpace(returnUrl)) { return this.RedirectToAction("Index", "Index"); } else { return this.Redirect(returnUrl); } } } } this.ViewBag.Error = "Incorrect username or password."; return this.View(vm); }
public async Task <IActionResult> Signin(SigninViewModel model) { if (ModelState.IsValid) { var result = await _signInManager.PasswordSignInAsync(model.Username, model.Password, model.RememberMe, false); if (result.RequiresTwoFactor) { return(RedirectToAction("MFACheck")); } else { if (!result.Succeeded) { ModelState.AddModelError("Login", "Cannot login."); } else { return(RedirectToAction("Index", "Home")); } } } return(View(model)); }
public async Task <IActionResult> GetSignin([FromRoute] int id) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var signin = await _context.Signins.FindAsync(id); if (signin == null) { return(NotFound()); } var viewModel = new SigninViewModel { Id = signin.Id, TimeIn = signin.TimeIn, TimeOut = signin.TimeOut, EmployeeId = signin.EmployeeId, SiteId = signin.SiteId }; return(Ok(viewModel)); }
public ActionResult Signin(SigninViewModel model) { string captcha = base.CacheManager.Session.Get <string>("Captcha"); if (!string.Equals(model.ValidateCode, captcha, System.StringComparison.CurrentCultureIgnoreCase)) { ModelState.AddModelError("ValidateCode", "验证码输入错误"); return(View()); } IMessage <UserTicket> message = base.Facade.User.Signin(model.UserName, model.Password); if (message.Success) { if (model.Remember) { base.CacheManager.Cookie.Set(Constants.SIGNINREMEMBERKEY, message.Entity.ParseToString()); } //设置票证 FormsAuthentication.SetAuthCookie(message.Entity.ParseToString(), false); return(Redirect(FormsAuthentication.DefaultUrl)); } else { base.ErrorMessage = message.Content; } return(View(model)); }
public async Task <ActionResult> Signin(SigninViewModel loginModel) { var model = new LoginViewModel(loginModel, new RegistrationViewModel(loginModel.ReturnUrl)); if (!ModelState.IsValid) { return(View("Login", model)); } AuthResponse authResult = await _registrationClient.AuthorizeAsync(new AuthModel { Email = loginModel.Username, Password = loginModel.Password, Ip = this.GetIp(), UserAgent = this.GetUserAgent() }); if (authResult.Status == AuthenticationStatus.Error) { ModelState.AddModelError("Username", " "); ModelState.AddModelError("Password", "Invalid user"); return(View("Login", model)); } var identity = await _userManager.CreateUserIdentityAsync(authResult.Account.Id, authResult.Account.Email, loginModel.Username); await HttpContext.Authentication.SignInAsync("ServerCookie", new ClaimsPrincipal(identity), new AuthenticationProperties()); return(RedirectToLocal(loginModel.ReturnUrl)); }
public async Task <IActionResult> Signin([FromBody] SigninViewModel model) { StatusCodeResult res = null; if (ModelState.IsValid) { // This doesn't count login failures towards account lockout // To enable password failures to trigger account lockout, set lockoutOnFailure: true var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure : true); if (result.Succeeded) { res = Ok(); return(await Task.FromResult(res)); } else { res = NotFound(); ModelState.AddModelError(string.Empty, "Invalid login attempt."); Response.StatusCode = StatusCodes.Status409Conflict; return(Json(ModelState.Values.SelectMany(v => v.Errors).ToList())); } } Response.StatusCode = StatusCodes.Status409Conflict; return(Json(ModelState.Values.SelectMany(v => v.Errors).ToList())); }
public async Task <IActionResult> Signin(SigninViewModel model) { if (ModelState.IsValid) { var result = await _signInManager.PasswordSignInAsync(model.Username, model.Password, model.RememberMe, false); if (result.Succeeded) { var user = await _userManager.FindByEmailAsync(model.Username); var userClaims = await _userManager.GetClaimsAsync(user); //if (!userClaims.Any(x => x.Type == "Department")) //{ // ModelState.AddModelError("Claim", "User not in tech department."); // return View(model); //} if (await _userManager.IsInRoleAsync(user, "Member")) { return(RedirectToAction("Member", "Home")); } } //else //{ // result.IsLockedOut gibi propertyleri kullanarak kontroller yapabiliriz. // Ama güvenlik açısından mümkün olduğunca geri dönüş hatalarını açıklayıcı şekilde vermemeliyiz. //} ModelState.AddModelError("Login", "Cannot login."); } return(View(model)); }
public async Task<ActionResult> Signin(SigninViewModel model, string returnUrl) { if (!ModelState.IsValid) { return View(model); } var user = await UserManager.FindByEmailAsync(model.Email); if (user == null) { ModelState.AddModelError("", "Invalid login attempt."); return View(model); } // This doesn't count login failures towards account lockout // To enable password failures to trigger account lockout, change to shouldLockout: true var result = await SignInManager.PasswordSignInAsync(user.UserName, model.Password, model.RememberMe, shouldLockout: false); switch (result) { case SignInStatus.Success: return RedirectToLocal(returnUrl); case SignInStatus.LockedOut: return View("Lockout"); case SignInStatus.RequiresVerification: return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }); case SignInStatus.Failure: default: ModelState.AddModelError("", "Invalid login attempt."); return View(model); } }
public ActionResult ProcessSignin(SigninViewModel model) { var isValidLogin = CheckifValidPasswordAndSignInUsingModel(model); if (isValidLogin) { if (model.RedirectMode == RedirectMode.Link) { return(Redirect(model.ReturnURL)); } object routeValues = null; if (!String.IsNullOrWhiteSpace(model.JSONEncodedRouteValues)) { var js = new JavaScriptSerializer(); routeValues = js.Deserialize(model.JSONEncodedRouteValues, Type.GetType(model.RouteValuesModelClassName)); } return(RedirectToAction(model.RouteAction, model.RouteController, routeValues)); } model.HasError = true; model.Password = String.Empty; return(RedirectToAction("Signin", model)); }
public async Task <IActionResult> Signup(SigninViewModel signupmodel) { ApplicationUser user = new ApplicationUser { UserName = signupmodel.UserName, Email = signupmodel.Email, FirstName = signupmodel.FirstName, LastName = signupmodel.LastName, Country = signupmodel.Country, NewStateId = signupmodel.NewStateId, LGAId = signupmodel.LGAId, NewStates = _account.FindNameByStateId(signupmodel.NewStateId), LGAs = _account.FindNameByLocalId(signupmodel.LGAId) }; var sign = await _account.CreateUser(user, signupmodel.Password); if (sign) { Alert("Account Created successfully", NotificationType.success); return(RedirectToAction("Login", "Account")); //return RedirectToAction("Index", "Home"); } Alert("Account not created!", NotificationType.error); return(View()); //ApplicationUser user = new ApplicationUser(); }
public async Task <IActionResult> Signup(SigninViewModel signupmodel) { ApplicationUser user = new ApplicationUser(); user.UserName = signupmodel.UserName; user.Email = signupmodel.Email; var sign = await _account.CreateUser(user, signupmodel.Password); if (sign) { //Alert("Account Created successfully", NotificationType.success); return(RedirectToAction("Index", "Home")); } Alert("Account not created!", NotificationType.error); return(View()); //ApplicationUser user = new ApplicationUser(); //user.UserName = signup.Username; //user.Email = signup.Email; //var newUser = await _account.CreateUser(user, signup.Password); //if (newUser) //{ // Alert("Welcome "+ signup.Username + "!", NotificationType.success); // return RedirectToAction("Index", "Home"); //} //Alert("Author not created!", NotificationType.error); //return View(); }
public async Task <IActionResult> LoginConfirm(SigninViewModel model) { if (!ModelState.IsValid) { return(RedirectToAction("Login")); } //Model is Valid var CurrentUser = await _userManager.FindByNameAsync(model.Username); if (CurrentUser == null) { TempData["UserMessage"] = "اطلاعات کاربری صحیح نمی باشد"; return(RedirectToAction("Login")); } //User Exists var CurrentUserStatus = CurrentUser.Status; var status = await _signInManager.PasswordSignInAsync(CurrentUser, model.Password, model.IsRemember, false); if (status.Succeeded) { return(RedirectToAction("Index", "Home")); //successful signin } TempData["UserMessage"] = "اطلاعات کاربری صحیح نمی باشد"; return(RedirectToAction("Login")); }
public async Task <IActionResult> SignIn(SigninViewModel model) { if (ModelState.IsValid) { var result = await _signinManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, false); if (result.Succeeded) { var user = await _userManager.FindByEmailAsync(model.UserName); // Exp Get List of claims and and example hopw to use it //var userClaims = await _userManager.GetClaimsAsync(user); //if (!userClaims.Any(x=>x.Type == "Department")) //{ // ModelState.AddModelError("Claim", "User doesn\'t have claim department"); // return View(model); //} if (await _userManager.IsInRoleAsync(user, "Admin")) { return(RedirectToAction("IndexZilnic", "AppAntrenament")); } } else { ModelState.AddModelError("Login", "Can\'t login."); } } return(View(model)); }
public IActionResult Signin(SigninViewModel u) { if (!(ModelState.IsValid)) { return(View()); } List <User> Users = context.Users.ToList(); if (Users.Count() < 1) { return(View("Index")); } foreach (User user in Users) { if (user.Email == u.Email) { string hashString = u.Password + user.PassSalt; // check for password for (int i = 0; i < user.PassIterations; i++) { hashString = hash(hashString); } // If the password is right if (user.PassHash == hashString) { GlobalStatic.userID = user.UserId; GlobalStatic.role = user.Role; GlobalStatic.Email = user.Email; GlobalStatic.FirstName = user.FirstName; GlobalStatic.LastName = user.LastName; return(View("Index")); } else { ModelState.AddModelError(string.Empty, "Invalid email/password"); GlobalStatic.userID = null; GlobalStatic.role = null; GlobalStatic.Email = null; GlobalStatic.FirstName = null; GlobalStatic.LastName = null; return(View()); } } } // no email matches ModelState.AddModelError(string.Empty, "Invalid email/password"); GlobalStatic.userID = null; GlobalStatic.role = null; GlobalStatic.Email = null; GlobalStatic.FirstName = null; GlobalStatic.LastName = null; return(View()); }
public IActionResult Signin(string error = null) { SigninViewModel signinvm = new SigninViewModel { ErrorMessage = error }; return(View(signinvm)); }
public IActionResult Authenticate([FromBody] SigninViewModel userCred) { var token = _tokenService.Authenticate(userCred.Username, userCred.Password); if (token == null) { return(Unauthorized()); } return(Ok(token)); }
private async Task AuthenticateUser(SigninViewModel loginDetails, UserToken tokenModel) { AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie); var identityUser = CreateCustomClaims(loginDetails, tokenModel); AuthenticationManager.SignIn(new AuthenticationProperties() { IsPersistent = false }, await Task.WhenAll(identityUser)); }