public async Task <IReadOnlyList <IReadOnlyList <DrawCompetitor> > > GroupAsync(Distance distance, IEnumerable <Guid> distanceCombinations, int round,
                                                                                        DistanceDrawSettings settings,
                                                                                        params IHistoricalTimeSelector[] selectors)
        {
            if (distance == null)
            {
                throw new ArgumentNullException(nameof(distance));
            }
            if (distanceCombinations == null)
            {
                throw new ArgumentNullException(nameof(distanceCombinations));
            }
            if (round < 1)
            {
                throw new ArgumentOutOfRangeException(nameof(round));
            }

            Debug.Assert(distance.Competition != null);

            var distanceExpert = distanceExpertManager.Find(distance.Discipline);

            if (distanceExpert == null)
            {
                throw new InvalidDisciplineException();
            }

            var confirmedCompetitors = ConfirmedCompetitors(distance, distanceCombinations, round);
            var roundCompetitors     = await distanceExpert.SelectCompetitorsForRound(distance, round, confirmedCompetitors).ToListAsync();

            var drawCompetitors = new List <DrawCompetitor>();

            switch (settings.GroupMode)
            {
            case DistanceDrawGroupMode.Category:
                drawCompetitors.AddRange(roundCompetitors.Select(rc => new DrawCompetitor(rc, null)));
                break;

            case DistanceDrawGroupMode.Time:
                foreach (var competitor in roundCompetitors)
                {
                    var personCompetitor    = competitor as PersonCompetitor;
                    IPersonLicenseTime time = null;
                    if (personCompetitor != null)
                    {
                        time = await personTimesWorkflow.FindHistoricalTimeAsync(distance.Competition.LicenseIssuerId, distance.Competition.Discipline, distance.Discipline, distance.Value, competitor.LicenseKey, selectors);
                    }
                    drawCompetitors.Add(new DrawCompetitor(competitor, time));
                }
                break;
            }

            var categories = await context.PersonCategories
                             .Where(c => c.LicenseIssuerId == distance.Competition.LicenseIssuerId && c.Discipline == distance.Competition.Discipline).ToListAsync();

            var sortedDrawCompetitors = distanceExpert.SortDrawCompetitors(distance, drawCompetitors, settings, categories).ToList();

            return(distanceExpert.GroupDrawCompetitors(distance, round, sortedDrawCompetitors, settings));
        }
Esempio n. 2
0
 public DrawCompetitor(CompetitorBase competitor, IPersonLicenseTime time)
 {
     Competitor = competitor;
     Time       = time;
 }