public async Task <AllBookOutput> GetAllAsync(AllBookInput input)
        {
            var builder = new AllBook();
            var books   = await GetAll(input, builder);

            var header = L("AllBookHeader");

            return(new AllBookOutput(books, header));
        }
        public async Task <AllBookOutput> GetAllFavoritesByCurrentUserIdAsync(AllBookInput input)
        {
            var builder = new BookByFavorite(AbpSession.GetUserId());
            var books   = await GetAll(input, builder);

            var header = L("BookByFavoriteHeader");

            return(new AllBookOutput(books, header));
        }
        public async Task <AllBookOutput> GetAllNotApprovedAsync(AllBookInput input)
        {
            using (CurrentUnitOfWork.DisableFilter(AbpDataFilters.SoftDelete, FilterNames.Approved))
            {
                var builder = new AllNotApprovedBook();
                var books   = await GetAll(input, builder);

                return(new AllBookOutput(books, L("AllNotApprovedHeader")));
            }
        }
        private Task <IPagedList <ShortBookDto> > GetAll(AllBookInput input, BuilderBase <Book> builder)
        {
            return(Task.Run(() =>
            {
                var books = Director <Book>
                            .Construct(builder)
                            .ToPagedList(input.PageIndex, input.PageSize)
                            .MapTo <IPagedList <ShortBookDto> >();

                return books;
            }));
        }
        private AllBookInput GetAllBookInput(int?page)
        {
            var input = new AllBookInput
            {
                PageIndex         = page - 1 ?? 0,
                PageSize          = GetDefaultPageSize(),
                SortType          = CookieHelper.SortType,
                OrderIsDescending = CookieHelper.OrderIsDescending
            };

            return(input);
        }
        public async Task <AllBookOutput> GetAllByCatalogIdAsync(AllBookInput <int> input)
        {
            var catalog = await _catalogCache.GetAsync(input.Id);

            if (catalog == null)
            {
                throw new UserFriendlyException(404, L("PageNotFoundTitle"), L("PageNotFoundDetails"));
            }

            var builder = new BookByCatalog(input.Id);
            var books   = await GetAll(input, builder);

            var header = L("BookByCatalogHeader", catalog.Name);

            return(new AllBookOutput(books, header));
        }
        private Task <IPagedList <ShortBookDto> > GetAll(AllBookInput input, BuilderSortBase <Book> builder)
        {
            return(Task.Run(() =>
            {
                builder
                .SortingBy(input.SortType)
                .OrderBy(input.OrderIsDescending);

                var books = Director <Book>
                            .Construct(builder)
                            .ToPagedList(input.PageIndex, input.PageSize)
                            .MapTo <IPagedList <ShortBookDto> >();

                return books;
            }));
        }
        public async Task <AllBookOutput> GetAllByAuthorIdAsync(AllBookInput <int> input)
        {
            var author = await _authorCache.GetAsync(input.Id);

            if (author == null)
            {
                throw new UserFriendlyException(404, L("PageNotFoundTitle"), L("PageNotFoundDetails"));
            }

            var builder = new BookByAuthor(input.Id);
            var books   = await GetAll(input, builder);

            var header = L("BookByAuthorHeader", author.Name);

            return(new AllBookOutput(books, header));
        }