public EventDetailData(List <User> users, Event @event, Models.Participant participant,
EventInvitation invitation, List <Models.Participant> participants)
{
Users = users;
Event = @event;
Participant = participant;
Invitation = invitation;
Participants = participants;
}
public async Task <IActionResult> AcceptInvitation(AcceptInvitationDto acceptInvitationDto)
{
IDatabaseContext context = _getDatabaseContext();
EventInvitation invitation = await context.EventInvitations
.Include(i => i.Event)
.ThenInclude(e => e.EventParticipations)
.FirstOrDefaultAsync(i => i.Token == acceptInvitationDto.InviteToken);
if (invitation == null)
{
return(BadRequest(RequestStringMessages.InvitationInvalid));
}
int currentUserId = HttpContext.GetUserId();
if (invitation.Event.EventParticipations.Select(ep => ep.ParticipantId).Contains(currentUserId))
{
// The invite link was used to access the event => Redirect to event
return(Ok(invitation.EventId));
}
if (invitation.Event.IsPrivate)
{
// Invitations to private events require to still be valid and not already used
if (invitation.Used)
{
return(BadRequest(RequestStringMessages.InvitationAlreadyUsed));
}
if (invitation.Requested + _inviteTimeout < DateTime.UtcNow)
{
return(BadRequest(RequestStringMessages.InvitationInvalid));
}
}
// Invitations to public events are theoretically pointless as the user could join without the invitation
// => These invitations are always considered as valid, even if already used
var participation = new EventParticipation
{
Event = invitation.Event,
ParticipantId = currentUserId
};
invitation.Event.EventParticipations.Add(participation);
invitation.Used = true;
await context.SaveChangesAsync();
return(Ok(invitation.EventId));
}
public async Task <JsonResult> SendInvitation([FromBody] JsonElement jsonbody)
{
var data = JsonSerializer.Deserialize <EventInvite>(jsonbody.GetRawText());
EventInvitation invitation = new EventInvitation()
{
FkUser = int.Parse(data.FkUser), FkEvent = int.Parse(data.FkEvent)
};
if (invitation.FkEvent > 0 && invitation.FkUser > 0)
{
_context.Add(invitation);
await _context.SaveChangesAsync();
}
var users = new SelectList(_context.User.Where(u => u.UserId != GetCurrentUser().UserId), "UserId", "Username");
return(new JsonResult(JsonSerializer.Serialize(users)));
}
public async Task <IActionResult> InviteParticipants(InviteParticipantsDto inviteParticipantsDto)
{
IDatabaseContext context = _getDatabaseContext();
Event? @event = await context.Events
.Include(e => e.Organizer)
.Include(e => e.EventInvitations)
.Include(e => e.EventParticipations)
.ThenInclude(ep => ep.Participant)
.FirstOrDefaultAsync(e => e.Id == inviteParticipantsDto.EventId);
if (@event == null)
{
return(BadRequest(RequestStringMessages.EventNotFound));
}
User currentUser = await HttpContext.GetCurrentUserAsync(context);
if (@event.Organizer != currentUser)
{
_logger.LogInformation("{0}(): Tried to add appointments to the event {1}, which he's not organizing", nameof(InviteParticipants), @event.Id);
return(BadRequest(RequestStringMessages.OrganizerRequired));
}
var mailInvites = new List <(string email, EventInvitation invite)>();
var userInvites = new List <(User user, EventInvitation invite)>();
foreach (string emailAddress in inviteParticipantsDto.EmailAddresses)
{
// Create new invite
var invite = new EventInvitation
{
Requested = DateTime.UtcNow,
Event = @event
};
context.EventInvitations.Add(invite);
// Check if a profile with this email exists
User?existingUser = await context.Users.FirstOrDefaultAsync(u => u.Email == emailAddress);
if (existingUser == null)
{
// No user exists
mailInvites.Add((emailAddress, invite));
}
else
{
// User with mail exists => Check if he's already part of the event
if (@event.EventParticipations.Any(e => e.Participant.Email == emailAddress))
{
return(BadRequest($"Die E-Mail-Adresse {emailAddress} nimmt bereits am Event teil"));
}
userInvites.Add((existingUser, invite));
}
}
await context.SaveChangesAsync();
await _notificationService.SendInvitationLinkAsync(userInvites, mailInvites);
return(Ok());
}
