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(); } }