public async Task <ActionResult> Accept(string id)
{
try
{
var query = new GetInvitationByKey(id);
var invitation = await _queryBus.QueryAsync(query);
if (invitation == null)
{
return(View("InvitationNotFound"));
}
var model = new AcceptViewModel
{
InvitationKey = id,
Email = invitation.EmailAddress
};
return(View(model));
}
catch (Exception exception)
{
ModelState.AddModelError("", exception);
_logger.Error("Failed ot launch", exception);
return(View(new AcceptViewModel()));
}
}
public ActionResult Accept(string email, Guid code)
{
var errors = new StringBuilder();
var invitation = db.Invitations.FirstOrDefault(i => i.Code == code);
if (invitation.IsAccepted)
{
errors.Append("This Invitation has already been accepted.");
}
if (DateTime.Now > invitation.Expires)
{
errors.Append("This invitation has expired");
}
if (!invitation.IsValid)
{
errors.Append("This invitation is invalid");
}
if (errors.ToString() != string.Empty)
{
TempData["ErrorMsg"] = errors.ToString();
return(View());
}
var accept = new AcceptViewModel
{
Email = email,
Code = code
};
return(View(accept));
}
public async Task <ActionResult> Decline(AcceptViewModel vm)
{
var invite = db.Invites.Find(vm.Invite.Id);
var household = db.Households.Find(vm.Household.Id);
if (invite != null && household != null)
{
if (db.Users.Find(User.Identity.GetUserId()).Invites.Any(i => i.Id == invite.Id) && invite.Accepted == false)
{
invite.Declined = true;
var invitee = db.Users.Find(invite.InviteeId);
invitee.Invites.Remove(invite);
var alerts = invitee.Alerts.Where(a => a.InviteId == null ||
(a.Invite.Accepted == true && a.Invite.InviteeId == invitee.Id) ||
(a.Invite.Declined == true && a.Invite.InviteeId == invitee.Id));
db.Alerts.RemoveRange(alerts);
db.Entry(invite).State = EntityState.Modified;
db.SaveChanges();
await DeclineAlert(invite.InviterId, invitee.FullName, invite.Id);
await ControllerContext.HttpContext.RefreshAuthentication(invitee);
}
}
return(RedirectToAction("Index", "Home"));
}
public async Task <ActionResult> Accept(int id, [FromForm] AcceptViewModel model)
{
if (ModelState.IsValid)
{
try
{
var meetingClient = new MeetingClient(_config);
var memberClient = new MemberClient(_config);
var attendee = await meetingClient.GetAttendee(id, model.AttendeeId);
if (null == attendee)
{
return(BadRequest("Attendee not found"));
}
var member = await memberClient.Get(model.MemberId);
if (null == member)
{
return(BadRequest("Member not found"));
}
if (null == attendee.Member)
{
attendee.Member = new Member();
}
attendee.Member.Id = member.Id;
attendee.Member.Name = member.Alias;
var response = await meetingClient.UpdateAttendee(id, attendee);
if (response.IsSuccessStatusCode)
{
_toastNotification.AddSuccessToastMessage($"Merci, le role {attendee.Role.Name} a été assigné à {attendee.Member.Name}.");
CookieOptions option = new CookieOptions();
option.Expires = DateTime.Now.AddYears(1);
Response.Cookies.Append("member", member.Id.ToString(), option);
return(RedirectToAction(nameof(Index)));
}
}
catch
{
return(View(model));
}
}
return(View(model));
}
public async Task <ActionResult> Accept(int id, int attendeeId)
{
var client = new MeetingClient(_config);
var meeting = await client.Get(id);
if (null == meeting)
{
return(NotFound());
}
var attendee = meeting.Attendees.Where(p => attendeeId == p.Id).SingleOrDefault();
if (null == attendee)
{
return(NotFound());
}
var model = new AcceptViewModel
{
AttendeeId = attendeeId,
MeetingDate = meeting.Date,
MeetingId = meeting.Id,
MeetingName = meeting.Name,
RoleName = attendee.Role.Name
};
var memberClient = new MemberClient(_config);
var members = await memberClient.GetAll();
var buffer = Request.Cookies["member"];
int memberId;
if (false == int.TryParse(buffer, out memberId))
{
memberId = 0;
}
model.MemberId = memberId;
model.Members = members.Select(p => new SelectListItem {
Value = p.Id.ToString(), Text = p.Alias
}).ToList();
return(View(model));
}
public ActionResult Accept(int?id)
{
if (id != null)
{
AcceptViewModel vm = new AcceptViewModel();
vm.Invite = db.Invites.Find(id);
if (vm.Invite != null)
{
var user = db.Users.Find(User.Identity.GetUserId());
if (user.Invites.Any(i => i.Id == vm.Invite.Id && i.Accepted == false && i.InviteeId == vm.Invite.InviteeId) && vm.Invite.InviteeId == user.Id && vm.Invite.Accepted == false)
{
vm.Household = db.Households.Find(vm.Invite.HouseholdId);
return(View(vm));
}
}
}
return(RedirectToAction("Index", "Home"));
}
public async Task <ActionResult> Accept(AcceptViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var query = new GetInvitationByKey(model.InvitationKey);
var invitation = await _queryBus.QueryAsync(query);
if (invitation == null)
{
return(View("InvitationNotFound"));
}
var cmd = new AcceptInvitation(model.UserName, model.Password, model.InvitationKey)
{
AcceptedEmail = model.Email,
FirstName = model.FirstName,
LastName = model.LastName
};
var reply = await _requestReplyBus.ExecuteAsync(cmd);
if (reply == null)
{
ModelState.AddModelError("",
"Failed to find an invitation with the specified key. You might have already accepted the invitation? If not, ask for a new one.");
_logger.Error("Failed to find invitation " + model.InvitationKey);
return(View(new AcceptViewModel()));
}
var getApps = new GetApplicationList {
AccountId = reply.AccountId
};
var apps = await _queryBus.QueryAsync(getApps);
var identity = CreateIdentity(reply.AccountId, reply.UserName, false, apps);
SignIn(identity);
return(Redirect("~/#/account/accepted"));
}
public ActionResult Accept(AcceptViewModel model)
{
var eventID = db.MeetingInvites.Where(x => x.id == model.InviteID).Select(x => x.EventID).SingleOrDefault();
var eventParticipants = new EventParticipants()
{
EventID = eventID,
UserID = User.Identity.GetUserId()
};
db.EventParticipants.Add(eventParticipants);
var m = db.MeetingInvites.Find(model.InviteID);
db.MeetingInvites.Remove(m);
db.SaveChanges();
var Event = db.Events.Find(eventID);
var user = db.Users.Find(User.Identity.GetUserId());
var email = new List <string>();
email.Add(user.Email);
var subject = "Tillagd i ett möte";
var message = $"Du har blivit tillagd i ett möte av: {Event.Host.FirstName} {Event.Host.LastName} <br> Datum: {Event.Date} <br> Tid: {Event.Time} <br> Plats: {Event.Place}";
DataLogic.DbMethods.Methods.SendEmailInvitation(email, message, subject);
ICalMessage.SendMessage(Event, user.Email);
var emailHost = new List <string>();
emailHost.Add(Event.Host.Email);
var subjectHost = "Accepterad inbjudan";
var messageHost = user.FirstName + " " + user.LastName + $" har accepterat din mötesinbjudan och valde tidsförslaget: " +
$"{model.SelectedTime} <br> Datum: {Event.Date} <br> Tid: {Event.Time} <br> Plats: {Event.Place}";
DataLogic.DbMethods.Methods.SendEmailInvitation(emailHost, messageHost, subjectHost);
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Accept(AcceptViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var cmd = new AcceptInvitation(model.UserName, model.Password, model.InvitationKey)
{
AcceptedEmail = model.Email,
FirstName = model.FirstName,
LastName = model.LastName
};
var identity = await _accountService.AcceptInvitation(this.ClaimsUser(), cmd);
//TODO: Remove hack.
// HERE since the message queue starts to process the events
// before we are done with them. We need some way to stack up the publishing
// until the current handler is done.
//
// can't use a message handler since we need a result from the invitation accept.
// so that we can construct a new identity
_uow.SaveChanges();
if (identity == null)
{
ModelState.AddModelError("",
"Failed to find an invitation with the specified key. You might have already accepted the invitation? If not, ask for a new one.");
_logger.Error("Failed to find invitation " + model.InvitationKey);
return(View(new AcceptViewModel()));
}
await SignInAsync(identity);
var url = Url.Content("~/");
return(RedirectToAction("UpdateSession", new { returnUrl = url }));
}
public async Task <ActionResult> Accept(AcceptViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var cmd = new AcceptInvitation(model.UserName, model.Password, model.InvitationKey)
{
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName
};
var reply = await _requestReplyBus.ExecuteAsync(cmd);
if (reply == null)
{
ModelState.AddModelError("",
"Failed to find an invitation with the specified key. You might have already accepted the invitation? If not, ask for a new one.");
_logger.Error("Failed to find invitation " + model.InvitationKey);
return(View(new AcceptViewModel()));
}
FormsAuthentication.SetAuthCookie(reply.UserName, false);
var user = new SessionUser(reply.AccountId, reply.UserName);
SessionUser.Current = user;
var getApps = new GetApplicationList();
var apps = await _queryBus.QueryAsync(getApps);
SessionUser.Current.Applications = apps.ToDictionary(x => x.Id, x => x.Name);
SessionUser.Current.Applications[0] = "Dashboard";
return(Redirect("~/#/account/accepted"));
}
public async Task <ActionResult> AcceptRegister(AcceptViewModel model, HttpPostedFileBase Avatar)
{
if (ModelState.IsValid)
{
var errorMsg = new StringBuilder();
var invitation = db.Invitations.FirstOrDefault(i => i.Code == model.Code);
if (invitation == null)
{
errorMsg.Append("There is no invitation that contains both the supplied Email and Code");
}
else
{
if (DateTime.Now > invitation.Expires)
{
errorMsg.AppendLine("The Invitation you are trying to accept has expired");
}
if (invitation.IsAccepted)
{
errorMsg.Append("This Invitation has already been accepted");
}
if (!invitation.IsValid)
{
errorMsg.Append("This invitation is invalid");
}
}
var result = new IdentityResult();
if (errorMsg.ToString() == string.Empty)
{
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
DisplayName = model.DisplayName,
AvatarPath = "/images/user.png",
HouseholdId = invitation.HouseholdId
};
if (Avatar != null)
{
if (ImageUploadValidator.IsWebFriendlyImage(Avatar))
{
var fileName = Path.GetFileName(Avatar.FileName);
Avatar.SaveAs(Path.Combine(Server.MapPath("~/Uploads/"), fileName));
user.AvatarPath = "/Uploads/" + fileName;
}
}
result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
db.Invitations.Attach(invitation);
invitation.IsAccepted = true;
invitation.Accepted = DateTime.Now;
invitation.IsValid = false;
db.SaveChanges();
//Add the "Member" role to the new user
var roleHelper = new UserRolesHelper();
roleHelper.AddUserToRole(user.Id, "Member");
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
return(RedirectToAction("Dashboard", "Households", new { id = invitation.HouseholdId }));
}
}
else
{
//There are errors that need to be shown to the user
TempData["ErrorMsg"] = errorMsg.ToString();
return(RedirectToAction("Accept", "Households", new { email = invitation.Email, code = invitation.Code }));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public AcceptView(SettingsService settingsService)
{
InitializeComponent();
DataContext = new AcceptViewModel(settingsService);
}
