/// <summary> /// Записывает версию файла в хранилище. /// </summary> /// <param name="fileMetadata">Метаданные существующего файла.</param> /// <param name="stream">Содержимое файла.</param> /// <param name="fileName">Имя файла.</param> /// <returns></returns> public IFileVersionMetadata WriteFileVersion(IFileMetadata fileMetadata, Stream stream, string fileName = null) { if (fileMetadata == null) { throw new ArgumentNullException("fileMetadata"); } if (fileMetadata.FolderMetadata == null) { throw new ArgumentNullException("fileMetadata.FolderMetadata"); } if (stream == null) { throw new ArgumentNullException("stream"); } this.Logger.WriteFormatMessage("WriteFileVersion:Начало записи новой версии файла, fileMetadata.Name: {0}, fileMetadata.UniqueID: {1}", fileMetadata.Name, fileMetadata.UniqueID); IBlobFileMetadata blobFileMetadata = (IBlobFileMetadata)fileMetadata; if (!string.IsNullOrEmpty(fileName)) { blobFileMetadata.Name = fileName; } //резервация параметров сохранения //например идентификатора версии, его нужно знать заранее. blobFileMetadata.EnsureSaveProperties(); //запись версии файла IFileVersionMetadata savedVersion = this.WriteInternal(blobFileMetadata, stream); return(savedVersion); }
public static byte[] GetArtwork(Album album, IFileMetadata fileMetadata) { byte[] artworkData = null; try { // Don't get artwork is the album is unknown if (!album.AlbumTitle.Equals(Defaults.UnknownAlbumText)) { // Get embedded artwork artworkData = GetEmbeddedArtwork(fileMetadata); if (artworkData == null || artworkData.Length == 0) { // If getting embedded artwork failed, try to get external artwork. artworkData = GetExternalArtwork(fileMetadata.Path, 0, 0); } } } catch (Exception ex) { LogClient.Error("Could not get artwork for Album with Title='{0}' and Album artist='{1}'. Exception: {2}", album.AlbumTitle, album.AlbumArtist, ex.Message); } return(artworkData); }
public static byte[] GetArtwork(string albumKey, IFileMetadata fileMetadata) { byte[] artworkData = null; try { // Don't get artwork if the album is unknown if (!string.IsNullOrEmpty(albumKey)) { // Get embedded artwork artworkData = GetEmbeddedArtwork(fileMetadata); if (artworkData == null || artworkData.Length == 0) { // If getting embedded artwork failed, try to get external artwork. artworkData = GetExternalArtwork(fileMetadata.Path, 0, 0); } } } catch (Exception ex) { LogClient.Error($"Could not get artwork for Album with AlbumKey='{albumKey}'. Exception: {ex.Message}"); } return(artworkData); }
/// <inheritdoc/> public async Task <byte[]> CreateFileAsync(IFileMetadata fileMetadata, Stream content = null) { Logger.LogMessage($"{nameof(IFolder)}.{nameof(CreateFileAsync)}()", Path.Combine(UserFileSystemPath, fileMetadata.Name)); FileInfo remoteStorageItem = new FileInfo(Path.Combine(RemoteStoragePath, fileMetadata.Name)); // Upload remote storage file content. await using (FileStream remoteStorageStream = remoteStorageItem.Open(FileMode.CreateNew, FileAccess.Write, FileShare.Delete)) { if (content != null) { await content.CopyToAsync(remoteStorageStream); remoteStorageStream.SetLength(content.Length); } } // Update remote storage file metadata. remoteStorageItem.Attributes = fileMetadata.Attributes; remoteStorageItem.CreationTimeUtc = fileMetadata.CreationTime.UtcDateTime; remoteStorageItem.LastWriteTimeUtc = fileMetadata.LastWriteTime.UtcDateTime; remoteStorageItem.LastAccessTimeUtc = fileMetadata.LastAccessTime.UtcDateTime; remoteStorageItem.LastWriteTimeUtc = fileMetadata.LastWriteTime.UtcDateTime; // Return remote storage item ID. It will be passed later into IEngine.GetFileSystemItemAsync() method. return(WindowsFileSystemItem.GetItemIdByPath(remoteStorageItem.FullName)); }
public static void SplitMetadata(IFileMetadata fileMetadata, ref Track track, ref TrackStatistic trackStatistic, ref Album album, ref Artist artist, ref Genre genre) { string path = fileMetadata.Path; // Track information track.Path = path; track.SafePath = path.ToSafePath(); track.FileName = FileUtils.NameWithoutExtension(path); track.Duration = Convert.ToInt64(fileMetadata.Duration.TotalMilliseconds); track.MimeType = fileMetadata.MimeType; track.BitRate = fileMetadata.BitRate; track.SampleRate = fileMetadata.SampleRate; track.TrackTitle = MetadataUtils.SanitizeTag(fileMetadata.Title.Value); track.TrackNumber = MetadataUtils.SafeConvertToLong(fileMetadata.TrackNumber.Value); track.TrackCount = MetadataUtils.SafeConvertToLong(fileMetadata.TrackCount.Value); track.DiscNumber = MetadataUtils.SafeConvertToLong(fileMetadata.DiscNumber.Value); track.DiscCount = MetadataUtils.SafeConvertToLong(fileMetadata.DiscCount.Value); track.Year = MetadataUtils.SafeConvertToLong(fileMetadata.Year.Value); track.HasLyrics = string.IsNullOrWhiteSpace(fileMetadata.Lyrics.Value) ? 0 : 1; track.NeedsIndexing = 0; // TrackStatistic information trackStatistic.Path = path; trackStatistic.SafePath = path.ToSafePath(); trackStatistic.Rating = fileMetadata.Rating.Value; // Before proceeding, get the available artists string albumArtist = GetFirstAlbumArtist(fileMetadata); string trackArtist = GetFirstArtist(fileMetadata); // will be used for the album if no album artist is found // Album information album.AlbumTitle = string.IsNullOrWhiteSpace(fileMetadata.Album.Value) ? Defaults.UnknownAlbumText : MetadataUtils.SanitizeTag(fileMetadata.Album.Value); album.AlbumArtist = (albumArtist == Defaults.UnknownArtistText ? trackArtist : albumArtist); album.DateAdded = DateTime.Now.Ticks; album.DateCreated = FileUtils.DateCreatedTicks(path); UpdateAlbumYear(album, MetadataUtils.SafeConvertToLong(fileMetadata.Year.Value)); // Artist information artist.ArtistName = trackArtist; // Genre information genre.GenreName = GetFirstGenre(fileMetadata); // Metadata hash System.Text.StringBuilder sb = new System.Text.StringBuilder(); sb.Append(album.AlbumTitle); sb.Append(artist.ArtistName); sb.Append(genre.GenreName); sb.Append(track.TrackTitle); sb.Append(track.TrackNumber); sb.Append(track.Year); track.MetaDataHash = CryptographyUtils.MD5Hash(sb.ToString()); // File information track.FileSize = FileUtils.SizeInBytes(path); track.DateFileModified = FileUtils.DateModifiedTicks(path); track.DateLastSynced = DateTime.Now.Ticks; }
/// <summary> /// Creates the metadata. /// </summary> /// <param name="fileName">Name of the file.</param> /// <returns></returns> private IFileMetadata CreateMetadata(string fileName) { IFileMetadata retval = null; try { using (var context = new MetaFSDB()) { var metadata = context.TemplateCatalogues.FirstOrDefault(x => x.IsActive.Value); if (metadata != null) { retval = new FileMetadata() { PcId = PcIdentifier, FullPath = fileName, TemplateId = metadata.TemplateId, FileName = Path.GetFileName(fileName), TemplateBody = metadata.TemplateBody.LoadAsXDocument() }; } } } catch (Exception ex) { Logger.LogError(ex); } return(retval); }
public IFileMetadata GetFileMetadata(string path) { bool restartTimer = this.updateFileMetadataTimer.Enabled; // If the timer is started, remember to restart it once we're done here. this.updateFileMetadataTimer.Stop(); IFileMetadata returnFileMetadata = null; // Check if there is a queued FileMetadata for this path, if yes, use that as it has more up to date information. lock (lockObject) { if (this.fileMetadataDictionary.ContainsKey(path.ToSafePath())) { returnFileMetadata = this.fileMetadataDictionary[path.ToSafePath()]; } } // If no queued FileMetadata was found, create a new one from the actual file. if (returnFileMetadata == null) { returnFileMetadata = metadataFactory.Create(path); } if (restartTimer) { this.updateFileMetadataTimer.Start(); // Restart the timer if necessary } return(returnFileMetadata); }
/// <summary> /// Gets the file metadata. /// </summary> /// <param name="macAddress">The mac address.</param> /// <param name="computerName">Name of the computer.</param> /// <param name="fileName">Name of the file.</param> /// <returns></returns> public IFileMetadata GetFileMetadata(string macAddress, string computerName, string fileName) { dynamic metadata; IFileMetadata retval = null; try { using (var context = new MetaFSDB()) { if ((metadata = GetMetadata(context, macAddress, computerName, fileName)) != null) { // Metadata found retval = new FileMetadata() { MetadataId = metadata.RowId, Category = metadata.Category, FileName = metadata.FileName, FullPath = metadata.FilePath, TemplateId = metadata.TemplateId, PcId = metadata.PcId, Metadata = ((string)metadata.Metadata).LoadAsXDocument(), SubCategory = metadata.SubCategory, TemplateBody = ((string)metadata.Template).LoadAsXDocument() }; } else // Metadata needs to be created { retval = CreateMetadata(fileName); } } } catch (Exception ex) { Logger.LogError(ex); } return(retval); }
private async Task UpdateDatabaseMetadataAsync(IFileMetadata fileMetadata, bool updateAlbumArtwork) { // Get the track from the database Track track = await this.trackRepository.GetTrackAsync(fileMetadata.SafePath); if (track == null) { return; } // Update track fields await Task.Run(() => MetadataUtils.FillTrackBase(fileMetadata, ref track)); // Update the Track in the database await this.trackRepository.UpdateTrackAsync(track); if (updateAlbumArtwork) { // Cache the new artwork string artworkID = await this.cacheService.CacheArtworkAsync(fileMetadata.ArtworkData.Value); // Add or update AlbumArtwork in the database await this.albumArtworkRepository.UpdateAlbumArtworkAsync(track.AlbumKey, artworkID); } }
public static void FillTrack(IFileMetadata fileMetadata, ref Track track) { string path = fileMetadata.Path; long nowTicks = DateTime.Now.Ticks; track.Path = path; track.SafePath = path.ToSafePath(); track.FileName = FileUtils.NameWithoutExtension(path); track.Duration = Convert.ToInt64(fileMetadata.Duration.TotalMilliseconds); track.MimeType = fileMetadata.MimeType; track.BitRate = fileMetadata.BitRate; track.SampleRate = fileMetadata.SampleRate; track.TrackTitle = MetadataUtils.TrimTag(fileMetadata.Title.Value); track.TrackNumber = MetadataUtils.SafeConvertToLong(fileMetadata.TrackNumber.Value); track.TrackCount = MetadataUtils.SafeConvertToLong(fileMetadata.TrackCount.Value); track.DiscNumber = MetadataUtils.SafeConvertToLong(fileMetadata.DiscNumber.Value); track.DiscCount = MetadataUtils.SafeConvertToLong(fileMetadata.DiscCount.Value); track.Year = MetadataUtils.SafeConvertToLong(fileMetadata.Year.Value); track.HasLyrics = string.IsNullOrWhiteSpace(fileMetadata.Lyrics.Value) ? 0 : 1; track.NeedsIndexing = 0; track.NeedsAlbumArtworkIndexing = 0; track.FileSize = FileUtils.SizeInBytes(path); track.DateFileCreated = FileUtils.DateCreatedTicks(path); track.DateFileModified = FileUtils.DateModifiedTicks(path); track.DateAdded = nowTicks; track.DateLastSynced = nowTicks; track.Artists = GetAllArtists(fileMetadata); track.Genres = GetAllGenres(fileMetadata); track.AlbumTitle = GetAlbumTitle(fileMetadata); track.AlbumArtists = GetAllAlbumArtists(fileMetadata); track.AlbumKey = GenerateInitialAlbumKey(track.AlbumTitle, track.AlbumArtists); track.Rating = fileMetadata.Rating.Value; }
private string AppendHeader(IOutputFile output) { string content = output.Content; IFileMetadata fileMetadata = output.FileMetadata; string header = GetHeader(output); //Deal with XML Declartions <?xml...> switch (fileMetadata.FileExtension.ToLower()) { case "xml": case "config": if (content.Substring(0, 2) == "<?") { int pos = content.IndexOf(">\r\n"); return(content.Substring(0, pos + 3) + header + content.Substring(pos + 3)); } break; } if (!string.IsNullOrWhiteSpace(header)) { content = header + content; } return(content); }
public async Task <IFileMetadata> GetFileMetadataAsync(string path) { IFileMetadata returnFileMetadata = null; await Task.Run(() => { returnFileMetadata = this.GetFileMetadata(path); }); return(returnFileMetadata); }
/// <summary> /// Creates or updates file in the remote storage. /// </summary> /// <param name="remoteStoragePath">Path of the file to be created or updated in the remote storage.</param> /// <param name="newInfo">New information about the file, such as modification date, attributes, custom data, etc.</param> /// <param name="mode">Specifies if a new file should be created or existing file should be updated.</param> /// <param name="newContentStream">New file content or null if the file content is not modified.</param> /// <param name="eTagOld">The ETag to be sent to the remote storage as part of the update request to make sure the content is not overwritten.</param> /// <param name="lockInfo">Information about the lock. Null if the item is not locked.</param> /// <returns>The new ETag returned from the remote storage.</returns> protected async Task <string> CreateOrUpdateFileAsync( string remoteStoragePath, IFileMetadata newInfo, FileMode mode, Stream newContentStream = null, string eTagOld = null, ServerLockInfo lockInfo = null) { FileInfo remoteStorageItem = new FileInfo(remoteStoragePath); try { Program.VirtualDrive.RemoteStorageMonitor.Enabled = false; // Disable RemoteStorageMonitor to avoid circular calls. // If another thread is trying to sync the same file, this call will fail in other threads. // In your implementation you must lock your remote storage file, or block it for reading and writing by other means. await using (FileStream remoteStorageStream = remoteStorageItem.Open(mode, FileAccess.Write, FileShare.None)) { string userFileSystemPath = Mapping.ReverseMapPath(remoteStoragePath); if (mode == FileMode.Open) { // Verify that the item in the remote storage is not modified since it was downloaded to the user file system. // In your real-life application you will send the ETag to the server as part of the update request. FileSystemItemMetadataExt itemInfo = Mapping.GetUserFileSysteItemMetadata(remoteStorageItem); if (!(await VirtualDrive.GetETagManager(userFileSystemPath).ETagEqualsAsync(itemInfo))) { throw new ConflictException(Modified.Server, "Item is modified in the remote storage, ETags not equal."); } } // Update ETag/LastWriteTime in user file system, so the synchronyzation or remote storage monitor would not start the new update. // This is only required to avoid circular updates because of the simplicity of this sample. // In your real-life application you will receive a new ETag from the server in the update response // and return it from this method. string eTagNew = newInfo.LastWriteTime.ToUniversalTime().ToString("o"); await VirtualDrive.GetETagManager(userFileSystemPath).SetETagAsync(eTagNew); // Update remote storage file content. if (newContentStream != null) { await newContentStream.CopyToAsync(remoteStorageStream); remoteStorageStream.SetLength(newContentStream.Length); } // Update remote storage file basic info. WindowsFileSystemItem.SetFileInformation( remoteStorageStream.SafeFileHandle, newInfo.Attributes, newInfo.CreationTime, newInfo.LastWriteTime, newInfo.LastAccessTime, newInfo.LastWriteTime); return(eTagNew); } } finally { Program.VirtualDrive.RemoteStorageMonitor.Enabled = true; } }
public SessionInfo(IFileMetadata metadata) { Key = metadata.Directory; if (Key.Length > 6) { Key = metadata.Directory.Substring(0, 6).ToUpper(); } Value = metadata.Directory.ToUpper(); }
public FileMetadataResponse(IFileMetadata fileMetadata) : base(fileMetadata) { Revisions = fileMetadata.Revisions; Extension = fileMetadata.Extension; ThumbnailId = fileMetadata.ThumbnailId; Revisions = fileMetadata.Revisions; Tags = fileMetadata.Tags; Language = fileMetadata.Language; }
/// <summary> /// Updates the existing record. /// </summary> /// <param name="currentMetadata">The current metadata.</param> /// <param name="context">The context.</param> /// <param name="metadata">The metadata.</param> private void UpdateExistingRecord(IFileMetadata currentMetadata, MetaFSDB context, XDocument metadata) { var existing = context.Metadatas.FirstOrDefault(x => x.MetaId == currentMetadata.MetadataId); existing.Metadata1 = metadata.ToString(); context.Metadatas.Attach(existing); var entry = context.Entry(existing); entry.Property(e => e.Metadata1).IsModified = true; context.SaveChanges(); }
public static async Task <Track> Path2TrackAsync(IFileMetadata fileMetadata) { var track = Track.CreateDefault(fileMetadata.Path); await Task.Run(() => { MetadataUtils.FillTrack(fileMetadata, ref track); }); return(track); }
public static async Task <PlayableTrack> Path2TrackAsync(IFileMetadata fileMetadata, TrackStatistic savedTrackStatistic) { var returnTrack = new PlayableTrack(); await Task.Run(() => { var track = new Track(); var trackStatistic = new TrackStatistic(); var album = new Album(); var artist = new Artist(); var genre = new Genre(); MetadataUtils.SplitMetadata(fileMetadata, ref track, ref trackStatistic, ref album, ref artist, ref genre); returnTrack.Path = track.Path; returnTrack.SafePath = track.Path.ToSafePath(); returnTrack.FileName = track.FileName; returnTrack.MimeType = track.MimeType; returnTrack.FileSize = track.FileSize; returnTrack.BitRate = track.BitRate; returnTrack.SampleRate = track.SampleRate; returnTrack.TrackTitle = track.TrackTitle; returnTrack.TrackNumber = track.TrackNumber; returnTrack.TrackCount = track.TrackCount; returnTrack.DiscNumber = track.DiscNumber; returnTrack.DiscCount = track.DiscCount; returnTrack.Duration = track.Duration; returnTrack.Year = track.Year; returnTrack.HasLyrics = track.HasLyrics; returnTrack.ArtistName = artist.ArtistName; returnTrack.GenreName = genre.GenreName; returnTrack.AlbumTitle = album.AlbumTitle; returnTrack.AlbumArtist = album.AlbumArtist; returnTrack.AlbumYear = album.Year; // If there is a saved TrackStatistic, used that one. Otherwise the // TrackStatistic from the file is used. That only contains rating. if (savedTrackStatistic != null) { trackStatistic = savedTrackStatistic; } returnTrack.Rating = trackStatistic.Rating; returnTrack.Love = trackStatistic.Love; returnTrack.PlayCount = trackStatistic.PlayCount; returnTrack.SkipCount = trackStatistic.SkipCount; returnTrack.DateLastPlayed = trackStatistic.DateLastPlayed; }); return(returnTrack); }
public string GetTableName(IFileMetadata metadata) { if (metadata == null) { throw new ArgumentNullException("metadata"); } FileMetadata typedMetadata = (FileMetadata)metadata; return(this.GetTableName(typedMetadata)); }
internal static async Task SaveFileMetadataAsync(IFileMetadata metadata) { var metadataFile = GetFileMetadataFileInfo(metadata.Id); var metadataJson = JsonConvert.SerializeObject(metadata); var metadataJsonBytes = Encoding.UTF8.GetBytes(metadataJson); using (var fileStream = new FileStream(metadataFile.FullName, FileMode.Create, FileAccess.Write)) { await fileStream.WriteAsync(metadataJsonBytes, 0, metadataJsonBytes.Length); } }
public File(IFileMetadata fileMetadata) { if (fileMetadata == null) { throw new ArgumentNullException("fileMetadata"); } Id = fileMetadata.Id; Name = fileMetadata.Name; MediaType = fileMetadata.MediaType; Size = fileMetadata.Size; }
/// <summary> /// Renders the helper. /// </summary> /// <param name="metadata">The metadata.</param> private void RenderHelper(IFileMetadata metadata) { var template = new TemplateDefinition(metadata); var controls = (new ControlFactory()).Create(template, View as IChangeMonitor); var container = View.Controls.Find("mainContainer", true).FirstOrDefault(); if (container != null) { container.InvokeThroughLambda(x => x.Controls.Clear()); container.InvokeThroughLambda(x => x.Controls.AddRange(controls.ToArray())); } }
public async Task <bool> SaveTracksAsync() { if (!this.AllEntriesValid()) { return(false); } var fmdList = new List <IFileMetadata>(); this.IsBusy = true; await Task.Run(() => { try { foreach (string path in this.paths) { IFileMetadata fmd = this.metadataService.GetFileMetadata(path); fmd.Artists = this.artists; fmd.Title = this.title; fmd.Album = this.album; fmd.AlbumArtists = this.albumArtists; fmd.Year = this.year; fmd.TrackNumber = this.trackNumber; fmd.TrackCount = this.trackCount; fmd.DiscNumber = this.discNumber; fmd.DiscCount = this.discCount; fmd.Genres = this.genres; fmd.Grouping = this.grouping; fmd.Comment = this.comment; fmd.Lyrics = this.lyrics; fmd.ArtworkData = this.Artwork; fmdList.Add(fmd); } } catch (Exception ex) { LogClient.Error("An error occurred while setting the metadata. Exception: {0}", ex.Message); } }); if (fmdList.Count > 0) { await this.metadataService.UpdateTracksAsync(fmdList, this.UpdateAlbumArtwork); } this.IsBusy = false; return(true); }
public IFileMetadata GetFileMetadata(string path) { // First, check if there is a fileMetadata which is queued for saving. // If yes, use that, as it has more up to date information. IFileMetadata fileMetadata = this.updater.GetFileMetadataToUpdate(path); if (fileMetadata == null) { // If not, create a new fileMetadata from the file path. fileMetadata = this.metadataFactory.Create(path); } return(fileMetadata); }
public FileMetadataResponse(IFileMetadata fileMetadata) : base(fileMetadata) { QuickNumber = fileMetadata.QuickNumber; Extension = fileMetadata.Extension; UploadDate = fileMetadata.UploadDate; EncryptionKey = fileMetadata.EncryptionKey; RevisionNumber = fileMetadata.RevisionNumber; Hash = fileMetadata.Hash; ThumbnailId = fileMetadata.ThumbnailId; Revisions = fileMetadata.Revisions; ParentDirectoryIds = fileMetadata.ParentDirectoryIds; Tags = fileMetadata.Tags.Select(x => new Tag(x)).ToArray(); Language = fileMetadata.Language; }
private byte[] GetEmbeddedArtwork(string filename, int size) { byte[] artwork = null; IFileMetadata fmd = this.GetFileMetadata(filename); if (fmd.ArtworkData.Value != null) { // If size > 0, resize the artwork. Otherwise, get the full artwork. artwork = size > 0 ? ImageUtils.ResizeImageInByteArray(fmd.ArtworkData.Value, size, size) : fmd.ArtworkData.Value; } return(artwork); }
public Task <IFileMetadata> Update(IFileMetadata metadata, Stream stream) { if (metadata == null) { throw new ArgumentNullException(nameof(metadata)); } if (stream == null) { throw new ArgumentNullException(nameof(stream)); } return(this.Update(metadata.FullName, stream)); }
/// <summary> /// Dynamicallies the render controls. /// </summary> /// <param name="metadata">The metadata.</param> public void DynamicallyRenderControls(IFileMetadata metadata) { if (View == null) { throw new NullReferenceException("View has not been set"); } if (metadata == null) { throw new NullReferenceException("Metadata was not found"); } RenderHelper(metadata); }
public static byte[] GetEmbeddedArtwork(IFileMetadata fileMetadata) { byte[] artworkData = null; try { artworkData = fileMetadata.ArtworkData.Value; } catch (Exception ex) { LogClient.Error("There was a problem while getting artwork data for Track with path='{0}'. Exception: {1}", fileMetadata.Path, ex.Message); } return(artworkData); }
public static void FillTrackBase(IFileMetadata fileMetadata, ref Track track) { track.TrackTitle = TrimTag(fileMetadata.Title.Value); track.Year = SafeConvertToLong(fileMetadata.Year.Value); track.TrackNumber = SafeConvertToLong(fileMetadata.TrackNumber.Value); track.TrackCount = SafeConvertToLong(fileMetadata.TrackCount.Value); track.DiscNumber = SafeConvertToLong(fileMetadata.DiscNumber.Value); track.DiscCount = SafeConvertToLong(fileMetadata.DiscCount.Value); track.HasLyrics = string.IsNullOrWhiteSpace(fileMetadata.Lyrics.Value) ? 0 : 1; track.Artists = GetOrderedMultiValueTags(fileMetadata.Artists); track.Genres = GetOrderedMultiValueTags(fileMetadata.Genres); track.AlbumTitle = GetAlbumTitle(fileMetadata); track.AlbumArtists = GetOrderedMultiValueTags(fileMetadata.AlbumArtists); track.AlbumKey = GenerateInitialAlbumKey(track.AlbumTitle, track.AlbumArtists); }
public FileImpl(IFileMetadata metadata) { _metadata = metadata; }