public static double GetTotalOverlap(this CSGOTeam team, ApplicationUser user)
{
double total = 0;
foreach (TeamAvailability practice in team.PracticeSchedule.Where(d => d.Available))
{
UserAvailability availability = user.Availability.SingleOrDefault(a => a.Day == practice.Day && a.Available);
if (availability != null)
{
/* CASE 0
* user |------------|
* team |----------------------|
* OR
* user |------------|
* team |----------------------|
*/
if (practice.To <= availability.From || practice.From >= availability.To)
{
continue;
}
/* CASE 1
* user |------------|
* team |----------------------|
*/
if (practice.From <= availability.From && practice.To >= availability.To)
{
total += (availability.To - availability.From).TotalHours;
}
/* CASE 2
* user |----------------------|
* team |------------|
*/
else if (practice.From >= availability.From && practice.To <= availability.To)
{
total += (practice.To - practice.From).TotalHours;
}
/* CASE 3
* user |---------|
* team |------------|
*/
else if (practice.To > availability.From)
{
total += (practice.To - availability.From).TotalHours;
}
/* CASE 4
* user |---------|
* team |------------|
*/
else if (practice.From < availability.To)
{
total += (availability.To - practice.From).TotalHours;
}
}
}
return(total);
}
public IHttpActionResult UpdateTeam(CSGOTeam team)
{
CSGOTeam entity = UserIsTeamAdmin(team.TeamId);
if (entity == null)
{
return(BadRequest("User is not a team admin for " + team.TeamName));
}
if (ModelState.IsValid)
{
_dbContext.Entry(entity).CurrentValues.SetValues(team);
try
{
_dbContext.SaveChanges();
}
catch (DbUpdateException e)
{
System.Diagnostics.Trace.TraceError($"Team update error: ${e.Message}");
return(BadRequest("Something went wrong!"));
}
return(Ok(team));
}
return(BadRequest("Invalid state of the team " + team.TeamName));
}
private CSGOTeam UserIsTeamAdmin(Guid teamId)
{
CSGOTeam team = _dbContext.Teams.Find(teamId);
ApplicationUser user = GetAuthUser();
return(team != null && team.Members.Any(m => m.IsAdmin && m.UserId == user.Id) ? team : null);
}
public IHttpActionResult SetTeamMapPool(List <TeamMapPool> maps)
{
CSGOTeam team = UserIsTeamAdmin(maps[0].TeamId);
if (team == null)
{
return(BadRequest("You need to be team admin."));
}
foreach (TeamMapPool mapPool in maps)
{
TeamMapPool entity = team.MapPool.SingleOrDefault(m => m.Map == mapPool.Map);
_dbContext.Entry(entity).CurrentValues.SetValues(mapPool);
}
try
{
_dbContext.SaveChanges();
}
catch (DbUpdateException e)
{
System.Diagnostics.Trace.TraceError($"Team map pool error: ${e.Message}");
return(BadRequest("Something went wrong..."));
}
return(Ok("ok"));
}
public async Task <IActionResult> NewTeam(CSGOTeam team)
{
ApplicationUser user = await GetAuthUser();
_dbContext.CSGOTeams.Add(team);
team.Members.Add(new TeamMember()
{
UserId = user.Id,
IsActive = true,
IsAdmin = true,
IsEditor = true
});
team.InitializeDefaults();
team.UniqueCustomUrl(_dbContext);
try
{
await _dbContext.SaveChangesAsync();
}
catch (DbUpdateException e)
{
System.Diagnostics.Trace.TraceError($"Team create error: ${e.Message}");
return(BadRequest("Something went wrong..."));
}
return(Ok(team));
}
private CSGOTeam UserIsTeamMember(string teamId)
{
CSGOTeam team = ResolveTeam(teamId);
ApplicationUser user = GetAuthUser();
return(team != null && team.Members.Any(m => m.UserId == user.Id) ? team : null);
}
private bool UserIsTeamMember(Guid teamId)
{
CSGOTeam team = _dbContext.Teams.Find(teamId);
ApplicationUser user = GetAuthUser();
return(team != null && team.Members.Any(m => m.UserId == user.Id));
}
public IHttpActionResult AbandonTeam(Guid teamId)
{
ApplicationUser user = GetAuthUser();
CSGOTeam team = _dbContext.Teams.Find(teamId);
TeamMember entity = team.Members.SingleOrDefault(e => e.UserId == user.Id);
team.Members.Remove(entity);
object response = new { removed = false };
if (team.Members.Count == 0)
{
_dbContext.Teams.Remove(team);
response = new { removed = true };
}
else if (!team.Members.Any(m => m.IsAdmin))
{
team.Members.First().IsAdmin = true;
}
try
{
_dbContext.SaveChanges();
}
catch (DbUpdateException e)
{
System.Diagnostics.Trace.TraceError($"Team abandon error: ${e.Message}");
return(BadRequest("Could not remove team because there's an active tournament registration associated with it!"));
}
return(Ok(response));
}
public IHttpActionResult GetTeamStrats(string teamId)
{
CSGOTeam team = UserIsTeamMember(teamId);
if (team == null)
{
return(BadRequest("You're not a member of this team."));
}
return(Ok(team.Strategies));
}
public IHttpActionResult GetIsTeamAdmin(string teamid)
{
CSGOTeam team = UserIsTeamAdmin(teamid);
if (team == null)
{
return(Ok(false));
}
return(Ok(true));
}
public static double GetTotalAvailability(this CSGOTeam team)
{
double total = 0;
foreach (Availability availability in team.PracticeSchedule.Where(a => a.Available))
{
total += (availability.To - availability.From).TotalHours;
}
return(total);
}
public IHttpActionResult GetTeamApplications(Guid teamId)
{
CSGOTeam team = UserIsTeamAdmin(teamId);
if (team == null)
{
return(BadRequest("You need to be team admin."));
}
return(Ok(team.Applications.OrderByDescending(n => n.Sent).ToList()));
}
private CSGOTeam ResolveTeam(string teamId)
{
CSGOTeam team = _dbContext.Teams.FirstOrDefault(t => t.CustomUrl == teamId);
if (team == null)
{
var valid = Guid.TryParse(teamId, out Guid id);
if (valid)
{
team = _dbContext.Teams.Find(id);
}
}
return(team);
}
public IHttpActionResult GetTournaments(string teamid)
{
CSGOTeam team = ResolveTeam(teamid);
List <Tournament> tournaments = _dbContext.Tournaments.ToList();
List <TeamTournamentViewModel> model = new List <TeamTournamentViewModel>();
foreach (var tournament in tournaments)
{
if (tournament.CSGOMatches.Any(m => m.Team1Id == team.TeamId || m.Team2Id == team.TeamId))
{
model.Add(new TeamTournamentViewModel(tournament, team.TeamId));
}
}
return(Ok(model));
}
public async Task <IActionResult> GetTournaments(string teamid)
{
CSGOTeam team = await ResolveTeam(teamid);
List <TeamTournamentViewModel> model = new();
await _dbContext.Tournaments
.Include(t => t.CSGOMatches)
.ThenInclude(m => m.Team1)
.Where(t => t.CSGOMatches.Any(m => m.Team1Id == team.TeamId))
.Include(t => t.CSGOMatches)
.ThenInclude(m => m.Team2)
.Where(t => t.CSGOMatches.Any(m => m.Team2Id == team.TeamId))
.ForEachAsync(tournament => model.Add(new TeamTournamentViewModel(tournament, team.TeamId)));
return(Ok(model));
}
public IHttpActionResult ApproveApplication(TeamApplication application)
{
CSGOTeam team = UserIsTeamAdmin(application.TeamId);
if (team == null)
{
return(BadRequest("You need to be team admin."));
}
TeamApplication entity = team.Applications.SingleOrDefault(a => a.ApplicantId == application.ApplicantId);
entity.State = NotificationState.Accepted;
ApplicationUser user = _dbContext.Users.Find(application.ApplicantId);
team.Members.Add(new TeamMember()
{
Member = user,
IsActive = true,
IsAdmin = false,
IsEditor = false
});
try
{
_dbContext.SaveChanges();
}
catch (DbUpdateException e)
{
System.Diagnostics.Trace.TraceError($"Team application approve error: ${e.Message}");
return(BadRequest("Something went wrong..."));
}
try
{
List <BellumGensPushSubscription> subs = _dbContext.PushSubscriptions.Where(s => s.userId == entity.ApplicantId).ToList();
NotificationsService.SendNotification(subs, application, NotificationState.Accepted);
}
catch (Exception e)
{
System.Diagnostics.Trace.TraceWarning($"Team application approve push notification fail: ${e.Message}");
}
return(Ok(entity));
}
public IHttpActionResult InviteToTeam(InviteModel model)
{
CSGOTeam team = UserIsTeamAdmin(model.teamId);
if (team == null)
{
return(BadRequest("User is not team admin for " + team.TeamName));
}
ApplicationUser invitedUserEntity = _dbContext.Users.Find(model.userId);
ApplicationUser invitingUserEntity = GetAuthUser();
TeamInvite invite = team.Invites.SingleOrDefault(i => i.InvitingUserId == invitingUserEntity.Id && i.InvitedUserId == invitedUserEntity.Id);
if (invite != null)
{
if (invite.State != NotificationState.NotSeen)
{
invite.State = NotificationState.NotSeen;
}
}
else
{
invite = new TeamInvite()
{
InvitedUser = invitedUserEntity,
InvitingUserId = invitingUserEntity.Id
};
team.Invites.Add(invite);
}
try
{
_dbContext.SaveChanges();
}
catch (DbUpdateException e)
{
System.Diagnostics.Trace.TraceError($"Team invite error: ${e.Message}");
return(BadRequest("Something went wrong..."));
}
List <BellumGensPushSubscription> subs = _dbContext.PushSubscriptions.Where(sub => sub.userId == invitedUserEntity.Id).ToList();
NotificationsService.SendNotification(subs, invite);
return(Ok(model.userId));
}
public async Task <IActionResult> AcceptTeamInvite(TeamInvite invite)
{
TeamInvite entity = await _dbContext.TeamInvites.FindAsync(invite.InvitingUserId, invite.InvitedUserId, invite.TeamId);
if (entity == null)
{
return(NotFound());
}
ApplicationUser user = await GetAuthUser();
if (invite.InvitedUserId != user.Id)
{
return(BadRequest("This invite was not sent to you..."));
}
CSGOTeam team = await _dbContext.CSGOTeams.FindAsync(invite.TeamId);
team.Members.Add(new TeamMember()
{
UserId = user.Id,
IsActive = true,
IsAdmin = false,
IsEditor = false
});
entity.State = NotificationState.Accepted;
try
{
await _dbContext.SaveChangesAsync();
}
catch (DbUpdateException e)
{
System.Diagnostics.Trace.TraceError($"User team invite accept error: ${e.Message}");
return(BadRequest("Something went wrong..."));
}
List <BellumGensPushSubscription> subs = await _dbContext.BellumGensPushSubscriptions.Where(s => s.UserId == entity.InvitingUser.Id).ToListAsync();
await _notificationService.SendNotificationAsync(subs, entity, NotificationState.Accepted);
return(Ok(entity));
}
public IHttpActionResult UpdateTeamMember(TeamMember member)
{
CSGOTeam team = UserIsTeamAdmin(member.TeamId);
if (team == null)
{
return(BadRequest("User is not team admin..."));
}
TeamMember entity = team.Members.SingleOrDefault(m => m.UserId == member.UserId);
_dbContext.Entry(entity).CurrentValues.SetValues(member);
try
{
_dbContext.SaveChanges();
}
catch (DbUpdateException e)
{
System.Diagnostics.Trace.TraceError($"Team member update error: ${e.Message}");
return(BadRequest("Something went wrong..."));
}
return(Ok("ok"));
}
public IHttpActionResult RemoveTeamMember(Guid teamId, string userId)
{
CSGOTeam team = UserIsTeamAdmin(teamId);
if (team == null)
{
return(BadRequest("User is not team admin..."));
}
TeamMember entity = team.Members.SingleOrDefault(m => m.UserId == userId);
_dbContext.TeamMembers.Remove(entity);
try
{
_dbContext.SaveChanges();
}
catch (DbUpdateException e)
{
System.Diagnostics.Trace.TraceError($"Team member delete error: ${e.Message}");
return(BadRequest("Something went wrong..."));
}
return(Ok("ok"));
}
public async Task <IActionResult> AbandonTeam(Guid teamId)
{
ApplicationUser user = await GetAuthUser();
CSGOTeam team = await _dbContext.CSGOTeams.FindAsync(teamId);
await _dbContext.Entry(team).Collection(t => t.Members).LoadAsync();
object response = new { removed = false };
if (team.Members.Count == 1)
{
_dbContext.CSGOTeams.Remove(team);
response = new { removed = true };
}
else
{
TeamMember entity = team.Members.FirstOrDefault(m => m.UserId == user.Id);
if (entity != null)
{
team.Members.Remove(entity);
if (!team.Members.Any(m => m.IsAdmin))
{
team.Members.First().IsAdmin = true;
}
}
}
try
{
await _dbContext.SaveChangesAsync();
}
catch (DbUpdateException e)
{
System.Diagnostics.Trace.TraceError($"Team abandon error: ${e.Message}");
return(BadRequest("Could not remove team because there's an active tournament registration associated with it!"));
}
return(Ok(response));
}
public IHttpActionResult TeamFromSteamGroup(SteamUserGroup group)
{
ApplicationUser user = GetAuthUser();
if (!SteamServiceProvider.VerifyUserIsGroupAdmin(user.Id, group.groupID64))
{
return(BadRequest("User is not a steam group owner for " + group.groupName));
}
CSGOTeam team = _dbContext.Teams.Add(new CSGOTeam()
{
SteamGroupId = group.groupID64,
TeamName = group.groupName,
TeamAvatar = group.avatarFull
});
team.InitializeDefaults();
team.UniqueCustomUrl(_dbContext);
team.Members.Add(new TeamMember()
{
UserId = user.Id,
IsActive = true,
IsAdmin = true,
IsEditor = true
});
try
{
_dbContext.SaveChanges();
}
catch (DbUpdateException e)
{
System.Diagnostics.Trace.TraceWarning($"Attempting to register steam group twice: ${group.groupID64} msg: ${e.Message}");
return(BadRequest(group.groupName + " Steam group has already been registered."));
}
return(Ok(team));
}
public IHttpActionResult RejectApplication(TeamApplication application)
{
CSGOTeam team = UserIsTeamAdmin(application.TeamId);
if (team == null)
{
return(BadRequest("You need to be team admin."));
}
TeamApplication entity = team.Applications.SingleOrDefault(a => a.ApplicantId == application.ApplicantId);
entity.State = NotificationState.Rejected;
try
{
_dbContext.SaveChanges();
}
catch (DbUpdateException e)
{
System.Diagnostics.Trace.TraceError($"Team application reject error: ${e.Message}");
return(BadRequest("Something went wrong... "));
}
return(Ok("ok"));
}
public IHttpActionResult SetTeamAvailability(TeamAvailability day)
{
CSGOTeam team = UserIsTeamAdmin(day.TeamId);
if (team == null)
{
return(BadRequest("You need to be team admin."));
}
TeamAvailability entity = team.PracticeSchedule.FirstOrDefault(s => s.Day == day.Day);
_dbContext.Entry(entity).CurrentValues.SetValues(day);
try
{
_dbContext.SaveChanges();
}
catch (DbUpdateException e)
{
System.Diagnostics.Trace.TraceError($"Team availability error: ${e.Message}");
return(BadRequest("Something went wrong..."));
}
return(Ok(entity));
}
public async Task <IActionResult> UpdateTeam(CSGOTeam team)
{
if (!await UserIsTeamAdmin(team.TeamId))
{
return(BadRequest("User is not a team admin for " + team.TeamName));
}
if (ModelState.IsValid)
{
_dbContext.Attach(team).State = EntityState.Modified;
try
{
await _dbContext.SaveChangesAsync();
}
catch (DbUpdateException e)
{
System.Diagnostics.Trace.TraceError($"Team update error: ${e.Message}");
return(BadRequest("Something went wrong!"));
}
return(Ok(team));
}
return(BadRequest("Invalid state of the team " + team.TeamName));
}
public IHttpActionResult SearchPlayers(PlaystyleRole?role, double overlap, Guid?teamid)
{
List <ApplicationUser> users = new List <ApplicationUser>();
List <UserStatsViewModel> players = new List <UserStatsViewModel>();
if (overlap <= 0 && role == null)
{
users = _dbContext.Users.Where(u => u.SearchVisible).OrderBy(u => u.Id).Take(50).ToList();
foreach (ApplicationUser user in users)
{
players.Add(new UserStatsViewModel(user));
}
return(Ok(players));
}
if (role != null)
{
users = _dbContext.Users.Where(u => u.SearchVisible && (u.PreferredPrimaryRole == role || u.PreferredSecondaryRole == role)).ToList();
}
else
{
users = _dbContext.Users.Where(u => u.SearchVisible && u.Availability.Any(d => d.Available)).ToList();
}
if (overlap > 0)
{
if (!User.Identity.IsAuthenticated)
{
return(BadRequest("You must sign in to perform search by availability..."));
}
if (teamid != null)
{
CSGOTeam team = _dbContext.Teams.Find(teamid);
overlap = Math.Min(overlap, team.GetTotalAvailability());
users = users.Where(u => u.GetTotalAvailability() >= overlap && team.GetTotalOverlap(u) >= overlap).ToList();
}
else
{
ApplicationUser user = GetAuthUser();
overlap = Math.Min(overlap, user.GetTotalAvailability());
if (!user.Availability.Any(a => a.Available))
{
return(BadRequest("You must provide your availability in your user profile..."));
}
users = users.Where(u => u.GetTotalAvailability() >= overlap && u.GetTotalOverlap(user) >= overlap).ToList();
}
foreach (ApplicationUser user in users)
{
players.Add(new UserStatsViewModel(user));
}
return(Ok(players));
}
foreach (ApplicationUser user in users)
{
players.Add(new UserStatsViewModel(user));
}
return(Ok(players));
}
