Esempio n. 1
0
        public async Task <BasePageList <ArticlePictureResult> > GetPicturesAsync(ArticlePictureFilter filter)
        {
            var articlePictureListPage = await _articlePictureRepository.GetAsync(filter);

            var createdByIds   = articlePictureListPage.Collections.GroupBy(x => x.PictureCreatedById).Select(x => x.Key);
            var createdByUsers = await _userRepository.GetNameByIdsAsync(createdByIds);

            foreach (var articlePicture in articlePictureListPage.Collections)
            {
                var createdBy = createdByUsers.FirstOrDefault(x => x.Id == articlePicture.PictureCreatedById);
                articlePicture.PictureCreatedBy = createdBy.DisplayName;
            }

            return(articlePictureListPage);
        }
        public async Task <IActionResult> Pictures(ArticlePictureFilterModel filter)
        {
            var filterRequest = new ArticlePictureFilter()
            {
                CreatedById     = filter.CreatedById,
                CreatedDateFrom = filter.CreatedDateFrom,
                CreatedDateTo   = filter.CreatedDateTo,
                Page            = filter.Page,
                PageSize        = _pagerOptions.PageSize,
                Keyword         = filter.Search,
                MimeType        = filter.MimeType
            };

            var articlePicturePageList = await _articleService.GetPicturesAsync(filterRequest);

            var articlePictures = articlePicturePageList.Collections.Select(x => new ArticlePictureModel
            {
                ArticleName        = x.ArticleName,
                ArticleId          = x.ArticleId,
                PictureId          = x.PictureId,
                PictureName        = x.PictureName,
                PictureCreatedBy   = x.PictureCreatedBy,
                PictureCreatedById = x.PictureCreatedById,
                PictureCreatedDate = x.PictureCreatedDate,
                ArticlePictureType = (ArticlePictureType)x.ArticlePictureTypeId,
                ContentType        = x.ContentType
            });

            var articlePage = new PageListModel <ArticlePictureModel>(articlePictures)
            {
                Filter      = filter,
                TotalPage   = articlePicturePageList.TotalPage,
                TotalResult = articlePicturePageList.TotalResult
            };

            if (_httpHelper.IsAjaxRequest(Request))
            {
                return(PartialView("Partial/_ArticlePictureTable", articlePage));
            }

            return(View(articlePage));
        }
        public async Task <BasePageList <ArticlePictureResult> > GetAsync(ArticlePictureFilter filter)
        {
            var pictureQuery = _pictureRepository.Get(x => x.StatusId != PictureStatus.Pending.GetCode());

            if (!string.IsNullOrEmpty(filter.Keyword))
            {
                var search = filter.Keyword.ToLower();
                pictureQuery = pictureQuery.Where(pic => pic.Title.ToLower().Contains(search));
            }

            if (filter.CreatedById.HasValue)
            {
                pictureQuery = pictureQuery.Where(x => x.CreatedById == filter.CreatedById);
            }

            if (!string.IsNullOrEmpty(filter.MimeType))
            {
                var mimeType = filter.MimeType.ToLower();
                pictureQuery = pictureQuery.Where(x => x.MimeType.Contains(mimeType));
            }

            // Filter by register date/ created date
            if (filter.CreatedDateFrom.HasValue && filter.CreatedDateTo.HasValue)
            {
                pictureQuery = pictureQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom && x.CreatedDate <= filter.CreatedDateTo);
            }
            else if (filter.CreatedDateTo.HasValue)
            {
                pictureQuery = pictureQuery.Where(x => x.CreatedDate <= filter.CreatedDateTo);
            }
            else if (filter.CreatedDateFrom.HasValue)
            {
                pictureQuery = pictureQuery.Where(x => x.CreatedDate >= filter.CreatedDateFrom && x.CreatedDate <= DateTimeOffset.UtcNow);
            }

            var query = from ap in _articlePictureRepository.Table
                        join p in pictureQuery
                        on ap.PictureId equals p.Id
                        join a in _articleRepository.Table
                        on ap.ArticleId equals a.Id
                        select new ArticlePictureResult()
            {
                ArticleId            = a.Id,
                ArticleName          = a.Name,
                PictureId            = p.Id,
                PictureName          = p.FileName,
                ArticlePictureTypeId = ap.PictureTypeId,
                PictureCreatedById   = p.CreatedById,
                PictureCreatedDate   = p.CreatedDate,
                ContentType          = p.MimeType
            };

            var filteredNumber = query.Select(x => x.PictureId).Count();

            var articlePictures = await query.Skip(filter.PageSize *(filter.Page - 1))
                                  .Take(filter.PageSize).ToListAsync();

            var result = new BasePageList <ArticlePictureResult>(articlePictures)
            {
                TotalResult = filteredNumber,
                TotalPage   = (int)Math.Ceiling((double)filteredNumber / filter.PageSize)
            };

            return(result);
        }