public async Task <MediaResultDTO> GetPageAsync(MediaQueryDTO query)
{
int paginationCount = (query.Page - 1) * query.ElementsPerPage;
var mediaQuery = this.mediaRepository.AllAsNoTracking();
var filteredQuery = ApplyQuery(mediaQuery, query);
var resultsFound = await filteredQuery.CountAsync();
var results = await filteredQuery.ToListAsync();
var medias = await filteredQuery.Skip(paginationCount).Take(query.ElementsPerPage).Select(
x => new MediaGridDTO()
{
Id = x.Id,
IsDetailFull = x.IsDetailFull,
MovieApiId = x.MovieApiId,
Overview = x.Overview,
Title = x.Title,
ImagePath =
x.Images.FirstOrDefault(x => x.ImageType == ImageType.Poster).Path,
MediaType = x.GetType().Name,
Rating = x.Ratings.Select(x => x.Score).Average(x => x),
}).ToListAsync();
return(new MediaResultDTO()
{
ResultCount = resultsFound,
Results = medias,
ResultsPerPage = query.ElementsPerPage,
CurrentPage = query.Page,
});
}
public async Task <MediaResultDTO> Query([FromBody] MediaQueryDTO query)
{
var user = this.User.FindFirst(ClaimTypes.NameIdentifier);
if (user != null)
{
query.UserId = user.Value;
}
var result = await this.mediaService.GetPageAsync(query);
return(result);
}
public async Task GetPageAsyncGetsProperAmountOfPagesAndResult()
{
// Arrange
var mediaRepoMock = new Mock <IRepository <Media> >();
var mock = this.GetMedia().AsQueryable().BuildMock();
mediaRepoMock.Setup(x => x.AllAsNoTracking()).Returns(mock.Object);
mediaRepoMock.Setup(x => x.AllAsNoTracking()).Returns(mock.Object);
var mediaService = new MediaService(
mediaRepoMock.Object,
this.genreRepo,
this.keywordRepo,
this.mediaKeywordRepo);
var expectedPages1 = 1;
var query1 = new MediaQueryDTO()
{
Page = expectedPages1, ElementsPerPage = 20,
};
var expectedPages2 = 3;
var query2 = new MediaQueryDTO()
{
Page = expectedPages2, ElementsPerPage = 2,
};
// Act
var totalResults = this.mediaRepo.AllAsNoTracking().Count();
var results1 = await mediaService.GetPageAsync(query1);
var results2 = await mediaService.GetPageAsync(query2);
// Assert
Assert.Equal(expectedPages1, results1.Pages);
Assert.Equal(expectedPages2, results2.Pages);
Assert.Equal((query2.ElementsPerPage * results2.Pages) - totalResults, results2.Results.Count()); // results at the last page of query2
}
public async Task OnGetAsync()
{
var user = await this.userManager.GetUserAsync(this.User);
this.Username = user.UserName;
var query = new MediaQueryDTO()
{
WatchType = this.WatchType,
SortType = this.SortType,
UserId = user.Id,
Page = this.CurrentPage,
ElementsPerPage = this.ElementsPerPage,
};
var media = await this.mediaService.GetPageAsync(query);
this.ResultCount = media.ResultCount;
this.MediaSet = media.Results;
this.Page();
}
public async Task SearchQueryFindsCorrectMedia()
{
var mediaRepoMock = new Mock <IRepository <Media> >();
var mediaList = this.GetMedia();
var keyword = new Keyword()
{
Name = "keyword", Id = 5
};
var mediaKeyword = new MediaKeyword()
{
KeywordId = 5, Keyword = keyword, Media = mediaList.FirstOrDefault()
};
var show = new Show()
{
Title = "Mr. Robot",
Budget = 1000,
Overview = "ijweifgjwiegjweigoweg",
Runtime = 100,
ReleaseDate = DateTime.Now,
Images = new List <MediaImage>()
{
new MediaImage {
Path = "", ImageType = ImageType.Poster
}
},
Ratings = new List <Rating>()
{
new Rating()
{
Score = 10
}
},
Keywords = new List <MediaKeyword>()
{
mediaKeyword
},
Genres = new List <MediaGenre>()
{
new MediaGenre {
Genre = new Genre()
{
Id = 1, Name = "Adventure", ApiId = 1,
}
}
},
};
mediaList.Add(show);
var mock = mediaList.AsQueryable().BuildMock();
mediaRepoMock.Setup(x => x.AllAsNoTracking()).Returns(mock.Object);
mediaRepoMock.Setup(x => x.All()).Returns(mock.Object);
var mediaService = new MediaService(
mediaRepoMock.Object,
this.genreRepo,
this.keywordRepo,
this.mediaKeywordRepo);
var query1 = new MediaQueryDTO()
{
Page = 1, ElementsPerPage = 20, SearchQuery = "Mr. R"
};
var query2 = new MediaQueryDTO()
{
Page = 1, ElementsPerPage = 2, Genres = "Adventure"
};
var query3 = new MediaQueryDTO()
{
Page = 1, ElementsPerPage = 20, Keywords = "5"
};
// Act
var totalResults = this.mediaRepo.AllAsNoTracking().Count();
var results1 = await mediaService.GetPageAsync(query1);
var results2 = await mediaService.GetPageAsync(query2);
var results3 = await mediaService.GetPageAsync(query3);
// Assert
Assert.Contains(results1.Results, x => x.Title == "Mr. Robot");
Assert.Equal(1, results1.ResultCount);
Assert.Contains(results2.Results, x => x.Title == "Borat");
Assert.Equal(2, results2.ResultCount);
Assert.Contains(results3.Results, x => x.Title == "Mr. Robot");
Assert.Equal(1, results3.ResultCount);
}
private static IQueryable <Media> ApplyQuery(IQueryable <Media> source, MediaQueryDTO query)
{
if (query.MediaType == nameof(Movie))
{
source = source.OfType <Movie>();
}
else if (query.MediaType == nameof(Show))
{
source = source.OfType <Show>();
}
if (!string.IsNullOrWhiteSpace(query.Keywords))
{
var keywords = query.Keywords.Split(", ").Select(x => int.Parse(x)).ToList();
source = source.Where(x =>
x.Keywords.Any(y =>
keywords.Contains(y.KeywordId)));
}
if (!string.IsNullOrWhiteSpace(query.Genres))
{
var genres = query.Genres.Split(", ");
foreach (string genre in genres)
{
source = source.Where(x => x.Genres.Select(x => x.Genre.Name).Contains(genre));
}
}
if (!string.IsNullOrWhiteSpace(query.WatchType))
{
var isValidWatchType = Enum.TryParse <WatchType>(query.WatchType, true, out WatchType watchType);
if (!isValidWatchType)
{
throw new InvalidEnumArgumentException($"Watchtype {query.WatchType} is not valid!");
}
source = source.Where(
x => x.Watchers.Any(x => x.UserId == query.UserId && x.WatchType == watchType));
}
if (!query.AreNotWatched)
{
source = source.Where(x => x.Watchers.Any(x => x.UserId != query.UserId));
}
if (query.SearchQuery != null)
{
source = source.Where(x =>
x.Title.Contains(query.SearchQuery ?? string.Empty));
}
source = query.SortType switch
{
"popularity" => source.Include(x => x.Watchers).OrderBy(x => x.Watchers.Count()),
"popularity-desc" => source.Include(x => x.Watchers).OrderByDescending(x => x.Watchers.Count()),
"rating" => source.OrderBy(x => x.Ratings.Average(x => x.Score)),
"rating-desc" => source.OrderByDescending(x => x.Ratings.Average(x => x.Score)),
"date" => source.OrderBy(x => x.ReleaseDate),
"date-desc" => source.OrderByDescending(x => x.ReleaseDate),
_ => source.OrderBy(x => x.Title),
};
return(source);
}
