Fixes for om 3.7.4

src/Commands/CommandOpenMod.cs

@@ -80,6 +80,7 @@ private void OnCommandWindowInputted(string text, ref bool shouldExecuteCommand)
 
             try
             {
+                Logger.Log($"Choice {text}");
                 s_CurrentStep.OnChoice(text);
                 s_CurrentStep = GetNextStep();
 
@@ -200,7 +201,11 @@ private CommandStep GetNextStep()
         public string Name { get; } = "openmod";
         public string Help { get; } = "Installs OpenMod";
         public string Syntax { get; } = "install";
-        public List<string> Aliases { get; } = new List<string>();
+
+        public List<string> Aliases { get; } = new()
+        {
+            "om"
+        };
         public List<string> Permissions { get; } = new List<string>();
     }
 }

src/Helpers/NuGetHelper.cs

@@ -1,19 +1,19 @@
-using OpenMod.Installer.RocketMod.Jobs;
-using OpenMod.NuGet;
-using System;
+using System;
 using System.IO;
+using System.Linq;
+using OpenMod.Installer.RocketMod.Helpers.Wrapper;
 
 namespace OpenMod.Installer.RocketMod.Helpers
 {
     public static class NuGetHelper
     {
-        private static NuGetPackageManager s_NuGetPackageManager;
+        private static NuGetPackageManagerWrapper s_NuGetPackageManagerWrapper;
 
-        public static NuGetPackageManager GetNuGetPackageManager()
+        public static NuGetPackageManagerWrapper GetNuGetPackageManager()
         {
-            if (s_NuGetPackageManager != null)
+            if (s_NuGetPackageManagerWrapper != null)
             {
-                return s_NuGetPackageManager;
+                return s_NuGetPackageManagerWrapper;
             }
 
             var workingDirectory = OpenModInstallerPlugin.Instance.OpenModManager.WorkingDirectory;
@@ -26,20 +26,22 @@ public static NuGetPackageManager GetNuGetPackageManager()
 
             Environment.SetEnvironmentVariable("NUGET_COMMON_APPLICATION_DATA", packagesPath);
 
-            s_NuGetPackageManager = new NuGetPackageManager(packagesPath)
-            {
-                Logger = new NuGetConsoleLogger()
-            };
+            var nugetAssembly = AppDomain.CurrentDomain.GetAssemblies().First(a => a.GetName().Name.Equals("OpenMod.Nuget", StringComparison.OrdinalIgnoreCase));
+
+            s_NuGetPackageManagerWrapper = new NuGetPackageManagerWrapper(nugetAssembly, packagesPath);
+
+            var logger = new NuGetConsoleLoggerWrapper(nugetAssembly);
+            s_NuGetPackageManagerWrapper.SetLogger(logger);
 
-            s_NuGetPackageManager.IgnoreDependencies(
+            s_NuGetPackageManagerWrapper.IgnoreDependencies(
                 "Microsoft.NETCore.Platforms",
                 "Microsoft.Packaging.Tools",
                 "NETStandard.Library",
                 /*"OpenMod.Unturned.Redist",
                 "OpenMod.UnityEngine.Redist",*/ // todo
                 "System.IO.FileSystem.Watcher");
 
-            return s_NuGetPackageManager;
+            return s_NuGetPackageManagerWrapper;
         }
     }
 }

src/Helpers/Wrapper/NuGetConsoleLoggerWrapper.cs

@@ -0,0 +1,10 @@
+using System.Reflection;
+
+namespace OpenMod.Installer.RocketMod.Helpers.Wrapper
+{
+    public class NuGetConsoleLoggerWrapper : TypeWrapper
+    {
+        public NuGetConsoleLoggerWrapper(Assembly nugetAssembly) : base(nugetAssembly, "NuGetConsoleLogger")
+        { }
+    }
+}

src/Helpers/Wrapper/NuGetPackageManagerWrapper.cs

@@ -0,0 +1,54 @@
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace OpenMod.Installer.RocketMod.Helpers.Wrapper
+{
+    public class NuGetPackageManagerWrapper : TypeWrapper
+    {
+        protected static PropertyInfo m_Logger;
+        protected static MethodInfo m_IgnoreDependencies;
+        protected static MethodInfo m_GetLatestPackageIdentityAsync;
+        protected static MethodInfo m_QueryPackageExactAsync;
+        protected static MethodInfo m_InstallAsync;
+
+        public NuGetPackageManagerWrapper(Assembly nugetAssembly, params object[] args) : base(nugetAssembly, "NuGetPackageManager", args)
+        {
+            m_Logger ??= s_Type.GetProperty("Logger");
+            m_IgnoreDependencies ??= s_Type.GetMethod("IgnoreDependencies");
+            m_GetLatestPackageIdentityAsync ??= s_Type.GetMethod("GetLatestPackageIdentityAsync");
+            m_QueryPackageExactAsync ??= s_Type.GetMethod("QueryPackageExactAsync");
+            m_InstallAsync ??= s_Type.GetMethod("InstallAsync");
+        }
+
+        public void SetLogger(NuGetConsoleLoggerWrapper logger)
+        {
+            m_Logger.SetValue(m_Instance, logger.Instance);
+        }
+
+        public void IgnoreDependencies(params string[] packageIds)
+        {
+            m_IgnoreDependencies.Invoke(m_Instance, new object[] { packageIds });
+        }
+
+        public async Task<PackageIdentityWrapper> GetLatestPackageIdentityAsync(string packageId)
+        {
+            var taskObj = m_GetLatestPackageIdentityAsync.Invoke(m_Instance, new object[] { packageId }) as Task;
+            var taskWrapper = new TaskWrapper<PackageIdentityWrapper>(taskObj);
+            return await taskWrapper.GetResult();
+        }
+
+        public async Task<PackageSearchMetadataWrapper> QueryPackageExactAsync(string packageId, string version = null, bool includePreRelease = false)
+        {
+            var taskObj = m_QueryPackageExactAsync.Invoke(m_Instance, new object[] { packageId, version, includePreRelease }) as Task;
+            var taskWrapper = new TaskWrapper<PackageSearchMetadataWrapper>(taskObj);
+            return await taskWrapper.GetResult();
+        }
+
+        public async Task<NuGetInstallResultWrapper> InstallAsync(PackageIdentityWrapper packageIdentity, bool allowPreReleaseVersions = false)
+        {
+            var taskObj = m_InstallAsync.Invoke(m_Instance, new[] { packageIdentity.Instance, allowPreReleaseVersions }) as Task;
+            var taskWrapper = new TaskWrapper<NuGetInstallResultWrapper>(taskObj);
+            return await taskWrapper.GetResult();
+        }
+    }
+}

src/Helpers/Wrapper/NuGetVersionWrapper.cs

@@ -0,0 +1,8 @@
+namespace OpenMod.Installer.RocketMod.Helpers.Wrapper
+{
+    public class NuGetVersionWrapper : TypeWrapper
+    {
+        public NuGetVersionWrapper(object instance) : base(instance)
+        { }
+    }
+}

src/Helpers/Wrapper/NugetWrapper.cs

@@ -0,0 +1,16 @@
+using System.Reflection;
+
+namespace OpenMod.Installer.RocketMod.Helpers.Wrapper
+{
+    public class NuGetInstallResultWrapper : TypeWrapper
+    {
+        protected static PropertyInfo m_Code;
+
+        public int Code => (int)m_Code.GetValue(m_Instance);
+
+        public NuGetInstallResultWrapper(object instance) : base(instance)
+        {
+            m_Code = s_Type.GetProperty("Code");
+        }
+    }
+}

src/Helpers/Wrapper/PackageIdentityWrapper.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+
+namespace OpenMod.Installer.RocketMod.Helpers.Wrapper
+{
+    public class PackageIdentityWrapper : TypeWrapper
+    {
+        protected static FieldInfo m_Id;
+        protected static FieldInfo m_Version;
+
+        public string Id => m_Id.GetValue(m_Instance) as string;
+
+        public bool HasVersion
+        {
+            get
+            {
+                var version = m_Version.GetValue(m_Instance);
+                return version != null;
+            }
+        }
+
+        public NuGetVersionWrapper Version
+        {
+            get
+            {
+                var version = m_Version.GetValue(m_Instance);
+                return version == null ? null : new NuGetVersionWrapper(version);
+            }
+        }
+
+        public PackageIdentityWrapper(object instance) : base(instance)
+        {
+            m_Id = s_Type.GetField("_id", BindingFlags.NonPublic | BindingFlags.Instance);
+            m_Version = s_Type.GetField("_version", BindingFlags.NonPublic | BindingFlags.Instance);
+        }
+    }
+}

src/Helpers/Wrapper/PackageSearchMetadataWrapper.cs

@@ -0,0 +1,23 @@
+using System.Reflection;
+
+namespace OpenMod.Installer.RocketMod.Helpers.Wrapper
+{
+    public class PackageSearchMetadataWrapper : TypeWrapper
+    {
+        protected static PropertyInfo m_Identity;
+
+        public PackageIdentityWrapper Identity
+        {
+            get
+            {
+                var identity = m_Identity.GetValue(m_Instance);
+                return new PackageIdentityWrapper(identity);
+            }
+        }
+
+        public PackageSearchMetadataWrapper(object instance) : base(instance)
+        {
+            m_Identity = s_Type.GetProperty("Identity");
+        }
+    }
+}

src/Helpers/Wrapper/TaskWrapper.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace OpenMod.Installer.RocketMod.Helpers.Wrapper
+{
+    public class TaskWrapper<TResult>
+    {
+        protected PropertyInfo m_Result;
+        protected Task m_Instance;
+
+        public Task Instance => m_Instance;
+
+        public async Task<TResult> GetResult()
+        {
+            await m_Instance;
+
+            var resultObj = m_Result.GetValue(m_Instance);
+            return resultObj switch
+            {
+                null => default,
+                TResult result => result,
+                _ => (TResult)Activator.CreateInstance(typeof(TResult), resultObj)
+            };
+        }
+
+        public TaskWrapper(Task instance)
+        {
+            m_Instance = instance;
+            m_Result = instance.GetType().GetProperty("Result");
+        }
+    }
+}

src/Helpers/Wrapper/TypeWrapper.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Linq;
+using System.Reflection;
+
+namespace OpenMod.Installer.RocketMod.Helpers.Wrapper
+{
+    public abstract class TypeWrapper
+    {
+        protected Type s_Type;
+
+        protected object m_Instance;
+
+        public object Instance => m_Instance;
+
+        protected TypeWrapper(object instance)
+        {
+            m_Instance = instance;
+            s_Type = instance.GetType();
+        }
+
+        protected TypeWrapper(Assembly nugetAssembly, string typeName, params object[] args)
+        {
+            s_Type = nugetAssembly.GetTypes().First(tp => tp.Name.Equals(typeName, StringComparison.OrdinalIgnoreCase));
+            m_Instance = Activator.CreateInstance(s_Type, args);
+        }
+    }
+}

src/Jobs/MigrateEconomyJob.cs

@@ -23,7 +23,7 @@ public void ExecuteMigration(string[] args)
             {
                 WorkingDirectory = openmodDirectory,
                 LogOnChange = false
-            }, null, null);
+            }, null, null, null);
 
             if (!AsyncHelper.RunSync(() => dataStore.ExistsAsync("autoexec")))
             {

src/Jobs/MigratePermissionsJob.cs

@@ -87,7 +87,7 @@ public void ExecuteMigration(string[] args)
                 WorkingDirectory = workingDirectory
             };
 
