private static IQueryable <Album> Filter(AlbumFilter filters, IQueryable <Album> query)
{
if (!String.IsNullOrWhiteSpace(filters.Title))
{
query = query
.Where(t => t.Title.ToLower().Contains(filters.Title.ToLower()));
}
if (!String.IsNullOrWhiteSpace(filters.Artist))
{
query = query
.Where(a => a.Artist.ToLower().Contains(filters.Artist.ToLower()));
}
if (filters.Genre > 0)
{
query = query.Where(g => g.Genre == filters.Genre);
}
if (filters.Price >= 0)
{
query = query.Where(g => g.Price == filters.Price);
}
if (filters.StockAmount >= 0)
{
query = query.Where(g => g.StockAmount == filters.StockAmount);
}
return(query);
}
private List <Artist> FilterDeeperThenArtist(bool includeGenre)
{
var tmpArtists =
allArtists.Where(a => a.Name.ToUpper().Contains(ArtistFilter.ToUpper())).ToList();
var finalList = new List <Artist>();
foreach (var a in tmpArtists)
{
ResetHighlight(a);
var query = a.Albums.
Where(al => al.Name.ToUpper().Contains(AlbumFilter.ToUpper()));
if (includeGenre)
{
query = query.Where(al => al.Genres.Contains(new Genre()
{
Name = GenreFilter
}, new GenreByNameComparer()));
}
if (query.Count() > 0)
{
finalList.Add(a);
}
foreach (var ma in query)
{
((TreeTag)ma.OptionalTag).IsHighlighted = true;
}
}
return(finalList);
}
public IEnumerable <AlbumDTO> ListAlbums(AlbumFilter filter)
{
using (UnitOfWorkProvider.Create())
{
_albumListQuery.Filter = filter;
return(_albumListQuery.Execute() ?? new List <AlbumDTO>());
}
}
/// <summary>
/// Configures albums list query
/// </summary>
/// <param name="filter">album filter</param>
/// <returns>configured query</returns>
private IQuery <AlbumDTO> GetQuery(AlbumFilter filter)
{
var query = albumListQuery;
query.ClearSortCriterias();
query.Filter = filter;
return(query);
}
public Album[] GetAllAlbumsPaged(out int totalCount, AlbumFilter filters, List <SortItem> sorts,
int pageIndex, int pageSize)
{
try { IAlbumRepository albumRepository =
_dataRepositoryFactory.GetDataRepository <IAlbumRepository>();
IEnumerable <Album> albums = albumRepository.GetAllAlbumsPaged(out totalCount, filters, sorts,
pageIndex, pageSize);
return(albums.ToArray()); }
catch (FaultException ex) { throw ex; }
catch (Exception ex) { throw new FaultException(ex.Message); }
}
public Task <JsonList <AlbumModel> > GetArtistAlbumsAsync(
int artistId, AlbumFilter filter, int offset = 0, int limit = OpenTidlConstants.DEFAULT_LIMIT)
{
return(RestClient.HandleAsync <JsonList <AlbumModel> >(
$"/artists/{artistId}/albums", new
{
filter = filter.ToString("F"),
offset,
limit,
countryCode = GetCountryCode()
}, null, "GET"));
}
public async Task <JsonList <AlbumModel> > GetArtistAlbums(Int32 artistId, AlbumFilter filter, Int32 offset = 0, Int32 limit = 9999)
{
return(HandleResponse(await RestClient.Process <JsonList <AlbumModel> >(
RestUtility.FormatUrl("/artists/{id}/albums", new { id = artistId }), new
{
filter = filter.ToString(),
offset = offset,
limit = limit,
token = Configuration.Token,
countryCode = GetCountryCode()
}, null, "GET")));
}
public AlbumListQueryResultDTO ListAllAlbums(AlbumFilter filter, int requiredPage = 1)
{
using (UnitOfWorkProvider.Create())
{
var query = GetQuery(filter);
query.Skip = Math.Max(0, requiredPage - 1) * PageSize;
query.Take = PageSize;
var sortOrder = filter.SortAscending ? SortDirection.Ascending : SortDirection.Descending;
query.AddSortCriteria(album => album.Name, sortOrder);
return(new AlbumListQueryResultDTO
{
RequestedPage = requiredPage,
TotalResultCount = query.GetTotalRowCount(),
ResultsPage = query.Execute(),
Filter = filter
});
}
}
public IEnumerable <Album> GetAllAlbumsPaged(out int totalCount, AlbumFilter filters,
List <SortItem> sorts, int pageIndex = 0, int pageSize = 15)
{
using (AlbumContext entityContext = new AlbumContext()) {
if (sorts.Count == 0)
{
sorts.Add(
new SortItem {
Column = "AlbumId", Direction = SortDirection.Ascending
});
}
IQueryable <Album> query;
query = entityContext.AlbumSet;
query = Filter(filters, query);
totalCount = query.Count();
query = Sort(sorts, query);
query = query.Skip((pageIndex) * pageSize).Take(pageSize);
var result = query.ToArray();
return(result);
}
}
public void GetAllAlbumsPaged_test()
{
Mock <IInventoryService> mockInventoryService
= new Mock <IInventoryService>();
Album[] albums = new Album[20];
for (int i = 0; i < 20; i++)
{
albums[i] = new Album {
AlbumId = i + 1
}
}
;
var albumFilter = new AlbumFilter {
AlbumNumber = "", Artist = "",
Title = "", Genre = 0, Price = 0, StockAmount = 0
};
var sortItems = new List <SortItem>();
int totalCount = 20;
mockInventoryService.Setup(obj => obj.GetAllAlbumsPaged(out totalCount, It.IsAny <AlbumFilter>(),
sortItems, 0, 4)).Returns(albums);
AlbumApiController controller = new AlbumApiController(mockInventoryService.Object);
dynamic response = controller.GetAllAlbumsPaged(Json.Encode(albumFilter),
Json.Encode(sortItems), 0, 4);
dynamic content = response.Content;
Assert.NotNull(content);
var data = content.albums;
Assert.Equal(data, albums);
var ttlCount = content.totalCount;
Assert.Equal(totalCount, ttlCount);
}
}
public IEnumerable <AlbumDTO> ListAlbums(AlbumFilter filter)
{
return(_albumService.ListAlbums(filter));
}
public Album[] GetAllAlbumsPaged(out int totalCount, AlbumFilter filters,
List <SortItem> sorts, int pageIndex, int pageSize)
{
return(Channel.GetAllAlbumsPaged(out totalCount, filters,
sorts, pageIndex, pageSize));
}
public JsonList<AlbumModel> GetArtistAlbums(Int32 artistId, AlbumFilter filter, Int32? offset, Int32? limit, Int32? timeout)
{
return HelperExtensions.Sync(() => this.GetArtistAlbums(artistId, filter, offset ?? 0, limit ?? 9999), timeout);
}
public JsonList <AlbumModel> GetArtistAlbums(Int32 artistId, AlbumFilter filter, Int32?offset, Int32?limit, Int32?timeout)
{
return(HelperExtensions.Sync(() => this.GetArtistAlbums(artistId, filter, offset ?? 0, limit ?? 9999), timeout));
}
public async Task<JsonList<AlbumModel>> GetArtistAlbums(Int32 artistId, AlbumFilter filter, Int32 offset = 0, Int32 limit = 9999)
{
return HandleResponse(await RestClient.Process<JsonList<AlbumModel>>(
RestUtility.FormatUrl("/artists/{id}/albums", new { id = artistId }), new
{
filter = filter.ToString(),
offset = offset,
limit = limit,
token = Configuration.Token,
countryCode = GetCountryCode()
}, null, "GET"));
}
