WinGet.cs

//--------------------------------------------------//
// Created by basicx-StrgV                          //
// https://github.com/basicx-StrgV/                 //
//--------------------------------------------------//
using System;
using System.Collections.Generic;
using System.IO;
using System.Security;
using System.Threading;
using System.Threading.Tasks;
using WGetNET.Builder;
using WGetNET.Components.Internal;
using WGetNET.Exceptions;
using WGetNET.Helper;
using WGetNET.Models;
using WGetNET.Parser;
 
namespace WGetNET
{
    public class WinGet
    {
        private ProcessManager _processManager;
        private string _wingetExePath;
        private DateTime _wingetExeModificationDate;
        private string _versionString;
        private Version _version;
        private bool _isPreview;
 
        private readonly bool _administratorPrivileges;
 
        public bool IsInstalled
        {
            get
            {
                // Check if the winget executable still exist to ensure a correct result,
                // even if winget gets removed while the application is running.
                if (File.Exists(_wingetExePath))
                {
                    return true;
                }
                else
                {
                    // Re-query installation and return the result to allow instalation of winget while the application is running.
                    return QueryInstallation();
                }
            }
        }
 
        public bool IsPreview
        {
            get
            {
                // Check if winget got modefied or removed while the application is running.
                if (_wingetExeModificationDate != GetLastModificationData())
                {
                    // Re-query installation if a change was detected.
                    QueryInstallation();
                }
 
                return _isPreview;
            }
        }
 
        public string VersionString
        {
            get
            {
                // Check if winget got modefied or removed while the application is running.
                if (_wingetExeModificationDate != GetLastModificationData())
                {
                    // Re-query installation if a change was detected.
                    QueryInstallation();
                }
 
                return _versionString;
            }
        }
 
        public Version Version
        {
            get
            {
                // Check if winget got modefied or removed while the application is running.
                if (_wingetExeModificationDate != GetLastModificationData())
                {
                    // Re-query installation if a change was detected.
                    QueryInstallation();
                }
 
                return _version;
            }
        }
 
        public WinGet()
        {
            // Check if the current process has administrator privileges
            _administratorPrivileges = SystemHelper.CheckAdministratorPrivileges();
 
            // Set inital values
            _processManager = new ProcessManager("winget");
            _wingetExePath = string.Empty;
            _wingetExeModificationDate = DateTime.MinValue;
            _versionString = string.Empty;
            _version = new Version(0, 0);
 
            QueryInstallation();
        }
 
        //---Settings Export---------------------------------------------------------------------------
        public string ExportSettings()
        {
            ProcessResult result = Execute(WinGetArguments.SettingsExport());
 
            return ProcessOutputReader.ExportOutputToString(result);
        }
 
        public async Task<string> ExportSettingsAsync(CancellationToken cancellationToken = default)
        {
            ProcessResult result = await ExecuteAsync(WinGetArguments.SettingsExport(), false, cancellationToken);
 
            return ProcessOutputReader.ExportOutputToString(result);
        }
 
        public void ExportSettingsToFile(string file)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(file, "file");
            ArgsHelper.ThrowIfPathIsInvalid(file);
 
            ProcessResult result = Execute(WinGetArguments.SettingsExport());
 
            FileHelper.WriteTextToFile(file, ProcessOutputReader.ExportOutputToString(result));
        }
 
        public async Task ExportSettingsToFileAsync(string file, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(file, "file");
            ArgsHelper.ThrowIfPathIsInvalid(file);
 
            ProcessResult result = await ExecuteAsync(WinGetArguments.SettingsExport(), false, cancellationToken);
 
            await FileHelper.WriteTextToFileAsync(file, ProcessOutputReader.ExportOutputToString(result), cancellationToken);
        }
        //---------------------------------------------------------------------------------------------
 
        //---Admin Settings----------------------------------------------------------------------------
        public List<WinGetAdminSetting> GetAdminSettings()
        {
            List<WinGetAdminSetting> adminSettings = new();
 
            string settingsJson = ExportSettings();
 
            SettingsModel settings = JsonHelper.StringToObject<SettingsModel>(settingsJson);
            if (settings == null)
            {
                return adminSettings;
            }
 
            WinGetAdminSettingBuilder builder = new();
            foreach (KeyValuePair<string, bool> entry in settings.AdminSettings)
            {
                builder.Clear();
 
                builder.AddEntryName(entry.Key);
                builder.AddStatus(entry.Value);
 
                WinGetAdminSetting? adminSetting = builder.GetInstance();
                if (adminSetting != null)
                {
                    adminSettings.Add(adminSetting);
                }
            }
 
            return adminSettings;
        }
 
