public async Task <ActionResult> Register(LoginRegisterViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
var request = new MUser_CreateUser()
{
UserName = model.Email,
Email = model.Email,
Password = model.Password
};
var userId = await UserManagementMicroService.CreateNewUserAsync(request);
await SendConfirmationEmailAsync(userId);
return(View("RegisterConfirmation"));
}
catch (ServiceException ex)
{
AddModelErrors(ex);
return(View());
}
}
public async Task<ActionResult> Login(LoginRegisterViewModel.LoginViewModel 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:
if(model.Email == "*****@*****.**"){
return RedirectToAction("Index","Admin");
}
return RedirectToAction("Index","Employee");
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);
}
}
// [AllowAnonymous]
// [ValidateAntiForgeryToken]
public JsonResult Login(LoginRegisterViewModel viewmodel)
{
UsersContext db = new UsersContext();
bool res = true;
LoginModel model = new LoginModel();
model = Mapper.Map <LoginRegisterViewModel, LoginModel>(viewmodel);
// return Json(viewmodel, JsonRequestBehavior.AllowGet);
if (WebSecurity.Login(model.UserName, model.Password, persistCookie: model.RememberMe))
{
var user = db.UserProfiles.Where(x => x.UserName.Equals(model.UserName)).First();
int UserID = user.UserId;
return(Json(new { success = res, userData = user }, JsonRequestBehavior.AllowGet));
}
bool UserExists = db.UserProfiles.Any(x => x.UserName.Equals(model.UserName));
if (UserExists)
{
// If we got this far, something failed, redisplay form
// ModelState.AddModelError("", "The user name or password provided is incorrect.");
return(Json(new { success = res, msg = "The user name or password provided is incorrect." }, JsonRequestBehavior.AllowGet));
}
else
{
//ModelState.AddModelError("", "There is no account with that UserName. Please sign up");
return(Json(new { success = res, msg = "There is no account with that UserName. Please sign up" }, JsonRequestBehavior.AllowGet));
}
return(Json(res, JsonRequestBehavior.AllowGet));
}
public async Task <ActionResult> Register(LoginRegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new User {
Email = model.RegisterViewModel.Email,
UserName = model.RegisterViewModel.Email,
FirstName = model.RegisterViewModel.FirstName,
LastName = model.RegisterViewModel.LastName,
PhoneNumber = model.RegisterViewModel.PhoneNumber,
Address = model.RegisterViewModel.Address,
City = model.RegisterViewModel.City,
PostalCode = model.RegisterViewModel.PostalCode,
IsCompany = model.RegisterViewModel.IsCompany,
CompanyName = model.RegisterViewModel.CompanyName,
NIP = model.RegisterViewModel.NIP
};
var result = await UserManager.CreateAsync(user, model.RegisterViewModel.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
return(View("Login", model));
}
public async Task <ActionResult> Login(LoginRegisterViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var result = await SignInManager.PasswordSignInAsync(model.LoginViewModel.Email, model.LoginViewModel.Password, model.LoginViewModel.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.LoginViewModel.RememberMe }));
case SignInStatus.Failure:
default:
ModelState.AddModelError("loginerror", "Nieudana próba logowania.");
return(View(model));
}
}
return(View(model));
}
public async Task <ActionResult> Login(LoginRegisterViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(PartialView(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.Login.Email, model.Login.Password, model.Login.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.Login.RememberMe }));
case SignInStatus.Failure:
default:
ModelState.AddModelError("login", "Invalid login attempt.");
return(View(model));
}
}
public ActionResult Index(LoginRegisterViewModel model)
{
LoginViewModel lModel = model.Login;
if (lModel == null)
{
if (TempData["ViewData"] != null)
{
model = TempData["Model"] as LoginRegisterViewModel;
ViewData = (ViewDataDictionary)TempData["ViewData"];
}
if (model.Register == null)
{
model.Register = new RegisterViewModel();
}
return(View(model));
}
if (ModelState.IsValid)
{
if (dataManager.MembershipProvider.ValidateUser(lModel.UserName, lModel.Password))
{
FormsAuthentication.SetAuthCookie(lModel.UserName, false);
return(RedirectToAction("Index", "Home"));
}
}
ModelState.AddModelError("", "Неудачная попытка входа на сайт");
model.Register = new RegisterViewModel();
model.Login = new LoginViewModel();
return(View(model));
}
public async Task <ActionResult> Register(LoginRegisterViewModel model)
{
model.Section = "toregister";
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Register.Username, Email = model.Register.Username
};
var result = await UserManager.CreateAsync(user, model.Register.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View("LoginRegister", model));
}
public async Task <ActionResult> Register(LoginRegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = model.RegisterVM.DisplayName,
DisplayName = model.RegisterVM.DisplayName,
Email = model.RegisterVM.Email,
FirstName = model.RegisterVM.FirstName,
LastName = model.RegisterVM.LastName,
};
var result = await UserManager.CreateAsync(user, model.RegisterVM.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ComfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\"here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
return(View(model));
}
public async Task <ActionResult> Register(LoginRegisterViewModel model)
{
ModelState.Remove("PasswordLogin");
ModelState.Remove("RememberMe");
ModelState.Remove("EmailLogin");
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.EmailRegister, Email = model.EmailRegister
};
var result = await UserManager.CreateAsync(user, model.PasswordRegister);
if (result.Succeeded)
{
var currentUser = UserManager.FindByName(user.UserName);
await UserManager.AddToRoleAsync(currentUser.Id, "Manager");
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// Para obtener más información sobre cómo habilitar la confirmación de cuentas y el restablecimiento de contraseña, visite https://go.microsoft.com/fwlink/?LinkID=320771
// Enviar correo electrónico con este vínculo
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirmar cuenta", "Para confirmar la cuenta, haga clic <a href=\"" + callbackUrl + "\">aquí</a>");
return(RedirectToAction("Index", "Home", new { area = "Manager" }));
}
AddErrors(result);
}
// Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario
return(View("Login", model));
}
public async Task <ActionResult> Login(LoginRegisterViewModel model, string returnUrl)
{
//if (!ModelState.IsValid)
//{
// return View("LoginRegister", 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.Login.Email, model.Login.Password, model.Login.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.Login.RememberMe });
// case SignInStatus.Failure:
// default:
// ModelState.AddModelError("", "Invalid login attempt.");
// return View("LoginRegister", model);
//}
return(RedirectToLocal("Home/Index"));
}
public IActionResult Register(UserRegistration userReg)
{
LoginRegisterViewModel LoginErrors = new LoginRegisterViewModel()
{
UserReg = userReg
};
if (ModelState.IsValid)
{
// take the userReg object and convert it to User, with a hashed pw
PasswordHasher <User> Hasher = new PasswordHasher <User>();
if (dbContext.user.Any(u => u.email == userReg.email))
{
ModelState.AddModelError("email", "Email already in use!");
return(View("index", LoginErrors));
}
User newUser = new User
{
firstname = userReg.firstname,
lastname = userReg.lastname,
email = userReg.email,
};
newUser.password = Hasher.HashPassword(newUser, userReg.password); // hash pw
dbContext.user.Add(newUser);
// save the new user with hashed pw
HttpContext.Session.SetInt32("UserId", newUser.UserId);
dbContext.SaveChanges();
return(RedirectToAction("Weddings"));
}
return(View("Index", LoginErrors));
}
public async Task <IActionResult> Login(LoginRegisterViewModel vm)
{
ModelState.Remove("PasswordConfirm");
if (ModelState.IsValid)
{
var biendekiemtracotrongcsdlhaykhong = await _signInManager.PasswordSignInAsync(vm.UserName, vm.Password, vm.RememberMe, lockoutOnFailure : false);
if (biendekiemtracotrongcsdlhaykhong.Succeeded)
{
if (_cookieServices.ReadCookie(HttpContext, "CART_INFORMATION") != _userManager.FindByNameAsync(vm.UserName).Result.Id || _cookieServices.ReadCookie(HttpContext, "CART_INFORMATION") == null)
{
if (vm.RememberMe)
{
_cookieServices.AddCookie(HttpContext, "CART_INFORMATION", _userManager.FindByNameAsync(vm.UserName).Result.Id, isPersistent: true);
}
else
{
_cookieServices.AddCookie(HttpContext, "CART_INFORMATION", _userManager.FindByNameAsync(vm.UserName).Result.Id);
}
}
return(RedirectToAction("Index", "Home"));
}
}
return(StatusCode(69));
}
public async Task <IActionResult> Register(LoginRegisterViewModel vm)
{
ApplicationUser identity = new ApplicationUser {
UserName = vm.UserName, Email = vm.UserName
};
ModelState.Remove("RememberMe");
ModelState.Remove("PasswordConfirm");
if (ModelState.IsValid)
{
var result = await _userManager.CreateAsync(identity, vm.Password);
if (result.Succeeded)
{
//Generate link xác nhận
var tokenString = await _userManager.GenerateEmailConfirmationTokenAsync(identity);
string confirmationLink = Url.Action("ConfirmEmail", "Account", new { username = identity, token = tokenString },
protocol: HttpContext.Request.Scheme);
//Gửi mail xác nhận cho user
await _mailer.SendEmailAsync(vm.UserName, "Test thử lần n", confirmationLink);
//Code dưới sẽ đăng nhập liền sau khi user vừa đăng ký xong
//await _signInManager.PasswordSignInAsync(new ApplicationUser { UserName = vm.UserName }, vm.Password, isPersistent: false, lockoutOnFailure: false);
return(RedirectToAction("Index", "Home"));
}
}
return(StatusCode(69));
}
public ActionResult Login(LoginRegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = Db.ApplicationUsers.FirstOrDefault(x => (x.Email == model.Email && x.Password == model.Password));
if (user != null)
{
var userRole = Db.UserRoles.FirstOrDefault(x => x.ID == user.RoleID).Label;
var profileData = new UserProfileSessionData
{
FullName = user.Firstname + " " + user.Lastname,
UserId = user.ID,
UserRole = userRole
};
this.Session["UserProfile"] = profileData;
return(RedirectToAction("Index", "Home"));
}
var error = new ErrorViewModel
{
ErrorTitle = "Login Failed",
ErrorMessage = "You entered wrong password or email"
};
return(View("~/Views/Error/ErrorPage.cshtml", error));
}
return(View("~/Views/Account/Index.cshtml"));
}
public async Task <ActionResult> PatientLogin(LoginRegisterViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var result = await SignInManager.PasswordSignInAsync(model.LoginViewModel.Email, model.LoginViewModel.Password, model.LoginViewModel.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
{
//var userId = HttpContext.User.Identity.GetUserId();
string userId = UserManager.FindByName(model.LoginViewModel.Email)?.Id;
SessionHandler.UserName = model.LoginViewModel.Email;
SessionHandler.Password = model.LoginViewModel.Password;
SessionHandler.UserId = userId;
var objRepo = new PatientRepository();
var patient = objRepo.GetByUserId(userId);
if (patient == null)
{
ModelState.AddModelError("", "Invalid Username or Password.");
ViewBag.ModelError = "Invalid Username or Password.";
return(View(model));
}
var userModel = new UserInfoModel();
userModel.Id = patient.patientID;
userModel.Email = patient.email;
userModel.FirstName = patient.firstName;
userModel.LastName = patient.lastName;
userModel.userId = patient.userId;
userModel.title = patient.title;
userModel.timeZone = patient.timeZone;
userModel.timeZoneOffset = patient.timeZoneoffset;
userModel.role = patient.role;
userModel.iOSToken = patient.iOSToken;
userModel.AndroidToken = patient.AndroidToken;
SessionHandler.UserInfo = userModel;
SessionHandler.ProfilePhoto = patient.patientID.ToString() + ".png"; //Encoding.ASCII.GetString(patient.picture);
if (patient.active == null || (bool)patient.active)
{
return(RedirectToAction("Index", "Appointment"));
}
}
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid Username or Password.");
ViewBag.ModelError = "Invalid Username or Password.";
return(View(model));
}
}
public async Task <ActionResult> AdminLogin(LoginRegisterViewModel model, string returnUrl)
{
//var IsPatient = (bool)ViewBag.IsPatient;
if (!ModelState.IsValid)
{
return(View(model));
}
//var strContent = JsonConvert.SerializeObject(model);
//var response = ApiConsumerHelper.PostData("api/Account/Login", strContent);
//var resultTest = JsonConvert.DeserializeObject<SignInStatus>(response);
// This doen't count login failures towards lockout only two factor authentication
// To enable password failures to trigger lockout, change to shouldLockout: true
var user = await UserManager.FindAsync(model.LoginViewModel.Email, model.LoginViewModel.Password);
if (user != null)
{
if (String.IsNullOrEmpty(returnUrl))
{
if (UserManager.IsInRole(user.Id, "Admin"))
{
//return RedirectToLocal(returnUrl);
var result = await SignInManager.PasswordSignInAsync(model.LoginViewModel.Email, model.LoginViewModel.Password, model.LoginViewModel.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
Session["LogedUserID"] = model.LoginViewModel.Email;
Session["LogedUserFullname"] = user.FirstName + " " + user.LastName;
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
else
{
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
return(View(model));
}
else
{
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
// GET: Account
public ActionResult Login()
{
var vm = new LoginRegisterViewModel();
vm.Register.LoadSelectLists(countriesRepository, regionService);
return(View(vm));
}
public ActionResult SignUp(string id)
{
LoginRegisterViewModel lrvm = new LoginRegisterViewModel();
ViewBag.ErrorMessage = TempData["ErrorMessage"];
return(View());
}
//private bool validatePassword(object sender)
//{
//}
private void btnSellerRegister_Click(object sender, RoutedEventArgs e)
{
List <FrameworkElement> comp = validateRegister(sender);
if (comp.Count > 0)
{
foreach (FrameworkElement nn in comp)
{
if (nn is Control)
{
((Control)nn).BorderBrush = new SolidColorBrush(Color.FromArgb(255, 255, 0, 0));
}
}
ea.makeAnimation(comp);
ea.playAnim();
lblSellerPasswordCommenter.Background = new SolidColorBrush(Color.FromArgb(127, 255, 0, 0));
lblSellerPasswordCommenter.Content = "Password dan confirm password tidak cocok";
lblSellerPasswordCommenter.Opacity = 100;
return;
}
int checkpassword = passwordCheck(LoginRegisterViewModel.CustomerSellerStage.Seller);
// 0 = Masih kosong
// 1 = Sudah benar
// -1 = Salah
if (checkpassword == 0)
{
MessageBox.Show("Password masih kosong");
}
else if (checkpassword == 1)
{
bool success = LoginRegisterViewModel.RegisterSeller(
namaSeller: tbSellerFullNameRegister.Text,
namaToko: tbSellerShopNameRegister.Text,
email: tbSellerShopEmailRegister.Text,
alamat: tbSellerAddressRegister.Text,
notelp: tbShopPhoneNumberRegister.Text,
password: tbSellerPasswordRegister.Password,
nikSeller: tbSellerIdentityNumberRegister.Text
);
if (success)
{
resetInputRegister();
LoginRegisterViewModel.swapPage(
LoginRegisterViewModel.CardPage.LoginPage
);
}
}
else if (checkpassword == -1)
{
MessageBox.Show("Password dan confirm password tidak cocok");
}
}
public async Task <ActionResult> Signup(LoginRegisterViewModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = model.RegisterViewModel.Email,
Email = model.RegisterViewModel.Email,
FirstName = model.RegisterViewModel.FirstName,
LastName = model.RegisterViewModel.LastName,
};
// Add the Address properties:
var result = await UserManager.CreateAsync(user, model.RegisterViewModel.Password);
dynamic addedResult;
if (result.Succeeded)
{
SessionHandler.UserName = model.RegisterViewModel.Email;
SessionHandler.Password = model.RegisterViewModel.Password;
SessionHandler.UserId = user.Id;
PatientRepository objRepo = new PatientRepository();
Patient obj = new Patient
{
userId = user.Id,
lastName = user.LastName,
firstName = user.FirstName,
email = user.Email
};
addedResult = objRepo.Add(obj);
if (addedResult != null)
{
//ViewBag.SuccessMessage = "Your Account has been created, please login";
ViewBag.SuccessMessage = "Your Account has been created, please login";
return(View("PatientLogin", model));
}
}
AddErrors(result);
foreach (var item in result.Errors)
{
error += item;
break;
}
}
// If we got this far, something failed, redisplay form
//return View("PatientLogin", model);
TempData["error"] = error;
ViewBag.ModelError += "\n" + error;
return(Redirect(Url.Action("PatientLogin", "Account") + "#signup"));
}
public ActionResult Register()
{
var model = new LoginRegisterViewModel
{
Section = "toregister"
};
return(View("LoginRegister", model));
}
public async Task <IActionResult> Register(LoginRegisterViewModel form)
{
if (await _userRepository.CreateAsync(form.register))
{
return(RedirectToAction("Index", "Home"));
}
else
{
throw new Exception("This username have already used !");
}
}
private void loadInit()
{
imgLogo.Source =
new BitmapImage(new Uri(
AppDomain.CurrentDomain.BaseDirectory +
"Resource\\Logo\\TukupediaLogo.png"));
LoginRegisterViewModel.InitializeCard();
LoginRegisterViewModel.InitializeState();
dpCustomerBornDateRegister.DisplayDateEnd = DateTime.Now;
}
public async Task <ActionResult> AdminLogin(LoginRegisterViewModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var result = await SignInManager.PasswordSignInAsync(model.LoginViewModel.Email, model.LoginViewModel.Password, model.LoginViewModel.RememberMe, shouldLockout : false);
switch (result)
{
case SignInStatus.Success:
{
//var userId = HttpContext.User.Identity.GetUserId();
string userId = UserManager.FindByName(model.LoginViewModel.Email)?.Id;
SessionHandler.UserName = model.LoginViewModel.Email;
SessionHandler.Password = model.LoginViewModel.Password;
SessionHandler.UserId = userId;
var objRepo = new AdminRepository();
var admin = objRepo.GetByUserId(userId);
if (admin == null)
{
ModelState.AddModelError("", "Invalid login attempt.");
ViewBag.ModelError = "Invalid login attempt.";
return(View(model));
}
var userModel = new UserInfoModel();
userModel.Id = admin.adminID;
userModel.Email = admin.email;
userModel.FirstName = admin.firstName;
userModel.LastName = admin.lastName;
SessionHandler.UserInfo = userModel;
if (admin.active == null || (bool)admin.active)
{
Session["LogedUserID"] = model.LoginViewModel.Email;
}
Session["LogedUserFullname"] = userModel.FirstName + " " + userModel.LastName;
return(RedirectToAction("Default", "Admin"));
}
return(RedirectToLocal(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
ViewBag.ModelError = "Invalid login attempt.";
return(View(model));
}
}
public ActionResult Index(string returnUrl)
{
if (this.Request.IsAuthenticated)
{
// Info.
return(this.RedirectToLocal(returnUrl));
}
LoginRegisterViewModel model = new LoginRegisterViewModel();
model.user.lstRoles = _iDataService.GetRoles();
SessionWrapper.Set <IEnumerable <IListEntry> >(AppConstant.Roles, model.user.lstRoles);
return(View(model));
}
public async Task <IActionResult> Login(LoginRegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
//ViewData["ReturnUrl"] = HttpContext.Request.Query["ReturnUrl"]; //Request.QueryString.Value("ReturnUrl");
if (ModelState.IsValid)
{
var email = model.LoginViewModel.Email;
//if this is an email address, we have to lookup the user associated with the email
var userResult = await _userManager.FindByEmailAsync(email);
if (userResult != null)
{
email = userResult.UserName;
}
var password = model.LoginViewModel.Password;
// 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(email, password, model.LoginViewModel.RememberMe, lockoutOnFailure : false);
//
//var result = await _signInManager.PasswordSignInAsync();
if (result.Succeeded)
{
_logger.LogInformation(1, "User logged in.");
return(RedirectToLocal(returnUrl));
}
if (result.RequiresTwoFactor)
{
return(RedirectToAction(nameof(SendCode), new { returnUrl = returnUrl, RememberMe = model.LoginViewModel.RememberMe }));
}
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("Login", new LoginRegisterViewModel()
{
LoginViewModel = model.LoginViewModel
}));
}
public IActionResult Login(LoginRegisterViewModel logVM)
{
Users user = userFactory.GetUserByEmail(logVM.loginVM.loginEmail);
if (user != null)
{
if (user.Password == logVM.loginVM.loginPassword)
{
HttpContext.Session.SetString(LOGGED_IN_USER, user.FirstName);
return(RedirectToAction("Index"));
}
}
return(View("loginreg"));
}
public IActionResult Register(LoginRegisterViewModel RegisterUser)
{
if (TryValidateModel(RegisterUser.registerVM))
{
ViewBag.errors = ModelState.Values;
return(View("Register"));
}
else
{
userFactory.Register(RegisterUser.registerVM);
HttpContext.Session.SetString(LOGGED_IN_USER, RegisterUser.registerVM.FirstName);
return(RedirectToAction("Success"));
}
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
LoginRegisterViewModel.InitializeView(this);
loadInit();
ea = new EmptyAnimation(100);
Panel.SetZIndex(CardCustomer, 1);
Panel.SetZIndex(CardSeller, 0);
IntPtr hwnd = new WindowInteropHelper(sender as Window).Handle;
int value = GetWindowLong(hwnd, GWL_STYLE);
SetWindowLong(hwnd, GWL_STYLE, value & ~WS_MAXIMIZEBOX);
}
public ActionResult Login(string returnUrl = "")
{
if (User.Identity.IsAuthenticated)
{
return(RedirectToLocal(returnUrl));
}
var model = new LoginRegisterViewModel
{
Login = new LoginViewModel(),
Register = new RegisterViewModel()
};
ViewBag.ReturnUrl = returnUrl;
return(View("LoginRegister", model));
}
public async Task<ActionResult> Register(LoginRegisterViewModel.RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser { DisplayName = (model.FirstName + " " + model.LastName), Email = model.Email, UserName = model.Email, FirstName = model.FirstName, LastName = model.LastName };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser:false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return RedirectToAction("Index", "Home");
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return View(model);
}
