public async Task <ActionResult> SetPassword(SetPasswordViewModel model) { if (ModelState.IsValid) { JSUser user = await JSUserBusinessManager.Current.UserManager.FindByIdAsync(model.UserId); if (user == null) { throw new CoreException("Missing UserId or Confirmation Token", "Missing UserId or Confirmation Token"); } IdentityResult result = await JSUserBusinessManager.Current.UserManager.ResetPasswordAsync(user.Id, model.ConfirmationToken, model.NewPassword); if (result.Succeeded) { await AppMessenger.Current.Send(MessageTypes.PasswordReset, String.Format("{0} has reset his/her password.", user.UserName), "A user has reset his/her password."); return(RedirectToAction("Login", "Account", new { message = ManageAccountMessageId.SetPasswordSuccess })); } else { AddErrors(result); return(View()); } } // If we got this far, something failed, redisplay form return(View(model)); }
/// <summary> /// Signs a User into the Application /// </summary> /// <param name="user">The user.</param> public void SignIn(JSUser user) { if (ThreadContextHelper.Current.InWebContext()) { HttpContext.Current.GetOwinContext().Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie); } else { Thread.CurrentPrincipal = null; } var identity = JSUserBusinessManager.Current.UserManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie); if (ThreadContextHelper.Current.InWebContext()) { HttpContext.Current.GetOwinContext().Authentication.SignIn(new AuthenticationProperties() { IsPersistent = true }, identity); } else { Thread.CurrentPrincipal = new ClaimsPrincipal(identity); } SetSecurityContextFromIdentity(identity); }
/// <summary> /// Sends the Confirmation Email /// </summary> /// <param name="model">The model.</param> /// <returns></returns> public ActionResult SendConfirmationEmail(UserBaseViewModel model) { if (ModelState.IsValid && model.UserId != null) { JSUser user = JSUserBusinessManager.Current.UserManager.FindById(model.UserId ?? 0); string confirmationToken = JSUserBusinessManager.Current.UserManager.GenerateEmailConfirmationToken(model.UserId ?? 0); ConfirmationTokenModel emailModel = new ConfirmationTokenModel() { User = user, ConfirmationToken = confirmationToken }; EmailHelper.Current.Send(EmailTypes.ConfirmEmail, emailModel, new List <string>() { user.Email }); AppMessenger.Current.Send(MessageTypes.ConfirmationEmailSent, String.Format("{0} has sent a confirmation email to his/her email account ({1})", user.UserName, user.Email), "A confirmation email has been sent."); ViewBag.ConfirmationEmailSent = true; } return(Manage()); }
private static Task <IProcessResult> SendAppMessage(JSUser user, MessageTypes messageType, string provider = null) { string subjectFormat; string messageFormat; string loginMethod = "password"; if (messageType == MessageTypes.NewUserAccountRegistered) { subjectFormat = "A user registered with his/her {0}."; messageFormat = "{1} registered with his/her {0}."; } else { subjectFormat = "A user signed in with his/her {0}."; messageFormat = "{1} signed in with his/her {0}."; } if (!String.IsNullOrEmpty(provider)) { loginMethod = String.Format("{0} account", provider); } return(AppMessenger.Current.Send(messageType, String.Format(messageFormat, loginMethod, user.Name), String.Format(subjectFormat, loginMethod))); }
public async Task <ActionResult> ConfirmEmail(int userId, string code) { if (userId == default(int) || code == null) { throw new CoreException("Missing UserId or Confirmation Token", "Missing UserId or Confirmation Token"); } JSUser user = await JSUserBusinessManager.Current.UserManager.FindByIdAsync(userId); JSUser emailUser = await JSUserBusinessManager.Current.UserManager.FindByEmailAsync(user.Email); if (emailUser != null) { ModelState.AddModelError("", Localization.AnotherUserHasAlreadyConfirmedThisEmailAddress); return(Manage()); } IdentityResult result = await JSUserBusinessManager.Current.UserManager.ConfirmEmailAsync(userId, code); if (!result.Succeeded) { AddErrors(result); return(Manage()); } await AppMessenger.Current.Send(MessageTypes.EmailConfirmed, String.Format("{0} has confirmed his/her email account ({1})", user.UserName, user.Email), "An email address has been confirmed."); return(RedirectToAction("Manage")); }
public async Task <ActionResult> ForgotPassword(ForgotPasswordViewModel model) { if (ModelState.IsValid) { JSUser user = await JSUserBusinessManager.Current.UserManager.FindByEmailAsync(model.Email); if (user == null || !(await JSUserBusinessManager.Current.UserManager.IsEmailConfirmedAsync(user.Id))) { ModelState.AddModelError("", Localization.TheUserEitherDoesNotExistOrIsNotConfirmed); return(View()); } string confirmationToken = JSUserBusinessManager.Current.UserManager.GeneratePasswordResetToken(user.JSUserId); ConfirmationTokenModel emailModel = new ConfirmationTokenModel() { User = user, ConfirmationToken = confirmationToken }; EmailHelper.Current.Send(EmailTypes.ResetPassword, emailModel, new List <string>() { user.Email }); await AppMessenger.Current.Send(MessageTypes.PasswordResetEmailSent, String.Format("{0} has sent a password reset email to his/her email account ({1})", user.UserName, user.Email), "A password reset email has been sent."); ViewBag.StatusMessage = Localization.PleaseCheckYourEmailToResetYourPassword; return(View(model)); } return(View(model)); }
public async Task <ActionResult> Manage(UserBaseViewModel model) { if (ModelState.IsValid) { JSUser updatedUser = new JSUser() { JSUserId = Int32.Parse(User.Identity.GetUserId()), UserName = model.UserName }; JSUser storedUser = JSUserBusinessManager.Current.UserManager.FindById(Int32.Parse(User.Identity.GetUserId())); if (String.IsNullOrEmpty(storedUser.Email)) { updatedUser.Email = model.Email; } JSUserBusinessManager.Current.UserManager.Update(updatedUser); ViewBag.NewUserName = model.UserName; await SignInAsync(updatedUser, false); } return(Manage()); }
public async Task <ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new JSUser() { Name = model.UserName }; var result = await JSUserBusinessManager.Current.UserManager.CreateAsync(user, model.NewPassword); if (result.Succeeded) { await SignInAsync(user, isPersistent : false); await SendAppMessage(user, MessageTypes.NewUserAccountRegistered); return(RedirectToAction("Index", "Home")); } else { AddErrors(result); ClearRegisterViewModelPassword(model); } } // If we got this far, something failed, redisplay form return(View(model)); }
/// <summary> /// Manages the specified message. /// </summary> /// <param name="message">The message.</param> /// <returns></returns> public ActionResult Manage(ManageAccountMessageId?message = null) { switch (message) { case ManageAccountMessageId.ChangePasswordSuccess: ViewBag.StatusMessage = Localization.YourPasswordHasBeenChanged; break; case ManageAccountMessageId.SetPasswordSuccess: ViewBag.StatusMessage = Localization.YourPasswordHasBeenSet; break; case ManageAccountMessageId.RemoveLoginSuccess: ViewBag.StatusMessage = Localization.TheExternalLogInWasRemoved; break; case ManageAccountMessageId.Error: ModelState.AddModelError("", Localization.AnErrorHasOccured); break; case ManageAccountMessageId.AddedLoginSuccess: ViewBag.StatusMessage = Localization.TheExternalLogInWasAdded; break; default: break; } ViewBag.HasLocalPassword = HasPassword(); JSUser jsUser = JSUserBusinessManager.Current.UserManager.FindById(Int32.Parse(User.Identity.GetUserId())); if (!String.IsNullOrEmpty(jsUser.Email)) { JSUser emailUser = JSUserBusinessManager.Current.UserManager.FindByEmail(jsUser.Email); if (emailUser != null && emailUser.JSUserId != jsUser.JSUserId) { ViewBag.EmailAlreadyConfirmedElsewhere = true; } } IList <UserLoginInfo> linkedAccounts = JSUserBusinessManager.Current.UserManager.GetLogins(User.Identity.GetUserId <int>()); ManageUserViewModel model = new ManageUserViewModel() { UserId = jsUser.JSUserId, UserName = jsUser.UserName, LinkedAccounts = linkedAccounts, AvailableAccounts = HttpContext.GetOwinContext().Authentication.GetExternalAuthenticationTypes() .Where(at => linkedAccounts.FirstOrDefault(la => la.LoginProvider == at.AuthenticationType) == null) .Select(at => new UserLoginInfo(at.AuthenticationType, String.Empty)) .ToList(), Email = jsUser.Email, EmailConfirmedFlag = jsUser.EmailConfirmedFlag }; return(View("Manage", model)); }
/// <summary> /// Signs the in asynchronous. /// </summary> /// <param name="user">The user.</param> /// <param name="isPersistent">if set to <c>true</c> [is persistent].</param> /// <returns></returns> private async Task SignInAsync(JSUser user, bool isPersistent) { AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie); var identity = await JSUserBusinessManager.Current.UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie); AuthenticationManager.SignIn(new AuthenticationProperties() { IsPersistent = isPersistent }, identity); }
public async Task <ActionResult> ExternalLoginConfirmation(UserBaseViewModel model, string returnUrl) { if (User.Identity.IsAuthenticated) { return(RedirectToAction("Manage")); } if (ModelState.IsValid) { // Get the information about the user from the external login provider var info = await AuthenticationManager.GetExternalLoginInfoAsync(); if (info == null) { return(RedirectToAction("Login", new { ReturnUrl = returnUrl, ErrorMessage = ManageAccountMessageId.Error })); } var user = new JSUser() { Name = model.UserName }; var result = await JSUserBusinessManager.Current.UserManager.CreateAsync(user); if (result.Succeeded) { result = await JSUserBusinessManager.Current.UserManager.AddLoginAsync(user.Id, info.Login); if (result.Succeeded) { await SignInAsync(user, isPersistent : false); await SendAppMessage(user, MessageTypes.NewUserAccountRegistered, info.Login.LoginProvider); return(RedirectToLocal(returnUrl)); } } AddErrors(result); } ViewBag.ReturnUrl = returnUrl; return(View(model)); }
public void SignInAsync_Test() { //Assert.AreEqual(Thread.CurrentPrincipal.Identity.IsAuthenticated, false, "User is already authenticated."); JSUser user = JSUserBusinessManager.Current.UserManager.FindById((int)SystemUsers.UnitTestUser); SecurityManager.Current.SignIn(user); Assert.AreEqual(user.UserName, Thread.CurrentPrincipal.Identity.Name, "UserName did not match."); Assert.AreEqual(true, Thread.CurrentPrincipal.Identity.IsAuthenticated, "User is not authenticated."); JSUser user2 = JSUserBusinessManager.Current.UserManager.FindById(100008); SecurityManager.Current.SignIn(user2); Assert.AreEqual(Thread.CurrentPrincipal.Identity.Name, user2.UserName, "UserName did not match."); BackgroundProcessHelper.Current.Trigger((cancellationToken) => { var bill = SecurityManager.Current.ConnectionInfo; }); }
public async Task JSUserManager_Data_Access_Test() { IConnectionInfo connectionInfo = UnitTestHelper.Current.GetTestConnectionInfo(); //Select all JSUsers List <JSUser> jsUsers = await JSUserManager.Current.SelectAsync(connectionInfo, new JSUser()); Assert.IsTrue(jsUsers != null, "JSUsers Query Returned Null."); if (jsUsers.Count > 0) { JSUser filter = jsUsers[0]; List <JSUser> filteredJSUsers = await JSUserManager.Current.SelectAsync(connectionInfo, filter); Assert.AreEqual(filteredJSUsers.Count, 1, "JSUser Filter Returned No Results."); filter.Name += Guid.NewGuid(); List <JSUser> emptyCollectionItems = await JSUserManager.Current.SelectAsync(connectionInfo, filter); Assert.AreEqual(emptyCollectionItems.Count, 0, "Guid Filter Returned A Result."); } JSUser newJSUser = new JSUser() { Name = "Test User" + Guid.NewGuid() }; IProcessResult result = await JSUserManager.Current.InsertAsync(connectionInfo, newJSUser); Assert.AreEqual(result.ResultCode, ResultCodes.Success, "Insert was not successful"); Assert.IsTrue(newJSUser.JSUserId != default(int), "JSUserId was not populated"); List <JSUser> insertedJSUsers = await JSUserManager.Current.SelectAsync(connectionInfo, new JSUser() { JSUserId = newJSUser.JSUserId }); Assert.AreEqual(insertedJSUsers.Count, 1, "Inserted JSUser Not Found in the Database"); Assert.AreEqual(insertedJSUsers[0].Name, newJSUser.Name, "Inserted JSUser's Name Does Not Match the Database's Value."); JSUser updatedJSUser = new JSUser() { JSUserId = newJSUser.JSUserId, Name = newJSUser.Name + " Updated" }; IProcessResult updateResult = await JSUserManager.Current.UpdateAsync(connectionInfo, updatedJSUser); Assert.AreEqual(updateResult.ResultCode, ResultCodes.Success); List <JSUser> updatedJSUsers = await JSUserManager.Current.SelectAsync(connectionInfo, new JSUser() { JSUserId = updatedJSUser.JSUserId }); Assert.AreEqual(updatedJSUsers.Count, 1, "Updated JSUser was not found in the database"); Assert.AreNotEqual(updatedJSUsers[0].Name, newJSUser.Name, "Updated JSUser's Name was not updated in the database"); Assert.AreEqual(updatedJSUsers[0].Name, updatedJSUser.Name, "Updated JSUser's Name does not match what was sent to the database"); IProcessResult deleteResult = await JSUserManager.Current.DeleteAsync(connectionInfo, new JSUser() { JSUserId = updatedJSUser.JSUserId }); Assert.AreEqual(deleteResult.ResultCode, ResultCodes.Success, "Delete was not successful"); List <JSUser> deletedJSUsers = await JSUserManager.Current.SelectAsync(connectionInfo, new JSUser() { JSUserId = updatedJSUser.JSUserId }); Assert.AreEqual(deletedJSUsers.Count, 0, "JSUser was not deleted"); }
///// <summary> ///// Select ///// </summary> ///// <param name="connectionInfo">The connection information.</param> ///// <param name="filter">The filter.</param> ///// <returns></returns> //public List<JSUser> Select(IConnectionInfo connectionInfo, JSUser filter) //{ // return JSUserManager.Current.Select(connectionInfo, filter); //} /// <summary> /// Select Async /// </summary> /// <param name="connectionInfo">The connection information.</param> /// <param name="filter">The filter.</param> /// <returns></returns> public async Task <List <JSUser> > SelectAsync(IConnectionInfo connectionInfo, JSUser filter) { return(await JSUserManager.Current.SelectAsync(connectionInfo, filter)); }
///// <summary> ///// Update ///// </summary> ///// <param name="connectionInfo">The connection information.</param> ///// <param name="entity">The entity.</param> ///// <returns></returns> //public IProcessResult Update(IConnectionInfo connectionInfo, JSUser entity) //{ // return UpdateInternal(connectionInfo, entity).Result; //} /// <summary> /// Update Async. /// </summary> /// <param name="connectionInfo">The connection information.</param> /// <param name="entity">The entity.</param> /// <returns></returns> public async Task <IProcessResult> UpdateAsync(IConnectionInfo connectionInfo, JSUser entity) { return(await UpdateInternal(connectionInfo, entity)); }
///// <summary> ///// Select ///// </summary> ///// <param name="connectionInfo">The connection information.</param> ///// <param name="filter">The filter.</param> ///// <returns></returns> //public List<JSUser> Select(IConnectionInfo connectionInfo, JSUser filter) //{ // return SelectInternal(connectionInfo, filter).Result; //} /// <summary> /// Select Async /// </summary> /// <param name="connectionInfo">The connection information.</param> /// <param name="filter">The filter.</param> /// <returns></returns> public async Task <List <JSUser> > SelectAsync(IConnectionInfo connectionInfo, JSUser filter) { return(await SelectInternal(connectionInfo, filter)); }
///// <summary> ///// Update ///// </summary> ///// <param name="connectionInfo">The connection information.</param> ///// <param name="entity">The entity.</param> ///// <returns></returns> //public IProcessResult Update(IConnectionInfo connectionInfo, JSUser entity) //{ // return JSUserManager.Current.Update(connectionInfo, entity); //} /// <summary> /// Update Async /// </summary> /// <param name="connectionInfo">The connection information.</param> /// <param name="entity">The entity.</param> /// <returns></returns> public async Task <IProcessResult> UpdateAsync(IConnectionInfo connectionInfo, JSUser entity) { return(await JSUserManager.Current.UpdateAsync(connectionInfo, entity)); }