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);
}
