public IActionResult Login(AccountLoginViewModel model) { if (ModelState.IsValid) { if ("lribeiro".Equals(model.Login) && "admin".Equals(model.Senha)) { //criando a identificação do usuário... var identity = new ClaimsIdentity( new[] { new Claim(ClaimTypes.Name, model.Login), //nome do usuário new Claim(ClaimTypes.Role, "Administrador") //perfil de acesso }, CookieAuthenticationDefaults.AuthenticationScheme ); //autenticando o usuário... var principal = new ClaimsPrincipal(identity); HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, principal); return(RedirectToAction("Index", "Home")); //redirecionamento } else { ViewBag.Mensagem = "Usuário inválido, tente novamente."; } } return(View()); }
public async Task <IActionResult> Login(AccountLoginViewModel vm) { if (ModelState.IsValid) { var result = await _signInManagerService.PasswordSignInAsync(vm.UserName, vm.Password, vm.RememberMe, false); if (result.Succeeded) { IdentityUser user = await _userManagerService.FindByNameAsync(vm.UserName); var role = await _userManagerService.GetRolesAsync(user); if (!string.IsNullOrEmpty(vm.ReturnUrl)) { return(Redirect(vm.ReturnUrl)); } else { return(RedirectToAction("Index", role[0].ToString())); } } else { ModelState.AddModelError("", "Username or password incorrect"); } } return(View(vm)); }
public async Task <IActionResult> Login([FromForm] AccountLoginViewModel model, [FromServices] SignInManager <User> signInManager, CancellationToken token) { if (!ModelState.IsValid) { return(View(model)); } return(await InvokeMediator(LoginUseCase.Publish(model.Login, model.Password), token, forbiddenResultFactoryAsync : async(_, _) => { var result = await signInManager.PasswordSignInAsync(model.Login, model.Password, true, false); if (result.IsLockedOut) { ModelState.AddModelError(string.Empty, "Sorry but your account is locked out."); } if (result.IsNotAllowed) { ModelState.AddModelError(string.Empty, "Sorry but that login type is not allowed for your account."); } return View(model); }, successResultFactoryAsync : async(response, _) => { var user = response.Result; var result = await signInManager.PasswordSignInAsync(user, model.Password, true, false); if (result.Succeeded) { return Redirect(model.ReturnUrl ?? "/"); } throw new ApplicationException(result.ToString()); })); }
public IActionResult Login(string returnUrl) { AccountLoginViewModel vm = new AccountLoginViewModel(); vm.ReturnUrl = returnUrl; return(View()); }
public IActionResult Login(AccountLoginViewModel model, string returnURL) { if (ModelState.IsValid) { Task <Microsoft.AspNetCore.Identity.SignInResult> signInTask; if (model.SaveSession) { signInTask = _signInManager.PasswordSignInAsync(model.Email, model.Password, true, false); } else { signInTask = _signInManager.PasswordSignInAsync(model.Email, model.Password, false, false); } if (signInTask.Result.Succeeded) { if (returnURL is not null) { return(Redirect(returnURL)); } return(RedirectToAction("Index", "Home")); } ModelState.AddModelError("", "Incorrect username or password"); } return(View()); }
public async Task <IActionResult> Login(AccountLoginViewModel model, string button, string returnUrl) { 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.UserName, model.Password, model.RememberMe, lockoutOnFailure : false); if (result.Succeeded) { _logger.LogInformation($"{model.UserName} logged in."); this.StatusMessage = "Login succeded !!"; return(RedirectToLocal(returnUrl)); } else { ModelState.AddModelError(string.Empty, "Invalid login attempt - محاولة دخول خاطئة"); //return View(model); } } // If we got this far, something failed, redisplay form return(View(model)); }
public IActionResult FacebookLogin(AccountLoginViewModel alvm, string returnUrl) { string redirectUrl = Url.Action("FacebookResponse", "Account", new { ReturnUrl = returnUrl, RememberMe = alvm.RememberMe }); AuthenticationProperties properties = _signInManager.ConfigureExternalAuthenticationProperties("Facebook", redirectUrl); return(new ChallengeResult("Facebook", properties)); }
public ActionResult Index(AccountLoginViewModel account) { var p = new Page(); if (ModelState.IsValid) { var user = db.Users.Include("Role").FirstOrDefault(_ => _.Username == account.Username && _.Password == account.Password); if (user != null) { Session["User"] = new UserLogin() { Email = user.Email, FullName = user.FullName, IDRole = user.IDRole, Role = user.Role, Username = user.Username }; return(RedirectToAction("Index", "Delivery")); } else { p.Message = "Sai tài khoản hoặc mật khẩu"; p.MessageLevel = MessageLevel.ERROR; } return(View("Index")); } return(View()); }
public async Task <IActionResult> Login(AccountLoginViewModel details, string returnUrl) { if (ModelState.IsValid) { var user = await _userManager.FindByNameAsync(details.UserName); if (user != null) { var result = await _signInManager.PasswordSignInAsync(user, details.Password, false, false); if (result.Succeeded) { return(Redirect(returnUrl ?? "/Dashboard")); } else { TempData["Message"] = new SystemMessage(MessageType.Warning, "Feil passord.").GetSystemMessage(); } } else { TempData["Message"] = new SystemMessage(MessageType.Warning, "Ukjent brukernavn.").GetSystemMessage(); } } return(View(details)); }
public async Task <IActionResult> LoginAsync([FromForm] AccountLoginViewModel account) { var user = await repositoryFactory.User.SignInAsync(account.Username, account.Password); if (user is null) { return(View()); } var claims = new List <Claim> { new Claim(ClaimUserTypes.UserName, user.UserName), new Claim(ClaimUserTypes.Email, user.Email), new Claim(ClaimUserTypes.Avatar, user.Avatar ?? string.Empty), new Claim(ClaimUserTypes.About, user.About ?? string.Empty), new Claim(ClaimUserTypes.Role, user.Role.ToString()) }; var identity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme); var principal = new ClaimsPrincipal(identity); await HttpContext.SignInAsync( CookieAuthenticationDefaults.AuthenticationScheme, principal, new AuthenticationProperties { IsPersistent = true, ExpiresUtc = DateTime.Now.AddSeconds(CodeMazeConfiguration.AppSettings.SessionTimeOut) }); HttpContext.Session.Set <UserClaim>(SessionHelper.SessionLogin, user); return(Ok(user != null)); }
public async Task <IActionResult> Login(AccountLoginViewModel model, string returnUrl = null) { if (!ModelState.IsValid) { return(View(model)); } ////var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, false); var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, false); if (result.Succeeded) { if (returnUrl != null) { return(LocalRedirect(returnUrl)); // the localredirect is to avoid 0RedirectVulnearability Attack } else { return(RedirectToAction("Index", "Dashboard")); } } else { ModelState.AddModelError(string.Empty, "Invalid login details"); } return(View(model)); }
public async Task <IActionResult> Login([Bind("LoginId,Password")] AccountLoginViewModel loginUser, string returnUrl = null) { if (ModelState.IsValid) { var userInfo = _accountRepository.GetSelectedUser(loginUser); var inputHashText = Password.CreateHashTextBase64(userInfo.Salt, loginUser.Password); if (userInfo.Password == inputHashText) { var claimsIdentity = new Authenticate( userId: userInfo.UserId, userName: userInfo.UserName).CreateClaimsIdentity(); await HttpContext.SignInAsync( CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(claimsIdentity)); return(LocalRedirect(returnUrl ?? Url.Content("~/"))); } else { ModelState.AddModelError("Password", "The Password is incorrect."); ViewData["Action"] = "Login"; ViewData["Controller"] = "Account"; ViewData["Title"] = "Login"; return(View(loginUser)); } } ViewData["Action"] = "Login"; ViewData["Controller"] = "Account"; ViewData["Title"] = "Login"; return(View(loginUser)); }
public async Task <ActionResult> Login([FromBody] AccountLoginViewModel loginVm) { try { var user = await _accountManager.Authenticate(loginVm.Email, loginVm.Password, loginVm.RememberMe); if (user == null) { return(Unauthorized()); } var identity = await GetClaimsIdentity(user); var response = new { uId = identity.Claims.Single(c => c.Type == "id").Value, firstName = user.FirstName, lastName = user.LastName, email = user.Email, formattedName = user.FirstName + " " + user.LastName, auth_token = await _jwtFactory.GenerateEncodedToken(user.Email, identity), expires_in = (int)_jwtOptions.ValidFor.TotalSeconds }; var userData = JsonConvert.SerializeObject(response); return(new OkObjectResult(userData)); } catch (Exception ex) { await _logger.Log(LogLevel.Error, "Account", ex, "Login"); throw ex; } }
public async Task <IActionResult> Login(AccountLoginViewModel vm) { if (ModelState.IsValid) { var results = await _signInManagerService.PasswordSignInAsync(vm.Email, vm.Password, vm.RememberMe, false); if (results.Succeeded) { var user = await _userManagerService.FindByEmailAsync(vm.Email); var isAdmin = await _userManagerService.IsInRoleAsync(user, "Admin"); if (string.IsNullOrEmpty(vm.ReturnUrl)) { if (isAdmin == true) { return(RedirectToAction("Index", "Admin")); } return(RedirectToAction("Index", "Home")); } else { return(Redirect(vm.ReturnUrl)); } } else { ModelState.AddModelError("", "Username or password is not correct"); return(View(vm)); } } return(View(vm)); }
public ActionResult Login() { //var tempPassword = BCrypt.Net.BCrypt.HashPassword("john"); var viewModel = new AccountLoginViewModel(); return(View(viewModel)); }
public async Task <IActionResult> Login(AccountLoginViewModel model, bool rememberMe = true) { //Get user using email var user = await _userManager.FindByEmailAsync(model.Email); if (user == null) //user not found { ModelState.AddModelError(string.Empty, "Invalid Login"); return(View()); } //Uer has not confirmed registration email if (!user.EmailConfirmed) { ModelState.AddModelError(string.Empty, "Confirm your email first."); return(View()); } //Sign in using sign in manager var passwordSignInResult = await _signInManager.PasswordSignInAsync(user, model.Password, isPersistent : rememberMe, lockoutOnFailure : false); if (!passwordSignInResult.Succeeded) //sing in unsuccessful { ModelState.AddModelError(string.Empty, "Invalid Login"); return(View()); } //Sign in successful return(RedirectToAction("Index", "Home")); }
public async Task <IActionResult> Login(AccountLoginViewModel model, [FromQuery] string returnUrl) { returnUrl = returnUrl ?? this.Url.Content("~/"); if (this.ModelState.IsValid) { var result = await this._signInManager.PasswordSignInAsync(model.Username, model.Password, model.RememberMe, lockoutOnFailure : true); if (result.Succeeded) { this._logger.LogInformation("User logged in."); return(this.LocalRedirect(returnUrl)); } else if (result.IsLockedOut) { this._logger.LogWarning("User account locked out."); return(this.LocalRedirect("/Identity/Account/Lockout")); } else { this.ModelState.AddModelError(string.Empty, "Invalid login attempt. Have you confirmed your email?"); return(this.View()); } } return(this.View()); }
public ActionResult LoginAdminExec(AccountLoginViewModel accountLogin) { if (ModelState.IsValid) { string filePath = Server.MapPath(@"/App_Data/Gestori.txt"); var reader = new ManagerReader(); IList <Manager> listaManager = reader.Read(filePath); Manager verificaEmail = listaManager.FirstOrDefault(e => e.Email == accountLogin.Email); if (verificaEmail == null) { ModelState.AddModelError("Email", "Email non presente"); return(View("LoginAdmin")); } Manager verificaAccount = listaManager.FirstOrDefault(e => e.Email == accountLogin.Email && e.Password == accountLogin.Password); if (verificaAccount == null) { ModelState.AddModelError("", "Credenziali Errate"); return(View("LoginAdmin")); } Session["admin"] = verificaAccount; Session["loggedAdmin"] = true; return(RedirectToAction("Index", "Home")); } return(View("LoginAdmin")); }
public ActionResult Login(AccountLoginViewModel model) { ResponseModel response = new ResponseModel(); if (!ModelState.IsValid) { response.Success = false; response.Msg = "请认真检查数据是否复合要求"; return(Json(response)); } if (Session["code"] == null) { response.Success = false; response.Msg = "验证码已过期,请重新获取验证码"; return(Json(response)); } if (Session["code"] != null && !Session["code"].ToString().Equals(model.ValidateCode)) { response.Success = false; response.Msg = "验证码输入错误,请重输入验证码"; return(Json(response)); } Account account = accountService.AccountLoginByUserName(model.LoginName, model.Pwd); AccountLoginStatusModel loginmodel = new AccountLoginStatusModel(); loginmodel.ID = account.Id; loginmodel.Name = account.Name; loginmodel.Email = account.Email; FormsAuthentication.SetAuthCookie(JsonConvert.SerializeObject(loginmodel), true); response.Success = true; response.Msg = "登录成功"; response.RedirectUrl = "/"; return(Json(response)); }
public async Task <IActionResult> Login(AccountLoginViewModel alvm, string returnUrl) { if (ModelState.IsValid) { ApplicationUser au = await _userManager.FindByEmailAsync(alvm.Email); if (au != null) { await _signInManager.SignOutAsync(); Microsoft.AspNetCore.Identity.SignInResult result = await _signInManager.PasswordSignInAsync(au, alvm.Password, alvm.RememberMe, false); if (result.Succeeded) { _logger.LogInformation("Info - Successful login for {0}", au.Email); return(Redirect(returnUrl ?? "/")); } } _logger.LogWarning("Warning - unsuccessful login attempt for {0}", au.Email); ModelState.AddModelError(nameof(AccountLoginViewModel.Email), "Invalid user or passsword"); } return(View(alvm)); }
public async Task <ActionResult> Login(AccountLoginViewModel 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(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(AccountLoginViewModel vm) { if (ModelState.IsValid) { var result = await signInManager.PasswordSignInAsync(vm.Email, vm.Password, false, false); if (result.Succeeded) { var user = await userManager.FindByEmailAsync(vm.Email); var roles = await userManager.GetRolesAsync(user); if (roles.Contains("Admin")) { return(RedirectToAction("Index", "Admin")); } else if (roles.Contains("Coach")) { return(RedirectToAction("Index", "Coach")); } else if (roles.Contains("Swimmer")) { return(RedirectToAction("Index", "Swimmer")); } else { return(RedirectToAction("Registered", "Home")); } } ModelState.AddModelError("", "Login Failure."); } return(View(vm)); }
public IActionResult Login(string returnUrl = "/") { AccountLoginViewModel vm = new AccountLoginViewModel { ReturnUrl = returnUrl }; return(View(vm)); }
public IActionResult Login(string returnUrl = "") { AccountLoginViewModel VM = new AccountLoginViewModel { ReturnUrl = returnUrl }; return(View(VM)); }
public ActionResult LoginAuth(string returnUrl) { AccountLoginViewModel login = new AccountLoginViewModel(); ViewBag.Login = true; login.returnUrl = returnUrl; return(View(login)); }
public static AccountLoginModel ViewToDomain(this AccountLoginViewModel @this) { return(new AccountLoginModel { Username = @this.Username, Password = @this.Password, RememberMe = @this.RememberMe }); }
public ActionResult Login(AccountLoginViewModel model) { if (model.Loginname.Equals("test") && model.Password.Equals("123456")) { FormsAuthentication.SetAuthCookie(model.Loginname, model.RememberMe); var url = string.IsNullOrEmpty(model.ReturnUrl) ? FormsAuthentication.DefaultUrl : model.ReturnUrl; return(Redirect(url)); } return(View()); }
public async Task <IActionResult> Login(string returnUrl) { var model = new AccountLoginViewModel() { ReturnUrl = returnUrl, ExternalsLogin = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList() }; return(View(model)); }
public IActionResult Login() { //shows the form //make a form viewModel AccountLoginViewModel accountLoginViewModel = new AccountLoginViewModel(); //set remember me accountLoginViewModel.RememberMe = true; return(View(accountLoginViewModel)); }
public ActionResult Login(string Message, string FailMessage) { var returnUrl = Request.QueryString["ReturnUrl"]; var data = new AccountLoginViewModel(); data.SuccessMessage = Message; data.ReturnUrl = returnUrl; data.FailMessage = FailMessage; return(View(data)); }
public ActionResult Login(string returnUrl) { var roles = TempData["RolesRequired"] as string; var vm = new AccountLoginViewModel() { ReturnUrl = returnUrl, RolesRequired = roles }; if (_currentUser.IsLoggedIn) { vm.Username = _currentUser.Username; vm.ShowWarning = true; } return View("Login", vm); }
public ActionResult Login(AccountLoginViewModel model) { ViewData["Message"] = "Submited...."; return View(model); }