public static void CreateURLShortcut(FileSystemPath shortcutName, FileSystemPath destinationDirectory, string targetURL)
{
using StreamWriter writer = new StreamWriter(destinationDirectory + shortcutName.ChangeFileExtension(new FileExtension(".url")));
writer.WriteLine("[InternetShortcut]");
writer.WriteLine("URL=" + targetURL);
writer.Flush();
}
public void CreateURLShortcut(FileSystemPath shortcutName, FileSystemPath destinationDirectory, string targetURL)
{
try
{
// Make sure the file extension is correct or else Windows won't treat it as an URL shortcut
shortcutName = shortcutName.ChangeFileExtension(new FileExtension(".url"));
// Delete if a shortcut with the same name already exists
DeleteFile(destinationDirectory + shortcutName);
// Create the shortcut
WindowsHelpers.CreateURLShortcut(shortcutName, destinationDirectory, targetURL);
}
catch (Exception ex)
{
Logger.Warn(ex, "Creating URL shortcut {0}", destinationDirectory);
throw;
}
}
public void CreateFileShortcut(FileSystemPath ShortcutName, FileSystemPath DestinationDirectory, FileSystemPath TargetFile, string arguments = null)
{
try
{
// Make sure the file extension is correct or else Windows won't treat it as a shortcut
ShortcutName = ShortcutName.ChangeFileExtension(new FileExtension(".lnk"));
// Delete if a shortcut with the same name already exists
DeleteFile(DestinationDirectory + ShortcutName);
// Create the shortcut
WindowsHelpers.CreateFileShortcut(ShortcutName, DestinationDirectory, TargetFile, arguments);
Logger.Info("The shortcut {0} was created", ShortcutName);
}
catch (Exception ex)
{
Logger.Warn(ex, "Creating shortcut {0}", DestinationDirectory);
throw;
}
}
public async Task ConvertAsync()
{
if (IsLoading)
{
return;
}
try
{
IsLoading = true;
// Attempt to get a default directory
FileSystemPath?defaultDir = SelectedType.SelectedMode.GetDefaultDir();
// Make sure the directory exists
if (defaultDir?.DirectoryExists != true)
{
defaultDir = null;
}
// Allow the user to select the files
FileBrowserResult fileResult = await Services.BrowseUI.BrowseFileAsync(new FileBrowserViewModel()
{
Title = Resources.Utilities_Converter_FileSelectionHeader,
DefaultDirectory = defaultDir?.FullPath,
ExtensionFilter = SelectedType.SourceFileExtension.GetFileFilterItem.ToString(),
MultiSelection = true
});
if (fileResult.CanceledByUser)
{
return;
}
// Allow the user to select the destination directory
DirectoryBrowserResult destinationResult = await Services.BrowseUI.BrowseDirectoryAsync(new DirectoryBrowserViewModel()
{
Title = Resources.Browse_DestinationHeader,
});
if (destinationResult.CanceledByUser)
{
return;
}
// Allow the user to select the file extension to export as
FileExtensionSelectionDialogResult extResult = await Services.UI.SelectFileExtensionAsync(new FileExtensionSelectionDialogViewModel(SelectedType.ConvertFormats, Resources.Utilities_Converter_ExportExtensionHeader));
if (extResult.CanceledByUser)
{
return;
}
try
{
await Task.Run(() =>
{
using RCPContext context = new(fileResult.SelectedFiles.First().Parent);
SelectedType.SelectedMode.InitContext(context);
// Convert every file
foreach (FileSystemPath file in fileResult.SelectedFiles)
{
// Get the destination file
FileSystemPath destinationFile = destinationResult.SelectedDirectory + file.Name;
// Set the file extension
destinationFile = destinationFile.ChangeFileExtension(new FileExtension(extResult.SelectedFileFormat, multiple: true)).GetNonExistingFileName();
// Convert the file
SelectedType.Convert(context, file.Name, destinationFile);
}
});
await Services.MessageUI.DisplaySuccessfulActionMessageAsync(Resources.Utilities_Converter_Success);
}
catch (Exception ex)
{
Logger.Error(ex, "Converting files");
await Services.MessageUI.DisplayExceptionMessageAsync(ex, Resources.Utilities_Converter_Error);
}
}
finally
{
IsLoading = false;
}
}
public async Task ConvertBackAsync()
{
if (IsLoading)
{
return;
}
try
{
IsLoading = true;
// Allow the user to select the files
FileBrowserResult fileResult = await Services.BrowseUI.BrowseFileAsync(new FileBrowserViewModel()
{
Title = Resources.Utilities_Converter_FileSelectionHeader,
ExtensionFilter = new FileFilterItemCollection(SelectedType.ConvertFormats.Select(x => new FileFilterItem($"*{x}", x.ToUpper()))).ToString(),
MultiSelection = true
});
if (fileResult.CanceledByUser)
{
return;
}
// Allow the user to select the destination directory
DirectoryBrowserResult destinationResult = await Services.BrowseUI.BrowseDirectoryAsync(new DirectoryBrowserViewModel()
{
Title = Resources.Browse_DestinationHeader,
});
if (destinationResult.CanceledByUser)
{
return;
}
// Get the state
object?state = await SelectedType.GetConvertBackStateAsync();
if (state is null)
{
return;
}
try
{
await Task.Run(() =>
{
using RCPContext context = new(fileResult.SelectedFiles.First().Parent);
SelectedType.SelectedMode.InitContext(context);
// Convert every file
foreach (FileSystemPath file in fileResult.SelectedFiles)
{
// Get the destination file
FileSystemPath destinationFile = destinationResult.SelectedDirectory + file.Name;
// Set the file extension
destinationFile = destinationFile.ChangeFileExtension(SelectedType.SourceFileExtension).GetNonExistingFileName();
// Convert the file
SelectedType.ConvertBack(context, file, destinationFile.Name, state);
}
});
await Services.MessageUI.DisplaySuccessfulActionMessageAsync(Resources.Utilities_Converter_Success);
}
catch (Exception ex)
{
Logger.Error(ex, "Converting files");
await Services.MessageUI.DisplayExceptionMessageAsync(ex, Resources.Utilities_Converter_Error);
}
}
finally
{
IsLoading = false;
}
}
public async Task SerializeAsync()
{
if (IsLoading)
{
return;
}
try
{
IsLoading = true;
// Allow the user to select the files
FileBrowserResult fileResult = await Services.BrowseUI.BrowseFileAsync(new FileBrowserViewModel()
{
Title = Resources.Utilities_Serializers_FileSelectionHeader,
ExtensionFilter = new FileFilterItem("*.json", "JSON").ToString(),
MultiSelection = true,
});
if (fileResult.CanceledByUser || !fileResult.SelectedFiles.Any())
{
return;
}
// Allow the user to select the destination directory
DirectoryBrowserResult destinationResult = await Services.BrowseUI.BrowseDirectoryAsync(new DirectoryBrowserViewModel()
{
Title = Resources.Browse_DestinationHeader,
});
if (destinationResult.CanceledByUser)
{
return;
}
try
{
await Task.Run(() =>
{
using RCPContext context = new(destinationResult.SelectedDirectory);
SelectedType.SelectedMode.InitContext(context);
// Serialize every file
foreach (FileSystemPath file in fileResult.SelectedFiles)
{
// Get the destination file
FileSystemPath destinationFile = destinationResult.SelectedDirectory + file.Name;
// Set the file extension
destinationFile = destinationFile.ChangeFileExtension(SelectedType.FileExtension).GetNonExistingFileName();
// Deserialize the file JSON
object data = JsonHelpers.DeserializeFromFile(file, SelectedType.Type);
// Serialize the data to the destination file
SelectedType.Serialize(context, destinationFile.Name, data);
}
});
await Services.MessageUI.DisplaySuccessfulActionMessageAsync(Resources.Utilities_Serializers_SerializeSuccess);
}
catch (Exception ex)
{
Logger.Error(ex, "Serializing files");
await Services.MessageUI.DisplayExceptionMessageAsync(ex, Resources.Utilities_Serializers_SerializeError);
}
}
finally
{
IsLoading = false;
}
}
public async Task DeserializeAsync()
{
if (IsLoading)
{
return;
}
try
{
IsLoading = true;
// Attempt to get a default directory
FileSystemPath?defaultDir = SelectedType.SelectedMode.GetDefaultDir();
// Make sure the directory exists
if (defaultDir?.DirectoryExists != true)
{
defaultDir = null;
}
// Allow the user to select the files
FileBrowserResult fileResult = await Services.BrowseUI.BrowseFileAsync(new FileBrowserViewModel()
{
Title = Resources.Utilities_Serializers_FileSelectionHeader,
DefaultDirectory = defaultDir?.FullPath,
ExtensionFilter = SelectedType.FileExtension.GetFileFilterItem.ToString(),
MultiSelection = true
});
if (fileResult.CanceledByUser || !fileResult.SelectedFiles.Any())
{
return;
}
// Allow the user to select the destination directory
DirectoryBrowserResult destinationResult = await Services.BrowseUI.BrowseDirectoryAsync(new DirectoryBrowserViewModel()
{
Title = Resources.Browse_DestinationHeader,
});
if (destinationResult.CanceledByUser)
{
return;
}
try
{
await Task.Run(() =>
{
using RCPContext context = new(fileResult.SelectedFiles.First().Parent);
SelectedType.SelectedMode.InitContext(context);
// Deserialize every file
foreach (FileSystemPath file in fileResult.SelectedFiles)
{
object?fileObj = SelectedType.Deserialize(context, file.Name);
if (fileObj is null)
{
Logger.Warn("Deserialized file was null");
continue;
}
// Get the destination file
FileSystemPath destinationFile = destinationResult.SelectedDirectory + file.Name;
// Set the file extension
destinationFile = destinationFile.ChangeFileExtension(new FileExtension(".json")).GetNonExistingFileName();
// Serialize as JSON
JsonHelpers.SerializeToFile(fileObj, destinationFile);
}
});
await Services.MessageUI.DisplaySuccessfulActionMessageAsync(Resources.Utilities_Serializers_DeserializeSuccess);
}
catch (Exception ex)
{
Logger.Error(ex, "Deserializing files");
await Services.MessageUI.DisplayExceptionMessageAsync(ex, Resources.Utilities_Serializers_DeserializeError);
}
}
finally
{
IsLoading = false;
}
}
/// <summary>
/// Imports files to the directory
/// </summary>
/// <returns>The task</returns>
public async Task ImportAsync()
{
// Run as a load operation
using (await Archive.LoadOperation.RunAsync())
{
// Lock the access to the archive
using (await Archive.ArchiveLock.LockAsync())
{
// Get the directory
DirectoryBrowserResult result = await Services.BrowseUI.BrowseDirectoryAsync(new DirectoryBrowserViewModel()
{
Title = Resources.Archive_ImportDirectoryHeader,
});
if (result.CanceledByUser)
{
return;
}
// Run as a task
await Task.Run(async() =>
{
// Keep track of the number of files getting imported
int imported = 0;
try
{
// Enumerate each directory view model
foreach (ArchiveDirectoryViewModel dir in this.GetAllChildren(true))
{
// Enumerate each file
foreach (ArchiveFileViewModel file in dir.Files)
{
// Get the file directory, relative to the selected directory
FileSystemPath fileDir = result.SelectedDirectory + dir.FullPath.Remove(0, FullPath.Length).Trim(Path.DirectorySeparatorChar);
if (!fileDir.DirectoryExists)
{
continue;
}
// Get the base file path
FileSystemPath baseFilePath = fileDir + new FileSystemPath(file.FileName);
// Get the file path, without an extension
FileSystemPath filePath = baseFilePath.RemoveFileExtension(true);
// Make sure there are potential file matches
if (!Directory.GetFiles(fileDir, $"{filePath.Name}*", SearchOption.TopDirectoryOnly).Any())
{
continue;
}
// Get the file stream
using ArchiveFileStream fileStream = file.GetDecodedFileStream();
// Initialize the file without loading the thumbnail
file.InitializeFile(fileStream, ArchiveFileViewModel.ThumbnailLoadMode.None);
// Check if the base file exists without changing the extensions
if (baseFilePath.FileExists)
{
// Import the file
file.ImportFile(baseFilePath, false);
imported++;
continue;
}
// Attempt to find a file for each supported extension
foreach (FileExtension ext in file.FileType.ImportFormats)
{
// Get the path
FileSystemPath fullFilePath = filePath.ChangeFileExtension(ext);
// Make sure the file exists
if (!fullFilePath.FileExists)
{
continue;
}
// Import the file
file.ImportFile(fullFilePath, true);
imported++;
// Break the loop
break;
}
}
}
}
catch (Exception ex)
{
Logger.Error(ex, "Importing archive directory {0}", DisplayName);
await Services.MessageUI.DisplayExceptionMessageAsync(ex, Resources.Archive_ImportDir_Error);
return;
}
// Make sure at least one file has been imported
if (imported == 0)
{
await Services.MessageUI.DisplayMessageAsync(Resources.Archive_ImportNoFilesError, MessageType.Warning);
}
});
}
}
}
public static void CreateFileShortcut(FileSystemPath shortcutName, FileSystemPath destinationDirectory, FileSystemPath targetFile, string arguments = null)
{
IWshShortcut shortcut = (IWshShortcut) new WshShell().CreateShortcut(destinationDirectory + shortcutName.ChangeFileExtension(new FileExtension(".lnk")));
shortcut.TargetPath = targetFile;
if (arguments != null)
{
shortcut.Arguments = arguments;
}
shortcut.WorkingDirectory = targetFile.Parent;
shortcut.Save();
}