        public async Task<List<WinGetAdminSetting>> GetAdminSettingsAsync(CancellationToken cancellationToken = default)
        {
            List<WinGetAdminSetting> adminSettings = new();
 
            string settingsJson = await ExportSettingsAsync(cancellationToken);
 
#if NETCOREAPP3_1_OR_GREATER
            SettingsModel settings = await JsonHelper.StringToObjectAsync<SettingsModel>(settingsJson, cancellationToken);
#elif NETSTANDARD2_0
            SettingsModel settings = JsonHelper.StringToObject<SettingsModel>(settingsJson);
#endif
            if (settings == null)
            {
                return adminSettings;
            }
 
            WinGetAdminSettingBuilder builder = new();
            foreach (KeyValuePair<string, bool> entry in settings.AdminSettings)
            {
                if (cancellationToken.IsCancellationRequested)
                {
                    return adminSettings;
                }
 
                builder.Clear();
 
                builder.AddEntryName(entry.Key);
                builder.AddStatus(entry.Value);
 
                WinGetAdminSetting? adminSetting = builder.GetInstance();
                if (adminSetting != null)
                {
                    adminSettings.Add(adminSetting);
                }
            }
 
            return adminSettings;
        }
 
        public bool EnableAdminSetting(string settingName)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(settingName, "settingName");
 
            ProcessResult result = Execute(WinGetArguments.Settings().Enable(settingName), true);
 
