#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 !" }));
}
}
