public async Task <ArtistList> ListAsync(int pageIndex, int pageSize, PublishStatus statusFlags = PublishStatus.PUBLISHED)
{
pageSize = Math.Min(pageSize, _maxPageSize);
ArtistList result = new ArtistList()
{
PageIndex = pageIndex,
PageSize = pageSize,
TotalItems = 0
};
PublishedStatusEnumMapper statusMapper = new PublishedStatusEnumMapper();
DbPublishedStatus contentStatusFlags = statusMapper.Map(statusFlags);
var artistsQuery = this._context.Artists.AsQueryable();
// bitwise & the status flags and check the result is not 0 to get any records matching flags
artistsQuery = artistsQuery.Where(a => (a.PublishStatus & contentStatusFlags) != 0);
int totalRecords = await artistsQuery.CountAsync();
artistsQuery = artistsQuery.Skip(pageSize * pageIndex).Take(pageSize);
var dbArtists = await artistsQuery
.Include(x => x.ArtistGenres)
.ThenInclude(x => x.Genre)
.ToListAsync();
result.TotalItems = totalRecords;
result.Items = dbArtists.Select(a => _mapper.MapToDetailRep(a)).ToList();
return(result);
}
public async Task <GenreDetail> GetAsync(string genre, PublishStatus?contentPublicationFlags = null)
{
PublishedStatusEnumMapper statusMapper = new PublishedStatusEnumMapper();
DbPublishedStatus contentStatusFlags = statusMapper.GetAllDbFlags();
if (contentPublicationFlags.HasValue)
{
contentStatusFlags = statusMapper.Map(contentPublicationFlags.Value);
}
var dbGenre = await _context.Genres.SingleOrDefaultAsync(x => x.Name == genre);
if (dbGenre != null)
{
var numAlbums = await _context.Genres.Where(g => g.Name == genre).SelectMany(x => x.AlbumGenres).CountAsync(x => x.Album.PublishStatus == DbPublishedStatus.PUBLISHED);
var numArtists = await _context.Genres.Where(g => g.Name == genre).SelectMany(x => x.ArtistGenres).CountAsync(x => x.Artist.PublishStatus == DbPublishedStatus.PUBLISHED);
GenreDetail result = new GenreDetail()
{
Name = dbGenre.Name,
TotalAlbums = numAlbums,
TotalArtists = numArtists,
Created = new DateTime(dbGenre.CreatedUtc.Ticks, DateTimeKind.Utc)
};
return(result);
}
else
{
return(null);
}
}
public void MappingToDbEnum_WithMultipleFlags_HasExpectedFlags()
{
PublishedStatusEnumMapper mapper = new PublishedStatusEnumMapper();
DbPublishedStatus result = mapper.Map(PublishStatus.ARCHIVED | PublishStatus.PUBLISHED);
Assert.True(result.HasFlag(DbPublishedStatus.ARCHIVED));
Assert.True(result.HasFlag(DbPublishedStatus.PUBLISHED));
Assert.False(result.HasFlag(DbPublishedStatus.UNPUBLISHED));
Assert.False(result.HasFlag(DbPublishedStatus.DELETED));
}
public void MapToDetailRep_HasPublishedStatus_WithValidInput(DbPublishedStatus publishedStatusTestCase)
{
DbArtist sourceObj = _validDbArtist;
sourceObj.PublishStatus = publishedStatusTestCase;
PublishedStatusEnumMapper statusMapper = new PublishedStatusEnumMapper();
ArtistMapper mapper = new ArtistMapper();
PublishStatus expetedStatus = statusMapper.Map(publishedStatusTestCase);
ArtistDetail result = mapper.MapToDetailRep(sourceObj);
ICollection <string> dbGenres = _validDbArtist.ArtistGenres.Select(x => x.Genre.Name).ToList();
Assert.Equal(expetedStatus, result.PublishedStatus);
}
public async Task <ICollection <ArtistNameRef> > ListNamesAsync(PublishStatus statusFlags)
{
PublishedStatusEnumMapper statusMapper = new PublishedStatusEnumMapper();
DbPublishedStatus contentStatusFlags = statusMapper.Map(statusFlags);
var artistsQuery = this._context.Artists.AsQueryable();
// bitwise & the status flags and check the result is not 0 to get any records matching flags
artistsQuery = artistsQuery.Where(a => (a.PublishStatus & contentStatusFlags) != 0);
var result = await artistsQuery.Select(x => new ArtistNameRef {
Id = x.Id,
Name = x.Name,
Status = statusMapper.Map(x.PublishStatus)
}).ToListAsync();
return(result);
}
/// <summary>
/// Gets a list of albums joined against the selected group and ordered by index
/// </summary>
public async Task <AlbumList> ListByAlbumGroupKeyAsync(string albumGroupKey, int pageIndex, int pageSize, PublishStatus statusFlags)
{
pageSize = Math.Min(pageSize, _maxPageSize);
if (pageIndex < 0)
{
pageIndex = 0;
}
PublishedStatusEnumMapper statusMapper = new PublishedStatusEnumMapper();
DbPublishedStatus contentStatusFlags = statusMapper.Map(statusFlags);
var group = await _context.AlbumGroups.SingleOrDefaultAsync(g => g.Key == albumGroupKey);
if (group == null)
{
throw new EntityNotFoundRepositoryException($"Group with key {albumGroupKey} not found");
}
AlbumList result = new AlbumList()
{
PageIndex = pageIndex,
PageSize = pageSize,
TotalItems = 0
};
var dbItems = _context.AlbumGroups
.Where(g => g.Key == albumGroupKey)
.SelectMany(g => g.Items).OrderBy(x => x.PositionIndex)
.Include(x => x.Album).ThenInclude(x => x.Artist)
.Include(x => x.Album).ThenInclude(x => x.AlbumGenres)
.ThenInclude(x => x.Genre)
.Include(x => x.Album).ThenInclude(x => x.Tracks);
result.TotalItems = await dbItems.CountAsync();
var pageItems = dbItems.Skip(pageSize * pageIndex).Take(pageSize);
var resultSet = await pageItems
.ToListAsync();
result.Items = resultSet.Select(a => _mapper.MapToDetailRep(a.Album)).ToList();
return(result);
}
public async Task <GenreList> ListAsync(PublishStatus?contentPublicationFlags = null)
{
PublishedStatusEnumMapper statusMapper = new PublishedStatusEnumMapper();
DbPublishedStatus contentStatusFlags = statusMapper.GetAllDbFlags();
if (contentPublicationFlags.HasValue)
{
contentStatusFlags = statusMapper.Map(contentPublicationFlags.Value);
}
List <GenreDetail> genres = await _context.Genres.Select(g => new GenreDetail {
Name = g.Name,
Created = new DateTime(g.CreatedUtc.Ticks, DateTimeKind.Utc),
TotalAlbums = g.AlbumGenres.Count(x => (x.Album.PublishStatus & contentStatusFlags) != 0),
TotalArtists = g.ArtistGenres.Count(x => (x.Artist.PublishStatus & contentStatusFlags) != 0)
}).ToListAsync();
GenreList result = new GenreList()
{
Genres = genres
};
return(result);
}
private async Task <AlbumList> ListAsyncInternal(int pageIndex, int pageSize, PublishStatus statusFlags, Expression <Func <DbAlbum, bool> > searchExpression = null)
{
pageSize = Math.Min(pageSize, _maxPageSize);
if (pageIndex < 0)
{
pageIndex = 0;
}
PublishedStatusEnumMapper statusMapper = new PublishedStatusEnumMapper();
DbPublishedStatus contentStatusFlags = statusMapper.Map(statusFlags);
AlbumList result = new AlbumList()
{
PageIndex = pageIndex,
PageSize = pageSize,
TotalItems = 0
};
var dbItems = this._context.Albums.Where(a => (a.PublishStatus & contentStatusFlags) != 0);
// apply an optional search expression on the list query to filter it
if (searchExpression != null)
{
dbItems = dbItems.Where(searchExpression);
}
int totalRecords = await dbItems.CountAsync();
dbItems = dbItems.Skip(pageSize * pageIndex).Take(pageSize);
var dbAlbums = await dbItems
.Include(x => x.Artist)
.Include(x => x.AlbumGenres)
.ThenInclude(x => x.Genre)
.Include(x => x.Tracks)
.ToListAsync();
result.TotalItems = totalRecords;
result.Items = dbAlbums.Select(a => _mapper.MapToDetailRep(a)).ToList();
return(result);
}
public PublishStatus Map(DbPublishedStatus input)
{
return(Enum.Parse <PublishStatus>(input.ToString()));
}
public void MappingFromDbEnum_ProducesSameFlagsOnOutput(DbPublishedStatus input, PublishStatus expectedOutput)
{
PublishedStatusEnumMapper mapper = new PublishedStatusEnumMapper();
Assert.Equal(expectedOutput, mapper.Map(input));
}
