// GET api/musicalbum/5
public MusicAlbum Get(int id)
{
MusicAlbum musicAlbum = null;
using (var ctx = new StoreEntities())
{
var albumRaw = (from album in ctx.Albums
where album.AlbumId == id
join artist in ctx.Artists on album.ArtistId equals artist.ArtistId
join genre in ctx.Genres on album.GenreId equals genre.GenreId
select new { album, artist, genre }).SingleOrDefault();
if (albumRaw != null)
{
musicAlbum = new MusicAlbum
{
Id = albumRaw.album.AlbumId,
Title = albumRaw.album.Title,
Price = albumRaw.album.Price,
Artist = new KeyValuePair <int, string>(albumRaw.artist.ArtistId, albumRaw.artist.Name),
Genre = new KeyValuePair <int, string>(albumRaw.genre.GenreId, albumRaw.genre.Name)
};
}
}
return(musicAlbum);
}
public async Task <IActionResult> PutMusicAlbum([FromRoute] int id, [FromBody] MusicAlbum musicAlbum)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != musicAlbum.Id)
{
return(BadRequest());
}
_context.Entry(musicAlbum).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MusicAlbumExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void GetAlbum_Method_IsValid()
{
var mock = new Mock <IMusicService>();
var musicAlbumMock = new MusicAlbum
{
Id = _id,
Description = "Description",
Logo = "Logo",
Singer = "Singer",
Title = "Title",
Type = 1,
Year = 2020
};
mock.Setup(repo => repo.GetAlbum(_id)).Returns(musicAlbumMock);
var controller = new MusicController(mock.Object);
var expected = new MusicAlbum
{
Id = _id,
Description = "Description",
Logo = "Logo",
Singer = "Singer",
Title = "Title",
Type = 1,
Year = 2020
};
var result = controller.GetAlbum(_id);
result.Should().BeEquivalentTo(expected);
}
public IHttpActionResult AddMusicAlbum([FromBody] MusicAlbumBindingModel musicAlbum)
{
if (musicAlbum == null)
{
return(this.BadRequest("Cannot create an empty music album model."));
}
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
if (musicAlbum.CoverImageData != null && musicAlbum.CoverImageData.IndexOf(',') == -1)
{
musicAlbum.CoverImageData = string.Format("{0}{1}", "data:image/jpg;base64,", musicAlbum.CoverImageData);
}
var user = this.Data.Users.Find(this.User.Identity.GetUserId());
var newMusicAlbum = new MusicAlbum
{
Title = musicAlbum.Title,
AuthorId = user.Id,
IsPublic = musicAlbum.IsPublic,
DateCreated = DateTime.Now,
CoverImageData = musicAlbum.CoverImageData
};
if (
this.Data.MusicAlbums.All()
.Any(a => a.Title == newMusicAlbum.Title && a.AuthorId == newMusicAlbum.AuthorId))
{
return(this.BadRequest("This music album already exists."));
}
this.Data.MusicAlbums.Add(newMusicAlbum);
this.Data.SaveChanges();
var userFollowers = user.FollowedBy.Select(u => u.Id);
foreach (var userId in userFollowers)
{
var notification = new Notification()
{
MusicAlbumId = newMusicAlbum.Id,
RecipientId = userId,
NotificationType = NotificationType.CreatedMusicAlbum,
DateCreated = DateTime.Now,
Message = user.UserName + " created music album."
};
this.Data.Notifications.Add(notification);
}
this.Data.SaveChanges();
var musicAlbumToReturn = Mapper.Map <MusicAlbumViewModel>(newMusicAlbum);
return(this.Ok(musicAlbumToReturn));
}
public void AutoMapper_Album_To_MusicAlbum_Mapping_IsValid()
{
var config = new MapperConfiguration(cfg =>
{
cfg.AddProfile(new MappingProfile());
});
var mapper = config.CreateMapper();
var expected = new MusicAlbum
{
Id = 101,
Description = "Description",
Logo = "Logo",
Singer = "Singer",
Title = "Title",
Type = 1,
Year = 2020
};
var source = new Album
{
AlbumId = 101,
Description = "Description",
Logo = "Logo",
Singer = "Singer",
Name = "Title",
Type = DataAccess.EF.Models.Enums.AlbumType.Cassette,
Year = 2020
};
var destination = mapper.Map <MusicAlbum>(source);
destination.Should().BeEquivalentTo(expected);
}
public void Insert(MusicAlbum musicAlbum)
{
musicAlbum.Id = NextIdValue();
_musicAlbums.Add(musicAlbum);
Save();
}
private static List <MusicAlbum> CreateAlbum()
{
Console.Write("Podaj liczbę płyt, którą chcesz dodać do pliku: ");
int quantity = Console.ReadLine().ParseInt();
List <MusicAlbum> albumList = new List <MusicAlbum>();
for (int i = 0; i < quantity; i++)
{
Console.WriteLine($"[{i}/{quantity}]");
Console.Write("Podaj tytuł: ");
string title = Console.ReadLine().NotEmptyString();
Console.Write("Podaj wykonawcę: ");
string artist = Console.ReadLine().NotEmptyString();
Console.Write("Nośnik: ");
string mediaType = Console.ReadLine().NotEmptyString();
Console.Write("Podaj rok wydania: ");
int releaseYear = Console.ReadLine().ParseInt().FitsReleaseYearRange();
MusicAlbum album = new MusicAlbum(title, artist, mediaType, releaseYear);
albumList.Add(album);
Console.WriteLine();
}
return(albumList);
}
public MusicAlbum UpdateAlbum(MusicAlbum updatedMusicAlbum)
{
var entity = db.MusicAlbums.Attach(updatedMusicAlbum);
entity.State = EntityState.Modified;
return(updatedMusicAlbum);
}
public void Add(MusicAlbum album)
{
var newAlbum = _mapper.Map <Album>(album);
_collectionRepository.InsertAlbum(newAlbum);
_collectionRepository.Save();
}
public ActionResult DeleteConfirmed(int id)
{
MusicAlbum musicAlbum = db.MusicAlbums.Find(id);
db.MusicAlbums.Remove(musicAlbum);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public IActionResult SaveMusicAlbum([Bind] MusicAlbum musicAlbum)
{
string resp = madb.AddMusicAlbum(musicAlbum);
TempData["msg"] = resp;
return(View());
}
public IActionResult OnGet(int musicAlbumId)
{
MusicAlbum = musicAlbum.GetById(musicAlbumId);
if (MusicAlbum == null)
{
return(RedirectToPage("./NotFound"));
}
return(Page());
}
public ActionResult Edit([Bind(Include = "Id,Genre,ArtistName,AlbumName,Song,Year,NumberOfSongs")] MusicAlbum musicAlbum)
{
if (ModelState.IsValid)
{
db.Entry(musicAlbum).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(musicAlbum));
}
public void Add_Method_Return_BadRequest()
{
var mock = new Mock <IMusicService>();
var controller = new MusicController(mock.Object);
MusicAlbum album = null;
var result = controller.Add(album);
Assert.IsInstanceOfType(result.Result, typeof(BadRequestResult));
}
public void MusicAlbumInstantiation()
{
var options = new MusicAlbumOptions();
SetMusicAlbumOptions(options);
var music_album = new MusicAlbum("-1", "-1", options);
AssertMusicAlbum(music_album, options);
AssertMusicAlbum(music_album, music_album.GetOptions());
}
public MusicAlbum Delete(string id)
{
MusicAlbum album = GetById(id);
if (album != null)
{
db.Albums.Remove(album);
}
return(album);
}
public IEnumerable <Audio> GetInstantMixFromAlbum(MusicAlbum item, User user)
{
var genres = item
.GetRecursiveChildren(user, true)
.OfType <Audio>()
.SelectMany(i => i.Genres)
.Concat(item.Genres)
.Distinct(StringComparer.OrdinalIgnoreCase);
return(GetInstantMixFromGenres(genres, user));
}
public IEnumerable <Audio> GetInstantMixFromAlbum(MusicAlbum item, User user)
{
var genres = item
.GetRecursiveChildren(user, i => i is Audio)
.Cast <Audio>()
.SelectMany(i => i.Genres)
.Concat(item.Genres)
.DistinctNames();
return(GetInstantMixFromGenres(genres, user));
}
public ActionResult <MusicAlbum> Add([FromBody] MusicAlbum album)
{
if (album == null)
{
return(BadRequest());
}
_musicService.Add(album);
return(CreatedAtAction(nameof(GetAlbum), new { id = album.Id, controller = "Music" }, album));
}
public ActionResult Create([Bind(Include = "Id,Genre,ArtistName,AlbumName,Song,Year,NumOfSongs")] MusicAlbum musicAlbum)
{
if (ModelState.IsValid)
{
db.MusicAlbums.Add(musicAlbum);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(musicAlbum));
}
// PUT api/musicalbum/5
public void Put(int id, MusicAlbum musicAlbum)
{
using (var ctx = new StoreEntities())
{
var albumRaw = ctx.Albums.Single(q => q.AlbumId == id);
albumRaw.Title = musicAlbum.Title;
albumRaw.Price = musicAlbum.Price;
albumRaw.ArtistId = musicAlbum.Artist.Key;
albumRaw.GenreId = musicAlbum.Genre.Key;
ctx.SaveChanges();
}
}
public void Update(MusicAlbum UpdateMusicAlbum)
{
var oldMusicAlbum = _musicAlbums.Where(b => b.Id == UpdateMusicAlbum.Id).FirstOrDefault();
if (oldMusicAlbum != null)
{
_musicAlbums.Remove(oldMusicAlbum);
_musicAlbums.Add(UpdateMusicAlbum);
}
Save();
}
public ActionResult Delete(int id)
{
MusicAlbumRepository musicAlbumRepository = new MusicAlbumRepository();
MusicAlbum musicAlbum = new MusicAlbum();
using (musicAlbumRepository)
{
musicAlbum = musicAlbumRepository.SelectOne(id);
}
return(View(musicAlbum));
}
public async Task <IActionResult> PostMusicAlbum([FromBody] MusicAlbum musicAlbum)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.MusicAlbums.Add(musicAlbum);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetMusicAlbum", new { id = musicAlbum.Id }, musicAlbum));
}
static void AssertMusicAlbum(MusicAlbum musicAlbum, MusicAlbumOptions options)
{
AssertAlbum(musicAlbum, options);
Assert.AreEqual(musicAlbum.Toc, options.Toc);
Assert.IsTrue(musicAlbum.Artists.IsReadOnly);
Assert.IsTrue(musicAlbum.Genres.IsReadOnly);
Assert.IsTrue(musicAlbum.Producers.IsReadOnly);
Assert.IsTrue(musicAlbum.AlbumArtUris.IsReadOnly);
CollectionAssert.AreEqual(musicAlbum.Artists, options.Artists);
CollectionAssert.AreEqual(musicAlbum.Genres, options.Genres);
CollectionAssert.AreEqual(musicAlbum.Producers, options.Producers);
CollectionAssert.AreEqual(musicAlbum.AlbumArtUris, options.AlbumArtUris);
}
// POST api/musicalbum
public void Post(MusicAlbum musicAlbum)
{
using (var ctx = new StoreEntities())
{
ctx.Albums.Add(new Album
{
Title = musicAlbum.Title,
Price = musicAlbum.Price,
ArtistId = musicAlbum.Artist.Key,
GenreId = musicAlbum.Genre.Key
});
ctx.SaveChanges();
}
}
public IEnumerable <Audio> GetInstantMixFromAlbum(MusicAlbum item, User user)
{
var genres = item
.GetRecursiveChildren(user, new InternalItemsQuery(user)
{
IncludeItemTypes = new[] { typeof(Audio).Name }
})
.Cast <Audio>()
.SelectMany(i => i.Genres)
.Concat(item.Genres)
.DistinctNames();
return(GetInstantMixFromGenres(genres, user));
}
public MusicAlbum UpdateAlbum(MusicAlbum updatedAlbum)
{
//Console.WriteLine($"updating album id: {updatedAlbum.Id}");
var album = musicAlbums.SingleOrDefault(x => x.Id == updatedAlbum.Id);
if (album != null)
{
album.AlbumName = updatedAlbum.AlbumName;
album.Description = updatedAlbum.Description;
album.YearRelase = updatedAlbum.YearRelase;
album.Genre = updatedAlbum.Genre;
}
return(album);
}
// GET: MusicAlbums/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
MusicAlbum musicAlbum = db.MusicAlbums.Find(id);
if (musicAlbum == null)
{
return(HttpNotFound());
}
return(View(musicAlbum));
}
/// <summary>
/// Gets the data.
/// </summary>
/// <param name="album">The album.</param>
/// <returns>Guid.</returns>
private Guid GetComparisonData(MusicAlbum album)
{
var songs = album.RecursiveChildren.OfType <Audio>().ToList();
var albumArtists = songs.Select(i => i.AlbumArtist)
.Where(i => !string.IsNullOrEmpty(i))
.Distinct(StringComparer.OrdinalIgnoreCase)
.ToList();
var albumNames = songs.Select(i => i.AlbumArtist)
.Where(i => !string.IsNullOrEmpty(i))
.Distinct(StringComparer.OrdinalIgnoreCase)
.ToList();
albumArtists.AddRange(albumNames);
return(string.Join(string.Empty, albumArtists.OrderBy(i => i).ToArray()).GetMD5());
}
