Exemple #1
0
        public override List <Model.Review> Get(ReviewSearchRequest search)
        {
            var query = _context.Reviews.Include(i => i.User).Include(i => i.Vehicle).AsQueryable();

            if (search.Id != 0)
            {
                query = query.Where(w => w.Id == search.Id);
            }

            if (!string.IsNullOrWhiteSpace(search.Comment))
            {
                query = query.Where(w => w.Comment == search.Comment);
            }

            if (search.NumberOfStars != 0)
            {
                query = query.Where(w => w.NumberOfStars == search.NumberOfStars);
            }

            if (search.DatePosted != null)
            {
                query = query.Where(w => w.DatePosted == search.DatePosted);
            }

            if (search.UserId != 0)
            {
                query = query.Where(w => w.UserId == search.UserId);
            }

            if (!string.IsNullOrWhiteSpace(search.FirstName))
            {
                query = query.Where(w => w.User.FirstName == search.FirstName);
            }

            if (!string.IsNullOrWhiteSpace(search.LastName))
            {
                query = query.Where(w => w.User.LastName == search.LastName);
            }

            if (search.VehicleId != 0)
            {
                query = query.Where(w => w.VehicleId == search.VehicleId);
            }

            if (!string.IsNullOrWhiteSpace(search.VehicleName))
            {
                query = query.Where(w => w.Vehicle.Name == search.VehicleName);
            }

            query.OrderBy(o => o.DatePosted);

            return(_mapper.Map <List <Model.Review> >(query));
        }
Exemple #2
0
        private async Task SetCourseReview(int CourseID)
        {
            var request = new ReviewSearchRequest()
            {
                CourseID = CourseID,
                UserID   = SignedInUser.User.UserID
            };

            var list = await reviewService.Get <List <MCourseReview> >(request);

            if (list != null)
            {
                CourseReview = list.FirstOrDefault();
            }
        }
        public async Task <List <MTrackReview> > Get(ReviewSearchRequest search)
        {
            var query = _context.UserTrackReviews.AsQueryable();

            if (search.UserID != 0)
            {
                query = query.Where(i => i.UserID == search.UserID);
            }

            if (search.TrackID != 0)
            {
                query = query.Where(i => i.TrackID == search.TrackID);
            }

            if (search.Rating != 0)
            {
                query = query.Where(i => i.Rating == search.Rating);
            }

            var list = await query.ToListAsync();

            return(_mapper.Map <List <MTrackReview> >(list));
        }
        private async Task LoadReviews(int?albumId = null, int?ratingFrom = null, int?ratingTo = null)
        {
            ReviewSearchRequest request = new ReviewSearchRequest()
            {
                AlbumId    = albumId,
                RatingFrom = ratingFrom,
                RatingTo   = ratingTo
            };

            if (albumId == null && ratingFrom == null && ratingTo == null)
            {
                var result = await _reviewService.Get <List <Model.Review> >(null);

                dgvReviews.AutoGenerateColumns = false;
                dgvReviews.DataSource          = result;
            }
            else
            {
                var result = await _reviewService.Get <List <Model.Review> >(request);

                dgvReviews.AutoGenerateColumns = false;
                dgvReviews.DataSource          = result;
            }
        }
 public async Task <List <MCourseReview> > Get([FromQuery] ReviewSearchRequest search)
 {
     return(await _service.Get(search));
 }
 public Task <IPagedList <ReviewDto> > GetPagedAsync(ReviewSearchRequest search)
 {
     throw new NotImplementedException();
 }