            return result.Success;
        }
 
        public bool EnableAdminSetting(WinGetAdminSetting setting)
        {
            ArgsHelper.ThrowIfObjectIsNull(setting, "setting");
 
            return EnableAdminSetting(setting.EntryName);
        }
 
        public async Task<bool> EnableAdminSettingAsync(string settingName, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(settingName, "settingName");
 
            ProcessResult result = await ExecuteAsync(WinGetArguments.Settings().Enable(settingName), true, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> EnableAdminSettingAsync(WinGetAdminSetting setting, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfObjectIsNull(setting, "setting");
 
            return await EnableAdminSettingAsync(setting.EntryName, cancellationToken);
        }
 
        public bool DisableAdminSetting(string settingName)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(settingName, "settingName");
 
            ProcessResult result = Execute(WinGetArguments.Settings().Disable(settingName), true);
 
            return result.Success;
        }
 
        public bool DisableAdminSetting(WinGetAdminSetting setting)
        {
            ArgsHelper.ThrowIfObjectIsNull(setting, "setting");
 
            return DisableAdminSetting(setting.EntryName);
        }
 
        public async Task<bool> DisableAdminSettingAsync(string settingName, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(settingName, "settingName");
 
            ProcessResult result = await ExecuteAsync(WinGetArguments.Settings().Disable(settingName), true, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> DisableAdminSettingAsync(WinGetAdminSetting setting, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfObjectIsNull(setting, "setting");
 
            return await DisableAdminSettingAsync(setting.EntryName, cancellationToken);
        }
        //---------------------------------------------------------------------------------------------
 
        //---Info--------------------------------------------------------------------------------------
        public WinGetInfo GetInfo()
        {
            ProcessResult result = Execute(WinGetArguments.WinGet().Info());
 
            InfoActionVersionId actionVersionId = InfoActionVersionId.VersionRange1;
            if (CheckWinGetVersion(new Version(1, 4, 3531), new Version(1, 5, 101)))
            {
                actionVersionId = InfoActionVersionId.VersionRange2;
            }
            else if (CheckWinGetVersion(new Version(1, 5, 441), new Version(1, 5, 441)))
            {
                actionVersionId = InfoActionVersionId.VersionRange3;
            }
            else if (CheckWinGetVersion(new Version(1, 5, 1081)))
            {
                actionVersionId = InfoActionVersionId.VersionRange4;
            }
 
            return ProcessOutputReader.ToWingetInfo(result.Output, actionVersionId);
        }
 
        public async Task<WinGetInfo> GetInfoAsync(CancellationToken cancellationToken = default)
        {
            ProcessResult result = await ExecuteAsync(WinGetArguments.WinGet().Info(), false, cancellationToken);
 
            // Check the version range the action should be performed for
            InfoActionVersionId actionVersionId = InfoActionVersionId.VersionRange1;
            if (CheckWinGetVersion(new Version(1, 4, 3531), new Version(1, 5, 101)))
            {
                actionVersionId = InfoActionVersionId.VersionRange2;
            }
            else if (CheckWinGetVersion(new Version(1, 5, 441), new Version(1, 5, 441)))
            {
                actionVersionId = InfoActionVersionId.VersionRange3;
            }
            else if (CheckWinGetVersion(new Version(1, 5, 1081)))
            {
                actionVersionId = InfoActionVersionId.VersionRange4;
            }
 
            // Return empty data if the task was canceled
            if (cancellationToken.IsCancellationRequested)
            {
                return WinGetInfo.Empty;
            }
 
            return ProcessOutputReader.ToWingetInfo(result.Output, actionVersionId);
        }
        //---------------------------------------------------------------------------------------------
 
        //---Custom execute----------------------------------------------------------------------------
        public WinGetResult ExecuteCustom(WinGetArguments args)
        {
            ArgsHelper.ThrowIfObjectIsNull(args, "args");
 
            ThrowIfNotInstalled();
 
            WinGetResult result = new(Execute(args), args);
 
            return result;
        }
 
        public WinGetResult ExecuteCustom(string args)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(args, "args");
 
            ThrowIfNotInstalled();
 
            WinGetArguments argsObj = WinGetArguments.CustomCmd(args);
 
            WinGetResult result = new(Execute(argsObj), argsObj);
 
            return result;
        }
 
        public async Task<WinGetResult> ExecuteCustomAsync(WinGetArguments args, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfObjectIsNull(args, "args");
 
            ThrowIfNotInstalled();
 
            WinGetResult result = new(await ExecuteAsync(args, false, cancellationToken), args);
 
            return result;
        }
 
        public async Task<WinGetResult> ExecuteCustomAsync(string args, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(args, "args");
 
            ThrowIfNotInstalled();
 
            WinGetArguments argsObj = WinGetArguments.CustomCmd(args);
 
            WinGetResult result = new(await ExecuteAsync(argsObj, false, cancellationToken), argsObj);
 
            return result;
        }
        //---------------------------------------------------------------------------------------------
 
        //---Protected Functions-----------------------------------------------------------------------
        // \cond PRIVATE
        private protected bool CheckWinGetVersion(Version minVersion, Version? maxVersion = null)
        {
            Version winGetVersion = Version;
            if ((winGetVersion.Major >= minVersion.Major && winGetVersion.Minor >= minVersion.Minor &&
                ((winGetVersion.Minor != minVersion.Minor) || (winGetVersion.Minor == minVersion.Minor && winGetVersion.Build >= minVersion.Build))) &&
                ((maxVersion == null) || (winGetVersion.Major <= maxVersion.Major && winGetVersion.Minor <= maxVersion.Minor &&
                ((winGetVersion.Minor != maxVersion.Minor) || (winGetVersion.Minor == maxVersion.Minor && winGetVersion.Build <= maxVersion.Build)))))
            {
                return true;
            }
            return false;
        }
 
        private protected ProcessResult Execute(WinGetArguments args, bool needsAdminRights = false)
        {
            ThrowIfNotInstalled();
 
            if (needsAdminRights)
            {
                ThrowIfNotAdmin();
            }
 
            return _processManager.ExecuteWingetProcess(args.Arguments);
        }
 
        private protected async Task<ProcessResult> ExecuteAsync(WinGetArguments args, bool needsAdminRights = false, CancellationToken cancellationToken = default)
        {
            ThrowIfNotInstalled();
 
            if (needsAdminRights)
            {
                ThrowIfNotAdmin();
            }
 
            return await _processManager.ExecuteWingetProcessAsync(args.Arguments, cancellationToken);
        }
        // \endcond
        //---------------------------------------------------------------------------------------------
 
        //---Other-------------------------------------------------------------------------------------
        private void ThrowIfNotInstalled()
        {
            if (!IsInstalled)
            {
                throw new WinGetNotInstalledException();
            }
        }
 
        private void ThrowIfNotAdmin()
        {
            if (!_administratorPrivileges)
            {
                throw new SecurityException("Administrator privileges are missing.");
            }
        }
 
        private string CheckWinGetVersion()
        {
            if (!IsInstalled)
            {
                return string.Empty;
            }
 
            ProcessResult result = Execute(WinGetArguments.WinGet().Version());
 
            for (int i = 0; i < result.Output.Length; i++)
            {
#if NETCOREAPP3_1_OR_GREATER
                if (result.Output[i].StartsWith('v') && result.Output[i].Length >= 2)
                {
                    // Return output without the 'v' at the start.
                    return result.Output[i].Trim()[1..];
                }
#elif NETSTANDARD2_0
                if (result.Output[i].StartsWith("v") && result.Output[i].Length >= 2)
                {
                    // Return output without the 'v' at the start.
                    return result.Output[i].Trim().Substring(1);
                }
#endif
            }
 
            return string.Empty;
        }
 
        private DateTime GetLastModificationData()
        {
            if (string.IsNullOrWhiteSpace(_wingetExePath) || !File.Exists(_wingetExePath))
            {
                return DateTime.MinValue;
            }
 
            return File.GetLastWriteTimeUtc(_wingetExePath);
        }
 
        private bool QueryInstallation()
        {
            bool isInstalled;
 
            _wingetExePath = SystemHelper.CheckWingetInstallation();
 
            if (string.IsNullOrWhiteSpace(_wingetExePath))
            {
                isInstalled = false;
                _processManager = new ProcessManager("winget");
            }
            else
            {
                isInstalled = true;
                _processManager = new ProcessManager(_wingetExePath);
            }
 
            _wingetExeModificationDate = GetLastModificationData();
 
            if (isInstalled)
            {
                _versionString = CheckWinGetVersion();
            }
            else
            {
                _versionString = string.Empty;
            }
 
            _version = VersionParser.Parse(_versionString);
 
            _isPreview = VersionParser.CheckPreviewStatus(_versionString);
 
            return isInstalled;
        }
        //---------------------------------------------------------------------------------------------
    }
}