public List <JudgeDto> GetJudges(string raceId, JudgePrincipal principal)
{
if (string.IsNullOrEmpty(raceId))
{
throw new ArgumentNullException("Missing RaceId");
}
var isAdmin = principal != null && principal.Judge.IsAdmin;
var judgesRepository = repositorySetProvider.GetRepositorySet(raceId).Judges;
var judges = new List <JudgeDto>();
foreach (var judge in judgesRepository.GetJudges())
{
var dto = new JudgeDto();
dto.JudgeId = judge.JudgeId;
dto.JudgeName = judge.Name;
dto.IsAdmin = judge.IsAdmin;
if (isAdmin)
{
dto.DeviceIds = new List <string>();
foreach (var judgeDevice in judgesRepository.FindJudgesDevices(judge.JudgeId))
{
dto.DeviceIds.Add(judgeDevice.DeviceId);
}
}
judges.Add(dto);
}
return(judges);
}
public AthleteDto GetAthlete(string raceId, string athleteId, JudgePrincipal principal)
{
if (string.IsNullOrEmpty(raceId))
{
throw new ArgumentNullException("Missing RaceId");
}
if (string.IsNullOrEmpty(athleteId))
{
throw new ArgumentNullException("Missing AthleteId");
}
var repositorySet = repositorySetProvider.GetRepositorySet(raceId);
var disciplines = repositorySet.Disciplines.GetDisciplines();
var isAuthenticated = principal != null;
var allowedAnnouncements = new HashSet <string>(disciplines.Where(d => d.AnnouncementsPublic || isAuthenticated).Select(d => d.DisciplineId));
var publicResults = new HashSet <string>(disciplines.Where(d => d.ResultsPublic).Select(d => d.DisciplineId));
var athlete = repositorySet.Athletes.FindAthlete(athleteId);
if (athlete == null)
{
throw new ArgumentOutOfRangeException("Unknown AthleteId " + athleteId);
}
AthleteDto athleteDto = new AthleteDto
{
Profile = BuildProfile(athlete),
Announcements = athlete.Announcements.Select(a => BuildAnnouncement(a, allowedAnnouncements.Contains(a.DisciplineId))).ToList(),
Results = GetVisibleResults(athlete.ActualResults, principal, publicResults).Select(BuildActualResult).ToList()
};
return(athleteDto);
}
public JudgeDto Verify(string raceId, JudgePrincipal principal)
{
return(new JudgeDto
{
JudgeId = principal.Judge.JudgeId,
JudgeName = principal.Judge.Name,
IsAdmin = principal.Judge.IsAdmin
});
}
public void RegularJudgeProperties()
{
var judge = new Judge
{
JudgeId = "judge01",
Name = "Peter Just"
};
var principal = new JudgePrincipal(judge);
Assert.That(principal.Judge, Is.SameAs(judge));
Assert.That(principal.Identity.IsAuthenticated, Is.True);
Assert.That(principal.Identity.Name, Is.EqualTo(judge.Name));
Assert.That(principal.Identity.AuthenticationType, Is.Not.Empty.Or.Null);
Assert.That(principal.IsInRole("Admin"), Is.False);
Assert.That(principal.IsInRole("Judge"), Is.True);
}
public void AdminJudgeProperties()
{
var judge = new Judge
{
IsAdmin = true,
JudgeId = "adm0",
Name = "John Admin Specialist"
};
var principal = new JudgePrincipal(judge);
Assert.That(principal.Judge, Is.SameAs(judge));
Assert.That(principal.Identity.IsAuthenticated, Is.True);
Assert.That(principal.Identity.Name, Is.EqualTo(judge.Name));
Assert.That(principal.Identity.AuthenticationType, Is.Not.Empty.Or.Null);
Assert.That(principal.IsInRole("Admin"), Is.True);
Assert.That(principal.IsInRole("Judge"), Is.True);
}
public List <AthleteDto> GetAthletes(string raceId, JudgePrincipal principal)
{
if (string.IsNullOrEmpty(raceId))
{
throw new ArgumentNullException("Missing RaceId");
}
var repositorySet = repositorySetProvider.GetRepositorySet(raceId);
var disciplines = repositorySet.Disciplines.GetDisciplines();
var isAuthenticated = principal != null;
var allowedAnnouncements = new HashSet <string>(disciplines.Where(d => d.AnnouncementsPublic || isAuthenticated).Select(d => d.DisciplineId));
var publicResults = new HashSet <string>(disciplines.Where(d => d.ResultsPublic).Select(d => d.DisciplineId));
var athletes = repositorySet.Athletes.GetAthletes();
return(athletes.OrderBy(a => a.Surname).ThenBy(a => a.FirstName).Select(athlete => new AthleteDto
{
Profile = BuildProfile(athlete),
Announcements = athlete.Announcements.Select(a => BuildAnnouncement(a, allowedAnnouncements.Contains(a.DisciplineId))).ToList(),
Results = GetVisibleResults(athlete.ActualResults, principal, publicResults).Select(BuildActualResult).ToList()
}).ToList());
}
private static List <ActualResult> GetVisibleResults(List <ActualResult> allResults, JudgePrincipal principal, ICollection <string> publicDisciplines)
{
if (principal != null && principal.Judge.IsAdmin)
{
return(allResults);
}
var shownResults = new Dictionary <string, ActualResult>(allResults.Count);
foreach (var result in allResults)
{
if (principal == null && !publicDisciplines.Contains(result.DisciplineId))
{
continue; // hidden from public eyes
}
shownResults[result.DisciplineId] = result;
}
return(shownResults.Values.ToList());
}
public StartingListReport GetReportStartingList(string raceId, string startingLaneId, JudgePrincipal principal)
{
if (string.IsNullOrEmpty(raceId))
{
throw new ArgumentNullException("Missing RaceId");
}
IRepositorySet repositorySet = repositorySetProvider.GetRepositorySet(raceId);
var rootStartingLanes = repositorySet.StartingLanes.GetStartingLanes();
var titleSource = flattener.GetParent(rootStartingLanes, startingLaneId);
var allowedStartingLanes = flattener.GetLeaves(rootStartingLanes, startingLaneId).ToDictionary(s => s.StartingLaneId);
var athletes = repositorySet.Athletes.GetAthletes().ToDictionary(a => a.AthleteId);
var disciplines = repositorySet.Disciplines.GetDisciplines().ToDictionary(d => d.DisciplineId);
var startingList = repositorySet.StartingList.GetStartingList();
var judges = repositorySet.Judges.GetJudges().ToDictionary(j => j.JudgeId);
var isAuthenticated = principal != null;
var report = new StartingListReport();
report.Title = BuildStartingListTitle(titleSource);
report.Entries = new List <StartingListReportEntry>();
foreach (var startingListEntry in startingList)
{
Athlete athlete;
Discipline discipline;
StartingLaneFlat startingLane;
Judge judge = null;
if (!athletes.TryGetValue(startingListEntry.AthleteId, out athlete))
{
continue; // athlete not found, give up
}
if (!disciplines.TryGetValue(startingListEntry.DisciplineId, out discipline))
{
continue; // discipline does not exist, give up
}
if (!allowedStartingLanes.TryGetValue(startingListEntry.StartingLaneId, out startingLane))
{
continue; // not showing this lane, skip
}
Announcement announcement = athlete.Announcements.FirstOrDefault(a => a.DisciplineId == startingListEntry.DisciplineId);
ActualResult latestResult = athlete.ActualResults.LastOrDefault(r => r.DisciplineId == startingListEntry.DisciplineId);
if (latestResult != null)
{
judges.TryGetValue(latestResult.JudgeId, out judge);
}
var allowAnnouncement = isAuthenticated || discipline.AnnouncementsPublic;
var allowResult = isAuthenticated || discipline.ResultsPublic;
StartingListReportEntry entry = new StartingListReportEntry();
entry.Announcement = allowAnnouncement ? BuildReportAnnouncement(announcement) : null;
entry.Athlete = ApiAthlete.BuildProfile(athlete);
entry.CurrentResult = allowResult ? BuildReportActualResult(latestResult, judge) : null;
entry.Discipline = BuildReportDiscipline(discipline);
entry.Start = BuildReportStart(startingListEntry, startingLane);
report.Entries.Add(entry);
}
report.Entries.Sort(CompareStartingListEntries);
return(report);
}
public ResultsListReport GetReportResultsList(string raceId, string resultsListId, JudgePrincipal principal)
{
if (string.IsNullOrEmpty(raceId))
{
throw new ArgumentNullException("Missing RaceId");
}
if (string.IsNullOrEmpty(resultsListId))
{
throw new ArgumentNullException("Missing ResultsListId");
}
IRepositorySet repositorySet = repositorySetProvider.GetRepositorySet(raceId);
var isAuthenticated = principal != null;
var resultsList = repositorySet.ResultsLists.FindResultsList(resultsListId);
if (resultsList == null)
{
throw new ArgumentOutOfRangeException("Wrong ResultsListId");
}
var disciplines = repositorySet.Disciplines.GetDisciplines().ToDictionary(d => d.DisciplineId);
var columns = new List <ResultsListColumn>();
var sortingIndex = -1;
foreach (var columnSource in resultsList.Columns)
{
ResultsListColumn column = new ResultsListColumn(columnSource.Title, columnSource.IsFinal, isAuthenticated);
foreach (var component in columnSource.Components)
{
Discipline discipline;
if (!disciplines.TryGetValue(component.DisciplineId, out discipline))
{
continue;
}
IRules rules = rulesProvider.Get(discipline.Rules);
column.AddComponent(discipline, rules, component.FinalPointsCoeficient ?? 1.0);
}
if (column.IsSortingColumn)
{
sortingIndex = columns.Count;
}
columns.Add(column);
}
var athletes = repositorySet.Athletes.GetAthletes();
var entries = new List <ResultsListReportEntry>();
foreach (var athlete in athletes)
{
if (columns.Any(c => c.IsParticipating(athlete)))
{
entries.Add(new ResultsListReportEntry
{
Athlete = ApiAthlete.BuildProfile(athlete),
Subresults = columns.Select(c => c.BuildSubresult(athlete)).ToList()
});
}
}
if (sortingIndex >= 0)
{
entries.Sort(new ResultsListReportEntryComparer(columns[sortingIndex].SortingComparer, sortingIndex));
}
return(new ResultsListReport
{
Metadata = new ResultsListMetadata
{
Title = resultsList.Title,
ResultsListId = resultsList.ResultsListId,
Columns = columns.Select(c => c.Metadata).ToList()
},
Results = entries
});
}
public ResultsListReport GetReportDisciplineResults(string raceId, string disciplineId, JudgePrincipal principal)
{
if (string.IsNullOrEmpty(raceId))
{
throw new ArgumentNullException("Missing RaceId");
}
if (string.IsNullOrEmpty(disciplineId))
{
throw new ArgumentNullException("Missing DisciplineId");
}
IRepositorySet repositorySet = repositorySetProvider.GetRepositorySet(raceId);
var discipline = repositorySet.Disciplines.FindDiscipline(disciplineId);
if (discipline == null)
{
throw new ArgumentOutOfRangeException("Unknown DisciplineId " + disciplineId);
}
var rules = rulesProvider.Get(discipline.Rules);
if (rules == null)
{
throw new ArgumentOutOfRangeException("Unknown DisciplineRules " + discipline.Rules);
}
var athletes = repositorySet.Athletes.GetAthletes();
var judges = repositorySet.Judges.GetJudges();
var allowAnnouncement = principal != null || discipline.AnnouncementsPublic;
var allowResult = principal != null || discipline.ResultsPublic;
var entries = new List <ResultsListReportEntry>();
foreach (var athlete in athletes)
{
var announcement = athlete.Announcements.FirstOrDefault(a => a.DisciplineId == disciplineId);
var actualResult = athlete.ActualResults.LastOrDefault(r => r.DisciplineId == disciplineId);
if (announcement == null)
{
continue; // does not compete in this discipline, skip
}
var judge = actualResult == null ? null : judges.FirstOrDefault(j => j.JudgeId == actualResult.JudgeId);
var entry = new ResultsListReportEntry();
entry.Athlete = ApiAthlete.BuildProfile(athlete);
entry.Subresults = new List <ResultsListReportEntrySubresult>();
var subresult = new ResultsListReportEntrySubresult();
if (allowAnnouncement)
{
subresult.Announcement = BuildReportAnnouncement(announcement);
}
if (allowResult)
{
subresult.CurrentResult = BuildReportActualResult(actualResult, judge);
subresult.FinalPoints = subresult.CurrentResult?.FinalPerformance?.Points;
}
entry.Subresults.Add(subresult);
entries.Add(entry);
}
entries.Sort(new ResultsListReportEntryComparer(rules.ResultsComparer, 0));
return(new ResultsListReport
{
Metadata = BuildDisciplineReportMetadata(discipline, rules),
Results = entries
});
}