public async Task <UpdateNeeded> IsUpdateNeededAsync(string packageName, bool includePreRelease)
{
SemanticVersion largestAvailableVersion;
try
{
using (var downloader = new NugetDownloader(commandDirectory))
{
var versionFound = await downloader.GetLatestVersionAsync(packageName, includePreRelease);
if (versionFound == null)
{
WriteLineIfVerbose($"Could not find '{packageName}'.");
return(UpdateNeeded.PackageNotFound);
}
largestAvailableVersion = SemanticVersion.Parse(versionFound);
}
}
catch (Exception ex)
{
WriteLine("Could not download Nuget.");
WriteLineIfVerbose(ex.ToString());
return(UpdateNeeded.No);
}
var directory = commandDirectory.GetDirectoryForPackage(packageName);
var packageDirs = Directory.EnumerateDirectories(directory);
var packageVersions = packageDirs.Select(packageDir => SemanticVersion.Parse(Path.GetFileName(packageDir)));
var largestInstalledVersion = packageVersions.Max();
return(largestInstalledVersion >= largestAvailableVersion ? UpdateNeeded.No : UpdateNeeded.Yes);
}
private async Task <bool> DeleteRedirectFileAsync(string packageName)
{
var packageDir = commandDirectory.GetDirectoryForPackage(packageName);
if (!Directory.Exists(packageDir))
{
WriteLine($"Package {packageName} is not installed.");
return(false);
}
var packageDirs = Directory.EnumerateDirectories(packageDir);
foreach (var packageAndVersionDir in packageDirs)
{
var packageInfo = await PackageInfo.GetMainFilePathAsync(packageName, packageAndVersionDir);
if (packageInfo == null || !packageInfo.Commands.Any())
{
return(true);
}
foreach (var command in packageInfo.Commands)
{
var binFile = commandDirectory.GetBinFile(command.Name + (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? ".cmd" : ""));
try
{
if (File.Exists(binFile))
{
WriteLineIfVerbose($"Deleting bin file '{binFile}'.");
File.Delete(binFile);
}
else
{
WriteLineIfVerbose($"Bin file '{binFile}' does not exist.");
}
}
catch (Exception ex)
{
WriteLine($"Could not delete bin file '{binFile}'.");
WriteLineIfVerbose(ex.ToString());
return(false);
}
}
}
return(true);
}
public async Task <bool> InstallAsync(string packageName, SemanticVersion packageVersion, bool force, bool includePreRelease)
{
WriteLineIfVerbose($"Installing {packageName}...");
PackageInfo packageInfo;
try
{
using (var downloader = new NugetDownloader(commandDirectory))
{
packageInfo = await downloader.DownloadAndExtractNugetAsync(packageName, packageVersion, force, includePreRelease);
if (packageInfo == null)
{
return(false);
}
}
}
catch (Exception ex)
{
WriteLineIfVerbose("Could not download Nuget.");
WriteLineIfVerbose(ex.ToString());
return(false);
}
var created = CreateBinFile(packageInfo);
if (!created)
{
if (Directory.Exists(packageInfo.PackageDir))
{
WriteLineIfVerbose($"Deleting {packageInfo}...");
Directory.Delete(packageInfo.PackageDir, true);
var packageDirectoryForAllVersions = commandDirectory.GetDirectoryForPackage(packageName);
if (Directory.EnumerateDirectories(packageDirectoryForAllVersions).Count() <= 1)
{
Directory.Delete(packageDirectoryForAllVersions, true);
}
}
return(false);
}
var added = CreateRuntimeConfigDevJsonFile(packageInfo.PackageDir);
if (!added)
{
return(false);
}
var restored = await RestoreAsync(packageInfo.PackageDir);
return(restored);
}
public async Task <bool> ListAsync()
{
var sb = new StringBuilder();
try
{
var packageDirectories = Directory.EnumerateDirectories(commandDirectory.PackagesDir).OrderBy(d => d);
foreach (var pkgDir in packageDirectories)
{
var packageDirectory = pkgDir;
if (!packageDirectory.EndsWith(Path.DirectorySeparatorChar.ToString()))
{
packageDirectory += Path.DirectorySeparatorChar.ToString();
}
var packageName = Path.GetFileName(Path.GetDirectoryName(packageDirectory));
var versionDirectories = Directory.EnumerateDirectories(packageDirectory).OrderBy(d => d);
foreach (var verDir in versionDirectories)
{
var versionDirectory = verDir;
if (!versionDirectory.EndsWith(Path.DirectorySeparatorChar.ToString()))
{
versionDirectory += Path.DirectorySeparatorChar.ToString();
}
var packageVersion = Path.GetFileName(Path.GetDirectoryName(versionDirectory));
sb.AppendLine($"{packageName} ({packageVersion})");
}
var packageDirs = Directory.EnumerateDirectories(commandDirectory.GetDirectoryForPackage(packageName)).OrderBy(d => d);
foreach (var packageDir in packageDirs)
{
var packageInfo = await PackageInfo.GetMainFilePathAsync(packageName, packageDir);
if (packageInfo == null || !packageInfo.Commands.Any())
{
continue;
}
foreach (var command in packageInfo.Commands)
{
if (command.Name == packageName)
{
continue;
}
if (IsVerbose)
{
sb.AppendLine($" {command.Name} ({command.ExecutableFilePath})");
}
else
{
sb.AppendLine($" {command.Name}");
}
}
}
}
var packagesInfo = sb.ToString();
WriteLine(packagesInfo);
return(true);
}
catch (Exception ex)
{
WriteLineIfVerbose($"Error getting package info: '{ex.Message}'.");
return(false);
}
}
