コード例 #1
0
        private static IPaginate <Tour> QueryForAllPlayers(
            ToursQuery request,
            IRepositoryReadOnly <Tour> toursRepo,
            Expression <Func <Tour, bool> > predicate)
        {
            if (request.QueryType == ToursQueryType.All)
            {
                return(toursRepo.GetList(predicate));
            }
            //todo:: valdiate data
            int size = request.QueryType == ToursQueryType.Last ? (int)request.Last : 1;

            if (request.SeasonsId != null &&
                request.SeasonsId.Length != 0)
            {
                var tours = new List <Tour>();

                foreach (var seasonId in request.SeasonsId)
                {
                    var toursPerSeason = toursRepo.GetList(
                        predicate: t => t.SeasonId == seasonId,
                        orderBy: q => q.OrderByDescending(t => t.Date),
                        size: size).Items;

                    tours.AddRange(toursPerSeason);
                }

                return(tours.ToPaginate(0, tours.Count));
            }

            return(toursRepo.GetList(
                       orderBy: q => q.OrderByDescending(t => t.Date),
                       size: size));
        }
コード例 #2
0
        private async Task <IPaginate <Tour> > FilterByPlayerIdAndIncomingStatus(
            ToursQuery request,
            IRepositoryReadOnly <Tour> toursRepo)
        {
            var leaguesId = await _leaguesService.GetPlayerJoinedLeagues(request.PlayerId);

            var actualSeasons = await _seasonsService.GetLeaguesSeasonsId(
                leaguesId,
                Array.Empty <int>(),
                LeaguesSeasonsIdQueryType.Actual);

            var tours = new List <Tour>();

            foreach (var season in actualSeasons)
            {
                var tour = toursRepo.Single(
                    t => t.SeasonId == season.SeasonId,
                    q => q.OrderByDescending(t => t.Date));

                if (tour != null && !tour.IsRegistrationClosed())
                {
                    tours.Add(tour);
                }
            }

            return(tours.ToPaginate(0, tours.Count));
        }
コード例 #3
0
        public async Task <PagedResult <TourDto> > Handle(ToursQuery request, CancellationToken cancellationToken)
        {
            var toursRepo = _uow.GetReadOnlyRepository <Tour>();

            Expression <Func <Tour, bool> > predicate = null;

            if (!(request.SeasonsId is null) && request.SeasonsId.Length != 0)
            {
                predicate = tour => request.SeasonsId.Contains(tour.SeasonId);
            }

            IPaginate <Tour> tours;
            int?count = null;

            if (request.PlayerId == 0)
            {
                tours = QueryForAllPlayers(request, toursRepo, predicate);
            }
            else
            {
                if (request.QueryType == ToursQueryType.Incoming)
                {
                    tours = await FilterByPlayerIdAndIncomingStatus(request, toursRepo);
                }
                else
                {
                    (count, tours) = await FilterByPlayerId(request, toursRepo, predicate);
                }
            }

            var toursDtos = new List <TourDto>();

            foreach (var tour in tours.Items)
            {
                if (request.QueryType == ToursQueryType.Incoming && tour.IsEnded())
                { // we want incoming tour, but this tour is ended - continue
                    continue;
                }

                toursDtos.Add(_mapper.Map <TourDto>(tour));
            }

            await EnrichTourDtoByLeagueId(toursDtos);

            if (request.QueryType == ToursQueryType.Incoming && request.PlayerId != 0)
            {
                EnrichByRegisterStatus(toursDtos, request.PlayerId);
            }
            return(PagedResult <TourDto> .Create(
                       toursDtos,
                       tours.Index,
                       tours.Size,
                       tours.Pages,
                       count ?? tours.Count));
        }
コード例 #4
0
        private async Task <(int, IPaginate <Tour>)> FilterByPlayerId(
            ToursQuery request,
            IRepositoryReadOnly <Tour> toursRepo,
            Expression <Func <Tour, bool> > predicate)
        {
            PagedResult <int> toursByPlayerIdDto =
                await _teamsService.GetToursByPlayerIdAsync(
                    request.Size,
                    request.Page,
                    request.PlayerId);

            if (toursByPlayerIdDto.IsEmpty)
            {
                return(0, null);
            }
            var tourIds = toursByPlayerIdDto.Items.ToList();

            predicate = predicate == null ?
                        t => tourIds.Contains(t.Id) :
                        predicate.AndAlso(t => tourIds.Contains(t.Id));

            return((int)toursByPlayerIdDto.TotalResults, toursRepo.GetList(predicate, size: tourIds.Count));
        }