public void InstallApertureLibrariesInProject(Project project) { if (project == null) { throw new ArgumentNullException(nameof(project)); } var installedPackages = packageInstallerService .GetInstalledPackages(project); // Check if package is already installed. foreach (var package in installedPackages) { if (package.Title.Equals("ApertureLabs.Selenium", StringComparison.Ordinal)) { return; } } packageInstaller.InstallPackage( source: null, project: project, packageId: "ApertureLabs.Selenium", version: default(Version), ignoreDependencies: false); }
private void InstallNetCoreDependencies(Project proj, IVsPackageMetadata[] packs, IVsPackageInstaller installer, IVsPackageInstallerServices installerServices) { var version = VisualStudioAutomationHelper.GetTargetFrameworkVersion(proj); // RAML.Parser.Expressions if (!installerServices.IsPackageInstalled(proj, AspNetCoreStaticFilesPackageId)) { if (version.StartsWith("1")) { NugetInstallerHelper.InstallPackageIfNeeded(proj, packs, installer, AspNetCoreStaticFilesPackageId, "1.0.0", RAML.Tools.Properties.Settings.Default.NugetExternalPackagesSource); } } // RAML.Parser.Expressions if (!installerServices.IsPackageInstalled(proj, RamlParserExpressionsPackageId)) { installer.InstallPackage(NugetPackagesSource, proj, RamlParserExpressionsPackageId, RamlParserExpressionsPackageVersion, false); } // RAML.NetCoreAPIExplorer if (!installerServices.IsPackageInstalled(proj, RamlNetCoreApiExplorerPackageId)) { installer.InstallPackage(NugetPackagesSource, proj, RamlNetCoreApiExplorerPackageId, RamlNetCoreApiExplorerPackageVersion, false); } }
private void InstallWebApiDependencies(Project proj, IVsPackageMetadata[] packs, IVsPackageInstaller installer, IVsPackageInstallerServices installerServices) { NugetInstallerHelper.InstallPackageIfNeeded(proj, packs, installer, NewtonsoftJsonPackageId, NewtonsoftJsonPackageVersion, Settings.Default.NugetExternalPackagesSource); NugetInstallerHelper.InstallPackageIfNeeded(proj, packs, installer, EdgePackageId, EdgePackageVersion, Settings.Default.NugetExternalPackagesSource); NugetInstallerHelper.InstallPackageIfNeeded(proj, packs, installer, "System.ComponentModel.Annotations", "4.0.0", Settings.Default.NugetExternalPackagesSource); // RAML.Parser if (!installerServices.IsPackageInstalled(proj, "RAML.Parser.Model")) { installer.InstallPackage(NugetPackagesSource, proj, "RAML.Parser.Model", "1.0.7", false); } // AMF.Api.Core if (!installerServices.IsPackageInstalled(proj, RamlApiCorePackageId)) { //installer.InstallPackage(nugetPackagesSource, proj, ramlApiCorePackageId, ramlApiCorePackageVersion, false); installer.InstallPackage(NugetPackagesSource, proj, RamlApiCorePackageId, RamlApiCorePackageVersion, false); } // AMF.WebApiExplorer if (!installerServices.IsPackageInstalled(proj, RamlWebApiExplorerPackageId)) { installer.InstallPackage(NugetPackagesSource, proj, RamlWebApiExplorerPackageId, RamlWebApiExplorerPackageVersion, false); } }
static void Realize(IVsPackageInstaller installer) { installer.InstallPackage(default(string), default(Project), default(string), default(string), default(bool)); installer.InstallPackage(default(string), default(Project), default(string), default(Version), default(bool)); installer.InstallPackagesFromRegistryRepository(default(string), default(bool), default(bool), default(Project), default(IDictionary <string, string>)); installer.InstallPackagesFromRegistryRepository(default(string), default(bool), default(bool), default(bool), default(Project), default(IDictionary <string, string>)); installer.InstallPackagesFromVSExtensionRepository(default(string), default(bool), default(bool), default(Project), default(IDictionary <string, string>)); installer.InstallPackagesFromVSExtensionRepository(default(string), default(bool), default(bool), default(bool), default(Project), default(IDictionary <string, string>)); }
/// <summary> /// Installs the specified NuGet package and displays a message in the status bar. /// </summary> /// <param name="installer">The VS package installer.</param> /// <param name="project">The target project.</param> /// <param name="package">The NuGet package name.</param> /// <param name="version">The NuGet package version.</param> private void InstallPackage(IVsPackageInstaller installer, Project project, string package, string version) { _dte.StatusBar.Text = @"Installing " + package + "..."; if (!string.IsNullOrEmpty(version)) { installer.InstallPackage("http://packages.nuget.org", project, package, version, false); } else { installer.InstallPackage("http://packages.nuget.org", project, package, (Version)null, false); } }
private static void InstallPackageDependency( Project project, PackageDependency packageDependency, IReadOnlyCollection <IVsPackageMetadata> installedPackages, IVsPackageInstaller packageInstaller) { var packageId = packageDependency.Name; var version = packageDependency.Version; if (installedPackages.Any(c => string.Equals(c.Id, packageId, StringComparison.InvariantCultureIgnoreCase)) && (installedPackages.Any(c => c.VersionString == version.ToString(3)) || !packageDependency.ForceUpdate)) { Trace.WriteLine($"{packageDependency.Name} is already installed"); return; } Trace.WriteLine($"Installing {packageId} version {version}"); try { packageInstaller.InstallPackage( null, project, packageId, version, true); Trace.WriteLine($"Successfully installed {packageId} version {version}"); } catch (Exception e) { Trace.WriteLine($"Unable to install {packageId} version {version}"); Trace.WriteLine(e); } }
private void InstallPackages(Solution sln, IDictionary <string, IEnumerable <PackageConfigEntry> > installedPackages, ConverterUpdateViewModel model, CancellationToken token) { foreach (var project in sln.GetProjects()) { token.ThrowIfCancellationRequested(); try { IEnumerable <PackageConfigEntry> packages; if (installedPackages.TryGetValue(project.FullName, out packages)) { model.Status = $"Adding packages back via project.json: {project.Name}"; foreach (var package in packages) { try { _installer.InstallPackage(null, project, package.Id, package.Version, false); } catch (Exception e) { Trace.WriteLine(e); } } model.Count++; } } catch (NotImplementedException e) { Trace.WriteLine(e); } } }
private void InstallReferences(IVsPackageInstaller installerServices, List <MissingReference> missingReferences) { if (missingReferences.Count > 0) { var packages = string.Join(", ", missingReferences.Select(r => r.Reference.Package)); var msg = string.Format("This template requires these references. Do you want to add them using nuget?\n\n{0}", packages); if (!Quiet) { var result = MessageBox.Show(Helpers.MainWindow, msg, "Missing packages", MessageBoxButtons.OKCancel, MessageBoxType.Information, MessageBoxDefaultButton.OK); if (result == DialogResult.Cancel) { throw new WizardCancelledException(); } } foreach (var missingRef in missingReferences) { SetStatusMessage(string.Format("Adding {0}.{1} to project...", missingRef.Reference.Package, missingRef.Reference.Version)); var reference = missingRef.Reference; if (!string.IsNullOrEmpty(reference.ExtensionId)) { installerServices.InstallPackagesFromVSExtensionRepository(reference.ExtensionId, false, false, false, missingRef.Project, new Dictionary <string, string> { { reference.Package, reference.Version } }); } else { installerServices.InstallPackage("https://packages.nuget.org", missingRef.Project, reference.Package, reference.Version, false); } } } }
private void OnInstallNugetPackageCommandInvoked(object sender, EventArgs e) { ThreadHelper.ThrowIfNotOnUIThread(); if (vs != null && vs.TryGetSelectedProject(out EnvDTE.Project project)) { IComponentModel componentModel = (IComponentModel)GetGlobalService(typeof(SComponentModel)); IVsPackageInstallerServices nuget = componentModel.GetService <IVsPackageInstallerServices>(); IVsPackageInstaller installer = componentModel.GetService <IVsPackageInstaller>(); EnvDTE.StatusBar status = vs.StatusBar; if (!nuget.IsPackageInstalled(project, nameof(Sassin))) { try { status.Text = $"{Metadata.ProductName} installing {nameof(Sassin)}..."; status.Animate(true, EnvDTE.vsStatusAnimation.vsStatusAnimationBuild); installer.InstallPackage(null, project, nameof(Sassin), Convert.ToString(null), false); } catch { status.Text = $"{Metadata.ProductName} failed to install {nameof(Sassin)}."; } finally { status.Animate(false, EnvDTE.vsStatusAnimation.vsStatusAnimationBuild); } } } }
private void OnConfigureCompileOnBuildCommandInvoked(object sender, EventArgs e) { ThreadHelper.ThrowIfNotOnUIThread(); if (vs != null && vs.TryGetSelectedProject(out EnvDTE.Project project)) { IComponentModel componentModel = (IComponentModel)GetGlobalService(typeof(SComponentModel)); IVsPackageInstallerServices nuget = componentModel.GetService <IVsPackageInstallerServices>(); IVsPackageInstaller installer = componentModel.GetService <IVsPackageInstaller>(); EnvDTE.StatusBar status = vs.StatusBar; if (!nuget.IsPackageInstalled(project, nameof(TSBuild))) { try { status.Text = $"{Symbol.Name}: installing {nameof(TSBuild)} package..."; status.Animate(true, EnvDTE.vsStatusAnimation.vsStatusAnimationBuild); installer.InstallPackage(null, project, nameof(TSBuild), Symbol.Version, false); } catch { status.Text = $"{Symbol.Name}: failed to install {nameof(TSBuild)}."; } finally { status.Animate(false, EnvDTE.vsStatusAnimation.vsStatusAnimationBuild); } } } }
private bool DoInstallAssemblyAsNuGetPackage(IEnumerable <FileSystemPath> assemblyLocations, Project vsProject, out string installedLocation) { installedLocation = string.Empty; var metadata = GetPackageFromAssemblyLocations(assemblyLocations); if (metadata == null) { // Not a NuGet package, we didn't handle this return(false); } // We need to get the repository path from the installed package. Sadly, this means knowing that // the package is installed one directory below the repository. Just a small crack in the black box. // (We can pass "All" as the package source, rather than the repository path, but that would give // us an aggregate of the current package sources, rather than using the local repo as a source) var installPath = Path.GetFullPath(metadata.InstallPath); var repositoryPath = Path.GetDirectoryName(installPath); vsPackageInstaller.InstallPackage(repositoryPath, vsProject, metadata.Id, (Version)null, false); installedLocation = installPath; // Successfully installed, we handled it return(true); }
/// <summary> /// This function is the callback used to execute the command when the menu item is clicked. /// See the constructor to see how the menu item is associated with this function using /// OleMenuCommandService service and MenuCommand class. /// </summary> /// <param name="sender">Event sender.</param> /// <param name="e">Event args.</param> private void MenuItemCallback(object sender, EventArgs e) { ThreadHelper.ThrowIfNotOnUIThread(); var question = MessageBox.Show("Selecting this command will install a NuGet package that will enable this project for script generation. " + "\r\rDo you want to continue?", "Install NuGet Package?", MessageBoxButtons.YesNo, MessageBoxIcon.Question); if (question == DialogResult.No) { return; } foreach (Project proj in VsHelper.GetSelectedCsharpProjects()) { if (!VsHelper.IsPackageInstalled(proj)) { try { IComponentModel componentModel = (IComponentModel)Package.GetGlobalService(typeof(SComponentModel)); IVsPackageInstaller installer = componentModel.GetService <IVsPackageInstaller>(); installer.InstallPackage(null, proj, TypeRightPackage.NugetID, (string)null, false); } catch (Exception exception) { // Show a message box to prove we were here VsShellUtilities.ShowMessageBox( this.ServiceProvider, "There was an error installing the package: \n\n" + exception.Message, "Could not install package", OLEMSGICON.OLEMSGICON_CRITICAL, OLEMSGBUTTON.OLEMSGBUTTON_OK, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST); } } } }
private void InstallNetCoreDependencies(Project proj, IVsPackageMetadata[] packs, IVsPackageInstaller installer, IVsPackageInstallerServices installerServices) { NugetInstallerHelper.InstallPackageIfNeeded(proj, packs, installer, "Microsoft.AspNetCore.StaticFiles", "1.0.0", Settings.Default.NugetExternalPackagesSource); // RAML.Parser.Expressions if (!installerServices.IsPackageInstalled(proj, RamlParserExpressionsPackageId)) { installer.InstallPackage(NugetPackagesSource, proj, RamlParserExpressionsPackageId, RamlParserExpressionsPackageVersion, false); } // AMF.NetCoreApiExplorer if (!installerServices.IsPackageInstalled(proj, RamlNetCoreApiExplorerPackageId)) { installer.InstallPackage(NugetPackagesSource, proj, RamlNetCoreApiExplorerPackageId, RamlNetCoreApiExplorerPackageVersion, false); } }
private static void InstallNugetPackageForSpecifiedVersion(IProject project, IVsPackageInstaller vsPackageInstaller, string packageName, string version) { vsPackageInstaller.InstallPackage("All", project.As <EnvDTE.Project>(), packageName, version, false); }
private void InstallPackages(IEnumerable <Project> projects, IDictionary <string, IEnumerable <PackageConfigEntry> > installedPackages, ConverterUpdateViewModel model, CancellationToken token) { var actualProjects = projects.Where(p => p.GetFullName() != null).ToList(); _logger.WriteLine($"Projects: {actualProjects.Count} Retrived packages: {installedPackages.Count}"); int countProjects = 0; foreach (var project in actualProjects) { countProjects++; token.ThrowIfCancellationRequested(); var exist = installedPackages.TryGetValue(project.GetFullName(), out var packages); var packagecount = exist ? packages.Count() : 0; _logger.WriteLine($"({countProjects}/{actualProjects.Count}) Project {project.Name}/{project.GetFullName()}, packages to install: {packagecount} "); if (packagecount == 0) { continue; } try { model.Status = $"({countProjects}/{actualProjects.Count}) Adding PackageReferences: {project.Name}"; int counter = 0; int countPackages = packages.Count(); foreach (var package in packages) { try { _installer.InstallPackage(null, project, package.Id, package.Version, false); counter++; model.Log = $"({counter}/{countPackages}) Added package {package.Id}"; _logger.WriteLine(model.Log); } catch (Exception e) { model.Log = $"Exception installing {package.Id} ({e})"; _logger.WriteLine(model.Log); } } model.Status = $"Added PackageReferences to {project.Name}/{project.FullName}, {counter} out of {packages.Count()} included"; _logger.WriteLine(model.Status); model.Count++; System.Threading.Thread.Sleep(1000); } catch (NotImplementedException e) { Trace.WriteLine(e); } } }
private static void InstallNugetPackageForSpecifiedVersion(IProject project, IVsPackageInstaller vsPackageInstaller, string packageId, string version) { vsPackageInstaller.InstallPackage( ServiceMatrixOverrides.GetNugetFeedServiceBaseAddress() ?? "All", project.As <EnvDTE.Project>(), packageId, version, false); }
/// <summary> /// Installs the specified NuGet package and displays a message in the status bar. /// </summary> /// <param name="installer">The VS package installer.</param> /// <param name="project">The target project.</param> /// <param name="package">The NuGet package name.</param> /// <param name="version">The NuGet package version.</param> private void InstallPackage(IVsPackageInstaller installer, Project project, string package, string version) { try { _dte.StatusBar.Text = @"Installing " + package + "..."; if (!string.IsNullOrEmpty(version)) { installer.InstallPackage("http://packages.nuget.org", project, package, version, false); } else { installer.InstallPackage("http://packages.nuget.org", project, package, (Version)null, false); } } catch (Exception ex) { MessageBox.Show("Error Processing Template: Error Installing NuGet Package: " + ex.Message); } }
public bool AddPackage(string packageId, string version = null, string source = null) { if (m_packageServices.IsPackageInstalled(m_project, packageId)) { return(false); } m_installer.InstallPackage(source ?? "All", m_project, packageId, version, false); return(true); }
private void InstallPackageEmptyVersionTest(object sender, EventArgs e) { EnvDTE.DTE dte = ServiceLocator.GetInstance <EnvDTE.DTE>(); IVsPackageInstaller services = ServiceLocator.GetInstance <IVsPackageInstaller>(); foreach (EnvDTE.Project project in dte.Solution.Projects) { _task = System.Threading.Tasks.Task.Run(() => services.InstallPackage("https://api.nuget.org/v2/", project, "newtonsoft.json", "", false)); return; } }
private void InstallBadSourceTest(object sender, EventArgs e) { EnvDTE.DTE dte = ServiceLocator.GetInstance <EnvDTE.DTE>(); IVsPackageInstaller services = ServiceLocator.GetInstance <IVsPackageInstaller>(); foreach (EnvDTE.Project project in dte.Solution.Projects) { _task = System.Threading.Tasks.Task.Run(() => services.InstallPackage("http://packagesource", project, "newtonsoft.json", "6.0.4", false)); return; } }
public static void InstallPackageApi(string source, string id, string version, bool prerelease) { var dte = ServiceLocator.GetInstance <EnvDTE.DTE>(); IVsPackageInstaller services = ServiceLocator.GetInstance <IVsPackageInstaller>(); foreach (EnvDTE.Project project in dte.Solution.Projects) { services.InstallPackage(source, project, id, version, prerelease); return; } }
public static void InstallPackageApiBadSource(string id, string version) { EnvDTE.DTE dte = ServiceLocator.GetInstance <EnvDTE.DTE>(); IVsPackageInstaller services = ServiceLocator.GetInstance <IVsPackageInstaller>(); foreach (EnvDTE.Project project in dte.Solution.Projects) { services.InstallPackage("http://packagesource", project, id, version, false); return; } }
private static void InstallLatestNugetPackage(IProject project, IVsPackageInstallerServices vsPackageInstallerServices, IVsPackageInstaller vsPackageInstaller, string packageName) { vsPackageInstaller.InstallPackage("All", project.As <EnvDTE.Project>(), packageName, (Version)null, false); // Call the installed packages to get the version that was just installed and cache the version. var installedPackages = vsPackageInstallerServices.GetInstalledPackages(); NugetPackageVersionManager.UpdateCache(packageName, installedPackages); }
public static void InstallPackageIfNeeded(Project proj, IEnumerable<IVsPackageMetadata> packs, IVsPackageInstaller installer, string packageId, string packageVersion, string nugetPackagesSource = null) { var packageMetadata = packs.FirstOrDefault(p => p.Id == packageId); if (packageMetadata == null || !IsSameOrNewerVersion(packageMetadata.VersionString, packageVersion)) { if (nugetPackagesSource == null) nugetPackagesSource = Settings.Default.NugetPackagesSource; installer.InstallPackage(nugetPackagesSource, proj, packageId, packageVersion, false); } }
public static bool TryInstallPackage(IServiceProvider serviceProvider, ILogger logger, Project project, string packageId, string version = null) { if (serviceProvider == null) { throw new ArgumentNullException(nameof(serviceProvider)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } if (project == null) { throw new ArgumentNullException(nameof(project)); } if (string.IsNullOrWhiteSpace(packageId)) { throw new ArgumentNullException(nameof(packageId)); } IVsPackageInstaller installer = LoadService(serviceProvider); if (installer == null) { return(false); } try { // The installer will no-op in case the package is installed installer.InstallPackage(source: null, project: project, packageId: packageId, version: version, ignoreDependencies: false); return(true); } catch (Exception ex) { if (ErrorHandler.IsCriticalException(ex)) { throw; } var message = string.Format(Strings.FailedDuringNuGetPackageInstall, packageId, project.Name, ex.Message); logger.WriteLine(Strings.SubTextPaddingFormat, message); return(false); } }
/// <inheritdoc/> public override void Execute(Project project) { var componentModel = (IComponentModel)this.Package.GetService(typeof(SComponentModel)); IVsPackageInstaller packageInstaller = componentModel.GetService <IVsPackageInstaller>(); packageInstaller.InstallPackage( null, project, SlowCheetahNuGetManager.PackageName, version: (string)null, // install latest stable version ignoreDependencies: false); this.Successor.Execute(project); }
private void PerformPackageInstall( IVsPackageInstaller packageInstaller, Project project, VsTemplateWizardInstallerConfiguration configuration) { string repositoryPath = configuration.RepositoryPath; var failedPackageErrors = new List <string>(); IPackageRepository repository = configuration.IsPreunzipped ? (IPackageRepository) new UnzippedPackageRepository(repositoryPath) : (IPackageRepository) new LocalPackageRepository(repositoryPath); foreach (var package in configuration.Packages) { // Does the project already have this package installed? if (_packageServices.IsPackageInstalled(project, package.Id)) { // If so, is it the right version? if (!_packageServices.IsPackageInstalled(project, package.Id, package.Version)) { // No? OK, write a message to the Output window and ignore this package. ShowWarningMessage(String.Format(VsResources.TemplateWizard_VersionConflict, package.Id, package.Version)); } // Yes? Just silently ignore this package! } else { try { _dte.StatusBar.Text = String.Format(CultureInfo.CurrentCulture, VsResources.TemplateWizard_PackageInstallStatus, package.Id, package.Version); packageInstaller.InstallPackage(repository, project, package.Id, package.Version.ToString(), ignoreDependencies: true, skipAssemblyReferences: package.SkipAssemblyReferences); } catch (InvalidOperationException exception) { failedPackageErrors.Add(package.Id + "." + package.Version + " : " + exception.Message); } } } if (failedPackageErrors.Any()) { var errorString = new StringBuilder(); errorString.AppendFormat(VsResources.TemplateWizard_FailedToInstallPackage, repositoryPath); errorString.AppendLine(); errorString.AppendLine(); errorString.Append(String.Join(Environment.NewLine, failedPackageErrors)); ShowErrorMessage(errorString.ToString()); } }
public static void InstallPackage(this IVsPackageInstaller packageInstaller, Project project, string packageName, IVsPackageInstallerServices packageInstallerServices, string version = null) { if (version == null) { version = new V2FeedContext(new Uri("http://www.nuget.org/api/v2/")).Execute <V2FeedPackage>(new Uri("http://www.nuget.org/api/v2/Packages?$filter=IsAbsoluteLatestVersion and Id eq '" + packageName + "'&$skip=0&$top=1&$select=Id,Version&targetFramework=&includePrerelease=true")).Single().Version; } packageInstaller.InstallPackage("http://packages.nuget.org", project, packageName, version, false); //workaround to the bug on Package installer that does not install package depencences var dependencies = new LocalPackageRepository(packageInstallerServices.GetPackageLocation(packageName)).FindPackage(packageName).DependencySets.SelectMany(ds => ds.Dependencies); foreach (var dependency in dependencies) { InstallPackage(packageInstaller, project, dependency.Id, packageInstallerServices, dependency.VersionSpec.ToString()); } }
public static void InstallPackageIfNeeded(Project proj, IEnumerable <IVsPackageMetadata> packs, IVsPackageInstaller installer, string packageId, string packageVersion, string nugetPackagesSource = null) { var packageMetadata = packs.FirstOrDefault(p => p.Id == packageId); if (packageMetadata == null || !IsSameOrNewerVersion(packageMetadata.VersionString, packageVersion)) { if (nugetPackagesSource == null) { nugetPackagesSource = RAML.Tools.Properties.Settings.Default.NugetPackagesSource; } installer.InstallPackage(nugetPackagesSource, proj, packageId, packageVersion, false); } }
private void UninstallPackageNoForce(object sender, EventArgs e) { EnvDTE.DTE dte = ServiceLocator.GetInstance <EnvDTE.DTE>(); IVsPackageInstaller services = ServiceLocator.GetInstance <IVsPackageInstaller>(); IVsPackageUninstaller uninstaller = ServiceLocator.GetInstance <IVsPackageUninstaller>(); foreach (EnvDTE.Project project in dte.Solution.Projects) { _task = System.Threading.Tasks.Task.Run(() => { services.InstallPackage("https://api.nuget.org/v2/", project, "windowsazure.storage", "4.3.0", false); uninstaller.UninstallPackage(project, "newtonsoft.json", true); }); return; } }
private static void InstallPackageDependency( Project project, PackageDependency packageDependency, IReadOnlyCollection <IVsPackageMetadata> installedPackages, IVsPackageInstaller packageInstaller) { var packageId = packageDependency.Name; var version = packageDependency.Version; if (installedPackages.Any(c => string.Equals(c.Id, packageId, StringComparison.InvariantCultureIgnoreCase)) && (installedPackages.Any(c => c.VersionString == version) || !packageDependency.ForceUpdate)) { Trace.WriteLine($"{packageDependency.Name} is already installed"); return; } ThreadHelper.ThrowIfNotOnUIThread(); if (packageDependency.IsSystemLibrary) { Trace.WriteLine("Package is a system library"); if (!project.IsNetStandardLibrary()) { Trace.WriteLine("Skipping package installation"); return; } } Trace.WriteLine($"Installing {packageId} version {version}"); try { packageInstaller.InstallPackage( null, project, packageId, version, true); Trace.WriteLine($"Successfully installed {packageId} version {version}"); } catch (Exception e) { Logger.Instance.TrackError(e); Trace.WriteLine($"Unable to install {packageId} version {version}"); Trace.WriteLine(e); } }
private void PerformPackageInstall(IVsPackageInstaller packageInstaller, Project project, string packageRepositoryPath, IEnumerable<VsTemplateWizardPackageInfo> packages) { var failedPackages = new List<VsTemplateWizardPackageInfo>(); foreach (var package in packages) { try { DTE.StatusBar.Text = String.Format(CultureInfo.CurrentCulture, VsResources.TemplateWizard_PackageInstallStatus, package.Id, package.Version); // TODO review parameters and installer call // REVIEW is it OK to ignoreDependencies? The expectation is that the vstemplate will list all the required packages // REVIEW We need to figure out if we can break IVsPackageInstaller interface by modifying it to accept a SemVer and still allow MVC 3 projects to work packageInstaller.InstallPackage(packageRepositoryPath, project, package.Id, package.Version, ignoreDependencies: true); } catch (InvalidOperationException) { failedPackages.Add(package); } } if (failedPackages.Any()) { var errorString = new StringBuilder(); errorString.AppendFormat(VsResources.TemplateWizard_FailedToInstallPackage, packageRepositoryPath); errorString.AppendLine(); errorString.AppendLine(); errorString.Append(String.Join(Environment.NewLine, failedPackages.Select(p => p.Id + "." + p.Version))); ShowErrorMessage(errorString.ToString()); } }
/// <summary> /// Installs the specified NuGet package and displays a message in the status bar. /// </summary> /// <param name="installer">The VS package installer.</param> /// <param name="project">The target project.</param> /// <param name="package">The NuGet package name.</param> /// <param name="version">The NuGet package version.</param> private void InstallPackage(IVsPackageInstaller installer, Project project, string package, string version) { try { _dte.StatusBar.Text = @"Installing " + package + "..."; if (!string.IsNullOrEmpty(version)) installer.InstallPackage("http://packages.nuget.org", project, package, version, false); else installer.InstallPackage("http://packages.nuget.org", project, package, (Version)null, false); } catch (Exception ex) { MessageBox.Show("Error Processing Template: Error Installing NuGet Package: " + ex.Message); } }
private static void InstallNugetPackageForSpecifiedVersion(IProject project, IVsPackageInstaller vsPackageInstaller, string packageId, string version) { vsPackageInstaller.InstallPackage( ServiceMatrixOverrides.GetNugetFeedServiceBaseAddress() ?? "All", project.As<EnvDTE.Project>(), packageId, version, false); }
private static void InstallLatestNugetPackage(IProject project,IVsPackageInstallerServices vsPackageInstallerServices, IVsPackageInstaller vsPackageInstaller, string packageName) { vsPackageInstaller.InstallPackage("All", project.As<EnvDTE.Project>(), packageName, (Version)null, false); // Call the installed packages to get the version that was just installed and cache the version. var installedPackages = vsPackageInstallerServices.GetInstalledPackages(); NugetPackageVersionManager.UpdateCache(packageName, installedPackages); }
/// <summary> /// Installs one or more packages into the specified project. /// </summary> /// <param name="packageInstaller">The package installer service that performs the actual package installation.</param> /// <param name="project">The target project for installation.</param> /// <param name="configuration">The packages to install, where to install them from, and additional options for their installation.</param> /// <param name="repositorySettings">The repository settings for the packages being installed.</param> /// <param name="warningHandler">An action that accepts a warning message and presents it to the user, allowing execution to continue.</param> /// <param name="errorHandler">An action that accepts an error message and presents it to the user, allowing execution to continue.</param> internal void PerformPackageInstall( IVsPackageInstaller packageInstaller, Project project, PreinstalledPackageConfiguration configuration, Lazy<IRepositorySettings> repositorySettings, Action<string> warningHandler, Action<string> errorHandler) { string repositoryPath = configuration.RepositoryPath; var failedPackageErrors = new List<string>(); IPackageRepository repository = configuration.IsPreunzipped ? (IPackageRepository)new UnzippedPackageRepository(repositoryPath) : (IPackageRepository)new LocalPackageRepository(repositoryPath); foreach (var package in configuration.Packages) { // Does the project already have this package installed? if (_packageServices.IsPackageInstalled(project, package.Id)) { // If so, is it the right version? if (!_packageServices.IsPackageInstalled(project, package.Id, package.Version)) { // No? Raise a warning (likely written to the Output window) and ignore this package. warningHandler(String.Format(VsResources.PreinstalledPackages_VersionConflict, package.Id, package.Version)); } // Yes? Just silently ignore this package! } else { try { if (InfoHandler != null) { InfoHandler(String.Format(CultureInfo.CurrentCulture, VsResources.PreinstalledPackages_PackageInstallStatus, package.Id, package.Version)); } packageInstaller.InstallPackage(repository, project, package.Id, package.Version.ToString(), ignoreDependencies: true, skipAssemblyReferences: package.SkipAssemblyReferences); } catch (InvalidOperationException exception) { failedPackageErrors.Add(package.Id + "." + package.Version + " : " + exception.Message); } } } if (failedPackageErrors.Any()) { var errorString = new StringBuilder(); errorString.AppendFormat(VsResources.PreinstalledPackages_FailedToInstallPackage, repositoryPath); errorString.AppendLine(); errorString.AppendLine(); errorString.Append(String.Join(Environment.NewLine, failedPackageErrors)); errorHandler(errorString.ToString()); } // RepositorySettings = null in unit tests if (project.IsWebSite() && repositorySettings != null) { using (_vsCommonOperations.SaveSolutionExplorerNodeStates(_solutionManager)) { CreateRefreshFilesInBin( project, repositorySettings.Value.RepositoryPath, configuration.Packages.Where(p => p.SkipAssemblyReferences)); CopyNativeBinariesToBin(project, repositorySettings.Value.RepositoryPath, configuration.Packages); } } }
/// <summary> /// Installs the specified NuGet package and displays a message in the status bar. /// </summary> /// <param name="installer">The VS package installer.</param> /// <param name="project">The target project.</param> /// <param name="package">The NuGet package name.</param> /// <param name="version">The NuGet package version.</param> private void InstallPackage(IVsPackageInstaller installer, Project project, string package, string version) { _dte.StatusBar.Text = @"Installing " + package + "..."; if (!string.IsNullOrEmpty(version)) installer.InstallPackage("http://packages.nuget.org", project, package, version, false); else installer.InstallPackage("http://packages.nuget.org", project, package, (Version)null, false); }
private void InstallReferences(IVsPackageInstaller installerServices, List<MissingReference> missingReferences) { if (missingReferences.Count > 0) { var packages = string.Join(", ", missingReferences.Select(r => r.Reference.Package)); var msg = string.Format("This template requires these references. Do you want to add them using nuget?\n\n{0}", packages); if (!Quiet) { var result = MessageBox.Show(Helpers.MainWindow, msg, "Missing packages", MessageBoxButtons.YesNoCancel, MessageBoxType.Information, MessageBoxDefaultButton.Yes); if (result == DialogResult.Cancel) throw new WizardCancelledException(); if (result == DialogResult.No) return; } foreach (var missingRef in missingReferences) { SetStatusMessage(string.Format("Adding {0}.{1} to project...", missingRef.Reference.Package, missingRef.Reference.Version)); var reference = missingRef.Reference; if (!string.IsNullOrEmpty(reference.ExtensionId)) { installerServices.InstallPackagesFromVSExtensionRepository(reference.ExtensionId, false, false, false, missingRef.Project, new Dictionary<string, string> { { reference.Package, reference.Version } }); } else { // "All" specifies to use configured package sources. // http://blog.nuget.org/20120926/invoking-nuget-services-from-inside-visual-studio.html#comment-686825894 installerServices.InstallPackage("All", missingRef.Project, reference.Package, reference.Version, false); } } } }
private static void InstallLatestNugetPackage(IProject project, IVsPackageInstallerServices vsPackageInstallerServices, IVsPackageInstaller vsPackageInstaller, string packageId, int? majorVersion) { // lookup latest version for the given major (or null), and install that var latestVersion = GetLatestVersionForMajor(packageId, majorVersion); vsPackageInstaller.InstallPackage( ServiceMatrixOverrides.GetNugetFeedServiceBaseAddress() ?? "All", project.As<EnvDTE.Project>(), packageId, latestVersion, false); // Call the installed packages to get the version that was just installed and cache the version. // Packages are needed in case latestVersion is null, var installedPackages = vsPackageInstallerServices.GetInstalledPackages(); NugetPackageVersionManager.UpdateCache(packageId, majorVersion, installedPackages); }
private void PerformPackageInstall( IVsPackageInstaller packageInstaller, Project project, VsTemplateWizardInstallerConfiguration configuration) { string repositoryPath = configuration.RepositoryPath; var failedPackageErrors = new List<string>(); IPackageRepository repository = configuration.IsPreunzipped ? (IPackageRepository)new UnzippedPackageRepository(repositoryPath) : (IPackageRepository)new LocalPackageRepository(repositoryPath); foreach (var package in configuration.Packages) { // Does the project already have this package installed? if (_packageServices.IsPackageInstalled(project, package.Id)) { // If so, is it the right version? if (!_packageServices.IsPackageInstalled(project, package.Id, package.Version)) { // No? OK, write a message to the Output window and ignore this package. ShowWarningMessage(String.Format(VsResources.TemplateWizard_VersionConflict, package.Id, package.Version)); } // Yes? Just silently ignore this package! } else { try { _dte.StatusBar.Text = String.Format(CultureInfo.CurrentCulture, VsResources.TemplateWizard_PackageInstallStatus, package.Id, package.Version); packageInstaller.InstallPackage(repository, project, package.Id, package.Version.ToString(), ignoreDependencies: true, skipAssemblyReferences: package.SkipAssemblyReferences); } catch (InvalidOperationException exception) { failedPackageErrors.Add(package.Id + "." + package.Version + " : " + exception.Message); } } } if (failedPackageErrors.Any()) { var errorString = new StringBuilder(); errorString.AppendFormat(VsResources.TemplateWizard_FailedToInstallPackage, repositoryPath); errorString.AppendLine(); errorString.AppendLine(); errorString.Append(String.Join(Environment.NewLine, failedPackageErrors)); ShowErrorMessage(errorString.ToString()); } }
private static void InstallNugetPackageForSpecifiedVersion(IProject project, IVsPackageInstaller vsPackageInstaller, string packageName, string version) { vsPackageInstaller.InstallPackage("All", project.As<EnvDTE.Project>(), packageName, version, false); }
static void Realize(IVsPackageInstaller installer) { installer.InstallPackage(default(string), default(Project), default(string), default(string), default(bool)); installer.InstallPackage(default(string), default(Project), default(string), default(Version), default(bool)); installer.InstallPackagesFromRegistryRepository(default(string), default(bool), default(bool), default(Project), default(IDictionary<string, string>)); installer.InstallPackagesFromRegistryRepository(default(string), default(bool), default(bool), default(bool), default(Project), default(IDictionary<string, string>)); installer.InstallPackagesFromVSExtensionRepository(default(string), default(bool), default(bool), default(Project), default(IDictionary<string, string>)); installer.InstallPackagesFromVSExtensionRepository(default(string), default(bool), default(bool), default(bool), default(Project), default(IDictionary<string, string>)); }
private void InstallReferences(IVsPackageInstaller installerServices, List<MissingReference> missingReferences) { if (missingReferences.Count > 0) { var packages = string.Join(", ", missingReferences.Select(r => r.Reference.Package)); var msg = string.Format("This template requires these references. Do you want to add them using nuget?\n\n{0}", packages); if (!Quiet) { var result = MessageBox.Show(Helpers.MainWindow, msg, "Missing packages", MessageBoxButtons.OKCancel, MessageBoxType.Information, MessageBoxDefaultButton.OK); if (result == DialogResult.Cancel) throw new WizardCancelledException(); } foreach (var missingRef in missingReferences) { SetStatusMessage(string.Format("Adding {0}.{1} to project...", missingRef.Reference.Package, missingRef.Reference.Version)); var reference = missingRef.Reference; if (!string.IsNullOrEmpty(reference.ExtensionId)) { installerServices.InstallPackagesFromVSExtensionRepository(reference.ExtensionId, false, false, false, missingRef.Project, new Dictionary<string, string> { { reference.Package, reference.Version } }); } else { installerServices.InstallPackage("https://packages.nuget.org", missingRef.Project, reference.Package, reference.Version, false); } } } }