コード例 #1
0
        public void ReturnsProperlyFilteredCategories(string searchText, FlashcardsSortingCriterion criterion,
                                                      bool descending, int pageIndex, int pageSize)
        {
            var model      = new FlashcardsFilteringModel(searchText, criterion, descending, pageIndex, pageSize);
            var categories = AddCategories();
            var flashards  = AddFlashcards(categories[0], 50);

            var query = Context.Flashcards.AsQueryable();
            var filteredFlashcards = FilteringServices.Filter(query, model).ToList();

            var expected = flashards.Where(f =>
                                           f.Key.Contains(model.SearchText) || f.Value.Contains(model.SearchText) || f.KeyDescription.Contains(model.SearchText) ||
                                           f.ValueDescription.Contains(model.SearchText) || f.Category.Name.Contains(model.SearchText));

            var lambda = GetLambda(criterion);

            expected = descending ? expected.OrderByDescending(lambda) : expected.OrderBy(lambda);

            var expectedList = expected.Skip(model.PageIndex * model.PageSize).Take(model.PageSize)
                               .ToList();

            Assert.Equal(expectedList.Count, filteredFlashcards.Count);
            for (var i = 0; i < expectedList.Count; i++)
            {
                var returned = filteredFlashcards[i];
                var exp      = new FlashcardDto(expectedList[i]);
                Assert.True(exp.Id == returned.Id);
            }
        }
コード例 #2
0
        public void InvalidFilteringModel(bool descending, FlashcardsSortingCriterion criterion)
        {
            var model = new FlashcardsFilteringModel("", criterion, descending, 1, 1);
            var query = Context.Flashcards.AsQueryable();

            Assert.Throws <ArgumentOutOfRangeException>(() => FilteringServices.Filter(query, model));
        }
コード例 #3
0
        public IActionResult Filter([FromBody] FlashcardsFilteringModel model)
        {
            var userId  = _userManager.GetUserId(this.User);
            var isAdmin = this.User.IsInRole(_roleNamesOptions.AdminRoleName);
            var query   = _filteringServices.Filter(_services.Get(userId, isAdmin), model);
            var list    = query.ToList();

            return(new JsonResult(list));
        }
コード例 #4
0
        public IQueryable <FlashcardDto> Filter(IQueryable <Flashcard> q, FlashcardsFilteringModel model)
        {
            var query = q.Include(f => f.Category).AsQueryable();

            query = query.Where(f =>
                                f.Key.Contains(model.SearchText) || f.Value.Contains(model.SearchText) || f.KeyDescription.Contains(model.SearchText) ||
                                f.ValueDescription.Contains(model.SearchText) || f.Category.Name.Contains(model.SearchText));
            if (model.Descending)
            {
                switch (model.SortingCriterion)
                {
                case FlashcardsSortingCriterion.None:
                    query = query.OrderByDescending(f => f.Id);
                    break;

                case FlashcardsSortingCriterion.Key:
                    query = query.OrderByDescending(f => f.Key);
                    break;

                case FlashcardsSortingCriterion.Value:
                    query = query.OrderByDescending(f => f.Value);
                    break;

                case FlashcardsSortingCriterion.KeyDescription:
                    query = query.OrderByDescending(f => f.KeyDescription);
                    break;

                case FlashcardsSortingCriterion.ValueDescription:
                    query = query.OrderByDescending(f => f.ValueDescription);
                    break;

                case FlashcardsSortingCriterion.Category:
                    query = query.OrderByDescending(f => f.Category.Name);
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
            }
            else
            {
                switch (model.SortingCriterion)
                {
                case FlashcardsSortingCriterion.None:
                    query = query.OrderBy(f => f.Id);
                    break;

                case FlashcardsSortingCriterion.Key:
                    query = query.OrderBy(f => f.Key);
                    break;

                case FlashcardsSortingCriterion.Value:
                    query = query.OrderBy(f => f.Value);
                    break;

                case FlashcardsSortingCriterion.KeyDescription:
                    query = query.OrderBy(f => f.KeyDescription);
                    break;

                case FlashcardsSortingCriterion.ValueDescription:
                    query = query.OrderBy(f => f.ValueDescription);
                    break;

                case FlashcardsSortingCriterion.Category:
                    query = query.OrderBy(f => f.Category.Name);
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
            }
            return(query.Skip(model.PageIndex * model.PageSize).Take(model.PageSize).Select(f => new FlashcardDto(f)));
        }