public void InstallPackagesFromVSExtensionRepository(string extensionId, bool isPreUnzipped, bool skipAssemblyReferences, bool ignoreDependencies, Project project, IDictionary <string, string> packageVersions)
{
if (String.IsNullOrEmpty(extensionId))
{
throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "extensionId");
}
if (project == null)
{
throw new ArgumentNullException("project");
}
if (!packageVersions.Any())
{
throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "packageVersions");
}
PreinstalledRepositoryProvider repoProvider = new PreinstalledRepositoryProvider(ErrorHandler, _sourceRepositoryProvider);
repoProvider.AddFromExtension(_sourceRepositoryProvider, extensionId);
List <PackageIdentity> toInstall = GetIdentitiesFromDict(packageVersions);
// Skip assembly references and disable binding redirections should be done together
bool disableBindingRedirects = skipAssemblyReferences;
VSAPIProjectContext projectContext = new VSAPIProjectContext(skipAssemblyReferences, disableBindingRedirects);
PackageManagementHelpers.RunSync(async() => await InstallInternal(project, toInstall, repoProvider, projectContext, ignoreDependencies, CancellationToken.None));
}
public void RestorePackages(Project project)
{
NuGetPackageManager packageManager = new NuGetPackageManager(_sourceRepositoryProvider, _settings, _solutionManager);
try
{
PackageManagementHelpers.RunSync(async() => await _restoreManager.RestoreMissingPackagesInSolutionAsync(CancellationToken.None));
}
catch (Exception ex)
{
ExceptionHelper.WriteToActivityLog(ex);
}
}
private void InstallPackage(string source, Project project, string packageId, NuGetVersion version, bool ignoreDependencies)
{
IEnumerable <string> sources = null;
if (!String.IsNullOrEmpty(source))
{
sources = new string[] { source };
}
VersionRange versionRange = VersionRange.All;
if (version != null)
{
versionRange = new VersionRange(version, true, version, true);
}
List <PackageIdentity> toInstall = new List <PackageIdentity>();
toInstall.Add(new PackageIdentity(packageId, version));
VSAPIProjectContext projectContext = new VSAPIProjectContext();
PackageManagementHelpers.RunSync(async() => await InstallInternal(project, toInstall, GetSources(sources), projectContext, ignoreDependencies, CancellationToken.None));
}
public void UninstallPackage(Project project, string packageId, bool removeDependencies)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
if (String.IsNullOrEmpty(packageId))
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "packageId"));
}
NuGetPackageManager packageManager = new NuGetPackageManager(_sourceRepositoryProvider, _settings, _solutionManager);
UninstallationContext uninstallContext = new UninstallationContext(removeDependencies, false);
VSAPIProjectContext projectContext = new VSAPIProjectContext();
// find the project
NuGetProject nuGetProject = PackageManagementHelpers.GetProject(_solutionManager, project, projectContext);
// uninstall the package
PackageManagementHelpers.RunSync(async() => await packageManager.UninstallPackageAsync(nuGetProject, packageId, uninstallContext, projectContext, CancellationToken.None));
}
/// <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,
Action <string> warningHandler,
Action <string> errorHandler)
{
string repositoryPath = configuration.RepositoryPath;
var failedPackageErrors = new List <string>();
LegacyNuGet.IPackageRepository repository = configuration.IsPreunzipped
? (LegacyNuGet.IPackageRepository) new LegacyNuGet.UnzippedPackageRepository(repositoryPath)
: (LegacyNuGet.IPackageRepository) new LegacyNuGet.LocalPackageRepository(repositoryPath);
PreinstalledRepositoryProvider repos = new PreinstalledRepositoryProvider(errorHandler, _sourceProvider);
repos.AddFromRepository(repository);
// store expanded node state
IDictionary <string, ISet <VsHierarchyItem> > expandedNodes = VsHierarchyHelper.GetAllExpandedNodes(_solutionManager);
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.IsPackageInstalledEx(project, package.Id, package.Version.ToNormalizedString()))
{
// 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));
}
List <PackageIdentity> toInstall = new List <PackageIdentity>();
toInstall.Add(new PackageIdentity(package.Id, package.Version));
// Skip assembly references and disable binding redirections should be done together
bool disableBindingRedirects = package.SkipAssemblyReferences;
VSAPIProjectContext projectContext = new VSAPIProjectContext(package.SkipAssemblyReferences, disableBindingRedirects);
// Old templates have hardcoded non-normalized paths
projectContext.PackageExtractionContext.UseLegacyPackageInstallPath = true;
// This runs from the UI thread
PackageManagementHelpers.RunSync(async() => await _installer.InstallInternal(project, toInstall, repos, projectContext, package.IgnoreDependencies, CancellationToken.None));
}
catch (InvalidOperationException exception)
{
failedPackageErrors.Add(package.Id + "." + package.Version + " : " + exception.Message);
}
catch (AggregateException aggregateEx)
{
var ex = aggregateEx.Flatten().InnerExceptions.FirstOrDefault();
if (ex is InvalidOperationException)
{
failedPackageErrors.Add(package.Id + "." + package.Version + " : " + ex.Message);
}
else
{
throw;
}
}
}
}
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 (EnvDTEProjectUtility.IsWebSite(project))
{
CreateRefreshFilesInBin(
project,
repositoryPath,
configuration.Packages.Where(p => p.SkipAssemblyReferences));
CopyNativeBinariesToBin(project, repositoryPath, configuration.Packages);
}
// collapse nodes
VsHierarchyHelper.CollapseAllNodes(_solutionManager, expandedNodes);
}
