public async Task <Album> GetByAlbumTypeAsync(int albumTypeId, string albumName)
{
using (var db = new MusicUniEntities())
{
var album = await db.Albums.SingleOrDefaultAsync(p => p.Name == albumName && p.AlbumTypeId == albumTypeId);
return(album);
}
}
public async Task <AlbumType> GetByBandAsync(int bandId, string albumTypeName)
{
using (var db = new MusicUniEntities())
{
var albumType = await db.AlbumTypes.SingleOrDefaultAsync(p => p.Name == albumTypeName && p.BandId == bandId);
return(albumType);
}
}
public async Task<IEnumerable<File>> GetAllyAsync()
{
using (var db = new MusicUniEntities())
{
var file = await db.Files.OrderBy(g => g.FileName)
.ToListAsync();
return file;
}
}
public async Task <IEnumerable <AlbumType> > GetAllyAsync()
{
using (var db = new MusicUniEntities())
{
var albumType = await db.AlbumTypes.OrderBy(g => g.Name)
.ToListAsync();
return(albumType);
}
}
public async Task <IEnumerable <Genre> > GetAllyAsync()
{
using (var db = new MusicUniEntities())
{
var genre = await db.Genres.OrderBy(g => g.Name)
.ToListAsync();
return(genre);
}
}
public async Task <IEnumerable <Band> > GetAllyAsync()
{
using (var db = new MusicUniEntities())
{
var band = await db.Bands.OrderBy(g => g.Name)
.ToListAsync();
return(band);
}
}
public async Task<File> GetByAlbumAsync(int albumId, string fileName)
{
using (var db = new MusicUniEntities())
{
var file = await db.Files.SingleOrDefaultAsync(p => p.FileName == fileName && p.AlbumId == albumId);
return file;
}
}
public async Task<IEnumerable<File>> GetPageByAlbumAsync(int pageNumber, int pageSize, string albumName)
{
using (var db = new MusicUniEntities())
{
var skip = (pageNumber - 1) * pageSize;
return await db.Files.Where(p => p.Album.Name == albumName)
.OrderByDescending(p => p.FileName)
.Skip(skip)
.Take(pageSize)
.ToArrayAsync();
}
}
public async Task <IEnumerable <AlbumType> > GetPageByBandAsync(int pageNumber, int pageSize, string bandName)
{
using (var db = new MusicUniEntities())
{
var skip = (pageNumber - 1) * pageSize;
return(await db.AlbumTypes.Where(p => p.Band.Name == bandName)
.OrderByDescending(p => p.Name)
.Skip(skip)
.Take(pageSize)
.ToArrayAsync());
}
}
public async Task <IEnumerable <Band> > GetPageByGenreAsync(int pageNumber, int pageSize, string genreName)
{
using (var db = new MusicUniEntities())
{
var skip = (pageNumber - 1) * pageSize;
return(await db.Bands.Where(p => p.Genres.Any(g => g.Name == genreName))
.OrderByDescending(p => p.Name)
.Skip(skip)
.Take(pageSize)
.ToArrayAsync());
}
}
//public async Task<IEnumerable<Genre>> GetPageByCategoryAsync(int pageNumber, int pageSize, string category)
//{
// using (var db = new MusicUniEntities())
// {
// var skip = (pageNumber - 1) * pageSize;
// return await db.Genres.Where(p => p.Published < DateTime.Now && p.Category.Name == category)
// .Include("AspNetUser")
// .OrderByDescending(p => p.Published)
// .Skip(skip)
// .Take(pageSize)
// .ToArrayAsync();
// }
//}
public async Task <IEnumerable <Genre> > GetPageAsync(int pageNumber, int pageSize)
{
using (var db = new MusicUniEntities())
{
var skip = (pageNumber - 1) * pageSize;
return(await db.Genres
.OrderByDescending(p => p.Name)
.Skip(skip)
.Take(pageSize)
.ToArrayAsync());
}
}
public async Task <IEnumerable <Album> > GetPageByAlbumTypeAsync(int pageNumber, int pageSize, int albumTypeId)
{
using (var db = new MusicUniEntities())
{
var skip = (pageNumber - 1) * pageSize;
return(await db.Albums.Where(p => p.AlbumTypeId == albumTypeId)
.OrderByDescending(p => p.Name)
.Skip(skip)
.Take(pageSize)
.ToArrayAsync());
}
}
public async Task <Genre> GetByNameAsync(string name)
{
using (var db = new MusicUniEntities())
{
var genre = await db.Genres.SingleOrDefaultAsync(p => p.Name == name);
//if (genre == null)
//{
// throw new KeyNotFoundException("The Genre name \"" + name + "\" does not exist.");
//}
return(genre);
}
}
public async Task<File> GetByNameAsync(string fileName)
{
using (var db = new MusicUniEntities())
{
var file = await db.Files.SingleOrDefaultAsync(p => p.FileName == fileName);
//if (file == null)
//{
// throw new KeyNotFoundException("The File name \"" + fileName + "\" does not exist.");
//}
return file;
}
}
public async Task <Album> GetByNameAsync(string name)
{
using (var db = new MusicUniEntities())
{
var album = await db.Albums.SingleOrDefaultAsync(p => p.Name == name);
//if (album == null)
//{
// throw new KeyNotFoundException("The Album name \"" + name + "\" does not exist.");
//}
return(album);
}
}
public async Task <Album> GetByIdAsync(int id)
{
using (var db = new MusicUniEntities())
{
var album = await db.Albums.SingleOrDefaultAsync(p => p.Id == id);
//if (album == null)
//{
// throw new KeyNotFoundException("The Album Id \"" + id + "\" does not exist.");
//}
return(album);
}
}
public async Task <Band> GetByNameAsync(string name)
{
using (var db = new MusicUniEntities())
{
var band = await db.Bands.SingleOrDefaultAsync(p => p.Name == name);
//if (band == null)
//{
// throw new KeyNotFoundException("The Band name \"" + name + "\" does not exist.");
//}
return(band);
}
}
public async Task <Band> GetByIdAsync(int id)
{
using (var db = new MusicUniEntities())
{
var band = await db.Bands.SingleOrDefaultAsync(p => p.Id == id);
//if (band == null)
//{
// throw new KeyNotFoundException("The Band Id \"" + id + "\" does not exist.");
//}
return(band);
}
}
public async Task <Genre> GetByIdAsync(int id)
{
using (var db = new MusicUniEntities())
{
var genre = await db.Genres.SingleOrDefaultAsync(p => p.Id == id);
//if (genre == null)
//{
// throw new KeyNotFoundException("The Genre Id \"" + id + "\" does not exist.");
//}
return(genre);
}
}
public async Task DeleteAsync(int id)
{
using (var db = new MusicUniEntities())
{
var genre = await db.Genres.SingleOrDefaultAsync(p => p.Id == id);
if (genre == null)
{
throw new KeyNotFoundException("The genre with the id of " + id + "does not exist.");
}
db.Genres.Remove(genre);
await db.SaveChangesAsync();
}
}
public async Task CreateAsync(AlbumType model)
{
using (var db = new MusicUniEntities())
{
var albumType =
await db.AlbumTypes.SingleOrDefaultAsync(pro => pro.Name == model.Name && pro.BandId == model.BandId);
if (albumType != null)
{
throw new ArgumentException("A albumType with the id of " + model.Id + " already exsits.");
}
db.AlbumTypes.Add(model);
await db.SaveChangesAsync();
}
}
public async Task CreateAsync(File model)
{
using (var db = new MusicUniEntities())
{
var file =
await db.Files.SingleOrDefaultAsync(pro => pro.FileName == model.FileName && pro.AlbumId == model.AlbumId);
if (file != null)
{
throw new ArgumentException("A file with the id of " + model.Id + " already exsits.");
}
db.Files.Add(model);
await db.SaveChangesAsync();
}
}
public async Task EditAsync(int id, Genre updateItem)
{
using (var db = new MusicUniEntities())
{
var genre = await db.Genres.SingleOrDefaultAsync(p => p.Id == id);
if (genre == null)
{
throw new KeyNotFoundException("A genre withthe id of " + id + "does not exisst in the data store");
}
genre.Name = updateItem.Name;
await db.SaveChangesAsync();
}
}
public async Task CreateAsync(Genre model)
{
using (var db = new MusicUniEntities())
{
var genre =
await db.Genres.SingleOrDefaultAsync(pro => pro.Name == model.Name);
if (genre != null)
{
throw new ArgumentException("A genre with the id of " + model.Id + " already exsits.");
}
db.Genres.Add(model);
await db.SaveChangesAsync();
}
}
public async Task EditAsync(int id, Band updateItem)
{
using (var db = new MusicUniEntities())
{
var band = await db.Bands.SingleOrDefaultAsync(p => p.Id == id);
if (band == null)
{
throw new KeyNotFoundException("A band withthe id of " + id + "does not exisst in the data store");
}
band.Name = updateItem.Name;
band.Description = updateItem.Description;
band.ImageUrl = updateItem.ImageUrl;
await db.SaveChangesAsync();
}
}
public async Task EditAsync(int id, AlbumType updateItem)
{
using (var db = new MusicUniEntities())
{
var albumType = await db.AlbumTypes.SingleOrDefaultAsync(p => p.Id == id);
if (albumType == null)
{
throw new KeyNotFoundException("A albumType withthe id of " + id + "does not exisst in the data store");
}
albumType.Name = updateItem.Name;
albumType.Description = updateItem.Description;
albumType.ImageUrl = updateItem.ImageUrl;
albumType.BandId = updateItem.BandId;
await db.SaveChangesAsync();
}
}
public async Task SetBandToGenre(string bandName, string genreName)
{
using (var db = new MusicUniEntities())
{
var band = await db.Bands.SingleOrDefaultAsync(p => p.Name == bandName);
var genre = await db.Genres.SingleOrDefaultAsync(p => p.Name == genreName);
if (band == null)
{
throw new KeyNotFoundException("The band with the Name of " + bandName + "does not exist.");
}
if (genre == null)
{
throw new KeyNotFoundException("The genre with the Name of " + bandName + "does not exist.");
}
genre.Bands.Add(band);
await db.SaveChangesAsync();
}
}
public async Task EditAsync(int id, File updateItem)
{
using (var db = new MusicUniEntities())
{
var file = await db.Files.SingleOrDefaultAsync(p => p.Id == id);
if (file == null)
{
throw new KeyNotFoundException("A file withthe id of " + id + "does not exisst in the data store");
}
file.Price = updateItem.Price;
file.FileName = updateItem.FileName;
file.FilePath = updateItem.FilePath;
file.FileRoot = updateItem.FileRoot;
file.FileSize = updateItem.FileSize;
file.FileType = updateItem.FileType;
file.Description = updateItem.Description;
file.ImageUrl = updateItem.ImageUrl;
file.AlbumId = updateItem.AlbumId;
await db.SaveChangesAsync();
}
}
