private string GetStartPage(string userName, bool useEmail = false)
{
ViewBag.StartPageClass = "fa-heart-o";
try
{
ApplicationUser appUser = _userManager.FindByName(userName);
if (useEmail)
{
appUser = _userManager.FindByEmail(userName);
}
if (appUser != null)
{
string page = ClaimHelper.GetSafeClaim(appUser, AppConstants.FAVORITE_PAGE);
if (page != string.Empty)
{
ViewBag.StartPageClass = "fa-heart red";
}
return(page);
}
}
catch
{
}
return(string.Empty);
}
public JsonResult Retrieve()
{
if (_userManager != null && _userManager.SupportsUserRole)
{
var appUsers = _userManager.Users.ToList();
var filteredUsers = appUsers.Where(u => u.Claims.Any(t => t.ClaimType == AppConstants.INVITATION_CLAIM && t.ClaimValue == "1"));
var invitedUsers = filteredUsers.Select(u =>
new UserInvitationViewModel
{
UserId = u.Id,
UserName = u.UserName,
UserEmail = u.Email,
InvitationCode = ClaimHelper.GetSafeClaim(u, AppConstants.INVITATION_CODE_CLAIM, string.Empty),
ExpirationDate = DateTime.Parse(ClaimHelper.GetSafeClaim(u, AppConstants.EXPIRATION_DATE_CLAIM, DateTime.Today.Date.AddDays(-1).ToShortDateString())),
UserRoles = TuplifyString(ClaimHelper.GetSafeClaim(u, AppConstants.ROLES_CLAIM, string.Empty)),
Password = string.Empty,
ConfirmPassword = string.Empty,
})
.ToList();
string message = string.Format("Total of {0:d} users are retrieved for invitation.", invitedUsers.Count());
DojoLogger.Trace(message, typeof(UserRoleManagerController));
return(Json(invitedUsers, JsonRequestBehavior.AllowGet));
}
else if (!_userManager.SupportsUserRole)
{
return(JsonError("User Role is not suported."));
}
else
{
return(JsonError("Role manager does not exist"));
}
}
private void SetExternalInvitationRoles(ApplicationUser externalUser, string phone)
{
//----------------------------------------------------------------------------------------------------
// when the external user accepts the invitation, we remove the invitation and roles claims for the
// internal user, confirm the email and add phone # for the external user.
//----------------------------------------------------------------------------------------------------
if (externalUser != null)
{
string roleClaim = ClaimHelper.GetSafeClaim(externalUser, AppConstants.ROLES_CLAIM, string.Empty);
string[] roles = roleClaim.Split(new char[] { ',' });
if (roles.Length > 0)
{
_userManager.AddToRoles(externalUser.Id, roles);
}
externalUser.EmailConfirmed = true;
externalUser.PhoneNumber = phone;
_userManager.Update(externalUser);
// remove invitation claim for the internal user
SafeRemoveClaim(externalUser, AppConstants.INVITATION_CLAIM, ClaimHelper.GetSafeClaim(externalUser, AppConstants.INVITATION_CLAIM, "1"));
SafeRemoveClaim(externalUser, AppConstants.EXPIRATION_DATE_CLAIM, ClaimHelper.GetSafeClaim(externalUser, AppConstants.EXPIRATION_DATE_CLAIM, string.Empty));
SafeRemoveClaim(externalUser, AppConstants.ROLES_CLAIM, ClaimHelper.GetSafeClaim(externalUser, AppConstants.ROLES_CLAIM, string.Empty));
}
}
public async Task <ActionResult> Accept(UserInvitationViewModel model)
{
try
{
//----------------------------------------------------------------------------------------------------
// when the user accepts the invitation, we remove the invitation claims and sign the user in;
// temporary password is the invitation code; also confirm the email as user gets here by email link.
//----------------------------------------------------------------------------------------------------
var user = _userManager.FindById(model.UserId);
if (user != null)
{
user.EmailConfirmed = true;
user.PhoneNumber = model.MobilePhone;
_userManager.Update(user);
// change user password
IdentityResult result = _userManager.ChangePassword(user.Id, model.InvitationCode, model.Password);
if (result.Succeeded)
{
string roleClaim = ClaimHelper.GetSafeClaim(user, AppConstants.ROLES_CLAIM, string.Empty);
string[] roles = roleClaim.Split(new char[] { ',' });
if (roles.Length > 0)
{
_userManager.AddToRoles(user.Id, roles);
}
// remove invitation claim for the user
SafeRemoveClaim(user, AppConstants.INVITATION_CLAIM, ClaimHelper.GetSafeClaim(user, AppConstants.INVITATION_CLAIM, "1"));
SafeRemoveClaim(user, AppConstants.INVITATION_CODE_CLAIM, ClaimHelper.GetSafeClaim(user, AppConstants.INVITATION_CODE_CLAIM, string.Empty));
SafeRemoveClaim(user, AppConstants.EXPIRATION_DATE_CLAIM, ClaimHelper.GetSafeClaim(user, AppConstants.EXPIRATION_DATE_CLAIM, string.Empty));
SafeRemoveClaim(user, AppConstants.ROLES_CLAIM, ClaimHelper.GetSafeClaim(user, AppConstants.ROLES_CLAIM, string.Empty));
user = _userManager.FindById(model.UserId);
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Index", "Home", "/")); // redirect user to home page
}
}
}
catch
{
}
// redirect to login page if anything is wrong
return(RedirectToAction("Login", "Account", "/"));
}
public JsonResult SetStartPage(string page)
{
try
{
ApplicationUser appUser = _userManager.FindByName(ClaimsPrincipal.Current.Identity.Name);
if (appUser != null)
{
// keep only one start page
string oldPage = ClaimHelper.GetSafeClaim(appUser, AppConstants.FAVORITE_PAGE);
_userManager.RemoveClaim(appUser.Id, new Claim(AppConstants.FAVORITE_PAGE, oldPage));
_userManager.AddClaim(appUser.Id, new Claim(AppConstants.FAVORITE_PAGE, page));
return(Json("success", JsonRequestBehavior.AllowGet));
}
}
catch
{
}
return(Json("fail", JsonRequestBehavior.AllowGet));
}
public ActionResult Accept(string id, string invite)
{
try
{
//------------------------------------------------------------------------------------------------
// present the user with the invitation form pre-popualated user name, email and invitation code.
//------------------------------------------------------------------------------------------------
var user = _userManager.FindById(id);
if (user != null)
{
var claimValue = ClaimHelper.GetSafeClaim(user, AppConstants.INVITATION_CODE_CLAIM, null);
if (claimValue != null)
{
var invitationCode = claimValue;
var expiredOn = ClaimHelper.GetSafeClaim(user, AppConstants.EXPIRATION_DATE_CLAIM, DateTime.Today.Date.AddDays(-1).ToShortDateString());
DateTime expirationDate;
if (DateTime.TryParse(expiredOn, out expirationDate) == true)
{
if (DateTime.Today.Date <= expirationDate && invitationCode == invite)
{
UserInvitationViewModel invitationModel = new UserInvitationViewModel();
invitationModel.UserId = id;
invitationModel.UserName = user.UserName;
invitationModel.UserEmail = user.Email;
invitationModel.InvitationCode = invite;
return(View(invitationModel));
}
}
}
else // user has been here before, redirect it to login page
{
return(RedirectToAction("Login"));
}
}
}
catch
{
}
// redirect to login page if anything is wrong
return(RedirectToAction("Login"));
}
public JsonResult Update(string model)
{
try
{
UserInvitationViewModel invitation = JsonConvert.DeserializeObject <UserInvitationViewModel>(model);
var user = _userManager.Users.Where(u => u.Id == invitation.UserId).First();
if (user == null)
{
Response.StatusCode = (int)System.Net.HttpStatusCode.Conflict;
return(JsonError("User does not exist."));
}
else
{
user.UserName = invitation.UserName;
user.Email = invitation.UserEmail;
_userManager.Update(user);
SafeRemoveClaim(user, AppConstants.INVITATION_CODE_CLAIM, ClaimHelper.GetSafeClaim(user, AppConstants.INVITATION_CODE_CLAIM, string.Empty));
SafeRemoveClaim(user, AppConstants.EXPIRATION_DATE_CLAIM, ClaimHelper.GetSafeClaim(user, AppConstants.EXPIRATION_DATE_CLAIM, string.Empty));
SafeRemoveClaim(user, AppConstants.ROLES_CLAIM, ClaimHelper.GetSafeClaim(user, AppConstants.ROLES_CLAIM, string.Empty));
_userManager.AddClaim(user.Id, new Claim(AppConstants.INVITATION_CODE_CLAIM, invitation.InvitationCode));
_userManager.AddClaim(user.Id, new Claim(AppConstants.EXPIRATION_DATE_CLAIM, invitation.ExpirationDate.ToString("MM/dd/yyyy")));
_userManager.AddClaim(user.Id, new Claim(AppConstants.ROLES_CLAIM, StringifyTuples(invitation.UserRoles)));
// send invitation email to user
SendInvitationEmail(user.Id, invitation);
Response.StatusCode = (int)System.Net.HttpStatusCode.OK;
return(Json(invitation, JsonRequestBehavior.AllowGet));
}
}
catch (Exception ex)
{
string message = string.Format("Inviting user fails. {0}", ex.Message);
DojoLogger.Warn(message, typeof(UserRoleManagerController));
Response.StatusCode = (int)System.Net.HttpStatusCode.InternalServerError;
return(Json(message, JsonRequestBehavior.AllowGet));
}
}
