public static List <ConversionItem> GetConversions(string dataFilePath = DefaultFilePath)
{
List <ConversionItem> items = new List <ConversionItem>();
if (!File.Exists(dataFilePath))
{
return(items);
}
XmlReaderSettings readerSettings = new XmlReaderSettings {
ConformanceLevel = ConformanceLevel.Auto,
IgnoreWhitespace = true
};
using (StreamReader stream = new StreamReader(dataFilePath, Encoding.UTF8)) {
using (XmlReader reader = XmlReader.Create(stream, readerSettings)) {
reader.MoveToContent();
while (!reader.EOF)
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "Item")
{
XElement element = (XElement)XNode.ReadFrom(reader);
ConversionItem item = ParseConversionItem(element);
items.Add(item);
}
else
{
reader.Read();
}
}
}
}
return(items);
}
public void SaveConversion(ConversionItem item)
{
// Get xml file or create root element if the file does not exist/cannot load
XDocument doc;
try {
doc = XDocument.Load(FilePath);
} catch (Exception) {
doc = new XDocument();
doc.Add(new XElement("Conversions"));
doc.Save(FilePath);
}
// Get root element and add new conversion
XElement root = doc.Root;
XElement itemElement = new XElement("Item");
using (XmlWriter writer = itemElement.CreateWriter()) {
// New file path
writer.WriteElementString("Path", item.NewData.FilePath);
// Old data
writer.WriteStartElement("Data");
WriteConversionData(writer, item.OldData);
writer.WriteEndElement();
}
// Add and save new item
root.Add(itemElement);
root.Save(FilePath);
}
public void RemoveConversion(ConversionItem item)
{
XDocument doc = XDocument.Load(FilePath);
IEnumerable <XElement> query = from node in doc.Descendants("Item")
let path = node.Descendants("Path").First()
where path != null && path.Value.Equals(item.NewData.FilePath)
select node;
query.ToList().ForEach(n => n.Remove());
doc.Save(FilePath);
}
public void Revert(IEnumerable <ConversionItem> fileItems, CancellationToken ct)
{
foreach (ConversionItem item in fileItems)
{
// Check if function has been cancelled if called asynchronously
if (ct != CancellationToken.None)
{
ct.ThrowIfCancellationRequested();
}
if (!File.Exists(item.NewData.FilePath))
{
OnProgressEvent(ProgressEvent.FileDoesNotExist, item);
continue;
}
if (File.Exists(item.OldData.FilePath))
{
ConversionItem reversedItem = new ConversionItem(item.NewData, item.OldData);
OnProgressEvent(ProgressEvent.FileAlreadyExists, reversedItem);
continue;
}
// Revert tags
TagLib.File tagFile = null;
try {
tagFile = TagLib.File.Create(item.NewData.FilePath);
} catch (Exception) {
// ignored
}
if (tagFile != null)
{
tagFile.Tag.Title = item.OldData.Title;
tagFile.Tag.Album = item.OldData.Album;
tagFile.Tag.Performers = item.OldData.Performers;
tagFile.Tag.AlbumArtists = item.OldData.AlbumArtists;
tagFile.Save();
}
File.Move(item.NewData.FilePath, item.OldData.FilePath);
OnProgressEvent(ProgressEvent.Reverted, item);
}
OnProgressEvent(ProgressEvent.Completed);
}
public void Convert(IEnumerable <string> files, CancellationToken ct)
{
// Convert each file
foreach (string filePath in files)
{
// Check if function has been cancelled if called asynchronously
if (ct != CancellationToken.None)
{
ct.ThrowIfCancellationRequested();
}
if (!File.Exists(filePath))
{
ConversionData nonExistentData = new ConversionData(filePath);
ConversionItem item = new ConversionItem(nonExistentData, null);
OnProgressEvent(ProgressEvent.FileDoesNotExist, item);
continue;
}
// Get file details
string directoryPath = Path.GetDirectoryName(filePath);
string extension = Path.GetExtension(filePath);
string fileName = Path.GetFileNameWithoutExtension(filePath);
// Get tags
TagLib.File tagFile = null;
try {
tagFile = TagLib.File.Create(filePath);
} catch (Exception) {
// ignored
}
string title = tagFile?.Tag.Title ?? "";
string album = tagFile?.Tag.Album ?? "";
string[] performers = tagFile?.Tag.Performers ?? new string[] {};
string[] albumArtists = tagFile?.Tag.AlbumArtists ?? new string[] {};
// Store old conversion data
ConversionData oldData = new ConversionData(filePath,
title,
album,
// Ensure values remain the same even if array is modified
(string[])performers.Clone(),
(string[])albumArtists.Clone());
// Check if function has been cancelled if called asynchronously
if (ct != CancellationToken.None)
{
ct.ThrowIfCancellationRequested();
}
// Translate
string newFileName = TextTranslator.Translate(fileName);
title = TextTranslator.Translate(title);
album = TextTranslator.Translate(album);
for (int i = 0; i < performers.Length; i++)
{
performers[i] = TextTranslator.Translate(performers[i]);
}
for (int i = 0; i < albumArtists.Length; i++)
{
albumArtists[i] = TextTranslator.Translate(albumArtists[i]);
}
// Check if function has been cancelled if called asynchronously
if (ct != CancellationToken.None)
{
ct.ThrowIfCancellationRequested();
}
// Replace illegal filename characters from the new filename
foreach (string s in IllegalFilenameMap.Keys)
{
string sVal;
if (IllegalFilenameMap.TryGetValue(s, out sVal))
{
newFileName = newFileName.Replace(s, sVal);
}
}
string newFilePath = directoryPath + Path.DirectorySeparatorChar + newFileName + extension;
if (File.Exists(newFilePath))
{
ConversionData existingData = new ConversionData(newFilePath);
ConversionItem item = new ConversionItem(oldData, existingData);
OnProgressEvent(ProgressEvent.FileAlreadyExists, item);
continue;
}
// Set new tags
if (tagFile != null)
{
tagFile.Tag.Title = title;
tagFile.Tag.Album = album;
tagFile.Tag.Performers = performers;
tagFile.Tag.AlbumArtists = albumArtists;
tagFile.Save();
}
File.Move(filePath, newFilePath);
// Store new conversion data
ConversionData newData = new ConversionData(newFilePath,
title,
album,
// Ensure values remain the same even if array is modified
(string[])performers.Clone(),
(string[])albumArtists.Clone());
// Check if function has been cancelled if called asynchronously
if (ct != CancellationToken.None)
{
ct.ThrowIfCancellationRequested();
}
// Update progress
ConversionItem conversionItem = new ConversionItem(oldData, newData);
OnProgressEvent(ProgressEvent.Converted, conversionItem);
}
OnProgressEvent(ProgressEvent.Completed);
}
public ProgressEventArgs(ProgressEvent type, ConversionItem item)
{
Type = type;
Item = item;
}
private void OnProgressEvent(ProgressEvent type, ConversionItem item = null)
{
Progress?.Invoke(this, new ProgressEventArgs(type, item));
}
