public IHttpActionResult Put(int id, [FromBody] AlbumRequestModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var album = this.context.GetById(id);
if (album == null)
{
return(this.BadRequest("Album not found!"));
}
if (allData.Producers.Find(model.ProducerId) == null)
{
return(this.BadRequest("No such producer can be found."));
}
if (this.AddArtistsToAlbum(model.ArtistIds, album) == null || this.AddSongsToAlbum(model.SongIds, album) == null)
{
return(this.BadRequest("No such song/artist can be found."));
}
this.context.Update(album);
this.context.Save();
return(this.Ok("[" + album.Title + "] album has been UPDATED!"));
}
public IHttpActionResult Post(AlbumRequestModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var currentUser = this.users
.All()
.FirstOrDefault(u => u.UserName == this.User.Identity.Name);
if (currentUser == null)
{
return(this.Unauthorized());
}
var newAlbum = new Album
{
Title = model.Title,
User = currentUser
};
this.albums.Add(newAlbum);
this.albums.SaveChanges();
return(this.Ok(newAlbum.Id));
}
public IHttpActionResult Put(int id, AlbumRequestModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var album = this.data.Albums
.All()
.FirstOrDefault(a => a.Id == id);
if (album == null)
{
return(this.BadRequest("Album with id " + id + " does not exist!"));
}
album.Title = model.Title;
album.Year = model.Year;
album.Producer = model.Producer;
this.data.Albums.Update(album);
this.data.Albums.SaveChanges();
return(this.Ok(model));
}
public IHttpActionResult ById(int id)
{
if (!this.ModelState.IsValid)
{
return BadRequest(ModelState);
}
var dbAlbum = this.data
.Albums
.All()
.FirstOrDefault(a => a.Id == id);
if (dbAlbum == null)
{
return BadRequest("Such album does not exist in database!");
}
var album = new AlbumRequestModel
{
Producer = dbAlbum.Producer,
Title = dbAlbum.Title,
Year = dbAlbum.Year
};
album.Id = dbAlbum.Id;
return Ok(album);
}
public IHttpActionResult Put(int id, AlbumRequestModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var album = this.albums
.All()
.FirstOrDefault(a => a.Id == id);
if (album == null)
{
return(this.NotFound());
}
if (album.User.UserName != this.User.Identity.Name)
{
return(this.Unauthorized());
}
album.Title = model.Title;
this.albums.Update(album);
this.albums.SaveChanges();
return(this.Ok("Album updated"));
}
public IHttpActionResult Post(AlbumRequestModel requestAlbum)
{
var album = Mapper.Map <Album>(requestAlbum);
album = this.albums.Add(album);
return(this.Created("/", Mapper.Map <AlbumResponseModel>(album)));
}
public IHttpActionResult Put(int id, AlbumRequestModel requestAlbum)
{
var album = Mapper.Map <Album>(requestAlbum);
album = this.albums.Update(id, album);
return(this.Ok(Mapper.Map <AlbumResponseModel>(album)));
}
public void PutWithInvalidUserShouldReturnUnauthorisedResult()
{
var controller = ControllerMockFactory.GetAlbumsController(this.albums, this.users, this.photos, false);
var correctedTitleAlbum = new AlbumRequestModel()
{
Title = TestConstants.ValidTitle
};
var result = controller.Put(1, correctedTitleAlbum);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(UnauthorizedResult));
}
public void PostWithFakeAccountShouldReturnUnauthorisedResult()
{
var controller = ControllerMockFactory.GetAlbumsController(
this.albums, this.users, this.photos, false);
var albumToBeAdded = new AlbumRequestModel()
{
Title = TestConstants.ValidTitle
};
var result = controller.Post(albumToBeAdded);
Assert.IsInstanceOfType(result, typeof(UnauthorizedResult));
}
public void PutWithBadAlbumIdShouldReturnNotFoundResult()
{
var controller = ControllerMockFactory.GetAlbumsController(this.albums, this.users, this.photos);
var correctedTitleAlbum = new AlbumRequestModel()
{
Title = TestConstants.ValidTitle
};
var result = controller.Put(TestConstants.DefaultNonExistingModelId, correctedTitleAlbum);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public IHttpActionResult Put(int id, AlbumRequestModel model)
{
var albumToUpdate = this.albums
.All()
.FirstOrDefault(a => a.Id == id);
if (albumToUpdate == null)
{
return(this.NotFound());
}
if (!this.ModelState.IsValid || model == null)
{
return(this.BadRequest(this.ModelState));
}
albumToUpdate.Title = model.Title;
albumToUpdate.ProducerName = model.ProducerName;
albumToUpdate.PublishYear = model.PublishYear;
foreach (var songId in model.SongIds)
{
var currentSong = this.songs
.All()
.FirstOrDefault(s => s.Id == songId);
if (currentSong != null)
{
albumToUpdate.Songs.Add(currentSong);
}
}
foreach (var artistId in model.ArtistIds)
{
var currentArtist = this.artists
.All()
.FirstOrDefault(a => a.Id == artistId);
if (currentArtist != null)
{
albumToUpdate.Artists.Add(currentArtist);
}
}
this.albums.SaveChanges();
return(this.Ok("The album was successfully updated."));
}
public void PutWithInvalidModelStateShouldReturnInvalidModelStateResultWithContent()
{
var controller = ControllerMockFactory.GetAlbumsController(this.albums, this.users, this.photos);
controller.ModelState.AddModelError("title", "Title cannot be null.");
var emptyAlbum = new AlbumRequestModel();
var result = controller.Put(0, emptyAlbum);
var expectedUpdates = 0;
var expectedSaveChangesCalls = 0;
Assert.IsInstanceOfType(result, typeof(InvalidModelStateResult));
Assert.AreEqual(expectedUpdates, this.albums.UpdatedEntities.Count);
Assert.AreEqual(expectedSaveChangesCalls, this.albums.NumberOfSaves);
}
public IHttpActionResult Get()
{
// TODO does not work properly with Mapper so I did it by hand but needs more work
var artists = db.Artists
.AsQueryable()
.ToList();
var artistModels = new List <ArtistRequestModel>();
foreach (var artist in artists)
{
var albums = new List <AlbumRequestModel>();
foreach (var album in artist.Albums)
{
var albumModel = new AlbumRequestModel
{
Producer = album.Producer,
Title = album.Title,
Year = album.Year
};
albums.Add(albumModel);
}
var songs = new List <SongRequestModel>();
foreach (var song in artist.Songs)
{
var songToAdd = new SongRequestModel
{
Title = song.Title,
GenreName = song.Genre.Name,
Year = song.Year
};
songs.Add(songToAdd);
}
var artistToAdd = new ArtistRequestModel
{
Name = artist.Name,
Albums = albums,
Songs = songs
};
artistModels.Add(artistToAdd);
}
return(this.Ok(artistModels));
}
public IHttpActionResult Get()
{
// TODO does not work properly with Mapper so I did it by hand but needs more work
var artists = db.Artists
.AsQueryable()
.ToList();
var artistModels = new List<ArtistRequestModel>();
foreach (var artist in artists)
{
var albums = new List<AlbumRequestModel>();
foreach (var album in artist.Albums)
{
var albumModel = new AlbumRequestModel
{
Producer = album.Producer,
Title = album.Title,
Year = album.Year
};
albums.Add(albumModel);
}
var songs = new List<SongRequestModel>();
foreach (var song in artist.Songs)
{
var songToAdd = new SongRequestModel
{
Title = song.Title,
GenreName = song.Genre.Name,
Year = song.Year
};
songs.Add(songToAdd);
}
var artistToAdd = new ArtistRequestModel
{
Name = artist.Name,
Albums = albums,
Songs = songs
};
artistModels.Add(artistToAdd);
}
return this.Ok(artistModels);
}
public void PostWithValidDataShouldReturnOkResult()
{
var controller = ControllerMockFactory.GetAlbumsController(this.albums, this.users, this.photos);
var albumToBeAdded = new AlbumRequestModel()
{
Title = TestConstants.ValidTitle
};
var result = controller.Post(albumToBeAdded);
var expectedSaveChanges = 1;
var expectedAlbumsAfterChange = TestConstants.DefaultNumberOfModels + 1;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <int>));
Assert.AreEqual(expectedAlbumsAfterChange, this.albums.NumberOfModels);
Assert.AreEqual(expectedSaveChanges, this.albums.NumberOfSaves);
}
public IHttpActionResult Post(AlbumRequestModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var album = new Album
{
Title = model.Title,
Year = model.Year,
Producer = model.Producer
};
this.data.Albums.Add(album);
this.data.Albums.SaveChanges();
return(this.Ok(album));
}
/// <summary>
/// Expect AlbumRequestModel with valid title, year (2 digits), ProducerName , ArtistIds (array) - it can be empty,
/// and SongIds (array) - it can be empty
/// </summary>
/// <param name="model"></param>
/// <returns>
/// If the album is added returns IHttpActionResult with status code 200 OK
/// If the input album in not in the valid format retunrs IHttpActionResult with status code 400 Bad Request
/// </returns>
public IHttpActionResult Post(AlbumRequestModel model)
{
if (!this.ModelState.IsValid || model == null)
{
return(this.BadRequest(this.ModelState));
}
var albumToAdd = new Album()
{
Title = model.Title,
ProducerName = model.ProducerName,
PublishYear = model.PublishYear
};
foreach (var songId in model.SongIds)
{
var currentSong = this.songs
.All()
.FirstOrDefault(s => s.Id == songId);
if (currentSong != null)
{
albumToAdd.Songs.Add(currentSong);
}
}
foreach (var artistId in model.ArtistIds)
{
var currentArtist = this.artists
.All()
.FirstOrDefault(a => a.Id == artistId);
if (currentArtist != null)
{
albumToAdd.Artists.Add(currentArtist);
}
}
this.albums.Add(albumToAdd);
this.albums.SaveChanges();
return(this.Ok("The album was successfully added."));
}
public IHttpActionResult Create(AlbumRequestModel album)
{
if (!this.ModelState.IsValid)
{
return BadRequest(this.ModelState);
}
var newAlbum = new Album
{
Title = album.Title,
Year = album.Year,
Producer = album.Producer
};
this.data.Albums.Add(newAlbum);
this.data.Albums.SaveChanges();
return Ok(new { Album = album, Id = newAlbum.Id });
}
public IHttpActionResult Create(AlbumRequestModel album)
{
if (!this.ModelState.IsValid)
{
return(BadRequest(this.ModelState));
}
var newAlbum = new Album
{
Title = album.Title,
Year = album.Year,
Producer = album.Producer
};
this.data.Albums.Add(newAlbum);
this.data.Albums.SaveChanges();
return(Ok(new { Album = album, Id = newAlbum.Id }));
}
public IHttpActionResult Post(AlbumRequestModel album)
{
if (!this.ModelState.IsValid)
{
return this.BadRequest(this.ModelState);
}
var albumToPost = new Album()
{
Title = album.Title,
Year = album.Year,
Producer = album.Producer
};
this.db.Albums.Add(albumToPost);
this.db.SaveChanges();
return this.Ok(album);
}
public void PutWithValidDataProvidedShouldReturnOkResult()
{
var controller = ControllerMockFactory.GetAlbumsController(this.albums, this.users, this.photos);
var correctedTitleAlbum = new AlbumRequestModel()
{
Title = "CoolTitle"
};
var result = controller.Put(0, correctedTitleAlbum);
var actual = result as OkNegotiatedContentResult <string>;
var expectedContent = "Album updated";
var expectedUpdates = 1;
var expectedSaveChangesCalls = 1;
Assert.AreEqual(expectedContent, actual.Content);
Assert.AreEqual(expectedUpdates, this.albums.UpdatedEntities.Count);
Assert.AreEqual(expectedSaveChangesCalls, this.albums.NumberOfSaves);
}
public IHttpActionResult Update(int id, AlbumRequestModel album)
{
if (!this.ModelState.IsValid)
{
return(BadRequest(this.ModelState));
}
var albumInDb = this.data.Albums
.All()
.FirstOrDefault(c => c.Id == id);
albumInDb.Title = album.Title;
albumInDb.Year = album.Year;
albumInDb.Price = album.Price;
albumInDb.Producer = album.Producer;
this.data.Albums.SaveChanges();
return(Ok(albumInDb));
}
// POST: api/Album
public IHttpActionResult Post(AlbumRequestModel albumInfo)
{
if (albumInfo == null)
{
return(this.BadRequest());
}
var albumToAdd = new Album
{
Title = albumInfo.Title,
Year = albumInfo.Year,
};
albumToAdd.Producer = this.producerData.All().FirstOrDefault(p => p.Name == albumInfo.Producer);
this.albumData.Add(albumToAdd);
this.albumData.SaveChanges();
return(this.Ok());
}
public IHttpActionResult Update(int id, AlbumRequestModel album)
{
if (!this.ModelState.IsValid)
{
return BadRequest(this.ModelState);
}
var albumInDb = this.data.Albums
.All()
.FirstOrDefault(c => c.Id == id);
albumInDb.Title = album.Title;
albumInDb.Year = album.Year;
albumInDb.Price = album.Price;
albumInDb.Producer = album.Producer;
this.data.Albums.SaveChanges();
return Ok(albumInDb);
}
public IHttpActionResult Post([FromBody] AlbumRequestModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var songIds = model.SongIds.ToList();
var artistsIds = model.ArtistIds.ToList();
var album = new Album
{
Title = model.Title,
ProducerId = model.ProducerId
};
this.context.AddEntity(album);
this.context.Save();
return(this.Created(this.Url.ToString(), album));
}
public IHttpActionResult Post([FromBody] AlbumRequestModel album)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var newAlbum = new Album
{
Title = album.Title,
Year = album.Year,
Producer = album.Producer,
Artists = album.Artists,
Songs = album.Songs
};
this.repository.Insert(newAlbum);
this.repository.SaveChanges();
return(this.Ok(newAlbum));
}
public IHttpActionResult Put(int id, [FromBody] AlbumRequestModel album)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var currentAlbum = this.repository.SelectById(id);
if (currentAlbum == null)
{
return(this.BadRequest("Invalid Id"));
}
currentAlbum.Title = string.IsNullOrEmpty(album.Title) ? currentAlbum.Title : album.Title;
currentAlbum.Year = album.Year;
currentAlbum.Producer = string.IsNullOrEmpty(album.Producer) ? currentAlbum.Producer : album.Producer;
this.repository.Update(currentAlbum);
this.repository.SaveChanges();
return(this.Ok(currentAlbum));
}
// PUT: api/Album/5
public IHttpActionResult Put(int id, AlbumRequestModel albumInfo)
{
if (albumInfo == null)
{
return(this.BadRequest());
}
var albumToModify = this.albumData.All()
.FirstOrDefault(a => a.AlbumId == id);
if (albumToModify == null)
{
return(this.BadRequest(string.Format("Album with id {0} not found!", id)));
}
albumToModify.Title = albumInfo.Title;
albumToModify.Year = albumInfo.Year;
albumToModify.Producer = this.producerData.All().FirstOrDefault(p => p.Name == albumInfo.Producer);
this.albumData.SaveChanges();
return(this.Ok());
}
public void PutWithInvalidModelStateShouldReturnInvalidModelStateResultWithContent()
{
var controller = ControllerMockFactory.GetAlbumsController(this.albums, this.users, this.photos);
controller.ModelState.AddModelError("title", "Title cannot be null.");
var emptyAlbum = new AlbumRequestModel();
var result = controller.Put(0, emptyAlbum);
var expectedUpdates = 0;
var expectedSaveChangesCalls = 0;
Assert.IsInstanceOfType(result, typeof(InvalidModelStateResult));
Assert.AreEqual(expectedUpdates, this.albums.UpdatedEntities.Count);
Assert.AreEqual(expectedSaveChangesCalls, this.albums.NumberOfSaves);
}
public void PutWithBadAlbumIdShouldReturnNotFoundResult()
{
var controller = ControllerMockFactory.GetAlbumsController(this.albums, this.users, this.photos);
var correctedTitleAlbum = new AlbumRequestModel() { Title = TestConstants.ValidTitle };
var result = controller.Put(TestConstants.DefaultNonExistingModelId, correctedTitleAlbum);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
public void PostWithValidDataShouldReturnOkResult()
{
var controller = ControllerMockFactory.GetAlbumsController(this.albums, this.users, this.photos);
var albumToBeAdded = new AlbumRequestModel() { Title = TestConstants.ValidTitle };
var result = controller.Post(albumToBeAdded);
var expectedSaveChanges = 1;
var expectedAlbumsAfterChange = TestConstants.DefaultNumberOfModels + 1;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(OkNegotiatedContentResult<int>));
Assert.AreEqual(expectedAlbumsAfterChange, this.albums.NumberOfModels);
Assert.AreEqual(expectedSaveChanges, this.albums.NumberOfSaves);
}
public void PostWithFakeAccountShouldReturnUnauthorisedResult()
{
var controller = ControllerMockFactory.GetAlbumsController(
this.albums, this.users, this.photos, false);
var albumToBeAdded = new AlbumRequestModel() { Title = TestConstants.ValidTitle };
var result = controller.Post(albumToBeAdded);
Assert.IsInstanceOfType(result, typeof(UnauthorizedResult));
}
/// <summary>
/// Expect AlbumRequestModel with valid title, year (2 digits), ProducerName , ArtistIds (array) - it can be empty,
/// and SongIds (array) - it can be empty
/// </summary>
/// <param name="model"></param>
/// <returns>
/// If the album is added returns IHttpActionResult with status code 200 OK
/// If the input album in not in the valid format retunrs IHttpActionResult with status code 400 Bad Request
/// </returns>
public IHttpActionResult Post(AlbumRequestModel model)
{
if (!this.ModelState.IsValid || model == null)
{
return this.BadRequest(this.ModelState);
}
var albumToAdd = new Album()
{
Title = model.Title,
ProducerName = model.ProducerName,
PublishYear = model.PublishYear
};
foreach (var songId in model.SongIds)
{
var currentSong = this.songs
.All()
.FirstOrDefault(s => s.Id == songId);
if (currentSong != null)
{
albumToAdd.Songs.Add(currentSong);
}
}
foreach (var artistId in model.ArtistIds)
{
var currentArtist = this.artists
.All()
.FirstOrDefault(a => a.Id == artistId);
if (currentArtist != null)
{
albumToAdd.Artists.Add(currentArtist);
}
}
this.albums.Add(albumToAdd);
this.albums.SaveChanges();
return this.Ok("The album was successfully added.");
}
public IHttpActionResult Put(int id, AlbumRequestModel model)
{
if (!this.ModelState.IsValid)
{
return this.BadRequest(this.ModelState);
}
var album = this.albums
.All()
.FirstOrDefault(a => a.Id == id);
if (album == null)
{
return this.NotFound();
}
if (album.User.UserName != this.User.Identity.Name)
{
return this.Unauthorized();
}
album.Title = model.Title;
this.albums.Update(album);
this.albums.SaveChanges();
return this.Ok("Album updated");
}
public IHttpActionResult Post(AlbumRequestModel model)
{
if (!this.ModelState.IsValid)
{
return this.BadRequest(this.ModelState);
}
var currentUser = this.users
.All()
.FirstOrDefault(u => u.UserName == this.User.Identity.Name);
if (currentUser == null)
{
return this.Unauthorized();
}
var newAlbum = new Album
{
Title = model.Title,
User = currentUser
};
this.albums.Add(newAlbum);
this.albums.SaveChanges();
return this.Ok(newAlbum.Id);
}
public void PutWithInvalidUserShouldReturnUnauthorisedResult()
{
var controller = ControllerMockFactory.GetAlbumsController(this.albums, this.users, this.photos, false);
var correctedTitleAlbum = new AlbumRequestModel() { Title = TestConstants.ValidTitle };
var result = controller.Put(1, correctedTitleAlbum);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(UnauthorizedResult));
}
public void PutWithValidDataProvidedShouldReturnOkResult()
{
var controller = ControllerMockFactory.GetAlbumsController(this.albums, this.users, this.photos);
var correctedTitleAlbum = new AlbumRequestModel() { Title = "CoolTitle" };
var result = controller.Put(0, correctedTitleAlbum);
var actual = result as OkNegotiatedContentResult<string>;
var expectedContent = "Album updated";
var expectedUpdates = 1;
var expectedSaveChangesCalls = 1;
Assert.AreEqual(expectedContent, actual.Content);
Assert.AreEqual(expectedUpdates, this.albums.UpdatedEntities.Count);
Assert.AreEqual(expectedSaveChangesCalls, this.albums.NumberOfSaves);
}
public IHttpActionResult Update(int id, AlbumRequestModel album)
{
if (!this.ModelState.IsValid)
{
return BadRequest(ModelState);
}
var dbAlbum = this.data
.Albums.All()
.FirstOrDefault(a => a.Id == id);
if (dbAlbum == null)
{
return BadRequest("Such album does not exist in database!");
}
album.Producer = dbAlbum.Producer;
album.Title = dbAlbum.Title;
album.Year = dbAlbum.Year;
this.data.SaveChanges();
album.Id = id;
return Ok(album);
}
public IHttpActionResult Put(int id, AlbumRequestModel model)
{
var albumToUpdate = this.albums
.All()
.FirstOrDefault(a => a.Id == id);
if (albumToUpdate == null)
{
return this.NotFound();
}
if (!this.ModelState.IsValid || model == null)
{
return this.BadRequest(this.ModelState);
}
albumToUpdate.Title = model.Title;
albumToUpdate.ProducerName = model.ProducerName;
albumToUpdate.PublishYear = model.PublishYear;
foreach (var songId in model.SongIds)
{
var currentSong = this.songs
.All()
.FirstOrDefault(s => s.Id == songId);
if (currentSong != null)
{
albumToUpdate.Songs.Add(currentSong);
}
}
foreach (var artistId in model.ArtistIds)
{
var currentArtist = this.artists
.All()
.FirstOrDefault(a => a.Id == artistId);
if (currentArtist != null)
{
albumToUpdate.Artists.Add(currentArtist);
}
}
this.albums.SaveChanges();
return this.Ok("The album was successfully updated.");
}
public IHttpActionResult Put(int id, AlbumRequestModel album)
{
if (!ModelState.IsValid)
{
return this.BadRequest(this.ModelState);
}
var albumToUpdate =
this.db
.Albums
.All()
.FirstOrDefault(a => a.Id == id);
albumToUpdate.Title = album.Title;
albumToUpdate.Year = album.Year;
albumToUpdate.Producer = album.Producer;
this.db.SaveChanges();
return this.Ok();
}
