public void RepoTeamInviteTestsGetTeamInvitesByTeamID()
{
MainTeam mt = new MainTeam {
MainTeamID = 0
};
TeamInvite invite = new TeamInvite {
Team = mt, Accepted = true
};
TeamInvite invite2 = new TeamInvite {
Team = mt, Accepted = false
};
List <TeamInvite> expected = new List <TeamInvite>
{
invite,
invite2
};
List <TeamInvite> inviteDB = new List <TeamInvite>
{
invite,
invite2,
new TeamInvite {
Team = new MainTeam {
MainTeamID = 1
}
}
};
_inviteSet.Object.AddRange(inviteDB);
ConnectMocksToDataStore(inviteDB);
List <TeamInvite> actual = _repo.getInvitesByTeamID(0);
Assert.AreEqual(2, actual.Count);
Assert.IsNotNull(_inviteSet.Object);
CollectionAssert.AreEqual(expected, actual);
}
public void RepoGamerTestsUpdateGamerInvites()
{
List <Gamer> gamerdb = new List <Gamer>
{
new Gamer {
GamerID = 0, Active = true, TeamInvites = new List <TeamInvite>()
},
new Gamer {
GamerID = 1, Active = true
}
};
TeamInvite i = new TeamInvite {
TeamInviteID = 1, Team = new MainTeam()
};
_gamerSet.Object.AddRange(gamerdb);
ConnectMocksToDataStore(gamerdb);
Gamer expected = new Gamer {
GamerID = 0, Active = true, TeamInvites = new List <TeamInvite>()
};
expected.TeamInvites.Add(i);
bool result = _repo.UpdateGamerTeamInvites(0, i);
Gamer actual = _repo.GetGamerById(0);
Assert.IsTrue(result);
Assert.AreEqual(expected, actual);
}
public void RepoTeamInviteTestsUpdateAccepted()
{
Gamer g = new Gamer {
GamerID = 0
};
Gamer g2 = new Gamer {
GamerID = 1
};
MainTeam t = new MainTeam {
MainTeamID = 0
};
List <TeamInvite> inviteDB = new List <TeamInvite>
{
new TeamInvite {
TeamInviteID = 0, Team = t, InvitedGamer = g, Accepted = false
},
new TeamInvite {
TeamInviteID = 1, Team = t, InvitedGamer = g2, Accepted = false
},
};
_inviteSet.Object.AddRange(inviteDB);
ConnectMocksToDataStore(inviteDB);
TeamInvite expected = new TeamInvite {
TeamInviteID = 0, Team = t, InvitedGamer = g, Accepted = true
};
bool result = _repo.UpdateTeamInviteAccepted(0, true);
TeamInvite actual = _repo.GetTeamInviteById(0);
Assert.AreEqual(expected.Accepted, actual.Accepted);
Assert.IsTrue(result);
}
private async Task <TeamInvite> DangerouslyWithdrawInvite(TeamInvite invite)
{
invite.Mark(InviteState.Withdrawn);
if (invite.UserProfileId != null && invite.UserProfileId != Guid.Empty && invite.UserProfileId.HasValue)
{
await this.authorizationService.RemovePermission(invite.UserProfileId.Value, AuthorizationHelper.GenerateARN(typeof(TeamInvite), invite.Id.ToString(), Shared.Permissions.TeamInvite.All));
}
return(invite);
}
public void TeamInviteTestsEnsureICanCreateAnInstance()
{
TeamInvite invite = new TeamInvite
{
Accepted = false,
TeamInviteID = 0,
DateSent = new DateTime().Date,
InvitedGamer = new Gamer {
GamerID = 0
},
Team = new MainTeam {
TeamName = "Sudsy"
}
};
Assert.IsNotNull(invite);
Assert.AreEqual("Sudsy", invite.Team.TeamName);
}
public async Task <IActionResult> InviteToTeam(InviteModel model)
{
if (!await UserIsTeamAdmin(model.TeamId))
{
return(BadRequest("User is not team admin..."));
}
ApplicationUser invitingUserEntity = await GetAuthUser();
TeamInvite invite = await _dbContext.TeamInvites.FindAsync(invitingUserEntity.Id, model.UserId, model.TeamId);
if (invite != null)
{
if (invite.State != NotificationState.NotSeen)
{
invite.State = NotificationState.NotSeen;
}
}
else
{
invite = new TeamInvite()
{
InvitedUserId = model.UserId,
InvitingUserId = invitingUserEntity.Id,
TeamId = model.TeamId
};
_dbContext.TeamInvites.Add(invite);
}
try
{
await _dbContext.SaveChangesAsync();
}
catch (DbUpdateException e)
{
System.Diagnostics.Trace.TraceError($"Team invite error: ${e.Message}");
return(BadRequest("Something went wrong..."));
}
List <BellumGensPushSubscription> subs = await _dbContext.BellumGensPushSubscriptions.Where(sub => sub.UserId == model.UserId).ToListAsync();
await _notificationService.SendNotificationAsync(subs, invite);
return(Ok(model.UserId));
}
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));
}
private async Task <TeamInvite> DangerouslyCreateInvite(Guid teamId, string invitee)
{
var invite = new TeamInvite(teamId);
if (EmailHelper.IsEmail(invitee))
{
invite.Email = invitee;
if (userUtils.GetIdFromEmail(invitee, out var userId))
{
var user = await this.context.UserProfiles.Include(u => u.TeamInvites).FirstOrDefaultAsync(u => u.Id == userId);
if (user.TeamInvites.Any(i => i.TeamId == teamId && i.State == InviteState.Pending))
{
return(null);
}
invite.UserProfileId = userId;
await this.authorizationService.AddPermission(userId, AuthorizationHelper.GenerateARN(typeof(TeamInvite), invite.Id.ToString(), Shared.Permissions.TeamInvite.All));
}
}
else
{
var user = await this.context.UserProfiles.Include(u => u.TeamInvites).FirstOrDefaultAsync(u => u.UserName == invitee);
if (user == null)
{
return(null);
}
if (user.TeamInvites.Any(i => i.TeamId == teamId && i.State == InviteState.Pending))
{
return(null);
}
invite.UserProfileId = user.Id;
invite.Email = user.Email;
await this.authorizationService.AddPermission(user.Id, AuthorizationHelper.GenerateARN(typeof(TeamInvite), invite.Id.ToString(), Shared.Permissions.TeamInvite.All));
}
return(invite);
}
public void RepoEnsureICanAddInviteToDB()
{
List <TeamInvite> inviteDB = new List <TeamInvite>
{
new TeamInvite {
TeamInviteID = 0
},
new TeamInvite {
TeamInviteID = 1
},
new TeamInvite {
TeamInviteID = 2
}
};
TeamInvite testInvite = new TeamInvite {
TeamInviteID = 3
};
_inviteSet.Object.AddRange(inviteDB);
ConnectMocksToDataStore(inviteDB);
_inviteSet.Setup(o => o.Add(It.IsAny <TeamInvite>())).Callback((TeamInvite i) => inviteDB.Add(i));
bool result = _repo.AddTeamInvite(testInvite);
List <TeamInvite> actual = _repo.GetAllTeamInvites();
List <TeamInvite> expected = new List <TeamInvite>
{
new TeamInvite {
TeamInviteID = 0
},
new TeamInvite {
TeamInviteID = 1
},
new TeamInvite {
TeamInviteID = 2
},
testInvite
};
Assert.IsTrue(result);
CollectionAssert.AreEqual(expected, actual);
}
public static void SendNotification(List <BellumGensPushSubscription> subs, TeamInvite notification, NotificationState state)
{
var subject = @"https://bellumgens.com";
foreach (BellumGensPushSubscription sub in subs)
{
var subscription = new PushSubscription(sub.endpoint, sub.p256dh, sub.auth);
var vapidDetails = new VapidDetails(subject, NotificationsService._publicVapidKey, NotificationsService._privateVapidKey);
var webPushClient = new WebPushClient();
var payload = new BellumGensNotificationWrapper(notification, state);
try
{
webPushClient.SendNotification(subscription, payload.ToString(), vapidDetails);
}
catch (WebPushException exception)
{
Console.WriteLine(exception);
}
}
}
public IHttpActionResult RejectTeamInvite(TeamInvite invite)
{
TeamInvite entity = _dbContext.TeamInvites.Find(invite.InvitingUserId, invite.InvitedUserId, invite.TeamId);
if (entity == null)
{
return(NotFound());
}
entity.State = NotificationState.Rejected;
try
{
_dbContext.SaveChanges();
}
catch (DbUpdateException e)
{
System.Diagnostics.Trace.TraceError($"User team invite reject error: ${e.Message}");
return(BadRequest("Something went wrong... "));
}
return(Ok(entity));
}
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 async Task SendInvite(string nickname, string teamId)
{
try
{
var player = (await _playerService.GetAllAsync(player => player.Name == nickname)).FirstOrDefault();
if (player != null)
{
var teamInvite = new TeamInvite
{
PlayerId = player.Id,
TeamId = int.Parse(teamId)
};
await _teamInviteService.AddAsync(teamInvite);
await Clients.User(nickname).SendAsync("SendInvite", nickname, teamId);
}
}
catch (Exception exception)
{ }
}
public async Task <int> Handle(InvitePlayerCommand request, CancellationToken cancellationToken)
{
request = request ?? throw new ArgumentNullException(nameof(request));
if (string.IsNullOrWhiteSpace(request.UserName))
{
throw new InvalidSearchQueryException();
}
var desiredPlayer = await this.playersRepository
.AllAsNoTracking()
.Include(p => p.PlayerTeams)
.ThenInclude(pt => pt.Team)
.Include(p => p.Claims)
.SingleOrDefaultAsync(p => p.UserName == request.UserName, cancellationToken)
?? throw new PlayerDoesNotExistException(request.UserName);
if (!await CommonCheckHelper.CheckIfPlayerHasLinkedSteamAccount(desiredPlayer.Id, this.playersRepository))
{
throw new PlayerDoesNotHaveALinkedSteamAccountException(desiredPlayer.UserName);
}
if (desiredPlayer.Claims.Any(c => c.ClaimType == IS_VAC_BANNED_CLAIM_TYPE))
{
throw new PlayerIsVacBannedException(desiredPlayer.UserName);
}
var desiredTeam = await this.teamsRepository
.AllAsNoTracking()
.Include(t => t.TournamentFormat)
.SingleOrDefaultAsync(t => t.Id == request.TeamId, cancellationToken)
?? throw new NotFoundException(nameof(Team), request.TeamId);
if (this.CheckIfUserIsPartOfATeamWithTheSameFormat(desiredPlayer, desiredTeam.TournamentFormatId))
{
throw new PlayerCannotBeAMemeberOfMultipleTeamsWithTheSameFormatException(request.UserName);
}
if (await CommonCheckHelper.CheckIfTeamIsFull(desiredTeam.Id, this.teamsRepository))
{
throw new TeamIsFullException(desiredTeam.Name);
}
if (await this.CheckIfUserAlreadyHasAnInviteForGivenTeam(request))
{
throw new PlayerAlreadyHasPendingInvite(request.UserName);
}
var invite = new TeamInvite
{
PlayerId = desiredPlayer.Id,
TeamId = desiredTeam.Id,
TeamName = desiredTeam.Name,
SenderUsername = this.userAccessor.Username
};
await this.teamInvitesRepository.AddAsync(invite);
var rowsAffected = await this.teamInvitesRepository.SaveChangesAsync(cancellationToken);
await this.mediator.Publish(new PlayerInvitedNotification
{
SenderName = invite.SenderUsername,
ReceiverId = desiredPlayer.Id,
TeamName = desiredTeam.Name
});
return(rowsAffected);
}
public async Task SendNotificationAsync(List <BellumGensPushSubscription> subs, TeamInvite notification, NotificationState state)
{
var subject = @"https://bellumgens.com";
foreach (BellumGensPushSubscription sub in subs)
{
var subscription = new PushSubscription(sub.Endpoint, sub.P256dh, sub.Auth);
var vapidDetails = new VapidDetails(subject, _publicVapidKey, _privateVapidKey);
var webPushClient = new WebPushClient();
var payload = new BellumGensNotificationWrapper(notification, state);
try
{
await webPushClient.SendNotificationAsync(subscription, payload.ToString(), vapidDetails);
}
catch
{
}
}
}
public async Task <TeamResult> CreateTeamAsync(ClaimsPrincipal signedInUser, DataTransferObjects.Team team)
{
// Validate team
if (team == null)
{
throw new ArgumentNullException(nameof(team));
}
if (team.Roster == null)
{
throw new ArgumentNullException(nameof(team.Roster));
}
if (team.Roster.Count() < 5)
{
throw new InvalidOperationException("Teams must have at least 5 members.");
}
if (team.Owner == null)
{
throw new ArgumentNullException(nameof(team.Owner));
}
if (string.IsNullOrEmpty(team.Owner.Username))
{
throw new InvalidOperationException("Team owner invalid username");
}
if (string.IsNullOrEmpty(team.Name))
{
throw new ArgumentNullException(nameof(team.Name));
}
if (!Team.TeamNameRegex.IsMatch(team.Name))
{
throw new InvalidOperationException($"Team name {team.Name} is invalid");
}
// Make sure we have a default season
var season = await _seasonManager.GetCurrentSeasonAsync();
if (season == null)
{
throw new InvalidProgramException("Current season not found");
}
var entity = new Team {
Name = team.Name, NormalizedName = team.Name.ToLower().Replace(' ', '-')
};
// Create team roster
var roster = new List <TeamInvite>();
foreach (var invitee in team.Roster)
{
// Validate invitee
if (string.IsNullOrEmpty(invitee.Username) && string.IsNullOrEmpty(invitee.Tag))
{
throw new InvalidOperationException("Team roster invalid");
}
if (invitee.Username != team.Owner.Username)
{
Player player = null;
if (!string.IsNullOrEmpty(invitee.Username))
{
// If the player has a username, load the user
player = _db.Players
.Include(x => x.User)
.SingleOrDefault(x => x.User.UserName == invitee.Username);
if (player == null)
{
throw new InvalidProgramException($"Player entity for user {invitee.Username} not found.");
}
}
else
{
player = await _db.Players.FirstOrDefaultAsync(x => x.Tag == invitee.Tag);
}
if (player == null)
{
throw new InvalidProgramException($"Unable to find player");
}
var invite = new TeamInvite {
Player = player, Team = entity
};
roster.Add(invite);
}
}
// Create team owner
var ownerPlayer = _db.Players
.Include(x => x.User)
.SingleOrDefault(x => x.User.UserName == team.Owner.Username);
if (ownerPlayer == null)
{
throw new InvalidProgramException($"Player entity for owner {team.Owner.Username} not found.");
}
if (ownerPlayer.User.Id != signedInUser.GetUserId())
{
throw new InvalidOperationException($"Team owner must be currently signed in user.");
}
var teamOwner = new TeamOwner {
Player = ownerPlayer, Team = entity
};
// Begin transaction as this is where we begin save operations
var transaction = await _db.Database.BeginTransactionAsync();
var result = await _userManager.AddClaimAsync(ownerPlayer.User, new Claim($"{AuthorizationDefaults.ClaimTypeTeamOwner}:{entity.NormalizedName}", ownerPlayer.User.UserName));
EnsureIdentitySucceeded(result);
// Refresh the signin to add the owner cookie
await _signInManager.RefreshSignInAsync(ownerPlayer.User);
entity.Invitees = roster;
entity.Owner = teamOwner;
_db.Add(teamOwner);
_db.Add(entity);
foreach (var invitee in roster)
{
_db.Add(invitee);
}
try
{
await _db.SaveChangesAsync();
// Setup rank & image
await _rankManager.CreateNewTeamRankingAsync(entity, season);
await _imageManager.CreateDefaultImageForTeamAsync(entity);
}
catch (Exception e)
{
transaction.Rollback();
return(TeamResult.Failed(e));
}
transaction.Commit();
return(TeamResult.Success(entity));
}
protected override void Seed(NashGaming.Models.NashGamingContext context)
{
List <Gamer> Gamerdb = new List <Gamer> {
new Gamer {
PSNID = "Dude", XB1Gamertag = "N/A", DisplayName = "MockUser1", Email = "*****@*****.**"
},
new Gamer {
GamerID = 6, PSNID = "Dude2", XB1Gamertag = "N/A", DisplayName = "MockUser2", Email = "*****@*****.**"
},
new Gamer {
GamerID = 7, PSNID = "Dude3", XB1Gamertag = "N/A", DisplayName = "MockUser3", Email = "*****@*****.**"
},
new Gamer {
GamerID = 8, PSNID = "Dude4", XB1Gamertag = "N/A", DisplayName = "MockUser4", Email = "*****@*****.**"
},
new Gamer {
GamerID = 9, PSNID = "Dude5", XB1Gamertag = "N/A", DisplayName = "MockUser5", Email = "*****@*****.**"
},
new Gamer {
GamerID = 10, PSNID = "Dude6", XB1Gamertag = "N/A", DisplayName = "MockUser6", Email = "*****@*****.**"
},
new Gamer {
GamerID = 11, PSNID = "Dude7", XB1Gamertag = "N/A", DisplayName = "MockUser7", Email = "*****@*****.**"
},
new Gamer {
GamerID = 12, PSNID = "Dude8", XB1Gamertag = "N/A", DisplayName = "MockUser8", Email = "*****@*****.**"
},
new Gamer {
GamerID = 13, PSNID = "Dude9", XB1Gamertag = "N/A", DisplayName = "MockUser9", Email = "*****@*****.**"
},
new Gamer {
GamerID = 14, PSNID = "Dude10", XB1Gamertag = "N/A", DisplayName = "LadderTeam1Guy1", Email = "*****@*****.**"
},
new Gamer {
GamerID = 15, PSNID = "Dude11", XB1Gamertag = "N/A", DisplayName = "LadderTeam1Guy2", Email = "*****@*****.**"
},
new Gamer {
GamerID = 16, PSNID = "Dude12", XB1Gamertag = "N/A", DisplayName = "LadderTeam1Guy3", Email = "*****@*****.**"
},
new Gamer {
GamerID = 17, PSNID = "Dude13", XB1Gamertag = "N/A", DisplayName = "LadderTeam1Guy4", Email = "*****@*****.**"
},
new Gamer {
GamerID = 18, PSNID = "Dude14", XB1Gamertag = "N/A", DisplayName = "LadderTeam2Guy1", Email = "*****@*****.**"
},
new Gamer {
GamerID = 19, PSNID = "Dude15", XB1Gamertag = "N/A", DisplayName = "LadderTeam2Guy2", Email = "*****@*****.**"
},
new Gamer {
GamerID = 20, PSNID = "Dude16", XB1Gamertag = "N/A", DisplayName = "LadderTeam2Guy3", Email = "*****@*****.**"
},
new Gamer {
GamerID = 21, PSNID = "Dude17", XB1Gamertag = "N/A", DisplayName = "LadderTeam2Guy4", Email = "*****@*****.**"
},
new Gamer {
GamerID = 22, PSNID = "Dude18", XB1Gamertag = "N/A", DisplayName = "RandomGamer1", Email = "*****@*****.**"
},
new Gamer {
GamerID = 23, PSNID = "Dude19", XB1Gamertag = "N/A", DisplayName = "RandomGamer2", Email = "*****@*****.**"
}
};
List <MainTeam> MainTeamdb = new List <MainTeam>
{
new MainTeam {
MainTeamID = 0, DateFounded = new DateTime(2016, 06, 01), TeamName = "MockTeam1", Website = "https://team1.com", Active = true
},
new MainTeam {
MainTeamID = 1, DateFounded = new DateTime(2016, 06, 01), TeamName = "MockTeam2", Website = "https://team2.com", Active = true
},
new MainTeam {
MainTeamID = 2, DateFounded = new DateTime(2016, 06, 01), TeamName = "MockTeam3", Website = "https://team3.com", Active = true
},
};
List <League> Leaguedb = new List <League>
{
new League {
LeagueID = 0, GamesPerWeek = 1, GameTitle = "CSGO", Platform = "PC", EndDate = new DateTime(2016, 09, 01), StartDate = new DateTime(2016, 06, 01), LeagueName = "CSGO 4v4 OBJ League", MinPlayers = 2, MaxPlayers = 4, LeagueType = "Open", Active = true, MainTeams = new List <MainTeam>(), Matches = new List <Match>(), Feed = new List <Posts>()
},
new League {
LeagueID = 1, GamesPerWeek = 2, GameTitle = "Halo", Platform = "XB1", EndDate = new DateTime(2016, 09, 01), StartDate = new DateTime(2016, 06, 01), LeagueName = "Halo 4v4 TDM League", MinPlayers = 2, MaxPlayers = 4, LeagueType = "Intermediate", Active = true, MainTeams = new List <MainTeam>(), Matches = new List <Match>(), Feed = new List <Posts>()
},
new League {
LeagueID = 2, GamesPerWeek = 1, GameTitle = "Rainbow Six: Siege", Platform = "PS4", EndDate = new DateTime(2016, 09, 01), StartDate = new DateTime(2016, 06, 01), LeagueName = "Rainbow6 Siege 5v5 League", MinPlayers = 3, MaxPlayers = 5, LeagueType = "Invite", Active = true, MainTeams = new List <MainTeam>(), Matches = new List <Match>(), Feed = new List <Posts>()
}
};
Leaguedb[0].MainTeams.Add(MainTeamdb[0]);
Leaguedb[0].MainTeams.Add(MainTeamdb[1]);
Leaguedb[0].MainTeams.Add(MainTeamdb[2]);
Leaguedb[1].MainTeams.Add(MainTeamdb[0]);
Leaguedb[1].MainTeams.Add(MainTeamdb[1]);
Leaguedb[1].MainTeams.Add(MainTeamdb[2]);
Leaguedb[2].MainTeams.Add(MainTeamdb[0]);
Leaguedb[2].MainTeams.Add(MainTeamdb[1]);
Leaguedb[2].MainTeams.Add(MainTeamdb[2]);
int l1seasonlength = Convert.ToInt16((Leaguedb[0].EndDate - Leaguedb[0].StartDate).Days / 7);
int l2seasonlength = Convert.ToInt16((Leaguedb[1].EndDate - Leaguedb[1].StartDate).Days / 7);
int l3seasonlength = Convert.ToInt16((Leaguedb[2].EndDate - Leaguedb[2].StartDate).Days / 7);
Leaguedb[0].SeasonLength = l1seasonlength;
Leaguedb[1].SeasonLength = l2seasonlength;
Leaguedb[2].SeasonLength = l3seasonlength;
List <Ladder> Ladderdb = new List <Ladder>
{
new Ladder {
LadderID = 0, GameTitle = "CSGO", Platform = "PC", LadderName = "2v2 Pistols Only", MinPlayers = 1, MaxPlayers = 2, Active = true, MainTeams = new List <MainTeam>(), Challenges = new List <Challenge>(), Feed = new List <Posts>(), Matches = new List <Match>()
}
};
Ladderdb[0].MainTeams.Add(MainTeamdb[0]);
Ladderdb[0].MainTeams.Add(MainTeamdb[1]);
TeamInvite ti1 = new TeamInvite {
TeamInviteID = 0, InvitedGamer = Gamerdb[8], Team = MainTeamdb[0], Accepted = false, DateSent = new DateTime(2016, 06, 03), DateAccepted = new DateTime(2016, 06, 12)
};
List <TeamInvite> TeamInviteDB = new List <TeamInvite> {
ti1
};
Challenge challenge1 = new Challenge {
ChallengeID = 0, Accepted = false, Ladder = Ladderdb[0], Initiator = MainTeamdb[0], Recipient = MainTeamdb[1], ProposedDate1 = new DateTime(2016, 06, 11), ProposedDate2 = new DateTime(2016, 06, 15), ProposedDate3 = new DateTime(2016, 06, 20)
};
foreach (Gamer g in Gamerdb)
{
context.Gamers.AddOrUpdate(g);
}
foreach (MainTeam t in MainTeamdb)
{
context.Teams.AddOrUpdate(t);
}
foreach (League lg in Leaguedb)
{
context.Leagues.AddOrUpdate(lg);
}
foreach (Ladder ld in Ladderdb)
{
context.Ladders.AddOrUpdate(ld);
}
context.Invites.AddOrUpdate(ti1);
context.Challenges.AddOrUpdate(challenge1);
context.SaveChanges();
}
