public async Task IsPuzzleAuthorCheck(AuthorizationHandlerContext authContext, IAuthorizationRequirement requirement)
{
EventRole role = GetEventRoleFromRoute();
if (role != EventRole.author)
{
return;
}
PuzzleUser puzzleUser = await PuzzleUser.GetPuzzleUserForCurrentUser(dbContext, authContext.User, userManager);
Puzzle puzzle = await GetPuzzleFromRoute();
Event thisEvent = await GetEventFromRoute();
if (thisEvent != null && await UserEventHelper.IsAuthorOfPuzzle(dbContext, puzzle, puzzleUser))
{
authContext.Succeed(requirement);
}
if (puzzle != null)
{
dbContext.Entry(puzzle).State = EntityState.Detached;
}
}
public async Task IsPlayerOnTeamCheck(AuthorizationHandlerContext authContext, IAuthorizationRequirement requirement)
{
EventRole role = GetEventRoleFromRoute();
if (role != EventRole.play)
{
return;
}
PuzzleUser puzzleUser = await PuzzleUser.GetPuzzleUserForCurrentUser(dbContext, authContext.User, userManager);
Team team = await GetTeamFromRoute();
Event thisEvent = await GetEventFromRoute();
if (thisEvent != null)
{
Team userTeam = await UserEventHelper.GetTeamForPlayer(dbContext, thisEvent, puzzleUser);
if (userTeam != null && userTeam.ID == team.ID)
{
authContext.Succeed(requirement);
}
}
}
public override Task <TypeReaderResult> ReadAsync(ICommandContext context, string input, IServiceProvider services)
{
var database = services.GetRequiredService <DatabaseService>();
if (context.Guild == null)
{
return(Task.FromResult(TypeReaderResult.FromError(CommandError.UnmetPrecondition, "Event roles are avaivable only inside guild context.")));
}
EventRole er = null;
if (int.TryParse(input, out int id))
{
er = database.EventRoles.FirstOrDefault(r => r.Id == id);
}
else
{
return(Task.FromResult(TypeReaderResult.FromError(CommandError.ParseFailed, "Event role id is not a valid number.")));
}
if (er == null)
{
return(Task.FromResult(TypeReaderResult.FromError(CommandError.ObjectNotFound, "Specified event role was not found.")));
}
if (er.Event?.GuildId != context.Guild.Id)
{
return(Task.FromResult(TypeReaderResult.FromError(CommandError.Exception, "Cross guild event role access is denied.")));
}
return(Task.FromResult(TypeReaderResult.FromSuccess(er)));
}
public static async Task IsEventAdminCheck(AuthorizationHandlerContext authContext, PuzzleServerContext dbContext, UserManager <IdentityUser> userManager, IAuthorizationRequirement requirement)
{
PuzzleUser puzzleUser = await PuzzleUser.GetPuzzleUserForCurrentUser(dbContext, authContext.User, userManager);
Event thisEvent = await AuthorizationHelper.GetEventFromContext(authContext);
EventRole role = AuthorizationHelper.GetEventRoleFromContext(authContext);
if (thisEvent != null && role == EventRole.admin && await puzzleUser.IsAdminForEvent(dbContext, thisEvent))
{
authContext.Succeed(requirement);
}
}
public async Task TryJoinEvent(IGuildUser user, EventRole er, string extra, bool extraChecks = true)
{
if (er.Event.GuildId != user.GuildId)
{
throw new Exception("Cross guild events are fobidden.");
}
if (extraChecks && er.ReamainingOpenings <= 0)
{
throw new Exception("No openings left.");
}
if (er.Event.Participants.Where(p => p.UserId == user.Id).Count() > 0)
{
throw new Exception("You are already participating.");
}
if (extraChecks && !er.Event.Active)
{
throw new Exception("Event is closed.");
}
if (er.Event.Guild.ParticipantRoleId != 0)
{
await user.AddRoleAsync(user.Guild.GetRole(er.Event.Guild.ParticipantRoleId));
}
var ep = new EventParticipant()
{
UserId = user.Id,
Event = er.Event,
Role = er
};
var embed = new EmbedBuilder()
.WithTitle($"{user} has joined event `{er.Event.Title}`")
.WithDescription($"They have chosen `{er.Title}` role.")
.WithColor(Color.Green);
if (extra != null && extra != string.Empty)
{
embed.AddField("Provided details", $"`{extra}`");
ep.UserData = extra;
}
_database.Add(ep);
await _database.SaveChangesAsync();
await UpdateEventMessage(er.Event);
if (er.Event.Guild.EventRoleConfirmationChannelId != 0)
{
await(await user.Guild.GetTextChannelAsync(er.Event.Guild.EventRoleConfirmationChannelId)).SendMessageAsync(embed: embed.Build());
}
}
public async Task IsEventAdminCheck(AuthorizationHandlerContext authContext, IAuthorizationRequirement requirement)
{
EventRole role = GetEventRoleFromRoute();
if (role != EventRole.admin)
{
return;
}
PuzzleUser puzzleUser = await PuzzleUser.GetPuzzleUserForCurrentUser(dbContext, authContext.User, userManager);
Event thisEvent = await GetEventFromRoute();
if (thisEvent != null && puzzleUser != null && await puzzleUser.IsAdminForEvent(dbContext, thisEvent))
{
authContext.Succeed(requirement);
}
}
public static async Task IsPuzzleAuthorCheck(AuthorizationHandlerContext authContext, PuzzleServerContext dbContext, UserManager <IdentityUser> userManager, IAuthorizationRequirement requirement)
{
PuzzleUser puzzleUser = await PuzzleUser.GetPuzzleUserForCurrentUser(dbContext, authContext.User, userManager);
Puzzle puzzle = await AuthorizationHelper.GetPuzzleFromContext(authContext);
Event thisEvent = await AuthorizationHelper.GetEventFromContext(authContext);
EventRole role = AuthorizationHelper.GetEventRoleFromContext(authContext);
if (thisEvent != null && role == EventRole.author && await UserEventHelper.IsAuthorOfPuzzle(dbContext, puzzle, puzzleUser))
{
authContext.Succeed(requirement);
}
if (puzzle != null)
{
dbContext.Entry(puzzle).State = EntityState.Detached;
}
}
public static async Task IsPlayerOnTeamCheck(AuthorizationHandlerContext authContext, PuzzleServerContext dbContext, UserManager <IdentityUser> userManager, IAuthorizationRequirement requirement)
{
PuzzleUser puzzleUser = await PuzzleUser.GetPuzzleUserForCurrentUser(dbContext, authContext.User, userManager);
Team team = await AuthorizationHelper.GetTeamFromContext(authContext);
Event thisEvent = await AuthorizationHelper.GetEventFromContext(authContext);
EventRole role = AuthorizationHelper.GetEventRoleFromContext(authContext);
if (thisEvent != null && role == EventRole.play)
{
Team userTeam = await UserEventHelper.GetTeamForPlayer(dbContext, thisEvent, puzzleUser);
if (userTeam != null && userTeam.ID == team.ID)
{
authContext.Succeed(requirement);
}
}
}
public static async Task IsEventAuthorCheck(AuthorizationHandlerContext authContext, PuzzleServerContext dbContext, UserManager <IdentityUser> userManager, IAuthorizationRequirement requirement)
{
EventRole role = AuthorizationHelper.GetEventRoleFromContext(authContext);
if (role != EventRole.author)
{
return;
}
PuzzleUser puzzleUser = await PuzzleUser.GetPuzzleUserForCurrentUser(dbContext, authContext.User, userManager);
if (authContext.Resource is AuthorizationFilterContext filterContext)
{
Event thisEvent = await AuthorizationHelper.GetEventFromContext(authContext);
if (thisEvent != null && await puzzleUser.IsAuthorForEvent(dbContext, thisEvent))
{
authContext.Succeed(requirement);
}
}
}
/// <summary>
/// Adds a user to a team after performing a number of checks to make sure that the change is valid
/// </summary>
/// <param name="context">The context to update</param>
/// <param name="Event">The event that the team is for</param>
/// <param name="EventRole">The event role of the user that is making this change</param>
/// <param name="teamId">The id of the team the player should be added to</param>
/// <param name="userId">The user that should be added to the team</param>
/// <returns>
/// A tuple where the first element is a boolean that indicates whether the player was successfully
/// added to the team and the second element is a message to display that explains the error in the
/// case where the user was not successfully added to the team
/// </returns>
public static async Task <Tuple <bool, string> > AddMemberAsync(PuzzleServerContext context, Event Event, EventRole EventRole, int teamId, int userId)
{
Team team = await context.Teams.FirstOrDefaultAsync(m => m.ID == teamId);
if (team == null)
{
return(new Tuple <bool, string>(false, $"Could not find team with ID '{teamId}'. Check to make sure the team hasn't been removed."));
}
var currentTeamMembers = await context.TeamMembers.Where(members => members.Team.ID == team.ID).ToListAsync();
if (currentTeamMembers.Count >= Event.MaxTeamSize && EventRole != EventRole.admin)
{
return(new Tuple <bool, string>(false, $"The team '{team.Name}' is full."));
}
PuzzleUser user = await context.PuzzleUsers.FirstOrDefaultAsync(m => m.ID == userId);
if (user == null)
{
return(new Tuple <bool, string>(false, $"Could not find user with ID '{userId}'. Check to make sure the user hasn't been removed."));
}
if (user.EmployeeAlias == null && currentTeamMembers.Where((m) => m.Member.EmployeeAlias == null).Count() >= Event.MaxExternalsPerTeam)
{
return(new Tuple <bool, string>(false, $"The team '{team.Name}' is already at its maximum count of non-employee players, and '{user.Email}' has no registered alias."));
}
if (await(from teamMember in context.TeamMembers
where teamMember.Member == user &&
teamMember.Team.Event == Event
select teamMember).AnyAsync())
{
return(new Tuple <bool, string>(false, $"'{user.Email}' is already on a team in this event."));
}
TeamMembers Member = new TeamMembers();
Member.Team = team;
Member.Member = user;
// Remove any applications the user might have started for this event
var allApplications = from app in context.TeamApplications
where app.Player == user &&
app.Team.Event == Event
select app;
context.TeamApplications.RemoveRange(allApplications);
context.TeamMembers.Add(Member);
await context.SaveChangesAsync();
MailHelper.Singleton.SendPlaintextWithoutBcc(new string[] { team.PrimaryContactEmail, user.Email },
$"{Event.Name}: {user.Name} has now joined {team.Name}!",
$"Have a great time!");
var teamCount = await context.TeamMembers.Where(members => members.Team.ID == team.ID).CountAsync();
if (teamCount >= Event.MaxTeamSize)
{
var extraApplications = await(from app in context.TeamApplications
where app.Team == team
select app).ToListAsync();
context.TeamApplications.RemoveRange(extraApplications);
var extraApplicationMails = from app in extraApplications
select app.Player.Email;
MailHelper.Singleton.SendPlaintextBcc(extraApplicationMails.ToList(),
$"{Event.Name}: You can no longer join {team.Name} because it is now full",
$"Sorry! You can apply to another team if you wish.");
}
return(new Tuple <bool, string>(true, ""));
}
public virtual void VisitEventRole(EventRole role)
{
this.contextStack.Push(role);
VisitConclusion(role);
this.contextStack.Pop();
}
public override void VisitEventRole(EventRole role)
{
BindIfNeeded(role);
base.VisitEventRole(role);
}
/// <summary>
/// Adds a user to a team after performing a number of checks to make sure that the change is valid
/// </summary>
/// <param name="context">The context to update</param>
/// <param name="Event">The event that the team is for</param>
/// <param name="EventRole">The event role of the user that is making this change</param>
/// <param name="teamId">The id of the team the player should be added to</param>
/// <param name="userId">The user that should be added to the team</param>
/// <returns>
/// A tuple where the first element is a boolean that indicates whether the player was successfully
/// added to the team and the second element is a message to display that explains the error in the
/// case where the user was not successfully added to the team
/// </returns>
public static async Task <Tuple <bool, string> > AddMemberAsync(PuzzleServerContext context, Event Event, EventRole EventRole, int teamId, int userId)
{
Team team = await context.Teams.FirstOrDefaultAsync(m => m.ID == teamId);
if (team == null)
{
return(new Tuple <bool, string>(false, $"Could not find team with ID '{teamId}'. Check to make sure the team hasn't been removed."));
}
var currentTeamMembers = await context.TeamMembers.Where(members => members.Team.ID == team.ID).ToListAsync();
if (currentTeamMembers.Count >= Event.MaxTeamSize && EventRole != EventRole.admin)
{
return(new Tuple <bool, string>(false, $"The team '{team.Name}' is full."));
}
PuzzleUser user = await context.PuzzleUsers.FirstOrDefaultAsync(m => m.ID == userId);
if (user == null)
{
return(new Tuple <bool, string>(false, $"Could not find user with ID '{userId}'. Check to make sure the user hasn't been removed."));
}
if (user.EmployeeAlias == null && currentTeamMembers.Where((m) => m.Member.EmployeeAlias == null).Count() >= Event.MaxExternalsPerTeam)
{
return(new Tuple <bool, string>(false, $"The team '{team.Name}' is already at its maximum count of non-employee players, and '{user.Email}' has no registered alias."));
}
if (await(from teamMember in context.TeamMembers
where teamMember.Member == user &&
teamMember.Team.Event == Event
select teamMember).AnyAsync())
{
return(new Tuple <bool, string>(false, $"'{user.Email}' is already on a team in this event."));
}
TeamMembers Member = new TeamMembers();
Member.Team = team;
Member.Member = user;
// Remove any applications the user might have started for this event
var allApplications = from app in context.TeamApplications
where app.Player == user &&
app.Team.Event == Event
select app;
context.TeamApplications.RemoveRange(allApplications);
context.TeamMembers.Add(Member);
await context.SaveChangesAsync();
return(new Tuple <bool, string>(true, ""));
}
public static async Task <List <Puzzle> > GetPuzzles(PuzzleServerContext context, Event Event, PuzzleUser user, EventRole role)
{
IQueryable <Puzzle> query;
if (role == EventRole.admin)
{
query = context.Puzzles.Where(p => p.Event == Event);
}
else
{
query = UserEventHelper.GetPuzzlesForAuthorAndEvent(context, Event, user);
}
return(await query.OrderBy(p => p.Group).ThenBy(p => p.OrderInGroup).ThenBy(p => p.Name).ToListAsync());
}
