/// <summary>
/// 获取阵容信息
/// </summary>
public int Call_TeamList(TeamRequest request)
{
TeamResponse response = new TeamResponse();
response.success = true;
response.pid = CurrentSession.UserId;
response.teams5 = new List <TeamInfo>();
response.teams10 = new List <TeamInfo>();
var player = this.CurrentSession.GetBindPlayer();
foreach (var team in player.Teams)
{
TeamInfo ti = new TeamInfo();
ti.selected = team.IsSelected;
ti.id = team.Id;
ti.bps = team.Units.Object;
response.teams5.Add(ti);
}
foreach (var f in player.Formations)
{
TeamInfo ti = new TeamInfo();
ti.selected = f.IsSelected;
ti.id = f.Id;
ti.bps = f.Units.Object;
response.teams10.Add(ti);
}
CurrentSession.SendAsync(response);
return(0);
}
private async Task <IEnumerable <Player> > GetPlayersByElementTypeAsync(ElementType elementType)
{
var fplApiClient = new WebApiClient();
StaticResponse staticResponse = await fplApiClient.GetStaticAsync();
var pickedElementIds = new HashSet <int>();
if (staticResponse.CurrentEvent > 0)
{
TeamResponse teamResponse = await fplApiClient.GetTeamAsync(MyTeamId, staticResponse.CurrentEvent);
pickedElementIds = new HashSet <int>(teamResponse.Picks.Select(p => p.ElementId));
}
double minimumMinutesRatio = 0.2d;
double totalMinutes = staticResponse.CurrentEvent * 90;
double minimumMinutesPlayed = totalMinutes * minimumMinutesRatio;
Dictionary <int, string> teamNamesById = staticResponse.Teams.ToDictionary(
t => t.Id,
t => t.Name);
IEnumerable <Element> elements = staticResponse.Elements
.Where(e => e.ElementType == (int)elementType)
.Where(e => e.Minutes >= minimumMinutesPlayed);
IEnumerable <Player> players = elements.Select(
e => Player.FromElement(e, teamNamesById, pickedElementIds.Contains(e.Id)));
return(players);
}
/// <summary>
/// Get Team details by Team name
/// </summary>
/// <param name="projectName"></param>
/// <param name="teamaName"></param>
/// <returns></returns>
public TeamResponse GetTeamByName(string projectName, string teamaName)
{
TeamResponse viewModel = new TeamResponse();
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(_configuration.UriString);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _credentials);
HttpResponseMessage response = client.GetAsync("_apis/projects/" + projectName + "/teams/" + teamaName + "?api-version=2.2").Result;
if (response.IsSuccessStatusCode)
{
viewModel = response.Content.ReadAsAsync <TeamResponse>().Result;
return(viewModel);
}
else
{
var errorMessage = response.Content.ReadAsStringAsync();
string error = Utility.GeterroMessage(errorMessage.Result.ToString());
this.lastFailureMessage = error;
return(new TeamResponse());
}
}
}
public void GetById_should_handle_exception()
{
// Arrange
BaseMock.ShouldThrowException = true;
TeamRequest request = new()
{
Id = 3
};
TeamResponse expected = new()
{
Status = new BaseResponse {
Code = Code.UnknownError, ErrorMessage = "An error occured while loading team data"
}
};
LogData expectedLog = new()
{
CallSide = nameof(TeamsService),
CallerMethodName = nameof(_teamsService.GetById),
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
Request = request,
Response = new Exception("Test exception")
};
// Act
TeamResponse actual = _teamsService.GetById(request, null).Result;
// Assert
Assert.AreEqual(expected, actual, "Excpetion handled");
_loggerMock.Verify(m => m.AddErrorLog(expectedLog), Times.Once);
}
[Test]
public void GetById_should_handle_not_found_team_response_from_repository()
{
// Arrange
TeamRequest request = new()
{
Id = 3
};
TeamResponse expected = new()
{
Status = new BaseResponse {
Code = Code.DataError, ErrorMessage = "Requested team not found"
}
};
LogData expectedLog = new()
{
CallSide = nameof(TeamsService),
CallerMethodName = nameof(_teamsService.GetById),
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
Request = request,
Response = expected
};
// Act
TeamResponse actual = _teamsService.GetById(request, null).Result;
// Assert
Assert.AreEqual(expected, actual, "Not found team response handled");
_loggerMock.Verify(m => m.AddLog(expectedLog), Times.Once);
}
[Test]
public TeamDetail GetTeamDetailByTeamResponse(IStat stat, TeamResponse team, IList <StatResponse> matchStats)
{
var teamDetail = new TeamDetail {
TeamInfo = team
};
var teamTotalAge = 0;
var teamStats = new StatResponse();
var players = matchStats.Where(p => p.TeamId == team.Id).Select(p => p.Player).ToList();
foreach (var player in players)
{
var playerStat = stat.GetPlayerStatByMatchIdAndTeamId(player.Id, team.Id, matchStats);
if (playerStat == null)
{
continue;
}
teamStats = stat.AddPlayerStatToTeamStats(teamStats, playerStat);
teamDetail.PlayerStats.Add(new PlayerMatchStat {
Player = player, Stat = playerStat
});
teamTotalAge = teamTotalAge + player.BirthDate.GetAge();
}
teamDetail.AgeRatio = ConvertFunctions.GetTeamAgeRatio(players.Count, teamTotalAge);
teamDetail.TeamStats = teamStats;
return(teamDetail);
}
public IActionResult UpdateTeam(Guid teamId, [FromBody] TeamResponse team)
{
if (!ModelState.IsValid)
{
return(StatusCode(400, "Model is not valid"));
}
try
{
var newTeam = mapper.Map <TeamDto>(team);
newTeam.TeamId = teamId;
var updated = teamService.UpdateTeam(newTeam);
if (updated)
{
return(StatusCode(201, "Task was updated"));
}
else
{
return(StatusCode(404, "Task not found"));
}
}
catch (Exception)
{
return(StatusCode(500));
}
}
private void CreateTestTeamMember()
{
var route4Me = new Route4MeManagerV5(ActualApiKey);
int?ownerId = GetOwnerMemberId();
if (ownerId == null)
{
return;
}
var newMemberParameters = new TeamRequest()
{
NewPassword = testPassword,
MemberFirstName = "John",
MemberLastName = "Doe",
MemberCompany = "Test Member To Remove",
MemberEmail = GetTestEmail(),
OwnerMemberId = (int)ownerId
};
newMemberParameters.SetMemberType(MemberTypes.Driver);
TeamResponse member = route4Me.CreateTeamMember(newMemberParameters,
out ResultResponse resultResponse);
if (member != null && member.GetType() == typeof(TeamResponse))
{
membersToRemove.Add(member);
}
}
/// <summary>
/// Get Team details by Team name
/// </summary>
/// <param name="projectName"></param>
/// <param name="teamaName"></param>
/// <returns></returns>
public TeamResponse GetTeamByName(string projectName, string teamaName)
{
try
{
TeamResponse viewModel = new TeamResponse();
using (var client = GetHttpClient())
{
HttpResponseMessage response = client.GetAsync("_apis/projects/" + projectName + "/teams/" + teamaName + "?api-version=" + _configuration.VersionNumber).Result;
if (response.IsSuccessStatusCode)
{
viewModel = response.Content.ReadAsAsync <TeamResponse>().Result;
return(viewModel);
}
else
{
logger.Debug(DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss") + "\t GetTeamByName \t" + response.Content.ReadAsStringAsync().Result);
var errorMessage = response.Content.ReadAsStringAsync();
string error = Utility.GeterroMessage(errorMessage.Result.ToString());
this.LastFailureMessage = error;
}
}
}
catch (Exception ex)
{
logger.Debug(DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss") + "\t GetTeamByName \t" + ex.Message + "\t" + "\n" + ex.StackTrace + "\n");
}
return(new TeamResponse());
}
public List <TeamResponse> GetChampionshipInfo(int Id)
{
List <TeamResponse> listOfTeams = new List <TeamResponse>();
var ifExist = context.ChampionshipTeam.Any(e => e.IdChampionship == Id);
if (ifExist == false)
{
return(null);
}
var listOfId = context.ChampionshipTeam.Where(e => e.IdChampionship == Id).Select(e => e.IdTeam).ToList();
foreach (var item in listOfId)
{
var teamName = context.Team.FirstOrDefault(e => e.IdTeam == item);
var score = context.ChampionshipTeam.FirstOrDefault(e => e.IdTeam == item);
var teamResponse = new TeamResponse()
{
Score = score.Score,
TeamName = teamName.TeamName
};
listOfTeams.Add(teamResponse);
}
return(listOfTeams);
}
public void GetTeamUsers(TeamRequest request, TeamResponse response)
{
var xRefTeamUser = _uow.Repository <XRefTeamUserEntity>().GetOverview();
var user = _uow.Repository <UserEntity>().GetOverview();
var role = _uow.Repository <RoleEntity>().GetOverview();
var tasks = _uow.Repository <TaskEntity>().GetOverview();
var teamUsers = (from x in xRefTeamUser
join u in user
on x.UserId equals u.Id
join r in role
on x.RoleId equals r.RoleId
where x.TeamId == request.TeamId
select new User
{
UserId = u.Id,
UserName = u.UserName,
UserRole = r.RoleName,
Me = request.UserId == x.UserId ? true : false,
CountTasks = tasks.Where(t => t.UserId == u.Id && t.TeamId == request.TeamId).Count()
}).ToList();
if (teamUsers != null)
{
response.TeamUsers = teamUsers;
}
}
public TeamResponseViewModel(TeamResponse response)
{
ParticipantCount = response.ParticipantCount;
Event = response.Event;
EventId = response.EventId;
TeamName = response.Team?.Name;
ExternalFileUrl = response.FileUrl;
}
public ActionResult DeleteTeam(string name)
{
var teams = _league.GetAllTeams();
TeamResponse team = new TeamResponse();
team.NewTeam = (Team)teams.ResponseType.FirstOrDefault(t => t.Name == name);
return(View(team));
}
public void GetTeamById(TeamRequest request, TeamResponse response)
{
var team = _uow.Repository <TeamEntity>().GetOverview(x => x.TeamId == request.TeamId).FirstOrDefault();
if (team != null)
{
response.Team = _mapper.Map <TeamVM>(team);
}
}
internal Team FromTeam(TeamResponse result)
{
var x = new Team();
var temp = result.Links.Self.Href.Split('/');
x.ApiId = Int32.Parse(temp[temp.Length - 1]);
x.Name = result.Name;
x.LogoURI = result.CrestUrl;
return x;
}
internal Team FromTeam(TeamResponse result)
{
var x = new Team();
var temp = result.Links.Self.Href.Split('/');
x.ApiId = Int32.Parse(temp[temp.Length - 1]);
x.Name = result.Name;
x.LogoURI = result.CrestUrl;
return(x);
}
public async Task <IHttpActionResult> YearWizardInfo()
{
int currYear = this.CurrentYear;
var teams = await this.Db.teamyeardatas.Include(x => x.team).Include(x => x.year).Where(x => x.year.value >= currYear - 2).ToListAsync();
var sortedUniqueTeams = teams.Where(x => x.team.validTeam).OrderByDescending(x => x.year.value).GroupBy(x => x.team.id).Select(x => x.First()).Select(x => x.team);
return(Ok(new { teams = sortedUniqueTeams.Select(x => TeamResponse.From(x)) }));
}
public TeamResponse GetTeamById(TeamRequest request)
{
var response = new TeamResponse();
RunCode(MethodBase.GetCurrentMethod().Name, request, response, (uow) =>
{
_manager.GetTeamById(request, response);
});
return(response);
}
public async Task <TeamResponse> CreateTeam(TeamRequest request)
{
var response = new TeamResponse();
await RunCodeAsync(MethodBase.GetCurrentMethod().Name, request, response, async (uow) =>
{
await _manager.CreateTeam(request, response);
});
return(response);
}
public async Task <IActionResult> GetTeam([FromRoute] Guid teamId)
{
try
{
var projection = await _teamQueryHandler.GetTeamAsync(teamId);
return(Ok(TeamResponse.From(projection)));
}
catch
{
return(NotFound());
}
}
public void CanMapTeamToTeamResponse()
{
var domainTeam = TestHelpers.CreateTeam().ToDomain();
var expectedResponse = new TeamResponse
{
Id = domainTeam.Id,
Context = domainTeam.Context,
Name = domainTeam.Name
};
domainTeam.ToResponse().Should().BeEquivalentTo(expectedResponse);
}
public async Task <IEnumerable <Data.Models.Team> > MapAsync(TeamResponse source)
{
var teams = new List <Data.Models.Team>();
foreach (var c in source.Teams)
{
teams.Add(new Data.Models.Team
{
OpenFootyId = c.Id,
Name = c.Name,
BookieName = c.ShortName,
Badge = c.CrestUrl
});
}
return(await Task.FromResult(teams));
}
public static Team MapTeam(TeamResponse team)
{
return(new Team
{
BaronKills = team.BaronKills,
DominionVictoryScore = team.DominionVictoryScore,
DragonKills = team.DragonKills,
FirstBaron = team.FirstBaron,
FirstBlood = team.FirstBlood,
FirstDragon = team.FirstDragon,
InhibitorKills = team.InhibitorKills,
TeamId = team.TeamId,
TowerKills = team.TowerKills,
VilemaxKills = team.VilemawKills,
Winner = team.Winner
});
}
public TeamResponse MapModelToResponse(Team team)
{
if (team == null)
{
return(null);
}
var teamResponse = new TeamResponse
{
Id = team.Id,
Name = team.Name,
AuthorId = team.AuthorId,
Description = team.Description,
Image = team.Image,
};
return(teamResponse);
}
public static DbTeam ToDbTeam(TeamResponse teamResponse)
{
var teamAlternateNames = new List <DbTeamAlternateName>();
if (!string.IsNullOrWhiteSpace(teamResponse.ShortName))
{
teamAlternateNames.Add(new DbTeamAlternateName
{
TeamId = teamResponse.Id,
AlternateName = teamResponse.ShortName
});
} // fix: dla przypisania wartości null jako AltName w bd, wtedy DataManager używając Selectmany miałby puste wartości, co spowodowałoby NullReferenceException przy próbach pobrania właściwości
return(new DbTeam
{
Id = teamResponse.Id,
Name = teamResponse.Name,
TeamAlternateNames = teamAlternateNames
});
}
public IHttpActionResult GetDataForYear(int year)
{
if (year < 1999 || year > DateTimeOffset.UtcNow.Year)
{
return(BadRequest("year not in valid range"));
}
this.Db.Configuration.ProxyCreationEnabled = false;
// TODO: Invalid players might need to be added to this (no shows, etc)
var yearDataWithPlayerForYear = this.Db.playeryeardatas.Include(p => p.player).AsNoTracking().Where(x => x.year.value == year).ToList();
var weeksForYear = this.Db.weeks.Where(w => w.year.value == year).Include(w => w.course).AsNoTracking().ToList();
var teamsForYear = this.Db.teams.AsNoTracking().Where(x => x.playeryeardatas.Any(y => y.year.value == year)).ToList();
var leaderboards = this.Db.leaderboards.AsNoTracking().ToList();
var pairings = this.Db.pairings.AsNoTracking().ToList();
var leaderBoardDataForYear = this.Db.leaderboarddatas.AsNoTracking().Where(x => x.year.value == year).ToList();
var courses = weeksForYear.Select(w => w.course).GroupBy(c => c.id).Select(g => g.First());
var teamMatchupsForYear = this.Db.teammatchups
.Include(x => x.teams)
.Include(x => x.matches)
.Include("matches.results")
.Where(x => x.week.year.value == year).ToList()
.GroupBy(x => x.weekId, x => x, (key, value) => value.OrderBy(x => x.matchOrder))
.SelectMany(x => x);
var dby = new DataByYear
{
PlayersForYear = yearDataWithPlayerForYear.Select(x => PlayerResponse.From(x)).ToList(),
LeaderboardDataForYear = leaderBoardDataForYear.Select(x => LeaderBoardDataResponse.From(x)).ToList(),
Leaderboards = leaderboards.Select(x => new LeaderBoardResponse(x)).ToList(),
TeamsForYear = teamsForYear.Select(x => TeamResponse.From(x)).ToList(),
TeamMatchups = teamMatchupsForYear.Select(x => TeamMatchupResponse.From(x)).ToList(),
Courses = courses.Select(x => CourseResponse.From(x)).ToList(),
Weeks = weeksForYear.Select(x => new WeekResponse(x)).ToList(),
Pairings = pairings
};
return(Ok(dby));
}
public ScheduleWeek(week w, GroupedPlayoffMatchup playoffMatchup, bool includeMatches = false)
: base(w)
{
this.TeamMatchups =
w.teammatchups.Select(x => includeMatches ? new TeamMatchupWithResults(x) : new ScheduleTeamMatchup(x)).OrderBy(x => x.MatchOrder).ToList();
this.Course = CourseResponse.From(w.course);
this.Pairing = w.pairing.pairingText;
if (playoffMatchup != null)
{
this.PlayoffMatchups = playoffMatchup.PlayoffMatchups.Select(y =>
new
{
team1 = TeamResponse.From(y.Team1),
team2 = TeamResponse.From(y.Team2),
team1Seed = y.Team1Seed,
team2Seed = y.Team2Seed,
playoffType = y.PlayoffType
});
}
}
//this returns seasons populated down to the category level.
public async Task <BindableCollection <Season> > GetSortedSeasons()
{
TeamResponse response = await ServiceAccessor.GetTeams();
if (response.status == SERVICE_RESPONSE.SUCCESS)
{
BindableCollection <Team> teams = response.teams;
BindableCollection <Season> seasons = new BindableCollection <Season>();
foreach (Team team in teams)
{
BindableCollection <Season> teamSeason = await GetPopulatedSeasons(team);
if (teamSeason != null)
{
seasons.AddRange(teamSeason);
}
}
return(new BindableCollection <Season>(seasons.OrderByDescending(s => s.year)));
}
return(null);
}
public void GetById_should_return_response_from_grpc_client()
{
// Arrange
TeamRequest request = new()
{
Id = 1
};
TeamResponse response = new()
{
Status = new BaseResponse {
Code = Code.Success, ErrorMessage = string.Empty
},
Data = new TeamData {
Id = 1, Name = "test", Description = "test", CreatedOn = Timestamp.FromDateTime(_dateTimeUtil.GetCurrentDateTime())
}
};
BaseMock.Response = response;
LogData expectedLog = new()
{
CallSide = nameof(TeamsController),
CallerMethodName = nameof(_teamsController.GetById),
CreatedOn = _dateTimeUtil.GetCurrentDateTime(),
Request = request,
Response = response
};
// Act
ObjectResult actual = _teamsController.GetById(request.Id) as ObjectResult;
TeamResponse actualData = actual.Value as TeamResponse;
// Assert
Assert.AreEqual(200, actual.StatusCode, "StatusCode as expected");
Assert.AreEqual(response, actualData, "Response data as expected");
_loggerMock.Verify(m => m.AddLog(expectedLog), Times.Once);
_teamsClientMock.Verify(m => m.GetById(request, null, null, new CancellationToken()), Times.Once);
}
[Test]
public async Task CreateTeam(TeamRequest request, TeamResponse response)
{
response.Errors = Validator.CreateTeam(request.Team);
if (response.Errors.Count() > 0)
{
return;
}
var teamDb = _uow.Repository <TeamEntity>().GetOverview(t => t.TeamName == request.Team.TeamName).FirstOrDefault();
if (teamDb != null)
{
response.Errors.Add("teamname", $"Team with name {request.Team.TeamName} already exist.");
return;
}
var newTeam = _mapper.Map <TeamEntity>(request.Team);
_uow.Repository <TeamEntity>().Add(newTeam);
_uow.Save();
var newXrefTeamUser = new XRefTeamUserEntity {
TeamId = newTeam.TeamId, UserId = request.UserId, RoleId = (int)Enums.Role.SCRUM_MASTER
};
_uow.Repository <XRefTeamUserEntity>().Add(newXrefTeamUser);
_uow.Save();
var backlog = new BacklogEntity {
TeamId = newTeam.TeamId
};
_uow.Repository <BacklogEntity>().Add(backlog);
_uow.Save();
var user = _uow.Repository <UserEntity>().GetOverview(u => u.Id == request.UserId).FirstOrDefault();
var userTeams = _uow.Repository <XRefTeamUserEntity>().GetOverview(u => u.UserId == user.Id).Select(t => t.TeamId).ToArray();
response.Token = await user.GenerateJwtToken(_configuration, userTeams);
response.Team = _mapper.Map <TeamVM>(newTeam);
}
public async Task <IEnumerable <Player> > GetPickedPlayersAsync()
{
var fplApiClient = new WebApiClient();
StaticResponse staticResponse = await fplApiClient.GetStaticAsync();
var pickedElementIds = new HashSet <int>();
if (staticResponse.CurrentEvent > 0)
{
TeamResponse teamResponse = await fplApiClient.GetTeamAsync(MyTeamId, staticResponse.CurrentEvent);
pickedElementIds = new HashSet <int>(teamResponse.Picks.Select(p => p.ElementId));
}
Dictionary <int, string> teamNamesById = staticResponse.Teams.ToDictionary(
t => t.Id,
t => t.Name);
IEnumerable <Element> pickedElements = staticResponse.Elements.Where(e => pickedElementIds.Contains(e.Id));
IEnumerable <Player> players = pickedElements.Select(
e => Player.FromElement(e, teamNamesById, true));
return(players);
}
