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