-            var dataStore = new YamlDataStore(dataStoreParams, null, null);
+            var dataStore = new YamlDataStore(dataStoreParams, null, null, null);
 
             AsyncHelperEx.RunSync(() => dataStore.SaveAsync("roles", openmodRoles));
             AsyncHelperEx.RunSync(() => dataStore.SaveAsync("users", openmodUsers));

src/Jobs/NuGetInstallJob.cs

@@ -1,5 +1,5 @@
-using OpenMod.Installer.RocketMod.Helpers;
-using OpenMod.NuGet;
+using System;
+using OpenMod.Installer.RocketMod.Helpers;
 using Rocket.Core.Logging;
 using System.IO;
 using System.Linq;
@@ -37,7 +37,7 @@ private async Task DownloadPackage(bool force, bool usePre)
             var package = await nuGetPackageManager.QueryPackageExactAsync(m_PackageId, null, usePre);
             if (package?.Identity == null)
             {
-                Logger.LogError($"Downloading has failed for {m_PackageId}: {NuGetInstallCode.PackageOrVersionNotFound}");
+                Logger.LogError($"Downloading has failed for {m_PackageId}: PackageOrVersionNotFound");
                 return;
             }
 
@@ -50,7 +50,7 @@ private async Task DownloadPackage(bool force, bool usePre)
             var identity = package.Identity;
 
             var installResult = await nuGetPackageManager.InstallAsync(identity, usePre);
