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