Пример #1
0
        public async Task <BirdsList> SearchBirdsAsync(BirdsSearchQuery query, CancellationToken token)
        {
            if (query == null)
            {
                throw new ArgumentNullException(nameof(query));
            }

            token.ThrowIfCancellationRequested();

            var limit  = query.Limit;
            var offset = query.Offset;
            var name   = query.Name;

            var builder = new StringBuilder();

            builder.Append($"{LocalUrl}/api/v1/birds?{nameof(limit)}={limit}&{nameof(offset)}={offset}&");

            if (name != null)
            {
                builder.Append($"{nameof(name)}={name}");
            }

            var requestUti = builder.ToString();

            var searchResult = await httpClient.GetAsync(requestUti, token).ConfigureAwait(false);

            searchResult.EnsureSuccessStatusCode();

            var responseContent = await searchResult.Content.ReadAsStringAsync().ConfigureAwait(false);

            var birdList = JsonConvert.DeserializeObject <BirdsList>(responseContent);

            return(birdList);
        }
Пример #2
0
        static async Task Main(string[] args)
        {
            var temp = new List <Bird>
            {
                new Bird {
                    Name = "Зяблик", Description = "описание зяблика"
                },
                new Bird {
                    Name = "Ворон", Description = "описание ворона"
                },
                new Bird {
                    Name = "Воробей", Description = "описание воробья"
                },
                new Bird {
                    Name = "Рябчик", Description = "описание рябчика"
                },
            };

            var config          = new Configuration();
            var birdsRepository = new BirdsRepository(config);

            var searchQuery  = new BirdsSearchQuery();
            var searchResult = await birdsRepository.SearchAsync(searchQuery, CancellationToken.None)
                               .ConfigureAwait(false);

            foreach (var bird in searchResult)
            {
                Console.WriteLine(bird.Name);
            }
        }
Пример #3
0
        public async Task SearchWithLimitTestAsync()
        {
            var offset      = 0;
            var limit       = 2;
            var searchQuery = new BirdsSearchQuery {
                Limit = limit, Offset = offset
            };
            var result = await this.BirdsApiClient.SearchBirdsAsync(searchQuery, CancellationToken.None).ConfigureAwait(false);

            Assert.NotNull(result);
            Assert.AreEqual(limit, result.Birds.Count);
        }
Пример #4
0
        public async Task <IActionResult> SearchAsync(
            [FromQuery] BirdsSearchQuery searchQuery,
            CancellationToken token)
        {
            token.ThrowIfCancellationRequested();

            var modelSearchQuery = BirdsConverter.Convert(searchQuery);
            var modelBirds       = await this.birdsRepository.SearchAsync(modelSearchQuery, token).ConfigureAwait(false);

            var viewBirdsList = new BirdsList
            {
                Birds = modelBirds.Select(BirdsConverter.Convert).ToList(),
            };

            return(this.Ok(viewBirdsList));
        }
Пример #5
0
        public async Task <IReadOnlyList <Bird> > SearchAsync(BirdsSearchQuery query, CancellationToken token)
        {
            token.ThrowIfCancellationRequested();

            if (query == null)
            {
                throw new ArgumentNullException(nameof(query));
            }

            var nameFilter = Builders <Bird> .Filter.Empty;

            if (query.Name != null)
            {
                nameFilter = Builders <Bird> .Filter.Regex("Name", new BsonRegularExpression(query.Name));
            }

            var result = await birds.Find(nameFilter).Skip(query.Offset).Limit(query.Limit).ToListAsync(token);

            return(result);
        }