#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously public ActionResult Login(LoginViewModel model) #pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously { if (ModelState.IsValid) { LoginViewModels loginViewModels = new LoginViewModels(); //var user = await UserManager.FindAsync(model.UserName, model.Password); Autenticacion objAu = new Autenticacion(); int idLinea = -1, idPerfil = -1; string controlador = string.Empty, pagina = string.Empty; int resultado = objAu.autenticar(model.UserName, model.Password, Request.UserHostAddress, out idLinea, out controlador, out pagina, out idPerfil); if (resultado == UtilErrores.OK) { Session["userName"] = model.UserName.ToUpper(); Session["IdLinea"] = idLinea; Session["IdPerfil"] = idPerfil; Session["PaginaInicio"] = string.Concat(controlador, "/", pagina); return(RedirectToAction(pagina, controlador, new { idLinea = idLinea })); } else { ViewBag.Mensaje = "Usuario invalido"; return(View(model)); } } // Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario return(View(model)); }
public async Task <IActionResult> Index(LoginViewModels model) { if (ModelState.IsValid) { model.Input.Password = _hash.EncryptString(model.Input.Password); var login = _context.User.Where(m => m.Account == model.Input.Username && m.Password == model.Input.Password).FirstOrDefault(); if (login is null) { model.ErrorMessage = "Credenciales Incorrectas"; return(View(model)); } var RoleName = _context.Role.FirstOrDefault(m => m.RoleId == login.RoleId).RoleValue; var claims = new List <Claim> { new Claim(ClaimTypes.Name, login.Account), new Claim("FullName", $"{login.FirstName} {login.LastName} {login.SecondLastName}"), new Claim("Id", login.UserId.ToString()), new Claim(ClaimTypes.Email, login.Email), new Claim(ClaimTypes.Role, RoleName) }; var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme); var authProperties = new AuthenticationProperties { }; await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(claimsIdentity), authProperties); return(RedirectToAction("Index", "Inventory")); } model.ErrorMessage = "Error al Iniciar"; return(View(model)); }
public async Task <ActionResult> Login(LoginViewModels model, string returnUrl) { if (!ModelState.IsValid) { return(View(model)); } // Nie powoduje to liczenia niepowodzeń logowania w celu zablokowania konta // Aby włączyć wyzwalanie blokady konta po określonej liczbie niepomyślnych prób wprowadzenia hasła, zmień ustawienie na shouldLockout: true var result = await SignInManager.PasswordSignInAsync(model.e_mail, model.password, model.rememberMe, shouldLockout : true); 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("", "Nieprawidłowa próba logowania."); return(View(model)); } }
public async Task <IActionResult> Login(LoginViewModels loginVM) { if (!ModelState.IsValid) { return(View(loginVM)); } var user = await _userManager.FindByNameAsync(loginVM.UserName); if (user != null) { var result = await _signInManager.PasswordSignInAsync(user, loginVM.Password, false, false); if (result.Succeeded) { if (string.IsNullOrEmpty(loginVM.ReturnUrl)) { return(RedirectToAction("Index", "Home")); } return(Redirect(loginVM.ReturnUrl)); } } ModelState.AddModelError("", "Usuário/Senha inválidos ou não localizados"); return(View(loginVM)); }
public async Task <IActionResult> Login(LoginViewModels loginViewModels) { if (!ModelState.IsValid) { return(View(loginViewModels)); } var user = await _userManager.FindByNameAsync(loginViewModels.UserName); if (user != null) { await _signInManager.SignOutAsync(); var result = await _signInManager.PasswordSignInAsync(user, loginViewModels.Password, loginViewModels.RememberMe, false); if (result.Succeeded) { if (string.IsNullOrEmpty(loginViewModels.ReturnUrl)) { return(View()); } else if (result.IsNotAllowed) { return(Json(new { message = "Tài khoản chưa được kích hoạt. Hãy kiểm tra email để kích hoạt tài khoản", status = false })); } return(Redirect(loginViewModels.ReturnUrl)); } } ModelState.AddModelError("", "Tên đăng nhập hoặc mật khẩu không đúng."); return(View(loginViewModels)); }
public async Task <ActionResult> Login(LoginViewModels model, string returnUrl) { if (!ModelState.IsValid) { // jezeli model bedzi e zawierac bledy to poinformuje o tym uzytkownika i zwroci mu to co wpisal return(View(model)); } var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout : false); switch (result) { case SignInStatus.Success: // RedirectToLocal jest helperem aby nie przekierowac uzytkownika na zewnatrz return(RedirectToLocal(returnUrl)); case SignInStatus.LockedOut: return(View("Lockout")); case SignInStatus.RequiresVerification: return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl })); case SignInStatus.Failure: default: ModelState.AddModelError("loginerror", "Nieudana próba logowania."); return(View(model)); } }
public async Task <ActionResult> Login(LoginViewModels model, string returnUrl) { if (!ModelState.IsValid) { return(View(model)); } 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 })); case SignInStatus.Failure: default: ModelState.AddModelError("loginerror", "Nieudana próba logowania"); return(View(model)); } }
public async Task <IActionResult> Index(LoginViewModels model) { if (ModelState.IsValid) { List <object[]> listObject = await _usuarios.userLogin(model.Input.Email, model.Input.Password); object[] objects = listObject[0]; var _identityError = (IdentityError)objects[0]; model.ErrorMessage = _identityError.Description; if (model.ErrorMessage.Equals("True")) { //serializar la información del usuario var data = JsonConvert.SerializeObject(objects[1]); //crear variables de sesión HttpContext.Session.SetString("User", data); return(RedirectToAction(nameof(PrincipalController.Index), "Principal")); } else { return(View(model)); } } return(View(model)); }
private void btnGiris_Click(object sender, EventArgs e) { var model = new LoginViewModels() { Email = txtEmail.Text, Password = txtEmail.Text }; var user = _clientRepository .Query(x => x.Email == model.Email && x.Password == model.Password).FirstOrDefault(); if (user == null) { MessageBox.Show("Email veya şifre hatalıdır!"); return; } MessageBox.Show($"Hoşgeldin {user.Name} {user.Surname}"); //string format dolar StockSettings.UserInfo = new UserInfoViewModel() { Id = user.Id, Email = user.Name, Name = user.Surname, ApplicationRole = user.ApplicationRole }; this.Close(); }
public async Task <IActionResult> LogIn(LoginViewModels model) { if (ModelState.IsValid) { var userEmail = await userManager.FindByEmailAsync(model.Email); if (userEmail != null && !userEmail.EmailConfirmed && (await userManager.CheckPasswordAsync(userEmail, model.Password))) { //In case I want to make the old users to be true, that have no token confirmation yet //var token = await userManager.GenerateEmailConfirmationTokenAsync(userEmail); //var confirmationLink = Url.Action("ConfirmEmail", "Account", new { userId = userEmail.Id, token = token }, Request.Scheme); //// WriteAllText creates a file, writes the specified string to the file, //// and then closes the file. You do NOT need to call Flush() or Close(). //System.IO.File.WriteAllText(@"C:\Users\Silviu Mihai\Documents\CsharpTokenUsers\TokenUsers.txt", confirmationLink); ModelState.AddModelError(string.Empty, "Email not confirmed yet !"); return(View(model)); } var result = await signInManager.PasswordSignInAsync(model.Email, model.Password, isPersistent : model.RememberMe, lockoutOnFailure : false); if (result.Succeeded) { return(RedirectToAction("index", "home")); } //In case the Login fails ModelState.AddModelError(string.Empty, "Invalid Login Attempt !"); // add errors to ModelState, to list the problems regarding the registration } return(View(model)); }
public async Task <IActionResult> Login(LoginViewModels model, string returnUrl = null) { 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.IsLockedOut) { _logger.LogWarning(2, "User account locked out."); 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 async Task <ActionResult> Login(LoginViewModels 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: // logger.Info("Logowanie udane | " + model.Email); 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("loginerror", "Nieudana próba logowania."); // logger.Info("Logowanie nieudane | " + model.Email); return(View(model)); } }
public async Task <IActionResult> Index(LoginViewModels model) { if (ModelState.IsValid) { var encryptPassword = _hash.EncryptString(model.Input.Password); var commisionerLogin = _context.Commisioner.FirstOrDefault(v => v.Nic.Equals(model.Input.Username) && v.CommisionerPassword.Equals(encryptPassword)); if (commisionerLogin is null) { model.ErrorMessage = "Usuario o contraseña invalidas"; return(View(model)); } var listObject = await _usuarios.userLogin(commisionerLogin.Email, model.Input.Password, commisionerLogin.CommisionerId); var _identityError = (IdentityError)listObject[0]; model.ErrorMessage = _identityError.Description; if (model.ErrorMessage.Equals("True")) { var data = JsonConvert.SerializeObject(listObject[1]); HttpContext.Session.SetString("User", data); return(RedirectToAction("Index", "Departments")); } else { return(View(model)); } } return(View(model)); }
public async Task <IActionResult> Login(LoginViewModels loginViewModels) { if (!ModelState.IsValid) { return(View(loginViewModels)); } var user = await _userManager.FindByNameAsync(loginViewModels.UserName); if (user != null) { await _signInManager.SignOutAsync(); var result = await _signInManager.PasswordSignInAsync(user, loginViewModels.Password, loginViewModels.RememberMe, false); if (result.Succeeded) { if (string.IsNullOrEmpty(loginViewModels.ReturnUrl)) { return(RedirectToAction("Index", "Home", "Admin")); } return(Redirect(loginViewModels.ReturnUrl)); } } ModelState.AddModelError("", "Tên đăng nhập hoặc mật khẩu không đúng."); return(View(loginViewModels)); }
public async Task <IActionResult> Index(LoginViewModels model) { //Valida de que las propiedades de LoginViewModels traigan sus datos correspondientes if (ModelState.IsValid) { List <object[]> listObject = await _usuarios.userLogin(model.Input.Email, model.Input.Password); object[] objects = listObject[0]; var _identityError = (IdentityError)objects[0]; model.ErrorMessage = _identityError.Description; //Si los datos de autenticación ingresados son correctos if (model.ErrorMessage.Equals("True")) { //Se obtiene la información del usuario que ha iniciado sesión var data = JsonConvert.SerializeObject(objects[1]); HttpContext.Session.SetString("User", data); return(RedirectToAction(nameof(PrincipalController.Index), "Principal")); } else { return(View(model)); } } return(View(model)); }
public async Task <IActionResult> Login(LoginViewModels model) { //di kiem thang email: KhachHang khachHang = _content.KhachHangs.SingleOrDefault(p => p.Email == model.Email && ((model.MatKhau + p.RandomKey).ToMD5() == p.MatKhau)); if (khachHang == null)//không khớp { ViewBag.ThongBaoLoi = "Sai thông tin đăng nhập"; return(View()); } //ghi nhận đăng nhập thành công var claims = new List <Claim> { new Claim(ClaimTypes.Name, khachHang.HoTen) }; ClaimsIdentity userIdentity = new ClaimsIdentity(claims, "login"); ClaimsPrincipal principal = new ClaimsPrincipal(userIdentity); await HttpContext.SignInAsync(principal); if (Url.IsLocalUrl(ReturnUrl)) { return(Redirect(ReturnUrl)); } return(RedirectToAction("Profile", "KhachHang"));//default }
public IActionResult Post(LoginViewModels login) { Usuarios usuarioBuscado = _usuarioRepository.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 async Task <IActionResult> Create(LoginViewModels models) { if (ModelState.IsValid) { ApplicationUser user = new ApplicationUser { UserName = models.UserName, Email = models.Email, CreatedDate = DateTime.Now, Status = true, EmailConfirmed = true }; IdentityResult result = await _userManager.CreateAsync(user, models.Password); if (result.Succeeded) { return(RedirectToAction("Index")); } else { foreach (IdentityError error in result.Errors) { ModelState.AddModelError("", error.Description); } } } return(View(models)); }
public ActionResult Login(LoginViewModels model) { try { var respuesta = modelo.Usuario.Where(c => c.emailUsuario == model.Username && c.password == model.Password).FirstOrDefault(); if (respuesta != null) { Usuario usuario = new Usuario() { nombreUsuario = respuesta.nombreUsuario, apellidoUsuario = respuesta.apellidoUsuario, emailUsuario = respuesta.emailUsuario, idUsuarioPerfil = respuesta.idUsuarioPerfil }; return(Index(usuario)); } else { ViewBag.MensajeError = "Datos son incorrectos"; return(View()); } } catch (Exception ex) { throw new Exception(ex.Message); } }
public ActionResult Login(LoginViewModels loginViewModels) { if (ModelState.IsValid) { UserManager um = new UserManager(); BusınessLayerResult <EverNoteUser> res = um.LoginUser(loginViewModels); if (res.Errors.Count > 0) { if (res.Errors.Find(x => x.Code == ErrorMessageCode.UserIsNotActıve) != null) { ViewBag.SetLink = "http://Home/Activate/1234-456-789"; } res.Errors.ForEach(x => ModelState.AddModelError("", x.Message)); return(View(loginViewModels)); } CurrentSession.Set <EverNoteUser>("login", res.Result); return(RedirectToAction("Index")); } return(View(loginViewModels)); }
public async Task <IActionResult> Index(LoginViewModels model) { if (ModelState.IsValid) { } return(View(model)); }
public ActionResult Login(LoginViewModels login) { if (ModelState.IsValid) { var result = UserDAO.CheckUser(login.UserName, Encryptor.MD5Hash(login.Password)); if (result == 1) { var user = UserDAO.GetByID(login.UserName); var userSession = new UserLogin(); userSession.UserID = user.ID; userSession.UserName = user.UserName; Session.Add(CommonConstants.UserSession, userSession); return(RedirectToAction("Laptop", "AdminLaptop")); } else if (result == 0) { ModelState.AddModelError("", "Tài khoản không tồn tại."); } else if (result == -2) { ModelState.AddModelError("", "Mật khẩu không đúng"); } else { ModelState.AddModelError("", "Đăng nhập không đúng"); } } return(View("Index")); }
public async Task <IActionResult> Login([FromBody] LoginViewModels model) { //if (!ModelState.IsValid) //{ // var errrors = CustomValidator.GetErrorsByModel(ModelState); // return BadRequest(errrors); //} var result = await _signInManager .PasswordSignInAsync(model.Email, model.Password, false, false); if (!result.Succeeded) { return(BadRequest(new { invalid = "Не правильно введені дані!" })); } var user = await _userManager.FindByEmailAsync(model.Email); await _signInManager.SignInAsync(user, isPersistent : false); return(Ok( new { token = CreateTokenJwt(user) })); }
public async Task <IActionResult> Login([FromBody] LoginViewModels model) { var user = await _userManager.FindByEmailAsync(model.UserName); if (user != null) { var checkPwd = await _signInManager.CheckPasswordSignInAsync(user, model.Password, true); if (checkPwd.Succeeded) { var claims = new[] { new Claim(JwtRegisteredClaimNames.Sub, user.UserName), new Claim(JwtRegisteredClaimNames.Jti, user.Id.ToString()), }; 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:Issuer"], claims, expires: DateTime.Now.AddMinutes(30), signingCredentials: creds); return(Ok(new { token = new JwtSecurityTokenHandler().WriteToken(token) })); } } return(BadRequest("Could not create token")); }
public async Task <IActionResult> Login([FromBody] LoginViewModels loginUser) { var user = await _usersService.FindUserLoginAsync(loginUser.UserName, loginUser.Password); var(accessToken, refreshToken) = await _tokenStoreService.CreateJwtTokens(user, refreshTokenSource : null); return(Ok(GetRequestResult(new { access_token = accessToken, refresh_token = refreshToken }))); }
public async Task <IActionResult> Login(LoginViewModels model, string returnUrl) { if (ModelState.IsValid) { ViewBag.ReturnUrl = returnUrl; var result = await signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, false); if (result.Succeeded) { CookieOptions option1 = new CookieOptions(); int userIdForCookie = 0; string userEmailForCookie = model.Email; if (db.Employees.Any(e => e.Email == model.Email)) { userIdForCookie = db.Employees.Where(e => e.Email == model.Email) .Select(e => e.EmployeeId).SingleOrDefault(); } else if (db.Donors.Any(e => e.Email == model.Email)) { userIdForCookie = db.Donors.Where(e => e.Email == model.Email) .Select(e => e.DonorId).SingleOrDefault(); } else if (db.Contractors.Any(e => e.Email == model.Email)) { userIdForCookie = db.Contractors.Where(e => e.Email == model.Email) .Select(e => e.ContractorId).SingleOrDefault(); } if (model.RememberMe) { option1.Expires = DateTime.Now.AddDays(7); } else { option1.Expires = DateTime.Now.AddDays(1); } //option1.Expires = TimeSpan.FromHours(12); Response.Cookies.Append("UserId", userIdForCookie.ToString(), option1); if (!string.IsNullOrEmpty(returnUrl) && Url.IsLocalUrl(ViewBag.ReturnUrl)) { return(Redirect(ViewBag.ReturnUrl)); } else { return(RedirectToAction("index", "home")); } } ModelState.AddModelError(string.Empty, "Invalid Login Attempt"); } return(View(model)); }
public ActionResult Login(String ReturnUrl) { var viewmodel = new LoginViewModels { UrlRetorno = ReturnUrl }; return(View(viewmodel)); }
public LoginPage() { InitializeComponent(); using (var scope = Dependencies.container.BeginLifetimeScope()) { VVM = Dependencies.Resolve <LoginViewModels>(); } BindingContext = VVM; }
public IActionResult Authenticate(LoginViewModels loginViewModels) { var token = jWTAuthenticationManager.Generate(Login(loginViewModels)); if (token == null) { return(Unauthorized()); } return(Ok(token)); }
public ActionResult Login(LoginViewModels loginDetails) { if (ModelState.IsValid) { return(authenticationService.UserAuthentication(loginDetails.Email, loginDetails.Password) ? RedirectToAction("Index", "User") : RedirectToAction("Login", "Account", new { status = "Invalid Email Or Password !" })); } else { return(RedirectToAction("Login", "Account", new { status = "Invalid login credentials !" })); } }