/// <summary> /// Gets the specified page of authors matching <paramref name="filter" />. /// </summary> /// <param name="filter">The filter.</param> /// <returns> /// Page of authors. /// </returns> /// <exception cref="ArgumentNullException">filter</exception> public DataPage <Author> GetAuthors(AuthorFilter filter) { if (filter == null) { throw new ArgumentNullException(nameof(filter)); } PrepareAuthorFilter(filter); using (var db = GetContext()) { var authors = db.Authors.AsQueryable(); if (!string.IsNullOrEmpty(filter.Last)) { authors = authors.Where(a => a.Lastx.Contains(filter.Last)); } int tot = authors.Count(); // sort and page authors = authors.OrderBy(a => a.Last) .ThenBy(a => a.First) .ThenBy(a => a.Suffix) .ThenBy(a => a.Id); var pgAuthors = authors.Skip(filter.GetSkipCount()) .Take(filter.PageSize) .ToList(); return(new DataPage <Author>( filter.PageNumber, filter.PageSize, tot, (from a in pgAuthors select EfHelper.GetAuthor(a)).ToList())); } }
public IEnumerable <AuthorDto> GetAuthors(out int totalRecords, AuthorFilter filter) { totalRecords = 0; var entities = Context.Author.Select(i => i); if (!string.IsNullOrWhiteSpace(filter.FirstName)) { entities = entities.Where(i => EF.Functions.Like(i.FirstName, $"{filter.FirstName}%")); } if (!string.IsNullOrWhiteSpace(filter.LastName)) { entities = entities.Where(i => EF.Functions.Like(i.LastName, $"{filter.LastName}%")); } if (!string.IsNullOrWhiteSpace(filter.Alias)) { entities = entities.Where(i => EF.Functions.Like(i.Alias, $"{filter.Alias}%")); } totalRecords = entities.Count(); if (totalRecords <= filter.Skip) { filter.Skip = 0; } entities = entities.ApplySortToEntities(filter.SortMembers); List <AuthorDto> authors = entities .Skip(filter.Skip) .Take(filter.Take) .ProjectToType <AuthorDto>().ToList(); return(authors); }
private static void PrepareAuthorFilter(AuthorFilter filter) { if (string.IsNullOrEmpty(filter.Last)) { filter.Last = StandardFilter.Apply(filter.Last, true); } }
public async Task <IActionResult> DeleteAuthorFilter(AuthorFilter filter) { if (!await authorService.GetFilters().AnyAsync(x => x.Id == filter.Id)) { return(NotFound()); } await authorService.DeleteFilter(filter.Id); return(NoContent()); }
public List <Guid> GetFilterAuthorIdsDirectly(AuthorFilter authorFilter) { string query = _defaultSelectCommand; query += String.Format(" And HourRate >= {0} And HourRate <= {1}", authorFilter.HourRateMin, authorFilter.HourRateMax); string jobCount = "(Select Count(*) From Job Where a.PersonId = Job.AuthorId)"; query += " And " + jobCount + " >= " + authorFilter.CountOfPastJobsMin; query += " And " + jobCount + " <= " + authorFilter.CountOfPastJobsMax; query += String.Format(" And (Title Like '%{0}%' Or Overview Like '%{0}%')", authorFilter.SearchString); return(GetCustomList(query)); }
public PartialViewResult GetAuthorsByFilter(AuthorFilter authorFilter, int page = 1) { if (Session["PersonId"] == null) { return(null); } List <Guid> authorIds = AuthorRepository.Instance.GetFilterAuthorIdsDirectly(authorFilter); InitAuthorsPartial(authorIds, page); return(PartialView("_Authors", authorFilter)); }
public async Task TestListTotalPages(int limit) { // Arrange using var dbContext = GetBookSellerContext($"{nameof(AuthorTests)}_{nameof(TestListTotalPages)}_{limit}", TOTAL_RECORDS); var controller = new AuthorsController(dbContext); var filter = new AuthorFilter { Limit = limit }; // Act var response = await controller.List(filter); // Assert Assert.Equal(ExpectedTotalPages(limit, TOTAL_RECORDS), response.Value.TotalPages); }
public ActionResult FindAuthors() { if (Session["PersonId"] == null) { return(Redirect(ControllersLibrary.LogInPage)); } ViewBag.Skills = SkillRepository.Instance.GetAllItems().OrderBy(i => i.Title); AuthorFilter af = new AuthorFilter(); List <Guid> authorIds = AuthorRepository.Instance.GetFilterAuthorIdsDirectly(af); InitAuthorsPartial(authorIds, 1); return(View(af)); }
public ActionResult GetAuthors(Pagination pagination, AuthorFilter authorFilter, string orderBy = "Name") { var orderByEntities = OrderMapper.MapTo <Author>(orderBy); IPagedList <Author> authors = _libraryRepository.GetAuthors(pagination, authorFilter, orderByEntities); var authorDtos = _mapper.Map <IEnumerable <AuthorDto> >(authors); var result = new { meta = authors.GetMetaData(), value = authorDtos }; return(Ok(result)); }
public void GetByFilterTest() { //Arrange Mock <IUnitOfWork> unitOfWorkMock = new Mock <IUnitOfWork>(); Mock <IRepository <Author> > repositoryMock = new Mock <IRepository <Author> >(); unitOfWorkMock.Setup(getRepository => getRepository.GetRepository <Author>()).Returns(repositoryMock.Object); repositoryMock.Setup(rep => rep.Get(It.IsAny <Expression <Func <Author, bool> > >())).Returns(authors.AsQueryable); AuthorService authorService = new AuthorService(unitOfWorkMock.Object); AuthorFilter authorfilter = new AuthorFilter(); //Act IEnumerable <AuthorDTO> authorsDto = authorService.Get(authorfilter); //Assert Assert.NotNull(authorsDto); Assert.NotEmpty(authorsDto); Assert.Equal(5, authorsDto.Count()); }
public async Task TestListFilter(string propertyName) { // Arrange using var dbContext = GetBookSellerContext($"{nameof(AuthorTests)}_{nameof(TestListFilter)}", TOTAL_RECORDS); var firstAuthor = dbContext.Author.First(); firstAuthor.FirstName = "[TEST]fIrStNaMe[TEST]"; firstAuthor.LastName = "[TEST]lAsTNaMe[TEST]"; dbContext.SaveChanges(); var filter = new AuthorFilter(); typeof(AuthorFilter).GetProperty(propertyName).SetValue(filter, propertyName); var controller = new AuthorsController(dbContext); // Act var response = await controller.List(filter); // Assert Assert.Single(response.Value.Items); }
List <Guid> IAuthorRepository.GetFilterAuthorIdsDirectly(AuthorFilter authorFilter) { return(Channel.GetFilterAuthorIdsDirectly(authorFilter)); }
public List <Guid> GetFilterAuthorIdsDirectly(AuthorFilter authorFilter) { return(Proxy.GetFilterAuthorIdsDirectly(authorFilter)); }
public async Task <IEnumerable <AuthorModel> > GetAuthorsAsync(PaginationQuery paginationFilter = null, AuthorFilter filter = null) { var skip = (paginationFilter.PageNumber - 1) * paginationFilter.PageSize; if (filter.Name is null) { var authorsNoFilter = _mapper.Map <IEnumerable <Author>, IEnumerable <AuthorModel> > (await _authorRepository.GetAuthorsAsync(skip, paginationFilter.PageSize)); return(authorsNoFilter); } var authorsFilter = _mapper.Map <IEnumerable <Author>, IEnumerable <AuthorModel> > (await _authorRepository.GetAuthorsAsync(skip, paginationFilter.PageSize, filter)); return(authorsFilter); }
public AuthorsController(IUnitOfWork uow) { this.uow = uow; af = new AuthorFilter(uow); }
public List <Guid> GetFilterAuthorIdsDirectly(AuthorFilter authorFilter) { return(AuthorRepository.Instance.GetFilterAuthorIdsDirectly(authorFilter)); }
public async Task <IEnumerable <Author> > GetAuthorsAsync(int skip, int pageSize, AuthorFilter filter) { var authorList = await _dbSet.Include("AuthorInPrintingEditions.PrintingEdition") .Where(a => a.Name.ToLower().Contains(filter.Name.ToLower())) .Skip(skip) .Take(pageSize) .ToListAsync(); return(authorList); }
public async Task <IActionResult> GetAuthors([FromQuery] PaginationQuery paginationQuery, [FromQuery] AuthorFilter filter) { var authorResponse = await _authorService.GetAuthorsAsync(); if (paginationQuery is null || paginationQuery.PageSize < 1 || paginationQuery.PageNumber < 1) { return(Ok(new PagedResponse <AuthorModel>(authorResponse))); } authorResponse = await _authorService.GetAuthorsAsync(paginationQuery, filter); var paginationResponse = PaginationProvider.CreatePaginatedResponse(_uriService, $"api/{ControllerContext.ActionDescriptor.ControllerName}/{Constants.Routes.AUTHORS_GET_ALL_ROUTE}", paginationQuery, filter, authorResponse); return(Ok(paginationResponse)); }
public IActionResult DisplaySearchResults(String TitleString, String AuthorString, int UniqueNumber, int SelectedGenre, TitleFilter SelectedTitleFilter, AuthorFilter SelectedAuthorFilter, PopularityFilter SelectedPopularityFilter, DateFilter SelectedDateFilter, RatingFilter SelectedRatingFilter, StockFilter SelectedStockFilter) { List <Book> SelectedBooks = new List <Book>(); var query = from r in _context.Books.Include(b => b.Genre) select r; if (TitleString != null && TitleString != "") { query = query.Where(r => r.Title.Contains(TitleString)); } if (AuthorString != null && AuthorString != "") { query = query.Where(r => r.Author.Contains(AuthorString)); } if (UniqueNumber != 0) { query = query.Where(r => r.UniqueID == UniqueNumber); } if (SelectedGenre != 0) { Genre GenreToDisplay = _context.Genres.Find(SelectedGenre); query = query.Where(r => r.Genre == GenreToDisplay); } if (SelectedStockFilter == StockFilter.True) { query = query.Where(b => b.CopiesOnHand > 0); } //if no sort SelectedBooks = query.Include(b => b.Reviews).ToList(); if (SelectedTitleFilter == TitleFilter.Ascending) { SelectedBooks = query.OrderBy(r => r.Title).ToList(); } else if (SelectedTitleFilter == TitleFilter.Descending) { SelectedBooks = query.OrderByDescending(r => r.Title).ToList(); } if (SelectedAuthorFilter == AuthorFilter.Ascending) { SelectedBooks = query.OrderBy(r => r.Author).ToList(); } else if (SelectedAuthorFilter == AuthorFilter.Descending) { SelectedBooks = query.OrderByDescending(r => r.Author).ToList(); } //POPULARTY FILTER CODE if (SelectedPopularityFilter == PopularityFilter.Ascending) { query = query.OrderByDescending(r => r.CopiesSold); } //don't need filter if not chosen - no else if (SelectedDateFilter == DateFilter.Oldest) { SelectedBooks = query.OrderBy(r => r.PublishedDate).ToList(); } else if (SelectedDateFilter == DateFilter.Newest) { SelectedBooks = query.OrderByDescending(r => r.PublishedDate).ToList(); } if (SelectedRatingFilter == RatingFilter.Descending) { //Int32 AvgRating = 0; //Int32 //List<Book> books = _context.Books.Include(b => b.Reviews).Where(b => b.Reviews != null).ToList(); //foreach(Book b in books) //{ // AvgRating += //} //foreach(Book book in query) SelectedBooks = query.OrderByDescending(r => r.AvgRating).ToList(); } //execute the query and store it into the SelectedRepositories list //SelectedBooks = query.Include(r => r.Reviews).ToList(); ViewBag.SelectedBooks = SelectedBooks.Count(); ViewBag.TotalBooks = _context.Books.Count(); //pass the filtered results to display in view return(View("Index", SelectedBooks)); }