/// <summary>
/// Creates a playlist
/// </summary>
/// <param name="playlistDTO">Playlist to create</param>
public async Task <Playlist> Create(PlaylistDTO playlistDTO)
{
if (playlistDTO == null)
{
throw new ArgumentNullException("Null Playlist");
}
if (playlistDTO.Title.Length > 50)
{
throw new ArgumentOutOfRangeException("Playlist's title needs to be shorter than 50 characters.");
}
var existingPlaylist = await _context.Playlists.FirstOrDefaultAsync(x => x.Title == playlistDTO.Title);
if (existingPlaylist != null)
{
throw new ArgumentException($"Playlist with title '{playlistDTO.Title}' already exists.");
}
Playlist playlistToAdd = playlistDTO.ToEntity();
var playlist = await _context.Playlists.AddAsync(playlistToAdd);
Log.Logger.Information($"Playlist with title '{playlist.Entity.Title}' has been created.");
await _context.SaveChangesAsync();
return(playlist.Entity);
}
/// <summary>
/// Ban user by ID
/// </summary>
/// <param name="id">User's ID</param>
/// <returns>Returns true if banning was successful</returns>
public async Task <bool> BanUserById(string id)
{
var userToBan = await _context.Users.FirstOrDefaultAsync(x => x.Id == id);
if (userToBan == null)
{
return(false);
}
userToBan.LockoutEnabled = true;
await _context.SaveChangesAsync();
return(true);
}
public async Task DeleteThrowsWhenIdAlreadyDeleted()
{
var options = Utils.GetOptions(nameof(DeleteThrowsWhenIdAlreadyDeleted));
var playlist = new PlaylistDTO
{
Title = "In Utero",
Duration = 1600,
//PixabayImage = "https://en.wikipedia.org/wiki/In_Utero_(album)#/media/File:In_Utero_(Nirvana)_album_cover.jpg",
};
using (var arrangeContext = new PGDbContext(options))
{
var sut = new PlaylistService(arrangeContext);
await sut.Create(playlist);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new PGDbContext(options))
{
var sut = new PlaylistService(assertContext);
await sut.Delete(1);
await Assert.ThrowsExceptionAsync <ArgumentException>(() => sut.Delete(1));
}
}
public async Task DeleteCorrectly()
{
var options = Utils.GetOptions(nameof(DeleteCorrectly));
var playlist = new PlaylistDTO
{
Title = "In Utero",
Duration = 1600,
//PixabayImage = "https://en.wikipedia.org/wiki/In_Utero_(album)#/media/File:In_Utero_(Nirvana)_album_cover.jpg",
};
using (var arrangeContext = new PGDbContext(options))
{
var sut = new PlaylistService(arrangeContext);
await sut.Create(playlist);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new PGDbContext(options))
{
var sut = new PlaylistService(assertContext);
await sut.Delete(1);
var playlists = await sut.GetAllPlaylists();
int playlistsCount = playlists.Count();
Assert.AreEqual(0, playlistsCount);
}
}
public async Task CreateCorrectly()
{
var options = Utils.GetOptions(nameof(CreateCorrectly));
var playlist = new PlaylistDTO
{
Title = "In Utero",
Duration = 1600,
//PixabayImage = "https://en.wikipedia.org/wiki/In_Utero_(album)#/media/File:In_Utero_(Nirvana)_album_cover.jpg",
};
using (var arrangeContext = new PGDbContext(options))
{
var sut = new PlaylistService(arrangeContext);
await sut.Create(playlist);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new PGDbContext(options))
{
var result = await assertContext.Playlists.FirstOrDefaultAsync(x => x.Title == playlist.Title);
Assert.AreEqual(playlist.Title, result.Title);
Assert.AreEqual(playlist.Duration, result.Duration);
//Assert.AreEqual(playlist.PixabayImage, result.Picture);
}
}
public async Task GetAllPlaylistsByUserCorrectly()
{
var options = Utils.GetOptions(nameof(GetAllPlaylistsByUserCorrectly));
var nirvanaPlaylist = new PlaylistDTO
{
Title = "In Utero",
Duration = 1600,
//PixabayImage = "https://en.wikipedia.org/wiki/In_Utero_(album)#/media/File:In_Utero_(Nirvana)_album_cover.jpg",
UserId = "153a257-526504u",
};
var acdcPlaylist = new PlaylistDTO
{
Title = "Back in Black",
Duration = 2531,
//PixabayImage = "https://upload.wikimedia.org/wikipedia/commons/thumb/9/92/ACDC_Back_in_Black.png/220px-ACDC_Back_in_Black.png",
UserId = "153a257-526504u",
};
var scorpionsPLaylist = new PlaylistDTO
{
Title = "Lovedrive",
Duration = 2190,
//PixabayImage = "https://en.wikipedia.org/wiki/Lovedrive#/media/File:Scorpions-album-lovedrive.jpg",
UserId = "68910y78a-89as1568",
};
using (var arrangeContext = new PGDbContext(options))
{
var sut = new PlaylistService(arrangeContext);
await sut.Create(nirvanaPlaylist);
await sut.Create(acdcPlaylist);
await sut.Create(scorpionsPLaylist);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new PGDbContext(options))
{
var sut = new PlaylistService(assertContext);
var firstUserPalylists = await sut.GetPlaylistsByUser("153a257-526504u");
int firstUserPalylistsCount = firstUserPalylists.Count();
var secondUserPalylists = await sut.GetPlaylistsByUser("68910y78a-89as1568");
int secondUserPalylistsCount = secondUserPalylists.Count();
Assert.AreEqual(2, firstUserPalylistsCount);
Assert.AreEqual(1, secondUserPalylistsCount);
}
}
/// <summary>
/// Creates a new Genre
/// </summary>
/// <param name="genreDTO">Genre to create</param>
public async Task <GenreDTO> Create(GenreDTO genreDTO)
{
if (genreDTO == null)
{
throw new ArgumentNullException("Null Genre");
}
if (genreDTO.Name.Length > 50)
{
throw new ArgumentOutOfRangeException("Genre's Name needs to be shorter than 50 characters.");
}
var existingGenre = await _context.Genres.FirstOrDefaultAsync(x => x.Name == genreDTO.Name);
if (existingGenre != null)
{
throw new ArgumentException($"Genre with name '{genreDTO.Name}' already exists.");
}
var genre = _context.Genres.Add(genreDTO.ToEntity());
await _context.SaveChangesAsync();
return(genre.Entity.ToDTO());
}
/// <summary>
/// Creates an Artist
/// </summary>
/// <param name="artistDTO">Artist to create</param>
public async Task <ArtistDTO> Create(ArtistDTO artistDTO)
{
if (artistDTO == null)
{
throw new ArgumentNullException("Null Artist");
}
if (artistDTO.Name.Length > 100)
{
throw new ArgumentOutOfRangeException("Artist's Name needs to be shorter than 100 characters.");
}
var existedArtist = await _context.Artists.FirstOrDefaultAsync(x => x.Name == artistDTO.Name);
if (existedArtist != null)
{
throw new ArgumentException($"Artist with name '{artistDTO.Name}' already exists.");
}
var artist = await _context.Artists.AddAsync(artistDTO.ToEntity());
await _context.SaveChangesAsync();
return(artist.Entity.ToDTO());
}
public async Task <SongDTO> Create(SongDTO songDTO)
{
if (songDTO == null)
{
throw new ArgumentNullException("Null Song");
}
if (songDTO.Title.Length > 50)
{
throw new ArgumentOutOfRangeException("Song's title needs to be shorter than 50 characters.");
}
var existingSong = await _context.Songs.FirstOrDefaultAsync(x => x.Title == songDTO.Title);
if (existingSong != null)
{
throw new ArgumentException($"Song with title '{songDTO.Title}' already exists.");
}
var song = await _context.Songs.AddAsync(songDTO.ToEntity());
await _context.SaveChangesAsync();
return(song.Entity.ToDTO());
}
public async Task GetPlaylistByIdCorrectly()
{
var options = Utils.GetOptions(nameof(GetPlaylistByIdCorrectly));
var nirvanaPlaylist = new PlaylistDTO
{
Title = "In Utero",
Duration = 1600,
//PixabayImage = "https://en.wikipedia.org/wiki/In_Utero_(album)#/media/File:In_Utero_(Nirvana)_album_cover.jpg",
};
var acdcPlaylist = new PlaylistDTO
{
Title = "Back in Black",
Duration = 2531,
//PixabayImage = "https://upload.wikimedia.org/wikipedia/commons/thumb/9/92/ACDC_Back_in_Black.png/220px-ACDC_Back_in_Black.png",
};
using (var arrangeContext = new PGDbContext(options))
{
var sut = new PlaylistService(arrangeContext);
await sut.Create(nirvanaPlaylist);
await sut.Create(acdcPlaylist);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new PGDbContext(options))
{
var sut = new PlaylistService(assertContext);
var userPalylists = await sut.GetPlaylistById(1);
Assert.AreEqual(nirvanaPlaylist.Title, userPalylists.Title);
Assert.AreEqual(nirvanaPlaylist.Duration, userPalylists.Duration);
Assert.AreEqual(nirvanaPlaylist.PixabayImage, userPalylists.PixabayImage);
}
}
public async Task GeneratePlaylistCorrectly()
{
var options = Utils.GetOptions(nameof(GeneratePlaylistCorrectly));
int timeForTrip = 7200;
string playlistTitle = "Sofia - Sandanski";
int metalPercentagee = 25;
int rockPercentagee = 25;
int popPercentagee = 50;
bool topTracks = true;
bool sameArtist = true;
User user = new User();
var arrangeContext = new PGDbContext(options);
var deezerService = new DeezerAPIService(arrangeContext);
await deezerService.ExtractSongsFromPlaylists("pop");
await deezerService.ExtractSongsFromPlaylists("rock");
await deezerService.ExtractSongsFromPlaylists("metal");
var sut = new PlaylistService(arrangeContext);
await sut.GeneratePlaylist(timeForTrip, playlistTitle, metalPercentagee, rockPercentagee, popPercentagee, topTracks, sameArtist, user);
await arrangeContext.SaveChangesAsync();
var actual = arrangeContext.Playlists.FirstOrDefault(x => x.Id == 1);
Assert.AreEqual(1, actual.Id);
Assert.AreEqual(playlistTitle, actual.Title);
Assert.AreEqual(user.Id, actual.UserId);
Assert.IsTrue(actual.Duration < timeForTrip + 300);
Assert.IsTrue(actual.Duration > timeForTrip - 300);
Assert.IsTrue(actual.PlaylistsGenres.Count() == 3);
Assert.IsTrue(actual.PlaylistsSongs.Count() != 0);
}
/// <summary>
/// Extract all songs with preview "link".mp3 from all playlists where their title contains "Rock".
/// Creates new Creator/Artist accordingly to the song's specifications.
/// </summary>
public async Task ExtractSongsFromPlaylists(string genreString)
{
genreString = genreString.ToLower();
var dbGenreName = await _context.Genres.FirstOrDefaultAsync(x => x.Name == genreString);
if (!(dbGenreName == null))
{
return;
}
var client = new HttpClient();
using (var response = await client.GetAsync($"https://api.deezer.com/search/playlist?q={genreString}"))
{
var responseAsString = await response.Content.ReadAsStringAsync();
var result = JsonConvert.DeserializeObject <QueryPlaylistsAPI>(responseAsString);
var expectedGenre = _context.Genres.FirstOrDefault(x => x.Name.ToLower().Equals(genreString));
if (expectedGenre == null)
{
await _context.Genres.AddAsync(new Genre()
{
Name = genreString
});
await _context.SaveChangesAsync();
expectedGenre = await _context.Genres.FirstOrDefaultAsync(a => a.Name.ToLower().Equals(genreString));
}
foreach (var playlist in result.Data)
{
using (var response2 = await client.GetAsync(playlist.Tracklist))
{
var responseAsString2 = await response2.Content.ReadAsStringAsync();
var result2 = JsonConvert.DeserializeObject <PlaylistAPI>(responseAsString2);
foreach (var song in result2.Data)
{
if (song.Preview == null || song.Preview.Length < 5)
{
continue;
}
var expectedArtist = await _context.Artists.FirstOrDefaultAsync(x => x.Name == song.Artist.Name);
if (expectedArtist == null)
{
var addedArtist = await _context.Artists.AddAsync(new Artist()
{
Name = song.Artist.Name,
Tracklist = song.Artist.Tracklist,
Type = song.Artist.Type
});
expectedArtist = addedArtist.Entity;
await _context.SaveChangesAsync();
}
var expectedAlbum = await _context.Albums.FirstOrDefaultAsync(x => x.Title == song.Album.Title);
if (expectedAlbum == null)
{
var addedAlbum = await _context.Albums.AddAsync(new Album()
{
Title = song.Album.Title,
Tracklist = song.Album.Tracklist,
});
expectedAlbum = addedAlbum.Entity;
await _context.SaveChangesAsync();
}
var isSongNull = await _context.Songs.FirstOrDefaultAsync(x => x.Title == song.Title);
if (isSongNull == null)
{
var songToAdd = new Song()
{
Title = song.Title,
DeezerID = song.Id,
Duration = song.Duration,
Rank = song.Rank,
Preview = song.Preview,
Link = song.Link,
GenreId = expectedGenre.Id,
ArtistId = expectedArtist.Id,
AlbumId = expectedAlbum.Id
};
await _context.Songs.AddAsync(songToAdd);
expectedAlbum.Songs.Add(songToAdd);
}
}
await _context.SaveChangesAsync();
}
System.Threading.Thread.Sleep(150);
}
}
}
