示例#1
0
        public async Task <BasePageList <ProductPictureResult> > GetPicturesAsync(ProductPictureFilter filter)
        {
            var productPicturesPageList = await _productPictureRepository.GetAsync(filter);

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

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

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

            var productPicturePageList = await _productService.GetPicturesAsync(filterRequest);

            var productPictures = productPicturePageList.Collections.Select(x => new ProductPictureModel
            {
                ProductName        = x.ProductName,
                ProductId          = x.ProductId,
                PictureId          = x.PictureId,
                PictureName        = x.PictureName,
                PictureCreatedBy   = x.PictureCreatedBy,
                PictureCreatedById = x.PictureCreatedById,
                PictureCreatedDate = x.PictureCreatedDate,
                ProductPictureType = (ProductPictureType)x.ProductPictureTypeId,
                ContentType        = x.ContentType
            });

            var productPage = new PageListModel <ProductPictureModel>(productPictures)
            {
                Filter      = filter,
                TotalPage   = productPicturePageList.TotalPage,
                TotalResult = productPicturePageList.TotalResult
            };

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

            return(View(productPage));
        }
        public async Task <BasePageList <ProductPictureResult> > GetAsync(ProductPictureFilter filter)
        {
            var pictureQuery = _pictureRepository.Get(x => x.StatusId != PictureStatus.Deleted.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 _productPictureRepository.Table
                        join p in pictureQuery
                        on ap.PictureId equals p.Id
                        join a in _productRepository.Table
                        on ap.ProductId equals a.Id
                        select new ProductPictureResult
            {
                ProductId            = a.Id,
                ProductName          = a.Name,
                PictureId            = p.Id,
                PictureName          = p.FileName,
                ProductPictureTypeId = ap.PictureTypeId,
                PictureCreatedById   = p.CreatedById,
                PictureCreatedDate   = p.CreatedDate,
                ContentType          = p.MimeType
            };

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

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

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

            return(result);
        }