/// <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;
}
