public ActionResult Edit(int? id)
{
TeamsService teamsService = new TeamsService();
TeamsEditVM model = new TeamsEditVM();
Team team;
if (!id.HasValue)
{
team = new Team();
}
else
{
team = teamsService.GetByID(id.Value);
if (team == null)
{
return RedirectToAction("List");
}
}
model.ID = team.ID;
model.Name = team.Name;
return View(model);
}
public ActionResult Edit()
{
TeamsService teamsService = new TeamsService();
TeamsEditVM model = new TeamsEditVM();
TryUpdateModel(model);
if (!ModelState.IsValid)
{
return View(model);
}
Team team;
if (model.ID == 0)
{
team = new Team();
}
else
{
team = teamsService.GetByID(model.ID);
if (team == null)
{
return RedirectToAction("List");
}
}
team.ID = model.ID;
team.Name = model.Name;
teamsService.Save(team);
return RedirectToAction("List");
}
public ActionResult Delete(int? id)
{
TeamsService teamsService = new TeamsService();
if (!id.HasValue)
{
return RedirectToAction("List");
}
teamsService.Delete(id.Value);
return RedirectToAction("List");
}
public void GetUsersTeamShouldNotReturnNull()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "GetUsersTeam_Teams_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var leaguesService = new LeaguesService(dbContext, townsService);
var mockUserStore = new Mock <IUserStore <FooteoUser> >();
var userManager = new Mock <UserManager <FooteoUser> >(mockUserStore.Object, null, null, null, null, null, null, null, null);
var town = townsService.CreateTown("Sofia");
var user = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = $"*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = $"footeoPlayer",
Town = town,
PasswordHash = "123123",
Player = new Player
{
FullName = "Footeo Player"
}
};
dbContext.Users.Add(user);
dbContext.SaveChanges();
userManager.Setup(u => u.RemoveFromRoleAsync(user, "Player")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(user, "PlayerInTeam")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(user, "Captain")).Returns(Task.FromResult(IdentityResult.Success));
var teamsService = new TeamsService(dbContext, townsService, leaguesService, userManager.Object, null);
teamsService.CreateTeam("Team", "TTT", user.UserName);
var team = teamsService.GetUsersTeam(user.UserName);
Assert.NotNull(team);
}
public UsersController(
UsersService usersService,
TeamsService teamsService,
PurchasesService purchasesService,
UserManager <User> userManager,
ICurrentUserAccessor currentUser,
AvatarsService avatarsService,
IMapper mapper)
{
_userManager = userManager;
_usersService = usersService;
_teamsService = teamsService;
_purchasesService = purchasesService;
_currentUser = currentUser;
_mapper = mapper;
_avatarsService = avatarsService;
}
public async Task Ok_Success()
{
_repository.SetupSequence(x => x.GetSeasonTeamsStatsAsync(It.IsAny <short>(), It.IsAny <byte>())).ReturnsAsync(MockedStats(1).ToList()).ReturnsAsync(MockedStats(2).ToList());
_seasonService.Setup(x => x.GetConfig(It.IsAny <short>())).ReturnsAsync(MockedConfig());
var service = new TeamsService(null, _seasonService.Object, null, _repository.Object, null, null, _mapper);
var result = await service.GetYearTeamsStatsAsync(Year);
Assert.NotNull(result);
Assert.IsInstanceOf <IEnumerable <BusinessEntities.TeamSeasonStats> >(result);
Assert.True(result.Any());
Assert.AreEqual(5, result.Count());
Assert.AreEqual(6, result.First().Pts);
Assert.AreEqual(30, result.Last().Pts);
Assert.AreEqual(10, result.First().G);
_seasonService.Verify(x => x.GetConfig(It.IsAny <short>()), Times.Once);
_repository.Verify(x => x.GetSeasonTeamsStatsAsync(It.IsAny <short>(), It.IsAny <byte>()), Times.Exactly(2));
}
private async Task <DialogTurnResult> ShowTeamsStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
var tokenResponse = (TokenResponse)stepContext.Result;
if (tokenResponse?.Token == null)
{
await stepContext.Context.SendActivityAsync(MessageFactory.Text("Login was not successful please try again."), cancellationToken);
return(await stepContext.EndDialogAsync(cancellationToken : cancellationToken));
}
var service = new TeamsService(tokenResponse.Token);
var teams = await service.GetJoinedTeamsAsync();
if (teams.Length == 0)
{
await stepContext.Context.SendActivityAsync("Sorry, you do not belong to any team at the moment.");
return(await stepContext.EndDialogAsync(null, cancellationToken));
}
else if (teams.Length == 1)
{
var team = teams.First();
var userProfile = await UserProfileAccessor.GetAsync(stepContext.Context);
userProfile.SelectedTeam = team;
await stepContext.Context.SendActivityAsync($"You only have one team: {team.DisplayName}. It was selected automatically.");
return(await stepContext.EndDialogAsync(team, cancellationToken));
}
else
{
stepContext.Values["teams"] = teams;
var promptOptions = new PromptOptions
{
Prompt = MessageFactory.Text("Please select one of you teams:"),
Choices = teams.Select(i => new Choice(i.DisplayName)).ToArray(),
Style = ListStyle.HeroCard
};
return(await stepContext.PromptAsync(nameof(ChoicePrompt), promptOptions, cancellationToken));
}
}
public GetTeamsResult AddTeam([FromBody] TeamsResult team)
{
try
{
if (team.ID == 0)
{
TeamsService.GetInstance().AddTeam(ConvertObjects.ConvertType(team));
}
else
{
TeamsService.GetInstance().AddLeagueTeam(team.ID, team.LeagueID);
}
return(GetTeamsResult(team.LeagueID, team.SportID));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task GetGroupByName_Test()
{
// Arrange
var teamsService = new TeamsService(this.dbContext);
this.dbContext.Groups.Add(new Group {
Name = "B"
});
this.dbContext.Groups.Add(new Group {
Name = "C"
});
await this.dbContext.SaveChangesAsync();
// Act
var group = teamsService.GetGroupByName("B");
// Assert
Assert.AreNotEqual(null, group);
}
public async Task ShouldReturnPaging(IUnitOfWork uow)
{
// Arrange
var sut = new TeamsService(uow, this.Logger);
var pageParameters = new PageParameters {
PageNumber = 2, PageSize = 3
};
var expected = Enumerable.Range(4, 3);
// Act
var actual = await sut.GetTeams(Team.RootTeamCode, pageParameters);
// Assert
var zip = actual.Zip(expected, (a, e) => new { Actual = a, Expcted = e });
Assert.All(zip, z => Assert.Equal(z.Expcted.ToString("00"), z.Actual.Code));
Assert.All(zip, z => Assert.Equal($"Team_{z.Expcted:00}", z.Actual.Name));
Assert.Equal(pageParameters.PageNumber, actual.PageNumber);
Assert.Equal(4, actual.TotalPages);
Assert.Equal(pageParameters.PageSize, actual.PageSize);
}
public async Task GetTotalGoldByPlayersShouldReturnTheTotalGoldOfAllPlayersInATeam()
{
var gameId = 2655757524;
var region = RiotSharp.Misc.Region.Eune;
var game = await this.api.Match.GetMatchAsync(region, gameId);
List <ParticipantIdentity> participantIdentities = game.ParticipantIdentities;
List <Participant> participants = game.Participants;
int firstTeamId = 100;
int secondTeamId = 200;
long firstTeamTotalExpectedGold = 71798;
long secondTeamTotalExpectedGold = 59756;
var service = new TeamsService();
var firstTeamResult = service.GetTotalGoldByPlayers(participantIdentities, participants, firstTeamId);
var secondTeamResult = service.GetTotalGoldByPlayers(participantIdentities, participants, secondTeamId);
Assert.Equal(firstTeamTotalExpectedGold, firstTeamResult);
Assert.Equal(secondTeamTotalExpectedGold, secondTeamResult);
}
public IHttpActionResult GetRankedTeams(int leagueId, int teamId)
{
League league = db.Leagues.Find(leagueId);
if (league == null)
{
return(NotFound());
}
Team team = db.Teams.Find(teamId);
if (team == null)
{
return(NotFound());
}
int?seasonId = league.SeasonId;
var resTeams = TeamsService.GetRankedTeams(leagueId, teamId, seasonId);
return(Ok(resTeams));
}
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 async Task AddTeam_Test()
{
// Arrange
var teamsService = new TeamsService(this.dbContext);
this.dbContext.Groups.Add(new Group {
Name = "E"
});
await this.dbContext.SaveChangesAsync();
// Act
await teamsService.CreateTeam(new Team
{
Name = "Manchester United",
GroupId = 1,
ImageUrl = "test.jpg"
});
var teams = this.dbContext.Teams;
// Assert
Assert.AreEqual(1, teams.Count());
}
private GetTeamsResult GetTeamsResult(int leagueID, int sportID)
{
var result = new GetTeamsResult();
var dataCache = new DataCache();
var allTeams = TeamsService.GetInstance().GetTeams(sportID: sportID, dataCache: dataCache);
var teams = TeamsService.GetInstance().GetTeams(leagueID: leagueID, dataCache: dataCache);
result.Teams = teams.Select(t => new TeamsResult()
{
ID = t.ID,
Name = t.Name
}).ToList();
result.AvailableTeams = allTeams
.Where(t => !teams.Any(t1 => t1.ID == t.ID))
.GroupBy(t => new { t.ID, t.Name })
.Select(t => new TeamsResult()
{
ID = t.Key.ID,
Name = t.Key.Name
}).ToList();
return(result);
}
public MessagesController(TeamsService teamsService)
{
_teamsService = teamsService;
}
public TeamsController(IUsersService usersService)
{
_usersService = usersService;
_teamsService = new TeamsService();
}
public void TeamDetailsReturnTeamMatchesAndSetProperties()
{
var teamsList = new List <Team>()
{
new Team
{
Id = 1,
Name = "Real Madrid",
},
new Team
{
Id = 2,
Name = "Barcelona",
},
};
var matchList = new List <Match>()
{
new Match
{
HomeGoals = 1,
AwayGoals = 0,
HomeTeamId = 1,
AwayTeamId = 2,
GameweekId = 1,
},
new Match()
{
HomeGoals = 3,
AwayGoals = 3,
HomeTeamId = 4,
AwayTeamId = 5,
GameweekId = 2,
},
};
var teamRepo = new Mock <IDeletableEntityRepository <Team> >();
teamRepo.Setup(x => x.All()).Returns(teamsList.AsQueryable());
var matchRepo = new Mock <IDeletableEntityRepository <Match> >();
matchRepo.Setup(x => x.All()).Returns(matchList.AsQueryable());
var service = new TeamsService(teamRepo.Object, matchRepo.Object);
var team = service.TeamDetails(1);
var homeTeamName = team.Matches.Select(x => x.HomeName).FirstOrDefault();
var awayTeamName = team.Matches.Select(x => x.AwayName).FirstOrDefault();
var homeGoals = team.Matches.Select(x => x.HomeGoals).FirstOrDefault();
var awayGoals = team.Matches.Select(x => x.AwayGoals).FirstOrDefault();
var gameWeekId = team.Matches.Select(x => x.GameweekId).FirstOrDefault();
Assert.Equal(1, team.Id);
Assert.Equal("Real Madrid", team.Name);
Assert.Equal(1, team.Matches.Count());
Assert.Equal(1, homeGoals);
Assert.Equal(0, awayGoals);
Assert.Equal("Real Madrid", homeTeamName);
Assert.Equal("Barcelona", awayTeamName);
Assert.Equal(1, gameWeekId);
matchRepo.Verify(m => m.All(), Times.Once);
}
public void GetTeamLeagueWinnerShouldReturnCorrectResult()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "GetTeamLeagueWinner_TeamLeagues_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var leaguesService = new LeaguesService(dbContext, townsService);
var mockUserStore = new Mock <IUserStore <FooteoUser> >();
var userManager = new Mock <UserManager <FooteoUser> >(mockUserStore.Object, null, null, null, null, null, null, null, null);
var town = townsService.CreateTown("Sofia");
var user = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = $"*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = $"footeoPlayer",
Town = town,
PasswordHash = "123123",
Player = new Player
{
FullName = "Footeo Player"
}
};
dbContext.Users.Add(user);
dbContext.SaveChanges();
userManager.Setup(u => u.RemoveFromRoleAsync(user, "Player")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(user, "PlayerInTeam")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(user, "Captain")).Returns(Task.FromResult(IdentityResult.Success));
var user2 = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = $"*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = $"footeo",
Town = town,
PasswordHash = "123123",
Player = new Player
{
FullName = "Footeo User"
}
};
dbContext.Users.Add(user2);
dbContext.SaveChanges();
userManager.Setup(u => u.RemoveFromRoleAsync(user2, "Player")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(user2, "PlayerInTeam")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(user2, "Captain")).Returns(Task.FromResult(IdentityResult.Success));
var teamsService = new TeamsService(dbContext, townsService, leaguesService, userManager.Object, null);
teamsService.CreateTeam("Team", "TTT", user.UserName);
teamsService.CreateTeam("Team2", "TTT", user2.UserName);
var team = dbContext.Teams.FirstOrDefault(n => n.Name == "Team");
var team2 = dbContext.Teams.FirstOrDefault(n => n.Name == "Team2");
leaguesService.CreateLeague("League", "Desc", DateTime.UtcNow.AddDays(7), DateTime.UtcNow.AddMonths(2), "Sofia");
var league = dbContext.Leagues.FirstOrDefault(l => l.Name == "League");
var teamLeaguesService = new TeamLeaguesService(dbContext, teamsService, leaguesService);
teamLeaguesService.JoinLeague(user.UserName, league.Id);
teamLeaguesService.JoinLeague(user2.UserName, league.Id);
var teamLeague1 = dbContext.TeamsLeagues.FirstOrDefault(t => t.Team == team);
var teamLeague2 = dbContext.TeamsLeagues.FirstOrDefault(t => t.Team == team2);
teamLeague1.Points = 100;
teamLeague2.Points = 50;
dbContext.SaveChanges();
league.Status = LeagueStatus.Completed;
dbContext.SaveChanges();
var winner = teamLeaguesService.GetTeamLeagueWinner(league.Id);
Assert.AreEqual(winner.Team.Name, teamLeague1.Team.Name);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="teamsService"></param>
public TeamsController(TeamsService <TeamsViewModel, Team> teamsService)
{
_teamsService = teamsService;
}
public TeamsController(ILogger <TeamsController> logger, TeamsService teamsService)
{
_logger = logger;
_teamsService = teamsService;
}
public ActionResult List()
{
TeamsService teamsService = new TeamsService();
TeamsListVM model = new TeamsListVM();
TryUpdateModel(model);
model.Teams = teamsService.GetAll();
if (!String.IsNullOrEmpty(model.Search))
{
model.Teams = model.Teams.Where(t => t.Name.ToLower().Contains(model.Search.ToLower())).ToList();
}
switch (model.SortOrder)
{
case "name_desc":
model.Teams = model.Teams.OrderByDescending(t => t.Name).ToList();
break;
case "name_asc":
default:
model.Teams = model.Teams.OrderBy(t => t.Name).ToList();
break;
}
return View(model);
}
public void RefereeAttendToMatchShouldNotReturnNull()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "AttendToMatch_Referees_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var town = townsService.CreateTown("Burgas");
var user = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = $"*****@*****.**",
FirstName = "Footeo",
LastName = "Referee",
UserName = $"footeoReferee",
Town = town,
PasswordHash = "123123"
};
dbContext.Users.Add(user);
dbContext.SaveChanges();
var userHT = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = $"*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = $"footeoPlayer",
Town = town,
PasswordHash = "123123",
Player = new Player
{
FullName = "Footeo Player"
}
};
dbContext.Users.Add(userHT);
dbContext.SaveChanges();
var userAT = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = $"*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = $"footeoPlayer2",
Town = town,
PasswordHash = "123123",
Player = new Player
{
FullName = "Footeo Player"
}
};
dbContext.Users.Add(userAT);
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(userHT, "Player")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(userHT, "PlayerInTeam")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(userHT, "Captain")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.RemoveFromRoleAsync(userAT, "Player")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(userAT, "PlayerInTeam")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(userAT, "Captain")).Returns(Task.FromResult(IdentityResult.Success));
var fieldsService = new FieldsService(dbContext, townsService);
var leaguesService = new LeaguesService(dbContext, townsService);
var teamsService = new TeamsService(dbContext, townsService, leaguesService, userManager.Object, null);
var teamLeaguesService = new TeamLeaguesService(dbContext, teamsService, leaguesService);
var fixturesService = new FixturesService(dbContext, leaguesService);
var matchesService = new MatchesService(dbContext, fixturesService, teamsService);
var refereesService = new RefereesService(dbContext, matchesService, teamLeaguesService);
var referee = new Referee
{
FullName = $"Footeo Referee"
};
refereesService.CreateReferee(user, referee);
townsService.CreateTown("Sofia");
leaguesService.CreateLeague("League", "Desc", DateTime.UtcNow, DateTime.UtcNow.AddMonths(3), "Sofia");
teamsService.CreateTeam("Home Team", "HT", userHT.UserName);
teamsService.CreateTeam("Away Team", "AT", userAT.UserName);
var league = dbContext.Leagues.FirstOrDefault(n => n.Name == "League");
teamLeaguesService.JoinLeague(userHT.UserName, league.Id);
teamLeaguesService.JoinLeague(userAT.UserName, league.Id);
fixturesService.CreateFixture("Matchday", DateTime.UtcNow.AddDays(7), league.Id);
var fixture = dbContext.Fixtures.FirstOrDefault(n => n.Name == "Matchday");
fieldsService.CreateField("Field", "Address", true, "Sofia");
var field = dbContext.Fields.FirstOrDefault(n => n.Name == "Field");
matchesService.CreateMatch(userHT.Player.Team.Id, userAT.Player.Team.Id, field.Id, fixture.Id);
var match = dbContext.Matches.FirstOrDefault();
refereesService.AttendAMatch(user.UserName, match.Id);
Assert.NotNull(match.Referee);
}
public TeamsController(TeamsService ps)
{
_ps = ps;
}
public void GetSquadReturnPlayersToChosenTeamAndSetPropertiesCorectly()
{
var playersList = new List <Player>()
{
new Player
{
ShortName = "L.Messi",
ScoredGoals = 10,
MatchesPlayed = 1,
Age = 33,
DateOfBirth = DateTime.Parse("12/12/1986"),
HeightCm = 166,
WeightKg = 70,
Nationality = "Argentina",
TeamNumber = 10,
TeamId = 1,
},
new Player
{
ShortName = "C.Ronaldo",
ScoredGoals = 11,
MatchesPlayed = 2,
Age = 35,
DateOfBirth = DateTime.Parse("12/12/1984"),
HeightCm = 186,
WeightKg = 80,
Nationality = "Portugal",
TeamNumber = 7,
TeamId = 1,
},
};
var teamsList = new List <Team>()
{
new Team
{
Id = 1,
Name = "Real Madrid",
Players = playersList,
},
new Team
{
Id = 2,
Name = "Barcelona",
},
};
var teamRepo = new Mock <IDeletableEntityRepository <Team> >();
teamRepo.Setup(x => x.All()).Returns(teamsList.AsQueryable());
var matchRepo = new Mock <IDeletableEntityRepository <Match> >();
var service = new TeamsService(teamRepo.Object, matchRepo.Object);
var team = service.GetSquad(1);
var playerFirstName = team.Players.Select(x => x.ShortName).FirstOrDefault();
var playerSquadNumber = team.Players.Select(x => x.SquadNumber).FirstOrDefault();
var scoredGoals = team.Players.Select(x => x.ScoredGoals).FirstOrDefault();
var age = team.Players.Select(x => x.Age).FirstOrDefault();
var matchesPlayed = team.Players.Select(x => x.MatchesPlayed).FirstOrDefault();
var weight = team.Players.Select(x => x.WeightKg).FirstOrDefault();
var height = team.Players.Select(x => x.HeightCm).FirstOrDefault();
var dateOfBirth = team.Players.Select(x => x.DateOfBirth).FirstOrDefault();
var nationality = team.Players.Select(x => x.Nationality).FirstOrDefault();
Assert.Equal("Real Madrid", team.TeamName);
Assert.Equal(2, team.Players.Count());
Assert.Equal(7, playerSquadNumber);
Assert.Equal("C.Ronaldo", playerFirstName);
Assert.Equal(11, scoredGoals);
Assert.Equal(35, age);
Assert.Equal(2, matchesPlayed);
Assert.Equal(80, weight);
Assert.Equal(186, height);
Assert.Equal(DateTime.Parse("12/12/1984"), dateOfBirth);
Assert.Equal("Portugal", nationality);
}
public TeamsController(TeamsService ts)
{
_ts = ts;
}
public HomeController(TeamsService teamsService, TelemetryService telemetryService)
{
_teamsService = teamsService;
_telemetryService = telemetryService;
}
public void GetFreeTeamsWorksCorrectly(ServiceFrequency appointmentServiceFrequency, DateTime appointmentStartDate, DateTime appointmentEndDate, ServiceFrequency serviceFrequency, DateTime startDate, DateTime endDate, int expectedCount)
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
var dbContext = new ApplicationDbContext(options);
var week = appointmentStartDate.GetWeekOfMonth();
var repositoryMock = new Mock <IDeletableEntityRepository <Team> >();
repositoryMock.Setup(x => x.All())
.Returns(new List <Team>()
{
new Team()
{
Id = "1",
CityId = 1,
Services = new List <TeamService>()
{
new TeamService()
{
TeamId = "1",
ServiceId = 1,
},
},
Orders = new List <Order>()
{
new Order()
{
Id = "1",
ServiceFrequency = appointmentServiceFrequency,
Status = OrderStatus.Pending,
AppointmetnId = "1",
TeamId = "1",
Appointment = new Appointment()
{
Id = "1",
OrderId = "1",
DayOfWeek = (int)appointmentStartDate.DayOfWeek,
StartDate = appointmentStartDate,
EndDate = appointmentEndDate,
WeekOfMonth = appointmentStartDate.GetWeekOfMonth(),
},
},
},
TeamMembers = new List <ApplicationUser>()
{
new ApplicationUser()
{
Id = "1",
TeamId = "1",
},
},
},
}.AsQueryable());
var service = new TeamsService(repositoryMock.Object);
var result = service.GetFreeTeams <TeamServiceModel>(startDate, endDate, 1, 1, serviceFrequency);
Assert.Equal(expectedCount, result.Count());
}
public void GetTeamLeagueShouldNotReturnNull()
{
var options = new DbContextOptionsBuilder <FooteoDbContext>()
.UseInMemoryDatabase(databaseName: "GetTeamLeague_TeamLeagues_DB")
.Options;
var dbContext = new FooteoDbContext(options);
var townsService = new TownsService(dbContext);
var leaguesService = new LeaguesService(dbContext, townsService);
var mockUserStore = new Mock <IUserStore <FooteoUser> >();
var userManager = new Mock <UserManager <FooteoUser> >(mockUserStore.Object, null, null, null, null, null, null, null, null);
var town = townsService.CreateTown("Sofia");
var user = new FooteoUser
{
Age = new Random().Next(20, 30),
Email = $"*****@*****.**",
FirstName = "Footeo",
LastName = "Player",
UserName = $"footeoPlayer",
Town = town,
PasswordHash = "123123",
Player = new Player
{
FullName = "Footeo Player"
}
};
dbContext.Users.Add(user);
dbContext.SaveChanges();
userManager.Setup(u => u.RemoveFromRoleAsync(user, "Player")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(user, "PlayerInTeam")).Returns(Task.FromResult(IdentityResult.Success));
userManager.Setup(u => u.AddToRoleAsync(user, "Captain")).Returns(Task.FromResult(IdentityResult.Success));
var teamsService = new TeamsService(dbContext, townsService, leaguesService, userManager.Object, null);
teamsService.CreateTeam("Team", "TTT", user.UserName);
var team = dbContext.Teams.FirstOrDefault(n => n.Name == "Team");
leaguesService.CreateLeague("League", "Desc", DateTime.UtcNow.AddDays(7), DateTime.UtcNow.AddMonths(2), "Sofia");
var league = dbContext.Leagues.FirstOrDefault(l => l.Name == "League");
var teamLeague = new TeamLeague
{
Team = team,
League = league
};
dbContext.TeamsLeagues.Add(teamLeague);
dbContext.SaveChanges();
var teamLeaguesService = new TeamLeaguesService(dbContext, teamsService, leaguesService);
var teamLeagueModel = teamLeaguesService.GetTeamLeague(team.Id, league.Id);
Assert.NotNull(teamLeagueModel);
}
public TeamsController(TeamsService service)
{
this.service = service;
}
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 TeamsController(TeamsService teamService)
{
_teamService = teamService;
}
public void GetTotalGoldByPlayersShouldThrowArgumentNullExceptionIfGivenInvalidParticipants()
{
var service = new TeamsService();
Assert.Throws <ArgumentNullException>(() => service.GetTotalGoldByPlayers(new List <ParticipantIdentity>(), null, 100));
}
public AccountController()
{
_usersService = new UsersService();
_temsService = new TeamsService();
}
