private static void TestAddSongRequest(IReadOnlyList <string> args)
{
var httpLink = ParseIntputLink(args);
var settings = TestSettings.MockSettings(httpLink);
using var scrapper = HttpWebScrapperFactory.Create(settings, Logger);
scrapper.OpenUrl();
var userData = UserData.Create("TestUserId", "TestUserName");
var number = SongRequestNumber.All;
var request = SongRequestModel.CreateNew(userData, TestConfig.SongLink, number);
request = request.AutoApprove(settings.AutoApproveReason);
request = request.StartProcessing();
var result = scrapper.Process(request);
if (result.IsSuccess)
{
Logger.Info("Song request processed successfully!");
}
else
{
Logger.Error($"Failed to process song request: {result.Description}");
}
}
public async Task <SongRequestCurrentlyPlayingModel> Play(SongRequestModel song)
{
try
{
if (await ChannelSession.Services.Spotify.PlaySong(song.URI))
{
return(new SongRequestCurrentlyPlayingModel()
{
ID = song.ID,
URI = song.URI,
Name = song.Name,
AlbumImage = song.AlbumImage,
Length = song.Length,
Type = song.Type,
IsFromBackupPlaylist = song.IsFromBackupPlaylist,
User = song.User,
State = SongRequestStateEnum.Playing,
});
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
return(null);
}
public IHttpActionResult ById(int id)
{
if (!this.ModelState.IsValid)
{
return BadRequest(ModelState);
}
var dbSong = this.data
.Songs
.All()
.FirstOrDefault(s => s.Id == id);
if (dbSong == null)
{
return BadRequest("Such song does not exist in database!");
}
var song = new SongRequestModel
{
Genre = (GenreTypeRequestModel)dbSong.Genre,
Title = dbSong.Title,
Year = dbSong.Year
};
return Ok(song);
}
/// <summary>
/// Expect SongRequestModel with valid title, year (2 digits), Genre , ArtistId and AlbumId.
/// </summary>
/// <param name="model"></param>
/// <returns>
/// If the song is added returns IHttpActionResult with status code 200 OK
/// If the input data in not in the valid format retunrs IHttpActionResult with status code 400 Bad Request
/// </returns>
public IHttpActionResult Post(SongRequestModel model)
{
if (!this.ModelState.IsValid || model == null)
{
return(this.BadRequest(this.ModelState));
}
var albumExists = this.albums
.All()
.Any(a => a.Id == model.AlbumId);
var artistExist = this.artists
.All()
.Any(a => a.Id == model.ArtistId);
if (!(albumExists && artistExist))
{
return(this.BadRequest("Invalid albumID or artistID"));
}
this.songs.Add(new Song
{
Title = model.Title,
Genre = model.Genre,
PublishYear = model.PublishYear,
ArtistId = model.ArtistId,
AlbumId = model.AlbumId
});
this.songs.SaveChanges();
return(this.Ok("The song was successfully added."));
}
public IHttpActionResult Post(SongRequestModel requestSong)
{
var song = Mapper.Map <Song>(requestSong);
song = this.songs.Add(song);
return(this.Created("/", Mapper.Map <SongResponseModel>(song)));
}
public IHttpActionResult Put(int id, SongRequestModel requestSong)
{
var song = Mapper.Map <Song>(requestSong);
song = this.songs.Update(id, song);
return(this.Ok(Mapper.Map <SongResponseModel>(song)));
}
public IHttpActionResult Post(SongRequestModel songToAdd)
{
var song = Mapper.Map<Song>(songToAdd);
this.db.Songs.Add(song);
this.db.SaveChanges();
return this.Ok(string.Format("{0} was added to Songs", song.Title));
}
private SongRequestResult ProcessResult(SongRequestModel songRequest)
{
if (!_settings.ShouldParseResult)
{
_logger.Info("No need to parse result. Returning success.");
return(SongRequestResult.Success(songRequest, _settings.DefaultSuccessMessage));
}
_logger.Info(
$"Song request '{songRequest.RequestId.ToString()}' seems to be added, " +
"processing result."
);
// Page can be loaded to quickly, need that notification will be enabled.
var waiter = new WebDriverWait(_webDriver, TimeoutToWait);
var notification = waiter.Until(
driver => driver.FindElement(By.ClassName(_settings.ClassNameOfNotificationIcon))
);
_logger.Debug("Found notification icon.");
var success = notification.FindElements(
By.ClassName(_settings.ClassNameOfSuccessNotificationIcon)
);
_logger.Debug("Tried to find success notification icon.");
var failure = notification.FindElements(
By.ClassName(_settings.ClassNameOfErrorNotificationIcon)
);
_logger.Debug("Tried to find error notification icon.");
var description = _webDriver.FindElement(
By.ClassName(_settings.ClassNameOfNotificationDescription)
);
var descriptionText = description.Text;
_logger.Debug($"Found notification description: [{descriptionText}].");
// Success.
if (success.Count > 0 && failure.Count == 0)
{
_logger.Info(
$"Song request '{songRequest.RequestId.ToString()}' processed successfully. " +
$"Result: {descriptionText}"
);
return(SongRequestResult.Success(songRequest, descriptionText));
}
// Failure.
_logger.Info(
$"Song request {songRequest.RequestId.ToString()} processed with failure. " +
$"Error: {descriptionText}"
);
return(SongRequestResult.Fail(songRequest, descriptionText));
}
private async Task AddSongRequest(UserViewModel user, SongRequestModel song)
{
song.User = user;
if (bannedSongsCache[song.Type].Contains(song.ID))
{
await ChannelSession.Chat.Whisper(user.UserName, "This song is banned from being requested.");
return;
}
bool isSongCurrentlyPlaying = false;
await SongRequestService.songRequestLock.WaitAndRelease(() =>
{
isSongCurrentlyPlaying = (this.Status != null);
if (ChannelSession.Settings.SongRequestSubPriority && user.IsMixerSubscriber)
{
for (int i = 0; i < this.requestSongs.Count; i++)
{
if (!this.requestSongs[i].User.IsMixerSubscriber)
{
this.requestSongs.Insert(i, song);
return(Task.FromResult(0));
}
}
}
this.requestSongs.Add(song);
if (ChannelSession.Settings.SongRequestsSaveRequestQueue)
{
ChannelSession.Settings.SongRequestsSavedRequestQueue = this.requestSongs.ToList();
}
return(Task.FromResult(0));
});
if (!isSongCurrentlyPlaying)
{
await this.Skip();
}
else
{
if (ChannelSession.Settings.SongAddedCommand != null)
{
Dictionary <string, string> specialIdentifiers = new Dictionary <string, string>()
{
{ "songtitle", song.Name },
{ "songalbumimage", song.AlbumImage }
};
await ChannelSession.Settings.SongAddedCommand.Perform(song.User, arguments : null, extraSpecialIdentifiers : specialIdentifiers);
}
}
ChannelSession.Services.Telemetry.TrackSongRequest(song.Type);
GlobalEvents.SongRequestsChangedOccurred();
}
public IHttpActionResult Post(SongRequestModel songToAdd)
{
var song = Mapper.Map <Song>(songToAdd);
this.db.Songs.Add(song);
this.db.SaveChanges();
return(this.Ok(string.Format("{0} was added to Songs", song.Title)));
}
public async Task MoveDown(SongRequestModel song)
{
await SongRequestService.songRequestLock.WaitAndRelease(() =>
{
this.requestSongs.MoveDown(song);
return(Task.FromResult(0));
});
GlobalEvents.SongRequestsChangedOccurred();
}
private async void BanQueueButton_Click(object sender, RoutedEventArgs e)
{
await this.Window.RunAsyncOperation(() =>
{
Button button = (Button)sender;
SongRequestModel songRequest = (SongRequestModel)button.DataContext;
this.viewModel.BanCommand.Execute(songRequest);
return(Task.FromResult(0));
});
}
public async Task Play(SongRequestModel song)
{
try
{
await ChannelSession.Services.Spotify.PlaySong(song.URI);
}
catch (Exception ex)
{
Logger.Log(ex);
}
}
public async Task Ban(SongRequestModel song)
{
await SongRequestService.songRequestLock.WaitAndRelease(() =>
{
ChannelSession.Settings.SongRequestsBannedSongs.Add(song);
bannedSongsCache[song.Type].Add(song.ID);
return(Task.FromResult(0));
});
await this.Remove(song);
}
public override async Task <OverlayItemBase> GetProcessedItem(UserViewModel user, IEnumerable <string> arguments, Dictionary <string, string> extraSpecialIdentifiers)
{
if (ChannelSession.Services.SongRequestService != null && this.songRequestsUpdated)
{
this.songRequestsUpdated = false;
List <SongRequestModel> songRequests = new List <SongRequestModel>();
SongRequestModel currentlyPlaying = await ChannelSession.Services.SongRequestService.GetCurrent();
if (currentlyPlaying != null)
{
songRequests.Add(currentlyPlaying);
}
IEnumerable <SongRequestModel> allSongRequests = this.testSongRequestsList;
if (this.testSongRequestsList.Count == 0)
{
allSongRequests = ChannelSession.Services.SongRequestService.RequestSongs.ToList();
}
foreach (SongRequestModel songRequest in allSongRequests)
{
if (!songRequests.Any(sr => sr.Equals(songRequest)))
{
songRequests.Add(songRequest);
}
}
this.SongRequestUpdates.Clear();
this.currentSongRequests.Clear();
OverlaySongRequests copy = this.Copy <OverlaySongRequests>();
for (int i = 0; i < songRequests.Count() && i < this.TotalToShow; i++)
{
this.currentSongRequests.Add(songRequests.ElementAt(i));
}
while (this.currentSongRequests.Count > 0)
{
OverlayCustomHTMLItem overlayItem = (OverlayCustomHTMLItem)await base.GetProcessedItem(user, arguments, extraSpecialIdentifiers);
copy.SongRequestUpdates.Add(new OverlaySongRequestItem()
{
HTMLText = overlayItem.HTMLText
});
this.currentSongRequests.RemoveAt(0);
}
return(copy);
}
return(null);
}
public async Task Remove(SongRequestModel song)
{
await SongRequestService.songRequestLock.WaitAndRelease(() =>
{
this.RequestSongs.Remove(song);
return(Task.FromResult(0));
});
await ChannelSession.Chat.SendMessage(string.Format("{0} removed from the queue.", song.Name));
GlobalEvents.SongRequestsChangedOccurred();
}
private async void DeleteQueueButton_Click(object sender, RoutedEventArgs e)
{
await this.Window.RunAsyncOperation(() =>
{
Button button = (Button)sender;
if (button != null && button.DataContext != null && button.DataContext is SongRequestModel)
{
SongRequestModel songRequest = (SongRequestModel)button.DataContext;
this.viewModel.DeleteCommand.Execute(songRequest);
}
return(Task.FromResult(0));
});
}
private async void GlobalEvents_OnSongRequestsChangedOccurred(object sender, System.EventArgs e)
{
List <SongRequestModel> songs = ChannelSession.Services.SongRequestService.RequestSongs.ToList();
if (this.IncludeCurrentSong)
{
SongRequestModel current = await ChannelSession.Services.SongRequestService.GetCurrent();
if (current != null)
{
songs.Insert(0, current);
}
}
await this.AddSongRequests(songs.Take(this.TotalToShow));
}
private void AddNewSong(SongRequestModel songRequest)
{
// Page can be loaded to quickly, need that UI will be available.
var waiter = CreateWebDriverWaiterForButton();
waiter.Until(_ => NewSongTextField.Enabled);
NewSongTextField.Clear();
NewSongTextField.SendKeys(songRequest.SongLink.Value);
waiter.Until(_ =>
{
AddSongButton.Click();
return(true);
});
}
public async Task RemoveLastRequested()
{
SongRequestModel song = null;
await SongRequestService.songRequestLock.WaitAndRelease(() =>
{
song = this.requestSongs.LastOrDefault();
return(Task.FromResult(0));
});
if (song != null)
{
await this.Remove(song);
}
GlobalEvents.SongRequestsChangedOccurred();
}
private async void GlobalEvents_OnSongRequestsChangedOccurred(object sender, EventArgs e)
{
this.currentlyPlaying = await ChannelSession.Services.SongRequestService.GetCurrent();
await DispatcherHelper.InvokeDispatcher(() =>
{
this.RequestSongs.Clear();
foreach (SongRequestModel songRequest in ChannelSession.Services.SongRequestService.RequestSongs.ToList())
{
this.RequestSongs.Add(songRequest);
}
return(Task.FromResult(0));
});
this.NotifyPropertyChanges();
}
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 IHttpActionResult Post(SongRequestModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var song = new Song
{
Title = model.Title,
Year = model.Year
};
this.data.Songs.Add(song);
this.data.Songs.SaveChanges();
return(this.Ok(song));
}
public SongRequestResult Process(SongRequestModel songRequest)
{
_logger.Info($"Processing song request [{songRequest}].");
if (!songRequest.IsApprovedAndProcessing)
{
string errorMessage = (
"Invalid song request to process. Expected " +
$"state {nameof(SongRequestState.ApprovedAndProcessing)}, " +
$"actual state {songRequest.State.ToString()}."
);
throw new ArgumentException(errorMessage, nameof(songRequest));
}
AddNewSong(songRequest);
return(ProcessResult(songRequest));
}
public IHttpActionResult Update(int id, SongRequestModel song)
{
if (!this.ModelState.IsValid)
{
return BadRequest(this.ModelState);
}
var songInDb = this.data.Songs
.All()
.FirstOrDefault(c => c.Id == id);
songInDb.Title = song.Title;
songInDb.Year = song.Year;
songInDb.Genre = song.Genre;
this.data.Songs.SaveChanges();
return Ok(songInDb);
}
public IHttpActionResult Update(int id, SongRequestModel song)
{
if (!this.ModelState.IsValid)
{
return(BadRequest(this.ModelState));
}
var songInDb = this.data.Songs
.All()
.FirstOrDefault(c => c.Id == id);
songInDb.Title = song.Title;
songInDb.Year = song.Year;
songInDb.Genre = song.Genre;
this.data.Songs.SaveChanges();
return(Ok(songInDb));
}
public async Task <SongRequestCurrentlyPlayingModel> Play(SongRequestModel song)
{
await this.DispatchWrapper(() => this.browser.InvokeScript("play", new object[] { song.ID }));
await this.SetVolume(this.lastVolume);
return(new SongRequestCurrentlyPlayingModel()
{
ID = song.ID,
URI = song.URI,
Name = song.Name,
AlbumImage = song.AlbumImage,
Length = song.Length,
Type = song.Type,
IsFromBackupPlaylist = song.IsFromBackupPlaylist,
User = song.User,
State = SongRequestStateEnum.Playing,
});
}
public IHttpActionResult Post([FromBody] SongRequestModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var entity = new Song
{
Name = model.Name,
Year = model.Year,
GenreId = model.GenreId
};
this.context.AddEntity(entity);
this.context.Save();
return(this.Created(this.Url.ToString(), entity));
}
public IHttpActionResult Update(SongRequestModel songToUpdate)
{
var targetSong = this.db.Songs
.FirstOrDefault(s => s.Id == songToUpdate.Id);
if (targetSong == null)
{
return(this.NotFound());
}
targetSong.Title = songToUpdate.Title;
targetSong.Year = songToUpdate.Year;
targetSong.Genre.Name = songToUpdate.GenreName;
targetSong.Album.Title = songToUpdate.AlbumTitle;
targetSong.Artist.Name = songToUpdate.ArtistName;
this.db.SaveChanges();
return(this.Ok("Song has been updated successfully!"));
}
protected override Task <Dictionary <string, string> > GetReplacementSets(UserViewModel user, IEnumerable <string> arguments, Dictionary <string, string> extraSpecialIdentifiers)
{
SongRequestModel songRequest = this.currentSongRequests.ElementAt(0);
Dictionary <string, string> replacementSets = new Dictionary <string, string>();
replacementSets["BACKGROUND_COLOR"] = this.BackgroundColor;
replacementSets["BORDER_COLOR"] = this.BorderColor;
replacementSets["TEXT_COLOR"] = this.TextColor;
replacementSets["TEXT_FONT"] = this.TextFont;
replacementSets["WIDTH"] = this.Width.ToString();
replacementSets["HEIGHT"] = this.Height.ToString();
replacementSets["TEXT_SIZE"] = ((int)(0.2 * ((double)this.Height))).ToString();
replacementSets["SONG_IMAGE"] = songRequest.AlbumImage;
replacementSets["SONG_IMAGE_SIZE"] = ((int)(0.8 * ((double)this.Height))).ToString();
replacementSets["SONG_NAME"] = songRequest.Name;
return(Task.FromResult(replacementSets));
}
public async Task RemoveLastRequested(UserViewModel user)
{
SongRequestModel song = null;
await SongRequestService.songRequestLock.WaitAndRelease(() =>
{
song = this.requestSongs.LastOrDefault(s => s.User.ID == user.ID);
return(Task.FromResult(0));
});
if (song != null)
{
await this.Remove(song);
}
else
{
await ChannelSession.Chat.Whisper(user.UserName, string.Format("You have no songs in the queue.", song.Name));
}
GlobalEvents.SongRequestsChangedOccurred();
}
public IHttpActionResult Create(SongRequestModel song)
{
if (!this.ModelState.IsValid)
{
return(BadRequest(this.ModelState));
}
this.data
.Songs
.Add(new Song
{
Title = song.Title,
Year = song.Year,
Genre = song.Genre
});
this.data.Songs.SaveChanges();
return(Ok(song));
}
public IHttpActionResult Update(SongRequestModel songToUpdate)
{
var targetSong = this.db.Songs
.FirstOrDefault(s => s.Id == songToUpdate.Id);
if (targetSong == null)
{
return this.NotFound();
}
targetSong.Title = songToUpdate.Title;
targetSong.Year = songToUpdate.Year;
targetSong.Genre.Name = songToUpdate.GenreName;
targetSong.Album.Title = songToUpdate.AlbumTitle;
targetSong.Artist.Name = songToUpdate.ArtistName;
this.db.SaveChanges();
return this.Ok("Song has been updated successfully!");
}
public IHttpActionResult Post(SongRequestModel song)
{
if (!this.ModelState.IsValid)
{
return this.BadRequest(this.ModelState);
}
var songToPost = new Song()
{
Title = song.Title,
Year = song.Year,
Genre = song.Genre,
ArtistId = song.ArtistId
};
this.db.Songs.Add(songToPost);
this.db.SaveChanges();
return this.Ok(song);
}
public async Task Remove(SongRequestModel song)
{
await SongRequestService.songRequestLock.WaitAndRelease(() =>
{
this.requestSongs.Remove(song);
return(Task.FromResult(0));
});
if (ChannelSession.Settings.SongRemovedCommand != null)
{
Dictionary <string, string> specialIdentifiers = new Dictionary <string, string>()
{
{ "songtitle", song.Name },
{ "songalbumimage", song.AlbumImage }
};
await ChannelSession.Settings.SongRemovedCommand.Perform(song.User, arguments : null, extraSpecialIdentifiers : specialIdentifiers);
}
GlobalEvents.SongRequestsChangedOccurred();
}
public IHttpActionResult Create(SongRequestModel song)
{
if (!this.ModelState.IsValid)
{
return BadRequest(this.ModelState);
}
this.data
.Songs
.Add(new Song
{
Title = song.Title,
Year = song.Year,
Genre = song.Genre
});
this.data.Songs.SaveChanges();
return Ok(song);
}
public IHttpActionResult Post(SongRequestModel request)
{
if (request == null)
{
return this.BadRequest(GlobalMessages.EntityMustNotBeNullMessage);
}
var song = new Song
{
Title = request.Title,
Genre = request.Genre,
Year = request.Year
};
Singer defaultSinger = this.data.SingersRepository.All().FirstOrDefault();
song.Singer = defaultSinger;
this.data.SongsRepository.Add(song);
int result = this.data.SaveChanges();
return this.Ok($"{GlobalMessages.EntitySuccessfullyAddedMessage} - {result}");
}
public IHttpActionResult Create(SongRequestModel song)
{
if (!this.ModelState.IsValid)
{
return BadRequest(ModelState);
}
var newSong= new Song
{
Genre = (GenreType)song.Genre,
Title = song.Title,
Year = song.Year
};
this.data.Songs.Add(newSong);
this.data.SaveChanges();
song.Id = newSong.Id;
return Ok(song);
}
public IHttpActionResult Update(string id, SongRequestModel request)
{
if (id == null)
{
return this.BadRequest(GlobalMessages.IdMustNotBeNullMessage);
}
if (request == null)
{
return this.BadRequest(GlobalMessages.EntityMustNotBeNullMessage);
}
Song entity = this.data.SongsRepository.FindById(id);
if (entity == null)
{
return this.BadRequest(GlobalMessages.EntityDoesNotExist);
}
// Map the request model to the db model
if (request.Title != default(string))
{
entity.Title = request.Title;
}
if (request.Genre != default(string))
{
entity.Genre = request.Genre;
}
if (request.Year != default(short))
{
entity.Year = request.Year;
}
this.data.SongsRepository.Update(entity);
int result = this.data.SaveChanges();
return this.Ok($"{GlobalMessages.EntitySuccessfullyUpdatedMessage} - {result}");
}
// POST: api/Song
public IHttpActionResult Post(SongRequestModel song)
{
var songToAdd = new Song
{
Title = song.Title,
Year = song.Year
};
var genre = this.genreData.All()
.FirstOrDefault(g => g.Name == song.Genre);
if (genre == null)
{
return this.BadRequest("Invalid song genre!");
}
songToAdd.Genre = genre;
var artist = this.artistData.All()
.FirstOrDefault(a => a.Name == song.Artist);
if (artist == null)
{
return this.BadRequest("Invalid song artist!");
}
songToAdd.Artist = artist;
var album = this.albumData.All()
.FirstOrDefault(a => a.Title == song.Album);
if (album == null)
{
return this.BadRequest("Invalid album artist!");
}
songToAdd.Album = album;
this.songData.Add(songToAdd);
this.songData.SaveChanges();
return this.Ok();
}
/// <summary>
/// Expect SongRequestModel with valid title, year (2 digits), Genre , ArtistId and AlbumId.
/// </summary>
/// <param name="model"></param>
/// <returns>
/// If the song is added returns IHttpActionResult with status code 200 OK
/// If the input data in not in the valid format retunrs IHttpActionResult with status code 400 Bad Request
/// </returns>
public IHttpActionResult Post(SongRequestModel model)
{
if (!this.ModelState.IsValid || model == null)
{
return this.BadRequest(this.ModelState);
}
var albumExists = this.albums
.All()
.Any(a => a.Id == model.AlbumId);
var artistExist = this.artists
.All()
.Any(a => a.Id == model.ArtistId);
if (!(albumExists && artistExist))
{
return this.BadRequest("Invalid albumID or artistID");
}
this.songs.Add(new Song
{
Title = model.Title,
Genre = model.Genre,
PublishYear = model.PublishYear,
ArtistId = model.ArtistId,
AlbumId = model.AlbumId
});
this.songs.SaveChanges();
return this.Ok("The song was successfully added.");
}
public IHttpActionResult Update(int id, SongRequestModel song)
{
if (!this.ModelState.IsValid)
{
return BadRequest(ModelState);
}
var dbSong = this.data
.Songs.All()
.FirstOrDefault(s => s.Id == id);
if (dbSong == null)
{
return BadRequest("Such song does not exist in database!");
}
dbSong.Genre = (GenreType)song.Genre;
dbSong.Title = song.Title;
dbSong.Year = song.Year;
this.data.SaveChanges();
song.Id = id;
return Ok(song);
}
public IHttpActionResult Put(int id, SongRequestModel song)
{
if (!ModelState.IsValid)
{
return this.BadRequest(this.ModelState);
}
var songToUpdate =
this.db
.Songs
.All()
.FirstOrDefault(s => s.Id == id);
songToUpdate.Title = song.Title;
songToUpdate.Year = song.Year;
songToUpdate.Genre = song.Genre;
songToUpdate.ArtistId = song.ArtistId;
this.db.SaveChanges();
return this.Ok();
}
// PUT: api/Song/5
public IHttpActionResult Put(int id, SongRequestModel songInfo)
{
if (songInfo == null)
{
return this.BadRequest("Invalid song info!");
}
var songToModify = this.songData.All()
.FirstOrDefault(s => s.SongId == id);
if (songToModify == null)
{
return this.BadRequest(string.Format("Song with id {0} not found!", id));
}
songToModify.Title = songInfo.Title;
songToModify.Year = songInfo.Year;
songToModify.Genre = this.genreData.All().FirstOrDefault(g => g.Name == songInfo.Genre);
songToModify.Artist = this.artistData.All().FirstOrDefault(a => a.Name == songInfo.Artist);
this.songData.SaveChanges();
return this.Ok("Song modified!");
}
public IHttpActionResult Put(int id, SongRequestModel model)
{
var songToUpdate = this.songs
.All()
.FirstOrDefault(c => c.Id == id);
if (songToUpdate == null)
{
return this.NotFound();
}
if (!this.ModelState.IsValid || model == null)
{
return this.BadRequest(this.ModelState);
}
var albumExists = this.albums
.All()
.Any(a => a.Id == model.AlbumId);
var artistExist = this.artists
.All()
.Any(a => a.Id == model.ArtistId);
if (!(albumExists && artistExist))
{
return this.BadRequest("Invalid albumID or artistID");
}
songToUpdate.Title = model.Title;
songToUpdate.Genre = model.Genre;
songToUpdate.PublishYear = model.PublishYear;
songToUpdate.ArtistId = model.ArtistId;
songToUpdate.AlbumId = model.AlbumId;
this.songs.SaveChanges();
return this.Ok("The song was updated successfully");
}
