/// <summary>
/// Saves the audiobook metadata in the library metadata folder.
/// </summary>
/// <param name="audiobook">Audiobook to be saved</param>
public void SaveMetadata(Audiobook audiobook)
{
if (string.IsNullOrEmpty(audiobook.Metadata.MetadataPath))
{
throw new FileNotFoundException("No metadata path is set for this audiobook.");
}
XElement audiobookXML = audiobook.ToXML();
string audiobookMetadataPath = Path.Combine(MetadataFolder, audiobook.Metadata.MetadataPath);
Directory.CreateDirectory(audiobookMetadataPath);
XMLHelper.SaveToXML(audiobook, Path.Combine(audiobookMetadataPath,
ConfigurationManager.AppSettings.Get("audiobook_metadata_filename") + "."
+ ConfigurationManager.AppSettings.Get("metadata_extensions")));
string chapterMetadataPath = Path.Combine(audiobookMetadataPath, "chapters");
Directory.CreateDirectory(chapterMetadataPath);
foreach (Chapter chapter in audiobook.Chapters)
{
if (string.IsNullOrEmpty(chapter.Metadata.MetadataPath))
{
chapter.Metadata.MetadataPath = Guid.NewGuid().ToString() + "." + ConfigurationManager.AppSettings.Get("metadata_extensions");
}
XMLHelper.SaveToXML(chapter, Path.Combine(chapterMetadataPath, chapter.Metadata.MetadataPath));
}
}
public void RemoveAudiobook(Audiobook audiobook)
{
if (audiobook != null && audiobook.Library != null)
{
audiobook.Library.RemoveAudiobook(audiobook);
}
}
/// <summary>
/// Loads a section of the audiobook folders from the appdata/metadata/library folder.
/// </summary>
/// <param name="audiobookFolders">list of all audiobook folders</param>
/// <param name="start">start index</param>
/// <param name="end">end index</param>
/// <param name="progress">progress object to give updates to the caller</param>
private void LoadMetadata(string[] audiobookFolders, int start, int end, IProgress <UpdateReport> progress = null)
{
for (int i = start; i < end; i++)
{
string audiobookMetadataPath = Path.Combine(audiobookFolders[i], ConfigurationManager.AppSettings.Get("audiobook_metadata_filename"))
+ "." + ConfigurationManager.AppSettings.Get("metadata_extensions");
// ignore folders without audiobook metadata
if (!File.Exists(audiobookMetadataPath))
{
continue;
}
Audiobook audiobook = AudiobookManager.Instance.CreateAudiobook(audiobookMetadataPath);
string chapterMetadataPath = Path.Combine(audiobookFolders[i], "chapters");
string[] chapterFiles = Directory.GetFiles(chapterMetadataPath);
Parallel.ForEach(chapterFiles, (chapterFile) =>
{
Chapter chapter = AudiobookManager.Instance.CreateChapter(chapterFile);
audiobook.Chapters.Add(chapter);
});
AddAudiobook(audiobook);
}
if (progress != null)
{
progress.Report(new UpdateReport());
}
}
public void UpdateAudiobook(Library library, Audiobook audiobook)
{
if (library != null)
{
library.UpdateAudiobook(audiobook);
}
}
private void ClearChapterMetadata(Audiobook audiobook)
{
string chapterMetadataPath = Path.Combine(audiobook.Metadata.MetadataPath, "chapters");
try
{
Directory.Delete(chapterMetadataPath, true);
}
catch (IOException)
{
throw new DeleteMetadataException(chapterMetadataPath, "could not be cleared.");
}
}
/// <summary>
/// Removes an audiobook from this library and removes the link to it from the audiobook.
/// The link is only removed if it points to this library.
/// </summary>
/// <param name="audiobook">audiobook to be removed</param>
public void RemoveAudiobook(Audiobook audiobook)
{
if (Contains(audiobook))
{
Audiobooks.Remove(audiobook.ID);
if (audiobook.Library.Equals(this))
{
audiobook.Library = null;
}
DeleteMetadataFolder(audiobook.Metadata.MetadataPath);
}
}
public object Clone()
{
Audiobook copy = new Audiobook(ID, Library);
copy.Metadata = (AudiobookMetadata)Metadata.Clone();
foreach (Chapter chapter in Chapters)
{
copy.Chapters.Add((Chapter)chapter.Clone());
}
return(copy);
}
/// <summary>
/// Adds an audiobook to the Library. If it is already added the audiobook is updated.
/// Every audiobook that is new to the library gets a new metadata path.
/// </summary>
public void UpdateAudiobook(Audiobook audiobook)
{
if (Contains(audiobook))
{
ClearChapterMetadata(audiobook);
Audiobooks.Remove(audiobook.ID);
}
else
{
audiobook.Metadata.MetadataPath = Path.Combine(MetadataFolder, Guid.NewGuid().ToString());
}
AddAudiobook(audiobook);
}
public Audiobook GetAudiobook(string destination)
{
foreach (Library library in LibraryManager.Instance.GetLibraries())
{
Audiobook found = library.GetAudiobooks().FirstOrDefault(a => a.Metadata.Path.Equals(destination));
if (found != null)
{
return(found);
}
}
return(null);
}
/// <summary>
/// Adds an audiobook to this library if it is not already added.
/// </summary>
/// <param name="audiobook"></param>
private void AddAudiobook(Audiobook audiobook)
{
if (!(audiobook == null || Contains(audiobook)) && audiobook.Chapters.Count > 0)
{
if (audiobook.Library != null)
{
audiobook.Library.RemoveAudiobook(audiobook);
}
audiobook.Library = this;
Audiobooks.Add(audiobook.ID, audiobook);
SaveMetadata(audiobook);
}
}
public Audiobook CreateAudiobook(string metadataPath)
{
Audiobook audiobook = CreateAudiobook();
if (File.Exists(metadataPath))
{
XDocument metadataDoc = XDocument.Load(metadataPath);
var audiobookRoot = XMLHelper.GetFirstXElement(metadataDoc, "Audiobook");
if (audiobookRoot != null)
{
audiobook.FromXML(audiobookRoot);
}
audiobook.Metadata.MetadataPath = Directory.GetParent(metadataPath).FullName;
}
return(audiobook);
}
/// <summary>
/// Checks whether this library contains the given audiobook.
/// </summary>
/// <param name="audiobook">audiobook which is searched for</param>
/// <returns>true if the audiobook is already in the library</returns>
public bool Contains(Audiobook audiobook)
{
return(Contains(audiobook.ID));
}
/// <summary>
/// Uses the scanner object to scan the library folder for new files. If new files are found corresponding
/// metadata files are created.
/// </summary>
/// <param name="hardScan">if set to true all files which are not found will be deleted permanently</param>
public void ScanLibrary(bool hardScan = false)
{
// build index to access audiobooks by their paths
Dictionary <string, Audiobook> audiobookIndex = new Dictionary <string, Audiobook>();
foreach (Audiobook audiobook in GetAudiobooks())
{
audiobookIndex.Add(audiobook.Metadata.Path, audiobook);
}
// look what changed
foreach (Audiobook audiobook in Scanner.ScanLibrary(LibraryPath))
{
if (audiobookIndex.ContainsKey(audiobook.Metadata.Path))
{
Audiobook changedAudiobook = audiobookIndex[audiobook.Metadata.Path];
// build index to access chapters by their paths
Dictionary <string, Chapter> chapterIndex = new Dictionary <string, Chapter>();
foreach (Chapter chapter in changedAudiobook.Chapters)
{
chapterIndex.Add(chapter.AudioPath.Path, chapter);
}
foreach (Chapter chapter in audiobook.Chapters)
{
if (chapterIndex.ContainsKey(chapter.AudioPath.Path))
{
chapterIndex.Remove(chapter.AudioPath.Path);
}
else
{
changedAudiobook.Chapters.Add(chapter);
}
}
if (hardScan)
{
// delete unused files
foreach (Chapter chapter in chapterIndex.Values)
{
changedAudiobook.Chapters.Remove(chapter);
File.Delete(Path.Combine(changedAudiobook.Metadata.MetadataPath, "chapters", chapter.Metadata.MetadataPath));
}
}
SaveMetadata(changedAudiobook);
audiobookIndex.Remove(audiobook.Metadata.Path);
}
else
{
UpdateAudiobook(audiobook);
}
}
if (hardScan)
{
// delete unused audiobooks
foreach (Audiobook audiobook in audiobookIndex.Values)
{
RemoveAudiobook(audiobook);
}
}
}
