Example #1
0
        public async Task <BasePageList <FarmPictureResult> > GetPicturesAsync(FarmPictureFilter filter)
        {
            var farmPicturePageList = await _farmPictureRepository.GetAsync(filter);

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

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

            return(farmPicturePageList);
        }
Example #2
0
        public async Task <IActionResult> Pictures(FarmPictureFilterModel filter)
        {
            var filterRequest = new FarmPictureFilter()
            {
                CreatedById     = filter.CreatedById,
                CreatedDateFrom = filter.CreatedDateFrom,
                CreatedDateTo   = filter.CreatedDateTo,
                Page            = filter.Page,
                PageSize        = _pagerOptions.PageSize,
                Keyword         = filter.Search,
                MimeType        = filter.MimeType
            };

            var farmPicturePageList = await _farmService.GetPicturesAsync(filterRequest);

            var farmPictures = farmPicturePageList.Collections.Select(x => new FarmPictureModel
            {
                FarmName           = x.FarmName,
                FarmId             = x.FarmId,
                PictureId          = x.PictureId,
                PictureName        = x.PictureName,
                PictureCreatedBy   = x.PictureCreatedBy,
                PictureCreatedById = x.PictureCreatedById,
                PictureCreatedDate = x.PictureCreatedDate,
                FarmPictureType    = (FarmPictureType)x.FarmPictureTypeId,
                ContentType        = x.ContentType
            });

            var farmPage = new PageListModel <FarmPictureModel>(farmPictures)
            {
                Filter      = filter,
                TotalPage   = farmPicturePageList.TotalPage,
                TotalResult = farmPicturePageList.TotalResult
            };

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

            return(View(farmPage));
        }
        public async Task <BasePageList <FarmPictureResult> > GetAsync(FarmPictureFilter 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 _farmPictureRepository.Table
                        join p in pictureQuery
                        on ap.PictureId equals p.Id
                        join a in _farmRepository.Table
                        on ap.FarmId equals a.Id
                        select new FarmPictureResult()
            {
                FarmId             = a.Id,
                FarmName           = a.Name,
                PictureId          = p.Id,
                PictureName        = p.FileName,
                FarmPictureTypeId  = ap.PictureTypeId,
                PictureCreatedById = p.CreatedById,
                PictureCreatedDate = p.CreatedDate,
                ContentType        = p.MimeType
            };

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

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

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

            return(result);
        }