public async override Task <bool> TestPackageInstalledAsync(SoftwarePackage package)
{
var fileinfo = await GetPackageFileAsync(package, ".appx");
using var stream = ZipFile.OpenRead(fileinfo.FullName)?.GetEntry("AppxManifest.xml")?.Open();
if (stream == null)
{
throw new Exception("Cannot test if package installed. File does not exist.");
}
using var reader = new StreamReader(stream);
XNamespace xdocNamespace = "http://schemas.microsoft.com/appx/manifest/foundation/windows10";
var xml = await reader.ReadToEndAsync();
var doc = XDocument.Parse(xml);
var appxName = doc.Descendants(xdocNamespace + "Identity")?.First()?.Attribute("Name")?.Value;
if (appxName == null)
{
throw new Exception("Cannot find package identity of appx.");
}
var sessionState = InitialSessionState.CreateDefault();
sessionState.ExecutionPolicy = ExecutionPolicy.Unrestricted;
using var ps = PowerShell.Create(sessionState);
ps.AddScript("Import-Module Appx -UseWindowsPowerShell");
ps.AddScript($"Get-AppxPackage '{appxName}'");
return((await ps.InvokeAsync()).Count > 0);
}
public override async Task InstallPackageAsync(SoftwarePackage package)
{
string arguments;
if (await GetUpgradePending(package.PackageName))
{
arguments = $"upgrade {package.PackageName} -y";
}
else
{
arguments = $"install {package.PackageName} -y";
}
var process = Process.Start(new ProcessStartInfo
{
FileName = "choco",
Arguments = arguments
});
await(process?.WaitForExitAsync() ?? Task.CompletedTask);
if (process == null || process.ExitCode != 0)
{
throw new InstallFailedException();
}
}
public override async Task <bool> TestPackageInstalledAsync(SoftwarePackage package)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (package.PackageName == null)
{
throw new ArgumentNullException(nameof(package.PackageName));
}
// dotnet tool list --global
var process = Process.Start(new ProcessStartInfo
{
FileName = await operatingSystemProvider.GetFullExecutablePathAsync("dotnet"),
Arguments = $"tool list --global",
RedirectStandardOutput = true,
});
if (process == null)
{
throw new Exception("Process did not start correctly.");
}
await process.WaitForExitAsync();
var results = await process.StandardOutput.ReadToEndAsync();
return(results.Contains(package.PackageName, StringComparison.InvariantCultureIgnoreCase));
}
private async Task InstallSoftwarePackageAsync(SoftwarePackage package, Dictionary <string, SoftwarePackage> packagesByName)
{
if (package.Dependencies?.Any() ?? false)
{
var missingDependencies = (from d in package.Dependencies
where !packagesByName.ContainsKey(d)
select d).ToArray();
if (missingDependencies.Any())
{
throw new DependencyMissingException(missingDependencies.ToArray());
}
var dependencies = from d in package.Dependencies
select packagesByName[d];
foreach (var depend in dependencies)
{
await InstallSoftwarePackageAsync(depend, packagesByName);
}
}
if (!await package.TestPlatformAsync())
{
return;
}
if (!await package.TestInstalledAsync())
{
await package.InstallAsync();
}
}
public override async Task InstallPackageAsync(SoftwarePackage package)
{
var process = Process.Start(new ProcessStartInfo
{
FileName = await operatingSystemProvider.GetFullExecutablePathAsync("code"),
Arguments = $"--install-extension {package.PackageName}"
});
await(process?.WaitForExitAsync() ?? Task.CompletedTask);
if (process == null || process.ExitCode != 0)
{
throw new InstallFailedException();
}
}
public override async Task <bool> TestPackageInstalledAsync(SoftwarePackage package)
{
var fileinfo = await GetPackageFileAsync(package, ".msi");
var productName = GetProductName(fileinfo.FullName);
if (OperatingSystem.IsWindows())
{
var productsKey = Registry.ClassesRoot.OpenSubKey($"Installer\\Products");
return((from s in productsKey?.GetSubKeyNames()
where OperatingSystem.IsWindows() &&
productsKey?.OpenSubKey(s)?.GetValue("ProductName")?.ToString() == productName
select s).Any());
}
throw new NotImplementedException();
}
public override async Task <bool> TestPackageInstalledAsync(SoftwarePackage package)
{
var cachedFeatures = await GetCachedFeaturesAsync();
if (cachedFeatures != null && cachedFeatures[package.PackageName] == DismPackageFeatureState.Installed)
{
return(true);
}
if (!await operatingSystemProvider.IsSuperUserAsync())
{
throw new SuperUserRequiredException();
}
var features = GetCurrentFeatures();
return(features[package.PackageName] == DismPackageFeatureState.Installed);
}
public override async Task InstallPackageAsync(SoftwarePackage package)
{
var fileinfo = await GetPackageFileAsync(package, ".msi");
var process = Process.Start(new ProcessStartInfo
{
FileName = "msiexec",
Arguments = $"/i {fileinfo.Name} /quiet /qn /norestart",
WorkingDirectory = fileinfo.DirectoryName
});
await(process?.WaitForExitAsync() ?? Task.CompletedTask);
if (process == null || process.ExitCode != 0)
{
throw new InstallFailedException();
}
}
public override async Task <bool> TestPackageInstalledAsync(SoftwarePackage package)
{
var process = Process.Start(new ProcessStartInfo
{
FileName = await operatingSystemProvider.GetFullExecutablePathAsync("npm"),
Arguments = $"list -g {package.PackageName}",
RedirectStandardOutput = true,
});
if (process == null)
{
throw new Exception("Process did not start correctly.");
}
await process.WaitForExitAsync();
return(process.ExitCode == 0);
}
public override async Task InstallPackageAsync(SoftwarePackage package)
{
var process = Process.Start(new ProcessStartInfo
{
FileName = await operatingSystemProvider.GetFullExecutablePathAsync("dotnet"),
Arguments = $"tool install --global {package.PackageName}"
});
if (process == null)
{
throw new Exception("Process did not start correctly.");
}
await process.WaitForExitAsync();
if (process.ExitCode != 0)
{
throw new InstallFailedException();
}
}
public async override Task InstallPackageAsync(SoftwarePackage package)
{
var fileinfo = await GetPackageFileAsync(package, ".appx");
var sessionState = InitialSessionState.CreateDefault();
sessionState.ExecutionPolicy = ExecutionPolicy.Unrestricted;
using var ps = PowerShell.Create(sessionState);
ps.AddScript($"cd \"{fileinfo.DirectoryName}\"");
ps.AddScript("Import-Module Appx -UseWindowsPowerShell");
ps.AddScript($"Add-AppxPackage '{package.PackageName}'");
await ps.InvokeAsync();
if (ps.HadErrors)
{
throw new InstallFailedException();
}
}
public SoftwarePackage GetSoftwarePackage(string id)
{
OpenConnection();
SoftwarePackage swPackg = null;
string sql = $"";
using (SqlCommand command = new SqlCommand(sql, _sqlConnection))
{
command.CommandType = CommandType.Text;
SqlDataReader dataReader = command.ExecuteReader(CommandBehavior.CloseConnection);
while (dataReader.Read())
{
swPackg = new SoftwarePackage
{
};
}
dataReader.Close();
}
return(swPackg);
}
private async Task InstallPackageInternalAsync(SoftwarePackage package, bool classic)
{
var arguments = $"install {package.PackageName}";
if (classic)
{
arguments += " --classic";
}
var process = Process.Start(new ProcessStartInfo
{
FileName = "snap",
Arguments = arguments,
RedirectStandardError = true,
CreateNoWindow = true
});
if (process != null)
{
await process.WaitForExitAsync();
var results = await process.StandardError.ReadToEndAsync();
var needsClassic = (from l in results.Split('\n', StringSplitOptions.RemoveEmptyEntries)
where l.Contains(CLASSIC_CHECK)
select l).Any();
if (needsClassic && !classic)
{
await InstallPackageInternalAsync(package, true);
return;
}
}
if (process == null || process.ExitCode != 0)
{
throw new InstallFailedException();
}
}
protected async Task <FileInfo> GetPackageFileAsync(SoftwarePackage package, string defaultExtension)
{
if (IsWebUrl(package))
{
var cachePath = Path.Join(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Clcrutch", "DependencyManager", "cache");
var cacheDirectoryInfo = new DirectoryInfo(cachePath);
if (!cacheDirectoryInfo.Exists)
{
cacheDirectoryInfo.Create();
}
var filename = Path.GetFileName(new Uri(package.PackageName).LocalPath);
if (string.IsNullOrEmpty(Path.GetExtension(filename)))
{
filename = $"{filename}{defaultExtension}";
}
var filepath = Path.Join(cachePath, filename);
var fileinfo = new FileInfo(filepath);
if (!fileinfo.Exists)
{
using var client = new HttpClient();
var webStream = await client.GetStreamAsync(package.PackageName);
var fileStream = fileinfo.Create();
await webStream.CopyToAsync(fileStream);
}
return(fileinfo);
}
else
{
return(new FileInfo(package.PackageName));
}
}
public override async Task <bool> TestPackageInstalledAsync(SoftwarePackage package)
{
var process = Process.Start(new ProcessStartInfo
{
FileName = await operatingSystemProvider.GetFullExecutablePathAsync("code"),
Arguments = "--list-extensions",
RedirectStandardOutput = true,
CreateNoWindow = true
});
if (process != null)
{
await process.WaitForExitAsync();
var packageString = await process.StandardOutput.ReadToEndAsync();
var packageLines = packageString.Split('\n', StringSplitOptions.RemoveEmptyEntries).ToList();
return(packageLines.Contains(package.PackageName));
}
return(false);
}
public override async Task <bool> TestPackageInstalledAsync(SoftwarePackage package)
{
var installedPackages = await GetInstalledPackagesAsync();
return((installedPackages?.ContainsKey(package.PackageName) ?? false) && (true || !await GetUpgradePending(package.PackageName)));
}
private bool IsWebUrl(SoftwarePackage package) =>
package.PackageName.Contains("https://") || package.PackageName.Contains("http://");
public SoftwarePackageDisplay(SoftwarePackage package)
{
Name = package.Name;
Description = package.Description;
}
public override async Task <bool> TestPackageInstalledAsync(SoftwarePackage package) => (await GetInstalledPackagesAsync())?.ContainsKey(package.PackageName) ?? false;
public override Task InstallPackageAsync(SoftwarePackage package) => InstallPackageInternalAsync(package, false);
public abstract Task InstallPackageAsync(SoftwarePackage package);
public override Task InstallPackageAsync(SoftwarePackage package)
{
DismApi.EnableFeatureByPackageName(GetDismSession(), package.PackageName, null, false, true);
return(UpdateCacheAsync(GetCurrentFeatures()));
}
public abstract Task <bool> TestPackageInstalledAsync(SoftwarePackage package);
