WinGetSourceManager.cs

//--------------------------------------------------//
// Created by basicx-StrgV                          //
// https://github.com/basicx-StrgV/                 //
//--------------------------------------------------//
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using WGetNET.Components.Internal;
using WGetNET.Helper;
using WGetNET.Models;
 
namespace WGetNET
{
    public class WinGetSourceManager : WinGet
    {
        public WinGetSourceManager()
        {
            // Provide empty constructor for xlm docs
        }
 
        //---List--------------------------------------------------------------------------------------
        public List<WinGetSource> GetInstalledSources()
        {
            ProcessResult result = Execute(WinGetArguments.SourceExport());
 
            return ProcessOutputReader.ToSourceList(result.Output);
        }
 
        public List<WinGetSource> GetInstalledSources(string sourceName)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(sourceName, "sourceName");
 
            ProcessResult result = Execute(WinGetArguments.SourceExport().Name(sourceName));
 
            return ProcessOutputReader.ToSourceList(result.Output);
        }
 
        public async Task<List<WinGetSource>> GetInstalledSourcesAsync(CancellationToken cancellationToken = default)
        {
            ProcessResult result = await ExecuteAsync(WinGetArguments.SourceExport(), false, cancellationToken);
 
            // Return empty list if the task was cancled
            if (cancellationToken.IsCancellationRequested)
            {
                return new List<WinGetSource>();
            }
 
            return ProcessOutputReader.ToSourceList(result.Output);
        }
 
        public async Task<List<WinGetSource>> GetInstalledSourcesAsync(string sourceName, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(sourceName, "sourceName");
 
            ProcessResult result = await ExecuteAsync(WinGetArguments.SourceExport().Name(sourceName), false, cancellationToken);
 
            // Return empty list if the task was cancled
            if (cancellationToken.IsCancellationRequested)
            {
                return new List<WinGetSource>();
            }
 
            return ProcessOutputReader.ToSourceList(result.Output);
        }
        //---------------------------------------------------------------------------------------------
 
        //---Add---------------------------------------------------------------------------------------
        public bool AddSource(string name, string arg)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(name, "name");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(arg, "arg");
 
            ProcessResult result =
                Execute(
                    WinGetArguments
                    .SourceAdd()
                    .Name(name)
                    .Arg(arg)
                    .AcceptSourceAgreements(),
                    true);
 