-            var isInstalled = installResult.Code == NuGetInstallCode.Success || installResult.Code == NuGetInstallCode.NoUpdatesFound;
+            var isInstalled = installResult.Code == 0 || installResult.Code == 1;
 
             if (isInstalled)
             {

src/Jobs/OpenModAssemblyLoadJob.cs

@@ -45,9 +45,9 @@ public void ExecuteMigration(string[] args)
                 }
 
                 var moduleDirectory = OpenModInstallerPlugin.Instance.OpenModManager.ModuleDirectory;
-                foreach (var dllpath in Directory.GetFiles(moduleDirectory, "*.dll", SearchOption.TopDirectoryOnly))
+                foreach (var dllPath in Directory.GetFiles(moduleDirectory, "*.dll", SearchOption.TopDirectoryOnly))
                 {
-                    var asm = Assembly.Load(File.ReadAllBytes(dllpath));
+                    var asm = Assembly.Load(File.ReadAllBytes(dllPath));
 
                     var name = GetVersionIndependentName(asm.FullName);
                     if (s_LoadedAssemblies.ContainsKey(name))

src/OpenMod.Installer.RocketMod.csproj

@@ -7,11 +7,10 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Nito.AsyncEx.Context" Version="5.1.0" />
-    <PackageReference Include="OpenMod.Core" Version="3.0.0-beta1" />
-    <PackageReference Include="OpenMod.NuGet" Version="3.0.0-beta1" />
-    <PackageReference Include="OpenMod.UnityEngine.Redist" Version="2019.4.10" />
-    <PackageReference Include="OpenMod.Unturned.Redist" Version="3.20.14" />
+    <PackageReference Include="Nito.AsyncEx.Context" Version="5.1.2" />
+    <PackageReference Include="OpenMod.Core" Version="3.7.4" />
+    <PackageReference Include="OpenMod.UnityEngine.Redist" Version="2021.3.29.1" />
+    <PackageReference Include="OpenMod.Unturned.Redist" Version="3.23.12.3" />
   </ItemGroup>
 
   <ItemGroup>