public async Task <IEnumerable <IPackageDetails> > SearchForUpdatesAsync(bool?allowPrerelease = null, bool authenticateIfRequired = true, CancellationToken token = default)
{
return((await SearchForPackagesUpdatesAsync(allowPrerelease, authenticateIfRequired, token))
.Select(
m => PackageDetailsFactory.Create(PackageOperationType.Update, m, m.Identity, true))
.ToList());
}
private async Task OnInstallPackageExecuteAsync()
{
try
{
_progressManager.ShowBar(this);
using (var cts = new CancellationTokenSource())
{
if (IsInstalled())
{
var updatePackageDetails = PackageDetailsFactory.Create(PackageOperationType.Update, VersionData, SelectedVersion, null);
await _packageCommandService.ExecuteUpdateAsync(updatePackageDetails, cts.Token);
}
else
{
var installPackageDetails = PackageDetailsFactory.Create(PackageOperationType.Install, VersionData, SelectedPackage, null);
await _packageCommandService.ExecuteInstallAsync(installPackageDetails, cts.Token);
}
}
await Task.Delay(200);
}
catch (Exception ex)
{
Log.Error(ex, $"Error when installing package {Package.Identity}, installation failed");
}
finally
{
_progressManager.HideBar(this);
}
}
private async Task BatchInstallExecuteAsync()
{
try
{
_progressManager.ShowBar(this);
var batchedPackages = _parentManagerPage.PackageItems.Where(x => x.IsChecked).ToList();
if (batchedPackages.Any(x => x.ValidationContext.HasErrors))
{
await _messageService.ShowErrorAsync("Can't perform install. One or multiple package cannot be installed due to validation errors", "Can't install packages");
return;
}
using (var cts = new CancellationTokenSource())
{
var installPackageList = new List <IPackageDetails>();
foreach (var package in batchedPackages)
{
var targetVersion = (await package.LoadVersionsAsync() ?? package.Versions)?.OrderByDescending(x => x).FirstOrDefault();
var installPackageDetails = PackageDetailsFactory.Create(PackageOperationType.Install, package.GetMetadata(), targetVersion, null);
installPackageList.Add(installPackageDetails);
}
using (var operationContext = _packageOperationContextService.UseOperationContext(PackageOperationType.Install, installPackageList.ToArray()))
{
foreach (var packageDetails in installPackageList)
{
await _packageCommandService.ExecuteInstallAsync(packageDetails, operationContext, cts.Token);
}
}
}
await Task.Delay(200);
}
catch (Exception ex)
{
Log.Error(ex, $"Error when updating package");
}
finally
{
_progressManager.HideBar(this);
_parentManagerPage.StartLoadingTimerOrInvalidateData();
}
}
public async Task <IEnumerable <IPackageDetails> > SearchForUpdatesAsync(string[] excludeReleaseTags, bool?allowPrerelease = null, CancellationToken token = default)
{
Argument.IsNotNull(() => excludeReleaseTags);
var foundUpdates = (await SearchForPackagesUpdatesAsync(allowPrerelease, true, token)).ToList();
// Replace all packages with restricted tag with nearest possible
var packagesToExclude = foundUpdates.Where(p => p.Identity.Version.Release.ContainsAny(excludeReleaseTags, StringComparison.OrdinalIgnoreCase)).ToList();
var metadataProvider = PackageMetadataProvider;
if (packagesToExclude.Any())
{
var localRepositorySource = _repositoryService.LocalRepository?.Source;
var installedPackagesMetadatas = await _projectRepositoryLoader.Value.LoadWithDefaultsAsync(localRepositorySource, token);
foreach (var package in packagesToExclude)
{
foundUpdates.Remove(package);
var metadata = await metadataProvider.GetHighestPackageMetadataAsync(package.Identity.Id, allowPrerelease ?? true, excludeReleaseTags, token);
if (metadata is null)
{
Log.Debug($"Couldn't retrieve update metadata for installed package {package.Identity.Id}");
continue;
}
var localPackage = installedPackagesMetadatas.FirstOrDefault(p => string.Equals(p.Identity.Id, metadata.Identity.Id));
if (localPackage is null)
{
// Normally shouldn't happen
Log.Debug($"Couldn't match retrieved update metadata with any local package");
continue;
}
if (metadata.Identity.Version > localPackage.Identity.Version)
{
// Add as replacement for alpha
foundUpdates.Add(metadata);
}
}
}
var updatePackages = foundUpdates.Select(p => PackageDetailsFactory.Create(PackageOperationType.Update, p, p.Identity, true)).ToList();
return(updatePackages);
}
private async Task OnUninstallPackageExecuteAsync()
{
try
{
_progressManager.ShowBar(this);
using (var cts = new CancellationTokenSource())
{
// InstalledPackage means you cannot directly choose version which should be uninstalled, may be this should be revised
var uninstallPackageDetails = PackageDetailsFactory.Create(PackageOperationType.Uninstall, Package.GetMetadata(), InstalledPackage, null);
await _packageCommandService.ExecuteUninstallAsync(uninstallPackageDetails, cts.Token);
}
await Task.Delay(200);
}
catch (Exception ex)
{
Log.Error(ex, $"Error when uninstalling package {Package.Identity}, uninstall was failed");
}
finally
{
_progressManager.HideBar(this);
}
}
public async Task <bool> RunAsync()
{
var folderProject = new FolderNuGetProject(_defaultProject.ContentPath);
if (!_directoryService.Exists(_defaultProject.ContentPath))
{
Log.Info($"Plugins folder does not exist");
return(false);
}
var subFolders = folderProject.GetPackageDirectories();
var failedIdentities = new List <PackageIdentity>();
var parsedPackages = new List <IPackageDetails>();
bool anyUpgraded = false;
using (var context = AcquireSourceContextForActions())
{
if (context == SourceContext.EmptyContext)
{
Log.Warning($"Source context is empty");
return(false);
}
foreach (var folder in subFolders)
{
var packageFolderName = Path.GetFileName(folder);
var package = PackageIdentityParser.Parse(packageFolderName);
var packageDetails = PackageDetailsFactory.Create(package);
parsedPackages.Add(packageDetails);
}
//no valid package folders
if (!parsedPackages.Any())
{
return(false);
}
_packageOperationNotificationService.NotifyAutomaticOperationBatchStarting(PackageOperationType.Install, parsedPackages.ToArray());
foreach (var packageDetails in parsedPackages)
{
var package = packageDetails.GetIdentity();
if (package is null)
{
continue;
}
var installationPath = _defaultProject.GetInstallPath(package);
var isV2packageInstalled = folderProject.PackageExists(package, NuGet.Packaging.PackageSaveMode.Defaultv2);
if (!isV2packageInstalled)
{
Log.Warning($"Package '{package}' is recognized in project folder as v2 NuGet installed package");
continue;
}
if (await _nuGetPackageManager.IsPackageInstalledAsync(_defaultProject, package, default))
{
Log.Info($"Skipping package '{package}', package is valid");
continue;
}
_packageOperationNotificationService.NotifyAutomaticOperationStarting(installationPath, PackageOperationType.Install, packageDetails);
//reinstall
try
{
var isInstalled = await _nuGetPackageManager.InstallPackageForProjectAsync(_defaultProject, package, default, false);
private async Task BatchUpdateExecuteAsync()
{
try
{
_progressManager.ShowBar(this);
var batchedPackages = _parentManagerPage.PackageItems.Where(x => x.IsChecked).ToList();
if (batchedPackages.Any(x => x.ValidationContext.HasErrors))
{
await _messageService.ShowErrorAsync("Can't perform update. One or multiple package cannot be updated due to validation errors", "Can't update packages");
return;
}
var projects = _projectLocator.GetAllExtensibleProjects()
.Where(x => _projectLocator.IsEnabled(x)).ToList();
using (var cts = new CancellationTokenSource())
{
var updatePackageList = new List <IPackageDetails>();
foreach (var package in batchedPackages)
{
var targetProjects = new List <IExtensibleProject>();
foreach (var project in projects)
{
if (!await _projectManager.IsPackageInstalledAsync(project, package.Identity, cts.Token))
{
targetProjects.Add(project);
}
}
var targetVersion = (await package.LoadVersionsAsync() ?? package.Versions)?.FirstOrDefault();
if (targetVersion is null)
{
Log.Warning("Cannot perform upgrade because of 'Target version' is null");
return;
}
var updatePackageDetails = PackageDetailsFactory.Create(PackageOperationType.Update, package.GetMetadata(), targetVersion, null);
updatePackageList.Add(updatePackageDetails);
}
using (var operationContext = _packageOperationContextService.UseOperationContext(PackageOperationType.Update, updatePackageList.ToArray()))
{
foreach (var updatePackageDetails in updatePackageList)
{
await _packageCommandService.ExecuteUpdateAsync(updatePackageDetails, operationContext, cts.Token);
}
}
}
await Task.Delay(200);
}
catch (Exception ex)
{
Log.Error(ex, $"Error when updating package");
}
finally
{
_progressManager.HideBar(this);
_parentManagerPage.StartLoadingTimerOrInvalidateData();
}
}
