public async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { if (!this.ModelState.IsValid) { return this.View(model); } if (model.Email.Contains("@")) { var user = this.UserManager.FindByEmail(model.Email); if (user != null) { model.Email = user.UserName; } } var result = await this.SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false); switch (result) { case SignInStatus.Success: return this.RedirectToLocal(returnUrl); case SignInStatus.LockedOut: return this.View("Lockout"); case SignInStatus.RequiresVerification: return this.RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }); case SignInStatus.Failure: default: this.ModelState.AddModelError(string.Empty, "Invalid login attempt."); return this.View(model); } }
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { if (ModelState.IsValid) { try { var user = await UserManager.FindAsync(model.Email, model.Password); if (user != null) { await SignInAsync(user, model.RememberMe); return Json(new { success = true, url = returnUrl }); } else { ModelState.AddModelError("", "Invalid username or password."); } //await experiment(user); } catch (DbEntityValidationException dbx) { foreach(var item in dbx.EntityValidationErrors) { foreach(var thisThing in item.ValidationErrors) { Trace.TraceInformation("Property: {0} Error: {1}", thisThing.PropertyName, thisThing.ErrorMessage); } } } } return PartialView(model); }
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { if (!this.ModelState.IsValid) { return this.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 this.SignInManager.PasswordSignInAsync(model.Username, model.Password, model.RememberMe, false); switch (result) { case SignInStatus.Success: return this.RedirectToLocal(returnUrl); case SignInStatus.LockedOut: return this.View("Lockout"); case SignInStatus.RequiresVerification: return this.RedirectToAction("SendCode", new { ReturnUrl = returnUrl, model.RememberMe }); case SignInStatus.Failure: default: this.ModelState.AddModelError("", "Invalid login attempt."); return this.View(model); } }
public async Task<ActionResult> SignIn(LoginViewModel model, string returnUrl) { if (!ModelState.IsValid) { //return PartialView("_Login", model); //return PartialView(); return View("Error"); } // 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(model.Email, model.Password, model.RememberMe, shouldLockout: false); switch (result) { case SignInStatus.Success: var user = await UserManager.FindAsync(model.Email, model.Password); await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); 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 RedirectToAction("Index", "Home"); //return View("_LoginPartial"); //return PartialView("_Login",model); return View("Error"); } }
public LoginView() : base() { loginViewModel = new LoginViewModel(); BindingContext = loginViewModel; InitializeComponent(); NavigationPage.SetHasNavigationBar(this, false); }
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { //if (ModelState.IsValid) //{ // var user = await UserManager.FindAsync(model.UserName, model.Password); // if (user != null) // { // MigrateShoppingCart(model.UserName); // await SignInAsync(user, model.RememberMe); // return RedirectToLocal(returnUrl); // } // else // { // ModelState.AddModelError("", "Invalid username or password."); // } //} //// If we got this far, something failed, redisplay form //return View(model); var result = PasswordSignIn(model.UserName, model.Password, model.RememberMe, shouldLockout: APPLY_USER_LOCKOUT); switch (result) { case SignInStatus.Success: return RedirectToLocal(returnUrl); case SignInStatus.LockedOut: ModelState.AddModelError("", "Account is locked"); return View(model); case SignInStatus.Failure: default: ModelState.AddModelError("", "Invalid atempt"); return View(model); } }
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { if (ModelState.IsValid) { var user = await UserManager.FindAsync(model.UserName, model.Password); if (user != null) { var identity = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie); identity.AddClaim(new Claim("FirstName", user.FirstName)); identity.AddClaim(new Claim("LastName", user.LastName)); identity.AddClaim(new Claim("Email", user.Email)); identity.AddClaim(new Claim("Role", user.role.ToString())); await SignInAsync(user, model.RememberMe); return RedirectToLocal(returnUrl); } else { ModelState.AddModelError("", "Invalid username or password."); } } // If we got this far, something failed, redisplay form return View(model); }
public async Task<ActionResult> Main(string LID) { if (LID != null) { var db = getDB0(); var getItem = db.Apply_User.Where(x => x.userid == LID).FirstOrDefault(); if (getItem != null) { LoginViewModel md = new LoginViewModel() { account = "user", password = "******", lang = "zh-TW", rememberme = false }; var getResult = await ajax_Login(md); LoginResult trnResult = Newtonsoft.Json.JsonConvert.DeserializeObject<LoginResult>(getResult); if (trnResult.result) { Response.Cookies.Add(new HttpCookie("user_id", Server.UrlEncode(EncryptString.desEncryptBase64(getItem.userid)))); Response.Cookies.Add(new HttpCookie("user_name", Server.UrlEncode(getItem.username))); Response.Cookies.Add(new HttpCookie("user_login", Server.UrlEncode(EncryptString.desEncryptBase64("Y")))); return Redirect(trnResult.url + "/Users"); } } } HttpContext.GetOwinContext().Authentication.SignOut(); ViewData["username"] = ""; ViewData["password"] = ""; #if DEBUG ViewData["username"] = CommWebSetup.AutoLoginUser; ViewData["password"] = CommWebSetup.AutoLoginPassword; #endif return View("Index"); }
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { // var user = new ApplicationUser { UserName = "******", Email = "*****@*****.**" }; // var re = await UserManager.CreateAsync(user, "Abc@123456"); if (!ModelState.IsValid) { 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(model.Email, 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 async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { if (!ModelState.IsValid) { 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(model.UserName, model.Password, model.RememberMe, false); switch (result) { case SignInStatus.Success: //var hubContext = GlobalHost.ConnectionManager.GetHubContext<BaseHub>(); var user = await UserManager.FindAsync(model.UserName, model.Password); //hubContext.Clients.AllExcept(user.UserName).kur("qjhui"); if (UserManager.IsInRole(user.Id, "Administrator")) { return RedirectToAction("Index", "Home"); } return RedirectToLocal(returnUrl); case SignInStatus.LockedOut: return View("Lockout"); case SignInStatus.RequiresVerification: return RedirectToAction("SendCode", new {ReturnUrl = returnUrl, model.RememberMe}); case SignInStatus.Failure: default: ModelState.AddModelError("", "Invalid login attempt."); return View(model); } }
public ActionResult Login(LoginViewModel model, string returnUrl) { if (!ModelState.IsValid) { return View(model); } var user = _db.Users.FirstOrDefault(x => x.Email == model.Email && x.Password == model.Password); if(user==null) return View("Lockout"); // Если нельзя заходить - то всё, заблокирован if (!ValidateUser(user)) { string text = user.BlockReason; text += "\nДата окончания блокировки: "; text += user.BlockForDate; text += "\nЕсли причина блокировки неясна, то - отпишите нам, пожалуйста, по кнопке в правом нижнем углу. С уважением, администрация GarageInc"; return Content(text); } var result = SignInManager.PasswordSignIn(model.Email, model.Password, model.RememberMe, shouldLockout: false); switch (result) { case SignInStatus.Success: { if (user != null) { using (var transaction = _db.Database.BeginTransaction()) { try { user.LastVisition = DateTime.Now; _db.Entry(user).State = EntityState.Modified; _db.SaveChanges(); transaction.Commit(); } catch (Exception error) { transaction.Rollback(); return PartialView("_Content", error.Message); } } } 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("", "Неудачная попытка входа."); return View(model); } }
public ActionResult LogIn(LoginViewModel model) { if (ModelState.IsValid) { bool temp = true; try { temp = model.Email == "*****@*****.**"; temp = model.Password == "123"; temp = Membership.ValidateUser(model.Email, model.Password); } catch (Exception e) { System.Console.WriteLine("Error"); } return RedirectToAction("Index", "Home"); } return RedirectToAction("LogIn", "Account"); }
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { if (!ModelState.IsValid) { 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(model.Email, model.Password, model.RememberMe, shouldLockout: false); switch (result) { case SignInStatus.Success: { var visitor = new Visitor(); var userTemp = db.Users.FirstOrDefault(x => x.Email == model.Email); visitor.UserId = userTemp.Id; visitor.Time = DateTime.Now.ToString(); visitor.VisitorIP = GetIPAdress(Request); visitor.VisitorCountry = "";// await GetCountryFromIp(visitor.VisitorIP); myContext.Visitors.Add(visitor); myContext.Entry(visitor).State = System.Data.Entity.EntityState.Added; myContext.SaveChanges(); 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 async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { if (ModelState.IsValid) { var user = await UserManager.FindAsync(model.UserName, model.Password); //zaatar - to handle the diable login if (!userLogic.CanLogin(model.UserName)) { ModelState.AddModelError("", "You cannot login. Your acount is disabled by the administrator."); return View(model); } //end zaatar if (user != null) { await SignInAsync(user, model.RememberMe); return RedirectToLocal(returnUrl); } else { ModelState.AddModelError("", "Invalid username or password."); } } return View(model); }
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { if (!ModelState.IsValid) { return View(model); } // Require the user to have a confirmed email before they can log on. var user = await UserManager.FindByNameAsync(model.Email); if (user != null) { if (!await UserManager.IsEmailConfirmedAsync(user.Id)) { ViewBag.errorMessage = "You must have a confirmed email to log on."; return View("Error"); } } // 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(model.Email, 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 async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { if (ModelState.IsValid) { var user = await UserManager.FindAsync(model.UserName, model.Password); if (user != null) { await SignInAsync(user, model.RememberMe); var db = new CMISProject.DAL.CIMSEntities(); if (db.Admins.Where(s => s.AdminName == model.UserName).Count() == 1) { HttpContext.Session["isAdmin"] = true; HttpContext.Session["UserId"] = db.Admins.Single(s => s.AdminName == model.UserName).AdminId; } else if( db.Users.Where(s => s.UserName == model.UserName).Count()==1) { HttpContext.Session["isAdmin"] = false; HttpContext.Session["UserId"] = db.Users.Single(s => s.UserName == model.UserName).UserId; } HttpContext.Session["Username"] = model.UserName; return RedirectToLocal(returnUrl); } else { ModelState.AddModelError("", "Invalid username or password."); } } // If we got this far, something failed, redisplay form return View(model); }
public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null) { EnsureDatabaseCreated(_applicationDbContext); ViewData["ReturnUrl"] = returnUrl; 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: false); if (result.Succeeded) { return RedirectToLocal(returnUrl); } if (result.RequiresTwoFactor) { return RedirectToAction(nameof(SendCode), new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }); } if (result.IsLockedOut) { return View("Lockout"); } else { ModelState.AddModelError(string.Empty, "Invalid login attempt."); return View(model); } } // If we got this far, something failed, redisplay form return View(model); }
public ActionResult Logar(LoginViewModel model) { if (!ModelState.IsValid) { return View("Index", model); } AutenticacaoService service = new AutenticacaoService(); Stopwatch sw = Stopwatch.StartNew(); bool resultado = service.Autenticar(model.Usuario, model.Senha); sw.Stop(); Trace.WriteLine("Autenticar em " + sw.ElapsedMilliseconds); if (!resultado) { ModelState.AddModelError("Usuario", "Usuário ou senha inválidos"); return View("Index", model); } return Content("TOP SECRET!"); }
public string GetUserDetails(string userName) { string isCaptchaDisplay = null; var loginType = CheckInputType(userName); var loginViewModel = new LoginViewModel(); var user = _wcfService.InvokeService<IUserService, User>(svc => svc.GetUserByUsername(userName, loginType)); if (user != null) { var ipAddress = GetClientIpAddress(); var userHistory = user.UserLogins.Select(x => x.UserHistories.FirstOrDefault(y => y.IpAddress == ipAddress)).ToList(); if (userHistory == null) { isCaptchaDisplay = "False"; loginViewModel.IsCaptchaDisplay = isCaptchaDisplay.AsBool(); return isCaptchaDisplay; } else { isCaptchaDisplay = "True"; loginViewModel.IsCaptchaDisplay = isCaptchaDisplay.AsBool(); return isCaptchaDisplay; } } //ModelState.AddModelError("UserName", "The user name is not correct."); return isCaptchaDisplay; }
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { if (ModelState.IsValid) { var user = await UserManager.FindAsync(model.UserName, model.Password); // // Insert a new user into the database //using (var db = new ApplicationDbContext()) //{ // db.Results.Add(new Result { TeamName = model.} ) //} if (user != null) { await SignInAsync(user, model.RememberMe); return RedirectToLocal(returnUrl); } else { ModelState.AddModelError("", "Invalid username or password."); } } // If we got this far, something failed, redisplay form return View(model); }
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { if (ModelState.IsValid) { var user = await UserManager.FindAsync(model.UserName, model.Password); if (user != null) { // Put in the session the logged user. Session["user"] = user; TempData["userName"] = user.UserName; // Define if the user is Administrator. If not I need go get his ID to use in the query. if (user.UserName.Equals("Admin")) TempData["userId"] = null; else TempData["userId"] = user.Id; TempData.Keep(); await SignInAsync(user, model.RememberMe); return RedirectToLocal(returnUrl); } else ModelState.AddModelError(string.Empty, "The User Name and/or Password entered is invalid. Please try again."); } // If we got this far, something failed, redisplay form return View(model); }
public void TestLoginIngresoFallido() { var userStore = new Mock<IUserStore<ApplicationUser>>(); var userManager = new Mock<ApplicationUserManager>(userStore.Object); var authenticationManager = new Mock<IAuthenticationManager>(); var signInManager = new Mock<ApplicationSignInManager>(userManager.Object, authenticationManager.Object); signInManager.Setup(s => s.PasswordSignInAsync(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>(), It.IsAny<bool>())) .Returns<string, string, bool, bool>(MockPasswordSignInAsync); var controller = new AccountController(userManager.Object, signInManager.Object); var contextMock = new Mock<HttpContextBase>(); controller.Url = new UrlHelper(new RequestContext(contextMock.Object, new RouteData())); var loginViewmodel = new LoginViewModel { Email = "*****@*****.**", Password = "******", RememberMe = false }; var returnUrl = "/Home/Index"; //Act var result = controller.Login(loginViewmodel, returnUrl); //Assert Assert.IsInstanceOfType(result.Result, typeof(ViewResult)); Assert.AreEqual("Usuario o Clave incorrectos", (result.Result as ViewResult).ViewData.ModelState[""].Errors[0].ErrorMessage); }
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { if (ModelState.IsValid) { // Validate the password IdentityResult result = await this.IdentityManager.Authentication.CheckPasswordAndSignInAsync( this.AuthenticationManager, model.UserName, model.Password, model.RememberMe); if (result.Success) { return this.RedirectToLocal(returnUrl); } else { this.AddErrors(result); } } // If we got this far, something failed, redisplay form return this.View(model); }
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { if (!ModelState.IsValid) { return View(model); } var user = UserManager.FindByEmail(model.Email); if (user != null && !UserManager.IsEmailConfirmed(user.Id)) { ModelState.AddModelError("", "Please confirm your account by following the instructions in the confirmation email."); 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(model.Email, 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 async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null) { ViewBag.ReturnUrl = returnUrl; if (ModelState.IsValid) { // This doesn't count login failures towards account lockout // To enable password failures to trigger account lockout, set shouldLockout: true var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, false); if (result.Succeeded) { return RedirectToLocal(returnUrl); } if (result.RequiresTwoFactor) { return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }); } if (result.IsLockedOut) { return View("Lockout"); } else { ModelState.AddModelError(string.Empty, "Invalid login attempt."); return View(model); } } // If we got this far, something failed, redisplay form return View(model); }
public Login() { loginController = new LoginController(); loginViewModel = loginController.loginViewModel; this.DataContext = loginController.loginViewModel; this.InitializeComponent(); }
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { if (ModelState.IsValid) { var user = await UserManager.FindAsync(model.GaTechId, model.Password); if (user != null) { if (user.EmailConfirmed) { await SignInAsync(user, model.RememberMe); return RedirectToLocal(returnUrl); } else { ModelState.AddModelError("", "Account activiation is awaiting email confirmation."); } } else { ModelState.AddModelError("", "Invalid username or password."); } } // If we got this far, something failed, redisplay form return View(model); }
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { model.RememberMe = true; if (!ModelState.IsValid) { return View(model); } SignInStatus result; try { result = await _signInManager.PasswordEmailSignInAsync(model.Email, model.Password , model.RememberMe, shouldLockout: IdentitySettings.ShouldLockOut); } catch(Exception exception) { _logger.Exception(exception); result = SignInStatus.Failure; } switch (result) { case SignInStatus.Success: return RedirectToLocal(returnUrl); case SignInStatus.LockedOut: return View("Lockout"); case SignInStatus.Failure: default: string invalidMessage = IdentityResourceHelper.Load(IdentitySettings.IdentityResource, "AccountController_Login_Invalid"); ModelState.AddModelError("", invalidMessage); return View(model); } }
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { if (!ModelState.IsValid) { 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(model.Email, model.Password, model.RememberMe, shouldLockout: false); switch (result) { case SignInStatus.Success: { //SessionHelper.UserSessionID = "TEMPSESSIONID"; AspNetUsersController aspUserCon = new AspNetUsersController(); var user = aspUserCon.GetUser(model.Email); //SessionHelper.UserSessionID = user.Id; SessionHelper.LoggedInUser<AspNetUser>(user, user.UserName); 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 async Task<ActionResult> Login(LoginViewModel model, string returnUrl) { //if (!ModelState.IsValid) return View(model); //var user = await UserManager.FindAsync(model.UserName, model.Password); //if (user != null) //{ // await SignInAsync(user, model.RememberMe); // return RedirectToLocal(returnUrl); //} //ModelState.AddModelError("", "Invalid username or password."); //// If we got this far, something failed, redisplay form //return View(model); if (!ModelState.IsValid) return View(model); var user = model.UserName == "Trong"&&model.Password=="123"; if (user){ return RedirectToLocal(returnUrl); } ModelState.AddModelError("", "Invalid username or password."); // If we got this far, something failed, redisplay form return View(model); }
public async Task <IActionResult> CreateToken([FromBody] LoginViewModel model) { if (ModelState.IsValid) { User user = await _userHelper.GetUserAsync(model.Username); if (user != null) { Microsoft.AspNetCore.Identity.SignInResult result = await _userHelper.ValidatePasswordAsync(user, model.Password); if (result.Succeeded) { Claim[] claims = new[] { new Claim(JwtRegisteredClaimNames.Sub, user.Email), new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()) }; SymmetricSecurityKey key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Tokens:Key"])); SigningCredentials credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256); JwtSecurityToken token = new JwtSecurityToken( _configuration["Tokens:Issuer"], _configuration["Tokens:Audience"], claims, expires: DateTime.UtcNow.AddDays(99), signingCredentials: credentials); var results = new { token = new JwtSecurityTokenHandler().WriteToken(token), expiration = token.ValidTo, user }; return(Created(string.Empty, results)); } } } return(BadRequest()); }
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl) { if (!ModelState.IsValid) { 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(model.Email, model.Password, model.RememberMe, shouldLockout : false); switch (result) { case SignInStatus.Success: { using (ApplicationDbContext db = new ApplicationDbContext()) { ApplicationUser user = new ApplicationUser(); user = db.Users.First(m => m.Email == model.Email); user.IsLogin = true; db.Entry(user).State = EntityState.Modified; db.SaveChanges(); } 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 void Login_With_Correct_Data() { //arrange Mock <IAuthProvider> mock = new Mock <IAuthProvider>(); mock.Setup(m => m.Authenticate("admin", "123")).Returns(true); LoginViewModel model = new LoginViewModel { UserName = "******", Password = "******" }; AccountController controller = new AccountController(mock.Object); //act ActionResult result = controller.Login(model, "/MyURL"); //assert Assert.IsInstanceOfType(result, typeof(RedirectResult)); Assert.AreEqual("/MyURL", ((RedirectResult)result).Url); }
public async Task <IActionResult> Login(LoginViewModel model, string returnUrl) { if (ModelState.IsValid) { var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, false); if (result.Succeeded) { // 防止 Open Redirect if (!string.IsNullOrEmpty(returnUrl) && Url.IsLocalUrl(returnUrl)) { return(Redirect(returnUrl)); } return(RedirectToAction("Index", "Home")); } ModelState.AddModelError(string.Empty, "登录失败,请重试"); } return(View(model)); }
public async Task <IActionResult> Login(LoginViewModel loginVM) { if (!ModelState.IsValid) { return(View(loginVM)); } var usuario = await _userManager.FindByNameAsync(loginVM.UserName); if (usuario != null) { var resultado = await _signInManager.PasswordSignInAsync(usuario, loginVM.Password, false, false); if (resultado.Succeeded) { return(RedirectToAction("Index", "Home")); } } ModelState.AddModelError("", "Usuário ou senha inválidos ou não encontrados"); return(View(loginVM)); }
public ActionResult Login(LoginViewModel loginViewModel) { ServicePointManager.ServerCertificateValidationCallback = (obj, certificate, chain, errors) => true; bool canLogIn = false; using (var authServ = ServiceHelper.GetAuthServiceClient()) { canLogIn = authServ.Login(loginViewModel.Username, loginViewModel.Password); } if (canLogIn) { // Sets the current HTTP context to the valid credentials provided AuthHelper.Login(loginViewModel); return(RedirectToAction("GetActiveGames", "JoinGame")); } else { ViewBag.StatusMessage = "Could not log in. Invalid Credentials."; return(View("Login")); } }
public ActionResult Login(LoginViewModel login) { if (ModelState.IsValid) { var userManager = HttpContext.GetOwinContext().GetUserManager <AppUserManager>(); var authManager = HttpContext.GetOwinContext().Authentication; AppUser user = userManager.Find(login.UserName, login.Password); if (user != null) { var ident = userManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie); authManager.SignIn( new AuthenticationProperties { IsPersistent = false }, ident); return(Redirect(Url.Action("Index", "Home"))); } } ModelState.AddModelError("", "Invalid username or password"); return(View(login)); }
public ActionResult Login(LoginViewModel model) { //Giriş kontrolü ve yönlendirme yapılacak //Session'a kullanıcı bilgi saklama if (ModelState.IsValid) //model doğru gelmişse { EvernoteUserManager eum = new EvernoteUserManager(); BusinessLayerResult <EvernoteUser> res = eum.LoginUser(model); //demekki hata var if (res.Errors.Count > 0) { res.Errors.ForEach(x => ModelState.AddModelError("", x.Message));//ilgili hatayı metoda ekle dedik.foreach ile .bu hatayıda view tarafında Validation summary ile okuyor. //business layerdan dönen hataların yönetimi if (res.Errors.Find(x => x.Code == ErrorMessageCode.UserIsNotActive) != null) { ViewBag.SetLink = "http://Home/Activate/1313-4344345-345345"; } return(View(model)); } //giriş başarılı ise Session["login"] = res.Result; //sessiona kullanıcı bilgisini at return(RedirectToAction("Index")); //yönlendirme .. } return(View(model)); }
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl) { if (!ModelState.IsValid) { return(View(model)); } // Uncomment to require the user to have a confirmed email before they can log on. var user = await _userManager.FindByNameAsync(model.Email); if (user != null) { if (!await _userManager.IsEmailConfirmedAsync(user.Id)) { string callbackUrl = await SendEmailConfirmationTokenAsync(user.Id, "Confirm your account-Resend"); ViewBag.ErrorMessage = "You must have a confirmed email to log on."; return(View("Error")); } } // 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(model.Email, model.Password, model.RememberMe, shouldLockout : false); switch (result) { case SignInStatus.Success: return(RedirectToLocal(returnUrl)); case SignInStatus.LockedOut: return(View("Lockout")); case SignInStatus.Failure: default: ModelState.AddModelError("", "Invalid login attempt."); return(View(model)); } }
public async Task <IActionResult> Login(LoginViewModel 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 { //проверяем роли и направляем по личным кабинетам User user = await _userManager.FindByEmailAsync(model.Email); var userRoles = await _userManager.GetRolesAsync(user); foreach (var role in userRoles) { if (role == "admin") { return(RedirectToAction("Index", "Roles"));//личный абинет администратора-методиста } else { return(RedirectToAction("Index", "Student"));//линый кабинет студента } } } } else { ModelState.AddModelError("", "Неправильный логин и (или) пароль"); } } return(View(model)); }
public async Task <IActionResult> Login([FromBody] LoginViewModel model) { if (ModelState.IsValid) { await HttpContext.Authentication.SignOutAsync(_externalCookieScheme); ClaimsPrincipal principal = HttpContext.User as ClaimsPrincipal; await HttpContext.Authentication.SignInAsync("MyCookieAuthenticationScheme", principal); var userTask = _userManager.FindByEmailAsync(model.Email); var user = userTask.Result; if (user != null) { var result = await _signInManager.PasswordSignInAsync(user.Email, model.Password, model.RememberMe, lockoutOnFailure : false); if (result.Succeeded) { //var user = _context.Users.SingleOrDefault(u => u.Email.Equals(model.Email)); _logger.LogInformation(1, "User logged in."); return(Ok(user)); } if (result.IsLockedOut) { _logger.LogWarning(2, "User account locked out."); return(View("Lockout")); } else { ModelState.AddModelError(string.Empty, "Invalid login attempt."); return(StatusCode(400, "Nem sikerült a bejelentkezés.")); } } } // If we got this far, something failed, redisplay form return(BadRequest()); }
public async Task <IActionResult> Register(LoginViewModel registro) { if (ModelState.IsValid) { var usuario = new IdentityUser() { UserName = registro.UserName }; var result = await _userManager.CreateAsync(usuario, registro.Password); if (result.Succeeded) { await _userManager.AddToRoleAsync(usuario, "Member"); await _signInManager.SignInAsync(usuario, isPersistent : false); return(RedirectToAction("Index", "Home")); } } return(View(registro)); }
public ActionResult Login(LoginViewModel model) { ActionResult result = null; try { if (!ModelState.IsValid) { throw new Exception(); } _vm.LoginUser(model.Username, model.Password); result = RedirectToAction("Index", "Vending"); } catch (Exception) { result = View("Login"); } return result; }
public async Task <IActionResult> Login(LoginViewModel model) { if (ModelState.IsValid) { var user = await _loginService.FindByUsername(model.Email); if (await _loginService.ValidateCredentials(user, model.Password)) { var tokenLifetime = _configuration.GetValue("TokenLifetimeMinutes", 120); var props = new AuthenticationProperties { ExpiresUtc = DateTimeOffset.UtcNow.AddMinutes(tokenLifetime), AllowRefresh = true, RedirectUri = model.ReturnUrl }; if (model.RememberMe) { var permanentTokenLifetime = _configuration.GetValue("PermanentTokenLifetimeDays", 365); props.ExpiresUtc = DateTimeOffset.UtcNow.AddDays(permanentTokenLifetime); props.IsPersistent = true; } ; await _loginService.SignInAsync(user, props); if (_interaction.IsValidReturnUrl(model.ReturnUrl)) { return(Redirect(model.ReturnUrl)); } } model.Message = "Wrong username and password"; } var vm = await BuildLoginViewModelAsync(model); var result = await _userService.GetFloristThemeIds(50); vm.ThemeId = result.KeyId; return(View(vm)); }
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl) { if (!ModelState.IsValid) { 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(model.Email, model.Password, model.RememberMe, shouldLockout : false); switch (result) { case SignInStatus.Success: return(RedirectToAction("Index", "Customer")); case SignInStatus.Failure: default: ModelState.AddModelError("", "Invalid login attempt."); return(View(model)); } }
public IActionResult Login(LoginViewModel model) { bool passwordCheck = false; bool userCheck = false; List <string> errors = new List <string>(); if (ModelState.IsValid) { User currentUser = _context.User.SingleOrDefault(user => user.Email == model.Email); if (currentUser != null && currentUser.Email.Equals(model.Email)) { PasswordHasher <User> Hasher = new PasswordHasher <User>(); if (0 != Hasher.VerifyHashedPassword(currentUser, currentUser.Password, model.Password)) { HttpContext.Session.SetInt32("CurrUserId", (int)currentUser.id); return(RedirectToAction("Index", "New")); } passwordCheck = true; } else { userCheck = true; } } errors = ModelState.Select(x => x.Value.Errors) .Where(y => y.Count > 0) .Select(z => z[0].ErrorMessage.ToString()) .ToList(); if (passwordCheck == true) { errors.Add("Password was incorrect."); } if (userCheck == true) { errors.Add("User doesn't exist is the Database."); } TempData["error_list"] = errors; return(RedirectToAction("Index")); }
public void Login_With_Incorrect_Data() { //arrange Mock <IAuthProvider> mock = new Mock <IAuthProvider>(); mock.Setup(m => m.Authenticate("user", "228")).Returns(false); LoginViewModel model = new LoginViewModel { UserName = "******", Password = "******" }; AccountController controller = new AccountController(mock.Object); //act ActionResult result = controller.Login(model, "/MyURL"); //assert Assert.IsInstanceOfType(result, typeof(ViewResult)); Assert.IsFalse(((ViewResult)result).ViewData.ModelState.IsValid); }
public async Task <IActionResult> Login(LoginViewModel loginViewModel) { if (!ModelState.IsValid) { return(View(loginViewModel)); } var user = await _userManager.FindByNameAsync(loginViewModel.UserName); if (user != null) { var result = await _signInManager.PasswordSignInAsync(user, loginViewModel.Password, false, false); if (result.Succeeded) { return(RedirectToAction("Index", "Home")); } } ModelState.AddModelError("", "用户名/密码错误"); return(View(loginViewModel)); }
public async Task <ActionResult> Login(LoginViewModel details, string returnUrl) { AppUser user = await UserManager.FindAsync(details.Name, details.Password); if (user == null) { ModelState.AddModelError("", "Некорректное имя или пароль."); } else { ClaimsIdentity ident = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie); AuthManager.SignOut(); AuthManager.SignIn(new AuthenticationProperties { IsPersistent = false }, ident); return(Redirect(returnUrl)); } return(View(details)); }
public async Task<ActionResult> Login(LoginViewModel lvm, string returnUrl) { //if user forgot to include user name or password, //send them back to the login page to try again if (ModelState.IsValid == false) { return View(lvm); } // finds the roleID string? roleID = _context.Roles.Where(r => r.Name == "FiredEmployee").FirstOrDefault().Id; // finds the user AppUser user = _context.Users.Where(u => u.Email == lvm.Email).FirstOrDefault(); // finds the roleID tied to the user string userroleid = _context.UserRoles.Where(ur => ur.UserId == user.Id).FirstOrDefault().RoleId; if (userroleid == roleID) { return View("Error", new String[] { "You are fired!" }); } //attempt to sign the user in using the SignInManager Microsoft.AspNetCore.Identity.SignInResult result = await _signInManager.PasswordSignInAsync(lvm.Email, lvm.Password, lvm.RememberMe, lockoutOnFailure: false); //if the login worked, take the user to either the url //they requested OR the homepage if there isn't a specific url if (result.Succeeded) { //return ?? "/" means if returnUrl is null, substitute "/" (home) return RedirectToAction("CheckFired"); } else //log in was not successful { //add an error to the model to show invalid attempt ModelState.AddModelError("", "Invalid login attempt."); //send user back to login page to try again return View(lvm); } }
public ActionResult Login(LoginViewModel model, string returnUrl) { if (!ModelState.IsValid) { return(View(model)); } var result = HttpContext.GetOwinContext().Get <SignInManager>() .PasswordSignIn(model.UserName, model.Password, false, false); if (result == SignInStatus.Success) { if (Url.IsLocalUrl(returnUrl)) { return(Redirect(returnUrl)); } return(RedirectToAction("Index", "Home")); } ModelState.AddModelError("", "The user name or password provided is incorrect."); return(View(model)); }
public ActionResult Login(LoginViewModel lvm) { var user = new User(); using (Model1Container context = new Model1Container()) { user = context.Users.Where(a => a.username == lvm.username && a.password == lvm.password).FirstOrDefault(); } if (user == null) { ModelState.AddModelError("", "Invalid username or password!"); } else { //ModelState.AddModelError("", "Successful"); Session["LogonUser"] = user; return(RedirectToAction("Index", "Home")); //("Index = Page", "Home = Controller") } return(View()); }
public async Task <ActionResult> Login(LoginViewModel model, string returnUrl) { if (ModelState.IsValid) { var user = await UserManager.FindAsync(model.Email, model.Password); if (user != null) { await SignInAsync(user, model.RememberMe); return(RedirectToLocal(returnUrl)); } else { ModelState.AddModelError("", "Invalid username or password."); } } // If we got this far, something failed, redisplay form return(View(model)); }
public async Task <IActionResult> SignIn([FromBody] LoginViewModel model) { if (ModelState.IsValid) { var result = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, false, false); if (result.Succeeded) { var user = await _userManager.FindByNameAsync(model.UserName); return(new JsonResult(new Dictionary <string, object> { { "access_token", GetToken(user) } })); } return(new JsonResult("Unable to sign in") { StatusCode = 401 }); } return(Error("Unexpected error")); }
public IActionResult Post(LoginViewModel login) { Usuario usuarioBuscado = _usuario.BuscarPorEmailSenha(login.Email, login.Senha); if (usuarioBuscado == null) { return NotFound("E-mail ou senha inválidos"); } var claims = new[] { new Claim(JwtRegisteredClaimNames.Email, usuarioBuscado.Email), new Claim(JwtRegisteredClaimNames.Jti, usuarioBuscado.IdUsuario.ToString()), new Claim(ClaimTypes.Role, usuarioBuscado.IdTipousuario.ToString()) }; var key = new SymmetricSecurityKey(System.Text.Encoding.UTF8.GetBytes("Senatur-chave-autenticacao")); var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256); var token = new JwtSecurityToken( issuer: "Senatur.WebApi", // emissor do token audience: "Senatur.WebApi", // destinatário do token claims: claims, // dados definidos acima expires: DateTime.Now.AddMinutes(30), // tempo de expiração signingCredentials: creds // credenciais do token ); return Ok(new { token = new JwtSecurityTokenHandler().WriteToken(token) }); }
public ActionResult Login(LoginViewModel model, string returnUrl) { if (!ModelState.IsValid) { return(View()); } if (!ValidateUser(model.Login, model.Password)) { ModelState.AddModelError(string.Empty, "Le nom d'utilisateur ou le mot de passe est incorrect."); return(View(model)); } SetIdentityToCookie(model); if (Url.IsLocalUrl(returnUrl)) { return(Redirect(returnUrl)); } return(RedirectToAction("Index", "Home")); }
public async Task <IActionResult> CreateToken([FromBody] LoginViewModel model) { if (ModelState.IsValid) { var user = await _userManager.FindByNameAsync(model.Username); if (user != null) { var result = await _signInManager.CheckPasswordSignInAsync(user, model.Password, false); if (result.Succeeded) { var claims = new[] { //Create the token new Claim(JwtRegisteredClaimNames.Sub, user.Email), new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()), new Claim(JwtRegisteredClaimNames.UniqueName, user.UserName) }; var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["Tokens:Key"])); var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256); var token = new JwtSecurityToken( _config["Tokens:Issuer"], _config["Tokens:Audience"], claims, expires: DateTime.UtcNow.AddMinutes(30), signingCredentials: creds ); var results = new { token = new JwtSecurityTokenHandler().WriteToken(token), expiration = token.ValidTo }; return(Created("", results)); } } } return(BadRequest()); }
public async Task <IActionResult> Login(LoginViewModel model) { if (ModelState.IsValid) { var result = await _userHelper.LoginAsync(model); if (result.Succeeded) { if (Request.Query.Keys.Contains("ReturnUrl")) { return(Redirect(Request.Query["ReturnUrl"].First())); } return(RedirectToAction("Index", "Home")); } ModelState.AddModelError(string.Empty, "User or password incorrect."); } return(View(model)); }
public ActionResult LogIn(LoginViewModel request) { if (ModelState.IsValid) { BusinessLayerResult <EvernoteUser> res = evernoteUserManager.LoginUser(request); if (res.Errors.Count > 0) { res.Errors.ForEach(x => ModelState.AddModelError("", x.message)); if (res.Errors.Find(x => x.code == ErrorMessageCode.UserIsNotActive) != null) { ViewBag.SetLik = "http://Home/Activa/1234-5678-8987"; } return(View(request)); } CurrentSession.Set <EvernoteUser>("login", res.Result); //session'a kullanıcı bilgi saklama return(RedirectToAction("Index")); } return(View()); }
public async Task<IActionResult> Login(LoginViewModel model, string returnUrl) { model.ExternalLogins = model.ExternalLogins ?? (await signInManager.GetExternalAuthenticationSchemesAsync()).ToList(); if (ModelState.IsValid) { var user = await userManager.FindByEmailAsync(model.Email); if(user != null && !user.EmailConfirmed && (await userManager.CheckPasswordAsync(user,model.Password))) { ModelState.AddModelError(string.Empty, "Email not confirmed yet"); return View(model); } var result = await signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, true); if (result.Succeeded) { if (!string.IsNullOrEmpty(returnUrl) && Url.IsLocalUrl(returnUrl)) { return Redirect(returnUrl); } else { return RedirectToAction("Index", "home"); } } if(result.IsLockedOut) { return View("AccountLocked"); } ModelState.AddModelError(string.Empty, "Invalid Login Attempt"); } return View(model); }