public void GetAllPlayers_ShouldReturnAllPlayers()
{
var options = GetDbOptions("GetAllPlayers_Database");
var dummyPlayer1 = new Player()
{
UserName = "******"
};
var dummyPlayer2 = new Player()
{
UserName = "******"
};
var dummyPlayer3 = new Player()
{
UserName = "******"
};
var actual = new List <Player>();
using (var context = new RiderDBContext(options))
{
var userManager = GetMockUserManager();
var playersService = new PlayersService(context, userManager.Object);
actual = playersService.GetAllPlayers().ToList();
}
Assert.Empty(actual);
using (var context = new RiderDBContext(options))
{
context.Users.Add(dummyPlayer1);
context.Users.Add(dummyPlayer2);
context.Users.Add(dummyPlayer3);
context.SaveChanges();
}
using (var context = new RiderDBContext(options))
{
var userManager = GetMockUserManager();
var playersService = new PlayersService(context, userManager.Object);
actual = playersService.GetAllPlayers().ToList();
}
Assert.Equal(3, actual.Count());
Assert.Contains(actual, x => x.UserName == dummyPlayer1.UserName);
Assert.Contains(actual, x => x.UserName == dummyPlayer2.UserName);
Assert.Contains(actual, x => x.UserName == dummyPlayer3.UserName);
}
public void PlayerHasATeamShouldReturnTrue()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "PlayerHasATeamTrue_Players_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var town = townsService.CreateTown("Vraca");
var user = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = "*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = "******",
Town = town,
PasswordHash = "123123"
};
dbContext.Users.Add(user);
dbContext.SaveChanges();
var playersService = new PlayersService(dbContext, null, null, null);
var player = new Player
{
FullName = "Footeo Player"
};
playersService.CreatePlayer(user, player);
var playerUser = dbContext.Players.FirstOrDefault(p => p.FullName == "Footeo Player");
playerUser.Team = new Team
{
Name = "Team",
Initials = "TTT"
};
dbContext.SaveChanges();
var playerHasATeam = playersService.PlayerHasATeam(user.UserName);
Assert.True(playerHasATeam);
}
public async Task GetPlayersByParticipantsDtoShouldRetrunCollectionOfPlayerDTO()
{
var gameId = 4503146831;
var region = RiotSharp.Misc.Region.Euw;
var game = await this.api.Match.GetMatchAsync(region, gameId);
List <ParticipantIdentity> participantIdentities = game.ParticipantIdentities;
List <Participant> participants = game.Participants;
int teamId = 100;
var firstPlayerExpectedUsername = participantIdentities[0].Player.SummonerName;
var firstPlayerExpectedCS = $"{participants[0].Stats.NeutralMinionsKilled + participants[0].Stats.TotalMinionsKilled}";
var firstPlayerExpectedDamage = participants[0].Stats.TotalDamageDealtToChampions;
var firstPlayerExpectedKDA = $"{participants[0].Stats.Kills}/{participants[0].Stats.Deaths}/{participants[0].Stats.Assists}";
var firstPlayerExpectedLevel = (int)participants[0].Stats.ChampLevel;
var lastPlayerExpectedUsername = participantIdentities[4].Player.SummonerName;
var lastPlayerExpectedCS = $"{participants[4].Stats.NeutralMinionsKilled + participants[4].Stats.TotalMinionsKilled}";
var lastPlayerExpectedDamage = participants[4].Stats.TotalDamageDealtToChampions;
var lastPlayerExpectedKDA = $"{participants[4].Stats.Kills}/{participants[4].Stats.Deaths}/{participants[4].Stats.Assists}";
var lastPlayerExpectedLevel = (int)participants[4].Stats.ChampLevel;
var service = new PlayersService(this.championsService.Object, this.spellsService.Object);
var result = await service.GetPlayersByParticipantsDto(participantIdentities, participants, teamId);
var firstPlayer = result.FirstOrDefault();
var lastPlayer = result.LastOrDefault();
Assert.NotNull(result);
Assert.NotNull(firstPlayer);
Assert.NotNull(lastPlayer);
Assert.IsType <PlayerDTO>(result.First());
Assert.Equal(firstPlayerExpectedUsername, firstPlayer.Username);
Assert.Equal(firstPlayerExpectedCS, firstPlayer.CS);
Assert.Equal(firstPlayerExpectedDamage, firstPlayer.Damage);
Assert.Equal(firstPlayerExpectedKDA, firstPlayer.KDA);
Assert.Equal(firstPlayerExpectedLevel, firstPlayer.Level);
Assert.Equal(lastPlayerExpectedUsername, lastPlayer.Username);
Assert.Equal(lastPlayerExpectedCS, lastPlayer.CS);
Assert.Equal(lastPlayerExpectedDamage, lastPlayer.Damage);
Assert.Equal(lastPlayerExpectedKDA, lastPlayer.KDA);
Assert.Equal(lastPlayerExpectedLevel, lastPlayer.Level);
}
public void SetPositionShouldReturnCorrectResult()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "SetPosition_Players_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var town = townsService.CreateTown("Vraca");
var user = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = "*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = "******",
Town = town,
PasswordHash = "123123"
};
dbContext.Users.Add(user);
dbContext.SaveChanges();
var playersService = new PlayersService(dbContext, null, null, null);
var player = new Player
{
FullName = "Footeo Player"
};
playersService.CreatePlayer(user, player);
playersService.SetPosition(user.UserName, PlayerPosition.Forward);
var position = player.Position.ToString();
var expectedPosition = "Forward";
Assert.AreEqual(expectedPosition, position);
}
public void GetPlayerByIdShouldNotReturnNull()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "GetPlayerByIdNull_Players_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var town = townsService.CreateTown("Vraca");
var user = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = "*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = "******",
Town = town,
PasswordHash = "123123"
};
dbContext.Users.Add(user);
dbContext.SaveChanges();
var playersService = new PlayersService(dbContext, null, null, null);
var player = new Player
{
FullName = "Footeo Player"
};
playersService.CreatePlayer(user, player);
var invalidPlayerId = 38;
var playerModel = playersService.GetPlayerById <PlayerDetailsViewModel>(invalidPlayerId);
Assert.Null(playerModel);
}
public void PlayerExistsByIdShouldReturnFalse()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "PlayerExistsByIdFalse_Players_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var town = townsService.CreateTown("Vraca");
var user = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = "*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = "******",
Town = town,
PasswordHash = "123123"
};
dbContext.Users.Add(user);
dbContext.SaveChanges();
var playersService = new PlayersService(dbContext, null, null, null);
var player = new Player
{
FullName = "Footeo Player"
};
playersService.CreatePlayer(user, player);
var invalidPlayerId = 83;
var playerExists = playersService.PlayerExistsById(invalidPlayerId);
Assert.False(playerExists);
}
private TeamResult GetTeamResult(int teamID, int leagueID)
{
var dataCache = new DataCache();
var team = TeamsService.GetInstance().GetTeam(teamID, leagueID, dataCache: dataCache);
var teams = TeamsService.GetInstance().GetTeams(leagueID: team.LeagueID, showAll: true, dataCache: dataCache);
var players = PlayersService.GetInstance().GetPlayers(dataCache: dataCache);
var playerStats = StatsService.GetInstance().GetAllStats(teamID, team.SportID, leagueID, dataCache: dataCache);
var statTypes = GamesService.GetInstance().GetStatTypes(team.SportID).OrderBy(s => s.GridDisplayOrder);
var teamResult = new TeamResult()
{
ID = team.ID,
Name = team.Name,
Games = team.Games.Select(g => new TeamGameResult()
{
ID = g.ID,
GameDate = g.GameDate,
OtherTeamName = g.Team1ID == team.ID ? teams.First(t => t.ID == g.Team2ID).Name : teams.First(t => t.ID == g.Team1ID).Name,
DidWin = DidWin(g.Team1ID == team.ID, g.Team1Score, g.Team2Score),
HighScore = Math.Max(g.Team1Score, g.Team2Score),
LowScore = Math.Min(g.Team1Score, g.Team2Score),
}).ToList(),
Teams = teams.Select(t => new TeamsResult()
{
ID = t.ID,
Name = t.Name
}).ToList(),
AvailablePlayers = players.Where(p => !team.Players.Exists(tp => tp.ID == p.ID)).Select(p => new PlayersResult()
{
ID = p.ID,
Name = p.Name,
}).ToList(),
TeamPlayerStats = playerStats.Select(s => ConvertObjects.ConvertType(s)).ToList(),
StatTypes = statTypes.Select(s => ConvertObjects.ConvertType(s)).ToList(),
};
return(teamResult);
}
public static async Task Run(
[TimerTrigger("0 */1 * * * *")] TimerInfo myTimer,
ExecutionContext executionContext,
[Import] PlayersService playersService,
[Import] IConfiguration configuration,
ILogger log)
{
var timer = new Stopwatch();
log.LogInformation("Started {integrationName} integration at {integrationDate}",
nameof(PlayersCrawler),
DateTime.UtcNow.ToString("g"));
timer.Start();
var playersClubsPageUrl = configuration["BadmintonLtPlayersClubsPageUrl"];
await playersService.ImportFrom(playersClubsPageUrl);
timer.Stop();
log.LogInformation("Executed {integrationName} integration. Elapsed time {elapsedTime} in milliseconds",
nameof(PlayersCrawler),
timer.ElapsedMilliseconds);
}
public void GetLatestPlayer_ShouldReturnLastAddedPlayer()
{
var options = GetDbOptions("GetLatestPlayer_Database");
var dummyPlayer1 = new Player()
{
UserName = "******", CreatedOn = DateTime.UtcNow
};
var dummyPlayer2 = new Player()
{
UserName = "******", CreatedOn = DateTime.UtcNow
};
var dummyPlayer3 = new Player()
{
UserName = "******", CreatedOn = DateTime.UtcNow
};
using (var context = new RiderDBContext(options))
{
context.Users.Add(dummyPlayer1);
context.Users.Add(dummyPlayer2);
context.Users.Add(dummyPlayer3);
context.SaveChanges();
}
Player actual;
using (var context = new RiderDBContext(options))
{
var userManager = GetMockUserManager();
var playersService = new PlayersService(context, userManager.Object);
actual = playersService.GetLatestPlayer();
}
Assert.Equal("Last", actual.UserName);
}
public IPrincipal PeonUser()
{
return(MakePrincipal(PlayersService.GetPlayerByName("Peon")));
}
public IPrincipal WizardUser()
{
return(MakePrincipal(PlayersService.GetPlayerByName("Wizard")));
}
public PlayersController()
{
_usersService = new UsersService();
_playersService = new PlayersService()
}
public PlayersController(IUsersService usersService)
{
_usersService = usersService;
_playersService = new PlayersService();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="playersService"></param>
public PlayersController(PlayersService <PlayersViewModel, Player> playersService)
{
_playersService = playersService;
}
public void IsSquadNumberTakenShouldReturnTrue()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "IsSquadNumberTakenTrue_Players_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var town = townsService.CreateTown("Vraca");
var user = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = "*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = "******",
Town = town,
PasswordHash = "123123"
};
dbContext.Users.Add(user);
dbContext.SaveChanges();
var mockUserStore = new Mock <IUserStore <FooteoUser> >();
var userManager = new Mock <UserManager <FooteoUser> >(mockUserStore.Object, null, null, null, null, null, null, null, null);
userManager.Setup(u => u.RemoveFromRoleAsync(user, "Player")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(user, "PlayerInTeam")).Returns(Task.FromResult(IdentityResult.Success));
var leaguesService = new LeaguesService(dbContext, townsService);
var player = new Player
{
FullName = "Footeo Player"
};
var playerUser = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = "*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = "******",
Town = town,
PasswordHash = "123123"
};
dbContext.Users.Add(playerUser);
dbContext.SaveChanges();
var playerTwo = new Player
{
FullName = "Footeo Player"
};
userManager.Setup(u => u.RemoveFromRoleAsync(playerUser, "Player")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(playerUser, "PlayerInTeam")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(playerUser, "Captain")).Returns(Task.FromResult(IdentityResult.Success));
var teamsService = new TeamsService(dbContext, townsService, leaguesService, userManager.Object, null);
var playersService = new PlayersService(dbContext, userManager.Object, null, teamsService);
playersService.CreatePlayer(user, player);
playersService.CreatePlayer(playerUser, playerTwo);
teamsService.CreateTeam("Team", "TTT", playerUser.UserName);
var team = dbContext.Teams.FirstOrDefault(t => t.Name == "Team");
playersService.JoinTeam(team.Id, user.UserName);
playersService.SetSquadNumber(user.UserName, 7);
var isSquadNumberTaken = playersService.IsSquadNumberTaken(7, team.Id);
Assert.True(isSquadNumberTaken);
}
public PlayersController(PlayersService ps)
{
_ps = ps;
}
public void PlayersRankingsMethodReturnCorrectData()
{
var teamEnglish = new Team
{
Name = "Arsenal",
};
var playersList = new List <Player>()
{
new Player
{
ShortName = "Name1",
Team = teamEnglish,
TeamNumber = 1,
ScoredGoals = 0,
MatchesPlayed = 5,
},
new Player
{
ShortName = "Name2",
Team = teamEnglish,
TeamNumber = 2,
ScoredGoals = 2,
MatchesPlayed = 5,
},
new Player
{
ShortName = "Name3",
Team = teamEnglish,
TeamNumber = 3,
ScoredGoals = 3,
MatchesPlayed = 5,
},
new Player
{
ShortName = "Name4",
Team = teamEnglish,
TeamNumber = 4,
ScoredGoals = 4,
MatchesPlayed = 5,
},
new Player
{
ShortName = "Name5",
Team = teamEnglish,
TeamNumber = 5,
ScoredGoals = 5,
MatchesPlayed = 5,
},
new Player
{
ShortName = "Name6",
Team = teamEnglish,
TeamNumber = 6,
ScoredGoals = 6,
MatchesPlayed = 5,
},
new Player
{
ShortName = "Name7",
Team = teamEnglish,
TeamNumber = 7,
ScoredGoals = 7,
MatchesPlayed = 5,
},
new Player
{
ShortName = "Name8",
Team = teamEnglish,
TeamNumber = 8,
ScoredGoals = 8,
MatchesPlayed = 5,
},
new Player
{
ShortName = "Name9",
Team = teamEnglish,
TeamNumber = 9,
ScoredGoals = 9,
MatchesPlayed = 5,
},
new Player
{
ShortName = "Name10",
Team = teamEnglish,
TeamNumber = 10,
ScoredGoals = 10,
MatchesPlayed = 5,
},
new Player
{
ShortName = "Name11",
Team = teamEnglish,
TeamNumber = 11,
ScoredGoals = 11,
MatchesPlayed = 5,
},
};
var leagueList = new List <League>()
{
new League
{
Id = 1,
Name = "English Premier Division",
Players = playersList,
},
new League
{
Id = 2,
Name = "Bundesliga",
},
};
var leagueRepo = new Mock <IDeletableEntityRepository <League> >();
leagueRepo.Setup(x => x.All()).Returns(leagueList.AsQueryable());
var service = new PlayersService(leagueRepo.Object);
var leagues = service.Rankings();
var leaguesCount = leagues.Leagues.Count();
var leagueName = leagues.Leagues.Select(x => x.LeagueName).FirstOrDefault();
var league = leagues.Leagues.FirstOrDefault();
var leaguePlayersCount = league.Players.Count();
var playerName = league.Players.Select(x => x.Neam).FirstOrDefault();
var teamName = league.Players.Select(x => x.TeamName).FirstOrDefault();
var teamNumber = league.Players.Select(x => x.TeamNumber).FirstOrDefault();
var scoredGoals = league.Players.Select(x => x.ScoredGoals).FirstOrDefault();
var matchesPlayed = league.Players.Select(x => x.MatchesPlayed).FirstOrDefault();
Assert.Equal(2, leaguesCount);
Assert.Equal("English Premier Division", leagueName);
Assert.Equal(10, leaguePlayersCount);
Assert.Equal("Name11", playerName);
Assert.Equal("Arsenal", teamName);
Assert.Equal(11, teamNumber);
Assert.Equal(11, scoredGoals);
Assert.Equal(5, matchesPlayed);
}
/// <summary>
/// default ctor
/// </summary>
public PlayersController(PlayersService service)
{
Service = service;
}
public void Init()
{
playersService = new PlayersService();
}
public void GetAllPlayersShouldReturnCollectionOfPlayers()
{
var players = new List <Player>
{
new Player
{
Id = "peshosId123",
Position = new Position
{
Name = PositionName.ShootingGuard,
Description = "Shooting guard position",
Playstyle = "You play like a shooting guard",
},
Name = "Pesho Player",
TeamName = "SoftUni Coders",
Championships = 6,
Description = "Some short description for this one",
Experience = "8 years",
Height = "2.0m",
Weight = "102kg",
},
new Player
{
Id = "goshosId123",
Position = new Position
{
Name = PositionName.PointGuard,
Description = "Point guard position",
Playstyle = "You play like a point guard",
},
Name = "Gosho Player",
TeamName = "SoftUni Coders",
Championships = 4,
Description = "Another short description for this one",
Experience = "5 years",
Height = "1.8m",
Weight = "85kg",
},
new Player
{
Id = "toshosId123",
Position = new Position
{
Name = PositionName.Center,
Description = "Center guard position",
Playstyle = "You play like a center guard",
},
Name = "Toshoo Player",
TeamName = "SoftUni Coders",
Championships = 2,
Description = "Some short descr for this one",
Experience = "5 years",
Height = "1.90m",
Weight = "91kg",
},
};
this.repository.Setup(r => r.AllAsNoTracking()).Returns(() => players.AsQueryable());
var service = new PlayersService(this.repository.Object);
var playersCollection = service.GetAllPlayersAsync <PlayerViewModel>();
Assert.Equal(3, playersCollection.Result.Count());
}
public GamesController()
{
_playersService = new PlayersService();
}
public TeamsController(PlayersService playersService, ImagesService imagesService)
{
_playersService = playersService;
_imagesService = imagesService;
}
public SteamAuthenticationStateProvider(PlayersService playersService)
{
this.playersService = playersService;
}
public void UsePart_ShouldSetIsUsedTrueAndChangeBikePartId()
{
var options = GetDbOptions("UsePart_Database");
var dummyPlayerPart1 = new PlayerParts()
{
Id = 10
};
var dummyPlayerPart2 = new PlayerParts()
{
Id = 20
};
var dummyPlayerPart3 = new PlayerParts()
{
Id = 30
};
var dummyBikePart = new BikeParts()
{
Id = 1020
};
using (var context = new RiderDBContext(options))
{
context.PlayerParts.Add(dummyPlayerPart1);
context.PlayerParts.Add(dummyPlayerPart2);
context.PlayerParts.Add(dummyPlayerPart3);
context.SaveChanges();
}
Assert.False(dummyPlayerPart1.IsUsed);
Assert.False(dummyPlayerPart2.IsUsed);
Assert.NotEqual(dummyPlayerPart1.BikePartId, dummyBikePart.Id);
Assert.NotEqual(dummyPlayerPart2.BikePartId, dummyBikePart.Id);
PlayerParts actual1;
PlayerParts actual2;
bool isUsed1;
bool isUsed2;
bool isUsed3;
using (var context = new RiderDBContext(options))
{
var userManager = GetMockUserManager();
var playersService = new PlayersService(context, userManager.Object);
isUsed1 = playersService.UsePart(10, 1020);
isUsed2 = playersService.UsePart(20, 1020);
isUsed3 = playersService.UsePart(221, 1020);
actual1 = context.PlayerParts.FirstOrDefault(x => x.Id == 10);
actual2 = context.PlayerParts.FirstOrDefault(x => x.Id == 20);
}
Assert.True(isUsed1);
Assert.True(isUsed2);
Assert.False(isUsed3);
Assert.True(actual1.IsUsed);
Assert.True(actual2.IsUsed);
Assert.Equal(dummyBikePart.Id, actual1.BikePartId);
Assert.Equal(dummyBikePart.Id, actual2.BikePartId);
}
public PlayersController(ILogger <PlayersController> logger, PlayersService playersService)
{
_logger = logger;
_playersService = playersService;
}
public List <PlayersResult> AddPlayer([FromBody] PlayersResult player)
{
PlayersService.GetInstance().AddPlayer(ConvertObjects.ConvertType(player));
return(GetPlayers());
}
private GameResult GetGameResult(int leagueID, int gameID)
{
try
{
var dataCache = new DataCache();
var game = GamesService.GetInstance().GetGame(gameID, dataCache: dataCache);
var teams = new List <int>()
{
game.Team1ID, game.Team2ID
};
var allTeams = TeamsService.GetInstance().GetTeams(leagueID: leagueID, validTeams: teams, dataCache: dataCache);
var players = PlayersService.GetInstance().GetPlayers(gameID: gameID, leagueID: leagueID, dataCache: dataCache);
var statTypes = GamesService.GetInstance().GetStatTypes(game.SportID, dataCache: dataCache).OrderBy(s => s.GridDisplayOrder);
var gameState = BaseballService.GetInstance().GetExistingGameState(gameID, leagueID, dataCache: dataCache);
int?playerAtBat = gameState.TopOfInning ? gameState.Team1Player?.ID : gameState.Team2Player?.ID;
var gameResult = new GameResult()
{
ID = game.ID,
GameDate = game.GameDate,
StatTypes = statTypes.Select(s => ConvertObjects.ConvertType(s)).ToList(),
QuickStatTypes = statTypes
.Where(st => st.QuickButtonOrder > 0)
.Select(s => ConvertObjects.ConvertType(s))
.OrderBy(s => s.QuickButtonOrder)
.ToList(),
Team1ID = game.Team1ID,
Team1Score = game.Team1Score,
Team1Name = game.Team1Name,
Team2ID = game.Team2ID,
Team2Score = game.Team2Score,
Team2Name = game.Team2Name,
Team1PlayerStats = game.PlayerStats
.Where(p => p.TeamID == game.Team1ID)
.Select(g =>
{
var order = Convert.ToInt16(g.Stats.Where(s => s.StatType.ID == (int)CalculatedStatTypes.BattingOrder).Sum(s => s.Value));
return(new PlayerStatsResult()
{
PlayerID = g.PlayerID,
PlayerName = players.FirstOrDefault(p => p.ID == g.PlayerID)?.Name,
PlayerNumber = players.FirstOrDefault(p => p.ID == g.PlayerID)?.Number ?? 0,
Order = order == 0 ? (int?)null : order,
AtBat = game.SportID == (int)SportsList.Baseball && g.PlayerID == playerAtBat,
PlayerStats = g.Stats.OrderBy(s => s.StatType.GridDisplayOrder)
.Select(s => new StatResult()
{
StatTypeID = s.StatType.ID,
Name = s.StatType.Name,
DefaultShow = s.StatType.DefaultShow,
Value = s.Value
}).ToList()
});
})
.ToList(),
Team2PlayerStats = game.PlayerStats
.Where(p => p.TeamID == game.Team2ID)
.Select(g =>
{
var order = Convert.ToInt16(g.Stats.Where(s => s.StatType.ID == (int)CalculatedStatTypes.BattingOrder).Sum(s => s.Value));
return(new PlayerStatsResult()
{
PlayerID = g.PlayerID,
PlayerName = players.FirstOrDefault(p => p.ID == g.PlayerID)?.Name,
PlayerNumber = players.FirstOrDefault(p => p.ID == g.PlayerID)?.Number ?? 0,
Order = order == 0 ? (int?)null : order,
AtBat = game.SportID == (int)SportsList.Baseball && g.PlayerID == playerAtBat,
PlayerStats = g.Stats.OrderBy(s => s.StatType.GridDisplayOrder)
.Select(s => new StatResult()
{
StatTypeID = s.StatType.ID,
Name = s.StatType.Name,
DefaultShow = s.StatType.DefaultShow,
Value = s.Value
}).ToList()
});
})
.ToList(),
Teams = allTeams.Select(t => new TeamsResult()
{
ID = t.ID,
Name = t.Name
})
.ToList()
};
if (game.SportID == (int)SportsList.Baseball)
{
gameResult.Team1PlayerStats = gameResult.Team1PlayerStats.OrderBy(p => p.Order == 0 || p.Order == null ? 99 : p.Order).ToList();
gameResult.Team2PlayerStats = gameResult.Team2PlayerStats.OrderBy(p => p.Order == 0 || p.Order == null ? 99 : p.Order).ToList();
gameResult.BaseballGameStateResult = ConvertObjects.ConvertType(BaseballService.GetInstance().GetExistingGameState(gameID, leagueID));
}
return(gameResult);
}
catch (Exception ex)
{
throw ex;
}
}
public PlayersServiceTests()
{
_sut = new PlayersService(Context);
}