            return result.Success;
        }
 
        public bool AddSource(string name, string arg, string type)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(name, "name");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(arg, "arg");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(type, "type");
 
            ProcessResult result =
                Execute(
                    WinGetArguments
                    .SourceAdd()
                    .Name(name)
                    .Arg(arg)
                    .Type(type)
                    .AcceptSourceAgreements(),
                    true);
 
            return result.Success;
        }
 
        public bool AddSource(WinGetSource source)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(source, "source");
 
            if (string.IsNullOrWhiteSpace(source.Type))
            {
                return AddSource(source.Name, source.Arg);
            }
 
            return AddSource(source.Name, source.Arg, source.Type);
        }
 
        public bool AddSource(IEnumerable<WinGetSource> sources)
        {
            ArgsHelper.ThrowIfObjectIsNull(sources, "sources");
 
            bool succes = true;
            foreach (WinGetSource source in sources)
            {
                if (!AddSource(source))
                {
                    succes = false;
                }
            }
 
            return succes;
        }
 
        public async Task<bool> AddSourceAsync(string name, string arg, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(name, "name");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(arg, "arg");
 
            ProcessResult result =
                await ExecuteAsync(
                    WinGetArguments
                    .SourceAdd()
                    .Name(name)
                    .Arg(arg)
                    .AcceptSourceAgreements(),
                    true, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> AddSourceAsync(string name, string arg, string type, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(name, "name");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(arg, "arg");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(type, "type");
 
            ProcessResult result =
                await ExecuteAsync(
                    WinGetArguments
                    .SourceAdd()
                    .Name(name)
                    .Arg(arg)
                    .Type(type)
                    .AcceptSourceAgreements(),
                    true, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> AddSourceAsync(WinGetSource source, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(source, "source");
 
            if (string.IsNullOrWhiteSpace(source.Type))
            {
                return await AddSourceAsync(source.Name, source.Arg, cancellationToken);
            }
 
            return await AddSourceAsync(source.Name, source.Arg, source.Type, cancellationToken);
        }
 
        public async Task<bool> AddSourceAsync(IEnumerable<WinGetSource> sources, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfObjectIsNull(sources, "sources");
 
            bool success = true;
            foreach (WinGetSource source in sources)
            {
                if (cancellationToken.IsCancellationRequested)
                {
                    return false;
                }
 
                if (!(await AddSourceAsync(source, cancellationToken)))
                {
                    success = false;
                }
            }
 
            return success;
        }
        //---------------------------------------------------------------------------------------------
 
        //---Update------------------------------------------------------------------------------------
        public bool UpdateSources()
        {
            ProcessResult result = Execute(WinGetArguments.SourceUpdate());
 
            return result.Success;
        }
 
        public async Task<bool> UpdateSourcesAsync(CancellationToken cancellationToken = default)
        {
            ProcessResult result = await ExecuteAsync(WinGetArguments.SourceUpdate(), false, cancellationToken);
 
            return result.Success;
        }
        //---------------------------------------------------------------------------------------------
 
        //---Export------------------------------------------------------------------------------------
        public void ExportSourcesToFile(string file)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(file, "file");
            ArgsHelper.ThrowIfPathIsInvalid(file);
 
            FileHelper.WriteTextToFile(
                file,
                SourcesToJson(
                    GetInstalledSources()));
        }
 
        public void ExportSourcesToFile(string file, string sourceName)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(file, "file");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(sourceName, "sourceName");
            ArgsHelper.ThrowIfPathIsInvalid(file);
 
            FileHelper.WriteTextToFile(
                file,
                SourcesToJson(
                    GetInstalledSources(sourceName)));
        }
 
        public void ExportSourcesToFile(string file, WinGetSource source)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(source, "source");
            ArgsHelper.ThrowIfPathIsInvalid(file);
 
            ExportSourcesToFile(file, source.Name);
        }
 
        public async Task ExportSourcesToFileAsync(string file, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(file, "file");
            ArgsHelper.ThrowIfPathIsInvalid(file);
 
            await FileHelper.WriteTextToFileAsync(
                file, SourcesToJson(
                    await GetInstalledSourcesAsync(cancellationToken)),
                cancellationToken);
        }
 
        public async Task ExportSourcesToFileAsync(string file, string sourceName, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(file, "file");
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(sourceName, "sourceName");
            ArgsHelper.ThrowIfPathIsInvalid(file);
 
            await FileHelper.WriteTextToFileAsync(
                file,
                SourcesToJson(
                    await GetInstalledSourcesAsync(sourceName, cancellationToken)),
                cancellationToken);
        }
 
        public async Task ExportSourcesToFileAsync(string file, WinGetSource source, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(source, "source");
            ArgsHelper.ThrowIfPathIsInvalid(file);
 
            await ExportSourcesToFileAsync(file, source.Name, cancellationToken);
        }
        //---------------------------------------------------------------------------------------------
 
        //---Import------------------------------------------------------------------------------------
        public bool ImportSourcesFromJson(string jsonString)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(jsonString, "jsonString");
 
            List<SourceModel> sources = JsonHelper.StringToObject<List<SourceModel>>(jsonString);
 
            bool success = true;
            for (int i = 0; i < sources.Count; i++)
            {
                if (!AddSource(WinGetSource.FromSourceModel(sources[i])))
                {
                    success = false;
                }
            }
 
            return success;
        }
 
        public async Task<bool> ImportSourcesFromJsonAsync(string jsonString, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(jsonString, "jsonString");
 
#if NETCOREAPP3_1_OR_GREATER
            List<SourceModel> sources =
                await JsonHelper.StringToObjectAsync<List<SourceModel>>(jsonString, cancellationToken);
#elif NETSTANDARD2_0
            List<SourceModel> sources =
                JsonHelper.StringToObject<List<SourceModel>>(jsonString);
#endif
 
            bool success = true;
            for (int i = 0; i < sources.Count; i++)
            {
                if (cancellationToken.IsCancellationRequested)
                {
                    return false;
                }
 
                if (!(await AddSourceAsync(WinGetSource.FromSourceModel(sources[i]), cancellationToken)))
                {
                    success = false;
                }
            }
 
            return success;
        }
        //---------------------------------------------------------------------------------------------
 
        //---Reset-------------------------------------------------------------------------------------
        public bool ResetSources()
        {
            ProcessResult result = Execute(WinGetArguments.SourceReset().Force(), true);
 
            return result.Success;
        }
 
        public async Task<bool> ResetSourcesAsync(CancellationToken cancellationToken = default)
        {
            ProcessResult result = await ExecuteAsync(WinGetArguments.SourceReset().Force(), true, cancellationToken);
 
            return result.Success;
        }
        //---------------------------------------------------------------------------------------------
 
        //---Remove------------------------------------------------------------------------------------
        public bool RemoveSources(string name)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(name, "name");
 
            ProcessResult result = Execute(WinGetArguments.SourceRemove().Name(name), true);
 
            return result.Success;
        }
 
        public bool RemoveSources(WinGetSource source)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(source, "source");
 
            return RemoveSources(source.Name);
        }
 
        public async Task<bool> RemoveSourcesAsync(string name, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfStringIsNullOrWhiteSpace(name, "name");
 
            ProcessResult result = await ExecuteAsync(WinGetArguments.SourceRemove().Name(name), true, cancellationToken);
 
            return result.Success;
        }
 
        public async Task<bool> RemoveSourcesAsync(WinGetSource source, CancellationToken cancellationToken = default)
        {
            ArgsHelper.ThrowIfWinGetObjectIsNullOrEmpty(source, "source");
 
            return await RemoveSourcesAsync(source.Name, cancellationToken);
        }
        //---------------------------------------------------------------------------------------------
 
        //---Other-------------------------------------------------------------------------------------
#pragma warning disable S2325 // Ignore warning for now because changing it will be an API braking change.
        public string SourcesToJson(IEnumerable<WinGetSource> sources)
#pragma warning restore S2325
        {
            ArgsHelper.ThrowIfObjectIsNull(sources, "sources");
 
            // Create source models for json parsing
            List<SourceModel> models = new();
            foreach (WinGetSource source in sources)
            {
                models.Add(SourceModel.FromWinGetSource(source));
            }
 
            return JsonHelper.GetJson(models);
        }
        //---------------------------------------------------------------------------------------------
    }
}