Esempio n. 1
0
        public async Task <List <Tour> > Search(SearchTourDto dto,
                                                CancellationToken cancellationToken = default(CancellationToken))
        {
            var tasks = _searchServices
                        .Select(x => SearchTaskWithTimeout(x, dto))
                        .ToList();
            var results = await Task.WhenAll(tasks);

            return(_toursMerger.Merge(results));
        }
Esempio n. 2
0
        public async Task <List <Tour> > Search(SearchTourDto dto,
                                                CancellationToken cancellationToken = default(CancellationToken))
        {
            var random  = new Random();
            var seconds = random.Next(3, 18);
            await Task.Delay(TimeSpan.FromSeconds(seconds), cancellationToken);

            var spec = BuildSpec(dto);

            var query = _tuiContext.Tours
                        .AsNoTracking()
                        .Where(spec.ToExpression())
                        .Take(1000);

            switch (dto.OrderBy)
            {
            case OrderBy.Price:
                query = query.OrderBy(x => x.PricePerPerson);
                break;

            case OrderBy.PriceDesc:
                query = query.OrderByDescending(x => x.PricePerPerson);
                break;

            //Если не указано, то по дате регистрации
            case null:
            case OrderBy.Date:
                query = query.OrderBy(x => x.DateRegistration);
                break;

            case OrderBy.DateDesc:
                query = query.OrderByDescending(x => x.DateRegistration);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }

            return(await query.ToListAsync(cancellationToken));
        }
Esempio n. 3
0
        private Specification <Tour> BuildSpec(SearchTourDto dto)
        {
            var spec = Specification <Tour> .Empty;

            if (dto.CityDepartureId.HasValue)
            {
                spec = spec.And(new TourWithCityDepartureSpec(dto.CityDepartureId.Value));
            }

            if (dto.CityArrivalId.HasValue)
            {
                spec = spec.And(new TourWithCityArrivalSpec(dto.CityArrivalId.Value));
            }

            if (!string.IsNullOrWhiteSpace(dto.DateRegistration))
            {
                spec = spec.And(new TourWithDateRegistrationSpec(DateTime.Parse(dto.DateRegistration)));
            }

            if (dto.MinNights.HasValue)
            {
                spec = spec.And(new TourWithNightCountGreaterSpec(dto.MinNights.Value));
            }

            if (dto.MaxNights.HasValue)
            {
                spec = spec.And(new TourWithNightCountLessSpec(dto.MaxNights.Value));
            }

            if (dto.RoomCapacity.HasValue)
            {
                spec = spec.And(new TourWithRoomCapacity(dto.RoomCapacity.Value));
            }

            return(spec);
        }
Esempio n. 4
0
        private async Task <List <Tour> > SearchTaskWithTimeout(ISearchService service, SearchTourDto dto)
        {
            using (var tokenSource = new CancellationTokenSource())
            {
                var searchTask = service.Search(dto, tokenSource.Token);
                //Ждём, что закончится быстрее: таймаут или поиск
                var completedTask = await Task.WhenAny(searchTask,
                                                       Task.Delay(TimeSpan.FromSeconds(_aggregatorTimeout.Seconds), tokenSource.Token));

                tokenSource.Cancel();
                if (completedTask == searchTask)
                {
                    return(await searchTask);
                }

                return(new List <Tour>());
            }
        }
Esempio n. 5
0
        public async Task <IActionResult> Get([FromQuery] SearchTourDto dto)
        {
            var result = await _searchService.Search(dto);

            return(Ok(result));
        }