Enable/disable portable mode setting

Plugins/Wox.Plugin.Program/Logger/ProgramLogger.cs

@@ -1,4 +1,4 @@
-using NLog;
+using NLog;
 using NLog.Config;
 using NLog.Targets;
 using System;
@@ -7,6 +7,7 @@
 using System.Runtime.CompilerServices;
 using System.Security;
 using Wox.Infrastructure;
+using Wox.Infrastructure.UserSettings;
 
 namespace Wox.Plugin.Program.Logger
 {
@@ -21,7 +22,7 @@ internal static class ProgramLogger
 
         static ProgramLogger()
         {
-            var path = Path.Combine(Constant.DataDirectory, DirectoryName, Constant.Version);
+            var path = Path.Combine(DataLocation.DataDirectory(), DirectoryName, Constant.Version);
             if (!Directory.Exists(path))
             {
                 Directory.CreateDirectory(path);

Wox.Core/Configuration/IPortable.cs

@@ -0,0 +1,16 @@
+
+namespace Wox.Core.Configuration
+{
+    public interface IPortable
+    {
+        void EnablePortableMode();
+        void DisablePortableMode();
+        void RemoveShortcuts();
+        void RemoveUninstallerEntry();
+        void CreateShortcuts();
+        void CreateUninstallerEntry();
+        void MoveUserDataFolder(string fromLocation, string toLocation);
+        void VerifyUserDataAfterMove(string fromLocation, string toLocation);
+        bool CanUpdatePortability();
+    }
+}

Wox.Core/Configuration/Portable.cs

@@ -0,0 +1,200 @@
+using Microsoft.Win32;
+using Squirrel;
+using System;
+using System.IO;
+using System.Reflection;
+using System.Windows;
+using Wox.Infrastructure;
+using Wox.Infrastructure.Logger;
+using Wox.Infrastructure.UserSettings;
+using Wox.Plugin.SharedCommands;
+
+namespace Wox.Core.Configuration
+{
+    public class Portable : IPortable
+    {
+        private UpdateManager portabilityUpdater;
+
+        public void DisablePortableMode()
+        {
+            portabilityUpdater = new UpdateManager(string.Empty, Constant.Wox, Constant.RootDirectory);
+
+            try
+            {
+                MoveUserDataFolder(DataLocation.PortableDataPath, DataLocation.RoamingDataPath);
+#if DEBUG
+                // Create shortcuts and uninstaller are not required in debug mode, 
+                // otherwise will repoint the path of the actual installed production version to the debug version
+#else
+                CreateShortcuts();
+                CreateUninstallerEntry();
+#endif
+                IndicateDeletion(DataLocation.PortableDataPath);
+
+                MessageBox.Show("Wox needs to restart to finish disabling portable mode, " +
+                    "after the restart your portable data profile will be deleted and roaming data profile kept");
+
+                portabilityUpdater.Dispose();
+
+                UpdateManager.RestartApp();
+            }
+            catch (Exception e)
+            {
+#if DEBUG
+                portabilityUpdater.Dispose();
+                throw;
+#else
+                portabilityUpdater.Dispose();
+                Log.Exception("Portable", "Error occured while disabling portable mode", e);
+                throw;
+#endif
+            }
+        }
+
+        public void EnablePortableMode()
+        {
+            portabilityUpdater = new UpdateManager(string.Empty, Constant.Wox, Constant.RootDirectory);
+
+            try
+            {
+                MoveUserDataFolder(DataLocation.RoamingDataPath, DataLocation.PortableDataPath);
+#if DEBUG
+                // Remove shortcuts and uninstaller are not required in debug mode, 
+                // otherwise will delete the actual installed production version
+#else
+                RemoveShortcuts();
+                RemoveUninstallerEntry();
+#endif
+                IndicateDeletion(DataLocation.RoamingDataPath);
+
+                MessageBox.Show("Wox needs to restart to finish enabling portable mode, " +
+                    "after the restart your roaming data profile will be deleted and portable data profile kept");
+
+                portabilityUpdater.Dispose();
+
+                UpdateManager.RestartApp();
+            }
+            catch (Exception e)
+            {
+#if DEBUG
+                portabilityUpdater.Dispose();
+                throw;
+#else
+                portabilityUpdater.Dispose();
+                Log.Exception("Portable", "Error occured while enabling portable mode", e);
+                throw;
+#endif
+            }
+        }
+
+        public void RemoveShortcuts()
+        {
+            var exeName = Constant.Wox + ".exe";
+            portabilityUpdater.RemoveShortcutsForExecutable(exeName, ShortcutLocation.StartMenu);
+            portabilityUpdater.RemoveShortcutsForExecutable(exeName, ShortcutLocation.Desktop);
+            portabilityUpdater.RemoveShortcutsForExecutable(exeName, ShortcutLocation.Startup);
+        }
+
+        public void RemoveUninstallerEntry()
+        {
+            portabilityUpdater.RemoveUninstallerRegistryEntry();
+        }
+
+        public void MoveUserDataFolder(string fromLocation, string toLocation)
+        {
+            FilesFolders.Copy(fromLocation, toLocation);
+            VerifyUserDataAfterMove(fromLocation, toLocation);
+        }
+
+        public void VerifyUserDataAfterMove(string fromLocation, string toLocation)
+        {
+            FilesFolders.VerifyBothFolderFilesEqual(fromLocation, toLocation);
+        }
+
+        public void CreateShortcuts()
+        {
+            var exeName = Constant.Wox + ".exe";
+            portabilityUpdater.CreateShortcutsForExecutable(exeName, ShortcutLocation.StartMenu, false);
+            portabilityUpdater.CreateShortcutsForExecutable(exeName, ShortcutLocation.Desktop, false);
+            portabilityUpdater.CreateShortcutsForExecutable(exeName, ShortcutLocation.Startup, false);
+        }
+
+        public void CreateUninstallerEntry()
+        {
+            var uninstallRegSubKey = @"Software\Microsoft\Windows\CurrentVersion\Uninstall";
+            // NB: Sometimes the Uninstall key doesn't exist
+            using (var parentKey =
+                RegistryKey.OpenBaseKey(RegistryHive.CurrentUser, RegistryView.Default)
+                    .CreateSubKey("Uninstall", RegistryKeyPermissionCheck.ReadWriteSubTree)) {; }
+
+            var key = RegistryKey.OpenBaseKey(RegistryHive.CurrentUser, RegistryView.Default)
+                .CreateSubKey(uninstallRegSubKey + "\\" + Constant.Wox, RegistryKeyPermissionCheck.ReadWriteSubTree);
+            key.SetValue("DisplayIcon", Constant.ApplicationDirectory + "\\app.ico", RegistryValueKind.String);
+
+            portabilityUpdater.CreateUninstallerRegistryEntry();
+        }
+
+        internal void IndicateDeletion(string filePathTodelete)
+        {
+            using (StreamWriter sw = File.CreateText(filePathTodelete + "\\" + DataLocation.DeletionIndicatorFile)){}
+        }
+
+        ///<summary>
+        ///This method should be run at first before all methods during start up and should be run before determining which data location
+        ///will be used for Wox.
+        ///</summary>
+        public void PreStartCleanUpAfterPortabilityUpdate()
+        {
+            // Specify here so this method does not rely on other environment variables to initialise
+            var portableDataPath = Path.Combine(Directory.GetParent(Assembly.GetExecutingAssembly().Location.NonNull()).ToString(), "UserData");
+            var roamingDataPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Wox");
+
+            bool DataLocationPortableDeleteRequired = false;
+            bool DataLocationRoamingDeleteRequired = false;
+
+            if ((roamingDataPath + "\\" + DataLocation.DeletionIndicatorFile).FileExits())
+                DataLocationRoamingDeleteRequired = true;
+
+            if ((portableDataPath + "\\" + DataLocation.DeletionIndicatorFile).FileExits())
+                DataLocationPortableDeleteRequired = true;
+
+            if (DataLocationRoamingDeleteRequired)
+            {
+                if(roamingDataPath.LocationExists())
+                    MessageBox.Show("Wox detected you restarted after enabling portable mode, " +
+                                    "your roaming data profile will now be deleted");
+
+                FilesFolders.RemoveFolderIfExists(roamingDataPath);
+
+                return;
+            }
+
+            if(DataLocationPortableDeleteRequired)
+            {
+                MessageBox.Show("Wox detected you restarted after disabling portable mode, " +
+                                    "your portable data profile will now be deleted");
+
+                FilesFolders.RemoveFolderIfExists(portableDataPath);
+
+                return;
+            }
+        }
+
+        public bool CanUpdatePortability()
+        {
+            var roamingLocationExists = DataLocation.RoamingDataPath.LocationExists();
+            var portableLocationExists = DataLocation.PortableDataPath.LocationExists();
+
+            if(roamingLocationExists && portableLocationExists)
+            {
+                MessageBox.Show(string.Format("Wox detected your user data exists both in {0} and " +
+                                    "{1}. {2}{2}Please delete {1} in order to proceed. No changes have occured.", 
+                                    DataLocation.PortableDataPath, DataLocation.RoamingDataPath, Environment.NewLine));
+
+                return false;
+            }
+
+            return true;
+        }
+    }
+}

Wox.Core/Plugin/PluginInstaller.cs

@@ -34,7 +34,7 @@ internal static void Install(string path)
                     return;
                 }
 
-                string pluginFolerPath = Infrastructure.Constant.PluginsDirectory;
+                string pluginFolerPath = Infrastructure.UserSettings.DataLocation.PluginsDirectory;
 
                 string newPluginName = plugin.Name
                     .Replace("/", "_")

Wox.Core/Plugin/PluginManager.cs

@@ -32,20 +32,20 @@ public static class PluginManager
         // todo happlebao, this should not be public, the indicator function should be embeded 
         public static PluginsSettings Settings;
         private static List<PluginMetadata> _metadatas;
-        private static readonly string[] Directories = { Constant.PreinstalledDirectory, Constant.PluginsDirectory };
+        private static readonly string[] Directories = { Constant.PreinstalledDirectory, DataLocation.PluginsDirectory };
 
         private static void ValidateUserDirectory()
         {
-            if (!Directory.Exists(Constant.PluginsDirectory))
+            if (!Directory.Exists(DataLocation.PluginsDirectory))
             {
-                Directory.CreateDirectory(Constant.PluginsDirectory);
+                Directory.CreateDirectory(DataLocation.PluginsDirectory);
             }
         }
 
         private static void DeletePythonBinding()
         {
             const string binding = "wox.py";
-            var directory = Constant.PluginsDirectory;
+            var directory = DataLocation.PluginsDirectory;
             foreach (var subDirectory in Directory.GetDirectories(directory))
             {
                 var path = Path.Combine(subDirectory, binding);

Wox.Core/Resource/Theme.cs

@@ -23,7 +23,7 @@ public class Theme
         private const string Folder = "Themes";
         private const string Extension = ".xaml";
         private string DirectoryPath => Path.Combine(Constant.ProgramDirectory, Folder);
-        private string UserDirectoryPath => Path.Combine(Constant.DataDirectory, Folder);
+        private string UserDirectoryPath => Path.Combine(DataLocation.DataDirectory(), Folder);
 
         public Theme()
         {

Wox.Core/Updater.cs

@@ -15,6 +15,7 @@
 using Wox.Infrastructure.Http;
 using Wox.Infrastructure.Logger;
 using System.IO;
+using Wox.Infrastructure.UserSettings;
 
 namespace Wox.Core
 {
@@ -80,13 +81,13 @@ public async Task UpdateApp(bool silentIfLatestVersion = true)
 
             await updateManager.ApplyReleases(newUpdateInfo);
 
-            if (Constant.IsPortableMode)
+            if (DataLocation.PortableDataLocationInUse())
             {
-                var targetDestination = updateManager.RootAppDirectory + $"\\app-{newReleaseVersion.ToString()}\\{Constant.PortableFolderName}";
-                FilesFolders.Copy(Constant.PortableDataPath, targetDestination);
-                if (!FilesFolders.VerifyBothFolderFilesEqual(Constant.PortableDataPath, targetDestination))
+                var targetDestination = updateManager.RootAppDirectory + $"\\app-{newReleaseVersion.ToString()}\\{DataLocation.PortableFolderName}";
+                FilesFolders.Copy(DataLocation.PortableDataPath, targetDestination);
+                if (!FilesFolders.VerifyBothFolderFilesEqual(DataLocation.PortableDataPath, targetDestination))
                     MessageBox.Show(string.Format("Wox was not able to move your user profile data to the new update version. Please manually" +
-                        "move your profile data folder from {0} to {1}", Constant.PortableDataPath, targetDestination));
+                        "move your profile data folder from {0} to {1}", DataLocation.PortableDataPath, targetDestination));
             }
             else
             {

Wox.Core/Wox.Core.csproj

@@ -51,6 +51,8 @@
     <Compile Include="..\SolutionAssemblyInfo.cs">
       <Link>Properties\SolutionAssemblyInfo.cs</Link>
     </Compile>
+    <Compile Include="Configuration\IPortable.cs" />
+    <Compile Include="Configuration\Portable.cs" />
     <Compile Include="Plugin\ExecutablePlugin.cs" />
     <Compile Include="Plugin\PluginsLoader.cs" />
     <Compile Include="Resource\LocalizationConverter.cs" />

Wox.Infrastructure/Logger/Log.cs

@@ -4,6 +4,7 @@
 using NLog;
 using NLog.Config;
 using NLog.Targets;
+using Wox.Infrastructure.UserSettings;
 
 namespace Wox.Infrastructure.Logger
 {
@@ -15,7 +16,7 @@ public static class Log
 
         static Log()
         {
-            CurrentLogDirectory = Path.Combine(Constant.DataDirectory, DirectoryName, Constant.Version);
+            CurrentLogDirectory = Path.Combine(DataLocation.DataDirectory(), DirectoryName, Constant.Version);
             if (!Directory.Exists(CurrentLogDirectory))
             {
                 Directory.CreateDirectory(CurrentLogDirectory);

Wox.Infrastructure/Storage/BinaryStorage.cs

@@ -5,6 +5,7 @@
 using System.Runtime.Serialization.Formatters;
 using System.Runtime.Serialization.Formatters.Binary;
 using Wox.Infrastructure.Logger;
+using Wox.Infrastructure.UserSettings;
 
 namespace Wox.Infrastructure.Storage
 {
@@ -17,7 +18,7 @@ public class BinaryStorage<T>
         public BinaryStorage(string filename)
         {
             const string directoryName = "Cache";
-            var directoryPath = Path.Combine(Constant.DataDirectory, directoryName);
+            var directoryPath = Path.Combine(DataLocation.DataDirectory(), directoryName);
             Helper.ValidateDirectory(directoryPath);
 
             const string fileSuffix = ".cache";

Wox.Infrastructure/Storage/PluginJsonStorage.cs

@@ -1,4 +1,5 @@
 using System.IO;
+using Wox.Infrastructure.UserSettings;
 
 namespace Wox.Infrastructure.Storage
 {
@@ -9,7 +10,7 @@ public PluginJsonStorage()
             // C# releated, add python releated below
             var dataType = typeof(T);
             var assemblyName = typeof(T).Assembly.GetName().Name;
-            DirectoryPath = Path.Combine(Constant.DataDirectory, DirectoryName, Constant.Plugins, assemblyName);
+            DirectoryPath = Path.Combine(DataLocation.DataDirectory(), DirectoryName, Constant.Plugins, assemblyName);
             Helper.ValidateDirectory(DirectoryPath);
 
             FilePath = Path.Combine(DirectoryPath, $"{dataType.Name}{FileSuffix}");

Wox.Infrastructure/Storage/WoxJsonStorage.cs

@@ -4,14 +4,15 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Wox.Infrastructure.UserSettings;
 
 namespace Wox.Infrastructure.Storage
 {
     public class WoxJsonStorage<T> : JsonStrorage<T> where T : new()
     {
         public WoxJsonStorage()
         {
-            var directoryPath = Path.Combine(Constant.DataDirectory, DirectoryName);
+            var directoryPath = Path.Combine(DataLocation.DataDirectory(), DirectoryName);
             Helper.ValidateDirectory(directoryPath);
 
             var filename = typeof(T).Name;