public override int GetHashCode()
{
int hash = 1;
if (Schema.Length != 0)
{
hash ^= Schema.GetHashCode();
}
if (Comment.Length != 0)
{
hash ^= Comment.GetHashCode();
}
if (Language.Length != 0)
{
hash ^= Language.GetHashCode();
}
if (ProtoPackage.Length != 0)
{
hash ^= ProtoPackage.GetHashCode();
}
if (LibraryPackage.Length != 0)
{
hash ^= LibraryPackage.GetHashCode();
}
hash ^= Services.GetHashCode();
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public List <ITrack> GetTracksForPlaylist()
{
var musicLibrary = LibraryPackage.GetInstance <IMusicLibrary>();
var tracks = Enumerable.Empty <ITrack>();
var nonLibraryFiles = new List <string>();
foreach (var file in Files)
{
var foundTracks = musicLibrary.GetTracksByAttributeValue(SearchAreas.Filename, file);
if (foundTracks.Count > 0)
{
tracks = tracks.Concat(foundTracks);
}
else
{
nonLibraryFiles.Add(file);
}
}
tracks = tracks.Concat(nonLibraryFiles.Select(file =>
{
try
{
return(Track.BuildTrackInstance(file));
}
catch (Exception ex)
{
throw new Exception(string.Format("Error while loading track from file '{0}' for playlist {1}", file, ToString()), ex);
}
}));
return(tracks.ToList());
}
/// <summary>
/// Retrieve all packages metadata in the library
/// </summary>
public IEnumerable <LibraryPackage> GetPackages()
{
foreach (var packageFolder in _libraryFolder.EnumerateDirectories())
{
var platformSpecificFolder = packageFolder.GetDirectories(_dotnetPlatform);
if (platformSpecificFolder != null && platformSpecificFolder.Length != 0)
{
var items = platformSpecificFolder[0].GetFiles("project.json");
if (items != null && items.Length == 1)
{
var item = items[0];
LibraryPackage package = null;
try
{
package = JsonConvert.DeserializeObject <LibraryPackage>(item.OpenText().ReadToEnd());
}
catch (Exception e)
{
//TODO: print to output
Debug.Print($"Could not find a valid package json fle in {item.FullName}: {e.Message}");
}
if (package != null)
{
yield return(package);
}
}
}
}
}
public static IAudioFileMetadata BuildAudioFileMetaData(CdMetadata cdMetadata, int trackNumber)
{
var AudioFileMetadata = LibraryPackage.GetInstance <IAudioFileMetadata>() as AudioFileMetadata;
AudioFileMetadata.Title = cdMetadata.Tracks[trackNumber];
AudioFileMetadata.Artist = cdMetadata.Artist;
AudioFileMetadata.Album = cdMetadata.Album;
return(AudioFileMetadata as IAudioFileMetadata);
}
public override string ToString()
{
var musicLibrary = LibraryPackage.GetInstance <IMusicLibrary>();
var displayTitle = Title == string.Empty ? "Unknown Title" : Title;
var displayArtist = "Unknown Artist";
if (ArtistId != null && ArtistId != -1)
{
displayArtist = musicLibrary.GetArtistById((long)ArtistId).ToString();
}
return(string.Format("{0} - {1}", displayArtist, displayTitle));
}
public static ITrack BuildTrackInstance(Song song)
{
if (song == null)
{
throw new ArgumentException("Cannot build track instance with a null song instance");
}
var track = LibraryPackage.GetInstance <ITrack>() as Track;
track._album = song.Album ?? new Album {
Id = -1
};
track._artist = song.Artist ?? new Artist {
Id = -1
};
track.Song = song;
return(track as ITrack);
}
public LibraryDbMockGenerator(bool overrideLibraryPackage = true)
{
DbContextMock = A.Fake <IMusicLibraryDbContext>();
if (overrideLibraryPackage && !containerModified)
{
LibraryPackage.ExecutingForUnitTests = true;
var libraryContainer = LibraryPackage.GetContainerForTestOverrides();
libraryContainer.Options.AllowOverridingRegistrations = true;
libraryContainer.RegisterSingleton <IMusicLibraryDbContext>(DbContextMock);
containerModified = true;
}
Songs = new List <Song>();
var songId = 0;
Artists.ForEach(artist =>
{
Albums.ForEach(album =>
{
Songs.Add(new Song
{
Id = songId,
FileName = Mp3FilePath,
Title = "wish you were here",
LengthInSeconds = 120,
AlbumId = album.Id,
ArtistId = artist.Id
});
songId++;
});
});
WireUpMockData();
}
public static IAudioFileMetadata BuildAudioFileMetaData(string fileName, long albumId = -1)
{
var audioFileMetadata = LibraryPackage.GetInstance <IAudioFileMetadata>() as AudioFileMetadata;
audioFileMetadata.AudioFilePath = fileName;
audioFileMetadata._dbAlbumId = albumId;
try
{
var fileInfo = new FileInfo(audioFileMetadata.AudioFilePath);
if (string.Equals(fileInfo.Extension, ".cda", StringComparison.OrdinalIgnoreCase))
{
audioFileMetadata.LoadDetailsFromCddbServer();
audioFileMetadata.LoadMissingTrackDetailsFromFileName();
audioFileMetadata.HasFutherMetadataTag = false;
return(audioFileMetadata as IAudioFileMetadata);
}
using (var fileStream = new FileStream(audioFileMetadata.AudioFilePath, FileMode.Open))
{
var tagFile = TagLib.File.Create(new StreamFileAbstraction(fileName, fileStream, fileStream));
var tag = tagFile.Tag;
if (tag == null)
{
throw new Exception("Audio file does not contain a valid tag");
}
audioFileMetadata.Title = tag.Title;
audioFileMetadata.Artist = tag.FirstPerformer;
audioFileMetadata.Album = tag.Album;
audioFileMetadata._trackLength = (int)tagFile.Length;
try
{
var artwork = tag.Pictures;
audioFileMetadata._hasAlbumArt = artwork?[0] != null;
}
catch (Exception ex)
{
logger.Warn(string.Format("Failed to extract album art info from the tag in audio file '{0}'", fileName), ex);
audioFileMetadata._hasAlbumArt = false;
}
}
audioFileMetadata.LoadMissingTrackDetailsFromFileName();
audioFileMetadata.HasFutherMetadataTag = true;
}
catch (Exception ex)
{
logger.Warn(string.Format("Error occured while parsing metadata from audio file '{0}'", audioFileMetadata.AudioFilePath), ex);
audioFileMetadata.HasFutherMetadataTag = false;
audioFileMetadata.LoadMissingTrackDetailsFromFileName();
}
return(audioFileMetadata as IAudioFileMetadata);
}
