private DirectoryInfo CreateArtistAlbumFormat(string writeFolder, IArtist artist, IAlbum album)
{
var albumFolderName = string.Format("{0} - {1}", artist.Name, album.Title);
var fullPath = Path.Combine(writeFolder, albumFolderName);
return(CreateDirectory(fullPath));
}
public AlbumPostController(IArtist artist, IImage image, IAlbum album, IAlbumSong albumSong)
{
_artist = artist;
_image = image;
_album = album;
_albumSong = albumSong;
}
internal void Publish(IArtist o)
{
Artist tr = o as Artist;
if (!RawCollection.Contains(tr))
BasicRegister(tr);
}
public static ArtistInfo FromArtist(IArtist artist)
{
if (artist == null)
return null;
return new ArtistInfo(artist.Id, artist.Name);
}
public HomeController(ITreck trecks, IGenres genres, IAlbums albums, IArtist artist)
{
_trecks = trecks;
_genres = genres;
_albums = albums;
_artist = artist;
}
public override IArtist GetArtist(ISecurityContext securityContext, IMediaFactory mediaFactory, IMetadataRepository mediaItemRepository)
{
IArtist artist = null;
var track = mediaItemRepository.GetByTarget <ITrack>(Location).FirstOrDefault();
if (track != null)
{
artist = mediaItemRepository.GetByLocation <IArtist>(track.Creator);
if (artist != null)
{
return(artist);
}
}
if (id3v2Tag == null || id3v2Tag.JoinedPerformers == null)
{
return(new MediaItemBuilder <IArtist>(securityContext, mediaFactory).GetDefault());
}
var artistName = id3v2Tag.JoinedPerformers;
var summary = string.Empty;
artist = mediaItemRepository.GetByName <IArtist>(artistName).FirstOrDefault();
if (artist != null)
{
return(artist);
}
var builder = new MediaItemBuilder <IArtist>(securityContext, mediaFactory)
.Identity(artistName, summary);
return(builder.ToMediaItem());
}
public void GoToArtist(IArtist iartist)
{
this.GenreNavigation.PropertyChanged -= NavigatorChanged;
this.GenreNavigation.Item = null;
DoGoToArtist(iartist);
this.GenreNavigation.PropertyChanged += NavigatorChanged;
}
public bool Validate(Song song)
{
//check the artist ID is valid
IArtist artist = _artistRepository.GetArtist(song.songArtistID);
if (artist == null)
{
return(false);
}
//check the genre id is valid
else if (_genreRepository.GetGenre(song.songGenreID) == null)
{
return(false);
}
//check the year it's released to make sure it's not outside the active years range
else if (artist.startingDate.Year > song.releaseDate.Year ||
(artist.endingDate.HasValue && artist.endingDate.Value.Year < song.releaseDate.Year))
{
return(false);
}
else
{
return(true);
}
}
public IEnumerable<ITrack> GetArtistTracks(IArtist artist, int? page = null, Timestamp startTime = null, Timestamp endTime = null)
{
IApiMethod method = this.CreateApiMethod("user.getArtistTracks");
method.AddParameter("artist", artist.Name);
if (page.HasValue)
{
method.AddParameter("page", page.ToString());
}
if (startTime != null)
{
method.AddParameter("startTimestamp", startTime.ToString());
}
if (endTime != null)
{
method.AddParameter("endTimestamp", endTime.ToString());
}
var response = method.Execute();
JArray tracks = (JArray)response["lfm"]["artisttracks"]["track"];
foreach (var track in tracks)
{
yield return new Track { Url = track.Value<string>("url"), Name = track.Value<string>("name") };
}
}
public static void ThrowIfNull(this IArtist artist)
{
if (artist == null)
{
throw new ArgumentNullException(nameof(artist));
}
}
private void DoGoToArtist(IArtist iartist)
{
if (iartist == null)
return;
this.ArtistNavigation.Item = iartist;
}
// BUG: This is currently returning inconsistent values if run multiple times with the same artist. Lyrics API sometimes returns an empty string for a song even if it does have it in its
// database and has successfully retrieved it before. Reason is unknown - rate limiting? - but is very difficult to filter for as it still returns a 200 response
public async Task <double> GetArtistAverageSongLength(IArtist artist)
{
var q = new Query("Aire Logic Technical Test", "1.0", "heliomance.github.com");
var lyricLengthLookups = new List <Task <int> >();
var works = await q.BrowseArtistWorksAsync(artist.Id);
lyricLengthLookups.AddRange(works.Results.Select(work => GetSongLength(artist.Name, work.Title)));
while (works.Offset + works.Results.Count < works.TotalResults)
{
works = await works.NextAsync();
lyricLengthLookups.AddRange(works.Results.Select(work => GetSongLength(artist.Name, work.Title)));
}
Console.WriteLine($"Found {lyricLengthLookups.Count} works by that artist on MusicBrainz");
// Only count non-instrumental songs where the lyrics where actually found
var songLengths = (await Task.WhenAll(lyricLengthLookups)).Where(l => l > 0).ToList();
Console.WriteLine($"Found lyrics for {songLengths.Count} songs");
// If no songs are found, or all songs are instrumental, return -1 without further calculation (avoids an error if the lyrics API doesn't have any songs by that artist)
if (songLengths.Any())
{
return(songLengths.Average());
}
return(-1);
}
public void PainterCreationWithoutReflectionTest()
{
SimpleFactory factory = SimpleFactory.GetFactory();
IArtist x = factory.GetArtist(typeof(Painter));
Assert.AreSame(x.GetType(), typeof(Painter));
}
public HomeController(IArtist artist, IArtWork artwork, IGroup group, IUserLogin userlogin)
{
_artist = artist;
_artwork = artwork;
_group = group;
_userlogin = userlogin;
}
public void OneTimeSetUp()
{
var deezer = DeezerSession.CreateNew();
string token = "frmFoXgyyO1ATzluA6gZIFIoWAf8b8G4tGWHaoxtDN9oCKMghM";
if (string.IsNullOrEmpty(token))
{
throw new NotLoggedInException();
}
deezer.Login(token)
.GetAwaiter().GetResult();
_user = deezer.User;
_album = deezer.Browse.GetAlbumById(302127)
.GetAwaiter().GetResult();
_artist = deezer.Browse.GetArtistById(27)
.GetAwaiter().GetResult();
_track = deezer.Browse.GetTrackById(3135556)
.GetAwaiter().GetResult();
_playlist = deezer.Browse.GetPlaylistById(908622995)
.GetAwaiter().GetResult();
_radio = deezer.Browse.GetRadioById(6)
.GetAwaiter().GetResult();
}
public void RemoveArtist(IArtist artist)
{
if (_database.Artists.Contains(artist))
{
_database.Artists.Remove(artist);
}
}
public TopHitsAlbumBrowse(IAlbum album, IArtist artist, IArray <ITrack> tracks, ISession session)
{
this.Album = album;
this.Artist = artist;
this.Tracks = tracks;
this.Session = session;
}
private async Task <uint> GetTrackCount(IArtist artist)
{
uint offset = 0;
uint fetchCount = 50;
uint trackCount = 0;
while (true)
{
foreach (var album in await artist.Albums(CancellationToken.None, offset, fetchCount))
{
await Task.Delay(_delayConfiguration.CheckArtistForUpdatesBackgroundJob_GetTrackCountDelay);
var apiAlbum = await _deezerApiService.GetDeezerApi().Albums.GetById(album.Id, CancellationToken.None);
trackCount += apiAlbum.TrackCount;
}
if (offset >= artist.NumberOfAlbums)
{
break;
}
offset += fetchCount;
}
return(trackCount);
}
public void AddAlbum(IAlbum album, IArtist artist)
{
artist = ArtistInDBConfirmation(artist);
album.ArtistID = artist.ID;
_database.AddAlbum(album);
RemoveIfDuplicate(album);
}
public MusicianPostController(IArtist artist, IArtistMusician artistMusician, IMusician musician, IImage image)
{
_artist = artist;
_artistMusician = artistMusician;
_musician = musician;
_image = image;
}
public Task <IEnumerable <AlbumModel> > LoadAlbumsByArtist(IArtist artist)
{
using var db = new SQLiteConnection(ConnectionString);
return(db.QueryAsync <AlbumModel>(
@"SELECT DISTINCT artist, album, genre, year FROM Tracks WHERE artist = @Artist ORDER BY album",
artist));
}
public bool Equals(IArtist other)
{
if (ReferenceEquals(null, other))
return false;
if (ReferenceEquals(this, other))
return true;
return Equals(Name, other.Name);
}
public void ToAlbumsByArtist(IArtist artist)
{
Func <IArtist, Task <IEnumerable <IAlbum> > > f = ViewModel.GetAlbumsByArtist;
albumListControl.GetAlbums = f.Partial(artist);
ViewFrame.NavigationService.Navigate(albumListControl);
ViewFrame.NavigationUIVisibility = NavigationUIVisibility.Hidden;
}
public void CopyProperties(IArtist other)
{
other.CheckArgument(nameof(other));
Id = other.Id;
RowVersion = other.RowVersion;
Name = other.Name;
}
internal static IntPtr GetPointer(IArtist artist)
{
if (artist.GetType() == typeof(ArtistWrapper))
{
return(((ArtistWrapper)artist).artist.artistPtr);
}
throw new ArgumentException("Invalid artist");
}
public void Initialize(IArtist artist)
{
_artist = artist;
Name = _artist.Name;
RaisePropertyChanged(() => Albums);
}
public IEnumerable <IDirectory> GetDirectories(IArtist artist)
{
return(ExecuteWithCaching(m_ArtistDirectoriesCache, artist, (IArtist a) =>
{
var directories = artist.Albums.SelectMany(GetDirectories).Distinct().ToList();
return CombineCommonAncestors(directories).ToList();
}));
}
public void WriteViolation(IRule <IArtist> violatedRule, Severity severity, IArtist artist)
{
// add violations to all directories contain files that are from this artist
foreach (var directory in m_MetadataMapper.GetDirectories(artist))
{
AddRuleViolation(directory, violatedRule);
}
}
public async Task <IEnumerable <IAlbum> > GetAlbumsByArtist(IArtist artist)
{
return(artist.Id.HasValue
? (await source.GetAlbumsByArtist(artist.Id.Value))
.Bind(TryDeserialize <IEnumerable <AlbumResponse> >)
.Match(err => Enumerable.Empty <IAlbum>(), x => x)
: Enumerable.Empty <IAlbum>());
}
public LoadSongsViewModel()
{
_artist = new Artist();
_album = new Album();
_discography = new Discography();
_songs = new List<Song>();
_artistContact = new ArtistContact();
}
private void UnPublish(IArtist o)
{
Artist tr = o as Artist;
IObjectState ios = tr;
ios.ObjectStateChanges -= LifeChanges;
RawCollection.Remove(tr);
}
public SearchRestController(IArtist artist, IGenre genre, IAlbum album, IMusician musician, IArtistGenre artistGenre)
{
_artist = artist;
_genre = genre;
_album = album;
_musician = musician;
_artistGenre = artistGenre;
}
public Work(WorkType type, IWork parent, IArtist artist, string name, short year, uint number)
{
this.type = type;
this.parent = parent;
this.artist = artist;
this.name = name ?? string.Empty;
this.year = year;
this.number = number;
}
public void SaveArtist(IArtist artist)
{
var collection = _db.GetCollection(_collectionName);
var query = Query.EQ("Artist", artist.Name);
var writeArtist = DataMapper.GetArtistAsBson(artist);
collection.Update(query, Update.Replace(writeArtist), UpdateFlags.Upsert);
}
public static Artist ConvertToDto(IArtist artist)
{
using (artist)
{
artist.WaitUntilLoaded();
return Mapper.Map<IArtist, Artist>(artist);
}
}
public Work(WorkType type, IWork parent, IArtist artist, string name, short year, uint number)
{
this.type = type;
this.parent = parent;
this.artist = artist;
this.name = name ?? string.Empty;
this.year = year;
this.number = number;
}
public MainController(IGenre genre, IArtist artist, IArtistGenre artistGenre, IImage image,
IArtistMusician artistMusician)
{
_genre = genre;
_artist = artist;
_artistGenre = artistGenre;
_image = image;
_artistMusician = artistMusician;
}
public MusicController(ITreck trecks, IPlaylist playlists, IPlaylistTreck playlistsTreck, IGenres genres, IAlbums albums, IArtist artist)
{
_trecks = trecks;
_playlists = playlists;
_playlistsTreck = playlistsTreck;
_genres = genres;
_albums = albums;
_artist = artist;
}
public void Delete(IArtist artist)
{
if (!_artistRepository.Exists(artist.Id))
{
throw new NotFoundException(artist.Id, "artist");
}
_artistRepository.Delete(artist.Id);
}
private void RemoveIfDuplicate(IArtist artist)
{
IArtist foundArtist = _database.FindArtist(artist);
if (foundArtist != artist)
{
_database.RemoveArtist(artist);
}
}
public static Task<IArtistBrowse> BrowseAsync(
this ISession session,
IArtist artist,
ArtistBrowseType type,
object userState = null)
{
var tcs = new TaskCompletionSource<IArtistBrowse>();
var browse = session.Browse(artist, type, userState);
browse.Completed += (sender, args) => tcs.SetResult(browse);
return tcs.Task;
}
public ViewResult Artist(IArtist artist)
{
if (ModelState.IsValid)
{
return View(new ArtistViewData(artist));
}
else
{
// captured by [HandleError]
throw new ArgumentException(ModelState["artist"].Errors.First().ErrorMessage);
}
}
public ArtistInformation(IArtist artist, Dispatcher dispatcher)
{
_portraits = new NotifyCollection<BitmapSource>();
_tracks = new NotifyCollection<Track>();
_albums = new NotifyCollection<Album>();
_similarArtists = new NotifyCollection<Artist>();
_dispatcher = dispatcher;
_artist = artist;
_browse = _artist.Browse();
_isLoading = !_browse.IsComplete;
_browse.Completed += ArtistBrowseCompleted;
}
public override IClip GetClip(ISecurityContext securityContext, IMediaFactory mediaFactory, IMetadataRepository mediaItemRepository, IArtist artist, IAlbum album)
{
var clip = mediaItemRepository.GetByTarget<IClip>(Location).FirstOrDefault();
if (clip != null)
{
return clip;
}
var name = GetClipName();
var summary = string.Empty;
var number = GetClipNumber();
var date = GetDate();
var duration = file != null && file.Properties != null ? file.Properties.Duration : TimeSpan.FromMinutes(5);
var height = file != null && file.Properties != null ? (uint)file.Properties.VideoHeight : 480;
var width = file != null && file.Properties != null ? (uint)file.Properties.VideoWidth : 640;
var builder = new MediaItemBuilder<IClip>(securityContext, mediaFactory)
.Identity(name, summary, date, date, number)
.Size(duration, height, width)
.Target(Location, Type.Name);
return builder.ToMediaItem();
}
public Recommendation(IArtist artist, float rating)
{
Artist = artist;
Value = rating;
}
private INotifyEnumerable<IAlbum> GetAlbums(IArtist artist)
{
return new NotifyCollection<IAlbum>(Builder<Album>
.CreateListOfSize(_random.Next(3, 5))
.WhereAll()
.Has(a => a.Year = _random.Next(1990, 2011))
.Has(a => a.Name = _albumNames[_random.Next(0, _albumNames.Length - 1)])
.Has(a => a.Artist = artist)
.Has(a => a.Info = GetAlbumInformation(a))
.Has(a => a.IsAvailable = true)
.Build());
}
private Task<Stream> GetArtistImageTask(ISession session, IArtist artist)
{
LoginService.EnsureUserIsLoggedIn();
return session
.BrowseAsync(artist, ArtistBrowseType.NoTracks | ArtistBrowseType.NoAlbums)
.ContinueWith(t =>
{
using (t.Result)
{
if (t.Result.Portraits.Count > 0)
{
using (var image = t.Result.Portraits[0])
{
if (image.WaitUntilLoaded())
{
return new MemoryStream(image.Data);
}
return new MemoryStream();
}
}
if (t.Result.Albums.Count > 0)
{
foreach (var album in t.Result.Albums)
{
using (album)
{
if (album.WaitUntilLoaded() && !string.IsNullOrEmpty(album.CoverId))
{
return GetImage(album.CoverId);
}
}
}
}
}
return new MemoryStream();
});
}
private IArtistInformation GetArtistInformation(IArtist artist)
{
return Builder<ArtistInformation>
.CreateNew()
.With(i => i.Albums = GetAlbums(artist))
.With(i => i.Biography = _latinText)
.Build();
}
public virtual IAlbum GetAlbum(ISecurityContext securityContext, IMediaFactory mediaFactory, IMetadataRepository mediaItemRepository, IArtist artist)
{
return null;
}
public IArtistBrowse Browse(IArtist artist, object userData = null)
{
return Browse(artist, ArtistBrowseType.Full, userData);
}
public virtual ITrack GetTrack(ISecurityContext securityContext, IMediaFactory mediaFactory, IMetadataRepository mediaItemRepository, IAudioStreamFactory audioStreamFactory, IArtist artist, IAlbum album)
{
return null;
}
public IArtistBrowse Browse(IArtist artist, ArtistBrowseType browseType, object userData = null)
{
if (!(artist is INativeObject))
{
throw new ArgumentException("Invalid type");
}
AssertHandle();
var browse = new NativeArtistBrowse(this, artist.GetHandle(), browseType);
browse.Initialize();
return browse;
}
public void Save()
{
Database db = Microsoft.Practices.EnterpriseLibrary.Data.DatabaseFactory.CreateDatabase();
if (_artist.ArtistId == 0)
{
//ADD ARTIST
IRepository<IArtist> artist = new ArtistRepository(db);
IRepositoryBLL<IArtist> artistRepoBll = new ArtistRepositoryBLL(artist);
_artist = artistRepoBll.Add(_artist);
//ADD ARTIST CONTACT
IRepository<IArtistContact> contact1 = new ArtistContactRepository(db);
IRepositoryBLL<IArtistContact> contactBll = new ArtistContactRepositoryBLL(contact1);
_artistContact.ArtistId = _artist.ArtistId;
_artistContact = contactBll.Add(_artistContact);
//ADD DISCOGRAPHY
IRepository<IDiscography> disco = new DiscographyRepository(db);
IRepositoryBLL<IDiscography> discoBll = new DiscographyRepositoryBLL(disco);
_discography.ArtistId = _artist.ArtistId;
_discography = discoBll.Add(_discography);
}
if (_album.AlbumId == 0)
{
//ADD ALBUM
IRepository<IAlbum> album1 = new AlbumRepository(db);
IRepositoryBLL<IAlbum> albumBll = new AlbumRepositoryBLL(album1);
_album.ArtistId = _artist.ArtistId;
_album = albumBll.Add(_album);
}
//ADD SONGS
IRepository<ISong> song1 = new SongRepository(db);
IRepositoryBLL<ISong> songBll = new SongRepositoryBLL(song1);
foreach (Song item in _songs)
{
item.AlbumId = _album.AlbumId;
songBll.Add(item);
}
}
private static IObservableCollection<TrackView> GetTrackCollectionFromMusicObject(IArtist iartist)
{
return iartist.Albums.LiveSelectMany(al=>al.Tracks).LiveSelect(t=> TrackView.GetTrackView(t));
}
private static IObservableCollection<IAlbum> GetAlbumCollectionFromMusicObject(IArtist iartist)
{
return iartist.Albums;
}
public virtual IAlbum GetAlbum(ISecurityContext securityContext, IMediaFactory mediaFactory, IMetadataRepository mediaItemRepository, IArtist artist)
{
IAlbum album = null;
var clip = mediaItemRepository.GetByTarget<IClip>(Location).FirstOrDefault();
if (clip != null)
{
album = mediaItemRepository.GetByLocation<IAlbum>(clip.Catalog);
if (album != null)
return album;
}
var albumName = GetAlbumName();
var summary = string.Empty;
album = mediaItemRepository.GetByName<IAlbum>(albumName).FirstOrDefault();
if (album != null)
{
return album;
}
var albumNumber = GetAlbumNumber();
var date = GetDate();
var builder = new MediaItemBuilder<IAlbum>(securityContext, mediaFactory)
.Identity(albumName, summary, date, date, albumNumber)
.Creator(artist.Location, artist.Name);
return builder.ToMediaItem();
}
public override IAlbum GetAlbum(ISecurityContext securityContext, IMediaFactory mediaFactory, IMetadataRepository mediaItemRepository, IArtist artist)
{
IAlbum album = null;
var track = mediaItemRepository.GetByTarget<ITrack>(Location).FirstOrDefault();
if (track != null)
{
album = mediaItemRepository.GetByLocation<IAlbum>(track.Catalog);
if (album != null)
return album;
}
var albumTitle = "Unknown Album";
var summary = string.Empty;
//var albumTag = GetTags().Where(x => x.Type == Id3v2TagType.Album).FirstOrDefault();
if (id3v2Tag != null && id3v2Tag.Album != null)
{
albumTitle = id3v2Tag.Album; //albumTag.Tuple.ToString();
album = mediaItemRepository.GetByCreatorAndName<IAlbum>(artist.Location, albumTitle);
if (album != null)
return album;
}
var builder = new MediaItemBuilder<IAlbum>(securityContext, mediaFactory)
.Identity(albumTitle, summary)
.Creator(artist.Location, artist.Name);
return builder.ToMediaItem();
}
public ArtistViewData(IArtist artist)
{
Artist = artist;
}
internal static IntPtr GetPointer(IArtist artist)
{
if (artist.GetType() == typeof(ArtistWrapper))
return ((ArtistWrapper)artist).artist.artistPtr;
throw new ArgumentException("Invalid artist");
}
public override ITrack GetTrack(ISecurityContext securityContext, IMediaFactory mediaFactory, IMetadataRepository mediaItemRepository, IAudioStreamFactory audioStreamFactory, IArtist artist, IAlbum album)
{
var track = mediaItemRepository.GetByTarget<ITrack>(Location).FirstOrDefault();
//if (track != null)
//return track;
if (id3v2Tag == null)
{
if (track != null)
return track;
var builder = new MediaItemBuilder<ITrack>(securityContext, mediaFactory)
.Identity("Unknown", string.Empty)
.Creator(artist.Location, artist.Name)
.Catalog(album.Location, album.Name)
.Target(Location, Type.Name);
return builder.ToMediaItem();
}
var name = id3v2Tag.Title != null ? id3v2Tag.Title : "Unknown Track";
var summary = id3v2Tag.Lyrics ?? string.Empty;
var recordDate = DateTime.MinValue;
if (id3v2Tag != null && id3v2Tag.RecordingDate > DateTime.MinValue)
recordDate = id3v2Tag.RecordingDate;
else if (id3v1Tag != null && id3v1Tag.Year >= DateTime.MinValue.Year && id3v1Tag.Year <= DateTime.MaxValue.Year)
recordDate = new DateTime((int)id3v1Tag.Year, 1, 1);
var releaseDate = DateTime.MinValue;
if (id3v2Tag != null && id3v2Tag.ReleaseDate > DateTime.MinValue)
releaseDate = id3v2Tag.ReleaseDate;
else if (id3v1Tag != null && id3v1Tag.Year >= DateTime.MinValue.Year && id3v1Tag.Year <= DateTime.MaxValue.Year)
releaseDate = new DateTime((int)id3v1Tag.Year, 1, 1);
var number = id3v2Tag.Track;
var duration = id3v2Tag.Duration;
if (duration == TimeSpan.Zero)
{
using (var audioStream = audioStreamFactory.CreateAudioStream(Location))
{
if (audioStream != null)
{
duration = audioStream.Duration;
}
}
}
var thumbnail = Guid.Empty.ToUrn();
var thumbnailData = id3v2Tag.Pictures != null && id3v2Tag.Pictures.Length > 0 ? id3v2Tag.Pictures[0].Data.ToArray() : new byte[0];
var trackId = track != null ? track.Location : Guid.NewGuid().ToUrn();
var fullBuilder = new MediaItemBuilder<ITrack>(securityContext, mediaFactory)
.Identity(name, summary, recordDate, releaseDate, number, trackId)
.Size(duration)
.Creator(artist.Location, artist.Name)
.Catalog(album.Location, album.Name)
.Target(Location, Type.Name)
.Thumbnail(thumbnail, thumbnailData);
return fullBuilder.ToMediaItem();
}
