public JsonResult Delete(string model)
{
try
{
UserInvitationViewModel invitation = JsonConvert.DeserializeObject <UserInvitationViewModel>(model);
var user = _userManager.FindByEmail(invitation.UserEmail);
if (user != null)
{
if (_userManager.Delete(user) == IdentityResult.Success)
{
Response.StatusCode = (int)System.Net.HttpStatusCode.OK;
return(Json(string.Empty, JsonRequestBehavior.AllowGet));
}
}
Response.StatusCode = (int)System.Net.HttpStatusCode.Conflict;
return(JsonError("User does not exist or cannot be deleted."));
}
catch (Exception ex)
{
string message = string.Format("Deleting user fails. {0}", ex.Message);
DojoLogger.Warn(message, typeof(UserRoleManagerController));
Response.StatusCode = (int)System.Net.HttpStatusCode.InternalServerError;
return(Json(message, JsonRequestBehavior.AllowGet));
}
}
private void SendInvitationEmail(string userId, UserInvitationViewModel invitation)
{
try
{
var recipient = invitation.UserEmail;
List <string> Ccs = new List <string>()
{
SettingsHelper.GetSafeSetting(AppConstants.EMAIL_SUPPORT_KEY, string.Empty),
//SettingsHelper.GetSafeSetting(AppConstants.EMAIL_DEVELOPER_KEY, string.Empty),
};
if (!string.IsNullOrEmpty(recipient))
{
string pageUrl = Request.Url.GetLeftPart(UriPartial.Authority);
string url = string.Format("{0}{1}?id={2}&invite={3}", pageUrl, "/Account/Accept", userId, invitation.InvitationCode);
ResourceManager rm = new ResourceManager("Senstay.Dojo.AppResources", Assembly.GetExecutingAssembly());
var subject = rm.GetString("InvitationEmailSubject");
var body = rm.GetString("InvitationEmailTemplate");
var content = string.Format(body, invitation.UserName, invitation.InvitationCode, url);
Helpers.EmailHelper.SendEmail(recipient, subject, content, Ccs);
string message = string.Format("Invitation email is sent to {0} on {1}", recipient, DateTime.Now.ToString("MM/dd/yyyy hh:mm:ss zzz"));
DojoLogger.Info(message, typeof(UserInvitationController));
}
else
{
string message = "Invitation recipient email is empty or null.";
DojoLogger.Warn(message, typeof(UserInvitationController));
}
}
catch (Exception ex)
{
string message = string.Format("Send invitation email error. {0}", ex.Message + ex.StackTrace);
DojoLogger.Error(message, typeof(UserInvitationController));
}
}
public ActionResult ExternalAccept(UserInvitationViewModel model)
{
string returnUrl = string.Format("/Account/ExternalInvitationRedirect/?id={0}&phone={1}", model.UserId, model.MobilePhone);
return(new ChallengeResult(model.Provider, Url.Action("ExternalInvitationLoginCallback", "Account",
new { ReturnUrl = returnUrl })));
}
public JsonResult Create(string model)
{
try
{
UserInvitationViewModel invitation = JsonConvert.DeserializeObject <UserInvitationViewModel>(model);
if (_userManager.FindByEmail(invitation.UserEmail) != null)
{
Response.StatusCode = (int)System.Net.HttpStatusCode.Conflict;
return(JsonError("User already exists."));
}
DojoLogger.Trace(string.Format("Inviting user '{0}', email '{1} to join Dojo.", invitation.UserName, invitation.UserEmail), typeof(UserRoleManagerController));
ApplicationUser newUser = new ApplicationUser()
{
UserName = invitation.UserName,
Email = invitation.UserEmail,
};
IdentityResult result = _userManager.Create(newUser, invitation.InvitationCode);
DojoLogger.Trace(string.Format("Creating User '{0}', email '{1} in DB.", invitation.UserName, invitation.UserEmail), typeof(UserRoleManagerController));
if (result == IdentityResult.Success)
{
newUser = _userManager.FindByEmail(invitation.UserEmail);
_userManager.AddClaim(newUser.Id, new Claim(AppConstants.INVITATION_CLAIM, "1"));
_userManager.AddClaim(newUser.Id, new Claim(AppConstants.INVITATION_CODE_CLAIM, invitation.InvitationCode));
_userManager.AddClaim(newUser.Id, new Claim(AppConstants.EXPIRATION_DATE_CLAIM, invitation.ExpirationDate.ToString("MM/dd/yyyy")));
_userManager.AddClaim(newUser.Id, new Claim(AppConstants.ROLES_CLAIM, StringifyTuples(invitation.UserRoles)));
DojoLogger.Trace(string.Format("Sending invitation email to User '{0}', ID {1}.", invitation.UserName, newUser.Id), typeof(UserRoleManagerController));
// send invitation email to user
SendInvitationEmail(newUser.Id, invitation);
Response.StatusCode = (int)System.Net.HttpStatusCode.OK;
return(Json(invitation, JsonRequestBehavior.AllowGet)); // keep claims out of it
}
else
{
Response.StatusCode = (int)System.Net.HttpStatusCode.InternalServerError;
return(Json("Unable to create invited user.", 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));
}
}
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 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));
}
}
public ActionResult InviteToContest(UserInvitationViewModel model)
{
var loggedUserId = this.User.Identity.GetUserId();
var contest = this.Data.Contests.Find(model.ContestId);
if (!this.ModelState.IsValid)
{
throw new HttpException();
}
if (loggedUserId != contest.CreatorId)
{
throw new HttpException();
}
if (contest.Invited.Any(p => p.Id == model.UserId) || contest.Participants.Any(p => p.Id == model.UserId))
{
return this.Content("User already invited", "text/html");
}
var invitedUser = this.Data.Users.Find(model.UserId);
var loggedUser = this.Data.Users.Find(loggedUserId);
invitedUser.InvitedContests.Add(contest);
contest.Invited.Add(invitedUser);
var text = string.Format("Hello, {0}, I'd like you to join the contest {1}", invitedUser.UserName, contest.Title);
var notification = new Notification
{
Text = text,
DateSent = DateTime.Now,
ReceiverId = model.UserId,
Receiver = invitedUser,
SenderId = loggedUserId,
Sender = loggedUser,
ContestId = contest.Id
};
this.Data.Notifications.Add(notification);
this.Data.SaveChanges();
var message = string.Format("Invitation to {0} sent", invitedUser.UserName);
return this.Content(message, "text/html");
}
