public async Task <ActionResult> AcceptInvitation(AcceptInvitationViewModel invitationvm)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
FirstName = invitationvm.FirstName,
LastName = invitationvm.LastName,
DisplayName = invitationvm.FirstName + " " + invitationvm.LastName,
UserName = invitationvm.Email,
Email = invitationvm.Email,
AvatarPath = "/Avatar/avatarPlaceholder.png",
HouseholdId = invitationvm.HouseholdId
};
var result = await UserManager.CreateAsync(user, invitationvm.Password);
if (result.Succeeded)
{
//InvitationHelper.MarkAsIvnalid(invitationvm.Id);
roleHelper.AddUserToRole(user.Id, "Member");
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
return(View(invitationvm));
}
public IHttpActionResult AcceptInvitation(AcceptInvitationViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var group = this.groupService.GetGroup(viewModel.GroupName);
if (group == null)
{
return(BadRequest("No such group"));
}
var currentUserId = User.Identity.GetUserId();
var username = User.Identity.GetUserName();
var acceptedInvitation = this.groupService.AcceptInvitation(currentUserId, group.GroupId);
if (!acceptedInvitation)
{
string message = $"No invitation for user '{username}' in group '{group.Name}'";
return(this.Content(HttpStatusCode.Forbidden, message));
}
var result = new AcceptInvitationResultModel
{
GroupId = group.GroupId,
GroupName = group.Name,
Username = username,
};
return(Created("", result)); // TODO: url
}
public async Task <ActionResult> AcceptInvitation(AcceptInvitationViewModel invitationvm)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
FirstName = invitationvm.RegisterVM.FirstName,
LastName = invitationvm.RegisterVM.LastName,
DisplayName = invitationvm.RegisterVM.DisplayName,
UserName = invitationvm.RegisterVM.Email,
Email = invitationvm.RegisterVM.Email,
AvatarPath = "/Avatars/default_user.png",
HouseholdId = invitationvm.HouseholdId
};
var result = await UserManager.CreateAsync(user, invitationvm.RegisterVM.Password);
if (result.Succeeded)
{
//var sentInvitation = db.Invitations.Find(invitationvm.Id);
//sentInvitation.IsValid = false;
roleHelper.AddUserToRole(user.Id, "Member");
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
db.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
return(View());
}
//
// Accept Invitation
public ActionResult AcceptInvitation(string recipientEmail, string code)
{
var realGuid = Guid.Parse(code);
var invitation = db.Invitations.FirstOrDefault(i => i.RecipientEmail == recipientEmail && i.Code == realGuid);
if (invitation == null)
{
return(View("NotFoundError", invitation));
}
var expirationDate = invitation.Created.AddDays(invitation.TTL);
if (invitation.IsValid)
{
var houseHoldName = db.Households.Find(invitation.HouseholdId).Name;
ViewBag.Greeting = $"<center>Thank You for accepting my invitation to join {houseHoldName}.</center><br />";
var invitationVm = new AcceptInvitationViewModel
{
Id = invitation.Id,
Email = recipientEmail,
Code = realGuid,
HouseholdId = invitation.HouseholdId
};
return(View(invitationVm));
}
return(View("AcceptError", invitation));
}
// GET: Households/Join
public ActionResult Join(string recipientEmail, string code)
{
var realGuid = Guid.Parse(code);
var invitation = db.Invitations.FirstOrDefault(i => i.RecipientEmail == recipientEmail && i.Code == realGuid);
if (invitation == null)
{
TempData["Warning"] = "No Invitation Found."; return(RedirectToAction("Index", "Home"));
}
var expirationDate = invitation.Created.AddDays(invitation.TTL);
if (invitation.IsValid && DateTime.Now < expirationDate)
{
var invitationVM = new AcceptInvitationViewModel
{
Id = invitation.Id,
Email = recipientEmail,
Code = realGuid,
HouseholdId = invitation.HouseholdId
};
return(View(invitationVM));
}
else
{
TempData["Warning"] = "This invitation expired or is no longer valid.";
return(RedirectToAction("Index", "Home"));
}
}
public async Task <ActionResult> AcceptInvitation(AcceptInvitationViewModel invitationVm)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
FirstName = invitationVm.FirstName,
LastName = invitationVm.LastName,
DisplayName = invitationVm.DisplayName,
Email = invitationVm.Email,
UserName = invitationVm.Email,
HouseholdId = invitationVm.HouseholdId,
AvatarPath = "/Images/default.jpg"
};
var result = await UserManager.CreateAsync(user, invitationVm.Password);
if (result.Succeeded)
{
var sentInvitation = db.Invitations.Find(invitationVm.Id);
sentInvitation.IsValid = false;
db.SaveChanges();
roleHelper.AddUserToRole(user.Id, "Member");
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Dashboard", "Households"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(invitationVm));
}
public ActionResult AcceptInvitation(string receipentEmail, string code)
{
var realGuid = Guid.Parse(code);
var invitation = db.Invitations.FirstOrDefault(i => i.ReceipentEmail == receipentEmail && i.Code == realGuid);
if (invitation == null)
{
return(View("NotFoundError", invitation));
}
var expirationDate = invitation.Created.AddDays(invitation.TTL);
if (invitation.IsValid && DateTime.Now < expirationDate)
{
var housholdName = db.Households.Find(invitation.HouseholdId).Name;
ViewBag.Greeting = $"Thankyou for accepting inviatation to join {housholdName}";
var invitationVm = new AcceptInvitationViewModel
{
Id = invitation.Id,
Email = receipentEmail,
Code = realGuid,
HouseholdId = invitation.HouseholdId
};
return(View(invitationVm));
}
//return RedirectToAction("InvitationExpired");
ViewBag.Error = "Your invitation expired. Please request another invitation to this house.";
return(View("InvitationExpired", invitation));
}
public async Task <ActionResult> AcceptInvitation(AcceptInvitationViewModel invitationvm)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
FirstName = invitationvm.FirstName,
LastName = invitationvm.LastName,
UserName = invitationvm.Email,
Email = invitationvm.Email,
AvatarPath = "/Avatars/default_user.png",
HouseholdId = invitationvm.HouseholdId
};
var result = await UserManager.CreateAsync(user, invitationvm.Password);
if (result.Succeeded)
{
InvitationHelper.MarkAsInvalid(invitationvm.Id);
roleHelper.AddUserToRole(user.Id, "Member");
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Dashboard", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(invitationvm));
}
public async Task <ActionResult> AcceptInvitation(AcceptInvitationViewModel invitationvm)
{
if (ModelState.IsValid)
{
UserRolesHelper helper = new UserRolesHelper();
var user = new ApplicationUser
{
FirstName = invitationvm.FirstName,
LastName = invitationvm.LastName,
UserName = invitationvm.Email,
Email = invitationvm.Email,
HouseholdId = invitationvm.HouseholdId
};
var result = await UserManager.CreateAsync(user, invitationvm.Password);
if (result.Succeeded)
{
InvitationExtensions.MarkAsInvalid(invitationvm.Id);
helper.RemoveUserFromRole(user.Id, "Guest");
helper.AddUserToRole(user.Id, "Household Member");
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
return(View(invitationvm));
}
public AcceptInvitationPage(AuthenticationResult result)
{
InitializeComponent();
BindingContext = _vm =
new AcceptInvitationViewModel(result.UserClaims.Single(claim => claim.Type == "email").Value)
{
Navigation = Navigation
};
}
public async Task <ActionResult> AcceptInvitation(AcceptInvitationViewModel invitationvm, HttpPostedFileBase avatar)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
FirstName = invitationvm.FirstName,
LastName = invitationvm.LastName,
DisplayName = invitationvm.DisplayName,
UserName = invitationvm.Email,
Email = invitationvm.Email,
AvatarPath = "/Avatars/default_user.png",
HouseholdId = invitationvm.HouseholdId
};
if (avatar != null)
{
if (ImageUploadValidator.IsWebFriendlyImage(avatar))
{
var fileName = Path.GetFileName(avatar.FileName);
var justFileName = Path.GetFileNameWithoutExtension(fileName);
justFileName = StringUtilities.URLFriendly(justFileName);
fileName = $"{justFileName}_{DateTime.Now.Ticks}{Path.GetExtension(fileName)}";
avatar.SaveAs(Path.Combine(Server.MapPath("~/Avatars/"), fileName));
user.AvatarPath = "/Avatars/" + fileName;
}
}
var result = await UserManager.CreateAsync(user, invitationvm.Password);
if (result.Succeeded)
{
InvitationHelper.MarkAsInvalid(invitationvm.Id);
roleHelper.AddUserToRole(user.Id, "Member");
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
//If we got this far, something failed, redisplay form
return(View(invitationvm));
}
public async Task <IActionResult> OnGet(string id)
{
ViewData["Message"] = String.Empty;
try
{
using (var httpClient = new System.Net.Http.HttpClient())
{
//var invitation = await _mediator.Send(new GetInvitationByIdQuery { Id = id });
httpClient.DefaultRequestHeaders.Add(_applicationSettings.IdentityService.ApiKeyName, _applicationSettings.IdentityService.ApiKeyValue);
var invitationClient = new Services.IdentityService.InvitationsClient(_applicationSettings.IdentityService.ApiUrl, httpClient);
var invitation = await invitationClient.IdAsync(id);
if (invitation != null && invitation.Id == id)
{
AcceptInvitation = new AcceptInvitationViewModel
{
InvitationExists = true,
InvitationId = invitation.Id,
InvitationExpired = invitation.IsExpired.Value
};
}
else
{
AcceptInvitation = new AcceptInvitationViewModel
{
InvitationExists = false
};
}
}
}
catch
{
AcceptInvitation = new AcceptInvitationViewModel
{
InvitationExists = false
};
}
return(Page());
}
public async Task <ActionResult> Register(AcceptInvitationViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
Email = model.Email,
UserName = model.Email,
LastName = model.LastName,
FirstName = model.FirstName,
AvatarPath = model.AvatarPath
};
if (model.HouseholdId != 0)
{
user.HouseholdId = model.HouseholdId;
}
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
if (model.HouseholdId != 0)
{
roleHelp.AddUserToRole(user.Id, "Member");
// fire the DidTheyJoin Notification method
var invitation = db.Invitations.Find(model.Id);
notifyHelp.DidTheyJoinUp(invitation);
inviteHelp.MarkAsInvalid(model.Id);
}
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code }, protocol: Request.Url.Scheme);
await EmailHelper.ComposeEmailAsync(model, callbackUrl);
return(RedirectToAction("NewlyRegistered"));
}
AddErrors(result);
TempData["Errors"] = ErrorReader.ErrorCompiler(ModelState);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public ActionResult AcceptInvitation(string recipientEmail, string code, int Id)
{
//var checkemail = db.Users.Where(u => u.Email == recipientEmail);
var realGuid = Guid.Parse(code);
var invitation = db.Invitations.FirstOrDefault(i => i.RecipientEmail == recipientEmail && i.Code == realGuid);
var expirationDate = invitation.Created.AddDays(invitation.TTL);
////if (checkemail != null)
////{
//// InvitationHelper.MarkAsInvalid(Id);
//// return RedirectToAction("Index", "Home");
////}
if (invitation == null)
{
return(View("NotFoundError", invitation));
}
if (invitation.IsValid && DateTime.Now < expirationDate)
{
var houseHoldName = db.Households.Find(invitation.HouseholdId).Name;
ViewBag.Greeting = $"<center>Thank you for accepting my invitation to join {houseHoldName}.</center>";
var invitationVm = new AcceptInvitationViewModel
{
Id = invitation.Id,
Email = recipientEmail,
Code = realGuid,
HouseholdId = invitation.HouseholdId
};
return(View(invitationVm));
}
return(View());
//return View("AcceptError", invitation);
}
public ActionResult Register(string recipientEmail, Guid?code, int?houseId, int?Id)
{
AcceptInvitationViewModel model = new AcceptInvitationViewModel();
var invitation = db.Invitations.FirstOrDefault(i => i.RecipientEmail == recipientEmail && i.Code == code);
if (invitation != null)
{
var expirationDate = invitation.Created.AddDays(invitation.TTL);
if (invitation.IsValid && DateTime.Now < expirationDate)
{
model.Code = (Guid)code;
model.HouseholdId = (int)houseId;
model.Email = recipientEmail;
model.Id = (int)Id;
ViewBag.HasCode = true;
}
}
else
{
ViewBag.HasCode = false;
}
model.AvatarPath = "/Images/default.png";
return(View(model));
}
