//[Route("~/[controller]/[action]")]
public async Task <IActionResult> SignIn(AccountSignInViewModel model, string ReturnUrl)
{
if (this._signInManager.IsSignedIn(User))
{
return(RedirectToAction("Index", "Home"));
}
model.ExternalLogins = new ExternalLoginsViewModel()
{
ExternalLogins = (await this._signInManager.GetExternalAuthenticationSchemesAsync()).ToList()
};
if (ModelState.IsValid)
{
// Change The Last Parametr To Activate The AccountLock After A specific Tries.
var result = await this._signInManager.PasswordSignInAsync(model.Email, model.Password, model.Remembre, false);
if (result.Succeeded)
{
if (!String.IsNullOrEmpty(ReturnUrl) && Url.IsLocalUrl(ReturnUrl))
{
// Will return the user to any URL.
return(Redirect(ReturnUrl));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
ModelState.AddModelError(string.Empty, "Email or Password Incorrect!!");
}
return(View(model));
}
public async Task <ActionResult> SignIn(AccountSignInViewModel viewModel)
{
if (ModelState.IsValid)
{
var result = await _signInManager.PasswordSignInAsync(viewModel.Email, viewModel.Password, viewModel.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
{
return(RedirectToAction("Index", "Entries"));
}
case SignInStatus.Failure:
{
ModelState.AddModelError("", "Invalid email or password!");
break;
}
case SignInStatus.LockedOut:
{
throw new NotImplementedException();
}
default:
{
throw new ApplicationException("Unexpected Microsoft.AspNet.Identity.Owin.SignInStatus enum value: " + result);
}
}
}
return(View(viewModel));
}
public async Task <ActionResult> SignIn(AccountSignInViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
var result = await _signInManager.PasswordSignInAsync(viewModel.Email, viewModel.Password, viewModel.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
return(RedirectToAction("Index", "Member"));
case SignInStatus.Failure:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(viewModel));
case SignInStatus.LockedOut:
case SignInStatus.RequiresVerification:
throw new NotImplementedException("Identity feature not implemented.");
default:
throw new Exception("Unexpected Microsoft.AspNet.Identity.Owin.SignInStatus enum value: " + result);
}
}
public async Task <IActionResult> SignIn(AccountSignInViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure : true);
if (result.Succeeded)
{
Logger.LogInformation("User signed in.");
return(RedirectToAction("Index", "Home"));
}
//if (result.RequiresTwoFactor)
//{
// return RedirectToPage("./LoginWith2fa", new { ReturnUrl = returnUrl, RememberMe = Input.RememberMe });
//}
if (result.IsLockedOut)
{
Logger.LogWarning("User account locked out.");
//return RedirectToPage("./Lockout");
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError(string.Empty, "Invalid login attempt.");
return(View(model));
}
}
public async Task SignInHttpPostValidViewModelTest()
{
var mockIUserStore = new Mock <IUserStore <User> >();
var mockIAuthenticationManager = new Mock <IAuthenticationManager>();
var mockApplicationUserManager = new Mock <ApplicationUserManager>(mockIUserStore.Object);
var mockApplicationSignInManager = new Mock <ApplicationSignInManager>(mockApplicationUserManager.Object, mockIAuthenticationManager.Object);
mockApplicationSignInManager.Setup(x => x.PasswordSignInAsync(It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>()))
.ReturnsAsync(SignInStatus.Success);
_accountController = new AccountController(mockApplicationUserManager.Object, mockApplicationSignInManager.Object, mockIAuthenticationManager.Object);
var viewModel = new AccountSignInViewModel()
{
Email = "",
Password = "",
RememberMe = false
};
var result = await _accountController.SignIn(viewModel) as RedirectToRouteResult;
Assert.AreEqual("Index", (string)result?.RouteValues["action"]);
}
//[Route("~/[controller]/[action]")]
public async Task <IActionResult> SignIn(string returnUrl)
{
var model = new AccountSignInViewModel();
model.ExternalLogins.ExternalLogins = (await this._signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
model.ExternalLogins.ReturnUrl = returnUrl;
return(View(model));
}
public async Task <ActionResult> SignIn(AccountSignInViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View());
}
return(await SignInUser(viewModel, viewModel.RememberMe));
}
public ActionResult SignIn(AccountSignInViewModel vm)
{
if (!ModelState.IsValid)
{
return(Content("Coś poszło nie tak..."));
}
var userSignInRequestModel = _mapper.Map <AccountSignInViewModel, UserSignInRequestModel>(vm);
if (!_userService.SignIn(userSignInRequestModel))
{
return(View("ActivateAccount"));
}
SetSignedInUser(vm.Username);
return(RedirectToAction("Index", "Home"));
}
public IActionResult SignIn(AccountSignInViewModel accountSignInViewModel)
{
var result = _client.GetStringAsync("api/accounts").Result;
var accounts = JsonConvert.DeserializeObject <List <AccountSignInViewModel> >(result);
var account = accounts.FirstOrDefault(a => a.Login == accountSignInViewModel.Login);
if (account == null)
{
return(Redirect("/site/vertical/pages-login.html"));
}
if (_encrypter.ValidatePassword(accountSignInViewModel.Password, account.Password))
{
return(Redirect("/site/vertical/table-company.html"));
}
return(Redirect("/site/vertical/pages-login.html"));
}
public async Task SignInHttpPostInvalidViewModelTest()
{
using (var mock = AutoMock.GetLoose())
{
var viewModel = new AccountSignInViewModel()
{
Email = "",
Password = "",
RememberMe = false
};
_accountController = mock.Create <AccountController>();
_accountController.ModelState.AddModelError("key", "error message");
var result = await _accountController.SignIn(viewModel);
Assert.IsInstanceOf <ViewResult>(result);
}
}
public async Task <IActionResult> SignIn(AccountSignInViewModel vm, string ReturnUrl)
{
if (ModelState.IsValid)
{
var result = await this._signInManager.PasswordSignInAsync(vm.Email, vm.Password, false, false);
if (result.Succeeded)
{
if (!string.IsNullOrEmpty(ReturnUrl) && Url.IsLocalUrl(ReturnUrl))
{
return(Redirect(ReturnUrl));
}
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError(string.Empty, "Invalid Login Attempt");
}
return(View(vm));
}
/// <summary>
/// Performs authentication for the application.
/// </summary>
/// <param name="vm">Sign in view model instance that contains the user's login information.</param>
/// <returns>Login reponse with authorization details.</returns>
internal async Task <UserResponse> AuthenticateAsync(AccountSignInViewModel vm, CancellationToken ct)
{
var response = new UserResponse()
{
AccessToken = "1234567890", RefreshToken = "abcdefghijklmnop", UserID = vm.Username, Email = vm.Username, FirstName = "John", LastName = "Doe"
};
await Task.Delay(2000, ct);
return(response);
//this.Client.DefaultRequestHeaders.Add("Authorization", "Basic YzExNGEzM2U4YjNhNDdmY2E3NzBhYmJiMGNlOWE0YjE6NDFjOTcxYTU3NzlhNGZhMGI4NGZmN2EzNTA4NTQ5M2U=");
//var dic = new Dictionary<string, string>();
//dic.Add("grant_type", "password");
//dic.Add("username", vm.Username);
//dic.Add("password", vm.Password);
//dic.Add("scope", "streaming");
//var contents = new System.Net.Http.FormUrlEncodedContent(dic);
//return await this.PostAsync<UserResponse>(URL_ACCOUNT_SIGNIN, contents, ct);
}
public ActionResult SignIn(AccountSignInViewModel model, string returnUrl = null, int?errorMessage = null)
{
if (!ModelState.IsValid)
{
return(View(new AccountSignInViewModel(
source: model,
returnUrl: returnUrl,
displayCaptcha: CaptchaSettings.CaptchaIsConfigured() && CaptchaSettings.RequireCaptchaOnLogin,
passwordResetAvailable: ControllerHelper.IsPasswordResetAvailable())));
}
var signedInCustomer = HttpContext.GetCustomer();
if (CaptchaSettings.CaptchaIsConfigured() &&
CaptchaSettings.RequireCaptchaOnLogin)
{
var captchaResult = CaptchaVerificationProvider.ValidateCaptchaResponse(Request.Form[CaptchaVerificationProvider.RecaptchaFormKey], signedInCustomer.LastIPAddress);
if (!captchaResult.Success)
{
NoticeProvider.PushNotice(captchaResult.Error.Message, NoticeType.Failure);
return(View(new AccountSignInViewModel(
source: model,
returnUrl: returnUrl,
displayCaptcha: CaptchaSettings.CaptchaIsConfigured() && CaptchaSettings.RequireCaptchaOnLogin,
passwordResetAvailable: ControllerHelper.IsPasswordResetAvailable())));
}
}
// Login
var result = ControllerHelper.Login(
signedInCustomer: signedInCustomer,
profile: HttpContext.Profile,
username: model.Email,
password: model.Password,
skinId: signedInCustomer.SkinID);
if (result.State == AccountControllerHelper.ResultState.Error)
{
NoticeProvider.PushNotice(result.Message, NoticeType.Failure);
return(View(new AccountSignInViewModel(
source: model,
returnUrl: returnUrl,
displayCaptcha: CaptchaSettings.CaptchaIsConfigured() && CaptchaSettings.RequireCaptchaOnLogin,
passwordResetAvailable: ControllerHelper.IsPasswordResetAvailable())));
}
else if (result.State == AccountControllerHelper.ResultState.PasswordChangeRequired)
{
NoticeProvider.PushNotice(result.Message, NoticeType.Info);
return(RedirectToAction(
actionName: ActionNames.ChangePassword,
routeValues: new
{
email = model.Email,
returnUrl = returnUrl
}));
}
var targetCustomer = new Customer(model.Email);
var identity = ClaimsIdentityProvider.Create(targetCustomer);
Request
.GetOwinContext()
.Authentication
.SignIn(
properties: new Microsoft.Owin.Security.AuthenticationProperties
{
IsPersistent = model.PersistLogin
},
identities: identity);
if (!string.IsNullOrEmpty(result.Message))
{
NoticeProvider.PushNotice(result.Message, NoticeType.Info);
}
// Consolidate any shopping cart items
CartActionProvider.ConsolidateCartItems(targetCustomer, CartTypeEnum.ShoppingCart);
CartActionProvider.ConsolidateCartItems(targetCustomer, CartTypeEnum.WishCart);
var safeReturnUrl = Url.MakeSafeReturnUrl(returnUrl);
return(Redirect(safeReturnUrl));
}
public async Task <ActionResult> frmUserSignIn(AccountSignInViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
//Sign-In the user
var result = await _signInManager.PasswordSignInAsync(viewModel.Username, viewModel.Password, viewModel.RememberMe, shouldLockout : false);
//Check the Result
switch (result)
{
case SignInStatus.Success:
return(RedirectToAction("Index", "Home"));
case SignInStatus.Failure:
ModelState.AddModelError("", "Invalid login attempt.");
try
{
MailMessage mail = new MailMessage();
//Change who you want to send the email to
mail.To.Add("Email sent to");
//Change who you want to send the email from
mail.From = new MailAddress("Email sent from");
mail.Subject = "Requesting Information";
string userMessage = "";
userMessage = "<br/>Name: " + viewModel.Username;
string Body = "Hi, <br/><br/> Unknown User Login:<br/><br/> " + userMessage + "<br/><br/>Thanks";
mail.Body = Body;
mail.IsBodyHtml = true;
SmtpClient smtp = new SmtpClient();
//SMTP Server Address of gmail
smtp.Host = "smtp.gmail.com";
smtp.Port = 587;
//Add in email credentials
smtp.Credentials = new NetworkCredential("email username", "email password");
// Smtp Email ID and Password For authentication
smtp.EnableSsl = true;
smtp.Send(mail);
ViewBag.Message = "Thank you for your time.";
}
catch
{
ViewBag.Message = "Error............";
}
return(View(viewModel));
case SignInStatus.LockedOut:
case SignInStatus.RequiresVerification:
throw new NotImplementedException("identity feature not implemented.");
default:
throw new Exception("Unexpected Microsoft.AspNet.Identity.Owin.SignInStatus enum value: " + result);
}
}
public ActionResult SignIn(AccountSignInViewModel model, string returnUrl = null, int?errorMessage = null)
{
if (!ModelState.IsValid)
{
return(View(new AccountSignInViewModel(
source: model,
captchaCode: string.Empty,
returnUrl: returnUrl,
displayCaptcha: Settings.RequireCaptchaOnLogin,
passwordResetAvailable: ControllerHelper.IsPasswordResetAvailable())));
}
var signedInCustomer = HttpContext.GetCustomer();
if (Settings.RequireCaptchaOnLogin &&
!ControllerHelper.IsCaptchaValid(
requiredSecurityCode: CaptchaStorageService.RetrieveSecurityCode(HttpContext, string.Concat(ControllerNames.Account, ActionNames.SignIn)),
securityCode: model.CaptchaCode))
{
CaptchaStorageService.ClearSecurityCode(HttpContext);
ModelState.AddModelError(
key: "CaptchaCode",
errorMessage: "The letters you entered did not match, please try again.");
return(View(new AccountSignInViewModel(
source: model,
captchaCode: string.Empty,
returnUrl: returnUrl,
displayCaptcha: Settings.RequireCaptchaOnLogin,
passwordResetAvailable: ControllerHelper.IsPasswordResetAvailable())));
}
// Login
var result = ControllerHelper.Login(
signedInCustomer: signedInCustomer,
profile: HttpContext.Profile,
username: model.Email,
password: model.Password,
skinId: signedInCustomer.SkinID);
if (result.State == AccountControllerHelper.ResultState.Error)
{
NoticeProvider.PushNotice(result.Message, NoticeType.Failure);
return(View(new AccountSignInViewModel(
source: model,
captchaCode: string.Empty,
returnUrl: returnUrl,
displayCaptcha: Settings.RequireCaptchaOnLogin,
passwordResetAvailable: ControllerHelper.IsPasswordResetAvailable())));
}
else if (result.State == AccountControllerHelper.ResultState.PasswordChangeRequired)
{
NoticeProvider.PushNotice(result.Message, NoticeType.Info);
return(RedirectToAction(
actionName: ActionNames.ChangePassword,
routeValues: new
{
email = model.Email,
returnUrl = returnUrl
}));
}
var targetCustomer = new Customer(model.Email);
var identity = ClaimsIdentityProvider.CreateClaimsIdentity(targetCustomer);
Request
.GetOwinContext()
.Authentication
.SignIn(
properties: new Microsoft.Owin.Security.AuthenticationProperties
{
IsPersistent = model.PersistLogin
},
identities: identity);
if (!String.IsNullOrEmpty(result.Message))
{
NoticeProvider.PushNotice(result.Message, NoticeType.Info);
}
// Clear the captcha so additional requests use a different security code.
CaptchaStorageService.ClearSecurityCode(HttpContext);
var safeReturnUrl = Url.MakeSafeReturnUrl(returnUrl);
return(Redirect(safeReturnUrl));
}
