Open package for editing

Author: ScottIsAFool

LiveWriterPluginManager/Services/ZipService.cs

@@ -13,6 +13,7 @@ namespace LiveWriterPluginManager.Services
     public interface IZipService
     {
         Task<Plugin> UnzipFileAsync(string filePath);
+        Task<Tuple<Manifest, string[]>> OpenPackageForEditing(string filePath);
         Task<bool> ZipFilesAsync(string[] files, string outputFile, Manifest manifest);
     }
 
@@ -38,24 +39,18 @@ public async Task<Plugin> UnzipFileAsync(string filePath)
                 var tcs = new TaskCompletionSource<bool>();
                 await Task.Run(async () =>
                 {
-                    using (var zipFile = ZipFile.Read(filePath))
-                    {
-                        zipFile.FlattenFoldersOnExtract = true;
-                        var fileName = Path.GetFileNameWithoutExtension(filePath);
-
-                        var extractPath = Path.Combine(AppHelper.PluginsFolder, fileName);
-                        zipFile.ExtractAll(extractPath, ExtractExistingFileAction.OverwriteSilently);
+                    var fileName = Path.GetFileNameWithoutExtension(filePath);
+                    var extractPath = Path.Combine(AppHelper.PluginsFolder, fileName);
 
-                        var manifest = await ReadManifest(extractPath);
+                    var manifest = await ExtractAndReturnManifest(extractPath, fileName);
 
-                        result = new Plugin
-                        {
-                            Name = manifest?.Name,
-                            Path = manifest?.PluginPath
-                        };
+                    result = new Plugin
+                    {
+                        Name = manifest?.Name,
+                        Path = manifest?.PluginPath
+                    };
 
-                        tcs.SetResult(true);
-                    }
+                    tcs.SetResult(true);
                 });
 
                 await tcs.Task;
@@ -68,6 +63,43 @@ await Task.Run(async () =>
             return result;
         }
 
+        public async Task<Tuple<Manifest, string[]>> OpenPackageForEditing(string filePath)
+        {
+            if (string.IsNullOrEmpty(filePath))
+            {
+                return new Tuple<Manifest, string[]>(new Manifest(), new string[0]);
+            }
+
+            var tcs = new TaskCompletionSource<Tuple<Manifest, string[]>>();
+            await Task.Run(async () =>
+            {
+                var filename = Path.GetFileNameWithoutExtension(filePath);
+                var extractPath = Path.Combine(Path.GetTempPath(), filename);
+
+                var manifest = await ExtractAndReturnManifest(filePath, extractPath);
+
+                var directory = new DirectoryInfo(extractPath);
+                var files = directory.EnumerateFiles().Select(x => x.FullName).ToArray();
+
+                tcs.SetResult(new Tuple<Manifest, string[]>(manifest, files));
+            });
+
+            var result = await tcs.Task;
+            return result;
+        }
+
+        private static async Task<Manifest> ExtractAndReturnManifest(string filePath, string extractPath)
+        {
+            using (var zipFile = ZipFile.Read(filePath))
+            {
+                zipFile.FlattenFoldersOnExtract = true;
+                zipFile.ExtractAll(extractPath, ExtractExistingFileAction.OverwriteSilently);
+            }
+
+            var manifest = await ReadManifest(extractPath);
+            return manifest;
+        }
+
         public async Task<bool> ZipFilesAsync(string[] files, string outputFile, Manifest manifest)
         {
             var manifestJson = JsonConvert.SerializeObject(manifest);

LiveWriterPluginManager/ViewModel/CreatePackageViewModel.cs

@@ -97,6 +97,36 @@ public RelayCommand CreatePackageCommand
                 });
             }
         }
+
+        public RelayCommand OpenPackageCommand
+        {
+            get
+            {
+                return new RelayCommand(async () =>
+                {
+                    var file = _fileService.GetZipFile();
+                    var packageDetails = await _zipService.OpenPackageForEditing(file);
+                    if (packageDetails.Item1 == null || !packageDetails.Item2.Any())
+                    {
+                        return;
+                    }
+                    ManifestViewModel = new ManifestViewModel(packageDetails.Item1);
+
+                    var files = packageDetails.Item2.Where(x => !x.Contains(Manifest.ManifestFileName)).Select(x => new FileViewModel(x));
+                    Files.Clear();
+                    foreach (var f in files)
+                    {
+                        Files.Add(f);
+                    }
+
+                    var pluginFile = Files.FirstOrDefault(x => x.Name == ManifestViewModel.PluginFileName);
+                    if (pluginFile != null)
+                    {
+                        pluginFile.IsPluginFile = true;
+                    }
+                });
+            }
+        }
     }
 
     public class FileViewModel : ViewModelBase
@@ -157,6 +187,7 @@ public ManifestViewModel(Manifest manifest)
             TermsUrl = _manifest.TermsUrl;
             Version = _manifest.Version;
             TargetWriterVersion = _manifest.TargetWriterVersion;
+            PluginFileName = _manifest.PluginFileName;
 
             Messenger.Default.Register<NotificationMessage>(this, m =>
             {
@@ -175,6 +206,7 @@ public ManifestViewModel(Manifest manifest)
         public string TermsUrl { get; set; }
         public string Version { get; set; }
         public string TargetWriterVersion { get; set; }
+        public string PluginFileName { get; set; }
 
         public bool PluginFileSet => !string.IsNullOrEmpty(_manifest?.PluginFileName);